@storylet-studio/model 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1113 @@
+import { ScalarValue, Expression } from '@wildwinter/expr';
+export { AstNode, Expression, RESERVED_PROPERTY_NAMES, ScalarValue, isCaseOnlyPropertyName, isValidPropertyName, propertyNameify } from '@wildwinter/expr';
+
+/** The template's key in every `templates` bag it appears in. */
+declare const SPATIAL = "spatial";
+/** A zone's outline, in the map's own coordinate space (the same space the view
+ *  sidecar's sites use). No units: a map is to its own scale. */
+type Polygon = ViewPoint[];
+/**
+ * Where something sits in the stack: bigger is nearer the front.
+ *
+ * SPARSE, and the fallback is what makes it so: an item without one takes its
+ * position in the list, which is the order everything already drew in, so a
+ * project that has never been restacked looks exactly as it did. Only a moved
+ * item gains a number, set midway between its new neighbours - the same scheme
+ * cards, decks and hands use for authored order, and merge-clean for the same
+ * reason: two authors restacking different things touch different entries.
+ *
+ * Generic on purpose. Zones need it now; BACKGROUNDS will need the identical
+ * thing, in their own band below the zones, and this is the piece they share.
+ */
+type Stacked = {
+    id: string;
+    z?: number;
+};
+/** A stack move, in the vocabulary every drawing tool uses. */
+type StackMove = "front" | "forward" | "backward" | "back";
+/** Back to front: the order to DRAW in, so the frontmost lands on top. */
+declare function stacked<T extends Stacked>(items: T[]): T[];
+/**
+ * The `z` that puts `id` where the move asks, or undefined when it is already
+ * there (so a no-op never writes a file or costs an undo step).
+ *
+ * Moving one place uses the midpoint between the item it passes and the one
+ * beyond, which is why the numbers stay sparse and nothing has to be renumbered.
+ */
+declare function restack<T extends Stacked>(items: T[], id: string, move: StackMove): number | undefined;
+/**
+ * A background image behind a map: a picture of the real space, so a designer
+ * (and later an experience runner) can map content onto somewhere physical.
+ *
+ * NOT a player-facing asset, which is what settles most of its design. The bytes
+ * are never touched - no transcoding, no downscaling - because the file on disk
+ * is also what a runtime server will one day serve, and legibility at a glance
+ * matters more than fidelity.
+ *
+ * On the GROUP rather than on a zone, because zones cross images: a site plan is
+ * one picture with a dozen zones traced over it, and half of them straddle two
+ * sheets. Several per group, composing one picture - tiles of a large site, or
+ * deliberate overlaps - never alternates, so nothing here is exclusive with
+ * anything else.
+ */
+interface SpatialBackground {
+    /** Stable id, so two authors adding images do not collide. */
+    id: string;
+    /** The file's name inside the box's `assets/` folder. A NAME, not a path:
+     *  assets belong to their box and travel with it. */
+    file: string;
+    /** Where it sits, in map units. Placement and scale in one rectangle, because
+     *  a separate scale factor is a second thing to reason about and there is no
+     *  rotation to make it worth having. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** 0 to 1, default 1. A tracing base wants to sit back. */
+    opacity?: number;
+    /** Its place in the stack among the OTHER BACKGROUNDS (see `stacked`).
+     *  Backgrounds are a band strictly below the zones, structurally, so no value
+     *  here can put an image over a zone. */
+    z?: number;
+    /** Out of the way while working on something else. */
+    hidden?: boolean;
+    /** Locked, the diagram-tool convention: invisible to the pointer, so clicks
+     *  pass through to whatever is above. What a tracing base should be once it is
+     *  placed. */
+    locked?: boolean;
+}
+/** What the spatial template keeps on a GROUP: the marker, and the pictures
+ *  behind the map. A bag rather than a boolean precisely so this could arrive
+ *  without a schema change - the marker and the configuration are one object, so
+ *  a group is spatial exactly when it has one. */
+interface SpatialGroup {
+    /** Present and true for a spatial group. */
+    map: true;
+    backgrounds?: SpatialBackground[];
+}
+/** Is this group a map? */
+declare function isSpatial(group: TagGroup): boolean;
+/** The group's spatial configuration, or undefined when it is an ordinary group. */
+declare function spatialOf(group: TagGroup): SpatialGroup | undefined;
+/**
+ * The group's backgrounds, in DRAW order (back to front), skipping any entry
+ * that is not one.
+ *
+ * Forgiving in the same way `polygonOf` is, and for the same reason: a
+ * hand-edited or badly merged shard must not throw inside a canvas. Anything
+ * malformed reads as absent HERE and is reported by validation instead, which is
+ * a place an author can see it.
+ */
+declare function backgroundsOf(group: TagGroup): SpatialBackground[];
+/**
+ * Where a dropped picture lands: fitted inside 60% of the viewport, in BOTH axes,
+ * centred on `at`, in map units.
+ *
+ * It does NOT define the map's coordinate space and does not arrive at one pixel
+ * to one unit (a 2816px site plan would fill the county). The requirement is
+ * narrower and more useful: whatever the zoom, a picture arrives at a size
+ * comfortable to GRAB.
+ *
+ * Computed once, at drop, and stored. Never re-derived from the camera, or the
+ * picture would move about when somebody zoomed.
+ *
+ * 60% of the shorter side was the first rule and it was wrong: scale-invariant as
+ * intended, but it put a 1.83:1 plan at a third of the width of a wide window,
+ * which is fiddly to grab. Fitting both axes measures 55% x 60% of the view for
+ * that image, at every zoom.
+ */
+declare function droppedRect(natural: {
+    width: number;
+    height: number;
+}, view: {
+    width: number;
+    height: number;
+}, scale: number, at: ViewPoint): Rect;
+/** Replace the group's backgrounds, returning the new `templates` bag. Keeps the
+ *  marker and every other template's bag, as every writer here does. */
+declare function withBackgrounds(group: TagGroup, backgrounds: SpatialBackground[]): TagGroup["templates"];
+/** A zone's outline, or undefined when the tag has never been drawn. Anything
+ *  malformed reads as undefined here and is REPORTED by validation instead: a
+ *  canvas that threw on a hand-edited shard would be a poor way to find out. */
+declare function polygonOf(tag: Tag): Polygon | undefined;
+/**
+ * Mark a group spatial, or clear the marker, returning the new `templates` bag.
+ *
+ * Every one of these writers PRESERVES keys it does not own, because a shard may
+ * carry another template's bag (or a newer version of this app's) and dropping it
+ * would be data loss on a file somebody else owns.
+ */
+declare function withSpatialGroup(group: TagGroup, on: boolean): TagGroup["templates"];
+/** A zone's place in the stack, or undefined when it has never been moved. */
+declare function zOf(tag: Tag): number | undefined;
+/** Set a zone's place in the stack, returning the new `templates` bag. */
+declare function withZ(tag: Tag, z: number): Tag["templates"];
+/** Set or clear a zone's outline, returning the new `templates` bag. */
+declare function withPolygon(tag: Tag, polygon: Polygon | undefined): Tag["templates"];
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The axis-aligned box around a polygon: what a canvas needs to hit-test
+ *  cheaply, to place a selection ring, and to frame a fit. */
+declare function polygonBounds(polygon: Polygon): Rect;
+/**
+ * A polygon's centre of AREA, not the average of its vertices.
+ *
+ * The two agree only for regular shapes: on an outline with a cluster of vertices
+ * along a fiddly coastline, the vertex average is dragged towards the crowded side.
+ * Falls back to the vertex average for a degenerate (zero-area) polygon, where
+ * there is no better answer.
+ *
+ * NOT the place to put a label: see `labelPoint`. The centre of area of a concave
+ * shape can lie outside the shape, which an L-shaped zone demonstrates in one
+ * line of arithmetic.
+ */
+declare function centroid(polygon: Polygon): ViewPoint;
+/**
+ * Where a zone's LABEL goes: a point guaranteed to be inside the zone.
+ *
+ * The centre of area is the obvious answer and it is wrong for concave outlines.
+ * An L-shaped zone puts its centre of area in the notch, so a label placed there
+ * sits outside its own zone, next to whatever is drawn in the gap. Since half the
+ * zones anyone draws over a floor plan are L-shaped corridors, this needs to be
+ * right rather than usually right.
+ *
+ * So: the centre of area when that is inside, and otherwise the middle of the
+ * widest run of the zone along the horizontal line through it. That keeps the
+ * label vertically where the eye expects and moves it sideways into the shape,
+ * which for an L means "along the arm". Cheap, stable as the polygon is dragged,
+ * and no substitute for the proper pole-of-inaccessibility if a zone ever needs
+ * one.
+ */
+declare function labelPoint(polygon: Polygon, opts?: {
+    bias?: "middle" | "top";
+}): ViewPoint;
+/**
+ * Is this point inside the polygon? The ray-casting test, which handles concave
+ * outlines and self-touching ones alike.
+ *
+ * This is the function that earns the map its keep: dragging a hand's pin from
+ * the docks into the market is not a cosmetic act, it rebinds the hand, and this
+ * is how the view knows which zone the pin was dropped in.
+ */
+declare function pointInPolygon(point: ViewPoint, polygon: Polygon): boolean;
+/**
+ * Which zone a point falls in, given the zones of a spatial group in draw order.
+ *
+ * Zones may overlap (a room inside a wing, a market square inside a district), so
+ * "which one" needs an answer rather than a shrug: the FRONTMOST match wins,
+ * because that is the one drawn on top and therefore the one the author sees at
+ * that point. Front is the stack (see `stacked`), which for a project nobody has
+ * restacked is the order the zones are listed in, exactly as before. Returns
+ * undefined for a point in open space.
+ */
+declare function zoneAt(point: ViewPoint, zones: (Stacked & {
+    polygon: Polygon;
+})[]): string | undefined;
+/**
+ * EVERY zone a point falls in, frontmost first.
+ *
+ * `zoneAt` is this list's head, so the two cannot disagree about which zone wins.
+ * The tail is what an author needs telling about: zones are allowed to overlap,
+ * so a site can sit inside two outlines while belonging to exactly one of them,
+ * and a picture that shows containment the model does not have is a picture that
+ * misleads. The editor uses the length of this to say so.
+ */
+declare function zonesAt(point: ViewPoint, zones: (Stacked & {
+    polygon: Polygon;
+})[]): string[];
+
+/**
+ * What a hand's relationship to one tag group is.
+ *
+ * `tag` is the tag id it is bound to, absent when the route exists but is not
+ * filled in yet (a hole nobody has chosen for). `editable` says whether this
+ * hand can be rebound on its own: the whole point of the distinction.
+ */
+type HandBinding = 
+/** A hole the hand's template declares and this hand fills. */
+{
+    kind: "chosen";
+    tag?: string;
+    editable: true;
+}
+/** A standalone hand's own binding. */
+ | {
+    kind: "rule";
+    tag?: string;
+    editable: true;
+}
+/** The template binds it for every instance: not this hand's to change. */
+ | {
+    kind: "fixed";
+    tag: string;
+    editable: false;
+}
+/** The hand has nothing to do with this group. */
+ | {
+    kind: "none";
+    editable: false;
+};
+/**
+ * How `hand` is bound to `groupId`, given its template (undefined for a
+ * standalone hand, or when the template has gone missing).
+ *
+ * Order matters: a standalone hand answers from its own rule, and a template
+ * instance prefers the HOLE, because a template that both binds a group and
+ * declares it as a hole is malformed and the hole is the one an instance can
+ * actually fill.
+ */
+declare function handBinding<E>(hand: Hand<E>, template: HandTemplate<E> | undefined, groupId: string): HandBinding;
+/**
+ * Take `hand` OFF its binding for `groupId`, IN PLACE, and say whether anything
+ * changed.
+ *
+ * The hand is left LOOSE, which for a template instance with a hole is an error
+ * the compiler already names ("missing chosen tag ... a hand is fully concrete").
+ * That is the point of clearing rather than quietly keeping the old value: a hand
+ * whose pin has ended up outside every zone genuinely has no zone, and an error
+ * an author can see beats a link that is silently wrong.
+ */
+declare function unbindHand<E>(hand: Hand<E>, template: HandTemplate<E> | undefined, groupId: string): boolean;
+/**
+ * Bind `hand` to `tagId` for `groupId`, IN PLACE, and say whether anything
+ * changed.
+ *
+ * Refuses anything the binding says is not this hand's to change, so a caller
+ * cannot rebind one instance and silently move its siblings. The caller is
+ * expected to have asked `handBinding` first and offered the gesture only where
+ * it means something; this is the backstop rather than the manners.
+ */
+declare function bindHand<E>(hand: Hand<E>, template: HandTemplate<E> | undefined, groupId: string, tagId: string): boolean;
+
+/** The frames on a canvas, in DRAW order (back to front). */
+declare function framesOf(canvas: CanvasFurniture | undefined): Frame[];
+
+/**
+ * The comment sidecar for one box.
+ *
+ * A flat LIST rather than a map: a thread carries its own anchor, so there is
+ * no key to hang it on. Id'd so the merge engine can tell two reviewers apart.
+ */
+interface NotesShard {
+    schema: string;
+    comments?: Comment[];
+}
+/** One message in a thread. The author is a NAME, stamped at posting time, not a
+ *  reference to anything: people leave projects and their words stay. */
+interface CommentMessage {
+    author: string;
+    /** ISO 8601, stamped when posted. */
+    ts: string;
+    body: string;
+    /**
+     * A TOMBSTONE: withdrawn, but still a turn in the conversation.
+     *
+     * A reply removed outright would renumber the argument around it - the answer
+     * to a question nobody can see any more reads as a non-sequitur - so what is
+     * left records who spoke and when, and that they took it back. The body is
+     * EMPTIED when this is set: "deleted" has to mean gone from the file, or the
+     * word is a lie to somebody who typed something they regret.
+     *
+     * Absent on every message that was never withdrawn, so an ordinary thread's
+     * shard is unchanged.
+     */
+    deleted?: true;
+}
+/**
+ * Where a thread is DRAWN, when it was dropped on a canvas rather than opened
+ * from an editor (design/annotation.md 3).
+ *
+ * `canvas` names the canvas it appears on: a deck id, or `map:<boxId>` for a
+ * box's map. `x`/`y` are that canvas's own coordinates when the thread is
+ * anchored to the canvas itself, and an OFFSET from the item's origin when the
+ * thread's `anchor` names an item on that canvas. One field, two readings,
+ * distinguished by a single comparison - `anchor === canvas` - because the
+ * alternative was a second key that could disagree with the first.
+ *
+ * A thread with no `mark` is not drawn anywhere: it was opened from an editor,
+ * and it lives in that document's topline where it always did.
+ */
+interface CommentMark {
+    canvas: string;
+    x: number;
+    y: number;
+}
+/**
+ * A thread, anchored to the id of the thing it is about.
+ *
+ * `anchor` is the SUBJECT: an item id, or a canvas id for a comment about a
+ * place rather than a thing. `mark` is only about where it is drawn.
+ */
+interface Comment {
+    id: string;
+    anchor: string;
+    /** Marked complete: hidden unless the reviewer asks to see resolved threads. */
+    resolved?: boolean;
+    /** Present when this thread is a marker on a canvas. */
+    mark?: CommentMark;
+    messages: CommentMessage[];
+}
+/** Is this thread drawn as a marker, and is it following an item or sitting on
+ *  the canvas? Answers both questions at once, so no caller has to remember the
+ *  `anchor === canvas` rule. */
+declare function markOf(thread: Comment): {
+    canvas: string;
+    x: number;
+    y: number;
+    item?: string;
+} | undefined;
+/** The threads drawn on one canvas, in the order they were written. */
+declare const marksOn: (shard: NotesShard | undefined, canvas: string) => Comment[];
+/** Every thread in the shard, forgiving of a mangled one. */
+declare function commentsOf(shard: NotesShard | undefined): Comment[];
+/** The threads about one thing, oldest first (their order in the shard). */
+declare const threadsFor: (shard: NotesShard | undefined, anchor: string) => Comment[];
+/** How many UNRESOLVED threads each anchor has: what a speech-bubble shows. A
+ *  resolved thread is done, and a badge that kept counting it would never
+ *  return to zero. */
+declare function openThreadCounts(shard: NotesShard | undefined): Record<string, number>;
+
+/** A confident reading of what `src` writes, or undefined. */
+declare function inferDeclFromWrite(src: string): Pick<PropertyDecl, "type" | "default"> | undefined;
+
+type PropertyType = "boolean" | "number" | "string" | "enum" | "flags" | "quality";
+/** A property declaration: @world / @story / @box / @deck / tag / hand
+ *  state. A declared property always has a value (`default` is required);
+ *  referencing an undeclared property is a publish-time error. */
+interface PropertyDecl {
+    name: string;
+    type: PropertyType;
+    default: ScalarValue;
+    values?: string[];
+    /**
+     * A quality's ordered ladder of stage names (design/quality.md). Order IS
+     * the meaning: `>=` compares by position here, and `advance()` steps along
+     * it. The one order-semantic list in the format, accepted as such: it is a
+     * declaration, and inserting a stage mid-ladder is the design's whole point.
+     */
+    stages?: string[];
+    /**
+     * The sharing axis (design/flows.md, Patter's flag adopted): is this
+     * property's value one world value across all flows, or a copy per flow?
+     * It does NOT change reference syntax - sharing is set here, on the
+     * declaration, not by a different scope token. Absent = the scope
+     * default: `@story` shared; box, deck, hand and tag properties per-flow.
+     * On a `@world` declaration the flag is a validation error - `@world` is
+     * the game's own state, always engine-level, never per-flow.
+     */
+    shared?: boolean;
+    purpose?: string;
+}
+/** A card-template field (box-defined). Data for the host; the engine never
+ *  interprets fields and they are not addressable from expressions. */
+interface FieldDecl {
+    name: string;
+    type: PropertyType;
+    default: ScalarValue;
+    values?: string[];
+    purpose?: string;
+}
+/** Cooldown policy, in turns (schema 3.4). */
+type RedrawPolicy = "always" | "never" | number;
+/** Slugify a human label into a filename- / address-safe gameId. */
+declare function gameIdify(text: string): string;
+declare function isValidGameId(gameId: string): boolean;
+
+/** The effective address: a pinned gameId, else derived from the title, else
+ *  the immutable id (so there is always something addressable). */
+declare function effectiveGameId(entity: {
+    gameId?: string;
+    title?: string;
+    id: string;
+}): string;
+/**
+ * The first free gameId of the form `base`, `base-2`, `base-3`, ... not already
+ * in `taken`.
+ *
+ * A gameId is API - `deal()` and the play log speak it - so a name minted for a
+ * new or duplicated entity must not collide with an existing one. This lived in
+ * two copies, one in the editor and one in the CLI's kit scaffolder, character
+ * for character the same; two copies of an addressing rule can drift, and a
+ * drift here means the same act produces different addresses depending on which
+ * program did it. It is here, beside `gameIdify`, because both programs need it
+ * and no UI touches it.
+ */
+declare function freeGameId(base: string, taken: ReadonlySet<string>): string;
+/**
+ * The first free TITLE of the form `base`, `base 2`, `base 3`, ... whose
+ * derived gameId is not already in `taken`.
+ *
+ * The sibling of `freeGameId` for the "New box", "New deck" case, where the
+ * author is given a title and the address follows from it. The dedupe is on the
+ * DERIVED gameId rather than the title, because two titles that slug to one
+ * address are the collision that matters.
+ */
+/**
+ * An id-sorted collection in the order a person should SEE it.
+ *
+ * Storage is sorted by immutable id (source rule 5) so that two authors adding
+ * one item each never touch the same line. That makes array position useless as
+ * display order, so the order the author arranged rides in a sparse `order`
+ * field, with position as the fallback and id to break a tie.
+ *
+ * One definition, because this rule has to give the same answer in four places
+ * that a reader compares side by side: the compiler (what the bundle carries),
+ * the editor (what the card document lists), the exports, and Find. When they
+ * disagree, the editor shows one order and the game plays another.
+ */
+declare function byDisplayOrder<T extends {
+    id?: string;
+    order?: number;
+}>(items: readonly T[]): T[];
+declare function freeTitle(base: string, taken: ReadonlySet<string>): string;
+interface Outcome<E> {
+    id: string;
+    gameId?: string;
+    title?: string;
+    purpose?: string;
+    /** Authored display order (sparse; one without it falls back to its id
+     *  position). Unlike `Card.order` this one IS compiled into the bundle:
+     *  which option is offered first is authorial, and a host reading a dealt
+     *  card's outcomes is building the player's menu. */
+    order?: number;
+    /** Gating; availability is always evaluated against current state. */
+    condition?: E;
+    /** Target ("@scope.name") -> expression; all right-hand sides evaluate
+     *  against pre-play state (schema 3.7). */
+    changes: Record<string, E>;
+}
+interface Card<E> {
+    id: string;
+    gameId?: string;
+    title?: string;
+    purpose?: string;
+    /** Authored display order within the deck (sparse; a card without one falls
+     *  back to its id position). Merges as a per-card value, so id-sorted storage
+     *  stays merge-clean (Reboot 7.4); dropped from the compiled bundle. */
+    order?: number;
+    condition?: E;
+    /** Default 0; an expression must evaluate to a number. */
+    priority: number | E;
+    redraw: RedrawPolicy;
+    /** Tags: tag group id -> tag ids. An absent group is a wildcard (matches
+     *  any binding of it), except the reserved home group, whose default
+     *  inverts (schema 2.4). Editors and fixtures speak gameIds; stored
+     *  references are ids. */
+    tags?: Record<string, string[]>;
+    /** How many hands may hold this card at once (schema 3.5): integer >= 1,
+     *  default 1. One copy is the exclusivity rule; copies: N is the
+     *  deliberate opt-out for interchangeable filler. Always counted WITHIN a
+     *  flow, whether or not the card is shared. */
+    copies?: number;
+    /** Scarcity across flows (design/shared-scarcity.md). Absent takes the
+     *  deck's flag; set here it overrides the deck, so a single unique card can
+     *  stay in the content it belongs to. A shared card's claims count every
+     *  flow's board, and a shared `redraw: "never"` is spent for everyone the
+     *  first time anyone plays it.
+     *
+     *  A finite `redraw` stays PER FLOW even when shared: a cooldown is an
+     *  absolute turn of the card's box clock and clocks are per flow, so
+     *  "3 turns of whose clock?" has no answer. A world-wide timer is a @world
+     *  question, not an engine one (shared-scarcity 9.3.3). */
+    shared?: boolean;
+    /** The world cap: how many hands ACROSS EVERY FLOW may hold this at once.
+     *  Read only when the card is shared, and defaults to `copies`, so the
+     *  common case writes one number and "five in the world, one to a customer"
+     *  is `copies: 1, sharedCopies: 5`. */
+    sharedCopies?: number;
+    /** Card-template data: field name -> value, validated at publish. */
+    fields?: Record<string, ScalarValue>;
+    outcomes: Outcome<E>[];
+}
+interface Deck<E> {
+    id: string;
+    gameId?: string;
+    title?: string;
+    purpose?: string;
+    /** The deck gate, evaluated once per draw in the draw's environment. */
+    condition?: E;
+    /** This pile is scarce across flows (design/shared-scarcity.md): every card
+     *  in it is shared unless the card says otherwise. The container is where
+     *  Patter puts its own shared-memory flag, and the deck is our container. */
+    shared?: boolean;
+    properties: PropertyDecl[];
+    cards: Card<E>[];
+}
+interface Tag {
+    id: string;
+    gameId?: string;
+    /**
+     * This tag's own starting values for properties its GROUP declares
+     * (design/hand-typing.md). The group says what the property IS; a tag says
+     * only where it starts, so "every zone has a haunting level" is written once
+     * and "the cave starts at 2" is written where it belongs.
+     *
+     * A name here that the group does not declare is an error: it would be a
+     * value for nothing.
+     */
+    values?: Record<string, ScalarValue>;
+    /** Authored display order (sparse; one without it falls back to its id
+     *  position). Merges as a per-item value, so id-sorted storage stays
+     *  merge-clean (Reboot 7.4). */
+    order?: number;
+    properties?: PropertyDecl[];
+    /** Template-of-play extras (e.g. spatial geometry). Source only: preserved
+     *  in shards, never compiled into the bundle. */
+    templates?: Record<string, unknown>;
+}
+/** A named axis for cross-cutting cards (schema 2.4, renamed from
+ *  Dimension). Tags are declared, not freeform. */
+interface TagGroup {
+    id: string;
+    gameId?: string;
+    purpose?: string;
+    /**
+     * A property reference (`"@story.act"`) whose value names a tag in this group
+     * by gameId. The engine reads it at every ask and binds the group, exactly as
+     * if the asking hand had chosen that tag; a hand's own binding wins.
+     *
+     * For an axis driven by STATE rather than by place: acts, chapters, a
+     * difficulty band. Without it, only a hand can bind a group, so such an axis
+     * had nowhere to gate and every card needed its own condition.
+     *
+     * A reference rather than an expression on purpose (design/where-and-
+     * selectors.md Part B): a computed binding belongs in a property the outcomes
+     * maintain, and an expression here would make this type generic for no gain.
+     */
+    boundBy?: string;
+    /**
+     * What omitting this group means for a card. Default false: omission is a
+     * wildcard, so the card matches whatever the group is bound to. True inverts
+     * it, so a card that names no tag here is unavailable wherever the group IS
+     * bound (and unaffected where it is not).
+     *
+     * `place` is the built-in instance of this pair: bound to the asking hand,
+     * and inverted per card rather than per group.
+     */
+    required?: boolean;
+    /** Authored display order (sparse; one without it falls back to its id
+     *  position). Merges as a per-item value, so id-sorted storage stays
+     *  merge-clean (Reboot 7.4). */
+    order?: number;
+    /**
+     * Properties EVERY tag in this group has (design/hand-typing.md). The
+     * declaration lives here and each tag carries only its own starting value in
+     * `Tag.values`, which is the separation the format was missing: a tag's own
+     * `properties` entry has to restate the type on every tag purely in order to
+     * say the value, and a tag added later silently arrives without it.
+     *
+     * Compiled by FLATTENING onto each tag, so the bundle keeps its per-tag
+     * shape and no runtime, port or bundle schema changes: source is where the
+     * author works and where merges happen, the bundle is a compiled artefact
+     * that can afford to be explicit.
+     *
+     * A tag may still declare its own `properties` for a group whose tags
+     * genuinely differ. Declaring the same NAME both ways is an error.
+     */
+    properties?: PropertyDecl[];
+    tags: Tag[];
+    /** Template-of-play extras for the GROUP, the same bag its tags carry: this is
+     *  where a group is marked spatial and where that template keeps its own
+     *  group-level configuration. Source only, preserved but never compiled.
+     *
+     *  A bag rather than a `spatial: true` flag because the marker and the
+     *  configuration are one thing (see model/spatial.ts), and because core is not
+     *  meant to grow a field per template of play. */
+    templates?: Record<string, unknown>;
+}
+/** The reserved tag group (schema 2.4): present in every box without
+ *  declaration, its tags the box's hand ids. Every hand implicitly binds it to
+ *  itself; a card that names a place is available only at that place.
+ *
+ *  Called `place` rather than `home` since 2026-08-21: one word for one thing
+ *  across the format, the editor and the exports. "Where" is the QUESTION a
+ *  card answers (at a place, or anywhere in a region); "place" is the direct
+ *  half of that answer. `home` was a metaphor an author had to learn, and it
+ *  leaked into hand-edited shards and the docs. */
+declare const PLACE_GROUP = "place";
+/** A declared kind of hand (schema 2.6): live-inherited, author-side only,
+ *  never called from game code. One condition governs every instance. */
+interface HandTemplate<E> {
+    id: string;
+    gameId?: string;
+    title?: string;
+    purpose?: string;
+    /** Authored display order (sparse; one without it falls back to its id
+     *  position). Merges as a per-item value, so id-sorted storage stays
+     *  merge-clean (Reboot 7.4). */
+    order?: number;
+    /** Fixed tag bindings: tag group id -> tag id. */
+    bindings?: Record<string, string>;
+    /** The holes: tag group ids each instance fills (one tag each). */
+    chooses?: string[];
+    /** Shared availability condition, ANDed in (schema 3.1); evaluated per
+     *  instance against that instance's composed @hand. */
+    condition?: E;
+    /** Default slot cap. */
+    slots: number | "unbounded";
+    /** Declared @hand state every instance carries. */
+    properties: PropertyDecl[];
+}
+/** A standalone hand's inline rule (schema 2.6): owned by the hand. */
+interface HandRule<E> {
+    bindings?: Record<string, string>;
+    condition?: E;
+    slots: number | "unbounded";
+}
+/** A hand (schema 2.6): a template instance (template + chosen) or a
+ *  standalone hand (rule). Exactly one of template / rule. Fully concrete:
+ *  deal is name-only. */
+interface Hand<E> {
+    id: string;
+    /** The name deal() is called with; a rename is a breaking change
+     *  (Reboot 7.4). */
+    gameId?: string;
+    title?: string;
+    purpose?: string;
+    /** Hand template id (not gameId). */
+    template?: string;
+    /** Template instances: tag group id -> tag id, one per `chooses` hole. */
+    chosen?: Record<string, string>;
+    /** Standalone hands: the inline rule. */
+    rule?: HandRule<E>;
+    /** Override; defaults to the template's / rule's slots. The ONLY template
+     *  field an instance may override (schema 2.6). */
+    slots?: number;
+    /** Standalone hands' own @hand state (template instances inherit the
+     *  template's declarations). */
+    properties?: PropertyDecl[];
+    /** Authored display order within the box (sparse; authoring-only, never
+     *  compiled into the bundle - the compiler's explicit field list drops it). */
+    order?: number;
+    /** Template-of-play extras (e.g. a spatial pin). Source only. */
+    templates?: Record<string, unknown>;
+}
+interface Box<E> {
+    id: string;
+    gameId?: string;
+    title?: string;
+    purpose?: string;
+    /** The only per-box ranking policy (Reboot 2.2). */
+    ranking: {
+        specificity: boolean;
+    };
+    /** The card template: what every card in this box carries. */
+    fields: FieldDecl[];
+    properties: PropertyDecl[];
+    tagGroups: TagGroup[];
+    decks: Deck<E>[];
+    handTemplates: HandTemplate<E>[];
+    hands: Hand<E>[];
+}
+declare const BUNDLE_SCHEMA = "storylets/bundle@0";
+/** Binds bundles to shards (staleness gate) and saves to bundles. */
+interface BundleContent {
+    project: string;
+    version: string;
+    /** hash32 over the canonical source shards (schema 2.8). */
+    hash: string;
+}
+interface BundleSettings {
+    playAdvancesTurns: number;
+}
+/**
+ * A map that a bundle was asked to carry: one spatial tag group's geometry,
+ * flattened for a host to draw (design/graphical-views.md 2, "The map MAY ship").
+ *
+ * INERT PAYLOAD. Nothing in the engine reads this and nothing ever will: the
+ * runtime deals in tag names. It is here so a host that wants an in-game map does
+ * not have to invent its own export, and it is absent unless the project asked
+ * for it (`export.map`), so a build that does not want a map carries no bytes.
+ *
+ * GAME IDS throughout, never internal ids. Internal ids are authoring identity
+ * and mean nothing outside the project; a host matches these against the same
+ * names it passes to `peek`. There is nothing here to strip either, which is why
+ * `metadata: "stripped"` needs no special case: no titles, no purposes.
+ *
+ * Sites are deliberately NOT here. A site is where an author parked a hand while
+ * working, held in the view sidecar precisely because it is not content, and a
+ * host that wants to place a hand already has its zone from the compiled binding.
+ */
+interface BundleMap {
+    /** The owning box, by gameId (tag groups are box-scoped). */
+    box: string;
+    /** The tag group this is a map of, by gameId. */
+    group: string;
+    /** One entry per zone that has been drawn; a tag with no polygon is not a
+     *  place yet and is left out rather than shipped as an empty shape. */
+    zones: {
+        tag: string;
+        polygon: ViewPoint[];
+    }[];
+    /** Background pictures, back to front, as bundle-relative paths. Hidden ones
+     *  do not ship: what an author put away is not something to spring on a host. */
+    backgrounds?: BundleBackground[];
+}
+/** One shipped picture. `locked` and `hidden` are authoring state and do not
+ *  travel; the draw order is the array order. */
+interface BundleBackground {
+    /** Where the file sits relative to the bundle ("assets/<box>/<file>"). */
+    file: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    opacity?: number;
+}
+interface Bundle {
+    schema: typeof BUNDLE_SCHEMA;
+    content: BundleContent;
+    metadata: "full" | "stripped";
+    settings: BundleSettings;
+    world: {
+        properties: PropertyDecl[];
+        /** ScopeRegistrySpec (@wildwinter/scoperegistry): the owned/foreign
+         *  split. Absent = engine-owned @world (standalone play). */
+        registry?: unknown;
+    };
+    story: {
+        properties: PropertyDecl[];
+    };
+    boxes: Box<Expression>[];
+    /** Maps, when the project asked for them. Absent is the normal state. */
+    maps?: BundleMap[];
+}
+declare const SAVE_SCHEMA = "storylets/save@1";
+interface PlayRecord {
+    /** Card and outcome by gameId (feeds the play-history functions). */
+    card: string;
+    outcome: string;
+    turn: number;
+}
+/** A property bag: name -> value. */
+type PropertyBag = Record<string, ScalarValue>;
+/** The per-scope property partitions one side of the sharing flag holds:
+ *  a save carries one of these for the shared values and one per flow
+ *  (design/flows.md). NO world key, in either: @world is the game's own
+ *  state, resolved through the world resolver and saved by whoever owns
+ *  it - "host saves its container once, each engine saves its own
+ *  envelope" (engine-runtimes.md 3.1). */
+interface PropsPartition {
+    story: PropertyBag;
+    box: Record<string, PropertyBag>;
+    deck: Record<string, PropertyBag>;
+    hand: Record<string, PropertyBag>;
+    /** Tag state, keyed by tag id. */
+    value: Record<string, PropertyBag>;
+}
+/** One flow's snapshot inside the envelope (schema 4). */
+interface FlowSave {
+    /** The per-flow property partitions. */
+    props: PropsPartition;
+    /** Per-box turn counters, keyed by box id (schema 3.4) - per flow: there
+     *  is deliberately no global turn. */
+    turns: Record<string, number>;
+    /** mulberry32 state, uint32 (schema 3.3), per flow. */
+    prng: number;
+    /** Absolute next-eligible turn (of the card's box's clock) per card id;
+     *  MAX_SAFE_INTEGER = never (deliberately not Infinity, which
+     *  JSON-serialises to null). */
+    cooldowns: Record<string, number>;
+    /** Hand contents (card ids, in dealt order), keyed by hand id. The claims
+     *  ledger is derived from this (schema 3.5). */
+    board: Record<string, string[]>;
+    playLog: PlayRecord[];
+}
+/** The whole engine, one envelope: the shared partitions once, then every
+ *  live flow keyed by its id - Patter's shape (one shared blob + N flow
+ *  blobs; multi-flow and save/load are the same feature). */
+/** The engine's half of a save: what every flow shares. Properties, and the
+ *  cards a shared `redraw: "never"` has taken out of the world for good
+ *  (design/shared-scarcity.md). Claims are NOT here: they are derived from the
+ *  live boards, and each flow's board rides its own blob. */
+interface SharedSave {
+    props: PropsPartition;
+    /** Card ids, sorted, so a save is byte-stable for a diff. */
+    spent: string[];
+}
+interface SaveEnvelope {
+    schema: typeof SAVE_SCHEMA;
+    content: BundleContent;
+    shared: SharedSave;
+    flows: Record<string, FlowSave>;
+}
+/** The .storyletsave FILE: the HOST's file, not the engine's - the engine's
+ *  envelope plus, when the host keeps one, its @world container. This is
+ *  "host saves its container once, each engine saves its own envelope"
+ *  folded into one file for the single-host case; the ENGINE never reads or
+ *  writes `world` (loadGame takes the envelope alone). */
+declare const SAVEFILE_SCHEMA = "storylets/savefile@1";
+interface SaveFile {
+    schema: typeof SAVEFILE_SCHEMA;
+    engine: SaveEnvelope;
+    /** The host's @world values, saved and restored by the host. */
+    world?: PropertyBag;
+}
+/** The project folder: a macOS package, a plain folder elsewhere. */
+declare const PROJECT_FOLDER_EXTENSION = ".storylets";
+/** The compiled bundle (strict JSON; generated, never hand-edited). */
+declare const BUNDLE_EXTENSION = ".storyletsc";
+/**
+ * Where a shipped background sits, relative to the bundle file.
+ *
+ * One function so the compiler (which writes the name into the bundle) and the
+ * export op (which writes the bytes) cannot drift apart: a path agreed in two
+ * places is a path that eventually disagrees. Per BOX, because two boxes may
+ * each have their own `plan.png` and a build must not silently keep one of them.
+ */
+declare const bundleAssetPath: (boxGameId: string, file: string) => string;
+/** Per-type shard extensions, JSON5 inside (source doc section 2). */
+declare const SHARD_EXTENSIONS: {
+    readonly project: ".storyletproj";
+    readonly box: ".storyletbox";
+    readonly tags: ".storylettags";
+    readonly hands: ".storylethands";
+    readonly deck: ".storyletdeck";
+    /** The arrangement layer: where things SIT, never what they are. Its own shard
+     *  because positions churn (an afternoon of tidying a canvas touches every
+     *  card) and content does not, so a designer arranging and a writer editing
+     *  never collide on one file (design/graphical-views.md section 1.2). */
+    readonly view: ".storyletview";
+    /** Threaded comments: content-ADJACENT, so neither in a content shard (a
+     *  writer's deck edit must not conflict with a reviewer's comment) nor in the
+     *  arrangement sidecar (this is not where anything sits). One per box,
+     *  id-keyed (design/annotation.md). Documentation NOTES used to share this
+     *  file and were retired: `purpose` already says why a thing exists, and
+     *  Patterpad's typed routing has no destination here. */
+    readonly notes: ".storyletnotes";
+};
+declare const PROJECT_SCHEMA = "storylets/project@0";
+declare const BOX_SCHEMA = "storylets/box@0";
+declare const TAGS_SCHEMA = "storylets/tags@0";
+declare const HANDS_SCHEMA = "storylets/hands@0";
+declare const DECK_SCHEMA = "storylets/deck@0";
+declare const VIEW_SCHEMA = "storylets/view@0";
+/** The comment sidecar's schema. Still called "notes" on disk: the file already
+ *  held both, and renaming it would break every project for no gain. */
+declare const NOTES_SCHEMA = "storylets/notes@0";
+/** A point in a canvas's own coordinates. */
+interface ViewPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Canvas furniture: what an author draws AROUND the content to make sense of it
+ * (design/graphical-views.md 3, "Frames and sites").
+ *
+ * Both canvases carry the same thing, which is why they share a type: a node
+ * canvas and a map are different views of different material, but "put a box
+ * round this lot and call it act two" is the same thought on either.
+ *
+ * It lives in the view sidecar because it is ARRANGEMENT. Nothing here is
+ * content: no runtime reads it, no bundle carries it, and deleting the sidecar
+ * loses only the drawing. Threaded comments are the
+ * other thing entirely - they attach to entities and they travel - but a canvas
+ * DRAWS their markers, while owning none of them.
+ */
+interface CanvasFurniture {
+    /** Titled areas behind the content, back to front (see `stacked`).
+     *
+     *  There was a second kind, a `stickies` list, retired on 2026-08-10
+     *  (design/annotation.md): a dropped comment marker does the same job in a
+     *  fraction of the space, and an annotation that takes as much room as the
+     *  thing it is about is a bad trade on a canvas. */
+    frames?: Frame[];
+}
+/**
+ * A titled area behind a group of things: Unreal's comment box.
+ *
+ * Deliberately dumb about what is inside it. It has no membership list and
+ * computes none: a frame is a thing an author DREW, and the cards under it are
+ * whatever happens to be under it now. That is what keeps it honest when content
+ * moves, and it is the same reasoning that keeps a zone's sites out of the map's
+ * sidecar.
+ */
+interface Frame extends ViewPoint {
+    id: string;
+    w: number;
+    h: number;
+    /** Shown in the frame's bar, and the handle it is dragged by. */
+    title?: string;
+    /** One of the furniture palette's names (see `FURNITURE_COLOURS`); the theme
+     *  decides what that looks like, so a frame does not carry a hex value that
+     *  would fight the palette on the day somebody switches theme. */
+    colour?: string;
+    /** Place in the frame band (sparse, `stacked`). Frames can nest. */
+    z?: number;
+}
+/** The furniture palette: names, not colours. The theme maps them, so the same
+ *  shard reads correctly on linen and on baize. */
+declare const FURNITURE_COLOURS: readonly ["paper", "amber", "sage", "sky", "rose", "slate"];
+type FurnitureColour = typeof FURNITURE_COLOURS[number];
+/** One deck's node canvas: where its cards sit, and the furniture around them.
+ *  Sparse throughout. A card with no entry lays out by default, and an entry for
+ *  a card that no longer exists is inert, so there is no referential integrity to
+ *  maintain against content that moves underneath. */
+interface DeckCanvas extends CanvasFurniture {
+    /** Keyed by CARD id. */
+    cards?: Record<string, ViewPoint>;
+}
+/** The box's map: where its hands sit in space, and the furniture around them. */
+interface BoxMap extends CanvasFurniture {
+    /** Keyed by HAND id. WHERE a site is, and nothing else.
+     *
+     *  Which zone it is IN is not recorded here, and deliberately (2026-08-06,
+     *  with the rebinding drag): a hand that binds a zone already says so in its
+     *  own shard, as `chosen` or as a rule binding, and that is the truth the
+     *  runtime deals from. A copy here could only ever go on to disagree with it,
+     *  and a site whose recorded zone contradicts the hand it stands for would be
+     *  the most misleading thing on the map.
+     *
+     *  Called `pins` until 2026-08-10 (design/annotation.md). No compatibility
+     *  branch: the only projects that exist are the examples in this repo, and they
+     *  were edited. */
+    sites?: Record<string, ViewPoint>;
+}
+/** The arrangement layer for one box: where things SIT, never what they are.
+ *
+ *  Its own shard on purpose (design/graphical-views.md section 1.2). Positions
+ *  churn, content does not: an afternoon of tidying a canvas touches every card,
+ *  and if that lived in the deck shard then a designer arranging and a writer
+ *  editing card text would collide on one file all day, while a content review
+ *  would be full of coordinates. Keyed by id throughout so the existing merge
+ *  engine handles two designers rearranging different things without a conflict.
+ *
+ *  Source-only. It never reaches the compiled bundle, exactly as `order` does
+ *  not: the compiler reads the fields it names and this is not among them. */
+interface ViewShard {
+    schema: typeof VIEW_SCHEMA;
+    /** Keyed by DECK id: one node canvas each. */
+    canvases?: Record<string, DeckCanvas>;
+    map?: BoxMap;
+}
+/** A coverage input driver: during a coverage run the harness feeds a
+ *  host-seam property (`@world.x`) values from `values`, so content gated on
+ *  external state gets exercised (Patter's coverageDrivers, carried whole). */
+interface CoverageDriver {
+    /** "initial": set once as each playthrough starts. "recurring": re-rolled
+     *  per turn at the cadence, so one run passes through several states. */
+    kind: "initial" | "recurring";
+    /** For recurring drivers: how often to re-roll per turn (default "sometimes"). */
+    cadence?: "rarely" | "sometimes" | "often";
+    /** The pool the harness picks from (uniform). Empty = inert. */
+    values: ScalarValue[];
+}
+/** Authoring-side coverage configuration (never compiled into the bundle). */
+interface CoverageConfig {
+    /** Property drivers, keyed by ref ("@world.danger"). */
+    drivers?: Record<string, CoverageDriver>;
+}
+interface ProjectShard {
+    schema: typeof PROJECT_SCHEMA;
+    project: {
+        id: string;
+        name: string;
+        version: string;
+    };
+    settings: BundleSettings;
+    /** Coverage drivers + argument domains (authoring/testing config; stays
+     *  out of the compiled bundle). */
+    coverage?: CoverageConfig;
+    /** Validation switches (authoring config; never compiled). Off is written
+     *  as ABSENT, like `export.map`: a shard says what an author chose. */
+    validation?: {
+        /** Also warn when state is WRITTEN but nothing reads it. Off by default:
+         *  cards are routinely written ahead of the content that will read them,
+         *  so mid-development this warning is mostly noise. The read side (a gate
+         *  on state nothing writes) always warns, because that kills cards now. */
+        warnUnreadWrites?: boolean;
+    };
+    world: {
+        properties: PropertyDecl[];
+        registry?: unknown;
+    };
+    story: {
+        properties: PropertyDecl[];
+    };
+    /** Templates of play: configuration bags keyed by template name. Core
+     *  validates only what it knows. */
+    templates: Record<string, unknown>;
+    export: {
+        bundle: string;
+        metadata: "full" | "stripped";
+        /**
+         * Does a `.storyletpack` carry the boxes' binary assets (background images)?
+         *
+         * Default false, and a project-level DEFAULT rather than a rule: a pack is a
+         * delivery, so the caller can override it per pack (2026-08-07). Some
+         * projects would benefit from sending their pictures in certain
+         * circumstances and others never would, which is why neither "always" nor
+         * "never" is the answer.
+         *
+         * Nothing to do with the compiled bundle, which has its own switch: `map`.
+         */
+        packAssets?: boolean;
+        /**
+         * Does the compiled bundle carry the maps (zone shapes and background
+         * pictures)?
+         *
+         * Default false, and the default matters: geometry is authoring data, the
+         * runtime deals in tag names, and a shipping build should carry nothing it
+         * does not use. But a host that wants an in-game map should not have to
+         * invent its own export, and it is most useful early - a prototype with a
+         * real map beats a prototype with a list of zone names.
+         *
+         * It sits beside `metadata` on purpose: that is already the switch for
+         * "authoring data that may or may not ship", and this is its sibling rather
+         * than a new concept. With it on, `export` also writes the background files
+         * next to the bundle, and `describeBundle` says what is in there.
+         */
+        map?: boolean;
+    };
+}
+interface BoxShard {
+    schema: typeof BOX_SCHEMA;
+    box: {
+        id: string;
+        gameId?: string;
+        title?: string;
+        purpose?: string;
+        /** Authored display order among boxes (sparse; absent falls back to the
+         *  folder-name position). Authoring-only, like a card's (never compiled
+         *  into the bundle); merges as a per-field value. */
+        order?: number;
+        ranking: {
+            specificity: boolean;
+        };
+        fields: FieldDecl[];
+        properties: PropertyDecl[];
+    };
+}
+/** The box's tag groups: how its cards are filed. */
+interface TagsShard {
+    schema: typeof TAGS_SCHEMA;
+    groups: TagGroup[];
+}
+/** The box's hand templates + hands (the writer/programmer contract). */
+interface HandsShard {
+    schema: typeof HANDS_SCHEMA;
+    templates: HandTemplate<string>[];
+    hands: Hand<string>[];
+}
+interface DeckShard {
+    schema: typeof DECK_SCHEMA;
+    deck: {
+        id: string;
+        gameId?: string;
+        title?: string;
+        purpose?: string;
+        condition?: string;
+        /** Scarce across flows: see Deck.shared. */
+        shared?: boolean;
+        /** Authored display order within the box (sparse; see BoxShard). */
+        order?: number;
+        properties: PropertyDecl[];
+    };
+    cards: Card<string>[];
+}
+
+export { BOX_SCHEMA, BUNDLE_EXTENSION, BUNDLE_SCHEMA, type Box, type BoxMap, type BoxShard, type Bundle, type BundleBackground, type BundleContent, type BundleMap, type BundleSettings, type CanvasFurniture, type Card, type Comment, type CommentMark, type CommentMessage, type CoverageConfig, type CoverageDriver, DECK_SCHEMA, type Deck, type DeckCanvas, type DeckShard, FURNITURE_COLOURS, type FieldDecl, type FlowSave, type Frame, type FurnitureColour, HANDS_SCHEMA, type Hand, type HandBinding, type HandRule, type HandTemplate, type HandsShard, NOTES_SCHEMA, type NotesShard, type Outcome, PLACE_GROUP, PROJECT_FOLDER_EXTENSION, PROJECT_SCHEMA, type PlayRecord, type Polygon, type ProjectShard, type PropertyBag, type PropertyDecl, type PropertyType, type PropsPartition, type Rect, type RedrawPolicy, SAVEFILE_SCHEMA, SAVE_SCHEMA, SHARD_EXTENSIONS, SPATIAL, type SaveEnvelope, type SaveFile, type SharedSave, type SpatialBackground, type SpatialGroup, type StackMove, type Stacked, TAGS_SCHEMA, type Tag, type TagGroup, type TagsShard, VIEW_SCHEMA, type ViewPoint, type ViewShard, backgroundsOf, bindHand, bundleAssetPath, byDisplayOrder, centroid, commentsOf, droppedRect, effectiveGameId, framesOf, freeGameId, freeTitle, gameIdify, handBinding, inferDeclFromWrite, isSpatial, isValidGameId, labelPoint, markOf, marksOn, openThreadCounts, pointInPolygon, polygonBounds, polygonOf, restack, spatialOf, stacked, threadsFor, unbindHand, withBackgrounds, withPolygon, withSpatialGroup, withZ, zOf, zoneAt, zonesAt };