@idle-screens/schema 3.6.1 → 3.7.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Rng, SaverPlugin, SaverManifest } from '@idle-screens/core';
+import { Rng, SaverContext, SaverPlugin, SaverManifest } from '@idle-screens/core';
 
 /**
  * Declarative, agent-authorable saver format. A `SaverSpec` describes a saver as DATA
@@ -291,6 +291,8 @@ type SpriteSpec = {
     baseline?: 'top' | 'middle' | 'bottom';
     maxWidth?: number;
     cycle?: CycleSpec;
+    /** See `TextRole`. Absent ⇒ no legibility advisories, no pixel change. */
+    role?: TextRole;
 }
 /** `soft` renders a radial falloff (glow orb) instead of a hard disc.
  *  `colorWeights` (same length as `colors`) biases the seeded per-entity pick —
@@ -409,13 +411,49 @@ type SpriteSpec = {
  | {
     kind: 'textBlock';
     text: string;
+    /** Wrap width as a fraction of `min(w,h)` (up to 2.0 — `text-off-screen` catches overflow). */
     maxWidth: number;
     fontSize: number;
     lineHeight?: number;
+    /** Moves the painted lines inside the wrap width (ragged edge); never the block. */
     align?: 'left' | 'center' | 'right';
     color?: string;
     reveal?: TextRevealSpec;
+    /**
+     * Which point of the rendered text (widest line × lines·lineHeight, as
+     * `align` lays it out) `position` names. Absent: today's behaviour —
+     * `position` is the top-left of the `maxWidth` layout box. With
+     * `'center'` the block is centred at `position` on every aspect ratio.
+     * Placement, so it is in the structural signature.
+     */
+    anchor?: TextBlockAnchor;
+    /**
+     * CSS font family and/or weight/style only (`"bold monospace"`,
+     * `"300 'Inter', sans-serif"`). A size inside it is rejected —
+     * `fontSize` owns size. Absent: `system-ui, sans-serif`.
+     */
+    font?: string;
+    /**
+     * 0..1 multiplier on the block's paint alpha (default 1). Paint, not
+     * carpentry: excluded from the structural signature, so steering it
+     * with `dur` glides the block in or out without a rebuild. Declare it
+     * (`"opacity": 1`) to make the path steerable.
+     */
+    opacity?: number;
+    /** See `TextRole`. Absent ⇒ no legibility advisories, no pixel change. */
+    role?: TextRole;
 };
+/**
+ * What a text layer is *for* — a declaration, not a pixel. `read` says the
+ * words must be readable from across the room and opts the layer into
+ * `adviseSpec`'s legibility advisories (`text-legibility`, `text-safe-area`).
+ * `atmosphere` says the text is texture (a haiku fading in a corner, dim
+ * labels on a wall board) and is the same as absent: silent. Changes no
+ * pixel anywhere, on any client; never part of the structural signature.
+ */
+type TextRole = 'read' | 'atmosphere';
+/** Compass points of a `textBlock`'s rendered box that `position` may name. */
+type TextBlockAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
 /**
  * Animated typing/deleting for `textBlock`. Layout always runs on the FULL
  * text — reveal only masks which glyphs are painted, so lines never reflow
@@ -582,6 +620,20 @@ interface SpecWarning {
     path: string;
     code: string;
     message: string;
+    /**
+     * Viewport-fraction boxes (`x`, `y`, `w`, `h` of `width`/`height`) the
+     * warning is about — `text-overlap` carries the two text boxes so an agent
+     * can move one without re-deriving the layout. Present only where a
+     * warning has geometry to report.
+     */
+    boxes?: WarningBox[];
+}
+/** A rectangle in viewport fractions (x/w of width, y/h of height). */
+interface WarningBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
 }
 /** Perf/safety caps enforced by `validateSpec`. */
 declare const LIMITS: {
@@ -613,7 +665,7 @@ declare const LIMITS: {
     readonly maxTextBlockLength: 2000;
     readonly minTextBlockFontSize: 0.01;
     readonly maxTextBlockFontSize: 0.2;
-    readonly maxTextBlockMaxWidth: 1;
+    readonly maxTextBlockMaxWidth: 2;
     readonly maxRevealSpeed: 120;
     readonly maxCaretBlinkHz: 3;
     readonly maxSegments: 24;
@@ -637,9 +689,30 @@ declare const LIMITS: {
 };
 type SequenceTransition = {
     type: 'cut';
-} | {
+}
+/**
+ * Interpolate numbers and hex colours into the next (structurally
+ * identical) segment over `dur` ms. Strings step on the first frame —
+ * unless `text: 'crossfade'`, which draws each `text` / `textBlock` layer
+ * whose string(s) differ twice for the window: the outgoing string at
+ * `1 − k`, the incoming at `k` (k = the morph's eased progress). Default
+ * `'step'`, today's behaviour, byte for byte.
+ */
+ | {
     type: 'morph';
     dur: number;
+    text?: 'step' | 'crossfade';
+}
+/**
+ * Cross-fade into the next segment over `dur` ms: the outgoing segment
+ * stays alive on its own canvas and is composited over the incoming one
+ * at `1 − easeSmooth(localT / dur)`. Works between unlike segments (no
+ * structural requirement). Hosts on the `basic`/`minimal` capability tier
+ * render it as `cut` (see `SequenceMountContext.capabilityTier`).
+ */
+ | {
+    type: 'fade';
+    dur: number;
 };
 interface SequenceSegment {
     key: string;
@@ -657,6 +730,25 @@ interface IdleSequence {
     label: string;
     seed?: number;
     loop: boolean;
+    /**
+     * What the sequence clock is anchored to. `mount` (default — today's
+     * behaviour): every viewer starts at T = 0 when it mounts, so a joiner sees
+     * segment 0 (pre-roll semantics). `epoch`: a viewer handed `sequenceBaseT`
+     * on its mount context (the host's `Date.now() − epoch`) starts its clock
+     * there, so every screen in a room shows the same segment — a late joiner
+     * lands mid-loop. `advance: 'input'` holds stay armed under either mode.
+     */
+    sync?: 'mount' | 'epoch';
+    /**
+     * A scene drawn under every segment on the sequence's **global** clock —
+     * the ground that does not reset at a boundary or under a `sequence.segment`
+     * steer. Segments render over it transparently (their `background` and
+     * `ghosting` are ignored; the bed may declare its own). Its entities count
+     * toward the perf cap together with the largest segment's, since the two
+     * are live at once. Steer it with `bed.<path>`. Absent ⇒ every segment
+     * paints its own ground, exactly as before the field existed.
+     */
+    bed?: SaverSpec;
     segments: SequenceSegment[];
 }
 
@@ -673,6 +765,8 @@ declare function assertValidSequence(seq: unknown): IdleSequence;
 
 /** Near plane for warp motion. z lives in [WARP_NEAR, 1]; screen scale is 1/z. */
 declare const WARP_NEAR = 0.08;
+/** Cap on the 1/z size multiplier so near stars don't blow out. */
+declare const WARP_MAX_SCALE = 8;
 /** One axis-pair of seeded harmonic octaves for wander motion (amps px, freqs rad/ms). */
 interface WanderOsc {
     ax: number[];
@@ -835,8 +929,26 @@ declare function linkPairs(positions: Array<{
     x: number;
     y: number;
 }>, k: number, maxDist: number, doWrap: boolean, w: number, h: number): Array<[number, number]>;
-/** Em-width of a string under the same character-class table `breakTextBlock` uses. */
-declare function textWidthEm(str: string): number;
+/**
+ * Which advance table the line-breaker uses. `proportional` is the
+ * character-class table below (the default, and the only table until
+ * `textBlock.font` existed); `mono` is a uniform 0.6 em advance — the classic
+ * monospace cell (Courier, Menlo, SF Mono all sit within a percent of it).
+ */
+type TextMetricsClass = 'proportional' | 'mono';
+/**
+ * Metrics class for a `textBlock.font` string: `mono` when the family names
+ * a monospace face (the generic `monospace`, or a well-known fixed-pitch
+ * family), else `proportional`. Absent font ⇒ proportional, as before.
+ */
+declare function textMetricsClassFor(font?: string): TextMetricsClass;
+/**
+ * Em-width of a string under the same character-class table `breakTextBlock`
+ * uses. `mono` counts grapheme clusters, not UTF-16 code units — an emoji or
+ * combining/ZWJ sequence is one advance-width cell, matching what's painted,
+ * not one cell per surrogate half or combining mark.
+ */
+declare function textWidthEm(str: string, metrics?: TextMetricsClass): number;
 interface TextBlockLine {
     text: string;
     widthEm: number;
@@ -846,7 +958,24 @@ interface TextBlockLine {
  * whitespace; a single word wider than the limit gets its own line unbroken.
  * Explicit `\n` always forces a break. Pure, deterministic, no canvas needed.
  */
-declare function breakTextBlock(text: string, maxWidthEm: number): TextBlockLine[];
+declare function breakTextBlock(text: string, maxWidthEm: number, metrics?: TextMetricsClass): TextBlockLine[];
+/**
+ * Where an anchored textBlock's layout origin sits relative to `position`:
+ * the (dx, dy) to ADD to `position` so that the named point of the rendered
+ * text lands on it. The rendered box is the widest line wide (placed inside
+ * the `maxWidth` box by `align`) and `lines × lineHeight` tall — so `anchor`
+ * says where the block sits and `align` only shapes its ragged edge. Absent
+ * anchor ⇒ (0, 0): `position` stays the layout box's top-left, exactly as
+ * before the field existed. Renderer, perception and advisories all call
+ * this, so their boxes agree by construction.
+ */
+declare function textBlockAnchorOffset(s: {
+    anchor?: TextBlockAnchor;
+    align?: 'left' | 'center' | 'right';
+}, maxWPx: number, maxLineW: number, totalH: number): {
+    dx: number;
+    dy: number;
+};
 /**
  * Split a string into paint-safe grapheme clusters: surrogate pairs stay
  * whole, combining marks / variation selectors / skin tones attach to their
@@ -893,6 +1022,25 @@ declare function manifestFor(spec: SaverSpec): SaverManifest;
  * deterministic, `renderFrame(t,seed)`-addressable, and flash-safe by construction.
  */
 declare function compileSaver(spec: unknown): SaverPlugin;
+/**
+ * Mount context for a compiled sequence. A plain `SaverContext` works — the
+ * clock starts at 0, as every SaverPlugin's does. `sequenceBaseT` is read
+ * only when the sequence declares `sync: 'epoch'`; hosts pass the shared
+ * clock's elapsed ms (idlescreens.com: `Date.now() − scene.epoch`) so every
+ * viewer of that sequence resolves the same segment.
+ */
+interface SequenceMountContext extends SaverContext {
+    /** ms already elapsed on the shared sequence clock. Ignored unless `sync: 'epoch'`. */
+    sequenceBaseT?: number;
+    /**
+     * The device's compute tier (`computeTier` from `@idle-screens/capabilities`;
+     * the string union is repeated here so schema does not depend on that
+     * package). A `fade` transition keeps two segments live for `dur`, which
+     * `basic` (canvas2d only) and `minimal` cannot afford: on those tiers fade
+     * renders as `cut`. Absent ⇒ fade enabled.
+     */
+    capabilityTier?: 'minimal' | 'basic' | 'standard' | 'high';
+}
 declare function compileSequence(spec: unknown): SaverPlugin;
 
 /**
@@ -925,6 +1073,20 @@ declare function applyDeltasToSpec(spec: SaverSpec, deltas: SteerDelta[]): Saver
  * target immediately (k > 0). Layer counts round to integers.
  */
 declare function lerpSpec(from: SaverSpec, to: SaverSpec, k: number): SaverSpec;
+/**
+ * The string(s) a text layer paints — `strings` of a `text` sprite, `text`
+ * of a `textBlock` — or null for every other sprite.
+ */
+declare function textStringsOf(sprite: SpriteSpec): string[] | null;
+/**
+ * Whether the text layer at index `i` paints different words in `a` and
+ * `b` — the layers a morph `text: 'crossfade'` draws twice. False for
+ * non-text layers and when the strings match.
+ */
+declare function textStringsDiffer(a: SaverSpec, b: SaverSpec, i: number): boolean;
+declare function morphNothingMorphable(a: SaverSpec, b: SaverSpec, opts?: {
+    textCrossfade?: boolean;
+}): boolean;
 /**
  * Enumerate all steerable leaf paths in a (resolved) spec. Returns dot-paths
  * like "layers.0.count", "background.stops.1.color", etc. Metadata fields
@@ -935,6 +1097,14 @@ declare function lerpSpec(from: SaverSpec, to: SaverSpec, k: number): SaverSpec;
  * Consumers can map to key-based paths via resolveSpecPath if needed.
  */
 declare function steerablePaths(spec: unknown): string[];
+/**
+ * Every path a sequence accepts on its track: `sequence.segment` (the
+ * clicker), the bed's paths under the `bed.` prefix, and the union of every
+ * segment's paths (a segment path lands on whichever segment owns it — see
+ * `SequenceInstance.applyTrack`). Deduplicated, numeric layer indices as in
+ * `steerablePaths`.
+ */
+declare function sequenceSteerablePaths(seq: IdleSequence): string[];
 /** Smooth (ease-in-out) progress curve used for glides. */
 declare function easeSmooth(k: number): number;
 /**
@@ -1289,6 +1459,58 @@ interface ScenePerception {
  * Intended as the payload behind an MCP previewScene.
  */
 declare function perceiveScene(spec: SaverSpec, opts?: LuminanceGridOptions): ScenePerception;
+interface SequenceFramePerception extends ScenePerception {
+    /** Which segment the global time `T` resolved to, and where in it. */
+    segment: {
+        index: number;
+        key: string;
+        localT: number;
+        held?: true;
+    };
+    /** True when a bed was composed under the segment. */
+    bed: boolean;
+}
+interface PerceiveSequenceOptions extends Omit<LuminanceGridOptions, 't'> {
+    /** Holds released by the clicker so far — see `ResolveOptions.releasedBelow`. */
+    releasedBelow?: number;
+}
+/**
+ * Perceive one frame of a sequence at global time `T`: resolve the segment,
+ * then — when the sequence has a `bed` — compose the bed at `T` (its clock
+ * never resets) under the segment's ink at `localT`, the segment's own
+ * background dropped, exactly as the renderer stacks them. The luminance maps
+ * add the two grids (clamped), so coverage, centroid and the profiles are of
+ * the composite; dominance ranks bed and segment layers together by their raw
+ * weights, bed layers keyed `bed:<key|index>`; text, motion and form list bed
+ * layers first with the same prefix. Bed and segment are assumed to share
+ * `units`/`referenceViewport`, as the renderer's shared canvas assumes. The
+ * bed and segment seeds come from `segmentRenderSeed`/`bedRenderSeed`
+ * (`./sequence`) — the same derivation `SequenceInstance` uses, chain roots
+ * and zero-seed normalization included — so the composed frame matches what
+ * the renderer actually draws at `T`, not just what the raw specs would show.
+ * Without a bed this is `perceiveScene(segment, localT)` plus the `segment`
+ * field. Intended as the payload behind a sequence-aware previewScene.
+ *
+ * Two known approximations, both accepted for a coarse, cheap, renderer-free
+ * tool rather than fixed here:
+ * - **The transition WINDOW isn't composed.** During a live `fade` or `morph`
+ *   (i.e. `localT < transition.dur`) the renderer also paints the outgoing
+ *   (or interpolating) segment, but this only ever perceives the segment
+ *   `resolveSegment` resolves to — call it at a `T` outside the transition's
+ *   `dur` for an accurate read. (Outside that window, a morph-chained
+ *   segment's entities and seed ARE correct — `segmentRenderSeed` already
+ *   resolves the chain root.) Composing the live window properly needs the
+ *   same capability-tier gate `SequenceInstance` uses to decide whether
+ *   `fade` even plays; this analytical path has no such context.
+ * - **Ink composites onto the bed by addition, not by blend mode.** This
+ *   matches a plain `source-over`, opaque-ink segment (the common case), but
+ *   a segment layer with `blend: 'multiply'`/`'screen'`/etc. or partial alpha
+ *   composites directionally differently on the real canvas than adding
+ *   luminance values ever can (`multiply` darkens; addition only brightens).
+ *   The per-cell grids don't retain per-layer blend/alpha to composite
+ *   correctly at this resolution.
+ */
+declare function perceiveSequenceFrame(seq: IdleSequence, T: number, opts?: PerceiveSequenceOptions): SequenceFramePerception;
 
 interface ResolvedSegment {
     index: number;
@@ -1333,6 +1555,33 @@ declare function segmentStart(seq: IdleSequence, index: number): number;
  * mode (validated elsewhere).
  */
 declare function resolveSegment(seq: IdleSequence, T: number, opts?: ResolveOptions): ResolvedSegment;
+/** Whether the boundary from `from` to `from + 1` morphs: same scene structure, `morph` transition. */
+declare function canMorph(seq: IdleSequence, from: number): boolean;
+/**
+ * Walk back through consecutive `morph` boundaries to the chain's origin. A
+ * morph-chained segment's entities are never re-seeded at the boundary —
+ * they're the same stream continued from wherever the chain started — so its
+ * actual render seed (see `segmentRenderSeed`) is always the chain root's,
+ * never its own index's.
+ */
+declare function morphChainRoot(seq: IdleSequence, index: number): number;
+/** `SpecInstance`'s seed normalization: 0 is falsy, so a valid `seed: 0` lands on 1. */
+declare function normalizeSeed(seed: number): number;
+/**
+ * The seed segment `index`'s entities actually render with — its chain
+ * root's own seed, else `seq.seed + ` the chain root's index, normalized
+ * exactly like `SpecInstance`. `undefined` when neither is set: the same
+ * "unknowable ahead of time" case a bare `SaverSpec` has via `ctx.seed`,
+ * which callers fall back to their own default for (as `perceiveScene` does).
+ */
+declare function segmentRenderSeed(seq: IdleSequence, index: number): number | undefined;
+/**
+ * The seed the bed's entities actually render with — its own seed, else
+ * `seq.seed + LIMITS.maxSegments` (past every segment's `seq.seed + index`,
+ * so a bed and segment 0 never share a stream), normalized like
+ * `SpecInstance`. `undefined` when there's no bed or no derivable seed.
+ */
+declare function bedRenderSeed(seq: IdleSequence): number | undefined;
 
 /**
  * Reproduces the hand-coded Fish Aquarium saver as pure DATA — the discriminating test
@@ -1372,6 +1621,23 @@ declare const SNOWFALL_SPEC: SaverSpec;
  */
 declare const LANTERNS_SPEC: SaverSpec;
 
+/**
+ * Lobby Talk — one screen of a "quarter in review" that runs on a lobby wall
+ * between meetings: a five-row adoption chart over the same slow haze and
+ * dust the whole talk shares. The words are the point, so every text layer
+ * declares `role: 'read'` — the opt-in that turns on `adviseSpec`'s
+ * legibility advisories (`text-legibility` against the ground *and* the
+ * brightest additive layer that can sit under a line, `text-safe-area` for
+ * the bezel zone). Tuned to zero advisories: the haze is bright enough to
+ * matter and dim enough to leave every label above 4.5:1 at its peak.
+ *
+ * Schema exercises: `role: 'read'` on both `textBlock` and `text`, a
+ * `list`-laid chart in three layers (labels, `bar`s, readouts), additive
+ * atmosphere (`lighter` soft circles with `pulse`) under readable copy.
+ * Steer `bars.sprite.values` to change the numbers live.
+ */
+declare const LOBBY_TALK_SPEC: SaverSpec;
+
 /**
  * Sakura Drift: cherry-blossom petals carried on a spring twilight breeze.
  * Glow-up pass (v1-ceiling features): petals ride `wander` harmonics with shared
@@ -1467,7 +1733,7 @@ declare const FACETS_SPEC: SaverSpec;
  * Relay Board — a six-row status chart in five layers instead of twenty-five.
  * One `list` of labels, one `list` of `bar`s whose lengths are the numbers,
  * one `list` of readouts, a title block, and a slow dust field behind so the
- * board reads as a live wall, not a document. Steer `bars.values` and the
+ * board reads as a live wall, not a document. Steer `bars.sprite.values` and the
  * bars glide to the new figures; the labels never move.
  */
 declare const RELAY_BOARD_SPEC: SaverSpec;
@@ -1508,4 +1774,4 @@ declare const EXAMPLE_SPECS: SaverSpec[];
 /** Lookup by saver id. */
 declare const EXAMPLE_BY_ID: Readonly<Record<string, SaverSpec>>;
 
-export { AQUARIUM_SPEC, AURORA_SPEC, type BackgroundDrift, type BackgroundSpec, type BandSpec, COHESION_T, COMETS_SPEC, CONSTELLATION_SPEC, type CohesionRead, type CycleSpec, DASHBOARD_SPEC, type DominanceEntry, EXAMPLE_BY_ID, EXAMPLE_SPECS, type Entity, FACETS_SPEC, type GradientStop, HAIKU_SPEC, type IdleSequence, LANTERNS_SPEC, LIMITS, type LayerCohesion, type LayerMotionStats, type LayerSnapshot, type LayerSpec, type LinkEdge, type LuminanceGrid, type LuminanceGridOptions, MATRIX_RAIN_SPEC, type MotionEase, type MotionSpec, NOSTALGHIA_CANDLE_SPEC, ORRERY_SPEC, PINGS_SPEC, POLYGONS_SPEC, PROCESSION_SPEC, type PerceiveOptions, type Placed, RAIN_SPEC, RELAY_BOARD_SPEC, type ResolveOptions, type ResolvedSegment, type RevealState, SAKURA_SPEC, SCHEMA_EXAMPLES, SCHEMA_VERSION, SNOWFALL_SPEC, type SaverSpec, type SceneDescription, type SceneDiff, type ScenePerception, type SceneSnapshot, type SchemaExample, type SequenceSegment, type SequenceTransition, type SpecError, type SpecWarning, type SpriteSpec, type SteerDelta, type TextBlockLine, type TextRevealInput, type TextRevealSpec, type TextSpriteInfo, type ValidationResult, WARP_NEAR, WARP_TUNNEL_SPEC, type WanderOsc, adviseSequence, adviseSpec, alphaAt, applyDeltasToSpec, assertValidSequence, assertValidSpec, breakTextBlock, buildEntities, cohesionOf, compileSaver, compileSequence, describeScene, diffScenes, dominanceRanking, easeSmooth, emitEnvelope, emitWindow, graphemeClusters, headingAt, layerCohesion, lerpSpec, lifeAlphaAt, linkEdges, linkPairs, luminanceGrid, manifestFor, motionStats, perceiveScene, positionAt, renderBrailleMap, renderDensityMap, resolveSegment, resolveSpecPath, revealState, rotationAt, seamCauseOf, seamsWorthWarning, segmentStart, sizeAt, spriteIndexAt, spriteVariants, steerablePaths, structuralSignature, textSprites, textWidthEm, validateSequence, validateSpec };
+export { AQUARIUM_SPEC, AURORA_SPEC, type BackgroundDrift, type BackgroundSpec, type BandSpec, COHESION_T, COMETS_SPEC, CONSTELLATION_SPEC, type CohesionRead, type CycleSpec, DASHBOARD_SPEC, type DominanceEntry, EXAMPLE_BY_ID, EXAMPLE_SPECS, type Entity, FACETS_SPEC, type GradientStop, HAIKU_SPEC, type IdleSequence, LANTERNS_SPEC, LIMITS, LOBBY_TALK_SPEC, type LayerCohesion, type LayerMotionStats, type LayerSnapshot, type LayerSpec, type LinkEdge, type LuminanceGrid, type LuminanceGridOptions, MATRIX_RAIN_SPEC, type MotionEase, type MotionSpec, NOSTALGHIA_CANDLE_SPEC, ORRERY_SPEC, PINGS_SPEC, POLYGONS_SPEC, PROCESSION_SPEC, type PerceiveOptions, type PerceiveSequenceOptions, type Placed, RAIN_SPEC, RELAY_BOARD_SPEC, type ResolveOptions, type ResolvedSegment, type RevealState, SAKURA_SPEC, SCHEMA_EXAMPLES, SCHEMA_VERSION, SNOWFALL_SPEC, type SaverSpec, type SceneDescription, type SceneDiff, type ScenePerception, type SceneSnapshot, type SchemaExample, type SequenceFramePerception, type SequenceMountContext, type SequenceSegment, type SequenceTransition, type SpecError, type SpecWarning, type SpriteSpec, type SteerDelta, type TextBlockAnchor, type TextBlockLine, type TextMetricsClass, type TextRevealInput, type TextRevealSpec, type TextRole, type TextSpriteInfo, type ValidationResult, WARP_MAX_SCALE, WARP_NEAR, WARP_TUNNEL_SPEC, type WanderOsc, type WarningBox, adviseSequence, adviseSpec, alphaAt, applyDeltasToSpec, assertValidSequence, assertValidSpec, bedRenderSeed, breakTextBlock, buildEntities, canMorph, cohesionOf, compileSaver, compileSequence, describeScene, diffScenes, dominanceRanking, easeSmooth, emitEnvelope, emitWindow, graphemeClusters, headingAt, layerCohesion, lerpSpec, lifeAlphaAt, linkEdges, linkPairs, luminanceGrid, manifestFor, morphChainRoot, morphNothingMorphable, motionStats, normalizeSeed, perceiveScene, perceiveSequenceFrame, positionAt, renderBrailleMap, renderDensityMap, resolveSegment, resolveSpecPath, revealState, rotationAt, seamCauseOf, seamsWorthWarning, segmentRenderSeed, segmentStart, sequenceSteerablePaths, sizeAt, spriteIndexAt, spriteVariants, steerablePaths, structuralSignature, textBlockAnchorOffset, textMetricsClassFor, textSprites, textStringsDiffer, textStringsOf, textWidthEm, validateSequence, validateSpec };