@weasel-js/core 1.5.1 → 1.6.0

package/dist/clipboard.d.ts

@@ -1,6 +1,7 @@
 import { NodeId } from '@weasel-js/routing';
-import { C as ClipboardSnapshot, I as InsertAdapter } from './types-BdaK9PcP.js';
+import { C as ClipboardSnapshot, I as InsertAdapter } from './types-CxC8P6W0.js';
 import '@weasel-js/history';
+import './path-JEV2c5If.js';
 
 type Replacer$1 = (key: string, value: unknown) => unknown;
 /** Options for `useClipboardOps`. */

package/dist/clone.d.ts

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

package/dist/{depSchema-BubKMv-2.d.ts → depSchema-BhgZc0-Q.d.ts}

@@ -1,13 +1,14 @@
 import { GradStop, ColorSpace, TextureHandle, FillStyle, Stroke, ScreenLength } from '@weasel-js/paint';
-import { a as Path, P as PoseDescriptor } from './poseDescriptor-PgfVKfa0.js';
+import { NodeId, Bounds, View, SelectionApi, ActionDeps, IngestItem, DragSample, Point2 } from '@weasel-js/routing';
+import { P as Path } from './path-JEV2c5If.js';
 import { ResolvedRun, TextStyle, TextVerticalAlign } from '@weasel-js/text';
+import { Mat3 } from '@weasel-js/geom';
 import * 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-BdaK9PcP.js';
+import { a as SceneAdapter, L as LayoutStrategy, b as LayoutDropTargetMode, I as InsertAdapter } from './types-CxC8P6W0.js';
+import { P as PoseDescriptor } from './poseDescriptor-rZa9W5hJ.js';
 import { ActiveToolContextValue } from '@weasel-js/routing/react';
-import { B as BoundsConstraint, P as PointSnapBehavior } from './types-BHGdrOcu.js';
-import { Mat3 as Mat3$1 } from '@weasel-js/geom';
+import { B as BoundsConstraint, P as PointSnapBehavior } from './types-D_74YlWs.js';
 
 /**
  * Axis-aligned rectangle pose with optional rotation. The canonical pose
@@ -627,7 +628,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
@@ -827,7 +828,8 @@ declare class GLTextureCache {
  *
  * Key: ImageBitmap (or pattern source object) identity (WeakMap) — lets GC
  * reclaim unreferenced bitmaps. The GL textures are NOT freed when the source
- * is gc'd; deferred to v2.
+ * is gc'd; a source's owner that knows it will never be drawn again frees them
+ * with {@link releaseImageSource}.
  *
  * Wrapping is set once at upload time per the `repetition` parameter:
  *   - undefined / 'no-repeat' → CLAMP_TO_EDGE
@@ -844,6 +846,8 @@ type TexSource = ImageBitmap | ImageData | HTMLCanvasElement | HTMLImageElement;
 declare class GLImageCache {
     private readonly gl;
     private readonly minification;
+    /** This context's `MAX_TEXTURE_SIZE`. */
+    readonly maxTextureSide: number;
     private readonly map;
     /**
      * MAG_FILTER each texture currently carries, so a redundant write can be
@@ -869,6 +873,11 @@ declare class GLImageCache {
      *  headless print/export path); bilinear-only minification undersamples
      *  and produces moiré. */
     constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
+    /** Delete `key`'s texture, if it has one. */
+    release(key: object): void;
+    /** Stop answering {@link releaseImageSource} and {@link maxImageTextureSide}.
+     *  Call when the context is disposed or lost. */
+    dispose(): void;
     upload(key: object, source: TexSource, repetition?: PatternRepetition): WebGLTexture;
     bind(key: object, unit: number): void;
     /** Set `key`'s MAG_FILTER, skipping the call when it already holds that
@@ -970,37 +979,48 @@ 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;
+
+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: Mat3, tx: number, ty: number): Mat3;
+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: Mat3, sx: number, sy: number): Mat3;
+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;
     translated: typeof translated;
     scaled: typeof scaled;
@@ -1013,7 +1033,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[];
@@ -1022,7 +1042,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;
@@ -1180,7 +1200,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`.
@@ -1402,7 +1422,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
@@ -1416,7 +1436,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
@@ -1438,7 +1458,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`.
@@ -1455,16 +1475,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;
@@ -1648,7 +1668,7 @@ 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;
@@ -1708,23 +1728,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
@@ -1735,7 +1746,7 @@ 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 {
@@ -1760,7 +1771,7 @@ interface CullRect {
  *
  * Returns `cmds` itself when nothing was dropped.
  */
-declare function cullDrawCommands(cmds: DrawCommand[], transform: Mat3, rect: CullRect): DrawCommand[];
+declare function cullDrawCommands(cmds: DrawCommand[], transform: GlMat3, rect: CullRect): DrawCommand[];
 
 /** Options for stroke tessellation. */
 interface StrokeOptions {
@@ -2517,7 +2528,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;
 }
@@ -2528,21 +2539,21 @@ 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;
@@ -2587,6 +2598,10 @@ declare function useViewAnimationOn(view: ViewChannel, animator: Animator): View
 interface PoseAdapter<TPose> {
     getPose(id: string): TPose;
     getParent(id: string): string | null;
+    /** Whether `id`'s pose is a frame its children are expressed in. Absent
+     *  means every node is one. A container whose pose derives from its children
+     *  is not: its children share its frame, so the fold passes over it. */
+    definesFrame?(id: string): boolean;
 }
 /**
  * The transforms a `compose` represents **exactly**. A parent transform wider
@@ -2836,19 +2851,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
@@ -2859,11 +2874,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. */
@@ -2963,6 +2978,12 @@ interface EditAnchorsDep {
      *  (when the polygon lives on data.path). Records one history entry
      *  labelled `label`. */
     applyEdit(id: string, worldPath: unknown, label: string): void;
+    /** The ops `applyEdit` would commit for the same arguments, unapplied, so
+     *  a caller can make the edit part of a larger batch — the pen joining
+     *  two paths edits one node and deletes the other in one undo step.
+     *  Optional; a caller that needs it declines the composite edit without
+     *  it. Returns `[]` when `id` has no editable polygon. */
+    editOps?(id: string, worldPath: unknown, label: string): Op[];
     /**
      * Anchors currently selected within the edited path, as **flat anchor
      * indices** — the same numbering `enumerateAnchors` produces and the
@@ -3235,6 +3256,9 @@ interface ResizePolicy<TPose> {
  */
 interface LayoutDep {
     getLayout(containerId: string): LayoutStrategy<unknown> | null;
+    /** Which container wins when several contain the drop point. Default
+     *  `'innermost'`. */
+    dropTarget?: LayoutDropTargetMode;
 }
 /**
  * Dep for `enterTextEditAction`.
@@ -3476,4 +3500,4 @@ declare module '@weasel-js/routing' {
     }
 }
 
-export { type PoseOverrides as $, type PoseComposition as A, type SliceDep as B, type CullRect as C, type DrawCommand as D, type Effect as E, type VertexColorChannel as F, type GroupDrawCommand as G, type InsertExtras as H, IDENTITY_COLOR_MATRIX as I, type SerializedScene as J, type GeometryProjection as K, type ContentHandlerEntry as L, type Mesh as M, type Node as N, type SvgIngestOptions as O, type PathDrawCommand as P, type PanBounds as Q, type RenderTarget as R, SPRITE_STRIDE as S, type TextDrawCommand as T, type Animator as U, type View as V, WeaselRenderer as W, ColorOverrideRegistry as X, type UseSceneOptions as Y, type SceneRegistry as Z, type RegisteredOp as _, type ImageDrawCommand as a, type StaggerPerItem as a$, type DerivedDep as a0, type ViewportDims as a1, ShaderProgram as a2, type BooleansAdapter as a3, type UseAnimatorOptions as a4, type SpringPresetName as a5, type EasingSpec as a6, type AnimationHandle as a7, type SampledTrack as a8, type AddLayerSpec as a9, type InterpolatorFactory as aA, type Keyframe as aB, type LassoSelectDep as aC, type LayerRecord as aD, type LayoutDep as aE, type LeafNode as aF, type LoopFactory as aG, type LoopOptions as aH, type NestedTimeline as aI, type NodeAtPointDep as aJ, type PhysicsHandle as aK, type PhysicsOptions as aL, type PoseAdapter as aM, type PoseClosure as aN, type PoseOverride as aO, RECT_POSE_COMPOSITION as aP, RIGID_POSE_COMPOSITION as aQ, type ResizePolicy as aR, SPRING_PRESETS as aS, type SerializedNode as aT, type SnapDep as aU, type SpringOptions as aV, type SpringPreset as aW, type StaggerBuilder as aX, type StaggerDelay as aY, type StaggerFactory as aZ, type StaggerOptions as a_, type AddNodeSpec as aa, type AnimateToBoundsOptions as ab, type AreaSelectDep as ac, type BezierEasing as ad, type BooleanOp as ae, type BooleanOpResult as af, type ClipboardDep as ag, type ClipboardIngestCtx as ah, type ColorOverride as ai, type ColorOverrideFn as aj, type ContainerNode as ak, type DecayLoopConfig as al, type DecayOptions as am, EASINGS as an, type EasingFn as ao, type EasingName as ap, type EditAnchorsDep as aq, type EventBooking as ar, type EventBookingHandle as as, type EventTrack as at, type FitViewToBoundsOptions as au, IDENTITY_POSE_COMPOSITION as av, type IngestCtx as aw, type IngestionDep as ax, type InsertDep as ay, type Interpolate as az, type ImageMinification as b, registerContentHandler as b$, type StaggerSpringPoseOptions as b0, type StaggerTweenOptions as b1, type SvgUnpacker as b2, type SystemLayerRecord as b3, type SystemLayerSpec as b4, type TextEditDep as b5, type TimelineClock as b6, type TimelineEvent as b7, type TimelineHandle as b8, type TimelineOptions as b9, easeInOutBounce as bA, easeInOutCirc as bB, easeInOutCubic as bC, easeInOutElastic as bD, easeInOutExpo as bE, easeInOutQuad as bF, easeInOutQuart as bG, easeInOutQuint as bH, easeInOutSine as bI, easeInQuad as bJ, easeInQuart as bK, easeInQuint as bL, easeInSine as bM, easeOut as bN, easeOutBack as bO, easeOutBounce as bP, easeOutCirc as bQ, easeOutCubic as bR, easeOutElastic as bS, easeOutExpo as bT, easeOutQuad as bU, easeOutQuart as bV, easeOutQuint as bW, easeOutSine as bX, fitViewToBounds as bY, linear as bZ, rebaseLocalPose as b_, type TimelineTrack as ba, type Track as bb, type TweenLoopOptions as bc, type TweenOptions as bd, type UserLayerRecord as be, VIEW_ANIMATION_KEY as bf, type ViewAnimationApi as bg, type ViewApi as bh, type ViewChannel as bi, applyBooleanOp as bj, asNodeId as bk, composeRectPose as bl, composeRigidPose as bm, composeWorldPose as bn, cubicBezierEasing as bo, decomposeRectPose as bp, decomposeRigidPose as bq, easeIn as br, easeInBack as bs, easeInBounce as bt, easeInCirc as bu, easeInCubic as bv, easeInElastic as bw, easeInExpo as bx, easeInOut as by, easeInOutBack as bz, type Mat3 as c, resolveEasing as c0, resolveStrokeWidth as c1, translateRectPose as c2, useDecayLoop as c3, useViewAnimation as c4, useViewAnimationOn as c5, worldPoseLookup as c6, 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 ViewAnimationOptions 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-Z_Af3vTl.d.ts → grid-Dx2gQbNv.d.ts}

@@ -1,4 +1,4 @@
-import { M as MoveBehavior, S as SnapStrategy } from './types-BHGdrOcu.js';
+import { M as MoveBehavior, S as SnapStrategy } from './types-D_74YlWs.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 };