@weasel-js/core 1.7.0 → 1.7.2

package/dist/{builtins-DLn2lCr_.d.ts → builtins-C-gRyVRx.d.ts}

@@ -1,18 +1,85 @@
-import { GradStop, ColorSpace, TextureHandle, FillStyle, Stroke, ScreenLength } from '@weasel-js/paint';
-import { NodeId, Bounds, View, ModifierState, SelectionApi, ActionDeps, IngestItem, DragSample, Point2, AnyToolOf, Contribution as Contribution$1, ContributionChrome as ContributionChrome$1, Tool as Tool$1, ToolDef as ToolDef$1 } from '@weasel-js/routing';
-import { P as Path } from './path-JEV2c5If.js';
+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-D-9QWBy5.js';
-import { P as PoseDescriptor } from './poseDescriptor-rZa9W5hJ.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-A37hYkeR.js';
+import { FontStyle } from '@weasel-js/font';
+import { ResolvedRun, TextStyle, TextVerticalAlign, StyledRun } from '@weasel-js/text';
+import { P as PoseDescriptor } from './poseDescriptor-D-OH-tu5.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-qYpyTAiZ.js';
-import { Mat3 } from '@weasel-js/geom';
-import { ResolvedRun, TextStyle, TextVerticalAlign } from '@weasel-js/text';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './types-B_9g6hMM.js';
 import { CursorSpec } from '@weasel-js/cursor';
 import { ClaimableGesture } from '@weasel-js/gestures';
-import { Reflection } from '@weasel-js/registry';
+
+/**
+ * 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
@@ -59,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;
@@ -96,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.
@@ -110,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> {
@@ -128,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`. */
@@ -136,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. */
@@ -171,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. */
@@ -186,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'`). */
@@ -196,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;
 }
@@ -240,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 })`.
@@ -248,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> {
@@ -271,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
@@ -360,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>;
@@ -427,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.
@@ -450,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. */
@@ -477,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):
@@ -520,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
@@ -634,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;
@@ -741,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);
@@ -775,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. */
@@ -833,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
@@ -853,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.
@@ -879,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
@@ -970,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 {
@@ -1072,72 +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;
-interface ProgramSource {
-    vert: string;
-    frag: string;
-}
-/** Every registered program's GLSL source, keyed by program id. */
-declare const programSourceRegistry: Reflection<ProgramSource>;
-/**
- * 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.
  *
@@ -1257,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;
@@ -1514,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
@@ -1575,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;
@@ -1601,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;
@@ -1611,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;
     /**
@@ -1624,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
@@ -1631,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. */
@@ -1645,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. */
@@ -1678,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;
@@ -1783,6 +1823,11 @@ 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[];
@@ -1854,7 +1899,11 @@ interface AffordanceRegion<TScratch = unknown> {
     targetId: string | null;
     /** Region geometry, expressed in the target's local frame.
      *
-     *  - `point` — circular hit (`hitRadiusPx` is screen-space).
+     *  - `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-
@@ -1867,6 +1916,16 @@ interface AffordanceRegion<TScratch = unknown> {
         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;
@@ -1889,8 +1948,8 @@ interface AffordanceRegion<TScratch = unknown> {
         innerHeight: number;
         /** Minimum band thickness outside the inner rect, in **screen**
          *  pixels. The framework widens `rx`/`ry` to at least
-         *  `innerHalfExtent + minBandPx / meanScale(view.scale)` for both
-         *  paint and hit-test.
+         *  `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
@@ -2122,6 +2181,8 @@ declare function subscribeToSources(sources: readonly {
 }[] | (() => 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
@@ -2235,6 +2296,15 @@ interface RenderLayer<TData> {
      */
     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)`.
@@ -2255,8 +2325,10 @@ interface RenderLayer<TData> {
  * `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[]): DrawCommand[];
+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.
@@ -2288,6 +2360,9 @@ declare function isLayerPainted<TData>(layer: RenderLayer<TData>, visibility: Re
  * 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 {
@@ -2406,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
@@ -2428,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
@@ -2445,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. */
@@ -2453,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;
@@ -2489,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;
@@ -2636,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 {
@@ -2684,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`
@@ -2708,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
@@ -2731,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. */
@@ -2755,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`. */
@@ -2889,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. */
@@ -2899,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. */
@@ -2920,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>;
@@ -2931,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;
@@ -2945,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
@@ -2973,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
@@ -3091,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.
- *
- * `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 }`.
+ * 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 composeWorldPose<TPose>(adapter: PoseAdapter<TPose>, id: string, compose: (parent: TPose, child: TPose) => TPose): TPose;
+declare function pathInWorld(path: Path, pose: PathInWorldPose): 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.
+ * 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.
  *
- * 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.
+ * 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 composeRectPose<TPose extends RectPose>(parent: TPose, child: 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;
+};
+
 /**
- * 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.
+ * 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.
+ *
+ * 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 translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): 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;
+}
 /**
- * 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.
+ * Why a text node has no outline geometry to give:
  *
- * `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.
+ * - `'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 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;
+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);
+}
 /**
- * `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.
+ * 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.
  *
- * 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`.
+ * `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 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>;
+declare function textToPath(data: TextOutlineSource, pose: PathInWorldPose, opts?: TextToPathOptions): PolygonPath;
 /**
- * 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.
+ * {@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.
  *
- * 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."
+ * 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 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.
  */
-declare function worldPoseLookup<TPose>(adapter: PoseAdapter<TPose>, compose: (parent: TPose, child: TPose) => TPose): (id: string) => TPose | null;
+
+/** 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 {
@@ -3237,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;
     };
     /**
@@ -3260,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;
@@ -3282,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
@@ -3402,6 +3589,14 @@ 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;
+    /** How the world the invocation edits in maps into the world `layer`'s
+     *  nodes are stored in, read now — set by `inPlane` alongside `plane`.
+     *  Absent or null: the same world. */
+    planeOf?(layer: string): 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.
@@ -3434,8 +3629,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`.
  *
@@ -3764,6 +3960,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`.
@@ -3771,7 +3971,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
@@ -3803,6 +4003,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`.
@@ -3849,12 +4051,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 `splitPathBySegment`, 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.
@@ -3862,7 +4067,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'`).
  */
@@ -3914,6 +4119,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.
          *
@@ -3970,6 +4181,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
@@ -3985,11 +4203,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 `splitPathBySegment`, 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.
          */
@@ -4052,6 +4267,12 @@ 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;
     }
 }
 
@@ -4072,13 +4293,21 @@ declare module '@weasel-js/routing' {
         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. */
@@ -4140,4 +4369,4 @@ declare function vignette({ amount, feather }: {
     feather?: number;
 }): Effect[];
 
-export { type InsertExtras as $, type Scene as A, type RectPose as B, type CullRect as C, type DrawCommand as D, type Effect as E, type InertiaConfig as F, type GlMat3 as G, type GestureLifecycleOptions as H, IDENTITY_COLOR_MATRIX as I, type PoseComposition as J, type SliceDep as K, type ToolsApi as L, type Mesh as M, type Node as N, type Tool as O, type PathDrawCommand as P, type Contribution as Q, type RenderTarget as R, SPRITE_STRIDE as S, type TextDrawCommand as T, type LayerHit as U, type ViewAnimationOptions as V, WeaselRenderer as W, type ChromeState as X, type VertexColorChannel as Y, type RedrawSource as Z, type LayerGroup as _, type GroupDrawCommand as a, type LoopFactory as a$, type SerializedScene as a0, type GeometryProjection as a1, type ContentHandlerEntry as a2, type SvgIngestOptions as a3, type AnyTool as a4, type PanBounds as a5, type Animator as a6, ColorOverrideRegistry as a7, type UseSceneOptions as a8, type SceneRegistry as a9, type ColorOverrideFn as aA, type ContainerNode as aB, type ContributionChrome as aC, type CustomPaintContext as aD, type DecayLoopConfig as aE, type DecayOptions as aF, EASINGS as aG, type EasingFn as aH, type EasingName as aI, type EditAnchorsDep as aJ, type EventBooking as aK, type EventBookingHandle as aL, type EventTrack as aM, type FitViewToBoundsOptions as aN, IDENTITY_POSE_COMPOSITION as aO, type IngestCtx as aP, type IngestionDep as aQ, type InsertDep as aR, type Interpolate as aS, type InterpolatorFactory as aT, type Keyframe as aU, type LassoSelectDep as aV, type LayerCommandCache as aW, type LayerDrawFailure as aX, type LayerRecord as aY, type LayoutDep as aZ, type LeafNode as a_, type RegisteredOp as aa, type PoseOverrides as ab, type DerivedDep as ac, type ViewportDims as ad, type ViewApi as ae, type Affordance as af, type AffordanceRegion as ag, type AffordanceBinding as ah, type CommonAffordanceScratch as ai, ShaderProgram as aj, type BooleansAdapter as ak, type UseAnimatorOptions as al, type SpringPresetName as am, type EasingSpec as an, type AnimationHandle as ao, type SampledTrack as ap, type AddLayerSpec as aq, type AddNodeSpec as ar, type AnimateToBoundsOptions as as, type AreaSelectDep as at, type BezierEasing as au, type BooleanOp as av, type BooleanOpResult as aw, type ClipboardDep as ax, type ClipboardIngestCtx as ay, type ColorOverride as az, type ImageDrawCommand as b, easeInOutBack as b$, type LoopOptions as b0, type NestedTimeline as b1, type NodeAtPointDep as b2, type PhysicsHandle as b3, type PhysicsOptions as b4, PointerContextProvider as b5, type PointerContextValue as b6, type PointerWorldPos as b7, type PoseAdapter as b8, type PoseClosure as b9, type Track as bA, type TweenLoopOptions as bB, type TweenOptions as bC, type UseToolsOptions as bD, type UserLayerRecord as bE, VIEW_ANIMATION_KEY as bF, type ViewAnimationApi as bG, type ViewChannel as bH, applyBooleanOp as bI, asNodeId as bJ, composeRectPose as bK, composeRigidPose as bL, composeWorldPose as bM, createPointerStore as bN, cubicBezierEasing as bO, decomposeRectPose as bP, decomposeRigidPose as bQ, drawLayers as bR, drawOneLayer as bS, easeIn as bT, easeInBack as bU, easeInBounce as bV, easeInCirc as bW, easeInCubic as bX, easeInElastic as bY, easeInExpo as bZ, easeInOut as b_, type PoseOverride as ba, RECT_POSE_COMPOSITION as bb, RIGID_POSE_COMPOSITION as bc, type ResizePolicy as bd, SPRING_PRESETS as be, type SerializedNode as bf, type SnapDep as bg, type SpringOptions as bh, type SpringPreset as bi, type StaggerBuilder as bj, type StaggerDelay as bk, type StaggerFactory as bl, type StaggerOptions as bm, type StaggerPerItem as bn, type StaggerSpringPoseOptions as bo, type StaggerTweenOptions as bp, type SvgUnpacker as bq, type SystemLayerRecord as br, type SystemLayerSpec as bs, type TextEditDep as bt, type TimelineClock as bu, type TimelineEvent as bv, type TimelineHandle as bw, type TimelineOptions as bx, type TimelineTrack as by, type ToolDef as bz, type ImageMinification as c, easeInOutBounce as c0, easeInOutCirc as c1, easeInOutCubic as c2, easeInOutElastic as c3, easeInOutExpo as c4, easeInOutQuad as c5, easeInOutQuart as c6, easeInOutQuint as c7, easeInOutSine as c8, easeInQuad as c9, usePointerPosition as cA, useTools as cB, useViewAnimation as cC, useViewAnimationOn as cD, worldPoseLookup as cE, easeInQuart as ca, easeInQuint as cb, easeInSine as cc, easeOut as cd, easeOutBack as ce, easeOutBounce as cf, easeOutCirc as cg, easeOutCubic as ch, easeOutElastic as ci, easeOutExpo as cj, easeOutQuad as ck, easeOutQuart as cl, easeOutQuint as cm, easeOutSine as cn, fitViewToBounds as co, isLayerPainted as cp, isLayerVisible as cq, linear as cr, rebaseLocalPose as cs, registerContentHandler as ct, resolveEasing as cu, resolveStrokeWidth as cv, subscribeToSources as cw, translateRectPose as cx, useDecayLoop as cy, usePointerContext as cz, type ProgramSource as d, ShaderCompileError as e, type ShaderDrawCommand as f, type ShaderProgramHandle as g, type ShaderUniform as h, type SolidPaint as i, type SpriteSheet as j, type SpritesDrawCommand as k, type StrokeOptions as l, type WeaselRendererOptions as m, blur as n, buildGradientRamp as o, cullDrawCommands as p, frameRect as q, mat3 as r, programSourceRegistry as s, registerEffect as t, registerProgram as u, tessellateStroke as v, viewToMat3 as w, vignette as x, type RenderLayer as y, type Dims 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 };