@weasel-js/core 1.4.4 → 1.5.0

package/README.md

@@ -1,19 +1,16 @@
 # weasel
 
-Domain-agnostic 2D scene-graph hooks for React, rendered on WebGL2. Bring your own object type and pose shape; weasel handles the viewport math, pointer gestures (move / resize / insert / clone / area-select / text edit), layered scene rendering, an op-based undo/redo model, and a stack of selection-driven action hooks (delete, duplicate, nudge, group, clipboard, undo/redo, …) wired to keyboard shortcuts when you ask.
+A 2D scene-graph engine for React, rendered on WebGL2. Bring your own node data and pose shape; weasel owns the scene tree, the viewport math, pointer and keyboard input, layered rendering, and op-based undo/redo — plus a standard set of editing actions (select, move, resize, rotate, delete, duplicate, nudge, group, align, clipboard, …) bound to the keys and gestures an editor user expects.
 
 Built for diagram editors, sketch tools, schematic editors, scene composers — anything where "objects on a canvas the user can grab, move, and arrange" is the substrate.
 
-> Pre-1.0: the API surface (paths, nesting, per-subobject units) is still settling. Expect breaking changes between minor versions until 1.0.
-
 ## Features
 
-- Pointer gestures: move, resize, rotate, insert, clone, area-select, text edit
+- Pointer interactions: move, resize, rotate, insert, clone, area-select, lasso, path-anchor editing, text edit
 - Op-based scene mutation with undo/redo and coalescing
-- Selection-driven action hooks (delete, duplicate, nudge, reorder, clipboard, …)
-- Centralized actions registry with default keybindings (`@experimental`)
+- A registry of actions with default key and gesture bindings, each one overridable by id (`@experimental`)
 - Layered canvas rendering with debug overlays
-- Path poses, rect poses, rotated poses; first-class compound paths
+- Rect, rotated and path poses; first-class compound paths; nested containers
 - Viewport with zoom/pan tools, momentum, and boundary clamping
 - Detached read-only scene views and navigation minimap (`<SceneViewCanvas>`, `<MinimapCanvas>`)
 - WebGL2 renderer with MSDF text, gradients, patterns, and per-vertex colors
@@ -29,65 +26,70 @@ npm install @weasel-js/core react
 
 ## How it fits together
 
-Every interaction takes a small, narrow **adapter** — a few methods that read the current scene and apply ops back. The kit doesn't own your scene; it asks. That keeps it agnostic to whether your scene lives in React state, Zustand, Redux, or a CRDT.
-
-```tsx
-import { useMove, useDelete, createHistory, snap, gridSnapStrategy } from '@weasel-js/core';
-
-const history = createHistory(adapter);
+`useScene` holds the scene: a tree of leaf and container nodes, each carrying your data and a pose. Every change to it is an **op**, which is what makes it undoable. `<SceneCanvas>` renders a scene and routes input to it.
 
-// Drag-to-move with snapping, history, and parent reparenting:
-const move = useMove(adapter, {
-  behaviors: [snap(gridSnapStrategy(20))],
-});
+Interactions are **actions** — descriptors registered into an actions registry — reached by **gesture bindings**. A tool is a list of `{ spec, actionId }` pairs and nothing more; the kit's own select, shape and viewport tools are built that way.
 
-// Selection-aware delete with Backspace/Delete bound:
-useDelete(adapter, { bindKeyboard: true });
+```tsx
+import { SceneCanvas, useScene, useSelection, gridSnapStrategy, type RectPose } from '@weasel-js/core';
+
+const W = 800, H = 600;
+
+export function Editor() {
+  const scene = useScene({ systemLayers: [{ id: 'default' }], initial: [] });
+  const selection = useSelection({ mode: 'multi' });
+
+  // Click to select, drag to move with grid snapping, handles to resize and
+  // rotate, the shape tools, and the standard keyboard actions (Cmd+A, Cmd+Z,
+  // Delete, …):
+  return (
+    <SceneCanvas
+      width={W}
+      height={H}
+      scene={scene}
+      selection={selection}
+      selectionMode="multi"
+      toolBundle="exhaustive"
+      selectTool={{ snap: gridSnapStrategy<RectPose>(20) }}
+      layers={{
+        grid: { spacing: 20, bounds: () => ({ x: 0, y: 0, width: W, height: H }) },
+      }}
+    />
+  );
+}
 ```
 
-Most apps don't call the gesture hooks directly — `<SceneCanvas>` owns useMove /
-useResize / useInsert / useAreaSelect / useSelection internally. Drop in a
-`useScene()` tree and a `layers` map and you get click-to-select, drag-to-move,
-corner-handle-resize, and an `tool="insert"` mode for free.
+To change a behavior you override the descriptor by id, bind a different gesture to it, or register your own — you don't call a hook per interaction. [docs/hooks.md](https://github.com/orochi235/weasel/blob/main/docs/hooks.md) has the full action table.
 
-See the live demo for a full working example: <https://orochi235.github.io/weasel/>
+Lower-level surfaces take a narrow **adapter** instead of a scene — a few methods that read your state and apply ops back — so they work over state weasel doesn't own. See [docs/adapters.md](https://github.com/orochi235/weasel/blob/main/docs/adapters.md).
 
 ## Demo
 
-Live demo: <https://orochi235.github.io/weasel/>
-
-## Text rendering
-
-Text is rendered via MSDF atlases. Register fonts before the first paint:
-
-```tsx
-import { registerFont } from '@weasel-js/core';
-
-await registerFont('Inter', { weight: 400 }, '/fonts/Inter-400.json', '/fonts/Inter-400.png');
-```
-
-Core doesn't ship a prebuilt atlas — bake one with `npm run gen:font -- <font.ttf> --name Inter-400 --out public/fonts` (see `scripts/gen-font.ts`) and serve the resulting `.json`/`.png` pair. The `hud` package ships its own bundled Inter atlas for consumers who don't need custom fonts.
+<https://orochi235.github.io/weasel/> — every kit feature as a small runnable demo, plus the release history for every published version.
 
 ## Actions registry
 
-An `Action` is a named operation — `delete`, `duplicate`, `group`, `insert`, `viewport.dragPan` — paired with the input that triggers it. `<ActionsProvider>` holds the registered descriptors, and the gesture dispatcher matches live input against each one's `defaultBinding`. Keystrokes and pointer gestures take the same path, so a keyboard shortcut and a drag are two bindings on one action rather than two mechanisms.
+An `Action` is a named operation — `delete`, `duplicate`, `group`, `insert`, `viewport.dragPan` — paired with the input that triggers it. `<ActionsProvider>` holds the registered descriptors, and the gesture dispatcher matches live input against each one's `defaultBinding` and the active tool's bindings. Keystrokes and pointer gestures take the same path, so a keyboard shortcut and a drag are two bindings on one action rather than two mechanisms.
 
-`<SceneCanvas>` auto-mounts a provider when none is above it and registers the kit-standard descriptors, derived from the scene, selection, view and history it already owns.
+`<SceneCanvas>` mounts a provider when none is above it and registers the kit-standard actions: escape, select-all, delete, duplicate, group and ungroup, undo and redo, flip, nudge, reorder, align, distribute, the pathfinder booleans, path-anchor editing, fill and stroke, clipboard, and the pointer-driven move, resize, rotate, insert, clone, area-select and lasso.
 
 ```tsx
-import { SceneCanvas } from '@weasel-js/core';
-
 <SceneCanvas
+  width={W}
+  height={H}
   scene={scene}
   selection={selection}
   actions={{
-    duplicate: null,                                // drop the default
-    'app.publish': {                                // add your own
+    duplicate: null,                  // drop the default
+    'app.publish': {                  // add your own
       id: 'app.publish',
       label: 'Publish',
       defaultBinding: { kind: 'key', key: 'p', mods: { mod: true } },
       requires: ['selection'],
-      invoker: { timing: 'immediate', run: ({ selection }) => publish(selection.get()) },
+      invoker: {
+        timing: 'immediate',
+        run: (deps) => publish((deps.selection as SelectionApi).get()),
+      },
     },
   }}
 />
@@ -95,53 +97,94 @@ import { SceneCanvas } from '@weasel-js/core';
 
 The `actions` prop takes `null` to unregister every default, or a record keyed by action id. Each value is `null` to drop that one id, a partial `Action` to merge onto the default of the same id, or a complete `Action` to register a new one.
 
-An action does its work through `invoker`, not a bare callback. `{ timing: 'immediate' }` runs once; `{ timing: 'ongoing' }` returns a handle so a drag can preview while it moves and commit at the end. The deps an invoker reads (`selection`, `scene`, `applyOps`, …) are declared in `requires` and resolved at invocation time, which is what lets a consumer swap one — see `useDepSource`.
+An action does its work through `invoker`, not a bare callback. `{ timing: 'immediate' }` runs once; `{ timing: 'ongoing' }` returns a handle so a drag can preview while it moves and commit at the end. The deps an invoker reads (`selection`, `scene`, `applyOps`, …) are declared in `requires` and resolved at invocation time, which is what lets a consumer swap one — see `useDepSource`. To fire an action yourself, wrap the canvas in your own `<ActionsProvider>` and call `trigger(id, params)` on the registry `useActionsRegistry()` returns.
+
+## Text rendering
+
+Text is rendered via MSDF atlases. Register fonts before the first paint:
+
+```tsx
+import { registerFont } from '@weasel-js/core';
+
+await registerFont('Inter', { weight: 400 }, '/fonts/Inter-400.json', '/fonts/Inter-400.png');
+```
+
+Core doesn't ship a prebuilt atlas — bake one from a weasel checkout with `npm run gen:font -- <font.ttf> --name Inter-400 --out public/fonts` (see [`packages/font/scripts/gen-font.ts`](https://github.com/orochi235/weasel/blob/main/packages/font/scripts/gen-font.ts)) and serve the resulting `.json`/`.png` pair. `@weasel-js/hud` bundles its own Inter atlas for its widgets.
+
+The glyph tier lives in `@weasel-js/font`; `registerFont` is re-exported from core, so the import above keeps working. An unregistered family renders in the default family with a one-time warning — see that package's README for `setFontFallbackPolicy`.
 
 ## Custom shaders (`@experimental`)
 
-The renderer supports `kind: 'shader'` `DrawCommand`s for layers that want a custom fragment shader. Register the program once, then emit a draw command with uniforms and bounds:
+A render layer can draw with its own fragment shader. Register the program once, then return a `kind: 'shader'` draw command with its uniforms and bounds:
 
 ```tsx
-import { registerProgram, registerTexture } from '@weasel-js/core';
-
-const voronoi = registerProgram(
-  'voronoi',
-  /* vert */ null,                            // null → use the default quad prelude
-  /* frag */ `
-    precision highp float;
-    varying vec2 v_uv;
-    uniform float u_time;
-    void main() { /* … */ }
-  `,
-);
-
-// Inside a RenderLayer.draw, return a tree of DrawCommands:
-return {
+import { registerProgram } from '@weasel-js/core/renderer';
+
+const stripes = registerProgram('stripes', '', `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform float u_time;
+out vec4 outColor;
+void main() {
+  float v = 0.5 + 0.5 * sin(v_uv.x * 40.0 + u_time);
+  outColor = vec4(vec3(v), 1.0);
+}`);
+
+// Inside a RenderLayer's draw:
+return [{
   kind: 'shader',
-  program: voronoi,
+  program: stripes,
   uniforms: { u_time: performance.now() / 1000 },
   bounds: { x: 0, y: 0, w: 256, h: 256 },
-};
+}];
 ```
 
-Uniforms support `number`, `vec2..4`, `mat3`, `mat4`, and `TextureHandle` (from `registerTexture`). The vertex prelude exposes `v_uv`, `v_screen`, and `v_world` varyings. API may change before v2.
+An empty vertex source selects the kit's vertex shader, which provides the `v_uv`, `v_screen` and `v_world` varyings and sets `u_bounds`, `u_view` and `u_proj` itself. Uniforms take a number, a 2–4 element tuple, a `Float32Array`, or a `TextureHandle` from `registerTexture`. Output **premultiplied** alpha — `vec4(rgb * a, a)` — or translucent pixels come out too bright. `bounds` is in CSS pixels.
 
 ## Subpath imports
 
-For tree-shaking and clarity, hook-specific helpers are scoped:
-
-```ts
-import { snapToGrid } from '@weasel-js/core/move';
-import { snapToGrid, clampMinSize } from '@weasel-js/core/resize';
-import { snapToGrid } from '@weasel-js/core/insert';
-```
+Core's main entry carries the everyday surface. A few narrower ones have their own:
+
+| Import | Holds |
+|---|---|
+| `@weasel-js/core/renderer` | the renderer, `registerProgram`, `registerTexture`, draw commands |
+| `@weasel-js/core/move`, `/resize`, `/insert`, `/clone`, `/clipboard` | helpers for building on those actions, e.g. `snapToGrid`, `clampMinSize` |
+| `@weasel-js/core/patterns-builtin` | the built-in fill patterns |
+| `@weasel-js/core/routing` | route grammar and introspection: parsing, the route registry, conflict checks |
+
+## Packages
+
+Every package is published under `@weasel-js` and released together at one version.
+
+| Package | What it is |
+|---|---|
+| `core` | the scene graph, `<SceneCanvas>`, actions, tools, and the WebGL2 renderer |
+| `geom` | pure 2D geometry — affine, box, curve, polyline; polygon booleans under `./booleans` |
+| `gestures` | the gesture taxonomy, route grammars and matchers; no React, no DOM |
+| `history` | undo/redo with scoped sub-histories; no React, no DOM |
+| `paint` | fills, strokes, gradients and dashes as plain data |
+| `text` | styled runs, kerned layout, wrapping and measurement |
+| `bidi` | the Unicode Bidirectional Algorithm (UAX #9) |
+| `font` | MSDF atlases, glyph metrics and runtime glyph rasterization |
+| `svg` | SVG import and export |
+| `modes` | app-level modality: capability tags, mode definitions, a mode registry |
+| `diagram` | node-link diagrams: ports on any node's perimeter, flowchart-style bodies |
+| `hud` | WebGL-rendered widgets composited into a canvas |
+| `cursor` | tool cursors as authored glyphs, baked to CSS or painted when too large |
+| `loupe` | a magnifier model: where it's aimed, how far it magnifies, what's under it |
+| `audio` | a Web Audio engine: voices, buses, lookahead scheduling, spatialization; no weasel dependencies |
+| `d3` | d3 data-join and transitions over `useScene` |
+| `theme` | design tokens as CSS variables and a parallel TypeScript export |
+| `ui` | React chrome components for weasel apps |
+| `labkit` | React widgets for self-contained interactive lab pages |
 
 ## Documentation
 
-- [Concepts](./docs/concepts.md)
-- [Hooks](./docs/hooks.md)
-- [Adapters](./docs/adapters.md)
-- [Extending](./docs/extending.md)
+- [Concepts](https://github.com/orochi235/weasel/blob/main/docs/concepts.md)
+- [Hooks](https://github.com/orochi235/weasel/blob/main/docs/hooks.md)
+- [Adapters](https://github.com/orochi235/weasel/blob/main/docs/adapters.md)
+- [Extending](https://github.com/orochi235/weasel/blob/main/docs/extending.md)
+- [Scene serialization](https://github.com/orochi235/weasel/blob/main/docs/scene-serialization.md)
 
 ## License
 

package/dist/{autoPoseDescriptor-DF1SnnSx.d.ts → autoPoseDescriptor-CvjflWJK.d.ts}

@@ -1,7 +1,6 @@
-import { c as ResizeAnchor, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, d as PointSnapFrame, M as ModifierState } from './types-ei3UMl9R.js';
-import { B as Bounds, P as PoseProjection } from './geometry-6fCNhAux.js';
-import { D as DebugSink } from './types-BHK2dkMu.js';
-import { P as Path } from './path-JEV2c5If.js';
+import { ResizeAnchor, Bounds, DebugSink, ModifierState } from '@weasel-js/routing';
+import { B as BoundsConstraint, P as PointSnapBehavior, a as PointSnapFrame } from './types-DMyo7dnM.js';
+import { P as PoseDescriptor, a as Path } from './poseDescriptor-CGOgIgf8.js';
 
 /** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
 interface CornerHandle {
@@ -72,14 +71,13 @@ declare function fixedCornerOf(bounds: Bounds, anchor: ResizeAnchor): {
  *  Consumers should import from here directly; `resize.ts` re-exports the
  *  same symbol for back-compat. */
 
-/** Options for the `resize` action: how the pose projects to and from a
- *  bounding box, and the constraints applied to that box during the drag. */
+/** Options for the `resize` action: the constraints applied to the dragged
+ *  bounding box, and how a gesture expands a group into its leaves. */
 interface UseResizeOptions<TPose> {
-    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. When
-     *  `TPose` is non-rect, pass `geometry` to project pose↔bounds; behaviors
-     *  in that case are typed `never` because none in the kit's library would
-     *  understand the pose shape. */
-    behaviors?: TPose extends ResizePose ? BoundsConstraint<TPose>[] : never;
+    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. For a
+     *  non-rect `TPose`, constraints are typed `never`; the pose descriptor
+     *  comes from `<SceneCanvas poseDescriptor>`. */
+    behaviors?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never;
     resizeLabel?: string;
     /** Reserved; resize is never transient in practice. Ignored. */
     transient?: boolean;
@@ -99,16 +97,12 @@ interface UseResizeOptions<TPose> {
      *
      *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
     expandIds?: (ids: string[]) => string[];
-    /** Projection from `TPose` to bounds and back. Defaults to rect identity
-     *  when `TPose extends ResizePose`. Required for non-rect TPose (Path,
-     *  polygon, etc.). */
-    geometry?: PoseProjection<TPose>;
     /** Behaviors that operate on world-space anchor points. Fire after
      *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
      *  with world-space frame points and returns at most one `PointSnapResult`;
      *  the hook back-solves the local pose so the chosen frame's world point
      *  lands on the snap target. First non-null result wins. */
-    pointSnapBehaviors?: TPose extends ResizePose ? PointSnapBehavior<TPose>[] : never;
+    pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
     /** Optional debug sink. When supplied, records corner-handle positions +
      *  circular hitboxes when the gesture starts (covers the on-screen
      *  handles for the resized target). Tree-shakes via optional-chain
@@ -132,7 +126,7 @@ interface UseResizeOptions<TPose> {
  *  corner, the fixed corner, or the center, per `frame` — to a grid, moving
  *  the whole pose by the same delta. Unlike the bounds-level `snapToGrid`,
  *  this preserves the node's dimensions. */
-declare function pointSnapToGrid<TPose extends ResizePose>(args: {
+declare function pointSnapToGrid<TPose extends Bounds>(args: {
     spacing: number;
     frame?: PointSnapFrame;
     bypassKey?: keyof ModifierState;
@@ -140,16 +134,25 @@ declare function pointSnapToGrid<TPose extends ResizePose>(args: {
 
 /** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
  *  callers that need to fork between `pathPoseDescriptor` and
- *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire `geometry`
- *  explicitly. */
+ *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire
+ *  `poseDescriptor` explicitly. */
 declare function isPathLike(p: unknown): p is Path;
+/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only
+ *  shape the rect descriptor and the kit's built-in painters can read. */
+declare function isRectPose(p: unknown): p is {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+};
 /** Per-call dispatch: if the pose looks like a Path, route to
  *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing
- *  demos with Path TPose to wire `geometry={pathPoseDescriptor}` explicitly.
- *  `getRotation` surfaces a `pose.rotation` field on non-Path poses so demos
- *  using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to wire
- *  `geometry={ROTATED_POSE_DESCRIPTOR}` just to get rotated selection chrome
- *  and rotation-aware corner hit-tests. */
-declare const AUTO_POSE_DESCRIPTOR: PoseProjection<unknown>;
+ *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`
+ *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses
+ *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to
+ *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated
+ *  selection chrome and rotation-aware corner hit-tests. */
+declare const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown>;
 
-export { AUTO_POSE_DESCRIPTOR as A, CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h, isPathLike as i, pointSnapToGrid as p };
+export { AUTO_POSE_DESCRIPTOR as A, CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, isRectPose as e, fixedCornerOf as f, type CornerEdge as g, hitCornerHandle as h, isPathLike as i, pointSnapToGrid as p };

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

@@ -1,4 +1,4 @@
-import { RECT_ORIGIN_PROJECTION } from './chunk-WPM42WJP.js';
+import { RECT_ORIGIN_PROJECTION } from './chunk-UCPV7JXC.js';
 import { registerOpFactory, captureSlot, slotFromIndex, resolveSlot } from './chunk-4RJP2N2L.js';
 
 // src/core/ops/transform.ts
@@ -99,24 +99,6 @@ function createReparentOp(args) {
 }
 registerOpFactory("reparent", (args) => createReparentOp(args));
 
-// src/interactions/scratchKey.ts
-function scratchKey(name) {
-  return { name };
-}
-function getScratch(store, key) {
-  return store[key.name];
-}
-function setScratch(store, key, value) {
-  store[key.name] = value;
-}
-function deleteScratch(store, key) {
-  if (Object.prototype.hasOwnProperty.call(store, key.name)) {
-    delete store[key.name];
-    return true;
-  }
-  return false;
-}
-
 // src/interactions/gestures/shared/snap.ts
 function snap(strategy, opts = {}) {
   const { bypassKey } = opts;
@@ -141,6 +123,6 @@ function snap(strategy, opts = {}) {
   };
 }
 
-export { createReparentOp, createTransformOp, deleteScratch, getScratch, scratchKey, setScratch, snap };
-//# sourceMappingURL=chunk-2VXGHUVL.js.map
-//# sourceMappingURL=chunk-2VXGHUVL.js.map
+export { createReparentOp, createTransformOp, snap };
+//# sourceMappingURL=chunk-BDWAA634.js.map
+//# sourceMappingURL=chunk-BDWAA634.js.map

package/dist/chunk-BDWAA634.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/ops/transform.ts","../src/core/ops/reparent.ts","../src/interactions/gestures/shared/snap.ts"],"names":[],"mappings":"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","file":"chunk-BDWAA634.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","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"]}