@weasel-js/core 1.2.0 → 1.3.0-pre.0

package/dist/renderer.d.ts

@@ -1,40 +1,12 @@
-import { M as Mesh, I as ImageMinification, G as GLImageCache } from './stroke-DaxnQ-u7.js';
-export { S as SpriteSheet, a as StrokeOptions, V as ViewLike, f as frameRect, t as tessellateStroke, v as viewToMat3 } from './stroke-DaxnQ-u7.js';
-import { G as GradStop } from './paint-types-1fUdZUaH.js';
-export { a as TextureHandle, r as registerTexture } from './paint-types-1fUdZUaH.js';
-import { M as Mat3, S as ShaderProgramHandle, D as DrawCommand } from './DrawCommand-uNkv5TjO.js';
-export { G as GroupDrawCommand, I as ImageDrawCommand, P as PathDrawCommand, a as ShaderDrawCommand, b as ShaderUniform, c as SolidPaint, T as TextDrawCommand, m as mat3, r as registerProgram } from './DrawCommand-uNkv5TjO.js';
-import { P as Path } from './path-B6MMiodD.js';
+import { M as Mesh, S as ShaderProgram, I as ImageMinification, G as GLImageCache } from './stroke-5pBwOm9s.js';
+export { a as ShaderCompileError, b as SpriteSheet, c as StrokeOptions, V as ViewLike, f as frameRect, t as tessellateStroke, v as viewToMat3 } from './stroke-5pBwOm9s.js';
+import { GradStop, TextureHandle } from '@weasel-js/paint';
+export { TextureHandle } from '@weasel-js/paint';
+import { M as Mat3, S as ShaderProgramHandle, D as DrawCommand } from './DrawCommand-BnZyQaDc.js';
+export { G as GroupDrawCommand, I as ImageDrawCommand, P as PathDrawCommand, a as ShaderDrawCommand, b as ShaderUniform, c as SolidPaint, T as TextDrawCommand, m as mat3, r as registerProgram } from './DrawCommand-BnZyQaDc.js';
+import { P as Path } from './path-JEV2c5If.js';
 export { canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
-
-/**
- * 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;
-}
+import '@weasel-js/text';
 
 interface GLMeshHandle {
     readonly vao: WebGLVertexArrayObject;
@@ -227,6 +199,28 @@ declare class GroupState {
     pop(): void;
 }
 
+/**
+ * registerTexture — accepts an image source, assigns an opaque id, stores in
+ * a module-level registry. Actual GL upload happens lazily at draw time in
+ * drawShader() via GLTextureCache.upload (which is idempotent).
+ *
+ * Lifecycle: textures live for the renderer's lifetime. No unregister in v1.
+ *
+ * Convention §9: this registry stores image data only — no per-renderer state.
+ * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).
+ */
+
+/**
+ * Register an image for use as a shader texture uniform.
+ *
+ * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.
+ * The handle is valid for the lifetime of the renderer it will be used with.
+ *
+ * @param image  The image to register. HTMLImageElement must be fully loaded.
+ * @returns      Opaque TextureHandle.
+ */
+declare function registerTexture(image: HTMLImageElement | ImageBitmap): TextureHandle;
+
 /**
  * Growable vertex staging for consecutive solid-fill geometry.
  *
@@ -373,6 +367,13 @@ declare class WeaselRenderer {
      * @experimental
      */
     registerProgram(handle: ShaderProgramHandle): void;
+    /**
+     * The compiled program for `id`, compiling it against this context on first
+     * use. Unlike {@link registerProgram} this neither throws on a missing
+     * source nor on a compile failure: a paint kind asking for a program it
+     * never registered must decline the paint, not take down the frame.
+     */
+    private ensureProgram;
     private applyViewport;
     isContextLost(): boolean;
     private onContextLost;
@@ -461,4 +462,4 @@ declare function tessellate(path: Path, opts?: TessellateOptions): Mesh;
  */
 declare const OUTLINE_MIN_SCREEN_PX = 48;
 
-export { DrawCommand, IDENTITY_COLOR_MATRIX, ImageMinification, Mat3, Mesh, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, ShaderProgramHandle, type TessellateOptions, WeaselRenderer, type WeaselRendererOptions, buildGradientRamp, tessellate };
+export { DrawCommand, IDENTITY_COLOR_MATRIX, ImageMinification, Mat3, Mesh, OUTLINE_MIN_SCREEN_PX, ShaderProgramHandle, type TessellateOptions, WeaselRenderer, type WeaselRendererOptions, buildGradientRamp, registerTexture, tessellate };

package/dist/renderer.js

@@ -1,12 +1,12 @@
-export { IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, WeaselRenderer, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-7KYLIC3E.js';
-import './chunk-CKADTCHK.js';
-import './chunk-CSMF654J.js';
-import './chunk-J7LUY47N.js';
-import './chunk-4Z6J4IVH.js';
-import './chunk-ADWOB5K2.js';
-import './chunk-UGFFCMQP.js';
-import './chunk-BHVYVFGV.js';
-import './chunk-GVCNT7UH.js';
-export { registerTexture } from './chunk-HGF5X6MZ.js';
+export { IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, WeaselRenderer, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-IFOVTYAK.js';
+import './chunk-3ZV53ZW2.js';
+import './chunk-AQS4JGRA.js';
+import './chunk-3FB44DBC.js';
+import './chunk-F74NVEHT.js';
+import './chunk-67KE7SDP.js';
+import './chunk-MXFSHJOM.js';
+import './chunk-ZB7UYJVG.js';
+import './chunk-2KKYDDDD.js';
+export { registerTexture } from './chunk-BJN5ZRIJ.js';
 //# sourceMappingURL=renderer.js.map
 //# sourceMappingURL=renderer.js.map

package/dist/resize.d.ts

@@ -1,11 +1,11 @@
-export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, U as UseResizeOptions, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-BBtn5bus.js';
-export { P as PoseProjection, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR } from './geometry-C56YbnfD.js';
-import { R as ResizePose, B as BoundsConstraint, M as ModifierState } from './types-BhrifbZ1.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, U as UseResizeOptions, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle, p as pointSnapToGrid } from './pointSnapToGrid-Dmthv94u.js';
+export { P as PoseProjection, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR } from './geometry-Dtt_k6Dq.js';
+import { R as ResizePose, B as BoundsConstraint, M as ModifierState } from './types-miXHGrZM.js';
 import { G as Guide } from './types-D2tTKEU0.js';
 import { V as View } from './view-DSQgxBJB.js';
 import './types-BHK2dkMu.js';
 import '@weasel-js/history';
-import './types-DbysOO-2.js';
+import './types-XBcDEp3Y.js';
 
 /** Resize constraint that stops a node shrinking past a minimum. The anchored
  *  edge stays put, so clamping pushes the dragged edge back rather than moving

package/dist/resize.js

@@ -1,4 +1,4 @@
-export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-J7LUY47N.js';
-export { RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR } from './chunk-4Z6J4IVH.js';
+export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-3FB44DBC.js';
+export { RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR } from './chunk-F74NVEHT.js';
 //# sourceMappingURL=resize.js.map
 //# sourceMappingURL=resize.js.map

package/dist/routing.d.ts

@@ -1,17 +1,18 @@
 import { ParsedModifiers, GestureName, GestureSpec } from '@weasel-js/gestures';
 export { ChannelRef, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, GestureName, ModRequirement, ModifierKey, ParsedModifiers, ParsedRoute, PhaseAtom, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, RouteDescriptionPart, RouteFieldName, RouteTermLabel, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute } from '@weasel-js/gestures';
-import { T as Tool } from './registry-l3JX0Z6b.js';
-import './types-C2R2bjxf.js';
+import { T as Tool } from './registry-BU1_3L_C.js';
+import './types-DIQAisSG.js';
 import '@weasel-js/history';
-import './path-B6MMiodD.js';
-import './types-BhrifbZ1.js';
-import './types-DbysOO-2.js';
+import './path-JEV2c5If.js';
+import './types-miXHGrZM.js';
+import './types-XBcDEp3Y.js';
 import './view-DSQgxBJB.js';
 import '@weasel-js/modes';
 import 'react';
-import './geometry-C56YbnfD.js';
-import './paint-types-1fUdZUaH.js';
-import './DrawCommand-uNkv5TjO.js';
+import './DrawCommand-BnZyQaDc.js';
+import '@weasel-js/paint';
+import '@weasel-js/text';
+import './geometry-Dtt_k6Dq.js';
 import 'react/jsx-runtime';
 import './types-BHK2dkMu.js';
 import '@weasel-js/geom';
@@ -53,6 +54,16 @@ interface RegistryEntry {
      *  than re-walking `Tool.bindings`. */
     spec: GestureSpec;
 }
+/**
+ * Stand-in target for a `{ kindOf }` predicate spec.
+ *
+ * The route grammar can name target *classes* (`empty`, `selected-body`,
+ * `kind:rect`) but not arbitrary predicates, so three distinct select-tool
+ * bindings all render as this one token. Narrowing it would mean giving the
+ * grammar a way to describe a function, which is a real design question and
+ * not one this reflection layer should answer by inventing syntax.
+ */
+declare const PREDICATE_TARGET = "predicate";
 /**
  * Flatten every tool's `bindings` into route-registry rows.
  *
@@ -65,6 +76,21 @@ interface RegistryEntry {
  * suggested otherwise.
  */
 declare function buildRouteRegistry(tools: readonly Tool<unknown>[]): RegistryEntry[];
+/** The route-grammar gesture a `GestureSpec.kind` routes as, or `undefined`
+ *  for kinds the grammar has no name for. */
+declare function routeGestureForSpecKind(kind: GestureSpec['kind']): GestureName | undefined;
+/**
+ * Every route string one `GestureSpec` declares, in route-grammar notation.
+ *
+ * One string per arg alternative — a spec bound to `['ArrowUp','ArrowDown']`
+ * yields two routes, because each is separately conflictable and separately
+ * readable. Returns `[]` for spec kinds the grammar can't name.
+ *
+ * This is the display counterpart to {@link buildRouteRegistry}: same
+ * projection of a spec onto the grammar, rendered as text instead of as a
+ * conflict-checkable row.
+ */
+declare function routesForSpec(spec: GestureSpec): readonly string[];
 
 /** Two or more tools declare the same exact (phase, gesture, arg, target,
  *  modifiers) tuple — the dispatcher's slot precedence picks one
@@ -112,4 +138,4 @@ interface Conflict {
  */
 declare function findConflicts(tools: readonly Tool<unknown>[]): Conflict[];
 
-export { type Conflict, type RegistryEntry, buildRouteRegistry, findConflicts };
+export { type Conflict, PREDICATE_TARGET, type RegistryEntry, buildRouteRegistry, findConflicts, routeGestureForSpecKind, routesForSpec };

package/dist/routing.js

@@ -1,3 +1,3 @@
-export { GESTURE_DESCRIPTORS, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute } from './chunk-CKADTCHK.js';
+export { GESTURE_DESCRIPTORS, PREDICATE_TARGET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute, routeGestureForSpecKind, routesForSpec } from './chunk-3ZV53ZW2.js';
 //# sourceMappingURL=routing.js.map
 //# sourceMappingURL=routing.js.map

package/dist/{stroke-DaxnQ-u7.d.ts → stroke-5pBwOm9s.d.ts}

@@ -1,6 +1,35 @@
-import { M as Mat3 } from './DrawCommand-uNkv5TjO.js';
-import { P as Path } from './path-B6MMiodD.js';
-import { S as Stroke } from './paint-types-1fUdZUaH.js';
+import { M as Mat3 } from './DrawCommand-BnZyQaDc.js';
+import { P as Path } from './path-JEV2c5If.js';
+import { Stroke } from '@weasel-js/paint';
+
+/**
+ * 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.
@@ -130,6 +159,14 @@ declare function viewToMat3(view: View): Mat3;
 /** Options for stroke tessellation. */
 interface StrokeOptions {
     flattenTolerance?: number;
+    /**
+     * Shorten each open subpath by this much at its start / end, in the same
+     * world units as the path. Stroke markers use this so a filled head is not
+     * speared by its own line; the caller resolves the distance, because this
+     * layer knows nothing about the marker registry.
+     */
+    startInset?: number;
+    endInset?: number;
 }
 /** Resolve a stroke width to world units. A number is already world units;
  *  `{ px }` is screen pixels divided by the accumulated scale, so it holds its
@@ -150,4 +187,4 @@ declare function resolveStrokeWidth(width: number | {
  */
 declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
 
-export { GLImageCache as G, type ImageMinification as I, type Mesh as M, type SpriteSheet as S, type View as V, type StrokeOptions as a, frameRect as f, resolveStrokeWidth as r, tessellateStroke as t, viewToMat3 as v };
+export { GLImageCache as G, type ImageMinification as I, type Mesh as M, ShaderProgram as S, type View as V, ShaderCompileError as a, type SpriteSheet as b, type StrokeOptions as c, frameRect as f, resolveStrokeWidth as r, tessellateStroke as t, viewToMat3 as v };

package/dist/{types-C2R2bjxf.d.ts → types-DIQAisSG.d.ts}

@@ -1,6 +1,6 @@
 import * as _weasel_js_history from '@weasel-js/history';
 import { Op, SerializedHistory } from '@weasel-js/history';
-import { P as Path } from './path-B6MMiodD.js';
+import { P as Path } from './path-JEV2c5If.js';
 
 /**
  * Axis-aligned rectangle pose with optional rotation. The canonical pose
@@ -79,6 +79,20 @@ interface NodeBase<TData, TLayer extends string, TPose> {
     pose: TPose;
     data: TData;
     parent: NodeId | null;
+    /** Nodes whose poses this node's geometry is computed from. Fixed at add
+     *  time. Absent or empty means the node's geometry is authored, which is the
+     *  normal case. */
+    dependsOn?: readonly NodeId[];
+    /** Computes this node's path from its dependencies' poses, in `dependsOn`
+     *  order. A dependency that has been removed arrives as `undefined`.
+     *  Returning `null` means "nothing to draw right now". Re-evaluated when a
+     *  dependency's world pose changes, never authored. Absolute-pose `Scene`
+     *  makes that the dependency's own pose, and an ancestor's move reaches it as
+     *  a `setPose` of its own from the container cascade.
+     *  `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 (TPose | undefined)[]) => Path | null;
 }
 /** A node with no children — a shape, a label, an image. */
 interface LeafNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
@@ -133,6 +147,11 @@ interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
     /** Only meaningful when `kind === 'container'`. Attach a clip-path function
      *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */
     clipFromPose?: (pose: TPose) => Path | null;
+    /** Mirrors `SceneNode.dependsOn`. */
+    dependsOn?: readonly NodeId[];
+    /** 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 (TPose | undefined)[]) => Path | null;
 }
 /** 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. */
@@ -180,6 +199,10 @@ interface SerializedNode<TData, TLayer extends string, TPose> {
     /** Registry key for the container's clip-path factory.
      *  Containers only; omitted when the container has no clip. */
     clipFromPoseKey?: string;
+    /** Ids this node's geometry derives from. Omitted when it derives from nothing. */
+    dependsOn?: readonly string[];
+    /** Registry key for the node's `derivePath` function. Omitted when it has none. */
+    derivePathKey?: string;
 }
 /** Per-scene registry mapping string keys to live function references.
  *  Passed to `createScene({ ..., registry })` and `sceneFromJSON(json, { registry })`.
@@ -187,6 +210,8 @@ interface SerializedNode<TData, TLayer extends string, TPose> {
 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 (TPose | undefined)[]) => Path | null>>;
 }
 /** Options for `useScene` — the layers the scene has, what it starts out
  *  holding, and how its history behaves. */
@@ -222,6 +247,58 @@ interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
      *  mode machines that depend on `scene.history`), pass nothing here and
      *  wire it after construction via `scene.setActiveJournalAccessor(fn)`. */
     getActiveJournal?: () => _weasel_js_history.Journal | null;
+    /** Re-render the host on every scene mutation. Default `true`. Set `false`
+     *  when the scene is read by a frame loop rather than by a render — a game
+     *  loop, a simulation — and nothing in the host's DOM derives from it.
+     *  Read by `useScene`; `createScene` ignores it. */
+    subscribe?: boolean;
+}
+/**
+ * One node's ephemeral presentation override — what a frame loop wants to say
+ * about a node without saying it about the document.
+ *
+ * Not document content: never recorded in history, never in `toJSON`, and
+ * writing one does not bump `Scene.getVersion()`. Hoist one entry per node and
+ * mutate it in place on a frame loop; `PoseOverrides.commit()` is what makes a
+ * mutation visible.
+ */
+interface PoseOverride<TPose> {
+    /** Replaces the node's document pose everywhere the render and hit-test
+     *  paths read one, including the clip a container derives from its pose.
+     *  Resolved by `effectivePose` — reading `node.pose` directly is how those
+     *  paths came to disagree about where a node is. */
+    pose?: TPose;
+    /** Multiplied into the node's painted alpha, on top of any `alphaFor`. */
+    alpha?: number;
+}
+/**
+ * The scene's ephemeral per-node overrides — see {@link PoseOverride}.
+ *
+ * The intended shape of a frame is: `set` each node once, mutate the entries
+ * in place per frame, `commit()` once. `commit` is not optional bookkeeping —
+ * the painter memo keys on pose *reference*, so a mutation without a commit
+ * paints the previous frame with no error.
+ *
+ * To promote a frame to document state (dropping a drag, baking an animation),
+ * write it once through `Scene.setPose` and `clear` the override.
+ */
+interface PoseOverrides<TPose> {
+    /** Store `entry` for `id` **by reference**; the caller keeps mutating it. */
+    set(id: NodeId, entry: PoseOverride<TPose>): void;
+    get(id: NodeId): PoseOverride<TPose> | undefined;
+    has(id: NodeId): boolean;
+    /** The overridden ids, as a snapshot array. */
+    ids(): readonly NodeId[];
+    clear(id: NodeId): void;
+    clearAll(): void;
+    /** Publish this frame's in-place mutations: invalidate the painter memo for
+     *  every overridden node, then notify subscribers. */
+    commit(): void;
+    /** Notified after every write. The canvas uses this to repaint without a
+     *  scene version bump. */
+    subscribe(fn: () => void): () => void;
+    /** Monotonic write counter. A snapshot for observers that poll. */
+    getGeneration(): number;
 }
 /**
  * The kit-owned scene tree: nodes, layers, and the undo history over both.
@@ -251,10 +328,19 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  not a live view, and not yours to mutate. */
     renderOrderNodes(): readonly Node<TData, TLayer, TPose>[];
     add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;
-    /** Delete `id` **and its entire subtree** — every descendant is removed in
-     *  the same operation. Recorded as one undoable step; `undo()` restores the
-     *  whole subtree (root + descendants, child order intact). */
+    /** Delete `id`, its **entire subtree**, and **everything that derives from**
+     *  any of those nodes — a node listing one of them in `dependsOn` goes too,
+     *  along with its own subtree, transitively. A dependent can live anywhere in
+     *  the tree, so this deletes nodes the caller never named and may unlink
+     *  several disjoint subtrees at once. Recorded as one undoable step; `undo()`
+     *  restores every one of them where it was, child order intact. */
     remove(id: NodeId): void;
+    /** {@link remove} over several roots at once, as a **single** undoable step.
+     *  Ids resolve against the tree as it stands at the call, so an id that
+     *  another one would cascade away is absorbed rather than removed twice —
+     *  which is what makes it safe to pass a whole selection. Throws if any id is
+     *  not in the scene; an empty list does nothing and records no step. */
+    removeMany(ids: readonly NodeId[]): void;
     update(id: NodeId, patch: {
         data: TData;
     }): void;
@@ -290,6 +376,9 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
     setLayerVisible(layer: TLayer, visible: boolean): void;
     setLayerLocked(layer: TLayer, locked: boolean): void;
     addLayer(spec: AddLayerSpec<TLayer>): void;
+    /** Drop a user layer and every node tagged to it, as one undoable step.
+     *  Removal cascades, so this also deletes nodes **on other layers** that
+     *  derive from a node on this one. */
     removeLayer(layer: TLayer): void;
     renameLayer(layer: TLayer, name: string): void;
     moveLayer(layer: TLayer, index: number): void;
@@ -331,6 +420,11 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  undo step of its own. */
     getSelection(): readonly NodeId[];
     setSelection(ids: readonly NodeId[]): void;
+    /** Per-node pose / alpha overrides the render and hit-test paths read
+     *  through. Like {@link Scene.getSelection} this is not document content:
+     *  writes are never recorded, never serialized, and do not bump
+     *  {@link Scene.getVersion}. See {@link PoseOverrides}. */
+    readonly overrides: PoseOverrides<TPose>;
     undo(): boolean;
     redo(): boolean;
     canUndo(): boolean;
@@ -396,4 +490,4 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
     getVersion(): number;
 }
 
-export { type AddLayerSpec as A, type ContainerNode as C, type LayerRecord as L, type NodeId as N, type RectPose as R, type Scene as S, type UseSceneOptions as U, type Node as a, type SerializedScene as b, type SceneRegistry as c, type RegisteredOp as d, type AddNodeSpec as e, type LeafNode as f, type SerializedNode as g, type SystemLayerRecord as h, type SystemLayerSpec as i, type UserLayerRecord as j, asNodeId as k };
+export { type AddLayerSpec as A, type ContainerNode as C, type LayerRecord as L, type NodeId as N, type PoseOverride as P, type RectPose as R, type Scene as S, type UseSceneOptions as U, type Node as a, type SerializedScene as b, type SceneRegistry as c, type RegisteredOp as d, type AddNodeSpec as e, type LeafNode as f, type PoseOverrides as g, type SerializedNode as h, type SystemLayerRecord as i, type SystemLayerSpec as j, type UserLayerRecord as k, asNodeId as l };

package/dist/{types-DbysOO-2.d.ts → types-XBcDEp3Y.d.ts}

@@ -178,13 +178,17 @@ interface MoveAdapter<TNode extends {
     /** Optional: see SceneAdapter.applyOps. */
     applyOps?(ops: Op[], label: string): void;
     findSnapTarget?(draggedId: string, worldX: number, worldY: number): SnapTarget<TPose> | null;
-    /** Optional: direct children of `id`. When present (alongside the
-     *  `cascadeWorldPose` option on `useMove`), dragging a node
-     *  auto-cascades its descendants in the live overlay so structurally-
-     *  grouped children visually follow the parent during the drag. No
-     *  additional ops are generated — children's local poses don't change
-     *  when the parent's local pose moves. */
-    getChildren?(id: string): string[];
+    /** Optional: ordered children of `parentId`, `null` for the root siblings.
+     *  One contract with {@link OrderedAdapter.getChildren} — the two land on
+     *  the same adapter object, and an implementation that answers only node
+     *  ids returns `[]` for the root, which the ops read as "no siblings".
+     *
+     *  When present (alongside the `cascadeWorldPose` option on `useMove`),
+     *  dragging a node auto-cascades its descendants in the live overlay so
+     *  structurally-grouped children visually follow the parent during the
+     *  drag. No additional ops are generated — children's local poses don't
+     *  change when the parent's local pose moves. */
+    getChildren?(parentId: string | null): string[];
     /** Optional: layout strategy attached to a container, or null if the
      *  container uses absolute positioning (default behavior). When present,
      *  `useMove` uses the strategy to compute drop targets, sibling reflow,
@@ -360,11 +364,12 @@ interface LayerEnumerableAdapter<TLayer extends string = string> {
  */
 interface OrderedAdapter {
     /** Ordered children of `parentId` (or root siblings if null), in z-order:
-     *  index 0 is bottom, last index is top. */
+     *  index 0 is bottom, last index is top. The same contract
+     *  {@link MoveAdapter.getChildren} declares — one method, two readers. */
     getChildren?(parentId: string | null): string[];
     /** Rewrite the order of `parentId`'s children. Length and contents must
      *  match the existing children — reorder only, no add/remove. */
     setChildOrder?(parentId: string | null, ids: string[]): void;
 }
 
-export type { AreaSelectAdapter as A, ClipboardSnapshot as C, DropTarget as D, InsertAdapter as I, LayoutStrategy as L, MoveAdapter as M, OrderedAdapter as O, RotateAdapter as R, SnapTarget as S, LassoHitMode as a, LassoSelectAdapter as b, ResizeAdapter as c, SceneAdapter as d, LayerEnumerableAdapter as e, LayoutSnap as f, ContainerBounds as g, LayoutChild as h, LayoutContainer as i, LayoutDragged as j };
+export type { AreaSelectAdapter as A, ClipboardSnapshot as C, DropTarget as D, InsertAdapter as I, LayoutStrategy as L, MoveAdapter as M, OrderedAdapter as O, RotateAdapter as R, SnapTarget as S, SceneAdapter as a, LassoHitMode as b, LassoSelectAdapter as c, ResizeAdapter as d, LayerEnumerableAdapter as e, LayoutSnap as f, ContainerBounds as g, LayoutChild as h, LayoutContainer as i, LayoutDragged as j };

package/dist/{types-BhrifbZ1.d.ts → types-miXHGrZM.d.ts}

@@ -1,5 +1,5 @@
 import { Op } from '@weasel-js/history';
-import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-DbysOO-2.js';
+import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-XBcDEp3Y.js';
 
 /**
  * Snapshot of modifier-key state at gesture dispatch.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.2.0",
+  "version": "1.3.0-pre.0",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -74,11 +74,13 @@
     "react": ">=18"
   },
   "dependencies": {
-    "@weasel-js/font": "1.2.0",
-    "@weasel-js/geom": "1.2.0",
-    "@weasel-js/gestures": "1.2.0",
-    "@weasel-js/history": "1.2.0",
-    "@weasel-js/modes": "1.2.0",
+    "@weasel-js/font": "1.3.0-pre.0",
+    "@weasel-js/geom": "1.3.0-pre.0",
+    "@weasel-js/gestures": "1.3.0-pre.0",
+    "@weasel-js/history": "1.3.0-pre.0",
+    "@weasel-js/modes": "1.3.0-pre.0",
+    "@weasel-js/paint": "1.3.0-pre.0",
+    "@weasel-js/text": "1.3.0-pre.0",
     "earcut": "2.2.4",
     "polygon-clipping": "^0.15.7"
   },