[idea:window-reference]reference2026-08-20

`#window`

A window shows an idea inside another page — its title, its permalink and its body, as one foldable block. It is pure presentation: a window registers nothing, mints no page and never re-registers the idea it transcludes, so one idea can be windowed anywhere and as often as it earns.

The ideas shown are named, or selected by tag, or both. Selection is rookery-wide, since the registry a window reads is the whole rookery’s — where the window sits makes no difference to what a tag pulls in.

Argument	Type	Description
`names`	str \| label \| array	The idea to show, or an array of them. A name is written bare (`"etal"`) or in full (`"idea:etal"`), as a string or a label, so `#window("etal")` and `#window(<etal>)` are the same call. Several are passed as one array — `#window(("a", "b"))` — and may be omitted entirely when `tags` does the selecting.
`tagged`	str \| array \| dictionary	The tags whose ideas to show, instead of naming them or alongside it. A window shows the union of the two, and an idea that is both named and tagged appears once, where it was named.
`match`	str	Whether a tagged idea has to carry `"any"` of the tags — the default — or `"all"` of them.
`filter`	function \| none	A predicate of your own over the idea’s tag dictionary, ANDed with `tagged` and `match` rather than replacing them. It is what expresses a selection those two cannot: an exclusion, or an OR of ANDs. The same argument `#ideas` and `#outline` take. On `#window`, the ideas it selects also register no backlinks, for the reason given below.
`sort`	str \| auto	The order the ideas are shown in. auto, the default, keeps the named ideas in the order they were written and appends the tag matches by name; `"date"` and `"lexicographic"` order the whole selection instead.
`unfurl`	int \| auto	How far transclusion nests. `0` renders the idea as a link to its own page and transcludes nothing, `1` renders it and collapses any window written inside it to a bare permalink, and `n` unfurls `n - 1` levels of those. Defaults to the rookery-wide `#rookery(window-unfurl: ..)`, itself `1`. Windows are all that count: an idea written inside a transcluded body is rebuilt in full whatever the budget.
`limit`	int \| none	How many blocks of the body to show — a block being a paragraph or a list, the unit that can be cut without leaving half a sentence. The whole body by default; in HTML and EPUB every footnote in the note is listed regardless, since the tail sits collapsed rather than dropped, and one written in the shown blocks renders twice — under a paged target, where the tail is truly dropped, only the footnotes that survive the cut are listed.
`folded`	bool	Whether the window starts closed, leaving its summary alone on the page until a reader opens it.
`foldable`	bool	Whether there is a disclosure at all. `false` renders the body with nothing to click and nothing that can hide it — for a window that is the thing being read rather than a reference to it, such as a slide, where a stray click folding it shut would be a bug. It makes `folded` inert.
`reserve-title`	bool	Whether a titleless window keeps the blank line its summary reserves for the title it does not have. Dead space above a slide’s body; no effect on a window whose idea has a title.
`backlink`	bool	Whether the window counts as a link from the page it sits on to the idea it shows. True is right for a window written into an idea’s prose; `false` is for a derived view — a deck, an index, a preview — which renders an idea rather than pointing at it, and should not fill that idea’s backlinks with pages nobody wrote a link on. `true`, the default, means every idea the window shows gains a backlink from it, named or tagged alike.
`display`	dictionary	What the window shows of itself, as a dictionary of six flags — see below.

As on #idea, every display key takes a boolean and defaults to auto, the rookery-wide setting given to #rookery(display: ..).

#window(
  "etal",
  display: (
    // a titleless idea is named by the label derived from its first
    // line; false names it only where it carries an authored title
    label: true,
    // the `created` date sits at the right-hand end of the summary
    date: true,
    // the tags are worn in the summary as pills, metadata tags excepted
    tags: true,
    // the window is drawn as a card, with its left rule and indent
    frame: true,
    // the name is shown in the summary as a permalink
    name: true,
    // the window takes a tint under the cursor
    background: true,
  ),
)

Each key is also an argument in its own right, with the prefix restored — display-frame: false — and an argument on the same call wins over the dictionary’s value for that key. #idea’s three remaining keys, title, context and backlinks, describe an idea’s own minted page rather than a window onto it, and a window reads none of them.

A tag selection backlinks exactly as a named one does: every idea a tagged window matches takes a backlink, both from the page the window sits on and from the idea whose prose it is written in. The one selection that registers nothing is filter—a predicate cannot ride in the metadata the backlink walk reads, and it is ANDed with tagged rather than replacing it.

Reference

[idea:windows]Windows

Windows can be used to interpolate the entirety of an idea’s content into a different context. They are useful in home pages or other sections that aggregate content.

Fundamentally, windows are a form of augmented hyperlink. They take their name from Ted Nelson’s notion of the transpointing window as they allow you to see the content on either side of the link (like a window).

Say you have an idea:

#idea("first-idea", title: [My first idea])

You can produce a window on this idea like so:

#import "@rookery/core:0.1.0": window
#window(<first-idea>)

Note that we do not need the idea: prefix. Like #hyperlink, #window is a function imported from rookery that already knows which namespace to look in.

By default, this window will be unfolded, showing the full content of the idea.

Reference documentation for #window.

[idea:window-depth]

Unfurling windows

An idea that windows onto itself, or two ideas that window onto each other, can constitute an infinite loop that could therefore unfurl forever. In order to prevent this, rookery has a notion of window unfurl, which is set to 1 by default.

When a window is called at a level of recursion greater than the unfurl budget, rookery renders a call to #window as a link to the idea’s standalone page rather than as transcluded content. It’s best to think of window unfurl as a multiplier, as the amount of work rookery needs to do multiplies when you raise it.

You can set the unfurl budget per window, or site-wide:

#show: rookery.with(window-unfurl: 1)
#window(<first-idea>)
#window(<first-idea>, unfurl: 2)

Here is a window on this selfsame idea. Because this documentation uses the default unfurl of 1, it only recurses as a window once, and then bottoms out as a link:

Unfurling windows

[idea:idea-href-reference]#idea-href

Where an idea’s minted page sits, relative to the page you are calling from. Takes a bare name, a full name or a label — the same forms #window and #hyperlink take — and must be called inside #context.

#import "@rookery/core:0.1.0": idea, idea-href

#idea("etal", title: [Et al.])[
  Attribution flattens a crowd into one name.
]

#context idea-href("etal")
// -> "ideas/etal.html"    called from a root page
// -> "../ideas/etal.html" called from a page one directory down

The depth arithmetic is measured from the calling page, so the same idea yields a different string on a nested page than on the root one. That is the point of the function, and it is why a caller must never cache the answer across pages.

none wherever no page is minted: a plain typst compile with no Rheo, and the combined PDF target.

[idea:idea-body-reference]#idea-body

One idea’s body, rendered, with none of a window’s chrome: no summary line, no permalink, no disclosure. For a consumer that wants to show an idea rather than describe it — a preview pane, a card in a view of the caller’s own design — where #ideas’ body field only hands over plain text.

#import "@rookery/core:0.1.0": idea, idea-body

#idea("etal", title: [Et al.])[
  Attribution flattens a crowd into one name.

  The convention is older than the citation styles that inherited it.
]

// anywhere after it, on any page
#idea-body("etal")            // both paragraphs, no title, no permalink
#idea-body("etal", limit: 1)  // the first paragraph alone

Argument	Type	Description
`name`	str \| label	The idea to render, in the same name forms every accessor here takes.
`unfurl`	int \| auto	The transclusion budget, as on `#window`. Pinned at `1` rather than auto, so a preview’s size stays bounded however deeply the idea it shows nests. `0` asks for no unfurling and still renders the body — there is no chrome here to fall back to a link.
`limit`	int \| none	How many blocks of the body to show, the same unit `#window`’s own `limit` cuts by. The whole body by default.

It supplies its own #context, unlike the data accessors on this page, so it can be called anywhere. The body comes wrapped in the same classes a window’s does, minus the box, so every rule the stylesheet already writes for prose inside a window — link colors, code, lists, footnotes — applies with nothing for a consumer to restyle.