Rookery - Outlines

[idea:tags]Tags

You can add tags to any idea. Tags work as a lateral filter across many ideas that you can use to group windows on them, group outlines, or filter ideas in a search modal.

#idea(
  "meeting-notes",
  tags: ("draft", "review"),
)[ ... ]

/* Window over all ideas with the tag "draft" */
#window(tagged: "draft")

Beneath their appearance as simple strings that can be used to organize ideas, tags are implemented as hash maps using strings as keys and abstract types as values. This means that you can use them to build up complex data structures that function as metadata for more structured ideas:

#idea(
  title: [An idea with complex metadata],
  tags: (
    "opened": datetime(year: 2026, month: 9, day: 19),
    "expected-length": duration(days: 2, hours: 1, minutes: 30),
    "details": ("a": 1, "b": 2),
  ),
)

For an example of treating tags as metadata to create more structured idea variants, see @rookery/timeline.

[idea:theme-reference]Theme reference

Key	Default	What it sets
`link-color`	`rgba(128, 0, 255, .12)`	The hover background on any rookery link, and the fallback `border-color` takes when you leave it unset.
`fold-color`	`rgba(0, 100, 255, .05)`	The hover background on a window block, unless that window sets `display-background: false`.
`name-color`	`gray`	The `[idea:etal]` name’s own text.
`date-color`	`gray`	An idea’s or a window’s date, where it is shown.
`border-color`	`link-color`	The left rule that an idea, a window and an outline all carry.
`rule-width`	`2px`	How thick that rule is. The card’s corner is arithmetic against it, so the tab the name straddles stays shut when you move it.
`pad`	`0.5em`	The padding every rookery block measures from—an idea’s box, a window’s, and the indent a nested one takes.
`label-font`	`monospace`	The face the `[idea:etal]` name is set in, and the outline’s ‘Contents’ title with it. Both are machinery rather than writing, so both leave the prose face behind.
`label-size`	`0.57rem`	The size of that name. Load-bearing beyond the label: the tab’s lift, a window’s summary and the footer’s padding are all measured against it, so the corner closes at whatever size you choose. `rem` rather than `em`, so it does not shrink again inside a window.
`tags-color`	`(:)`	One color, or a `(text:, background:)` pair, per tag—delivered as a rule on `.idea-tag-<tag>` so it reaches the pill, the outline row’s marker and a search result’s chip alike.

[idea:class-reference]HTML class reference

You can also style more granularly with your own CSS using the classes below. A trailing * below stands for a family whose members are named in the description.

Class	What it is
`.idea-box`	An idea’s own block where it was written, carrying the left rule and the padding every rookery block nested inside it measures from.
`.idea-head`, `.idea-tab`	The heading group, and the short top rule the name straddles at the card’s corner.
`.idea`, `.idea-title`	The idea’s heading element—which carries the anchor an `@idea:etal` fragment resolves to—and the title text inside it.
`.idea-label`, `.idea-date`	The `[idea:etal]` permalink and the date beside it, in a heading, a window summary or prose, wherever either is shown.
`.idea-tag`, `.idea-tag-<tag>`	A tag pill in the hat, and one extra class per tag the idea carries. The second reaches every surface that names the tag—the idea’s heading, its box, its outline row, its pill, and a search result’s chip, which JavaScript builds in the browser—so a single rule of your own styles a tag everywhere it shows up.
`.idea-ref`	An `@idea:other` reference in prose. See referencing ideas.
`.idea-window`	A transclusion, wearing the same rule and indent as `.idea-box`; the second class `.idea-window-plain` opts a bare `#idea-body` out of that box.
`.idea-window-*`	The fold: `-details` the `<details>`, `-summary` the row you click, `-title` the name in that row, `-body` what folds away under it. The date beside the title is `.idea-date`, the same class it wears in a heading.
`.idea-window-more*`	The second fold a `limit:` makes inside the body: `.idea-window-more` its `<details>`, `-more-summary` the shown blocks you click to see the rest, and `.idea-window-ellipsis` the `…` at the end of them.
`.idea-outline*`	A page’s outline: `.idea-outline` the list at each level of nesting, `-title` its “Contents” label, `-row` one row per idea.
`.idea-footnote*`	An idea’s own footnotes, carried on every surface it appears on: `.idea-footnotes` the block, `-title` its label, `.idea-footnote-list` and `.idea-footnote` its entries.
`.idea-fn-*`	`-ref` the superscript mark in prose, `-backlink` the way back up to it from the entry.
`.idea-references`, `.idea-page-refs`	The bibliography an idea’s citations draw from, and the page’s own for citations written outside any idea.
`.idea-footer*`	On an idea page: `.idea-footer` the ruled-off apparatus under the note, `-title` the label on each of its sections.
`.idea-context`, `.idea-backlinks`	That footer’s two sections: where the note was written, and the notes pointing at it.
`.idea-page-list`, `.idea-page-row`	A list of pages in either section, and one row in it—a page cannot fold, so it wears a window’s shape without being one.
`.idea-row*`	One row of an `#idea-row` list: `.idea-row` the `<li>`, `-when` its date cell, `-title` the title, `-cell` each extra cell, `-badges` the chip strip at the end. `@rookery/search` and `@rookery/timeline` draw the same row, so a rule of yours here reaches all three.
`.idea-index-count`	The “n ideas” line on the minted index page.
`.idea-dup-warning`	The build-time notice shown when two ideas claim the same name.

Every one of those elements also carries a data-rookery attribute naming the same thing without the prefix—.idea-box is [data-rookery="box"], .idea-window-summary is [data-rookery="window-summary"]—and it is the attribute, not the class, that rookery’s own stylesheet selects on. The two say the same thing, so write whichever reads better in your CSS; the attribute is there because css-prefix moves the classes and nothing should have to follow them to find an element. .idea-window-plain is the one that does not repeat itself: a plain window is [data-rookery="window"] wearing data-rookery-plain besides.

Anything that names a tag—a card, a window, a pill, an outline row, an index row, a badge—carries one more, data-rookery-tags, listing those tag names, minus any made invisible by invisible-tags.

[idea:outline-reference]#outline

A contents list over the ideas in your rookery, derived from how you nest them. See outlining ideas for what it lists and what it leaves out.

Typst’s own idiom for an outline over something other than headings is a target: argument, so rookery overloads that call rather than asking you to remember a second name:

#import "@rookery/core:0.1.0": idea, outline
#outline(target: idea, scope: "page", depth: 2)   // the ideas on this page
#outline()                                        // Typst's own, over headings

target: idea takes the arguments below; every other target proxies straight through to Typst’s #outline, unchanged. Passing tagged, match, filter or scope without target: idea is refused by name, rather than forwarded into Typst’s outline to be rejected there with a message about an argument you did not think you were writing.

Argument	Type	Description
`title`	content \| auto \| none	The label above the list. auto prints ‘Contents’, matching Typst’s own `#outline`; none omits it; any other content replaces it. Rendered as a real heading that neither self-lists in a later outline nor takes the document’s heading numbering.
`depth`	int \| none	How many levels of nesting to show, counted as Typst counts heading levels: a top-level idea is `1`. Levels of containment, not of pages.
`scope`	str	How wide to cast: `"rookery"`, the default, lists every idea in the rookery as one tree in spine order; `"page"` narrows to the ideas written on this page. The whole spine compiles as one document, so the wider reading costs nothing extra.
`tagged`	str \| array \| dictionary \| none	The tags to restrict the outline to.
`match`	str	Whether a listed idea has to carry `"any"` of those tags — the default — or `"all"` of them.
`filter`	function \| none	A predicate over the idea’s tag dictionary, ANDed with the two above. The same trio `#window` and `#ideas` take.

Filtering happens before depth is applied, and that order is the point: depth: 1 means the top level of what you asked for, not whatever survived from the top level of everything. An idea whose parent was filtered out is promoted to its nearest surviving ancestor’s level rather than left dangling.

Rows are not grouped under per-page headings. An idea’s name is flat and travels between files precisely so a reader never has to know which file holds it; an index that led with filenames would put that back.

The same function is exported as #ideas-outline as well, taking the same six arguments with no target: to write:

#import "@rookery/core:0.1.0": ideas-outline
#ideas-outline(scope: "page", depth: 2)

Prefer #outline. Reach for #ideas-outline where you would rather not shadow Typst’s own #outline at all — a project that imports this package with *, or one with show outline: rules of its own to keep clear of. Nothing is lost by the shadow itself, since every non-idea target proxies through untouched; what you are choosing is whether the name in your file is Typst’s or rookery’s.

Index