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

package/dist/renderer.d.ts

@@ -1,69 +1,12 @@
-import { I as ImageMinification, G as GLImageCache } from './viewToMat3-CQW_YqDw.js';
-export { V as ViewLike, v as viewToMat3 } from './viewToMat3-CQW_YqDw.js';
-import { G as GradStop, S as Stroke } from './paint-types-CnLIzqq1.js';
-export { a as TextureHandle, r as registerTexture } from './paint-types-CnLIzqq1.js';
-import { M as Mat3, S as ShaderProgramHandle, D as DrawCommand } from './DrawCommand-BbPrSTra.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-BbPrSTra.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;
-}
-
-/**
- * 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;
-}
+import '@weasel-js/text';
 
 interface GLMeshHandle {
     readonly vao: WebGLVertexArrayObject;
@@ -256,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.
  *
@@ -402,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;
@@ -475,23 +447,6 @@ interface TessellateOptions {
  *  line segments, then the resulting polygon triangulated. */
 declare function tessellate(path: Path, opts?: TessellateOptions): Mesh;
 
-/** Options for stroke tessellation. */
-interface StrokeOptions {
-    flattenTolerance?: number;
-}
-/**
- * Build a triangle-mesh ribbon from a stroked Path.
- *
- * Supports:
- *   - cap: 'butt' | 'round' | 'square'
- *   - join: 'miter' | 'round' | 'bevel'
- *   - center alignment directly; RectPath inner/outer alignment via a
- *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the
- *     renderer level
- *   - dash splitting
- */
-declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
-
 /**
  * On-screen glyph size (CSS px) at or above which a face with registered
  * outlines is drawn as geometry instead of sampled from a distance field.
@@ -507,4 +462,4 @@ declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptio
  */
 declare const OUTLINE_MIN_SCREEN_PX = 48;
 
-export { DrawCommand, IDENTITY_COLOR_MATRIX, ImageMinification, Mat3, type Mesh, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, ShaderProgramHandle, type StrokeOptions, type TessellateOptions, WeaselRenderer, type WeaselRendererOptions, buildGradientRamp, tessellate, tessellateStroke };
+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, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-3B4QEB2G.js';
-import './chunk-J3YC3GVF.js';
-import './chunk-CSMF654J.js';
-import './chunk-J7LUY47N.js';
-import './chunk-4Z6J4IVH.js';
-import './chunk-JOSUVS6C.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-DGBrjGbB.js';
-import './types-vqxpCFVp.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-CnLIzqq1.js';
-import './DrawCommand-BbPrSTra.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-J3YC3GVF.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-5pBwOm9s.d.ts

@@ -0,0 +1,190 @@
+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.
+ *
+ * - `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;
+}
+
+/**
+ * GL texture upload cache for ImageBitmap objects.
+ *
+ * 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; deferred to v2.
+ *
+ * Wrapping is set once at upload time per the `repetition` parameter:
+ *   - undefined / 'no-repeat' → CLAMP_TO_EDGE
+ *   - 'repeat'   → REPEAT (both axes)
+ *   - 'repeat-x' → REPEAT on S, CLAMP on T
+ *   - 'repeat-y' → CLAMP on S, REPEAT on T
+ *
+ * Convention §2: texels stored straight; shader premultiplies.
+ */
+type PatternRepetition = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+/** MIN_FILTER strategy for uploaded textures. */
+type ImageMinification = 'linear' | 'mipmap';
+type TexSource = ImageBitmap | ImageData | HTMLCanvasElement | HTMLImageElement;
+declare class GLImageCache {
+    private readonly gl;
+    private readonly minification;
+    private readonly map;
+    /** `minification` selects the MIN_FILTER strategy for uploaded textures.
+     *  `'linear'` (default) is the screen path's existing behavior. `'mipmap'`
+     *  generates mipmaps and filters LINEAR_MIPMAP_LINEAR — required for
+     *  quality minification when a large source bitmap is drawn small (the
+     *  headless print/export path); bilinear-only minification undersamples
+     *  and produces moiré. */
+    constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
+    upload(key: object, source: TexSource, repetition?: PatternRepetition): WebGLTexture;
+    bind(key: object, unit: number): void;
+}
+
+/**
+ * Uniform-grid sprite sheet layout — frame index to the source rect an
+ * `ImageDrawCommand` samples. Pure arithmetic over the grid description; it
+ * never touches the bitmap.
+ */
+/** A sprite sheet's grid. `margin` and `spacing` follow the Tiled / Aseprite
+ *  tileset convention, so a sheet exported from either describes itself here. */
+interface SpriteSheet {
+    frameWidth: number;
+    frameHeight: number;
+    columns: number;
+    /** Empty pixels around the whole grid. Default 0. */
+    margin?: number;
+    /** Empty pixels between adjacent cells — the gutter that keeps linear
+     *  sampling off the neighboring frame. Default 0. */
+    spacing?: number;
+}
+/**
+ * Row-major source rect for frame `index`, counting from 0 at the top-left.
+ *
+ * `index` is not range-checked and does not wrap: past the last cell this
+ * returns a rect below the sheet, which draws as an edge smear. Wrapping is
+ * the animation's business (`frameRect(sheet, tick % count)`) — a sheet does
+ * not know how many of its cells are filled.
+ */
+declare function frameRect(sheet: SpriteSheet, index: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+
+/**
+ * View → Mat3 helper for layer `draw` implementations on world-space layers.
+ *
+ * The kit's main package ships a `View` type at
+ * `src/core/viewport/view.ts`; we re-declare a structurally compatible
+ * shape here to avoid a runtime cross-package import. Exported as
+ * `ViewLike` from the package barrel.
+ */
+
+/** A weasel View — `{x, y, scale: {x, y}}`. Local type to avoid a cross-package import. */
+interface View {
+    x: number;
+    y: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Build the world→screen transform matrix for a `View`.
+ * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap
+ * world-space content emitted from a layer `draw` implementation.
+ *
+ * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.
+ *
+ * Column-major layout (matches `mat3.identity()`):
+ * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.
+ */
+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
+ *  on-screen thickness as the view zooms. */
+declare function resolveStrokeWidth(width: number | {
+    px: number;
+}, scale: number): number;
+/**
+ * Build a triangle-mesh ribbon from a stroked Path.
+ *
+ * Supports:
+ *   - cap: 'butt' | 'round' | 'square'
+ *   - join: 'miter' | 'round' | 'bevel'
+ *   - center alignment directly; RectPath inner/outer alignment via a
+ *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the
+ *     renderer level
+ *   - dash splitting
+ */
+declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
+
+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-vqxpCFVp.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;
@@ -323,6 +412,19 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  `SceneCanvasAdapter`). Pass `this` from `sceneToAdapter` or a compatible
      *  adapter. */
     applyBatch(ops: Op[], label: string, adapter: unknown): void;
+    /** The transient set of active ids — "operate on these N as a unit".
+     *  Shared by every view over this scene unless a view supplies its own
+     *  (see `CanvasView.selection`). Not document content: it never appears
+     *  in `toJSON`. It does ride on history entries, so undo and redo put
+     *  back the selection an edit was made under; changing it is never an
+     *  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;
@@ -388,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 };