@weasel-js/core 1.4.3 → 1.4.4

package/dist/{builtins-CtGORLCG.d.ts → builtins-BXFBXegF.d.ts}

@@ -218,6 +218,23 @@ declare class GLImageCache {
     private readonly gl;
     private readonly minification;
     private readonly map;
+    /**
+     * MAG_FILTER each texture currently carries, so a redundant write can be
+     * skipped.
+     *
+     * The batch sets this per flush — the same bitmap can be drawn at both
+     * filters in one frame, and the value has to be right at the draw rather than
+     * at upload. Filtering is state on the *texture object*, though, not on the
+     * unit, so re-asserting a value it already has is a write to a live texture
+     * for no reason. On a large sheet that is not free: a consumer's wall samples
+     * a 5652px-square atlas, 122MB resident, and measured `sampling: 'nearest'`
+     * costing up to 8x `'linear'` there — where the linear pass re-asserts the
+     * upload default and the nearest pass changes state on every draw.
+     *
+     * Whether that is the cause is unproven (see `docs/TODO.md`), but the write
+     * was redundant either way.
+     */
+    private readonly magFilters;
     /** `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
@@ -227,13 +244,21 @@ declare class GLImageCache {
     constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
     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
+     *  value. Its texture must be bound to the active unit — callers pair this
+     *  with `bind`. */
+    setMagFilter(key: object, filter: number): void;
 }
 
 /**
- * CPU gradient-ramp builder + GL 1×256 RGBA texture cache.
+ * CPU gradient-ramp builder + the GL texture every baked ramp lives in.
  *
- * Each unique stop list is uploaded once. Key = JSON.stringify(stops).
- * The cache is GL-context-bound; discard and recreate on context loss.
+ * Each unique stop list is baked once into a 256-texel strip and written to its
+ * own **row** of one RGBA texture, keyed by `JSON.stringify(stops)`. One
+ * texture rather than one per ramp is what lets a gradient take a batch texture
+ * slot the way a bitmap or a font atlas does: every gradient in a frame samples
+ * the same unit, so a run does not break per gradient. The atlas is
+ * GL-context-bound; discard and recreate on context loss.
  *
  * Output convention §2: texels are stored as straight RGBA. The fragment
  * shader applies premultiplication before writing outColor.
@@ -242,25 +267,66 @@ 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;
-declare class GradientRampCache {
+declare class GradientRampAtlas {
     private readonly gl;
-    private readonly map;
+    /** Row per stop list, in least-recently-used order: a hit re-inserts, so the
+     *  first entry is the row a full atlas recycles. */
+    private readonly rowByKey;
+    private texture;
+    private rows;
+    /** Mirror of the texture, so growth can respecify it without re-baking every
+     *  ramp it already holds. */
+    private pixels;
     private totalQueries;
     private cacheHits;
     constructor(gl: WebGL2RenderingContext);
-    upload(stops: GradStop[]): string;
-    bind(key: string, unit: number): void;
+    /** Rows the atlas currently holds — its texture height. */
+    get height(): number;
+    /**
+     * Bake `stops` into a row and return it, reusing the row an identical stop
+     * list already holds.
+     *
+     * **A returned row outlives the frame only while the atlas has room.** Past
+     * `RAMP_ATLAS_MAX_ROWS` an upload recycles the least recently used row, which
+     * rewrites texels a row handed out earlier still names. Nothing that defers
+     * its draw past this call may hold a row across another `upload` without
+     * arranging to be flushed first.
+     */
+    upload(stops: GradStop[]): 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
+     * rewrites its texels.
+     *
+     * 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;
+    /**
+     * The `v` a row is sampled at — its center.
+     *
+     * The center is load-bearing: the atlas filters LINEAR, so a `v` anywhere
+     * else blends the ramp beside it into this one. At the center the neighbor's
+     * weight is exactly zero.
+     */
+    rowV(row: number): number;
+    bind(unit: number): void;
     hitRate(): number;
     resetStats(): void;
     /**
-     * Delete every uploaded GL ramp texture and clear the map. Called by
-     * `WeaselRenderer.dispose()`. Only the GL textures are owned resources —
-     * `buildGradientRamp`'s CPU-side `Uint8ClampedArray` is transient per
-     * `upload()` call and already gone by the time a ramp is cached. The
-     * cache is unusable but refillable afterward (stats are left as-is; call
+     * Delete the atlas texture and forget every row in it. Called by
+     * `WeaselRenderer.dispose()`. The CPU mirror goes with it, so the atlas is
+     * unusable but refillable afterward (stats are left as-is; call
      * `resetStats()` separately if desired).
      */
     free(): void;
+    /** The row the next ramp is written to: a free one, a taller atlas, or the
+     *  least recently used row of a full one. */
+    private claimRow;
+    /** Grow to `rows`, keeping every row at the index it already had — a row
+     *  index is a stable name, and callers hold them. */
+    private resize;
+    private writeRow;
 }
 
 /** Row-major 4×5 color matrix identity. */
@@ -302,33 +368,72 @@ declare class GroupState {
 }
 
 /**
- * Growable vertex staging for consecutive solid-fill geometry.
+ * Growable vertex staging for a run of solid-fill geometry, image quads and
+ * glyphs.
  *
  * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the
- * uniforms the flush draws under. Colors ride the vertices (the batch program
- * is `pathFillVColor` with `u_color` left at white) because shapes in a run
- * differ in color and a merged draw has one set of uniforms — and so does the
- * model transform, applied here rather than uploaded, so that shapes under
- * different transforms still share a draw.
+ * uniforms the flush draws under.
+ *
+ * **One batch for all three, because a page interleaves them.** A grid of
+ * thumbnails is a ground rect under an atlas quad under a caption, per cell,
+ * and while each kind staged separately every one had to drain the others
+ * before it could stage — so a shape that batches perfectly in any one half
+ * alone paid a flush per command. Everything a vertex needs to say which it is
+ * fits in the same vertex: solids carry the UV of a 1x1 white texel and are
+ * their own color, quads carry their atlas UV and a white color, glyphs carry
+ * a font atlas UV, their text color, and a paint mode saying the texel is a
+ * distance field rather than a color. Gradients join as a fourth off the ramp
+ * atlas — a linear one without a mode of its own, since (ramp position, row) is
+ * what the plain mode already samples, and a radial or conic one with a mode
+ * that says its UV is a gradient-space coordinate to take a `length` or an
+ * `atan` of. See `shaders/batchFill.ts`.
+ *
+ * Colors ride the vertices because shapes in a run differ in color and a merged
+ * draw has one set of uniforms — and so does the model transform, applied here
+ * rather than uploaded, so shapes under different transforms still share a
+ * draw. The texture rides them too, as a slot index into the units the flush
+ * binds: slot 0 is the white texel every solid samples, and `draw.ts` hands out
+ * the rest per bitmap. A run holds as many bitmaps as there are slots, so an
+ * atlas is what makes a wall of one sheet coalesce and a handful of loose
+ * bitmaps no longer breaks a run per command.
  */
 
-declare class SolidBatch {
+/**
+ * A gradient vertex's `a_uv`, each channel affine in the coordinates the
+ * geometry arrives in: `u = ux*x + uy*y + u0`, and the same for `v`.
+ *
+ * One shape for all three gradients. A linear one's `v` row is the constant
+ * atlas row and its `u` row is the ramp position; a radial or conic one's two
+ * rows are the gradient-space coordinate, and the row rides `a_post` instead.
+ */
+interface GradientUV {
+    ux: number;
+    uy: number;
+    u0: number;
+    vx: number;
+    vy: number;
+    v0: number;
+}
+declare class DrawBatch {
     private readonly gl;
     private readonly aPos;
     private readonly aColor;
-    /** Cycled per flush, and created on first use so a renderer that flushes
-     *  rarely allocates as few slots as it flushes. */
-    private readonly ring;
-    private next;
-    /** The same, for flushes past a slot's capacity; these sets grow to fit. */
+    private readonly aUv;
+    private readonly aPost;
+    private readonly aSlot;
+    /** One ring per tier, cycled per flush. Slots are created on first use, so a
+     *  renderer that flushes rarely allocates as few as it flushes. */
+    private readonly rings;
+    private readonly nextInRing;
+    /** The same, for flushes past the largest tier; these sets grow to fit. */
     private readonly largeRing;
     private nextLarge;
     private verts;
     private idx;
     private nVerts;
     private nIdx;
-    /** Whether the staged run is rects alone, so its indices are the canonical
-     *  quad pattern and a slot already holding that pattern needs no upload. */
+    /** Whether the staged run is quads alone, so its indices are the canonical
+     *  pattern and a slot already holding that pattern needs no upload. */
     private pureRects;
     constructor(gl: WebGL2RenderingContext, prog: ShaderProgram);
     get length(): number;
@@ -340,6 +445,62 @@ declare class SolidBatch {
      * 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;
+    /**
+     * 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
+     * after-the-color-matrix alpha factor.
+     *
+     * Corners wind top-left, top-right, bottom-right, bottom-left with UVs
+     * following — the same winding `pushRect` uses, which is what lets a run of
+     * mixed rects and quads keep the canonical index pattern. The flips a command
+     * asks for are already in the `u` / `v` the caller passes.
+     *
+     * `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;
+    /**
+     * 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
+     * `rgba`.
+     *
+     * `mode` says which channels of that atlas carry the distance field, and
+     * rides the vertices packed into the slot — so a run off a baked MSDF atlas
+     * and one off the runtime canvas bake still share a draw. The synthetic-bold
+     * threshold does not: it is `u_synthBold`, and `draw.ts` breaks the run when
+     * it changes.
+     *
+     * **A synthetic oblique is sheared here rather than in the shader.** The old
+     * text program carried the baseline per vertex and skewed against
+     * `u_synthItalic`; the batch places its own corners, so the shear is one
+     * multiply while they are being placed, and `tanItalic` is 0 for an upright
+     * face. It has to happen before `m`, which is where the shader had it too.
+     *
+     * Corners wind top-left, top-right, bottom-right, bottom-left — `pushQuad`'s
+     * 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;
+    /**
+     * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped
+     * through `m`, sampling the ramp atlas at `slot`.
+     *
+     * `uv` gives each channel of `a_uv` as an affine function of the coordinates
+     * the corners arrive in, which is what lets a gradient ride the vertices at
+     * all: a linear one's ramp position is affine in position outright, and a
+     * radial or conic one's gradient-space *coordinate* is, even though the ramp
+     * position it yields is not. Either way the rasterizer's interpolation across
+     * a triangle is exact. `mode` says which of the two the fragment shader is
+     * looking at, and `post` carries the atlas row for the modes that read it —
+     * see `shaders/batchFill.ts`.
+     *
+     * 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;
+    /** `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;
     /**
      * 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
@@ -351,6 +512,9 @@ declare class SolidBatch {
     uploadAndBind(): number;
     reset(): void;
     dispose(): void;
+    private writeVertex;
+    /** Two triangles over the four corners just written. */
+    private pushQuadIndices;
     /** Grow the CPU arrays so `vertices` / `indices` more fit. */
     private reserve;
     private nextRingSlot;
@@ -359,67 +523,6 @@ declare class SolidBatch {
     private deleteSet;
 }
 
-/**
- * Growable vertex staging for consecutive image quads.
- *
- * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the
- * uniforms the flush draws under. The counterpart to `SolidBatch`, and the same
- * two tricks — the model transform is applied here rather than uploaded, so
- * quads under different group transforms still share a draw, and opacity rides
- * the vertices, so quads under different opacities do too. What it cannot
- * absorb is the texture: a batch samples one, which is why an atlas is what
- * makes a large run coalesce at all.
- *
- * Every run is quads, so a slot's index buffer is written once at creation and
- * never again: the pattern for N quads is a prefix of the pattern for any
- * larger N, so the pattern for a slot's capacity serves every flush it takes.
- * `SolidBatch` carries meshes, whose indices are rebased per flush, and has to
- * re-upload; this does not.
- */
-
-declare class ImageBatch {
-    private readonly gl;
-    private readonly aPos;
-    private readonly aUv;
-    private readonly aOpacity;
-    /** One ring per tier, cycled per flush. Slots are created on first use, so a
-     *  renderer that flushes rarely allocates as few as it flushes. */
-    private readonly rings;
-    private readonly nextInRing;
-    /** For flushes past the largest tier; these sets grow to fit. */
-    private readonly largeRing;
-    private nextLarge;
-    private verts;
-    private nQuads;
-    constructor(gl: WebGL2RenderingContext, prog: ShaderProgram);
-    /** Indices staged — what a caller passes to `drawElements`. */
-    get length(): number;
-    get quads(): number;
-    /** Whether staging one more quad would put the run past the per-flush cap. */
-    wouldOverflow(): boolean;
-    /**
-     * Append one image quad: the destination rect `(x, y, w, h)` mapped through
-     * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `opacity`.
-     *
-     * An affine maps a rect to a parallelogram, so two triangles still cover it
-     * and the batch draws at `u_model` identity. Corners wind top-left,
-     * top-right, bottom-right, bottom-left, with UVs following — the flips a
-     * command asks for are already in the `u`/`v` the caller passes.
-     */
-    pushQuad(x: number, y: number, w: number, h: number, m: Mat3, u0: number, v0: number, u1: number, v1: number, opacity: 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;
-    reset(): void;
-    dispose(): void;
-    /** Grow the CPU arrays so one more quad fits. */
-    private reserve;
-    private nextRingSlot;
-    private nextLargeSlot;
-    private createSet;
-    private deleteSet;
-}
-
 /** How to construct a `WeaselRenderer`: the GL context or canvas to draw
  *  into, the output size, and the quality knobs that separate screen
  *  rendering from print. */
@@ -486,21 +589,21 @@ declare class WeaselRenderer {
     private readonly gl;
     private pathFill;
     private pathFillVColor;
-    private textSdf;
-    private textSdfR8;
     private imageFill;
-    private imageFillVOpacity;
+    private batchFill;
     private gradFill;
     private patternFill;
     private meshCache;
     private textureCache;
     private imageCache;
-    private gradRampCache;
+    private gradRamps;
     private programRegistry;
     private quadVbo;
     private quadIbo;
-    private solidBatch;
-    private imageBatch;
+    private drawBatch;
+    /** 1x1 white, so a batch flush sampling no image still samples something —
+     *  see `shaders/batchFill.ts`. */
+    private whiteTexture;
     private readonly groupState;
     private widthCss;
     private heightCss;
@@ -560,7 +663,7 @@ declare class WeaselRenderer {
      *  Scope: built-in shader programs, any consumer-registered programs, the
      *  shared quad/rect geometry, any in-flight transient meshes, and the
      *  enumerable Map-keyed caches (`GLTextureCache` atlas/image textures,
-     *  `GradientRampCache` ramp textures) ARE freed.
+     *  `GradientRampAtlas`'s ramp texture) ARE freed.
      *
      *  NOT freed: `GLImageCache` (bitmap/pattern textures) and `GLMeshCache`'s
      *  persistent per-Path mesh cache are keyed by `WeakMap`, not enumerable,
@@ -596,18 +699,15 @@ declare class WeaselRenderer {
     /** @internal */ _gl(): WebGL2RenderingContext;
     /** @internal */ _pathFill(): ShaderProgram;
     /** @internal */ _pathFillVColor(): ShaderProgram;
-    /** @internal */ _solidBatch(): SolidBatch;
-    /** @internal */ _imageBatch(): ImageBatch;
-    /** @internal */ _textSdf(): ShaderProgram;
-    /** @internal */ _textSdfR8(): ShaderProgram;
+    /** @internal */ _drawBatch(): DrawBatch;
     /** @internal */ _imageFill(): ShaderProgram;
-    /** @internal */ _imageFillVOpacity(): ShaderProgram;
+    /** @internal */ _batchFill(): ShaderProgram;
     /** @internal */ _gradFill(): ShaderProgram;
     /** @internal */ _patternFill(): ShaderProgram;
     /** @internal */ _meshCache(): GLMeshCache;
     /** @internal */ _textureCache(): GLTextureCache;
     /** @internal */ _imageCache(): GLImageCache;
-    /** @internal */ _gradRampCache(): GradientRampCache;
+    /** @internal */ _gradRamps(): GradientRampAtlas;
     /** @internal */ _groupState(): GroupState;
     /** @internal */ _widthCss(): number;
     /** @internal */ _heightCss(): number;

package/dist/{chunk-ORZNKVXM.js → chunk-2VXGHUVL.js}

@@ -1,4 +1,4 @@
-import { RECT_ORIGIN_PROJECTION } from './chunk-SBFC6J3C.js';
+import { RECT_ORIGIN_PROJECTION } from './chunk-WPM42WJP.js';
 import { registerOpFactory, captureSlot, slotFromIndex, resolveSlot } from './chunk-4RJP2N2L.js';
 
 // src/core/ops/transform.ts
@@ -142,5 +142,5 @@ function snap(strategy, opts = {}) {
 }
 
 export { createReparentOp, createTransformOp, deleteScratch, getScratch, scratchKey, setScratch, snap };
-//# sourceMappingURL=chunk-ORZNKVXM.js.map
-//# sourceMappingURL=chunk-ORZNKVXM.js.map
+//# sourceMappingURL=chunk-2VXGHUVL.js.map
+//# sourceMappingURL=chunk-2VXGHUVL.js.map

package/dist/{chunk-ORZNKVXM.js.map → chunk-2VXGHUVL.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/core/ops/transform.ts","../src/core/ops/reparent.ts","../src/interactions/scratchKey.ts","../src/interactions/gestures/shared/snap.ts"],"names":[],"mappings":"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","file":"chunk-ORZNKVXM.js","sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface TransformAdapter<TPose> {\n  setPose(id: string, pose: TPose): void;\n}\n\n/** @internal */\ninterface TransformArgs<TPose> {\n  id: string;\n  from: TPose;\n  to: TPose;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Op: set an object's pose, inverting back to `from`. `coalesceKey` defaults to\n *  `transform:${id}` so successive pose writes to the same node (drag-move,\n *  resize, repeated nudges) merge into one undo entry within the history's\n *  coalesce window. Pass an explicit key (or a unique one) to opt out. */\nexport function createTransformOp<TPose>(args: TransformArgs<TPose>): Op {\n  const { id, from, to, label, coalesceKey = `transform:${id}` } = args;\n  return {\n    name: 'transform',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      // Always call setPose so consumers that inspect op behavior (tests,\n      // overlays) see a consistent \"this op writes (id, to)\" signal. When\n      // from and to are structurally identical, additionally report a\n      // no-op to history so the entry can be skipped from the undo stack.\n      // setPose(id, to) is idempotent in this branch — adapters write the\n      // same pose they already had.\n      (adapter as TransformAdapter<TPose>).setPose(id, to);\n      if (poseShallowEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createTransformOp<TPose>({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<TransformArgs<unknown>>('transform', (args) => createTransformOp(args));\n\nfunction poseShallowEqual<TPose>(a: TPose, b: TPose): boolean {\n  if (a === b) return true;\n  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;\n  const ka = Object.keys(a as object);\n  const kb = Object.keys(b as object);\n  if (ka.length !== kb.length) return false;\n  for (const k of ka) {\n    if ((a as Record<string, unknown>)[k] !== (b as Record<string, unknown>)[k]) return false;\n  }\n  return true;\n}\n","import type { Op } from './types';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, resolveSlot, slotFromIndex, type OrderedReader, type Slot } from './slot';\n\ninterface ReparentAdapter extends OrderedReader {\n  setParent(id: string, parentId: string | null): void;\n  /** Sibling-order write, paired with `getChildren`. Optional: an adapter\n   *  without both silently ignores slots and appends. */\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n}\n\n/** @internal */\ninterface ReparentArgs {\n  id: string;\n  fromParentId: string | null;\n  toParentId: string | null;\n  /** Sibling ordinal under the old parent. Sugar for `fromSlot: { index }`,\n   *  and only a seed: `apply` re-observes the node's full slot through the\n   *  adapter and that observation supersedes this. */\n  fromIndex?: number;\n  /** Sibling ordinal under the new parent. Sugar for `toSlot: { index }`.\n   *  Omit to append. */\n  toIndex?: number;\n  /** Slot under the old parent, anchor included. `invert()` forwards it as\n   *  the destination slot; without it undo re-parents with no position and\n   *  the node lands last, quietly changing paint order. */\n  fromSlot?: Slot;\n  /** Slot under the new parent, anchor included. Omit to append. */\n  toSlot?: Slot;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Move `id` to `slot` among `parentId`'s children. No-op when the adapter\n *  has no ordering seam, when `id` isn't there, or when it's already in\n *  place. */\nfunction placeAt(\n  a: ReparentAdapter,\n  parentId: string | null,\n  id: string,\n  slot: Slot,\n): void {\n  if (!a.getChildren || !a.setChildOrder) return;\n  const current = a.getChildren(parentId);\n  const from = current.indexOf(id);\n  if (from < 0) return;\n  const next = current.slice();\n  next.splice(from, 1);\n  const resolved = resolveSlot(next, slot);\n  const to = resolved === undefined ? next.length : Math.max(0, Math.min(resolved, next.length));\n  if (from === to) return;\n  next.splice(to, 0, id);\n  a.setChildOrder(parentId, next);\n}\n\n/** Present when the caller named a destination at all; `undefined` leaves\n *  placement to the adapter. */\nfunction optionalSlot(slot: Slot | undefined, index: number | undefined): Slot | undefined {\n  if (slot) return slot;\n  return index === undefined ? undefined : slotFromIndex(index);\n}\n\n/**\n * Op: change `id`'s parent and sibling slot, inverting back to the prior\n * parent and slot.\n *\n * `coalesceKey` defaults to `reparent:${id}` so successive reparents of the\n * same id batch-merge cleanly.\n */\nexport function createReparentOp(args: ReparentArgs): Op {\n  const {\n    id, fromParentId, toParentId,\n    label = 'Reparent', coalesceKey = `reparent:${id}`,\n  } = args;\n  let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);\n  const toSlot = optionalSlot(args.toSlot, args.toIndex);\n  const argsForSerial: ReparentArgs = {\n    id, fromParentId, toParentId, fromSlot, toSlot, label, coalesceKey,\n  };\n  return {\n    name: 'reparent',\n    args: argsForSerial,\n    label,\n    coalesceKey,\n    apply(adapter) {\n      const a = adapter as ReparentAdapter;\n      const observed = captureSlot(a, fromParentId, id);\n      if (observed) {\n        fromSlot = observed;\n        argsForSerial.fromSlot = observed;\n      }\n      a.setParent(id, toParentId);\n      if (toSlot) placeAt(a, toParentId, id, toSlot);\n    },\n    invert() {\n      return createReparentOp({\n        id,\n        fromParentId: toParentId,\n        toParentId: fromParentId,\n        fromSlot: toSlot,\n        toSlot: fromSlot,\n        label,\n        coalesceKey,\n      });\n    },\n  };\n}\n\nregisterOpFactory<ReparentArgs>('reparent', (args) => createReparentOp(args));\n","/**\n * Typed keys for the gesture/behavior scratch store.\n *\n * Gestures expose `ctx.scratch: Record<string, unknown>` as a per-gesture\n * mutable bag that behaviors use to stash state across `onDown` / `onMove`\n * / `onEnd` calls. The store is `unknown`-valued because behaviors are\n * tool-agnostic — a single behavior may run under different tools with\n * different scratch shapes. Without a typing convention every read site\n * has to `(ctx.scratch as <some shape>)[KEY]`, and a writer changing the\n * shape can silently break readers with no compile-time signal.\n *\n * `ScratchKey<T>` is a phantom-typed string that carries its payload type\n * via a branded interface. `getScratch` and `setScratch` use the brand to\n * narrow / constrain at the typing layer; at runtime the key is just its\n * underlying string and the store remains a plain `Record`.\n *\n * @example\n * ```ts\n * // Module-level (or behavior-level) constant, shared by writer + reader:\n * const LASSO_VERTICES = scratchKey<readonly { x: number; y: number }[]>('lasso.vertices');\n *\n * // Writer (a tool's onMove):\n * setScratch(ctx.scratch, LASSO_VERTICES, vertices);\n *\n * // Reader (a behavior's onEnd):\n * const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n * //    ^?  readonly { x: number; y: number }[] | undefined\n * ```\n */\n\n/** Phantom-typed key for a scratch slot. The `__scratchKeyPayload` phantom\n *  field carries the value type without occupying any runtime memory. */\nexport interface ScratchKey<T> {\n  readonly name: string;\n  /** Phantom — never read at runtime. Only present so TypeScript can\n   *  recover `T` at use sites. */\n  readonly __scratchKeyPayload?: (_: T) => T;\n}\n\n/** Compatible scratch store shape. The kit's gesture context's `scratch`\n *  field already satisfies this; consumers don't need to construct one. */\nexport type ScratchStore = Record<string, unknown>;\n\n/**\n * Make a typed scratch key. Use module-level constants so the same key\n * is shared by writer and reader.\n *\n * Namespace the name by behavior or feature to avoid collisions\n * (`'behavior.field'` is a good convention). Two keys with the same\n * `name` refer to the same slot at runtime — the type parameter is a\n * compile-time contract, not a uniqueness guarantee.\n */\nexport function scratchKey<T>(name: string): ScratchKey<T> {\n  return { name };\n}\n\n/** Read a typed slot from the scratch store. Returns `undefined` if\n *  nothing has been written under the key. */\nexport function getScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): T | undefined {\n  return store[key.name] as T | undefined;\n}\n\n/** Write a value to a typed slot. Overwrites whatever was there. */\nexport function setScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n  value: T,\n): void {\n  store[key.name] = value;\n}\n\n/** Remove a slot from the scratch store. Returns `true` if it was set,\n *  `false` if it wasn't. */\nexport function deleteScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): boolean {\n  if (Object.prototype.hasOwnProperty.call(store, key.name)) {\n    delete store[key.name];\n    return true;\n  }\n  return false;\n}\n","import type { MoveBehavior, ModifierState, SnapStrategy } from '../types';\nimport {\n  RECT_ORIGIN_PROJECTION,\n  type OriginProjection,\n} from './strategies/grid';\n\ntype ModKey = keyof ModifierState;\n\n/**\n * Generic snap behavior factory: wraps a `SnapStrategy` and returns a\n * `MoveBehavior` whose `onMove` returns a uniform `GroupTransform`.\n *\n * Implementation:\n *   1. Compute the primary's proposed pose by applying the gesture's\n *      `transform` (translate) to `origin.get(primaryId)`.\n *   2. Call `strategy.snap(proposed)`. If null, no-op.\n *   3. Derive the snapped delta via the `OriginProjection`:\n *        dx = origin(snapped).x - origin(originPose).x\n *      ...so the gesture applies the same delta to every dragged id.\n *\n * The pose-shape-aware delta extraction lives here — gestures stay pose-shape\n * agnostic. Default projection is `{x, y}`-bearing (rect / path / polygon).\n * Pass `origin` for exotic poses.\n */\nexport function snap<TPose>(\n  strategy: SnapStrategy<TPose>,\n  opts: { bypassKey?: ModKey; origin?: OriginProjection<TPose> } = {},\n): MoveBehavior<TPose> {\n  const { bypassKey } = opts;\n  const proj: OriginProjection<TPose> = opts.origin\n    ?? (RECT_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  return {\n    onMove(ctx, transform) {\n      if (bypassKey && ctx.modifiers[bypassKey]) return;\n      // The new contract: behaviors see a GroupTransform, not a pose. But\n      // strategies still operate on poses. Reconstruct the proposed pose\n      // by applying the (translate) transform to the primary's origin.\n      if (transform.kind !== 'translate') return;\n      const primaryId = ctx.draggedIds[0];\n      if (primaryId === undefined) return;\n      const originPose = ctx.origin.get(primaryId);\n      if (originPose === undefined) return;\n      const proposed = proj.translate(originPose, transform.dx, transform.dy);\n      const snapped = strategy.snap(proposed, ctx);\n      if (snapped === null) return;\n      const o0 = proj.getOrigin(originPose);\n      const o1 = proj.getOrigin(snapped);\n      return {\n        transform: { kind: 'translate', dx: o1.x - o0.x, dy: o1.y - o0.y },\n      };\n    },\n  };\n}\n"]}
+{"version":3,"sources":["../src/core/ops/transform.ts","../src/core/ops/reparent.ts","../src/interactions/scratchKey.ts","../src/interactions/gestures/shared/snap.ts"],"names":[],"mappings":"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","file":"chunk-2VXGHUVL.js","sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface TransformAdapter<TPose> {\n  setPose(id: string, pose: TPose): void;\n}\n\n/** @internal */\ninterface TransformArgs<TPose> {\n  id: string;\n  from: TPose;\n  to: TPose;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Op: set an object's pose, inverting back to `from`. `coalesceKey` defaults to\n *  `transform:${id}` so successive pose writes to the same node (drag-move,\n *  resize, repeated nudges) merge into one undo entry within the history's\n *  coalesce window. Pass an explicit key (or a unique one) to opt out. */\nexport function createTransformOp<TPose>(args: TransformArgs<TPose>): Op {\n  const { id, from, to, label, coalesceKey = `transform:${id}` } = args;\n  return {\n    name: 'transform',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      // Always call setPose so consumers that inspect op behavior (tests,\n      // overlays) see a consistent \"this op writes (id, to)\" signal. When\n      // from and to are structurally identical, additionally report a\n      // no-op to history so the entry can be skipped from the undo stack.\n      // setPose(id, to) is idempotent in this branch — adapters write the\n      // same pose they already had.\n      (adapter as TransformAdapter<TPose>).setPose(id, to);\n      if (poseShallowEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createTransformOp<TPose>({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<TransformArgs<unknown>>('transform', (args) => createTransformOp(args));\n\nfunction poseShallowEqual<TPose>(a: TPose, b: TPose): boolean {\n  if (a === b) return true;\n  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;\n  const ka = Object.keys(a as object);\n  const kb = Object.keys(b as object);\n  if (ka.length !== kb.length) return false;\n  for (const k of ka) {\n    if ((a as Record<string, unknown>)[k] !== (b as Record<string, unknown>)[k]) return false;\n  }\n  return true;\n}\n","import type { Op } from './types';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, resolveSlot, slotFromIndex, type OrderedReader, type Slot } from './slot';\n\ninterface ReparentAdapter extends OrderedReader {\n  setParent(id: string, parentId: string | null): void;\n  /** Sibling-order write, paired with `getChildren`. Optional: an adapter\n   *  without both silently ignores slots and appends. */\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n}\n\n/** @internal */\ninterface ReparentArgs {\n  id: string;\n  fromParentId: string | null;\n  toParentId: string | null;\n  /** Sibling ordinal under the old parent. Sugar for `fromSlot: { index }`,\n   *  and only a seed: `apply` re-observes the node's full slot through the\n   *  adapter and that observation supersedes this. */\n  fromIndex?: number;\n  /** Sibling ordinal under the new parent. Sugar for `toSlot: { index }`.\n   *  Omit to append. */\n  toIndex?: number;\n  /** Slot under the old parent, anchor included. `invert()` forwards it as\n   *  the destination slot; without it undo re-parents with no position and\n   *  the node lands last, quietly changing paint order. */\n  fromSlot?: Slot;\n  /** Slot under the new parent, anchor included. Omit to append. */\n  toSlot?: Slot;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Move `id` to `slot` among `parentId`'s children. No-op when the adapter\n *  has no ordering seam, when `id` isn't there, or when it's already in\n *  place. */\nfunction placeAt(\n  a: ReparentAdapter,\n  parentId: string | null,\n  id: string,\n  slot: Slot,\n): void {\n  if (!a.getChildren || !a.setChildOrder) return;\n  const current = a.getChildren(parentId);\n  const from = current.indexOf(id);\n  if (from < 0) return;\n  const next = current.slice();\n  next.splice(from, 1);\n  const resolved = resolveSlot(next, slot);\n  const to = resolved === undefined ? next.length : Math.max(0, Math.min(resolved, next.length));\n  if (from === to) return;\n  next.splice(to, 0, id);\n  a.setChildOrder(parentId, next);\n}\n\n/** Present when the caller named a destination at all; `undefined` leaves\n *  placement to the adapter. */\nfunction optionalSlot(slot: Slot | undefined, index: number | undefined): Slot | undefined {\n  if (slot) return slot;\n  return index === undefined ? undefined : slotFromIndex(index);\n}\n\n/**\n * Op: change `id`'s parent and sibling slot, inverting back to the prior\n * parent and slot.\n *\n * `coalesceKey` defaults to `reparent:${id}` so successive reparents of the\n * same id batch-merge cleanly.\n */\nexport function createReparentOp(args: ReparentArgs): Op {\n  const {\n    id, fromParentId, toParentId,\n    label = 'Reparent', coalesceKey = `reparent:${id}`,\n  } = args;\n  let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);\n  const toSlot = optionalSlot(args.toSlot, args.toIndex);\n  const argsForSerial: ReparentArgs = {\n    id, fromParentId, toParentId, fromSlot, toSlot, label, coalesceKey,\n  };\n  return {\n    name: 'reparent',\n    args: argsForSerial,\n    label,\n    coalesceKey,\n    apply(adapter) {\n      const a = adapter as ReparentAdapter;\n      const observed = captureSlot(a, fromParentId, id);\n      if (observed) {\n        fromSlot = observed;\n        argsForSerial.fromSlot = observed;\n      }\n      a.setParent(id, toParentId);\n      if (toSlot) placeAt(a, toParentId, id, toSlot);\n    },\n    invert() {\n      return createReparentOp({\n        id,\n        fromParentId: toParentId,\n        toParentId: fromParentId,\n        fromSlot: toSlot,\n        toSlot: fromSlot,\n        label,\n        coalesceKey,\n      });\n    },\n  };\n}\n\nregisterOpFactory<ReparentArgs>('reparent', (args) => createReparentOp(args));\n","/**\n * Typed keys for the gesture/behavior scratch store.\n *\n * Gestures expose `ctx.scratch: Record<string, unknown>` as a per-gesture\n * mutable bag that behaviors use to stash state across `onDown` / `onMove`\n * / `onEnd` calls. The store is `unknown`-valued because behaviors are\n * tool-agnostic — a single behavior may run under different tools with\n * different scratch shapes. Without a typing convention every read site\n * has to `(ctx.scratch as <some shape>)[KEY]`, and a writer changing the\n * shape can silently break readers with no compile-time signal.\n *\n * `ScratchKey<T>` is a phantom-typed string that carries its payload type\n * via a branded interface. `getScratch` and `setScratch` use the brand to\n * narrow / constrain at the typing layer; at runtime the key is just its\n * underlying string and the store remains a plain `Record`.\n *\n * @example\n * ```ts\n * // Module-level (or behavior-level) constant, shared by writer + reader:\n * const LASSO_VERTICES = scratchKey<readonly { x: number; y: number }[]>('lasso.vertices');\n *\n * // Writer (a tool's onMove):\n * setScratch(ctx.scratch, LASSO_VERTICES, vertices);\n *\n * // Reader (a behavior's onEnd):\n * const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n * //    ^?  readonly { x: number; y: number }[] | undefined\n * ```\n */\n\n/** Phantom-typed key for a scratch slot. The `__scratchKeyPayload` phantom\n *  field carries the value type without occupying any runtime memory. */\nexport interface ScratchKey<T> {\n  readonly name: string;\n  /** Phantom — never read at runtime. Only present so TypeScript can\n   *  recover `T` at use sites. */\n  readonly __scratchKeyPayload?: (_: T) => T;\n}\n\n/** Compatible scratch store shape. The kit's gesture context's `scratch`\n *  field already satisfies this; consumers don't need to construct one. */\nexport type ScratchStore = Record<string, unknown>;\n\n/**\n * Make a typed scratch key. Use module-level constants so the same key\n * is shared by writer and reader.\n *\n * Namespace the name by behavior or feature to avoid collisions\n * (`'behavior.field'` is a good convention). Two keys with the same\n * `name` refer to the same slot at runtime — the type parameter is a\n * compile-time contract, not a uniqueness guarantee.\n */\nexport function scratchKey<T>(name: string): ScratchKey<T> {\n  return { name };\n}\n\n/** Read a typed slot from the scratch store. Returns `undefined` if\n *  nothing has been written under the key. */\nexport function getScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): T | undefined {\n  return store[key.name] as T | undefined;\n}\n\n/** Write a value to a typed slot. Overwrites whatever was there. */\nexport function setScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n  value: T,\n): void {\n  store[key.name] = value;\n}\n\n/** Remove a slot from the scratch store. Returns `true` if it was set,\n *  `false` if it wasn't. */\nexport function deleteScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): boolean {\n  if (Object.prototype.hasOwnProperty.call(store, key.name)) {\n    delete store[key.name];\n    return true;\n  }\n  return false;\n}\n","import type { MoveBehavior, ModifierState, SnapStrategy } from '../types';\nimport {\n  RECT_ORIGIN_PROJECTION,\n  type OriginProjection,\n} from './strategies/grid';\n\ntype ModKey = keyof ModifierState;\n\n/**\n * Generic snap behavior factory: wraps a `SnapStrategy` and returns a\n * `MoveBehavior` whose `onMove` returns a uniform `GroupTransform`.\n *\n * Implementation:\n *   1. Compute the primary's proposed pose by applying the gesture's\n *      `transform` (translate) to `origin.get(primaryId)`.\n *   2. Call `strategy.snap(proposed)`. If null, no-op.\n *   3. Derive the snapped delta via the `OriginProjection`:\n *        dx = origin(snapped).x - origin(originPose).x\n *      ...so the gesture applies the same delta to every dragged id.\n *\n * The pose-shape-aware delta extraction lives here — gestures stay pose-shape\n * agnostic. Default projection is `{x, y}`-bearing (rect / path / polygon).\n * Pass `origin` for exotic poses.\n */\nexport function snap<TPose>(\n  strategy: SnapStrategy<TPose>,\n  opts: { bypassKey?: ModKey; origin?: OriginProjection<TPose> } = {},\n): MoveBehavior<TPose> {\n  const { bypassKey } = opts;\n  const proj: OriginProjection<TPose> = opts.origin\n    ?? (RECT_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  return {\n    onMove(ctx, transform) {\n      if (bypassKey && ctx.modifiers[bypassKey]) return;\n      // The new contract: behaviors see a GroupTransform, not a pose. But\n      // strategies still operate on poses. Reconstruct the proposed pose\n      // by applying the (translate) transform to the primary's origin.\n      if (transform.kind !== 'translate') return;\n      const primaryId = ctx.draggedIds[0];\n      if (primaryId === undefined) return;\n      const originPose = ctx.origin.get(primaryId);\n      if (originPose === undefined) return;\n      const proposed = proj.translate(originPose, transform.dx, transform.dy);\n      const snapped = strategy.snap(proposed, ctx);\n      if (snapped === null) return;\n      const o0 = proj.getOrigin(originPose);\n      const o1 = proj.getOrigin(snapped);\n      return {\n        transform: { kind: 'translate', dx: o1.x - o0.x, dy: o1.y - o0.y },\n      };\n    },\n  };\n}\n"]}

package/dist/{chunk-LEURURX3.js → chunk-BL65SHCX.js}

@@ -9,12 +9,24 @@ function DepRegistryProvider({ children }) {
   const sourcesRef = useRef(/* @__PURE__ */ new Map());
   const registry = useMemo(() => ({
     register: (name, source) => {
-      sourcesRef.current.set(name, source);
+      const key = name;
+      const entry = source;
+      const stack = sourcesRef.current.get(key);
+      if (stack) stack.push(entry);
+      else sourcesRef.current.set(key, [entry]);
+      let released = false;
       return () => {
-        sourcesRef.current.delete(name);
+        if (released) return;
+        released = true;
+        const cur = sourcesRef.current.get(key);
+        if (!cur) return;
+        const i = cur.lastIndexOf(entry);
+        if (i === -1) return;
+        cur.splice(i, 1);
+        if (cur.length === 0) sourcesRef.current.delete(key);
       };
     },
-    get: (name) => sourcesRef.current.get(name)?.()
+    get: (name) => sourcesRef.current.get(name)?.at(-1)?.()
   }), []);
   return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: registry, children });
 }
@@ -557,5 +569,5 @@ function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
 }
 
 export { ActionDisabledReason, ActionsProvider, ActionsScope, DepRegistryProvider, PREDICATE_TARGET, actionBindings, buildDepsFromRequires, buildRouteRegistry, evaluateEnabled, findConflicts, reportRouteConflicts, routeGestureForSpecKind, routesForSpec, useAction, useActionsRegistry, useDepRegistry, useDepSource, useOptionalDepRegistry };
-//# sourceMappingURL=chunk-LEURURX3.js.map
-//# sourceMappingURL=chunk-LEURURX3.js.map
+//# sourceMappingURL=chunk-BL65SHCX.js.map
+//# sourceMappingURL=chunk-BL65SHCX.js.map