@weasel-js/core 1.6.1 → 1.7.1

package/dist/{builtins-HWyuLzE-.d.ts → builtins-BSUfH8nU.d.ts}

@@ -1,15 +1,85 @@
-import { GradStop, ColorSpace, TextureHandle, FillStyle, Stroke, ScreenLength } from '@weasel-js/paint';
-import { NodeId, Bounds, View, SelectionApi, ActionDeps, IngestItem, DragSample, Point2 } from '@weasel-js/routing';
-import { P as Path } from './path-JEV2c5If.js';
-import { ResolvedRun, TextStyle, TextVerticalAlign } from '@weasel-js/text';
-import { Mat3 } from '@weasel-js/geom';
+import { G as GlMat3, a as ShaderProgramHandle, b as ShaderUniform, c as ShaderProgram } from './registerProgram-ateHDGjw.js';
+import { Mesh } from '@weasel-js/geom/tessellate';
+import { GradStop, ColorSpace, FillStyle, Stroke, ScreenLength } from '@weasel-js/paint';
+import { NodeId, Bounds, View, ModifierState, SelectionApi, ActionDeps, IngestItem, DragSample, DebugSink, Point2, LongPressState, AnyToolOf, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, Tool as Tool$1, ToolDef as ToolDef$1 } from '@weasel-js/routing';
+import { Path, EasingSpec, SpringPresetName, PolygonPath, Rect, Mat3 } from '@weasel-js/geom';
 import { ReactNode } from 'react';
 import * as _weasel_js_history from '@weasel-js/history';
 import { Op, History, SerializedHistory } from '@weasel-js/history';
-import { a as SceneAdapter, L as LayoutStrategy, b as LayoutDropTargetMode, I as InsertAdapter } from './types-CxC8P6W0.js';
-import { P as PoseDescriptor } from './poseDescriptor-rZa9W5hJ.js';
-import { ActiveToolContextValue } from '@weasel-js/routing/react';
-import { B as BoundsConstraint, P as PointSnapBehavior } from './types-D_74YlWs.js';
+import { L as LayoutStrategy, a as ParallaxOpts, C as ContainerBounds, b as SceneAdapter, P as PlaneMap, R as RegionPickView, c as LayoutDropTargetMode, d as ReflowTransition, I as InsertAdapter } from './types-CA54-mAZ.js';
+import { FontStyle } from '@weasel-js/font';
+import { ResolvedRun, TextStyle, TextVerticalAlign, StyledRun } from '@weasel-js/text';
+import { P as PoseDescriptor } from './poseDescriptor-CjSXMf8X.js';
+import { ActiveToolContextValue, ToolsApi as ToolsApi$1, UseToolsOptions as UseToolsOptions$1 } from '@weasel-js/routing/react';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './types-DSjd6W3n.js';
+import { CursorSpec } from '@weasel-js/cursor';
+import { ClaimableGesture } from '@weasel-js/gestures';
+
+/**
+ * Folding a node's pose up its parent chain to world, and back down. Lives
+ * under `core/` so the scene can lay out in world without reaching up into
+ * `features/`; `features/groups/composePose` re-exports all of it.
+ */
+/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */
+interface PoseAdapter<TPose> {
+    getPose(id: string): TPose;
+    getParent(id: string): string | null;
+    /** Whether `id`'s pose is a frame its children are expressed in. Absent
+     *  means every node is one. A container whose pose derives from its children
+     *  is not: its children share its frame, so the fold passes over it. */
+    definesFrame?(id: string): boolean;
+}
+/**
+ * The transforms a `compose` represents **exactly**. A parent transform wider
+ * than its strategy's closure is rounded to the nearest pose — for `'rigid'`
+ * that means an anisotropically scaled parent turns a rotated child into a
+ * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the
+ * shear is dropped.
+ *
+ * Measured over 50,000 random parent/child pairs: rotation and translation
+ * compose to within 5.7e-13, anisotropic scale to a right-angle error of 0.99.
+ * See `docs/superpowers/specs/2026-09-10-group-as-frame-design.md`.
+ */
+type PoseClosure = 'identity' | 'translation' | 'rigid';
+/** Consumer's pose-composition strategy for hierarchical scenes. `compose`
+ *  folds a child's pose (in parent's frame) up to the next frame; `decompose`
+ *  is its inverse. Default is IDENTITY — an absolute-pose scene where every
+ *  node already stores world coords (parent is grouping-only, no transform). */
+interface PoseComposition<TPose> {
+    compose: (parent: TPose, child: TPose) => TPose;
+    decompose: (parent: TPose, world: TPose) => TPose;
+    closure: PoseClosure;
+}
+/** Default pose-composition strategy: IDENTITY. Both `compose` and
+ *  `decompose` return the child/world pose unchanged, modeling an
+ *  absolute-pose scene where every node stores world coords and parents are
+ *  grouping-only (no transform). With this strategy `composeWorldPose`
+ *  returns a node's own raw pose and `rebaseLocalPose` is a no-op. */
+declare const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown>;
+/**
+ * Walk `id`'s parent chain (root first to id last) and fold local poses into
+ * a world pose via `compose`. Returns the world pose for `id`. Cycle-safe:
+ * a visited-set guard breaks if the chain ever loops back to itself.
+ *
+ * `compose(parent, child)` interprets `child` as expressed *in `parent`'s
+ * local frame* and returns the equivalent pose in the next frame up. For a
+ * standard translation-only rect: `world = { x: p.x + c.x, y: p.y + c.y,
+ * width: c.width, height: c.height }`.
+ */
+declare function composeWorldPose<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
+/**
+ * Convert `worldPose` into a local pose expressed under `newParentId`'s
+ * frame. Used when reparenting so the child's visual world position is
+ * preserved despite the change of frame. Inverse of one `compose` step.
+ *
+ * `decompose(parent, world)` returns the local pose `child` such that
+ * `compose(parent, child) === world`. For axis-aligned rects:
+ * `child = { ...world, x: world.x - parent.x, y: world.y - parent.y }`.
+ *
+ * Pass `newParentId === null` for the root frame; the function returns
+ * `worldPose` unchanged.
+ */
+declare function rebaseLocalPose<TPose>(adapter: PoseAdapter<TPose>, worldPose: TPose, newParentId: string | null, compose: (parent: TPose, child: TPose) => TPose, decompose: (parent: TPose, world: TPose) => TPose): TPose;
 
 /**
  * Axis-aligned rectangle pose with optional rotation. The canonical pose
@@ -56,6 +126,12 @@ interface DerivedDep<TPose> {
      *  about costs nothing. */
     readonly path: Path | null;
 }
+/** Computes a node's path from its dependencies: the type of a node's
+ *  `derivePath` and of each entry in `SceneRegistry.derivePath`. */
+type DerivePathFn<TPose> = (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => Path | null;
+/** Computes a node's pose from its dependencies: the type of a node's
+ *  `derivePose` and of each entry in `SceneRegistry.derivePose`. */
+type DerivePoseFn<TPose> = (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null;
 interface NodeBase<TData, TLayer extends string, TPose> {
     id: NodeId;
     layer: TLayer;
@@ -93,7 +169,7 @@ interface NodeBase<TData, TLayer extends string, TPose> {
      *  `node` is deliberately widened: naming `TData`/`TLayer` here puts them in
      *  a contravariant position, making `Scene` invariant in both and breaking
      *  assignment kit-wide. The cost is that a `derivePath` casts to read `node.data`. */
-    derivePath?: (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => Path | null;
+    derivePath?: DerivePathFn<TPose>;
     /** Computes this node's pose from its dependencies' poses, the same way
      *  `derivePath` computes its path — same `dependsOn` list, same widened
      *  `node`, same registry-keyed serialization.
@@ -107,7 +183,7 @@ interface NodeBase<TData, TLayer extends string, TPose> {
      *  Returning `null` means "I have nothing to derive from right now", and
      *  the node falls back to its authored `pose`. `setPose` on a derived node
      *  still writes that authored pose; it is simply not what anything reads. */
-    derivePose?: (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null;
+    derivePose?: DerivePoseFn<TPose>;
 }
 /** A node with no children — a shape, a label, an image. */
 interface LeafNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
@@ -125,6 +201,33 @@ interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends
      *  renderer rasterizes the returned path into the stencil buffer and
      *  paints descendants only where it covers. */
     clipFromPose?: (pose: TPose) => Path | null;
+    /** How this container arranges its children. Whenever the container's
+     *  child set or order changes, or its bounds change size, the scene hands
+     *  the change to the strategy — `depart` for children that left it,
+     *  `arrive` for children that joined it, `childPoses` otherwise — and records the poses it writes in the same
+     *  undo entry as the change. A drag reads it too: it is the layout `move`
+     *  reflows and drops against. */
+    layout?: LayoutStrategy<TPose>;
+}
+/** A pose a container's layout wrote — reported by {@link Scene.onReflow} —
+ *  in the node's stored frame. */
+interface LayoutMove<TPose> {
+    id: NodeId;
+    from: TPose;
+    to: TPose;
+}
+/** How a scene reads a laid-out container's bounds and folds poses to the
+ *  world frame a {@link LayoutStrategy} works in. */
+interface LayoutFrame<TPose> {
+    /** The container's bounds, from its world pose. Default: the pose's own
+     *  `x`/`y`/`width`/`height`; a pose without them is not laid out. */
+    bounds?(pose: TPose): ContainerBounds | null;
+    /** `pose` resized from bounds `from` to `to`, for a layout that grows its
+     *  container. Default: `to`'s fields written over the pose. */
+    remap?(pose: TPose, from: ContainerBounds, to: ContainerBounds): TPose;
+    /** Omit for the absolute-pose model. A scene whose canvas composes poses
+     *  (`<SceneCanvas poseComposition>`) passes the same strategy here. */
+    composition?: PoseComposition<TPose>;
 }
 /** A node in the scene tree: either a leaf or a container. Re-exported
  *  publicly as `SceneNode`, to avoid colliding with the DOM's `Node`. */
@@ -133,6 +236,10 @@ interface LayerRecordBase<TLayer extends string> {
     id: TLayer;
     visible: boolean;
     locked: boolean;
+    /** Draw this layer as a parallax plane: through a view derived from the
+     *  camera's (see `deriveParallaxView`), and picked through the same one.
+     *  Absent means the layer moves with the camera. */
+    parallax?: ParallaxOpts;
 }
 /** A layer declared when the scene was created. Fixed set, no display name —
  *  these are the kit's own render bands, not something a user manages. */
@@ -168,9 +275,11 @@ interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
     dependsOn?: readonly NodeId[] | 'children';
     /** Mirrors `SceneNode.derivePath`. Taken as a live function; its registry key is
      *  looked up from it, never passed in. */
-    derivePath?: (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => Path | null;
+    derivePath?: DerivePathFn<TPose>;
     /** Mirrors `SceneNode.derivePose`, on the same terms as `derivePath`. */
-    derivePose?: (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null;
+    derivePose?: DerivePoseFn<TPose>;
+    /** Mirrors `ContainerNode.layout`; ignored for leaves. */
+    layout?: LayoutStrategy<TPose>;
 }
 /** A custom scene mutation registered with `Scene.registerOp`: how to apply
  *  it and how to undo it. The pair is what makes it participate in history. */
@@ -183,6 +292,8 @@ interface SystemLayerSpec<TLayer extends string> {
     id: TLayer;
     visible?: boolean;
     locked?: boolean;
+    /** See `LayerRecord.parallax`. */
+    parallax?: ParallaxOpts;
 }
 /** Argument to `Scene.addLayer`. Always produces a `UserLayerRecord`
  *  (`kind: 'user'`). */
@@ -193,6 +304,8 @@ interface AddLayerSpec<TLayer extends string> {
     visible?: boolean;
     /** Default `false`. */
     locked?: boolean;
+    /** See `LayerRecord.parallax`. */
+    parallax?: ParallaxOpts;
     /** Render-stack position. Default: top of stack (highest render index). */
     index?: number;
 }
@@ -237,6 +350,8 @@ interface SerializedNode<TData, TLayer extends string, TPose> {
     derivePathKey?: string;
     /** Registry key for the node's `derivePose` function. Omitted when it has none. */
     derivePoseKey?: string;
+    /** Registry key for the container's layout strategy. Omitted when it has none. */
+    layoutKey?: string;
 }
 /** Per-scene registry mapping string keys to live function references.
  *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
@@ -245,10 +360,33 @@ interface SceneRegistry<TPose> {
     /** Maps registry keys to `clipFromPose` factory functions for container nodes. */
     clipFromPose?: Readonly<Record<string, (pose: TPose) => Path | null>>;
     /** Maps registry keys to `derivePath` functions for nodes with `dependsOn`. */
-    derivePath?: Readonly<Record<string, (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => Path | null>>;
+    derivePath?: Readonly<Record<string, DerivePathFn<TPose>>>;
     /** Maps registry keys to `derivePose` functions for nodes with `dependsOn`. */
-    derivePose?: Readonly<Record<string, (node: Node<unknown, string, TPose>, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null>>;
+    derivePose?: Readonly<Record<string, DerivePoseFn<TPose>>>;
+    /** Maps registry keys to container layout strategies. */
+    layout?: Readonly<Record<string, LayoutStrategy<TPose>>>;
 }
+/**
+ * Decides what one edit's changes to containers do to their children.
+ * `arrivals` maps each container to the ids that joined it — by an `add`
+ * under it or a `move` into it, whatever op or call made them — in the order
+ * they arrived. `changed` names every container whose child set or order
+ * changed, or whose pose changed size, arrivals included. Both are read once
+ * the edit's other mutations have landed.
+ *
+ * Return the poses to write, in each node's stored frame; they become part of
+ * the same edit, and so of the same undo step. An empty map writes nothing.
+ * Return `null` to refuse: the whole edit is reverted (see
+ * `SceneArrivalRefused`).
+ *
+ * Runs only for live edits. Undo, redo and a restored history replay the
+ * arrangement that was decided the first time. With none installed, a scene
+ * holding declared layouts (`ContainerNode.layout`) runs its own.
+ */
+type SceneArrivalHandler<TPose> = (arrivals: ReadonlyMap<NodeId, readonly NodeId[]>, changed: ReadonlySet<NodeId>, 
+/** The nodes that left each container in the edit, by the container they
+ *  left — removed, or moved out. */
+departures: ReadonlyMap<NodeId, readonly NodeId[]>) => ReadonlyMap<NodeId, TPose> | null;
 /** Options for `useScene` — the layers the scene has, what it starts out
  *  holding, and how its history behaves. */
 interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
@@ -268,6 +406,8 @@ interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
     /** Per-scene registry for non-serializable function fields (clipFromPose, etc.).
      *  Required only when serializing/deserializing scenes that use function fields. */
     registry?: SceneRegistry<TPose>;
+    /** How laid-out containers are measured. See {@link LayoutFrame}. */
+    layoutFrame?: LayoutFrame<TPose>;
     /** When supplied, `scene.applyOps(ops, label)` consults this on every call.
      *  If it returns a non-null `Journal`, ops are routed to the journal's
      *  `applyBatch` instead of recording a new parent-history entry. The journal
@@ -357,6 +497,13 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  entries over the kit's. */
     readonly registry: SceneRegistry<TPose>;
     get(id: NodeId): Node<TData, TLayer, TPose> | undefined;
+    /** A token for the node `id` names right now, for telling one node from a
+     *  later one that reuses its id. It holds for as long as the node stays in
+     *  the scene, whatever edits it takes, and is different every time the id
+     *  enters the scene — by `add`, by an undo or redo that brings it back, or
+     *  by `loadState`. `undefined` when `id` is not in the scene. Compare tokens
+     *  for equality only; their order means nothing. */
+    incarnation(id: NodeId): number | undefined;
     childrenOf(id: NodeId): readonly NodeId[];
     ancestorsOf(id: NodeId): readonly NodeId[];
     renderOrder(): Iterable<NodeId>;
@@ -424,6 +571,16 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  **No-op elision** — declaring what the node already declares does nothing
      *  and pushes no history entry. */
     setDependsOn(id: NodeId, dependsOn: readonly NodeId[] | 'children' | undefined): void;
+    /** Give container `id` a different layout — a strategy, its key in
+     *  `SceneRegistry.layout`, or `null` for none — and re-arrange its children
+     *  under it, as one undoable step. Throws for a leaf, or a key the registry
+     *  does not hold. A registered layout is recorded by its key, so a
+     *  serialized history restores it; an unregistered one lives only as long
+     *  as the session.
+     *
+     *  **No-op elision** — setting the layout a container already has does
+     *  nothing and pushes no history entry. */
+    setLayout(id: NodeId, layout: LayoutStrategy<TPose> | string | null): void;
     /** Reparent `id` under `parent` (or to a root when `parent` is `null`) at
      *  `index` within the new sibling list, appending when `index` is omitted.
      *  Siblings are reindexed. Recorded as one undoable step.
@@ -447,6 +604,10 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  drops them, and every node mutation on them throws. Locking is never
      *  blocked by the lock, and neither are the other layer operations. */
     setLayerLocked(layer: TLayer, locked: boolean): void;
+    /** Set or clear (`undefined`) a layer's parallax — see
+     *  `LayerRecord.parallax`. Undoable; an animation tweening it writes inside
+     *  {@link Scene.untracked} so no frame becomes an undo step. */
+    setLayerParallax(layer: TLayer, parallax: ParallaxOpts | undefined): void;
     /** Whether `id` sits on a locked layer or under a container that does.
      *  A container's lock covers its whole subtree, whatever layers the
      *  descendants are tagged to. An id not in the scene is not locked. */
@@ -474,6 +635,11 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  Pass `null` to detach. Overrides any `getActiveJournal` set in
      *  `UseSceneOptions`. */
     setActiveJournalAccessor(fn: (() => _weasel_js_history.Journal | null) | null): void;
+    /** Install what the scene does when nodes join a container, replacing any
+     *  handler installed before; `null` removes it. Returns a function that
+     *  removes this handler, and does nothing once another has replaced it.
+     *  See {@link SceneArrivalHandler}. */
+    setArrivalHandler(handler: SceneArrivalHandler<TPose> | null): () => void;
     /** Apply a batch of ops with journal-aware routing.
      *
      *  - **Without active journal** (or no `getActiveJournal` in options):
@@ -517,6 +683,13 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
     canUndo(): boolean;
     canRedo(): boolean;
     batch<T>(label: string, fn: () => T): T;
+    /** The layout container `id` declares, or `null` for a leaf or a
+     *  container that declares none. */
+    layoutOf(id: NodeId): LayoutStrategy<TPose> | null;
+    /** Called with the poses each live edit's layout pass wrote, after the
+     *  edit lands — never for an undo or redo, which restore poses rather than
+     *  arrange them. What a reflow animation glides from. */
+    onReflow(listener: (moves: readonly LayoutMove<TPose>[]) => void): () => void;
     /** Run `fn` with every mutation applied but none recorded — for writes
      *  that are not edits, such as a simulation stepping poses each frame.
      *  Undo and redo move between recorded states and never restore an
@@ -631,64 +804,6 @@ interface FitViewToBoundsOptions {
  */
 declare function fitViewToBounds(bounds: Bounds, viewportDims: ViewportDims, currentView: View, opts?: FitViewToBoundsOptions): View;
 
-/**
- * Minimal compile/link/lookup wrapper for a GL program. Throws
- * `ShaderCompileError` on compile or link failure with the GL info log
- * embedded in the error message — never returns a half-initialized program.
- *
- * Designed so test code can stub `getShaderParameter` / `getProgramParameter`
- * via the recorder Proxy without further special-casing.
- */
-type Stage = 'vertex' | 'fragment' | 'link';
-/** Thrown when a shader fails to compile or link, carrying which stage failed
- *  and the driver's log. */
-declare class ShaderCompileError extends Error {
-    readonly stage: Stage;
-    readonly log: string;
-    constructor(stage: Stage, log: string);
-}
-declare class ShaderProgram {
-    private readonly gl;
-    readonly handle: WebGLProgram;
-    private readonly uniforms;
-    private readonly attributes;
-    constructor(gl: WebGL2RenderingContext, vertSrc: string, fragSrc: string);
-    private compile;
-    lookupUniforms(names: readonly string[]): void;
-    lookupAttributes(names: readonly string[]): void;
-    uniform(name: string): WebGLUniformLocation | undefined;
-    attribute(name: string): number | undefined;
-}
-
-/**
- * A tessellated representation of a Path, ready to upload to GL.
- *
- * - `vertices` is interleaved x,y in path-local coordinates (`Float32Array`
- *   of length `2 * vertexCount`).
- * - `indices` are triangle indices into `vertices` (`Uint32Array`, length
- *   `3 * triangleCount`).
- * - `requiresStencil` is set for paths whose fillRule is `'evenodd'` and
- *   whose triangulation is a *naive* per-contour fan rather than a clean
- *   inside/outside triangulation. The renderer must use a stencil
- *   two-pass when this flag is true. Single-contour paths and `'nonzero'`
- *   multi-contour paths leave it false.
- * - `anchorA` / `anchorB` / `anchorT` parameterize each mesh vertex by
- *   the two consecutive path anchors it lies between and the arc-length
- *   fraction along that segment (0 = at A, 1 = at B). Vertices that fall
- *   exactly on an anchor set A === B and t = 0. Used at draw time when
- *   the DrawCommand supplies per-anchor colors so the renderer can lerp
- *   per mesh vertex. Optional — emitted by the path tessellators; absent
- *   on meshes built by other paths (e.g. text glyphs).
- */
-interface Mesh {
-    readonly vertices: Float32Array;
-    readonly indices: Uint32Array;
-    readonly requiresStencil?: boolean;
-    readonly anchorA?: Uint32Array;
-    readonly anchorB?: Uint32Array;
-    readonly anchorT?: Float32Array;
-}
-
 interface GLMeshHandle {
     readonly vao: WebGLVertexArrayObject;
     readonly indexCount: number;
@@ -738,7 +853,10 @@ declare class GLMeshCache {
     /** Meshes this context has drawn at least once; see `uploadRecurring`. */
     private readonly seen;
     private readonly finalizer;
+    /** Every persistent upload not yet freed, so `dispose` can reach them. */
+    private readonly persistent;
     private readonly pendingDeletes;
+    private disposed;
     /** Transient resources allocated this frame; freed at end of render(). */
     private readonly transientThisFrame;
     constructor(gl: WebGL2RenderingContext, aPositionLoc: number);
@@ -772,6 +890,13 @@ declare class GLMeshCache {
      * Called by the renderer at the top of each `render()`, before any draws.
      */
     drainPendingDeletes(): void;
+    /**
+     * Free every GL resource this cache holds — persistent, pending and
+     * transient — and ignore finalizers from here on. Idempotent. Unlike the
+     * other paths this does not wait on GC, which is what lets a renderer on a
+     * context it does not own give back everything it uploaded.
+     */
+    dispose(): void;
     /** @internal — for tests asserting the queue size. */
     _pendingDeleteCount(): number;
     /** @internal — for tests that need to simulate the finalizer firing. */
@@ -830,7 +955,7 @@ declare class GLTextureCache {
  * Key: ImageBitmap (or pattern source object) identity (WeakMap) — lets GC
  * reclaim unreferenced bitmaps. The GL textures are NOT freed when the source
  * is gc'd; a source's owner that knows it will never be drawn again frees them
- * with {@link releaseImageSource}.
+ * with {@link releaseImageSource}, and `dispose` frees them all.
  *
  * Wrapping is set once at upload time per the `repetition` parameter:
  *   - undefined / 'no-repeat' → CLAMP_TO_EDGE
@@ -850,6 +975,9 @@ declare class GLImageCache {
     /** This context's `MAX_TEXTURE_SIZE`. */
     readonly maxTextureSide: number;
     private readonly map;
+    /** Every texture `map` holds, so `dispose` can reach them — a WeakMap
+     *  cannot be enumerated. */
+    private readonly textures;
     /**
      * MAG_FILTER each texture currently carries, so a redundant write can be
      * skipped.
@@ -876,9 +1004,12 @@ declare class GLImageCache {
     constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
     /** Delete `key`'s texture, if it has one. */
     release(key: object): void;
-    /** Stop answering {@link releaseImageSource} and {@link maxImageTextureSide}.
-     *  Call when the context is disposed or lost. */
+    /** Delete every texture this cache uploaded and stop answering
+     *  {@link releaseImageSource} and {@link maxImageTextureSide}. Idempotent. */
     dispose(): void;
+    /** {@link dispose} without the deletes, for a cache whose context was lost:
+     *  its textures died with it. */
+    abandon(): void;
     upload(key: object, source: TexSource, repetition?: PatternRepetition): WebGLTexture;
     bind(key: object, unit: number): void;
     /** Set `key`'s MAG_FILTER, skipping the call when it already holds that
@@ -967,70 +1098,6 @@ declare class GradientRampAtlas {
     private writeRow;
 }
 
-/**
- * 2D affine matrix utilities. Column-major 9-element Float32Array, matching
- * `WebGL2RenderingContext.uniformMatrix3fv` byte order so we can pass the
- * array directly without a transpose flag.
- *
- * Layout (column-major):
- *   [m00, m10, 0,
- *    m01, m11, 0,
- *    tx,  ty,  1]
- *
- * `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,
- *                                              m10*x + m11*y + ty]`.
- */
-
-type GlMat3 = Float32Array;
-declare function identity(): GlMat3;
-declare function multiply(out: GlMat3, m: GlMat3): GlMat3;
-/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`
- *  constructs a fresh matrix. */
-declare function translated(m: GlMat3, tx: number, ty: number): GlMat3;
-/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */
-declare function scaled(m: GlMat3, sx: number, sy: number): GlMat3;
-/** This layout read as the kernel's 6-element affine. The two carry the same
- *  logical order, so the conversion is a repack and nothing else — it exists
- *  so the repack has a name instead of appearing inline at each crossing. */
-declare function toAffine(m: GlMat3): Mat3;
-/** The kernel's affine in this layout. The inverse of {@link toAffine}, and
- *  what an `SvgGroupNode.transform` (also a kernel affine) becomes on its way
- *  to a `GroupDrawCommand`. */
-declare function fromAffine(a: Mat3): GlMat3;
-/** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`
- *  finds it singular — the same rule, read through this layout. */
-declare function invert(m: GlMat3): GlMat3 | null;
-declare function apply(m: GlMat3, x: number, y: number): [number, number];
-/**
- * Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
- * into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
- * matches clip-down).
- */
-declare function screenToClip(width: number, height: number): GlMat3;
-/**
- * Uniform-equivalent scale factor: the square root of the absolute
- * determinant of the linear part, i.e. the geometric mean of the two axis
- * scales. Rotation-invariant. Under non-uniform scale it is between the two
- * axes and exact on neither — the same compromise `meanScale` documents.
- */
-declare function meanScaleOf(m: GlMat3): number;
-/** The renderer's 3x3 matrix operations, as one namespace. These work on the
- *  9-element `Float32Array` form the GL uniform upload wants — distinct from
- *  `@weasel-js/geom`'s 6-element affine `GlMat3`, though the logical element
- *  order is the same. */
-declare const mat3: {
-    identity: typeof identity;
-    toAffine: typeof toAffine;
-    fromAffine: typeof fromAffine;
-    multiply: typeof multiply;
-    translated: typeof translated;
-    scaled: typeof scaled;
-    invert: typeof invert;
-    apply: typeof apply;
-    screenToClip: typeof screenToClip;
-    meanScaleOf: typeof meanScaleOf;
-};
-
 /** Row-major 4×5 color matrix identity. */
 declare const IDENTITY_COLOR_MATRIX: Float32Array<ArrayBuffer>;
 interface GroupFrame {
@@ -1069,66 +1136,6 @@ declare class GroupState {
     pop(): void;
 }
 
-/**
- * registerProgram — public API for registering custom shader programs.
- *
- * Stores raw GLSL source strings in a module-level registry. GL compilation
- * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which
- * calls getProgramSource() and compiles the result. This keeps registerProgram
- * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.
- *
- * Module-level state = source strings only; compiled GL
- * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).
- *
- * Lifecycle: program sources live for the module lifetime. No unregister in v1.
- */
-
-/** Opaque handle to a compiled custom shader program. */
-interface ShaderProgramHandle {
-    readonly id: string;
-}
-/**
- * Scalar and vector uniform types accepted by the custom shader uniform binder.
- *
- * | TS type                 | GL call                              |
- * |-------------------------|--------------------------------------|
- * | number                  | uniform1f                            |
- * | [n, n]                  | uniform2fv                           |
- * | [n, n, n]               | uniform3fv                           |
- * | [n, n, n, n]            | uniform4fv                           |
- * | Float32Array length 9   | uniformMatrix3fv (column-major)      |
- * | Float32Array length 16  | uniformMatrix4fv (column-major)      |
- * | TextureHandle           | bind to next tex unit + uniform1i    |
- */
-type ShaderUniform = number | [number, number] | [number, number, number] | [number, number, number, number] | Float32Array | TextureHandle;
-/**
- * Register a custom shader program by id.
- *
- * Pass an empty string for `vert` to use the kit's default vertex shader
- * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and
- * `v_world` varyings plus `u_bounds` and `u_view` uniforms.
- *
- * **IMPORTANT — Premultiplied alpha:**
- * Your fragment shader MUST output premultiplied alpha:
- *   `outColor = vec4(rgb * a, a);`  ← correct
- *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions
- *
- * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.
- * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.
- *
- * **Re-registration behavior:**
- * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id replaces
- *   the source (hot-reload). Each renderer must call `WeaselRenderer.registerProgram(handle)`
- *   again to pick up the new source.
- * - Prod mode: calling with an existing id throws.
- *
- * Actual GL compilation and `ShaderCompileError` throwing happen in
- * `WeaselRenderer.registerProgram()`, not here.
- *
- * @experimental API may break before v2.
- */
-declare function registerProgram(id: string, vert: string, frag: string): ShaderProgramHandle;
-
 /**
  * One full-screen pass over what a group has already drawn.
  *
@@ -1248,6 +1255,9 @@ interface TextDrawCommand {
     /** Wrap width. Absent never wraps. */
     maxWidth?: number;
     align?: 'left' | 'center' | 'right';
+    /** Spread each wrapped line across `width` — see `LayoutRunsOpts.justify`.
+     *  `align` then sets only the lines it does not spread. Default `false`. */
+    justify?: boolean;
     /** Box width `align` resolves within, from `x`. Default `maxWidth`; with
      *  neither, `x` is the line's left edge, midpoint or right edge. */
     width?: number;
@@ -1505,11 +1515,43 @@ declare class DrawBatch {
 /** How to construct a `WeaselRenderer`: the GL context or canvas to draw
  *  into, the output size, and the quality knobs that separate screen
  *  rendering from print. */
+/** A run of top-level commands, `[start, end)` by index, that
+ *  {@link WeaselRenderer.lastFrameStats} accounts for separately — one render
+ *  layer's commands, say. Spans are in order and do not overlap. */
+interface RenderSpan {
+    id: string;
+    start: number;
+    end: number;
+}
+/** Per-frame options for {@link WeaselRenderer.render}. */
+interface RenderOptions {
+    spans?: readonly RenderSpan[];
+}
+/** What one span cost. A batched run is drawn when something closes it, so
+ *  its draw call counts toward the span that closed it. */
+interface RenderSpanStats {
+    id: string;
+    drawCalls: number;
+    ms: number;
+}
+/** What one `render()` cost. See {@link WeaselRenderer.lastFrameStats}. */
+interface RenderStats {
+    drawCalls: number;
+    ms: number;
+    spans: RenderSpanStats[];
+}
+/** Construction options for {@link WeaselRenderer}. Pass `gl` or `canvas`;
+ *  a context passed in must have a stencil buffer. */
 interface WeaselRendererOptions {
+    /** A WebGL2 context to draw with. Wins over `canvas`. */
     gl?: WebGL2RenderingContext;
+    /** A canvas to open a stencil-backed WebGL2 context on, when `gl` is absent. */
     canvas?: HTMLCanvasElement;
+    /** Drawing size in CSS pixels. */
     width: number;
+    /** Drawing size in CSS pixels. */
     height: number;
+    /** Device pixels per CSS pixel. */
     dpr: number;
     /** MIN_FILTER strategy for image/pattern textures (`GLImageCache`).
      *  Default `'linear'` — the existing screen behavior. The headless
@@ -1566,17 +1608,23 @@ interface RenderTarget {
  */
 declare class WeaselRenderer {
     private readonly gl;
+    private stats;
     private pathFill;
     private pathFillVColor;
     private imageFill;
     private batchFill;
     private gradFill;
     private patternFill;
+    /** Compiled on first use: only atlas text under a texture paint needs one. */
+    private glyphPaintPrograms;
     private meshCache;
     private textureCache;
     private imageCache;
     private gradRamps;
     private programRegistry;
+    /** The source each compiled custom program was built from — or, after a
+     *  failed recompile, the source that failed, so it is not retried every frame. */
+    private programSources;
     private quadVbo;
     private quadIbo;
     private drawBatch;
@@ -1592,6 +1640,7 @@ declare class WeaselRenderer {
     /** Offscreen buffers for group effects. Allocates nothing until a group
      *  with effects asks, so a canvas without them pays no memory. */
     private readonly effectTargets;
+    private readonly paintScratch;
     private readonly imageMinification;
     private flattenTolerance?;
     private readonly bakeBudget;
@@ -1602,6 +1651,9 @@ declare class WeaselRenderer {
     /** True after `dispose()`. A disposed renderer ignores further `render()`
      *  calls and `registerProgram()` calls. */
     private disposed;
+    /** What registered paint kinds hang their GPU state on. One per context
+     *  generation: a restore releases it and opens the next. */
+    private paintResources;
     constructor(opts: WeaselRendererOptions);
     private uploadQuadGeometry;
     /**
@@ -1615,6 +1667,10 @@ declare class WeaselRenderer {
      * @experimental
      */
     registerProgram(handle: ShaderProgramHandle): void;
+    private installProgram;
+    /** Recompile every program whose module-level source was re-registered
+     *  since it was compiled. A source that fails keeps the old program drawing. */
+    private refreshPrograms;
     /**
      * The compiled program for `id`, compiling it against this context on first
      * use. Unlike {@link registerProgram} this neither throws on a missing
@@ -1622,6 +1678,7 @@ declare class WeaselRenderer {
      * never registered must decline the paint, not take down the frame.
      */
     private ensureProgram;
+    private glyphPaintProgram;
     /** The GL state every frame assumes. Applied per `render()` rather than once
      *  at construction because a co-tenant sharing this context moves all of it
      *  between our frames. */
@@ -1636,27 +1693,15 @@ declare class WeaselRenderer {
     isContextLost(): boolean;
     private onContextLost;
     private onContextRestored;
-    /** Free the GL resources this renderer itself owns and detach context-loss
+    /** Free every GL resource this renderer created and detach context-loss
      *  listeners when a canvas was supplied. Idempotent.
      *
-     *  Scope: built-in shader programs, any consumer-registered programs, the
-     *  shared quad/rect geometry, any in-flight transient meshes, and the
-     *  enumerable Map-keyed caches (`GLTextureCache` atlas/image textures,
-     *  `GradientRampAtlas`'s ramp texture) ARE freed.
-     *
-     *  NOT freed: `GLImageCache` (bitmap/pattern textures) and `GLMeshCache`'s
-     *  persistent per-Path mesh cache are keyed by `WeakMap`, not enumerable,
-     *  and are only reclaimed when the GL context itself goes away (cf.
-     *  `GLImageCache`'s own "deferred to v2" note). On a caller-owned
-     *  long-lived context — the headless render-to-pixels path hands the same
-     *  `gl` to many short-lived renderers — the image/pattern textures and
-     *  persistent Path meshes each renderer uploads DO accumulate across
-     *  renderer instances until the caller recycles the context.
-     *
-     *  Also: a Mesh that gets GC'd after `dispose()` still lands in
-     *  `GLMeshCache`'s `pendingDeletes` queue via its `FinalizationRegistry`,
-     *  but nothing drains that queue post-dispose (only `render()` does) —
-     *  those GL resources leak until the context goes away too.
+     *  That covers the built-in and consumer-registered programs (their shaders
+     *  go with them), the shared quad geometry, the batch, the effect targets,
+     *  and every cache: atlas and gradient-ramp textures, bitmap and pattern
+     *  textures, and meshes — transient, persistent, and those whose Path was
+     *  already collected. The context itself is left alone, so a caller-owned
+     *  context can host renderer after renderer without accumulating anything.
      *
      *  A disposed renderer ignores further `render()` and `registerProgram()`
      *  calls. */
@@ -1669,7 +1714,11 @@ declare class WeaselRenderer {
      * it — every other command carries its own transform in the stream, so
      * callers with no view concept can keep calling `render(commands)`.
      */
-    render(commands: DrawCommand[], viewMatrix?: GlMat3): void;
+    render(commands: DrawCommand[], viewMatrix?: GlMat3, opts?: RenderOptions): void;
+    /** What the last `render()` cost: GL draw calls issued and CPU milliseconds
+     *  spent issuing them, in total and per requested span. GPU time is not
+     *  measured; the GPU runs asynchronously. */
+    lastFrameStats(): RenderStats;
     /** Change the curve-flattening tolerance after construction. `undefined`
      *  restores the cached `DEFAULT_FLATTEN_TOLERANCE` route. */
     setFlattenTolerance(tolerance: number | undefined): void;
@@ -1774,6 +1823,547 @@ interface CullRect {
  */
 declare function cullDrawCommands(cmds: DrawCommand[], transform: GlMat3, rect: CullRect): DrawCommand[];
 
+/**
+ * Read-only state that affordances consult on every render and hit-test
+ * call. Built via `buildChromeState` and held across renders, so affordances
+ * must not cache anything they read from it.
+ */
+interface ChromeState {
+    /** Currently selected ids. Live; reflects useSelection's React state. */
+    readonly selection: readonly NodeId[];
+    /** True when the canvas is in multi-mode AND >= 2 ids are selected. */
+    readonly multiActive: boolean;
+    /** Bounds for any selection member id. Honors active-tool overlay state
+     *  (move/resize/rotate ghosts → ghost bounds; otherwise → committed
+     *  pose bounds). Returns null for unknown ids or ids whose bounds aren't
+     *  computable. */
+    boundsOf(id: string): Bounds | null;
+    /** Multi-union AABB when `multiActive`. Recomputed from `boundsOf` over
+     *  every selected id on each read, expanding rotated members to the extent
+     *  of their ink; null otherwise. */
+    readonly unionBounds: Bounds | null;
+    /** Active modifier state at the moment of the call. */
+    readonly modifiers: ModifierState;
+    /** True iff the node's pose-descriptor declares it can carry a rotation.
+     *  Affordances consult this to decide whether to expose rotate cursors /
+     *  drag-bands. Defaults to `true` when the descriptor doesn't declare
+     *  (back-compat) or when the id is unknown — the rotation gesture will
+     *  no-op visually for poses without AABB fields, but the affordance
+     *  doesn't lie about the cursor. Optional on the interface so unit-test
+     *  call sites that construct `ChromeState` by hand keep compiling;
+     *  affordances should treat an absent predicate as "true". */
+    canRotate?(id: string): boolean;
+}
+
+/**
+ * @experimental
+ * A single interactive piece of chrome. Pure functions; the kit composes
+ * multiple affordances into a single RenderLayer per tool via
+ * `composeAffordanceLayer`.
+ *
+ * Affordances declare interactive regions in a target's *local* frame.
+ * The framework (`composeAffordanceLayer`) composes the target's bounds
+ * transform (rotation around the AABB center, when present) for both paint
+ * and hit-test, so the affordance never touches rotation, view.scale, or
+ * world↔screen math.
+ */
+interface Affordance {
+    /** Stable id for debug overlays + visibility maps. */
+    id: string;
+    /** Enumerate this affordance's interactive regions. Each region lives in
+     *  some target id's local frame (or in the world frame when `targetId`
+     *  is `null`). Returning `[]` means "no chrome for this state" (no
+     *  selection, multi-mode disabled, etc.). */
+    regions(state: ChromeState): readonly AffordanceRegion[];
+    /** Optional non-interactive decoration (e.g., a leader line drawn from
+     *  a bounds edge to a handle — visual only, not draggable). Receives
+     *  raw state + view because the decoration may live outside any single
+     *  target's local frame. Most affordances leave this undefined. */
+    decorate?(state: ChromeState, view: View): DrawCommand[];
+}
+/**
+ * @experimental
+ * One interactive region produced by an affordance. The framework owns
+ * the local↔world transform for `targetId` (when non-null), so `shape`,
+ * `paint.sizePx`, and `hitRadiusPx` are always specified in coordinates
+ * the affordance can reason about directly.
+ */
+interface AffordanceRegion<TScratch = unknown> {
+    /** Stable id, e.g. `corner-min-min`. Used for debug overlays + a11y. */
+    id: string;
+    /** Target id whose `state.boundsOf(targetId)` defines this region's
+     *  local frame. `bounds.rotation` (if present) is the only transform
+     *  applied — translation is the AABB origin; scale is identity. Pass
+     *  `null` for affordances anchored to the viewport / world frame
+     *  (identity transform). */
+    targetId: string | null;
+    /** Region geometry, expressed in the target's local frame.
+     *
+     *  - `point` — square hit of half-extent `hitRadiusPx` screen pixels,
+     *    axis-aligned on screen unless `turned`. `standoff` pushes the anchor `px`
+     *    screen pixels off the edge whose outward normal (target-local) is
+     *    `normal`, measured along that normal as it lands on screen — for
+     *    chrome that floats a fixed distance off an edge at any zoom.
+     *  - `rect`  — axis-aligned rect (target rotation applies).
+     *  - `annulus` — outer ellipse minus inner rect cutout. Used for
+     *    invisible zones that sit *around* the AABB (e.g. rotate-on-
+     *    hover band). The outer ellipse is defined by world-space
+     *    semi-axes `rx` / `ry` around `(cx, cy)`; the inner rect is the
+     *    same target-local rect that defines the AABB. Hit-test:
+     *    inside outer ellipse AND outside inner rect. */
+    shape: {
+        kind: 'point';
+        x: number;
+        y: number;
+        hitRadiusPx: number;
+        standoff?: {
+            px: number;
+            normal: {
+                x: number;
+                y: number;
+            };
+        };
+        /** Turn the square to the target, at the angle the target's x axis
+         *  lands on screen (`screenAngleOf`) — for handles painted turned. */
+        turned?: boolean;
+    } | {
+        kind: 'rect';
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | {
+        kind: 'annulus';
+        /** Outer-ellipse center (target-local). */
+        cx: number;
+        cy: number;
+        /** Outer-ellipse semi-axes (target-local). */
+        rx: number;
+        ry: number;
+        /** Inner rect (target-local) — the cutout. Typically the
+         *  selection's AABB. */
+        innerX: number;
+        innerY: number;
+        innerWidth: number;
+        innerHeight: number;
+        /** Minimum band thickness outside the inner rect, in **screen**
+         *  pixels. The framework widens `rx`/`ry` to at least
+         *  `innerHalfExtent + pxExtent(minBandPx, view.scale)` on each axis
+         *  for both paint and hit-test.
+         *
+         *  This exists because the clamp has to know the view and the
+         *  affordance doesn't: `ChromeState` carries no scale. Expressing the
+         *  floor in world units instead (which is what the rotate ring used
+         *  to do) makes the band shrink on screen as you zoom in, until the
+         *  ring around a small shape is too thin to hover. */
+        minBandPx?: number;
+    };
+    /** Optional paint. World position is derived from `shape` + target
+     *  transform; visual size stays in screen pixels (so handles don't
+     *  warp under zoom or non-uniform scale). Omit for hit-only regions.
+     *
+     *  - `square` — small fixed-size square (only valid over `point` shapes).
+     *  - `annulus` — fill + stroke the annulus ring (only valid over
+     *    `annulus` shapes). Uses even-odd fill rule to punch the inner-rect
+     *    cutout.
+     *  - `custom` — emit arbitrary draw commands; receives a {@link CustomPaintContext}. */
+    paint?: {
+        kind: 'square';
+        sizePx: number;
+        fill?: FillStyle;
+        stroke?: Stroke;
+    } | {
+        kind: 'annulus';
+        fill?: FillStyle;
+        stroke?: Stroke;
+        insetPx?: number;
+    } | {
+        kind: 'custom';
+        draw: (ctx: CustomPaintContext) => DrawCommand[];
+    };
+    /** Discriminator a press on this region reports as `AffordanceHit.kind` —
+     *  the string routing specs match on (`'handle:top-left'`,
+     *  `'rotate-handle'`, `'anchor:3'`). Omit for regions that only exist
+     *  inside a consumer-registered layer, where the layer id is the
+     *  discriminator; `buildAffordanceAt` falls back to
+     *  `<affordanceId>:<regionId>`. */
+    hitKind?: string;
+    /** Cursor to show while hovering this region. Read by the hover-cursor
+     *  pump in `useGestureDispatcher` via `AffordanceHit.cursor`, which
+     *  `buildAffordanceAt` fills in from the region the walk landed on. */
+    cursor?: CursorSpec;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Read only when the affordance is composed into a
+     *  consumer-registered layer; kit chrome routes through
+     *  `buildAffordanceAt`, which reports `'shared'`. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+    /** Drag binding produced when this region is hit. Lazily called so
+     *  affordances don't pay binding-construction cost on every paint frame —
+     *  state snapshots (e.g., capturing per-leaf poses at click time) belong
+     *  inside `bind()`, not inside `regions()`. */
+    bind(): AffordanceBinding<TScratch>;
+}
+/** Context passed to a region's `paint.kind === 'custom'` draw callback.
+ *  Provides both the world-space anchor (already transformed) and the
+ *  original local shape, for affordances that want to do additional
+ *  geometry themselves. */
+interface CustomPaintContext {
+    /** World-space mapping of `shape`. For `point`, only `x`/`y` are set.
+     *  For `rect`, all four fields are set. */
+    world: {
+        x: number;
+        y: number;
+        width?: number;
+        height?: number;
+    };
+    /** The original local shape (same object identity as `region.shape`). */
+    local: AffordanceRegion['shape'];
+    view: View;
+    state: ChromeState;
+}
+/**
+ * @experimental
+ * Result of an affordance hit — what the region computed about itself.
+ *
+ * `initialScratch` is the payload: what the region already knows (which
+ * corner, which target id) so the action that picks up the drag doesn't
+ * re-derive it. `<SceneCanvas>` reads it out of the layer hit-test and packs
+ * it into `AffordanceHit`, which flows to the matching action through
+ * `InvocationCtx.drag.affordance`.
+ *
+ * This used to also carry a `drag: DragChannel` naming the handlers the
+ * tool-routing dispatcher should wire up. Every implementation supplied a
+ * no-op stub that claimed, because the real routing had already moved to
+ * bindings; the field went with that dispatcher.
+ */
+interface AffordanceBinding<TScratch = unknown> {
+    initialScratch?: TScratch;
+}
+/**
+ * The fields `buildAffordanceAt` lifts out of a region's `initialScratch`
+ * when it turns a region hit into an `AffordanceHit`.
+ *
+ * Scratch is otherwise opaque — whatever the affordance wants to hand the
+ * action that picks up the drag. These few names are the exception: they mean
+ * the same thing to every affordance, and the actions that consume them
+ * (`resizeAction`, `rotateAction`) read them off `AffordanceHit` rather than
+ * out of scratch. An affordance that doesn't set them simply produces a hit
+ * without those fields.
+ */
+interface CommonAffordanceScratch {
+    /** The node (or `MULTI_RESIZE_TARGET_ID`) this chrome acts on. Becomes
+     *  `AffordanceHit.targetIds`. */
+    targetId?: string;
+    /** For resize chrome: which corner stays pinned. Mirrors the kit's
+     *  `ResizeAnchor`, spelled inline so `affordances/` doesn't take a type
+     *  dependency on the gesture layer for one field. */
+    anchor?: {
+        x: 'min' | 'max' | 'free';
+        y: 'min' | 'max' | 'free';
+    };
+    /** World-space invariant point of the transform — the fixed corner for a
+     *  resize, the pivot for a rotation. */
+    fixedPoint?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * What a **registered layer's** `hitTest` returns. Extends `AffordanceBinding`
+ * so existing implementations keep typechecking; the added fields are how a
+ * consumer's own chrome says the things kit chrome says through
+ * `AffordanceRegion` — which cursor to show, and whether it owns the point
+ * outright.
+ */
+interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
+    /** Cursor while the pointer is over this hit. Reaches the hover-cursor
+     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
+    cursor?: CursorSpec;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Omitted means `'shared'` — today's behavior. Same name and
+     *  meaning as `AffordanceHit.strength`, which it becomes. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+}
+
+/**
+ * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
+ * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend
+ * supplies it explicitly so layers don't have to know about DPR.
+ */
+interface Dims {
+    width: number;
+    height: number;
+}
+/**
+ * What a layer's `draw` threw, and which layer threw it.
+ *
+ * A `draw` runs on the frame loop, so a throw that escapes it surfaces as an
+ * uncaught `requestAnimationFrame` error on the window and takes the whole
+ * frame with it — every other layer included. One broken layer painting
+ * nothing, named in the console, is the lesser wrong.
+ */
+interface LayerDrawFailure {
+    layerId: string;
+    error: unknown;
+}
+/**
+ * Several consecutive layers composited as one.
+ *
+ * A layer's own `effects` run over that layer alone, which is the wrong
+ * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not
+ * `blur(A) over blur(B)`, and it costs a buffer and a pass chain per layer. A
+ * group draws its members into one buffer, runs one chain over it, and
+ * composites the result back once.
+ *
+ * Membership is by `RenderLayer.id` — the same names `layerOrder` and
+ * `layerVisibility` use, not the `layers` map's slot keys.
+ *
+ * Only *consecutive* members share a buffer, because anything drawn between
+ * two members has to land between them. A group whose members are separated in
+ * the render order is drawn as one bracket per run, with a warning: the
+ * picture is right, the declaration almost certainly is not.
+ *
+ * This is a render-stack bracket, not a scene `ContainerNode` — it holds no
+ * ids, survives no reload, and nothing in the scene knows about it.
+ */
+interface LayerGroup {
+    /** Names the group in warnings; not a layer id and never drawn. */
+    id: string;
+    /**
+     * Member layer ids. Order here is ignored — the render order decides.
+     *
+     * A name claims that layer and every layer under it in the `:` namespace, so
+     * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers
+     * draws as — the same set `before`/`after: 'scene'` anchors against. The
+     * separator is required: `'scene'` does not reach `scenery`. A name matching
+     * no layer being drawn is warned about rather than ignored.
+     */
+    layers: readonly string[];
+    /**
+     * Passes over the group's combined pixels, in order. A thunk is re-read on
+     * every frame, so an animating radius costs no React render; an array is
+     * read once per frame either way.
+     */
+    effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);
+    /** Opacity applied to the group's composited result, not to each member. */
+    alpha?: number;
+    /** 4×5 color matrix (row-major, 20 numbers) applied to the composited
+     *  result. See `GroupDrawCommand.colorMatrix`. */
+    colorMatrix?: number[];
+}
+/** One layer's memoized output, keyed by layer id. Owned by the canvas that
+ *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */
+type LayerCommandCache = Map<string, {
+    deps: readonly unknown[];
+    cmds: DrawCommand[];
+}>;
+/**
+ * A single named render sub-layer within a canvas renderer.
+ *
+ * @template TData - The data object passed to each draw call.
+ */
+/** Something outside React whose changes a paint reads — a mode registry, a
+ *  scoping lookup. A notification repaints the canvas; the listener takes no
+ *  arguments and the returned function unsubscribes. */
+interface RedrawSource {
+    subscribe(listener: () => void): () => void;
+}
+/** The `subscribe` for a layer that draws `sources`: it notifies whenever any
+ *  of them does. A thunk is read when the subscription is made. Every layer
+ *  that draws other layers declares this, so wrapping never silences what
+ *  repaints a source. */
+declare function subscribeToSources(sources: readonly {
+    subscribe?: RedrawSource['subscribe'];
+}[] | (() => readonly {
+    subscribe?: RedrawSource['subscribe'];
+}[])): RedrawSource['subscribe'];
+/** One layer of a canvas: `draw` turns `data` and the view into draw commands;
+ *  the other fields control caching, visibility, coordinate space and hit-testing. */
+interface RenderLayer<TData> {
+    /** Unique identifier used in visibility maps and ordering arrays. When a
+     *  cache is in use, an id must identify the same logical layer across
+     *  frames — reusing it for a different layer can serve cross-layer commands. */
+    id: string;
+    /** Human-readable name for UI toggles. */
+    label: string;
+    /**
+     * Emit a DrawCommand tree for the GL backend to dispatch.
+     *
+     * For world-space layers (the default), emit commands in WORLD COORDS —
+     * `drawLayers` automatically wraps them in `{ kind: 'group', transform:
+     * viewToMat3(view), ... }` before handing them to the renderer. Do NOT
+     * apply the view transform yourself.
+     *
+     * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel
+     * coords directly; `drawLayers` passes them through unchanged. If part
+     * of a screen-space layer's output needs to track the view, wrap that
+     * subset manually with `viewToMat3(view)`.
+     */
+    draw: (data: TData, view: View, dims: Dims) => DrawCommand[];
+    /**
+     * Optional cache key. When present and a `LayerCommandCache` is supplied to
+     * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as
+     * every entry is `Object.is`-equal to the previous call's. A layer with no
+     * `deps` rebuilds on every frame.
+     *
+     * **The returned commands must be treated as immutable.** A cached tree is
+     * handed to the renderer again on later frames, so mutating a tree you
+     * previously returned corrupts the cache silently rather than erroring.
+     *
+     * **Screen-space layers are not protected against a stale `view`/`dims`
+     * the way world-space layers are** (see `space` below) — include them in
+     * `deps` if `draw` reads them.
+     */
+    deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];
+    /**
+     * Whether the layer is shown when no explicit visibility entry exists.
+     * Defaults to `true` when absent.
+     */
+    defaultVisible?: boolean;
+    /**
+     * When true, the layer is always drawn regardless of the visibility map.
+     * Useful for layers that must never be hidden (e.g. base grid).
+     */
+    alwaysOn?: boolean;
+    /**
+     * Coordinate space the layer draws in.
+     *
+     * - `'world'` (default): the layer's `draw` returns world-space commands;
+     *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`
+     *   automatically.
+     * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)
+     *   commands; `drawLayers` passes them through unchanged. World-anchored
+     *   chrome inside a screen-space layer must call `worldToScreen` or wrap
+     *   the relevant subset with `viewToMat3(view)` manually.
+     */
+    space?: 'world' | 'screen';
+    /**
+     * Where the layer learns that state `draw` reads, outside the scene and the
+     * props, has changed. The canvas painting it subscribes while the layer is
+     * mounted and repaints on every notification, so a layer reading a mode
+     * registry needs no consumer code to follow a mode switch.
+     */
+    subscribe?: RedrawSource['subscribe'];
+    /**
+     * Full-screen passes run over this layer's own pixels before it joins the
+     * frame — a blur here blurs the world and leaves the HUD drawn above it
+     * sharp, which is the thing a CSS `filter` on the `<canvas>` cannot do.
+     *
+     * Costs nothing while empty: the renderer allocates no offscreen buffer
+     * until a layer actually declares one. See `GroupDrawCommand.effects` for
+     * what a pass may read, and {@link LayerGroup} to run one chain over
+     * several layers at once instead of one chain each.
+     */
+    effects?: readonly Effect[];
+    /**
+     * Optional hit-test for **consumer-attached** layers.
+     *
+     * Only layers registered through `CanvasExtensionApi.registerLayer` are
+     * hit-tested: `hitTestExtras` walks them last-registered-first on
+     * pointerdown, and `<SceneCanvas>` folds the result into its `affordanceAt`
+     * thunk ahead of the kit's own selection chrome. First non-null result
+     * wins; null means "I don't claim this hit, try the next layer."
+     *
+     * Layers that reach the draw stack some other way — a `Tool.overlay`, an
+     * entry in the `layers` map — are painted but never hit-tested, so defining
+     * `hitTest` on one has no effect. (The kit's own chrome doesn't need it: it
+     * goes through `buildAffordanceAt`.)
+     *
+     * Coordinates are world-space. The `data` arg is the layer's
+     * configured data slot (same as `draw`); `view` and `dims` mirror
+     * `draw`'s arguments.
+     */
+    hitTest?: (worldX: number, worldY: number, data: TData, view: View, dims: Dims, 
+    /** Chrome-caps visibility predicate. When supplied, the layer must
+     *  not return a hit from any chrome element whose id reports
+     *  `false`. Absent → every element is hittable. */
+    isVisible?: (id: string) => boolean) => LayerHit | null;
+    /**
+     * Called on every pointermove when no gesture is currently captured.
+     * Lets layers (e.g. HUD widgets) track hover state without participating
+     * in the drag pipeline. Coords are world-space; the layer is responsible
+     * for any further conversion (e.g. world→screen for screen-space layers)
+     * and for its own throttling.
+     */
+    onUncapturedMove?: (worldX: number, worldY: number, evt: PointerEvent, view: View, dims: Dims) => void;
+    /**
+     * Called when the cursor leaves the canvas element. Lets layers clear
+     * any hover state they're holding.
+     */
+    onUncapturedLeave?: () => void;
+}
+/** Where one layer's commands landed in {@link drawLayers}' output,
+ *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's
+ *  run is one span under the group's id. */
+interface LayerDrawSpan {
+    id: string;
+    start: number;
+    end: number;
+    buildMs: number;
+}
+/**
+ * Walk visible layers and concatenate their emitted DrawCommand arrays into
+ * one flat list, ready to feed to `WeaselRenderer.render(commands)`.
+ *
+ * Visibility resolution order:
+ *   1. `alwaysOn` — always drawn, ignores visibility map.
+ *   2. Explicit entry in `visibility` map — overrides default.
+ *   3. `layer.defaultVisible` — falls back to `true` when absent.
+ *
+ * Transform composition: world-space layers (the default; `space` unset or
+ * `'world'`) have their commands wrapped in a `kind: 'group'` with
+ * `viewToMat3(view)` before they reach the renderer. Screen-space layers
+ * (`space: 'screen'`) pass through unchanged.
+ *
+ * A layer whose `draw` throws is dropped for the frame and reported through
+ * `onLayerError` — the rest of the frame still paints.
+ *
+ * `groups` brackets runs of consecutive layers so they composite as one — see
+ * `LayerGroup`. A layer named by no group is emitted exactly as it was before
+ * groups existed, and a frame that declares none allocates nothing.
+ *
+ * `spans`, when passed, receives one {@link LayerDrawSpan} per layer drawn.
+ */
+declare function drawLayers<TData>(layers: RenderLayer<TData>[], data: TData, visibility: Record<string, boolean>, order: string[] | undefined, view: View | undefined, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void, groups?: readonly LayerGroup[], spans?: LayerDrawSpan[]): DrawCommand[];
+/**
+ * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in
+ * `visibility`, then `defaultVisible`, defaulting to shown.
+ */
+declare function isLayerVisible<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>): boolean;
+/**
+ * Does this layer reach the screen at all — both gates, in the order
+ * `drawLayers` applies them.
+ *
+ * **A listed `order` is the whole list**, so omission from it drops a layer
+ * that `visibility` would have shown, and `alwaysOn` does not rescue it.
+ * Hit-testing asks this, not `isLayerVisible`: a layer that is not painted
+ * but still claims pointer events is a pointer landing on nothing the user
+ * can see.
+ */
+declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Record<string, boolean>, order: string[] | undefined): boolean;
+/**
+ * Draw one layer and put its commands in the space its `space` declares:
+ * world-space output wrapped in a `viewToMat3(view)` group, screen-space
+ * output passed through.
+ *
+ * Anything rendering layers through a view — the canvas itself, a viewport
+ * node's inner pass — goes through here. A second copy of this rule that
+ * forgets the wrap draws world content at raw world coords, which looks
+ * plausible at the identity view and wrong everywhere else.
+ *
+ * A `draw` that throws yields no commands, and `onLayerError` is told which
+ * layer it was. The layer's cache entry goes with it, so the next frame is a
+ * real re-attempt rather than a stale tree served under fresh deps.
+ */
+declare function drawOneLayer<TData>(layer: RenderLayer<TData>, data: TData, view: View, dims: Dims, cache?: LayerCommandCache, onLayerError?: (failure: LayerDrawFailure) => void): DrawCommand[];
+/** Whether `b` matches `a` entry for entry under `Object.is` — how
+ *  `RenderLayer.deps` is compared, and any cache keyed the same way. */
+declare function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean;
+
 /** Per-axis limits on a view's position. Any side may be left open. */
 interface PanBounds {
     minX?: number;
@@ -1891,7 +2481,9 @@ interface TimelineClock {
 interface EventBookingHandle {
     stop(): void;
 }
+/** One entry on an `EventTrack`. Give it `fire`, `book`, or both. */
 interface TimelineEvent {
+    /** Time within the track's timeline, in ms. */
     t: number;
     /** Runs on the frame that crosses the edge, told how far behind the frame it
      *  was crossed, in ms — never negative, and measured against `duration` on
@@ -1913,6 +2505,7 @@ interface EventTrack {
     /** Sorted ascending by `t`. */
     events: TimelineEvent[];
 }
+/** How a timeline books its events against an outside clock. */
 interface EventBooking {
     clock: TimelineClock;
     /** How far ahead of the playhead to book, in clock ms. Default 100. An event
@@ -1930,6 +2523,7 @@ interface TimelineTrack {
     at: number;
     timeline: NestedTimeline;
 }
+/** Any track a timeline can hold. */
 type Track = SampledTrack<any> | EventTrack | TimelineTrack;
 /** What a child timeline may declare. The parent owns playback, so `loop`,
  *  `autoplay`, `onDone` and `cancelKey` have no meaning below the root. */
@@ -1938,18 +2532,24 @@ interface NestedTimeline {
     /** Defaults to the largest end time across `tracks`. */
     duration?: number;
 }
+/** What `animator.timeline` takes: a root timeline, which owns playback. */
 interface TimelineOptions extends NestedTimeline {
     /** `true` loops forever, `n` loops n additional times. Default false. */
     loop?: boolean | number;
     /** Default true. When false the timeline registers but holds at t=0 until resumed. */
     autoplay?: boolean;
+    /** Called when playback reaches the end of its last lap. */
     onDone?: () => void;
+    /** Any new animation passed the same `cancelKey` cancels this one. */
     cancelKey?: string;
+    /** Names this timeline in `animator.watch` events and `animator.live()`. */
+    label?: string;
     /** Books each event's `book` against a clock the timeline does not own, so a
      *  consumer on that clock lands it at its true sub-frame time. The frame
      *  clock's mapping onto it is smoothed each frame and resynced on a jump. */
     booking?: EventBooking;
 }
+/** What `animator.timeline` returns: playback control plus live editing. */
 interface TimelineHandle extends AnimationHandle {
     /** Move the playhead. Never fires event tracks, at any depth. */
     seek(t: number): void;
@@ -1974,144 +2574,6 @@ interface TimelineHandle extends AnimationHandle {
     subscribe(cb: () => void): () => void;
 }
 
-/** No easing: constant rate from start to finish. */
-declare const linear: EasingFn;
-/** Accelerates from a standstill, gently. */
-declare const easeInQuad: EasingFn;
-/** Decelerates to a stop, gently. The safe default for UI motion. */
-declare const easeOutQuad: EasingFn;
-/** Accelerates then decelerates, gently. */
-declare const easeInOutQuad: EasingFn;
-/** Accelerates from a standstill, moderately. */
-declare const easeInCubic: EasingFn;
-/** Decelerates to a stop, moderately. */
-declare const easeOutCubic: EasingFn;
-/** Accelerates then decelerates, moderately. */
-declare const easeInOutCubic: EasingFn;
-/** Accelerates from a standstill, sharply. */
-declare const easeInQuart: EasingFn;
-/** Decelerates to a stop, sharply. */
-declare const easeOutQuart: EasingFn;
-/** Accelerates then decelerates, sharply. */
-declare const easeInOutQuart: EasingFn;
-/** Accelerates from a standstill, very sharply. */
-declare const easeInQuint: EasingFn;
-/** Decelerates to a stop, very sharply. */
-declare const easeOutQuint: EasingFn;
-/** Accelerates then decelerates, very sharply. */
-declare const easeInOutQuint: EasingFn;
-/** Accelerates from a standstill along a sine curve — the mildest
- *  acceleration of the built-ins. */
-declare const easeInSine: EasingFn;
-/** Decelerates to a stop along a sine curve — the mildest
- *  deceleration of the built-ins. */
-declare const easeOutSine: EasingFn;
-/** Accelerates then decelerates along a sine curve. */
-declare const easeInOutSine: EasingFn;
-/** Accelerates exponentially: barely moves at first, then rushes. */
-declare const easeInExpo: EasingFn;
-/** Decelerates exponentially: leaps away, then creeps in. */
-declare const easeOutExpo: EasingFn;
-/** Exponential at both ends — a very fast middle between two
- *  near-still extremes. */
-declare const easeInOutExpo: EasingFn;
-/** Accelerates along a circular arc: slow start, abrupt arrival. */
-declare const easeInCirc: EasingFn;
-/** Decelerates along a circular arc: abrupt start, slow arrival. */
-declare const easeOutCirc: EasingFn;
-/** Circular arcs at both ends. */
-declare const easeInOutCirc: EasingFn;
-/** Pulls back past the start before moving forward. Overshoots below 0. */
-declare const easeInBack: EasingFn;
-/** Overshoots the target, then settles back onto it. Exceeds 1. */
-declare const easeOutBack: EasingFn;
-/** Overshoots at both ends. Leaves the 0–1 range on each side. */
-declare const easeInOutBack: EasingFn;
-/** Oscillates around the start with growing amplitude, then snaps away. */
-declare const easeInElastic: EasingFn;
-/** Springs past the target and wobbles into it. Exceeds 1. */
-declare const easeOutElastic: EasingFn;
-/** Wobbles at both ends. Leaves the 0–1 range on each side. */
-declare const easeInOutElastic: EasingFn;
-/** Lands on the target and bounces, in hops of decreasing height. */
-declare const easeOutBounce: EasingFn;
-/** Bounces up to the start before departing — `easeOutBounce` reversed. */
-declare const easeInBounce: EasingFn;
-/** Bounces at both ends. */
-declare const easeInOutBounce: EasingFn;
-/** Alias for `easeInQuad`, kept for call sites that predate the
- *  named-curve library. */
-declare const easeIn: EasingFn;
-/** Alias for `easeOutQuad`, kept for call sites that predate the
- *  named-curve library. */
-declare const easeOut: EasingFn;
-/** Alias for `easeInOutQuad`, kept for call sites that predate the
- *  named-curve library. */
-declare const easeInOut: EasingFn;
-/** All easings in one bag — useful for demos / pickers. */
-declare const EASINGS: {
-    readonly linear: EasingFn;
-    readonly easeInQuad: EasingFn;
-    readonly easeOutQuad: EasingFn;
-    readonly easeInOutQuad: EasingFn;
-    readonly easeInCubic: EasingFn;
-    readonly easeOutCubic: EasingFn;
-    readonly easeInOutCubic: EasingFn;
-    readonly easeInQuart: EasingFn;
-    readonly easeOutQuart: EasingFn;
-    readonly easeInOutQuart: EasingFn;
-    readonly easeInQuint: EasingFn;
-    readonly easeOutQuint: EasingFn;
-    readonly easeInOutQuint: EasingFn;
-    readonly easeInSine: EasingFn;
-    readonly easeOutSine: EasingFn;
-    readonly easeInOutSine: EasingFn;
-    readonly easeInExpo: EasingFn;
-    readonly easeOutExpo: EasingFn;
-    readonly easeInOutExpo: EasingFn;
-    readonly easeInCirc: EasingFn;
-    readonly easeOutCirc: EasingFn;
-    readonly easeInOutCirc: EasingFn;
-    readonly easeInBack: EasingFn;
-    readonly easeOutBack: EasingFn;
-    readonly easeInOutBack: EasingFn;
-    readonly easeInElastic: EasingFn;
-    readonly easeOutElastic: EasingFn;
-    readonly easeInOutElastic: EasingFn;
-    readonly easeInBounce: EasingFn;
-    readonly easeOutBounce: EasingFn;
-    readonly easeInOutBounce: EasingFn;
-};
-/** The name of one of the built-in easing curves. */
-type EasingName = keyof typeof EASINGS;
-/** Named spring tunings, from softest to firmest. Springs settle on a target
- *  rather than running for a fixed duration, so these are an alternative to an
- *  easing curve, not a modifier on one. */
-declare const SPRING_PRESETS: Record<SpringPresetName, SpringPreset>;
-
-/** Cubic-bezier control points, CSS `cubic-bezier()` order. The curve's two
- *  endpoints are implicit at (0,0) and (1,1). */
-interface BezierEasing {
-    /** `readonly` so an `as const` preset is assignable; nothing ever writes it. */
-    bezier: readonly [number, number, number, number];
-}
-/** An easing curve as a value: a function, the name of a built-in, or control
- *  points. Anything an editor has to name, show or serialize must not be a bare
- *  function, which is why the union exists. */
-type EasingSpec = EasingFn | EasingName | BezierEasing;
-/** Build the easing curve for four cubic-bezier control points. `x1`/`x2` are
- *  clamped to [0,1] — CSS `cubic-bezier()`'s constraint for a monotone x(t),
- *  which both `solveForX` root-finders assume. `y1`/`y2` are unclamped: an
- *  overshoot easing (back, elastic) needs them outside 0..1. */
-declare function cubicBezierEasing(x1: number, y1: number, x2: number, y2: number): EasingFn;
-/** Resolve a spec to the function that shapes progress. `undefined` is linear. */
-declare function resolveEasing(spec?: EasingSpec): EasingFn;
-
-/** An easing curve: maps normalized progress `t ∈ [0, 1]` to eased progress.
- *  Curves may leave the 0–1 range in the middle (back, elastic) but should
- *  pass through 0 at 0 and 1 at 1. */
-type EasingFn = (t: number) => number;
-
 /** Blends two `T` values at eased progress `t`. Called once per frame; see
  *  {@link InterpolatorFactory} when the blend has setup worth hoisting. */
 type Interpolate<T> = (from: T, to: T, t: number) => T;
@@ -2121,15 +2583,6 @@ type Interpolate<T> = (from: T, to: T, t: number) => T;
  *  shape exactly. For cheap interpolations the per-tick `Interpolate<T>` form is
  *  fine; this is the escape hatch when setup-per-tick is wasteful. */
 type InterpolatorFactory<T> = (from: T, to: T) => (t: number) => T;
-/** A spring's physical parameters. Higher stiffness settles faster, higher
- *  damping overshoots less, higher mass makes both sluggish. */
-interface SpringPreset {
-    stiffness: number;
-    damping: number;
-    mass: number;
-}
-/** One of the tunings in `SPRING_PRESETS`. */
-type SpringPresetName = 'gentle' | 'wobbly' | 'stiff' | 'slow';
 /** A running animation. Cancel it, or bend its time — pausing and time-scaling
  *  act on this animation's own virtual clock, independent of the animator's. */
 interface AnimationHandle {
@@ -2169,6 +2622,8 @@ interface TweenOptions<T> {
     onDone?: () => void;
     /** Any new animation passed the same cancelKey cancels the prior one in flight. */
     cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
 /** A spring animation: runs until the value settles on `to` rather than for a
  *  set duration, so it absorbs an initial velocity naturally. Non-numeric `T`
@@ -2193,6 +2648,8 @@ interface SpringOptions<T> {
     onTick: (value: T) => void;
     onDone?: () => void;
     cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
 /** Spring and decay as one animation. With a `to`, a spring pulls toward it;
  *  with `to: null`, the value coasts on its velocity. Either can become the
@@ -2216,6 +2673,8 @@ interface PhysicsOptions<T> {
     onTick: (value: T) => void;
     onDone?: () => void;
     cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
 /** An `AnimationHandle` that can also be steered while it runs — the point of
  *  the physics primitive. */
@@ -2240,6 +2699,8 @@ interface DecayOptions<T> {
     onTick: (value: T) => void;
     onDone?: () => void;
     cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
 /** Options for `useAnimator`. Everything here is an injection seam for tests;
  *  the defaults are the real clock, rAF, and `setTimeout`. */
@@ -2374,7 +2835,82 @@ interface Animator {
      * stop firing even though the override is still installed.
      */
     keepAlive(): () => void;
+    /**
+     * Subscribe to the lifecycle of every animation this animator runs, the
+     * composites and timelines included. Returns an unsubscribe. Events arrive
+     * synchronously, as each thing happens — see {@link AnimatorEvent} for the
+     * order. With no listener attached nothing is built or delivered, so an
+     * unwatched animator pays nothing for this.
+     */
+    watch(listener: AnimatorListener): () => void;
+    /** What is running right now, in registration order: a fresh snapshot per
+     *  call, for a debug overlay to draw. */
+    live(): LiveAnimation[];
 }
+/** Which animator call started an animation. A loop, tween loop or stagger is
+ *  an entry of its own beside the children it runs; `keepAlive` holds the
+ *  frame loop open and animates nothing. */
+type AnimationKind = 'tween' | 'spring' | 'decay' | 'physics' | 'timeline' | 'loop' | 'tweenLoop' | 'stagger' | 'keepAlive';
+/** Who an {@link AnimatorEvent} is about. One object per registration, so the
+ *  same animation's events share it by identity. */
+interface AnimationInfo {
+    /** The id on the animation's handle. */
+    readonly id: number;
+    readonly kind: AnimationKind;
+    /** The animation's `cancelKey`. Pose helpers key by node, as `pose:<id>`. */
+    readonly key?: string;
+    /** The animation's `label` option. */
+    readonly label?: string;
+}
+/** One row of `animator.live()`. */
+interface LiveAnimation extends AnimationInfo {
+    /** Paused on its own handle. The animator-wide pause is `animator.isPaused()`. */
+    readonly paused: boolean;
+    /** Its own time scale; the animator's multiplies on top. */
+    readonly timeScale: number;
+    /** Virtual ms its clock has advanced since it started. */
+    readonly elapsed: number;
+    /** 0 to 1, for a tween or a timeline (the playhead over its duration).
+     *  Absent where there is no end to measure against: physics, composites. */
+    readonly progress?: number;
+}
+/**
+ * One thing happening to an animation, as `animator.watch` delivers it.
+ *
+ * - `start` — registered. A finished timeline that `seek` or `edit` revives
+ *   starts again, under the same id.
+ * - `end` — finished on its own. Delivered once every animation has ticked
+ *   that frame, in registration order.
+ * - `cancel` — stopped by its handle, `cancel`, `cancelKey` or `cancelAll`.
+ * - `interrupt` — stopped because `by` claimed its `cancelKey`. Delivered
+ *   before `by`'s `start`.
+ * - `lap` — a looping timeline wrapped; `lap` counts wraps since it started.
+ * - `fire` — an event on a timeline's event track was crossed, at any depth.
+ *   `path` indexes from the root timeline's `tracks()` down through each
+ *   nested timeline to the event track. Delivered after the event's own `fire`.
+ */
+type AnimatorEvent = {
+    readonly type: 'start' | 'end' | 'cancel';
+    readonly animation: AnimationInfo;
+} | {
+    readonly type: 'interrupt';
+    readonly animation: AnimationInfo;
+    readonly by: AnimationInfo;
+} | {
+    readonly type: 'lap';
+    readonly animation: AnimationInfo;
+    readonly lap: number;
+} | {
+    readonly type: 'fire';
+    readonly animation: AnimationInfo;
+    readonly track: EventTrack;
+    readonly path: readonly number[];
+    readonly event: TimelineEvent;
+    /** As the event's own `fire` is told: ms behind the frame it was crossed. */
+    readonly lateBy: number;
+};
+/** Receives what `animator.watch` delivers. */
+type AnimatorListener = (event: AnimatorEvent) => void;
 /** Options for `Animator.loop`. */
 interface LoopOptions {
     /** Maximum number of iterations. Default Infinity. */
@@ -2384,13 +2920,18 @@ interface LoopOptions {
     /** Any new animation passed the same cancelKey cancels the prior one in flight.
      *  Also enables `animator.cancelKey` / `animator.isActive(key)` for this loop. */
     cancelKey?: string;
+    /** Names this loop in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
-/** Options for the top-level `Animator.stagger` factory form (third overload). */
+/** A stagger run's own options: the factory form's fourth argument, and part
+ *  of every fluent builder method's options. */
 interface StaggerOptions {
     /** Cancel-key for the supervising registration. `animator.cancelKey(key)`
      *  cancels the whole stagger; `animator.isActive(key)` returns true while
      *  any timer or child is alive. */
     cancelKey?: string;
+    /** Names this stagger in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
 /** Produces one iteration of a loop. Must arrange for `next` to be called when
  *  the animation it returns finishes, or the loop stalls after one pass. */
@@ -2405,8 +2946,9 @@ type StaggerFactory<TItem> = (item: TItem, index: number) => AnimationHandle;
  *  vary an option (e.g. `to: (_item, i) => (i + 1) * 10`). */
 type StaggerPerItem<T, TItem> = T | ((item: TItem, index: number) => T);
 /** Options for the stagger builder's `.tween`: a tween per item, where
- *  `from`, `to` and `ms` may each vary by item. */
-interface StaggerTweenOptions<T, TItem> {
+ *  `from`, `to` and `ms` may each vary by item. `cancelKey` and `label` belong
+ *  to the stagger as a whole, as in {@link StaggerOptions}. */
+interface StaggerTweenOptions<T, TItem> extends StaggerOptions {
     from: StaggerPerItem<T, TItem>;
     to: StaggerPerItem<T, TItem>;
     ms: StaggerPerItem<number, TItem>;
@@ -2416,8 +2958,10 @@ interface StaggerTweenOptions<T, TItem> {
     onDone?: (item: TItem, index: number) => void;
 }
 /** Options for the stagger builder's `.springPose`: the spring tuning, and
- *  whether each item's settle is recorded as an undoable op. */
-interface StaggerSpringPoseOptions<TPose> {
+ *  whether each item's settle is recorded as an undoable op. `cancelKey` and
+ *  `label` belong to the stagger as a whole, as in {@link StaggerOptions};
+ *  each item's spring keeps its own per-node key. */
+interface StaggerSpringPoseOptions<TPose> extends StaggerOptions {
     preset?: SpringPresetName;
     stiffness?: number;
     damping?: number;
@@ -2430,7 +2974,7 @@ interface StaggerSpringPoseOptions<TPose> {
  *  items and the delay schedule are already fixed. */
 interface StaggerBuilder<TItem> {
     /** Run an arbitrary per-item factory. */
-    each(factory: StaggerFactory<TItem>): AnimationHandle;
+    each(factory: StaggerFactory<TItem>, opts?: StaggerOptions): AnimationHandle;
     /** Sugar: per-item `animator.tween` with per-item-varying options. */
     tween<T>(opts: StaggerTweenOptions<T, TItem>): AnimationHandle;
     /** Sugar: per-item `springPose` against an adapter. `poseFn` returns the
@@ -2458,6 +3002,8 @@ interface TweenLoopOptions<T> {
     onTick: (value: T) => void;
     onDone?: () => void;
     cancelKey?: string;
+    /** Names this animation in {@link AnimatorEvent}s and `animator.live()`. */
+    label?: string;
 }
 
 /** Cancel-key prefix. Each hook instance appends its own id, so two runners
@@ -2576,144 +3122,275 @@ declare function usePointerContext(): PointerContextValue | null;
 declare function usePointerPosition(): PointerWorldPos;
 
 /**
- * Pose composition for hierarchical scene graphs.
+ * Project a leaf path from its source frame into world coordinates given a
+ * `{x, y, width, height, rotation?}` pose. Two transforms compose, in this
+ * order:
  *
- * As of the nesting change, `getPose(id)` on adapters returns the
- * **local** pose — relative to the object's direct parent. Anything in the
- * kit that needs to draw, hit-test, snap, or otherwise reason about world
- * coordinates routes through `composeWorldPose`, which walks the parent
- * chain and folds local poses together via a consumer-supplied `compose`.
+ *   1. Translate so the path's source AABB origin lands at `pose.x, pose.y`.
+ *   2. If `pose.rotation` is nonzero, rotate every coord about the unrotated
+ *      AABB center — i.e. `(pose.x + pose.width/2, pose.y + pose.height/2)`,
+ *      matching `SceneCanvas.rotateAroundAABBCenter` so the baked geometry
+ *      lines up with what the renderer draws.
  *
- * Pose shape is generic, so the compose strategy is too. For the common
- * `{x, y, width, height}` axis-aligned rect, use `composeRectPose` —
- * translation only, child dimensions preserved. Custom pose shapes (paths,
- * matrix transforms) supply their own.
+ * RectPaths can't carry rotation as-is (they're axis-aligned by definition);
+ * a non-zero `pose.rotation` on a rect promotes the result to a polygon so
+ * the four corners are baked into world coords. Callers that need to keep
+ * the rect fast-path can pre-check `pose.rotation` themselves.
  *
- * The inverse — `rebaseLocalPose` — converts a world-space pose into a
- * local pose under a target parent. Used when reparenting so the visual
- * world position of a child is preserved across the parent change.
+ * Used by adapters that need true world geometry — most notably boolean ops,
+ * where operating on the unrotated source path produces wrong shapes.
  */
-/** Re-exported; the declaration lives in `core/scene/types.ts`, which names
- *  it and may not import from features. */
 
-/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */
-interface PoseAdapter<TPose> {
-    getPose(id: string): TPose;
-    getParent(id: string): string | null;
-    /** Whether `id`'s pose is a frame its children are expressed in. Absent
-     *  means every node is one. A container whose pose derives from its children
-     *  is not: its children share its frame, so the fold passes over it. */
-    definesFrame?(id: string): boolean;
+/** Subset of pose fields this helper consumes. Matches the kit's auto-rotate
+ *  convention (`SceneCanvas.defaultDrawOne`): `x/y/width/height` define an
+ *  AABB whose unrotated center is the rotation pivot. */
+interface PathInWorldPose {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
 }
 /**
- * The transforms a `compose` represents **exactly**. A parent transform wider
- * than its strategy's closure is rounded to the nearest pose — for `'rigid'`
- * that means an anisotropically scaled parent turns a rotated child into a
- * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the
- * shear is dropped.
+ * Project a stored path into the pose's **local frame** — translate (and, for
+ * rects, rebase to the pose's `width`/`height`) so the path's AABB origin sits
+ * at the pose origin. This is translate-only: it does NOT apply
+ * `pose.rotation`. Callers that want the fully world-positioned (rotated) path
+ * should use `pathInWorld`, which composes this with the rotation wrap.
  *
- * Measured over 50,000 random parent/child pairs: rotation and translation
- * compose to within 5.7e-13, anisotropic scale to a right-angle error of 0.99.
- * See `docs/superpowers/specs/2026-09-10-group-as-frame-design.md`.
+ * Rects rebase onto the pose's `width`/`height` because resize updates the pose,
+ * not the stored `RectPath` — so the live size lives on the pose. Honoring it
+ * here keeps this in lockstep with the renderer (`SceneCanvas` paints the rect
+ * at `pose.width/height`); otherwise world-space consumers (slice, booleans,
+ * release-compound) would operate on the stale pre-resize dimensions.
+ *
+ * Used by the local seams: the default painter (paint + silhouette), and as the
+ * building block `pathInWorld`/`findShapeSilhouette` rotate on top of.
  */
-type PoseClosure = 'identity' | 'translation' | 'rigid';
-/** Consumer's pose-composition strategy for hierarchical scenes. `compose`
- *  folds a child's pose (in parent's frame) up to the next frame; `decompose`
- *  is its inverse. Default is IDENTITY — an absolute-pose scene where every
- *  node already stores world coords (parent is grouping-only, no transform). */
-interface PoseComposition<TPose> {
-    compose: (parent: TPose, child: TPose) => TPose;
-    decompose: (parent: TPose, world: TPose) => TPose;
-    closure: PoseClosure;
-}
-/** Default pose-composition strategy: IDENTITY. Both `compose` and
- *  `decompose` return the child/world pose unchanged, modeling an
- *  absolute-pose scene where every node stores world coords and parents are
- *  grouping-only (no transform). With this strategy `composeWorldPose`
- *  returns a node's own raw pose and `rebaseLocalPose` is a no-op. */
-declare const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown>;
+declare function pathInPoseFrame(path: Path, pose: PathInWorldPose): Path;
 /**
- * Walk `id`'s parent chain (root first to id last) and fold local poses into
- * a world pose via `compose`. Returns the world pose for `id`. Cycle-safe:
- * a visited-set guard breaks if the chain ever loops back to itself.
+ * Bake `pose` into `path`'s coordinates so the returned path is positioned
+ * in world space. Returns a fresh `Path` instance; never mutates inputs.
+ */
+declare function pathInWorld(path: Path, pose: PathInWorldPose): Path;
+/**
+ * Inverse of `pathInWorld` for a path in **world** space: the unrotated
+ * stored path plus the pose that draws it there. Inverse-rotates about the
+ * pose's AABB center, so the stored path is unrotated and the pose's
+ * `rotation` is preserved, then fits the pose's AABB fields to the result.
+ * The new box's center is placed where the old rotation carries it, since
+ * the pivot moves with the box: `pathInWorld(result.path, result.pose)`
+ * reproduces `worldPath` whether or not its bounds changed.
  *
- * `compose(parent, child)` interprets `child` as expressed *in `parent`'s
- * local frame* and returns the equivalent pose in the next frame up. For a
- * standard translation-only rect: `world = { x: p.x + c.x, y: p.y + c.y,
- * width: c.width, height: c.height }`.
+ * Generic in the pose type so consumer-defined pose fields (including
+ * `rotation`) survive the round-trip. Used by the anchor-edit commit, its
+ * live preview, and the default slice dep.
  */
-declare function composeWorldPose<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
+declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: PolygonPath): {
+    pose: P;
+    path: PolygonPath;
+};
+declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: Path): {
+    pose: P;
+    path: Path;
+};
+
 /**
- * Default `compose` for axis-aligned rectangles. Adds translation; preserves
- * child width/height. Treat as the canonical compose for any
- * `{x, y, width, height}` pose under a translation-only hierarchy.
+ * Text as path geometry: the glyph outlines a text node draws, placed in
+ * world space and composed into one `Path`. What "Create Outlines" replaces a
+ * text node with, and what a Boolean op reads when a text node is an operand.
  *
- * Generic over the concrete pose type so callers with a wider pose
- * (e.g. `RectPose & { rotation }`) can pass it through; the extra fields
- * are taken from the child unchanged.
+ * The walk is `layoutRuns`', so the glyphs land exactly where the renderer's
+ * outline tier puts them — same pen positions, same baselines, same synthetic
+ * italic shear — but with the tier forced on for every glyph whatever its
+ * size, and with paint set aside: unfilled text has outlines too.
+ * `textToPathsByPaint` is the same walk, split by the paint each glyph wears.
  */
-declare function composeRectPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose;
+
+/** The fields of a text node's data that decide its glyph geometry, and the
+ *  paint `textToPathsByPaint` splits it by. Paint never changes the geometry. */
+interface TextOutlineSource {
+    text: string;
+    runs?: readonly StyledRun[];
+    style?: TextStyle;
+    verticalAlign?: TextVerticalAlign;
+    /** The node's `data.fill`: `null` is no fill, absent the default black. */
+    fill?: FillStyle | null;
+    /** The node's `data.stroke`: absent or `null` is no stroke. */
+    stroke?: Stroke | null;
+}
+/** One paint's share of a text node's outlines — see {@link textToPathsByPaint}. */
+interface TextPaintPath {
+    /** The resolved fill these glyphs wear: the run's own, else the node's.
+     *  `null` for unfilled text, painted by its stroke alone. */
+    fill: FillStyle | null;
+    /** The resolved stroke — the run's own, else the node's — or absent. */
+    stroke?: Stroke;
+    /** World-space outlines, as {@link textToPath} builds them. */
+    path: PolygonPath;
+}
+/** A text node as {@link textToPath} reads it: its data and its pose. */
+interface TextNodeSource {
+    data: TextOutlineSource;
+    pose: PathInWorldPose;
+}
+/** Options for {@link textToPath}. */
+interface TextToPathOptions {
+    /** The view scale a `{ px }` `fontSize` or `letterSpacing` resolves
+     *  against, as for `textCommandFromPose`. Default 1. */
+    scale?: number;
+}
 /**
- * Translate a `RectPose`-shaped pose by `(dx, dy)`. Suitable as the default
- * `translatePose` for `useMove` when poses carry top-level `x`/`y`. Other
- * fields (width/height, plus any extra props on `TPose`) are preserved.
+ * Why a text node has no outline geometry to give:
+ *
+ * - `'no-outlines'` — the face that serves it has no outlines registered
+ *   (`registerFontOutlines`), so there is no geometry to read.
+ * - `'outlines-loading'` — registered but not parsed yet. `loadTextOutlines`
+ *   waits for it; the call has already started the load.
+ * - `'outlines-failed'` — registered, and the bytes did not load or parse.
+ * - `'synthetic-bold'` — the requested weight is faked from a lighter face.
+ *   The renderer thickens the distance field for that, and a path has no
+ *   field to thicken; emboldening geometry needs outline offsetting, which
+ *   the kit does not have. Converting would silently lighten the text.
  */
-declare function translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): TPose;
+type TextOutlinesFailure = 'no-outlines' | 'outlines-loading' | 'outlines-failed' | 'synthetic-bold';
+/** Thrown by {@link textToPath} when some run of the text has no outline
+ *  geometry. Names the run's requested face. */
+declare class TextOutlinesError extends Error {
+    readonly reason: TextOutlinesFailure;
+    readonly family: string;
+    readonly weight: number;
+    readonly style: FontStyle;
+    constructor(reason: TextOutlinesFailure, family: string, weight: number, style: FontStyle, detail: string);
+}
 /**
- * Convert `worldPose` into a local pose expressed under `newParentId`'s
- * frame. Used when reparenting so the child's visual world position is
- * preserved despite the change of frame. Inverse of one `compose` step.
+ * The outline geometry of a text node, in world space: every glyph and every
+ * underline, strikethrough and overline rule it draws, as one `'nonzero'`
+ * compound path whose filled region is their union. Glyphs keep the font's
+ * curves; overlapping contours are not merged — run the result through
+ * `pathUnion` for that, at the cost of flattening the curves.
  *
- * `decompose(parent, world)` returns the local pose `child` such that
- * `compose(parent, child) === world`. For axis-aligned rects:
- * `child = { ...world, x: world.x - parent.x, y: world.y - parent.y }`.
+ * `pose` is the node's box and rotation. Synthetic italic is sheared exactly
+ * as the renderer shears it. Throws {@link TextOutlinesError} when any run's
+ * face cannot supply outlines — never returns a partial or empty path for
+ * that. Text with no ink (empty, or only spaces) returns an empty path.
+ */
+declare function textToPath(data: TextOutlineSource, pose: PathInWorldPose, opts?: TextToPathOptions): PolygonPath;
+/**
+ * {@link textToPath}, split by paint: one path per distinct resolved fill and
+ * stroke, each gathering the glyphs and decoration rules that wear it — a
+ * rule takes the fill of the run it underlines. Groups come in the order
+ * their paint first appears in the text; a paint whose runs put down no ink
+ * has none. Together the paths cover exactly what `textToPath` covers.
  *
- * Pass `newParentId === null` for the root frame; the function returns
- * `worldPose` unchanged.
+ * Paint resolves as the renderer resolves it: a run's `fill` / `stroke`, else
+ * the node's `data.fill` / `data.stroke` from `data`, else the default black
+ * fill and no stroke. Throws as `textToPath` does.
  */
-declare function rebaseLocalPose<TPose>(adapter: PoseAdapter<TPose>, worldPose: TPose, newParentId: string | null, compose: (parent: TPose, child: TPose) => TPose, decompose: (parent: TPose, world: TPose) => TPose): TPose;
-/** Inverse of `composeRectPose` — subtracts parent translation. */
-declare function decomposeRectPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose;
-/**
- * `compose` for a container whose pose defines a **frame**: the child's local
- * pose is offset into the parent's unrotated box, then the whole thing is
- * turned about the parent's center. Rotations add; the child keeps its size.
- *
- * Reduces to `composeRectPose` when the parent is upright, so a scene that
- * never rotates a container behaves identically under either strategy.
- *
- * Exact for translation and rotation. A parent carrying scale is outside what
- * this can express — see `PoseClosure`.
- */
-declare function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose;
-/** Inverse of `composeRigidPose` — un-turns about the parent's center, then
- *  subtracts the parent's offset. */
-declare function decomposeRigidPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose;
-/** Translation-only composition over `RectPose`. What a scene wants when a
- *  container groups its children but never turns them. */
-declare const RECT_POSE_COMPOSITION: PoseComposition<RectPose>;
-/** Composition over `RectPose` where a container's pose is a frame: rotating
- *  the container rotates its contents. */
-declare const RIGID_POSE_COMPOSITION: PoseComposition<RectPose>;
-/**
- * Build a `(id) => world pose | null` callback over a `PoseAdapter`.
- * Convenience for RenderLayers that take a `getPose` callback (selection
- * overlays, debug layers, etc.) so consumers don't hand-write a
- * `composeWorldPose` call per layer.
- *
- * Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the
- * common case is an id removed mid-render between selection state and the
- * next paint. Layers should treat `null` as "skip this id."
- */
-declare function worldPoseLookup<TPose>(adapter: PoseAdapter<TPose>, compose: (parent: TPose, child: TPose) => TPose): (id: string) => TPose | null;
+declare function textToPathsByPaint(data: TextOutlineSource, pose: PathInWorldPose, opts?: TextToPathOptions): TextPaintPath[];
+/**
+ * Load the outlines of every face `data` is set in — the requested faces and
+ * the ones they resolve to — so a following {@link textToPath} does not fail
+ * with `'outlines-loading'`. Resolves once each has loaded or failed.
+ */
+declare function loadTextOutlines(data: TextOutlineSource, opts?: TextToPathOptions): Promise<void>;
+
+/**
+ * Create Outlines: replace each selected text node with path nodes carrying
+ * its glyph outlines, giving up editability for geometry — the destructive
+ * conversion every vector editor has. One path per paint the text wears; one
+ * undoable batch; the replacement takes the text node's slot, so stacking
+ * order is unchanged.
+ */
+
+/** What a path minted by Create Outlines must carry — see
+ *  {@link CreateOutlinesAdapter.createPathNode}. */
+interface OutlinePathSpec {
+    /** The fill these glyphs wear, resolved: their run's, else the node's,
+     *  else the default text fill. `null` is no fill. */
+    fill: FillStyle | null;
+    /** The stroke they wear, resolved the same way; absent for none. */
+    stroke?: Stroke;
+    /** The parent the path goes under: the text's own, or the container
+     *  minted to hold a multi-paint text's paths. */
+    parent: string | null;
+}
+/** What `applyCreateOutlines` reads and writes through. */
+interface CreateOutlinesAdapter {
+    getSelection(): readonly NodeId[] | readonly string[];
+    /** The text node behind `id`, or `undefined` for anything else. */
+    getTextSource(id: NodeId): TextNodeSource | undefined;
+    /**
+     * Mint one path node of text node `sourceId`'s outlines. `path` is in world
+     * space. The node must wear `spec`'s fill and stroke — a text whose runs
+     * differ in paint gets one path per paint — and sit under `spec.parent`.
+     * The kit places it; only the consumer knows its data shape.
+     */
+    createPathNode(path: PolygonPath, sourceId: NodeId, spec: OutlinePathSpec): {
+        id: string;
+    };
+    /**
+     * Mint the container that holds a multi-paint text's paths, under `parent`.
+     * `bounds` is the world envelope of the paths. The kit puts the container in
+     * the text's slot and the paths inside it, in the text's order. Without
+     * this, the paths are laid flat in that slot instead.
+     */
+    createContainerNode?(sourceId: NodeId, spec: {
+        parent: string | null;
+        bounds: Rect;
+    }): {
+        id: string;
+    };
+    /** Full node for `id`, so undo restores the text node whole. Without it the
+     *  delete captures an `{ id }` stub. */
+    getNode?(id: string): {
+        id: string;
+    } | undefined | null;
+    /** Parent and sibling order — the reorder contract. With both, each path is
+     *  inserted at its text node's index; without, where `insertNode` defaults. */
+    getParent?(id: string): string | null;
+    getChildren?(parentId: string | null): readonly string[];
+    applyOps?(ops: Op[], label?: string): void;
+    setSelection?(ids: NodeId[]): void;
+    insertNode?(node: {
+        id: string;
+    }, index?: number): void;
+    removeNode?(id: string): void;
+}
+/** Outcome of {@link applyCreateOutlines}. */
+type CreateOutlinesResult = 
+/** `resultIds` are what replaced the text nodes at their level — a path,
+ *  a container, or a run of flat paths each — which is also what is now
+ *  selected in the text nodes' place. */
+{
+    kind: 'applied';
+    resultIds: string[];
+}
+/** Nothing selected is text with ink. */
+ | {
+    kind: 'noop';
+    reason: 'no-text';
+}
+/** Some selected text has no outline geometry; nothing was changed. */
+ | {
+    kind: 'failed';
+    reason: 'text-outlines';
+    error: TextOutlinesError;
+};
+/**
+ * Convert every text node in the selection to outlines, as one batch labeled
+ * "Create Outlines". Other selected nodes are left alone and stay selected.
+ * All or nothing: if any text node's face cannot supply outlines the scene is
+ * untouched and the error comes back in the result.
+ */
+declare function applyCreateOutlines(adapter: CreateOutlinesAdapter): CreateOutlinesResult;
 
 /** Boolean op identifiers — five Pathfinder primaries plus Crop. */
 type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop';
 /**
  * z-position descriptor for a path node. `parentId` is the direct parent
  * (or `null` for a top-level node); `index` is the position within that
- * parent's child order. Used by the optional `getZOrder` hook below to
- * reposition the result of a boolean op at the topmost source's slot.
+ * parent's child order — never a global render index.
  */
 /** @internal */
 interface BooleanZOrder {
@@ -2722,15 +3399,23 @@ interface BooleanZOrder {
 }
 /** Adapter the hook and the pure core both consume. */
 interface BooleansAdapter {
-    getSelection(): NodeId[];
+    getSelection(): readonly NodeId[] | readonly string[];
     getWorldPath(id: NodeId): Path | undefined;
+    /**
+     * Optional: the text node behind `id`, for an id `getWorldPath` has no path
+     * for. Its glyph outlines (`textToPath`) become the operand, so text can be
+     * cut, united or intersected like any shape.
+     */
+    getTextSource?(id: NodeId): TextNodeSource | undefined;
     compareZ(a: NodeId, b: NodeId): number;
     /**
      * Mint a new node from a boolean-op result `Path`. `producedBy` names the
      * op that synthesized it — adapters that store provenance (e.g. for a
-     * layer-panel icon) record it; others ignore the arg.
+     * layer-panel icon) record it; others ignore the arg. `sourceId` is the
+     * topmost source, whose slot the result takes: give the node that source's
+     * parent, or the kit's reorder cannot find it there.
      */
-    createPathNode(path: Path, producedBy: BooleanOp): {
+    createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId): {
         id: string;
     };
     /**
@@ -2745,12 +3430,22 @@ interface BooleansAdapter {
         id: string;
     } | undefined | null;
     /**
-     * Optional: return the parent + child-index of `id` so the result of a
-     * boolean op can be placed in the topmost source's z-slot. Adapters that
-     * also expose `getChildren`/`setChildOrder` (the `ReorderAdapter`
-     * contract) will have the kit emit a `createMoveToIndexOp` after the
-     * inserts. Adapters that omit this method get v1 behavior — the result
-     * lands wherever the adapter's plain `insertNode` defaults to.
+     * Optional: the reorder contract. With `getChildren` (and `getParent`, or
+     * every node reads as top-level) the kit reads each source's slot among its
+     * siblings, and with `setChildOrder` as well it moves the result into the
+     * topmost source's slot. Without them the result lands wherever
+     * `insertNode` defaults to. `defaultCommitAdapter` supplies all three.
+     */
+    getParent?(id: string): string | null;
+    getChildren?(parentId: string | null): readonly string[];
+    setChildOrder?(parentId: string | null, ids: string[]): void;
+    /**
+     * Optional override for the slot the kit otherwise reads through
+     * `getParent` / `getChildren`: `id`'s parent and its index in that
+     * parent's child order.
+     *
+     * @deprecated Supply `getParent` and `getChildren` instead, and the kit
+     * derives this.
      */
     getZOrder?(id: NodeId): BooleanZOrder | undefined;
     applyOps?(ops: Op[], label?: string): void;
@@ -2767,6 +3462,13 @@ type BooleanOpResult = {
 } | {
     kind: 'noop';
     reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result';
+}
+/** A text operand had no outline geometry. Nothing was changed: an op that
+ *  quietly dropped the operand would commit a different shape than asked. */
+ | {
+    kind: 'failed';
+    reason: 'text-outlines';
+    error: TextOutlinesError;
 };
 /**
  * Run one Boolean operation over the selected paths and commit the result as a
@@ -2844,6 +3546,33 @@ interface ContentHandlerEntry {
 /** Register a content handler. Returns a disposer that removes it. */
 declare function registerContentHandler(entry: ContentHandlerEntry): () => void;
 
+/**
+ * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)
+ * share: what their committed batch is called in history, whether it is
+ * recorded at all, and the callbacks fired as the gesture opens and closes.
+ *
+ * Move and rotate read it from their binding's params; resize reads it from
+ * the `resizePolicy` dep, where the rest of its options already live.
+ */
+
+/** The lifecycle options, as a binding's params or the resize policy carry
+ *  them. */
+interface GestureLifecycleOptions {
+    /** History label for the committed batch. Unset, the batch takes its first
+     *  op's label (a layout drop or a behavior names its own), else the
+     *  action's. */
+    label?: string;
+    /** Commit through `scene.untracked`: the edit lands, but no undo entry
+     *  records it and the consumer `applyOps` hook is bypassed. Unset, any
+     *  behavior's `defaultTransient: true` turns it on. */
+    transient?: boolean;
+    /** Fired once the gesture starts changing poses, with the ids it moves. */
+    onGestureStart?(ids: string[]): void;
+    /** Fired once per `onGestureStart`: `true` when the gesture wrote to the
+     *  document, `false` on cancel, abort, or a release with nothing to write. */
+    onGestureEnd?(committed: boolean): void;
+}
+
 /** Optional consumer seam: given a node and the affine `m` that a pose-transform
  *  action applied to the node's POSE, return updated `data` with the node's
  *  data-held geometry transformed by `m`, or `null` if this node has no
@@ -2860,6 +3589,10 @@ interface GeometryProjection {
 interface ViewApi {
     get(): View;
     set(v: View): void;
+    /** How this camera's world maps into the world the invocation edits in,
+     *  when that is a parallax plane — set by `inPlane` on the view it hands a
+     *  wrapped action. Absent or null: the camera's own world. */
+    plane?(): PlaneMap | null;
     /** Optional recenter callback. When wired, `viewportZoomAction`'s `reset`
      *  branch (Cmd-0) calls this instead of resetting to identity — letting
      *  consumers re-fit the page (or other reference bounds) into the workspace.
@@ -2892,8 +3625,9 @@ interface ViewApi {
      *  pass over what the asking view does not paint. */
     layerIsPainted?(layerId: string): boolean;
 }
-/** The part of the asking view a region hit-test consults. */
-type HitTestView = Pick<ViewApi, 'layerIsPainted'>;
+/** The part of the asking view a region hit-test consults. `get` is its
+ *  camera, which a parallax layer is picked through. */
+type HitTestView = RegionPickView;
 /**
  * Adapter dep for `areaSelectAction`.
  *
@@ -3222,6 +3956,10 @@ interface InsertDep {
         width: number;
         height: number;
     }, extras: InsertExtras): NodeId | null;
+    /** The scene layer `commit` puts the node on. An insert on a layer carrying
+     *  `parallax` is dragged out in that plane's world, so `bounds` arrive
+     *  there too. Omitted: the camera's world. */
+    layer?(): string;
 }
 /**
  * Adapter dep for `resizeAction`.
@@ -3229,7 +3967,7 @@ interface InsertDep {
  * Carries the behavior-shaping options the legacy `useResize` hook
  * exposed through `UseResizeOptions`: bounds-frame behaviors (e.g.
  * `lockAspectWithModifier`), world-space anchor-point snap behaviors (e.g.
- * `pointSnapToGrid`), and group-expansion (`expandIds`).
+ * `@weasel-js/guides`' `pointSnapToGrid`), and group-expansion (`expandIds`).
  *
  * Optional in `DepSchema`: when absent, `resizeAction` falls back to
  * identity defaults (no behaviors, identity expandIds). Consumers wire the
@@ -3239,7 +3977,7 @@ interface InsertDep {
  * The generic is erased to `unknown` at the schema entry; consumers cast at
  * the call site (mirrors the `scene` entry's convention).
  */
-interface ResizePolicy<TPose> {
+interface ResizePolicy<TPose> extends GestureLifecycleOptions {
     /** Bounds-frame constraints. Constrained to `TPose extends Bounds` since
      *  constraints read/write `{x,y,width,height}`. For non-rect TPose pass `[]`. */
     constraints: TPose extends Bounds ? BoundsConstraint<TPose>[] : never[];
@@ -3261,6 +3999,8 @@ interface LayoutDep {
     /** Which container wins when several contain the drop point. Default
      *  `'innermost'`. */
     dropTarget?: LayoutDropTargetMode;
+    /** Carries displaced siblings to their slots over time. Absent, they snap. */
+    reflow?: ReflowTransition<unknown> | null;
 }
 /**
  * Dep for `enterTextEditAction`.
@@ -3307,12 +4047,15 @@ interface ClipboardDep {
     isEmpty(): boolean;
 }
 /**
- * Consumer-supplied commit for the Slice action. `commit` receives the finite
- * slice segment (world coords); the consumer scans the scene, splits crossed
- * paths via `splitPathByLine`, and applies the result as one undoable batch.
+ * The commit behind the Slice action. `commit` receives the cut as a polyline
+ * of at least two points (world coords): the drag's two ends for a straight
+ * cut, its whole trail for a freehand one, the placed points for a
+ * click-by-click one, whose last point equals its first when it closes into
+ * a loop. `<SceneCanvas>` publishes one over its scene (`useSliceDepSource`);
+ * a consumer replaces it with `useSliceDep`.
  */
 interface SliceDep {
-    commit(a: Point2, b: Point2): void;
+    commit(cut: ReadonlyArray<Point2>): void;
 }
 /**
  * The names an action may declare in `requires`, and what each resolves to.
@@ -3320,7 +4063,7 @@ interface SliceDep {
  * This is the whole vocabulary of things an action can reach — selection,
  * scene, view, history, and the rest. The interface itself is declared empty
  * in `@weasel-js/routing`, which knows that an action names its dependencies
- * but not what any of them are; these 24 entries are the kit's, merged in from
+ * but not what any of them are; these entries are the kit's, merged in from
  * outside exactly the way a consumer merges its own
  * (`declare module '@weasel-js/core'`).
  */
@@ -3372,6 +4115,12 @@ declare module '@weasel-js/routing' {
          * absent means no snapping (identity).
          */
         snap?: SnapDep;
+        /**
+         * The canvas's debug sink — the one tools reach as `ToolCtx.debug`.
+         * Sourced by `<SceneCanvas>`; absent while its `debug` overlay is off.
+         * Actions report what they did here, and the overlay draws it.
+         */
+        debug?: DebugSink;
         /**
          * Lasso-select dep — polygon hit-test + selection read/write.
          *
@@ -3428,6 +4177,13 @@ declare module '@weasel-js/routing' {
          * invoker reads `deps.booleansAdapter` to execute the op.
          */
         booleansAdapter?: BooleansAdapter;
+        /**
+         * Create Outlines adapter — read selection ids, resolve text nodes, and
+         * mint the path nodes that replace them. Consumers wire it with
+         * `useCreateOutlinesAdapter(adapter)`; the `createOutlines` action reads it
+         * in both its `enabled` predicate and its invoker.
+         */
+        createOutlinesAdapter?: CreateOutlinesAdapter;
         /**
          * Gesture dispatcher control surface — exposes `cancelAll(reason)` so
          * actions that need to abort an in-flight handle (Escape cancels a
@@ -3443,11 +4199,8 @@ declare module '@weasel-js/routing' {
          */
         layout?: LayoutDep;
         /**
-         * Slice dep — consumer-supplied commit for the Slice action.
-         *
-         * Receives the finite slice segment in world coordinates; the consumer
-         * scans the scene, splits crossed paths via `splitPathByLine`, and
-         * applies the result as one undoable batch.
+         * Slice dep — the commit for the Slice action. `<SceneCanvas>` publishes
+         * `useSliceDepSource`; a consumer overrides it with `useSliceDep`.
          *
          * Optional: when absent, `sliceAction` is a no-op.
          */
@@ -3510,8 +4263,48 @@ declare module '@weasel-js/routing' {
          * by every surface under one `<PointerContextProvider>`.
          */
         pointer?: PointerContextValue;
+        /**
+         * The touch or pen long-press being held, if any: where, since when, how
+         * far through, and whether any binding would fire on it. Sourced by
+         * `<SceneCanvas>` from its gesture dispatcher; press feedback reads it.
+         */
+        longPress?: LongPressState;
+    }
+}
+
+/**
+ * The routing types that carry an overlay, bound to the kit's `RenderLayer`.
+ *
+ * `@weasel-js/routing` never reads an overlay — it collects the live ones and
+ * hands them back in scope order — so it leaves the element type open. What a
+ * weasel canvas draws is a `RenderLayer`, and every kit call site should see
+ * that rather than `unknown`, so core binds the parameter once, here, and
+ * re-exports these names under the ones they have always had.
+ */
+
+/** What a canvas overlay is, at this layer. */
+type Overlay = RenderLayer<unknown>;
+declare module '@weasel-js/routing' {
+    interface OverlaySchema {
+        overlay: RenderLayer<unknown>;
     }
 }
+/** Routing's `Contribution`, with overlays typed as `RenderLayer`. */
+type Contribution = Contribution$1<Overlay>;
+/** Routing's `ContributionChrome`, with overlays typed as `RenderLayer`. */
+type ContributionChrome = ContributionChrome$1<Overlay>;
+/** Routing's `Tool`, with overlays typed as `RenderLayer`. */
+type Tool<TScratch = unknown> = Tool$1<TScratch, Overlay>;
+/** A `Tool` of any scratch type: the element type for a list of mixed tools. */
+type AnyTool = AnyToolOf<Overlay>;
+/** Routing's `ToolDef` (what `defineTool` takes), with overlays typed as `RenderLayer`. */
+type ToolDef<TScratch = void> = ToolDef$1<TScratch, Overlay>;
+/** Routing's `ToolsApi`, with overlays typed as `RenderLayer`. */
+type ToolsApi = ToolsApi$1<Overlay>;
+/** Routing's `UseToolsOptions`, with overlays typed as `RenderLayer`. */
+type UseToolsOptions = UseToolsOptions$1<Overlay>;
+/** Routing's `useTools`, typed for `RenderLayer` overlays. */
+declare const useTools: (opts: UseToolsOptions) => ToolsApi;
 
 /** Options for stroke tessellation. */
 interface StrokeOptions {
@@ -3572,4 +4365,4 @@ declare function vignette({ amount, feather }: {
     feather?: number;
 }): Effect[];
 
-export { type DerivedDep as $, type SliceDep as A, type VertexColorChannel as B, type CullRect as C, type DrawCommand as D, type Effect as E, type InsertExtras as F, type GlMat3 as G, type SerializedScene as H, IDENTITY_COLOR_MATRIX as I, type GeometryProjection as J, type ContentHandlerEntry as K, type SvgIngestOptions as L, type Mesh as M, type Node as N, type PanBounds as O, type PathDrawCommand as P, type Animator as Q, type RenderTarget as R, SPRITE_STRIDE as S, type TextDrawCommand as T, ColorOverrideRegistry as U, type ViewAnimationOptions as V, WeaselRenderer as W, type UseSceneOptions as X, type SceneRegistry as Y, type RegisteredOp as Z, type PoseOverrides as _, type GroupDrawCommand as a, type StaggerDelay as a$, type ViewportDims as a0, type ViewApi as a1, ShaderProgram as a2, type BooleansAdapter as a3, type UseAnimatorOptions as a4, type SpringPresetName as a5, type EasingSpec as a6, type AnimationHandle as a7, type SampledTrack as a8, type AddLayerSpec as a9, type InterpolatorFactory as aA, type Keyframe as aB, type LassoSelectDep as aC, type LayerRecord as aD, type LayoutDep as aE, type LeafNode as aF, type LoopFactory as aG, type LoopOptions as aH, type NestedTimeline as aI, type NodeAtPointDep as aJ, type PhysicsHandle as aK, type PhysicsOptions as aL, PointerContextProvider as aM, type PointerContextValue as aN, type PointerWorldPos as aO, type PoseAdapter as aP, type PoseClosure as aQ, type PoseOverride as aR, RECT_POSE_COMPOSITION as aS, RIGID_POSE_COMPOSITION as aT, type ResizePolicy as aU, SPRING_PRESETS as aV, type SerializedNode as aW, type SnapDep as aX, type SpringOptions as aY, type SpringPreset as aZ, type StaggerBuilder as a_, type AddNodeSpec as aa, type AnimateToBoundsOptions as ab, type AreaSelectDep as ac, type BezierEasing as ad, type BooleanOp as ae, type BooleanOpResult as af, type ClipboardDep as ag, type ClipboardIngestCtx as ah, type ColorOverride as ai, type ColorOverrideFn as aj, type ContainerNode as ak, type DecayLoopConfig as al, type DecayOptions as am, EASINGS as an, type EasingFn as ao, type EasingName as ap, type EditAnchorsDep as aq, type EventBooking as ar, type EventBookingHandle as as, type EventTrack as at, type FitViewToBoundsOptions as au, IDENTITY_POSE_COMPOSITION as av, type IngestCtx as aw, type IngestionDep as ax, type InsertDep as ay, type Interpolate as az, type ImageDrawCommand as b, fitViewToBounds as b$, type StaggerFactory as b0, type StaggerOptions as b1, type StaggerPerItem as b2, type StaggerSpringPoseOptions as b3, type StaggerTweenOptions as b4, type SvgUnpacker as b5, type SystemLayerRecord as b6, type SystemLayerSpec as b7, type TextEditDep as b8, type TimelineClock as b9, easeInExpo as bA, easeInOut as bB, easeInOutBack as bC, easeInOutBounce as bD, easeInOutCirc as bE, easeInOutCubic as bF, easeInOutElastic as bG, easeInOutExpo as bH, easeInOutQuad as bI, easeInOutQuart as bJ, easeInOutQuint as bK, easeInOutSine as bL, easeInQuad as bM, easeInQuart as bN, easeInQuint as bO, easeInSine as bP, easeOut as bQ, easeOutBack as bR, easeOutBounce as bS, easeOutCirc as bT, easeOutCubic as bU, easeOutElastic as bV, easeOutExpo as bW, easeOutQuad as bX, easeOutQuart as bY, easeOutQuint as bZ, easeOutSine as b_, type TimelineEvent as ba, type TimelineHandle as bb, type TimelineOptions as bc, type TimelineTrack as bd, type Track as be, type TweenLoopOptions as bf, type TweenOptions as bg, type UserLayerRecord as bh, VIEW_ANIMATION_KEY as bi, type ViewAnimationApi as bj, type ViewChannel as bk, applyBooleanOp as bl, asNodeId as bm, composeRectPose as bn, composeRigidPose as bo, composeWorldPose as bp, createPointerStore as bq, cubicBezierEasing as br, decomposeRectPose as bs, decomposeRigidPose as bt, easeIn as bu, easeInBack as bv, easeInBounce as bw, easeInCirc as bx, easeInCubic as by, easeInElastic as bz, type ImageMinification as c, linear as c0, rebaseLocalPose as c1, registerContentHandler as c2, resolveEasing as c3, resolveStrokeWidth as c4, translateRectPose as c5, useDecayLoop as c6, usePointerContext as c7, usePointerPosition as c8, useViewAnimation as c9, useViewAnimationOn as ca, worldPoseLookup as cb, ShaderCompileError as d, type ShaderDrawCommand as e, type ShaderProgramHandle as f, type ShaderUniform as g, type SolidPaint as h, type SpriteSheet as i, type SpritesDrawCommand as j, type StrokeOptions as k, type WeaselRendererOptions as l, blur as m, buildGradientRamp as n, cullDrawCommands as o, frameRect as p, mat3 as q, registerEffect as r, registerProgram as s, tessellateStroke as t, vignette as u, viewToMat3 as v, type Scene as w, type RectPose as x, type InertiaConfig as y, type PoseComposition as z };
+export { type SvgIngestOptions as $, type PoseComposition as A, type PoseAdapter as B, type CullRect as C, type DrawCommand as D, type Effect as E, type GestureLifecycleOptions as F, type GroupDrawCommand as G, type SliceDep as H, IDENTITY_COLOR_MATRIX as I, type ToolsApi as J, type Tool as K, type Contribution as L, type LayerHit as M, type Node as N, type ChromeState as O, type PathDrawCommand as P, type VertexColorChannel as Q, type RenderOptions as R, SPRITE_STRIDE as S, type TextDrawCommand as T, type LayerGroup as U, type ViewAnimationOptions as V, WeaselRenderer as W, type InsertExtras as X, type SerializedScene as Y, type GeometryProjection as Z, type ContentHandlerEntry as _, type ImageDrawCommand as a, type LayoutMove as a$, type AnyTool as a0, type PanBounds as a1, type Animator as a2, ColorOverrideRegistry as a3, type UseSceneOptions as a4, type SceneRegistry as a5, type RegisteredOp as a6, type PoseOverrides as a7, type DerivedDep as a8, type ViewportDims as a9, type ContainerNode as aA, type ContributionChrome as aB, type CreateOutlinesResult as aC, type CustomPaintContext as aD, type DecayLoopConfig as aE, type DecayOptions as aF, type DerivePathFn as aG, type EditAnchorsDep as aH, type EventBooking as aI, type EventBookingHandle as aJ, type EventTrack as aK, type FitViewToBoundsOptions as aL, type HitTestView as aM, IDENTITY_POSE_COMPOSITION as aN, type IngestCtx as aO, type IngestionDep as aP, type InsertDep as aQ, type Interpolate as aR, type InterpolatorFactory as aS, type Keyframe as aT, type LassoSelectDep as aU, type LayerCommandCache as aV, type LayerDrawFailure as aW, type LayerDrawSpan as aX, type LayerRecord as aY, type LayoutDep as aZ, type LayoutFrame as a_, type ViewApi as aa, type Affordance as ab, type AffordanceRegion as ac, type AffordanceBinding as ad, type CommonAffordanceScratch as ae, type DerivePoseFn as af, type BooleansAdapter as ag, type CreateOutlinesAdapter as ah, type UseAnimatorOptions as ai, type AnimationHandle as aj, type SampledTrack as ak, type SceneArrivalHandler as al, type AddLayerSpec as am, type AddNodeSpec as an, type AnimateToBoundsOptions as ao, type AnimationInfo as ap, type AnimationKind as aq, type AnimatorEvent as ar, type AnimatorListener as as, type AreaSelectDep as at, type BooleanOp as au, type BooleanOpResult as av, type ClipboardDep as aw, type ClipboardIngestCtx as ax, type ColorOverride as ay, type ColorOverrideFn as az, type ImageMinification as b, loadTextOutlines as b$, type LeafNode as b0, type LiveAnimation as b1, type LoopFactory as b2, type LoopOptions as b3, type NestedTimeline as b4, type NodeAtPointDep as b5, type OutlinePathSpec as b6, type Overlay as b7, type PathInWorldPose as b8, type PhysicsHandle as b9, type TextPaintPath as bA, type TextToPathOptions as bB, type TimelineClock as bC, type TimelineEvent as bD, type TimelineHandle as bE, type TimelineOptions as bF, type TimelineTrack as bG, type ToolDef as bH, type Track as bI, type TweenLoopOptions as bJ, type TweenOptions as bK, type UseToolsOptions as bL, type UserLayerRecord as bM, VIEW_ANIMATION_KEY as bN, type ViewAnimationApi as bO, type ViewChannel as bP, applyBooleanOp as bQ, applyCreateOutlines as bR, asNodeId as bS, composeWorldPose as bT, createPointerStore as bU, depsUnchanged as bV, drawLayers as bW, drawOneLayer as bX, fitViewToBounds as bY, isLayerPainted as bZ, isLayerVisible as b_, type PhysicsOptions as ba, PointerContextProvider as bb, type PointerContextValue as bc, type PointerWorldPos as bd, type PoseClosure as be, type PoseOverride as bf, type ResizePolicy as bg, type SerializedLayer as bh, type SerializedNode as bi, type SnapDep as bj, type SpringOptions as bk, type StaggerBuilder as bl, type StaggerDelay as bm, type StaggerFactory as bn, type StaggerOptions as bo, type StaggerPerItem as bp, type StaggerSpringPoseOptions as bq, type StaggerTweenOptions as br, type SvgUnpacker as bs, type SystemLayerRecord as bt, type SystemLayerSpec as bu, type TextEditDep as bv, type TextNodeSource as bw, type TextOutlineSource as bx, TextOutlinesError as by, type TextOutlinesFailure as bz, type RenderSpan as c, pathInPoseFrame as c0, pathInWorld as c1, rebaseLocalPose as c2, registerContentHandler as c3, resolveStrokeWidth as c4, subscribeToSources as c5, textToPath as c6, textToPathsByPaint as c7, useDecayLoop as c8, usePointerContext as c9, usePointerPosition as ca, useTools as cb, useViewAnimation as cc, useViewAnimationOn as cd, worldEditToStorage as ce, type RenderSpanStats as d, type RenderStats as e, type RenderTarget as f, type ShaderDrawCommand as g, type SolidPaint as h, type SpriteSheet as i, type SpritesDrawCommand as j, type StrokeOptions as k, type WeaselRendererOptions as l, blur as m, buildGradientRamp as n, cullDrawCommands as o, frameRect as p, vignette as q, registerEffect as r, type RenderLayer as s, tessellateStroke as t, type Dims as u, viewToMat3 as v, type RedrawSource as w, type Scene as x, type RectPose as y, type InertiaConfig as z };