@weasel-js/core 1.5.0 → 1.5.2

package/dist/clipboard.d.ts

@@ -1,5 +1,5 @@
 import { NodeId } from '@weasel-js/routing';
-import { C as ClipboardSnapshot, I as InsertAdapter } from './types-DtjCJA5r.js';
+import { C as ClipboardSnapshot, I as InsertAdapter } from './types-BdaK9PcP.js';
 import '@weasel-js/history';
 
 type Replacer$1 = (key: string, value: unknown) => unknown;

package/dist/clone.d.ts

@@ -1,6 +1,6 @@
-import { C as CloneBehavior } from './types-DMyo7dnM.js';
+import { C as CloneBehavior } from './types-BHGdrOcu.js';
 import '@weasel-js/history';
-import './types-DtjCJA5r.js';
+import './types-BdaK9PcP.js';
 import '@weasel-js/routing';
 
 /** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */

package/dist/{depSchema-nMqj_qTM.d.ts → depSchema-FKQBEfg7.d.ts}

@@ -1,14 +1,13 @@
-import { GradStop, TextureHandle, FillStyle, Stroke } from '@weasel-js/paint';
-import { a as Path, P as PoseDescriptor } from './poseDescriptor-CGOgIgf8.js';
+import { GradStop, ColorSpace, TextureHandle, FillStyle, Stroke, ScreenLength } from '@weasel-js/paint';
+import { NodeId, Bounds, View, SelectionApi, ActionDeps, IngestItem, DragSample, Point2 } from '@weasel-js/routing';
+import { a as Path, P as PoseDescriptor } from './poseDescriptor-PgfVKfa0.js';
 import { ResolvedRun, TextStyle, TextVerticalAlign } from '@weasel-js/text';
+import { Mat3 } from '@weasel-js/geom';
 import * as _weasel_js_history from '@weasel-js/history';
 import { Op, History, SerializedHistory } from '@weasel-js/history';
-import { NodeId, Bounds, View as View$1, SelectionApi, ActionDeps, IngestItem, DragSample, Point2 } from '@weasel-js/routing';
-import { a as SceneAdapter, L as LayoutStrategy, I as InsertAdapter } from './types-DtjCJA5r.js';
-import { MutableRefObject, ReactNode } from 'react';
+import { a as SceneAdapter, L as LayoutStrategy, I as InsertAdapter } from './types-BdaK9PcP.js';
 import { ActiveToolContextValue } from '@weasel-js/routing/react';
-import { B as BoundsConstraint, P as PointSnapBehavior } from './types-DMyo7dnM.js';
-import { Mat3 as Mat3$1 } from '@weasel-js/geom';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './types-BHGdrOcu.js';
 
 /**
  * Axis-aligned rectangle pose with optional rotation. The canonical pose
@@ -366,6 +365,12 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
      *  structural edit, so repeat calls hand back the same array — a snapshot,
      *  not a live view, and not yours to mutate. */
     renderOrderNodes(): readonly Node<TData, TLayer, TPose>[];
+    /** The nodes on one layer, in render order. Cached alongside
+     *  {@link Scene.renderOrderNodes} until a structural edit, so a caller that
+     *  only cares about one layer pays the tree walk once rather than once per
+     *  call. A snapshot, not a live view, and not yours to mutate. An unknown
+     *  layer id yields an empty array. */
+    nodesOnLayer(layer: TLayer): readonly Node<TData, TLayer, TPose>[];
     add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;
     /** Delete `id`, its **entire subtree**, and **everything that derives from**
      *  any of those nodes — a node listing one of them in `dependsOn` goes too,
@@ -510,6 +515,15 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
     canUndo(): boolean;
     canRedo(): boolean;
     batch<T>(label: string, fn: () => T): T;
+    /** 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
+     *  untracked write; the next recorded change starts from whatever the
+     *  untracked writes left, so undoing it lands there. A `batch` inside
+     *  records nothing; inside a `batch`, these writes stay out of its entry.
+     *  Notifies once, reverts `fn`'s writes if it throws, and throws on
+     *  `applyBatch` and `history.apply` / `applyOps`, which exist to record. */
+    untracked<T>(fn: () => T): T;
     /** Read-only snapshot of every history entry currently reachable from
      *  the present state. Oldest applied first, then redoable entries in
      *  the order they'd be re-applied. Each entry id is stable. */
@@ -613,7 +627,7 @@ interface FitViewToBoundsOptions {
  * returns `currentView` unchanged and logs a `console.warn`. Callers that
  * want to no-op silently can detect zero area themselves before calling.
  */
-declare function fitViewToBounds(bounds: Bounds, viewportDims: ViewportDims, currentView: View$1, opts?: FitViewToBoundsOptions): View$1;
+declare function fitViewToBounds(bounds: Bounds, viewportDims: ViewportDims, currentView: View, opts?: FitViewToBoundsOptions): View;
 
 /**
  * Minimal compile/link/lookup wrapper for a GL program. Throws
@@ -878,8 +892,9 @@ declare class GLImageCache {
  */
 
 /** Bake gradient stops into a 256-entry RGBA lookup strip, which the shader
- *  samples instead of evaluating stops per fragment. */
-declare function buildGradientRamp(stops: GradStop[]): Uint8ClampedArray;
+ *  samples instead of evaluating stops per fragment. `space` is the gradient's
+ *  `interpolate` — the ramp is where a non-sRGB blend is paid for, once. */
+declare function buildGradientRamp(stops: GradStop[], space?: ColorSpace): Uint8ClampedArray;
 declare class GradientRampAtlas {
     private readonly gl;
     /** Row per stop list, in least-recently-used order: a hit re-inserts, so the
@@ -905,7 +920,7 @@ declare class GradientRampAtlas {
      * its draw past this call may hold a row across another `upload` without
      * arranging to be flushed first.
      */
-    upload(stops: GradStop[]): number;
+    upload(stops: GradStop[], space?: ColorSpace): number;
     /**
      * Whether uploading `stops` would move where existing rows sit — by growing
      * the atlas, which changes every row's `v`, or by recycling one, which
@@ -914,7 +929,7 @@ declare class GradientRampAtlas {
      * Anything holding a row past this call asks first and gets itself out of
      * the way, because neither can be undone once it has happened.
      */
-    wouldReshape(stops: GradStop[]): boolean;
+    wouldReshape(stops: GradStop[], space?: ColorSpace): boolean;
     /**
      * The `v` a row is sampled at — its center.
      *
@@ -955,37 +970,51 @@ declare class GradientRampAtlas {
  * `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,
  *                                              m10*x + m11*y + ty]`.
  */
-type Mat3 = Float32Array;
-declare function identity(): Mat3;
-declare function multiply(out: Mat3, m: Mat3): Mat3;
-declare function translate(m: Mat3, tx: number, ty: number): Mat3;
-declare function scale(m: Mat3, sx: number, sy: number): Mat3;
+
+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: Mat3): Mat3 | null;
-declare function apply(m: Mat3, x: number, y: number): [number, number];
+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): Mat3;
+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: Mat3): number;
+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 `Mat3`, though the logical element
+ *  `@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;
-    translate: typeof translate;
-    scale: typeof scale;
+    translated: typeof translated;
+    scaled: typeof scaled;
     invert: typeof invert;
     apply: typeof apply;
     screenToClip: typeof screenToClip;
@@ -995,7 +1024,7 @@ declare const mat3: {
 /** Row-major 4×5 color matrix identity. */
 declare const IDENTITY_COLOR_MATRIX: Float32Array<ArrayBuffer>;
 interface GroupFrame {
-    transform?: Mat3;
+    transform?: GlMat3;
     alpha?: number;
     /** Row-major 4×5 color matrix (20 floats). Absent leaves the stack unchanged. */
     colorMatrix?: Float32Array | number[];
@@ -1004,7 +1033,7 @@ declare class GroupState {
     private transformStack;
     private alphaStack;
     private colorMatrixStack;
-    get transform(): Mat3;
+    get transform(): GlMat3;
     get alpha(): number;
     get colorMatrix(): Float32Array;
     push(frame: GroupFrame): void;
@@ -1162,7 +1191,7 @@ interface PathDrawCommand {
  *  is how a container node's transform reaches its descendants. */
 interface GroupDrawCommand {
     kind: 'group';
-    transform?: Mat3;
+    transform?: GlMat3;
     alpha?: number;
     /**
      * Optional 4×5 color matrix (row-major, 20 numbers) — `out = M₄ₓ₄ * in + bias`.
@@ -1384,7 +1413,7 @@ declare class DrawBatch {
      * alpha). An affine maps a rect to a parallelogram, so two triangles still
      * cover it and the batch draws at `u_model` identity.
      */
-    pushRect(x: number, y: number, w: number, h: number, m: Mat3, r: number, g: number, b: number, a: number): void;
+    pushRect(x: number, y: number, w: number, h: number, m: GlMat3, r: number, g: number, b: number, a: number): void;
     /**
      * Append one image quad: the destination rect `(x, y, w, h)` mapped through
      * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `post` as the
@@ -1398,7 +1427,7 @@ declare class DrawBatch {
      * `slot` is the texture unit the corners sample, which `draw.ts` assigns per
      * bitmap within the run.
      */
-    pushQuad(x: number, y: number, w: number, h: number, m: Mat3, u0: number, v0: number, u1: number, v1: number, post: number, slot: number): void;
+    pushQuad(x: number, y: number, w: number, h: number, m: GlMat3, u0: number, v0: number, u1: number, v1: number, post: number, slot: number): void;
     /**
      * Append one glyph quad: the box `(x0, y0)`-`(x1, y1)` mapped through `m`,
      * sampling `(u0, v0)`-`(u1, v1)` of the font atlas at `slot`, painted in
@@ -1420,7 +1449,7 @@ declare class DrawBatch {
      * winding, which is what lets a run of mixed rects, image quads and glyphs
      * keep the canonical index pattern.
      */
-    pushGlyph(x0: number, y0: number, x1: number, y1: number, baselineY: number, tanItalic: number, m: Mat3, u0: number, v0: number, u1: number, v1: number, r: number, g: number, b: number, a: number, slot: number, mode: number): void;
+    pushGlyph(x0: number, y0: number, x1: number, y1: number, baselineY: number, tanItalic: number, m: GlMat3, u0: number, v0: number, u1: number, v1: number, r: number, g: number, b: number, a: number, slot: number, mode: number): void;
     /**
      * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped
      * through `m`, sampling the ramp atlas at `slot`.
@@ -1437,16 +1466,16 @@ declare class DrawBatch {
      * Values outside 0..1 are the sampler's business; the atlas clamps to the
      * edge texel, which is what the gradient shader's own `clamp` did.
      */
-    pushGradientRect(x: number, y: number, w: number, h: number, m: Mat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): void;
+    pushGradientRect(x: number, y: number, w: number, h: number, m: GlMat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): void;
     /** `pushMesh` for a mesh filled by a gradient — see `pushGradientRect` for
      *  what `uv`, `post` and `mode` carry. */
-    pushGradientMesh(mesh: Mesh, m: Mat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): void;
+    pushGradientMesh(mesh: Mesh, m: GlMat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): void;
     /**
      * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The
      * mesh's own indices are rebased onto the staged vertices, which is why the
      * index buffer is uploaded per flush rather than written once.
      */
-    pushMesh(mesh: Mesh, m: Mat3, r: number, g: number, b: number, a: number): void;
+    pushMesh(mesh: Mesh, m: GlMat3, r: number, g: number, b: number, a: number): void;
     /** Upload the staged geometry into the next set of buffers and bind its VAO.
      *  Returns the index count for the caller's `drawElements`. */
     uploadAndBind(): number;
@@ -1554,7 +1583,7 @@ declare class WeaselRenderer {
      *  with effects asks, so a canvas without them pays no memory. */
     private readonly effectTargets;
     private readonly imageMinification;
-    private readonly flattenTolerance?;
+    private flattenTolerance?;
     private readonly bakeBudget;
     private readonly textOutlineMinScreenSize;
     private contextLost;
@@ -1630,7 +1659,10 @@ 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?: Mat3): void;
+    render(commands: DrawCommand[], viewMatrix?: GlMat3): void;
+    /** Change the curve-flattening tolerance after construction. `undefined`
+     *  restores the cached `DEFAULT_FLATTEN_TOLERANCE` route. */
+    setFlattenTolerance(tolerance: number | undefined): void;
     resize(dims: {
         width: number;
         height: number;
@@ -1687,23 +1719,14 @@ declare function frameRect(sheet: SpriteSheet, index: number): {
 };
 
 /**
- * View → Mat3 helper for layer `draw` implementations on world-space layers.
+ * View → GlMat3 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.
+ * `View` is `@weasel-js/routing`'s, the one every viewport action is typed
+ * in. A type-only import emits no runtime edge, so there is no reason for the
+ * renderer to hold a second structurally-identical declaration and put it in
+ * the emitted `.d.ts` anonymously.
  */
 
-/** 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
@@ -1714,7 +1737,32 @@ interface View {
  * 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;
+declare function viewToMat3(view: View): GlMat3;
+
+/** A screen-space rectangle, CSS pixels. */
+interface CullRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * `cmds` without the commands that cannot put a pixel inside `rect`, where
+ * `transform` maps the commands' space to screen space — `viewToMat3(view)`
+ * for a world-space layer.
+ *
+ * Conservative by construction: a command is dropped only when a bound that
+ * encloses everything it can paint misses `rect`. Paths are bounded by their
+ * control hull plus the farthest a stroke can reach (miter spikes and square
+ * caps included), images and sprites by their quads, and every bound is taken
+ * through the accumulated transform as the AABB of its corners, so rotation
+ * only enlarges it. Text and shader commands are always kept, and so is a
+ * group with `effects` — an effect may move pixels. Clips are ignored, which
+ * can only keep more. A group whose children all go is dropped.
+ *
+ * Returns `cmds` itself when nothing was dropped.
+ */
+declare function cullDrawCommands(cmds: DrawCommand[], transform: GlMat3, rect: CullRect): DrawCommand[];
 
 /** Options for stroke tessellation. */
 interface StrokeOptions {
@@ -1731,9 +1779,7 @@ interface StrokeOptions {
 /** 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;
+declare function resolveStrokeWidth(width: ScreenLength, scale: number): number;
 /**
  * Build a triangle-mesh ribbon from a stroked Path.
  *
@@ -2473,7 +2519,7 @@ interface ViewAnimationOptions {
     /** Easing curve. Default `easeOutCubic`. */
     easing?: EasingSpec;
     /** Replace the kit's log-scale / fixed-anchor curve. */
-    interpolator?: InterpolatorFactory<View$1>;
+    interpolator?: InterpolatorFactory<View>;
     /** Fires when the target is reached. Not called on cancel. */
     onDone?: () => void;
 }
@@ -2484,28 +2530,29 @@ interface AnimateToBoundsOptions extends FitViewToBoundsOptions, ViewAnimationOp
  *  channel `view.set` uses, so a camera animation on an uncontrolled canvas
  *  costs no React render. */
 interface ViewChannel {
-    get(): View$1;
-    set(v: View$1): void;
+    get(): View;
+    set(v: View): void;
 }
 /** The camera animation surface. One animation at a time. */
 interface ViewAnimationApi {
     /** Glide from the live view to `to`. A thunk receives the pending target when
      *  one is in flight, so successive discrete steps compound. */
-    animate(to: View$1 | ((base: View$1) => View$1), opts?: ViewAnimationOptions): void;
+    animate(to: View | ((base: View) => View), opts?: ViewAnimationOptions): void;
     /** `fitViewToBounds` composed with `animate`. */
     animateToBounds(bounds: Bounds, dims: ViewportDims, opts?: AnimateToBoundsOptions): void;
     /** Cancel. The view stays where it is — no jump to the target. */
     stop(): void;
     isAnimating(): boolean;
     /** Where the in-flight animation is heading, or null when none is. */
-    target(): View$1 | null;
+    target(): View | null;
     /** Cancel unless the write that prompted this came from the runner's own
      *  per-frame write. Feed it from every channel that can move the camera. */
     stopIfExternal(): void;
 }
 /**
  * Animate the viewport `View`. Runs on the kit's {@link Animator} — pass one to
- * share a canvas's animator, or omit it and the hook makes its own.
+ * share a canvas's animator, or omit it and the hook makes its own. A caller
+ * that always has one should use {@link useViewAnimationOn}, which builds none.
  *
  * Every animation from one instance registers under that instance's cancel key,
  * so starting one cancels whatever *it* had in flight, and each starts from the
@@ -2513,6 +2560,9 @@ interface ViewAnimationApi {
  * Two instances on one animator are independent.
  */
 declare function useViewAnimation(view: ViewChannel, animator?: Animator): ViewAnimationApi;
+/** {@link useViewAnimation} on an animator the caller owns. Constructs no
+ *  animator of its own, so the camera runs on exactly the one passed. */
+declare function useViewAnimationOn(view: ViewChannel, animator: Animator): ViewAnimationApi;
 
 /**
  * Pose composition for hierarchical scene graphs.
@@ -2779,58 +2829,6 @@ interface ContentHandlerEntry {
 /** Register a content handler. Returns a disposer that removes it. */
 declare function registerContentHandler(entry: ContentHandlerEntry): () => void;
 
-/**
- * @experimental
- * PointerContext — a tiny ambient context that publishes the world-space
- * position of the canvas pointer, refreshed on every `pointermove` over
- * the canvas. Cleared (set to `null`) on `pointerleave`.
- *
- * Why ref-based and not state-based: cursor moves fire dozens of times per
- * second; routing those through React state would re-render every consumer
- * in the tree. The context exposes a stable `pointerRef` whose `.current`
- * is mutated directly by the publisher, plus a thunk `getDropPoint()` that
- * reads it on demand. Consumers (e.g. `useClipboard`) pull via the thunk
- * inside their callbacks — no subscription, no re-render.
- *
- * `<SceneCanvas>` publishes automatically. `useClipboardOps` consumes when
- * the caller didn't pass an explicit `getDropPoint` option. Other future
- * hit-on-cursor consumers (drop-zone hover, context-menu anchor) can reuse
- * the same context.
- */
-
-/** @experimental World-space pointer position, or `null` when the pointer
- *  isn't over the publishing canvas. */
-type PointerWorldPos = {
-    worldX: number;
-    worldY: number;
-} | null;
-/** @experimental */
-interface PointerContextValue {
-    /** Live ref — mutate to publish, read for the latest snapshot. The
-     *  identity is stable for the lifetime of the provider. */
-    readonly pointerRef: MutableRefObject<PointerWorldPos>;
-    /** Convenience thunk equivalent to `() => pointerRef.current`. Stable
-     *  identity for the lifetime of the provider; safe to pass to hooks. */
-    readonly getDropPoint: () => PointerWorldPos;
-}
-/**
- * @experimental
- * Wrap the part of the React tree that should share a pointer-position
- * context. Usually placed at the demo / app root, alongside
- * `<ActionsProvider>` and `<SelectionContextProvider>`.
- *
- * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts
- * an internal provider when no parent provider is in scope, so child hooks
- * (`useClipboard` without an explicit `getDropPoint`) read the canvas's
- * tracked pointer for free.
- */
-declare function PointerContextProvider({ children }: {
-    children: ReactNode;
-}): ReactNode;
-/** @experimental Read the surrounding pointer-context value, or `null` when
- *  no provider is in scope. */
-declare function usePointerContext(): PointerContextValue | null;
-
 /** Optional consumer seam: given a node and the affine `m` that a pose-transform
  *  action applied to the node's POSE, return updated `data` with the node's
  *  data-held geometry transformed by `m`, or `null` if this node has no
@@ -2840,19 +2838,19 @@ interface GeometryProjection {
         id?: string;
         data: unknown;
         pose: unknown;
-    }, m: Mat3$1): unknown | null;
+    }, m: Mat3): unknown | null;
 }
 
 /** Minimal view API the action layer consumes. */
 interface ViewApi {
-    get(): View$1;
-    set(v: View$1): void;
+    get(): View;
+    set(v: View): void;
     /** 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.
      *  Return the target `View` to let the action animate there; return nothing
      *  to keep dispatching the view yourself. */
-    recenter?(): View$1 | void;
+    recenter?(): View | void;
     /** Optional canvas-local host dimensions (CSS px). When wired,
      *  `viewportZoomAction`'s keyboard branches (Cmd+= / Cmd+-) anchor at the
      *  host center instead of the top-left origin. Null when the host isn't
@@ -2863,11 +2861,11 @@ interface ViewApi {
     } | null;
     /** Optional camera animation. `<SceneCanvas>` wires these three; a consumer
      *  publishing their own `view` dep need not, and actions fall back to `set`. */
-    animate?(to: View$1, opts?: ViewAnimationOptions): void;
+    animate?(to: View, opts?: ViewAnimationOptions): void;
     stopAnimation?(): void;
     /** Where an in-flight camera animation is heading, or null. Compute the next
      *  discrete step from this so repeated presses compound. */
-    animationTarget?(): View$1 | null;
+    animationTarget?(): View | null;
     /** Optional momentum decay. `<SceneCanvas>` wires this from `useDecayLoop`;
      *  a consumer publishing their own `view` dep need not, and `viewport.dragPan`
      *  simply lands the pan without coasting. */
@@ -3318,13 +3316,6 @@ declare module '@weasel-js/routing' {
         scene: Scene<unknown, string, unknown>;
         /** Undo/redo history bound to the current scene. */
         history: History;
-        /**
-         * Canvas pointer position in world space.
-         *
-         * Exposes `pointerRef` (mutable live ref) and `getDropPoint()` thunk.
-         * Marked `@experimental` in the source.
-         */
-        pointer: PointerContextValue;
         /** Currently active tool id + hotkey-hold stack. */
         activeTool: ActiveToolContextValue;
         /**
@@ -3487,4 +3478,4 @@ declare module '@weasel-js/routing' {
     }
 }
 
-export { type ViewportDims as $, type SliceDep as A, type VertexColorChannel as B, type InsertExtras as C, type DrawCommand as D, type Effect as E, type SerializedScene as F, type GroupDrawCommand as G, type GeometryProjection as H, IDENTITY_COLOR_MATRIX as I, type ContentHandlerEntry as J, type SvgIngestOptions as K, type PanBounds as L, type Mesh as M, type Node as N, type Animator as O, type PathDrawCommand as P, ColorOverrideRegistry as Q, type RenderTarget as R, SPRITE_STRIDE as S, type TextDrawCommand as T, type UseSceneOptions as U, type View as V, WeaselRenderer as W, type SceneRegistry as X, type RegisteredOp as Y, type PoseOverrides as Z, type DerivedDep as _, type ImageDrawCommand as a, type StaggerOptions as a$, ShaderProgram as a0, type BooleansAdapter as a1, type UseAnimatorOptions as a2, type SpringPresetName as a3, type EasingSpec as a4, type AnimationHandle as a5, type SampledTrack as a6, type AddLayerSpec as a7, type AddNodeSpec as a8, type AnimateToBoundsOptions as a9, type LassoSelectDep as aA, type LayerRecord as aB, type LayoutDep as aC, type LeafNode as aD, type LoopFactory as aE, type LoopOptions as aF, type NestedTimeline as aG, type NodeAtPointDep as aH, type PhysicsHandle as aI, type PhysicsOptions as aJ, PointerContextProvider as aK, type PointerContextValue as aL, type PointerWorldPos as aM, type PoseAdapter as aN, type PoseClosure as aO, type PoseOverride as aP, RECT_POSE_COMPOSITION as aQ, RIGID_POSE_COMPOSITION as aR, type ResizePolicy as aS, SPRING_PRESETS as aT, type SerializedNode as aU, type SnapDep as aV, type SpringOptions as aW, type SpringPreset as aX, type StaggerBuilder as aY, type StaggerDelay as aZ, type StaggerFactory as a_, type AreaSelectDep as aa, type BezierEasing as ab, type BooleanOp as ac, type BooleanOpResult as ad, type ClipboardDep as ae, type ClipboardIngestCtx as af, type ColorOverride as ag, type ColorOverrideFn as ah, type ContainerNode as ai, type DecayLoopConfig as aj, type DecayOptions as ak, EASINGS as al, type EasingFn as am, type EasingName as an, type EditAnchorsDep as ao, type EventBooking as ap, type EventBookingHandle as aq, type EventTrack as ar, type FitViewToBoundsOptions as as, IDENTITY_POSE_COMPOSITION as at, type IngestCtx as au, type IngestionDep as av, type InsertDep as aw, type Interpolate as ax, type InterpolatorFactory as ay, type Keyframe as az, type ImageMinification as b, rebaseLocalPose as b$, type StaggerPerItem as b0, type StaggerSpringPoseOptions as b1, type StaggerTweenOptions as b2, type SvgUnpacker as b3, type SystemLayerRecord as b4, type SystemLayerSpec as b5, type TextEditDep as b6, type TimelineClock as b7, type TimelineEvent as b8, type TimelineHandle as b9, easeInOutBack as bA, easeInOutBounce as bB, easeInOutCirc as bC, easeInOutCubic as bD, easeInOutElastic as bE, easeInOutExpo as bF, easeInOutQuad as bG, easeInOutQuart as bH, easeInOutQuint as bI, easeInOutSine as bJ, easeInQuad as bK, easeInQuart as bL, easeInQuint as bM, easeInSine as bN, easeOut as bO, easeOutBack as bP, easeOutBounce as bQ, easeOutCirc as bR, easeOutCubic as bS, easeOutElastic as bT, easeOutExpo as bU, easeOutQuad as bV, easeOutQuart as bW, easeOutQuint as bX, easeOutSine as bY, fitViewToBounds as bZ, linear as b_, type TimelineOptions as ba, type TimelineTrack as bb, type Track as bc, type TweenLoopOptions as bd, type TweenOptions as be, type UserLayerRecord as bf, VIEW_ANIMATION_KEY as bg, type ViewAnimationApi as bh, type ViewApi as bi, type ViewChannel as bj, applyBooleanOp as bk, asNodeId as bl, composeRectPose as bm, composeRigidPose as bn, composeWorldPose as bo, cubicBezierEasing as bp, decomposeRectPose as bq, decomposeRigidPose as br, easeIn as bs, easeInBack as bt, easeInBounce as bu, easeInCirc as bv, easeInCubic as bw, easeInElastic as bx, easeInExpo as by, easeInOut as bz, type Mat3 as c, registerContentHandler as c0, resolveEasing as c1, resolveStrokeWidth as c2, translateRectPose as c3, useDecayLoop as c4, usePointerContext as c5, useViewAnimation as c6, worldPoseLookup as c7, ShaderCompileError as d, type ShaderDrawCommand as e, type ShaderProgramHandle as f, type ShaderUniform as g, type SolidPaint as h, type SpriteSheet as i, type SpritesDrawCommand as j, type StrokeOptions as k, type WeaselRendererOptions as l, blur as m, buildGradientRamp as n, frameRect as o, mat3 as p, registerProgram as q, registerEffect as r, vignette as s, tessellateStroke as t, type Scene as u, viewToMat3 as v, type RectPose as w, type InertiaConfig as x, type ViewAnimationOptions as y, type PoseComposition as z };
+export { type DerivedDep as $, type SliceDep as A, type VertexColorChannel as B, type CullRect as C, type DrawCommand as D, type Effect as E, type InsertExtras as F, type GlMat3 as G, type SerializedScene as H, IDENTITY_COLOR_MATRIX as I, type GeometryProjection as J, type ContentHandlerEntry as K, type SvgIngestOptions as L, type Mesh as M, type Node as N, type PanBounds as O, type PathDrawCommand as P, type Animator as Q, type RenderTarget as R, SPRITE_STRIDE as S, type TextDrawCommand as T, ColorOverrideRegistry as U, type ViewAnimationOptions as V, WeaselRenderer as W, type UseSceneOptions as X, type SceneRegistry as Y, type RegisteredOp as Z, type PoseOverrides as _, type GroupDrawCommand as a, type StaggerSpringPoseOptions as a$, type ViewportDims as a0, ShaderProgram as a1, type BooleansAdapter as a2, type UseAnimatorOptions as a3, type SpringPresetName as a4, type EasingSpec as a5, type AnimationHandle as a6, type SampledTrack as a7, type AddLayerSpec as a8, type AddNodeSpec as a9, type Keyframe as aA, type LassoSelectDep as aB, type LayerRecord as aC, type LayoutDep as aD, type LeafNode as aE, type LoopFactory as aF, type LoopOptions as aG, type NestedTimeline as aH, type NodeAtPointDep as aI, type PhysicsHandle as aJ, type PhysicsOptions as aK, type PoseAdapter as aL, type PoseClosure as aM, type PoseOverride as aN, RECT_POSE_COMPOSITION as aO, RIGID_POSE_COMPOSITION as aP, type ResizePolicy as aQ, SPRING_PRESETS as aR, type SerializedNode as aS, type SnapDep as aT, type SpringOptions as aU, type SpringPreset as aV, type StaggerBuilder as aW, type StaggerDelay as aX, type StaggerFactory as aY, type StaggerOptions as aZ, type StaggerPerItem as a_, type AnimateToBoundsOptions as aa, type AreaSelectDep as ab, type BezierEasing as ac, type BooleanOp as ad, type BooleanOpResult as ae, type ClipboardDep as af, type ClipboardIngestCtx as ag, type ColorOverride as ah, type ColorOverrideFn as ai, type ContainerNode as aj, type DecayLoopConfig as ak, type DecayOptions as al, EASINGS as am, type EasingFn as an, type EasingName as ao, type EditAnchorsDep as ap, type EventBooking as aq, type EventBookingHandle as ar, type EventTrack as as, type FitViewToBoundsOptions as at, IDENTITY_POSE_COMPOSITION as au, type IngestCtx as av, type IngestionDep as aw, type InsertDep as ax, type Interpolate as ay, type InterpolatorFactory as az, type ImageDrawCommand as b, resolveEasing as b$, type StaggerTweenOptions as b0, type SvgUnpacker as b1, type SystemLayerRecord as b2, type SystemLayerSpec as b3, type TextEditDep as b4, type TimelineClock as b5, type TimelineEvent as b6, type TimelineHandle as b7, type TimelineOptions as b8, type TimelineTrack as b9, easeInOutCirc as bA, easeInOutCubic as bB, easeInOutElastic as bC, easeInOutExpo as bD, easeInOutQuad as bE, easeInOutQuart as bF, easeInOutQuint as bG, easeInOutSine as bH, easeInQuad as bI, easeInQuart as bJ, easeInQuint as bK, easeInSine as bL, easeOut as bM, easeOutBack as bN, easeOutBounce as bO, easeOutCirc as bP, easeOutCubic as bQ, easeOutElastic as bR, easeOutExpo as bS, easeOutQuad as bT, easeOutQuart as bU, easeOutQuint as bV, easeOutSine as bW, fitViewToBounds as bX, linear as bY, rebaseLocalPose as bZ, registerContentHandler as b_, type Track as ba, type TweenLoopOptions as bb, type TweenOptions as bc, type UserLayerRecord as bd, VIEW_ANIMATION_KEY as be, type ViewAnimationApi as bf, type ViewApi as bg, type ViewChannel as bh, applyBooleanOp as bi, asNodeId as bj, composeRectPose as bk, composeRigidPose as bl, composeWorldPose as bm, cubicBezierEasing as bn, decomposeRectPose as bo, decomposeRigidPose as bp, easeIn as bq, easeInBack as br, easeInBounce as bs, easeInCirc as bt, easeInCubic as bu, easeInElastic as bv, easeInExpo as bw, easeInOut as bx, easeInOutBack as by, easeInOutBounce as bz, type ImageMinification as c, resolveStrokeWidth as c0, translateRectPose as c1, useDecayLoop as c2, useViewAnimation as c3, useViewAnimationOn as c4, worldPoseLookup as c5, ShaderCompileError as d, type ShaderDrawCommand as e, type ShaderProgramHandle as f, type ShaderUniform as g, type SolidPaint as h, type SpriteSheet as i, type SpritesDrawCommand as j, type StrokeOptions as k, type WeaselRendererOptions as l, blur as m, buildGradientRamp as n, cullDrawCommands as o, frameRect as p, mat3 as q, registerEffect as r, registerProgram as s, tessellateStroke as t, vignette as u, viewToMat3 as v, type Scene as w, type RectPose as x, type InertiaConfig as y, type PoseComposition as z };

package/dist/{grid-BrIa38gG.d.ts → grid-CuxXjaQV.d.ts}

@@ -1,4 +1,4 @@
-import { M as MoveBehavior, S as SnapStrategy } from './types-DMyo7dnM.js';
+import { M as MoveBehavior, S as SnapStrategy } from './types-BHGdrOcu.js';
 import { DebugSink } from '@weasel-js/routing';
 
 /**
@@ -10,17 +10,33 @@ import { DebugSink } from '@weasel-js/routing';
  * as base units) or a `{ value, unit }` tag that's resolved against a
  * `UnitSystem` at the API boundary. Internals never see units.
  *
- * Linear factors only. No per-axis units. No mixed-unit arithmetic.
+ * An entry is affine — `base = value * factor + offset` — so a scale that
+ * puts zero somewhere else (degC against K) is expressible. No per-axis
+ * units. No mixed-unit arithmetic.
  */
 /** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */
 type Unit = string;
-/** Conversion table mapping unit names to factors against a base unit. */
+/** What one unit is worth in base units: `base = value * factor + offset`. */
+interface UnitScale {
+    factor: number;
+    /** Where this unit puts zero, in base units. Absent is 0 — a pure scale. */
+    offset?: number;
+}
+/** One unit's conversion. A bare number is the `{ factor }` shorthand. */
+type UnitEntry = number | UnitScale;
+/** Conversion table mapping unit names to their scale against a base unit. */
 interface UnitSystem {
     /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */
     base: Unit;
-    /** Factor to multiply a value in `unit` by to get base units. base unit's factor is 1. */
-    units: Record<Unit, number>;
+    /** How to reach base units from each unit. The base unit's entry is 1. */
+    units: Record<Unit, UnitEntry>;
 }
+/**
+ * One unit's scale, with the bare-number shorthand widened and the offset
+ * defaulted — what every conversion in the kit reads. Throws if the system
+ * does not carry the unit.
+ */
+declare function unitScale(unitSystem: UnitSystem, unit: Unit): Required<UnitScale>;
 /** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */
 type UnitValue = number | {
     value: number;
@@ -139,4 +155,4 @@ declare function pointToGridCell(point: {
     row: number;
 };
 
-export { ANGLE_RADIANS as A, IMPERIAL_INCHES as I, METRIC_MM as M, type OriginProjection as O, PIXELS as P, RECT_ORIGIN_PROJECTION as R, type UseMoveOptions as U, type UnitValue as a, type UnitSystem as b, type Unit as c, formatUnit as f, gridSnapStrategy as g, pointToGridCell as p, resolveUnit as r };
+export { ANGLE_RADIANS as A, IMPERIAL_INCHES as I, METRIC_MM as M, type OriginProjection as O, PIXELS as P, RECT_ORIGIN_PROJECTION as R, type UseMoveOptions as U, type UnitValue as a, type UnitSystem as b, type UnitEntry as c, type Unit as d, type UnitScale as e, formatUnit as f, gridSnapStrategy as g, pointToGridCell as p, resolveUnit as r, unitScale as u };