@weasel-js/core 1.6.1 → 1.7.1

package/dist/version.js

@@ -0,0 +1,6 @@
+//#region src/version.ts
+var e = "1.7.1";
+//#endregion
+export { e as VERSION };
+
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","names":["VERSION"],"sources":["../src/version.ts"],"sourcesContent":["/**\n * The kit version a build was compiled from, so an app can report what it is\n * running. Substituted at build time — by `vite.config.ts` for the published\n * package, and by `scripts/vite-build-info.ts` for anything in this repo that\n * bundles core's source through the workspace aliases.\n *\n * Apps pair this with their own compile timestamp; the kit deliberately does\n * not carry one, since a published package's build date says nothing about\n * when the app embedding it was built.\n */\n\ndeclare const __WEASEL_CORE_VERSION__: string | undefined;\n\n/**\n * Semver of `@weasel-js/core` as of the build.\n *\n * Falls back to `'0.0.0-unknown'` when core's source is imported by a bundler\n * that hasn't been given the define — honest about not knowing rather than\n * throwing, since nothing about version reporting should be able to break a\n * consumer's build.\n */\nexport const VERSION: string =\n  typeof __WEASEL_CORE_VERSION__ === 'string' ? __WEASEL_CORE_VERSION__ : '0.0.0-unknown';\n"],"mappings":";AAqBA,IAAaA,IAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -14,7 +14,12 @@
     "url": "https://github.com/orochi235/weasel/issues"
   },
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./src/import-shims/mesh.ts",
+    "./src/features/meshPaint/register.ts",
+    "./dist/mesh.js",
+    "./dist/features/meshPaint/register.js"
+  ],
   "engines": {
     "node": ">=22"
   },
@@ -36,6 +41,10 @@
       "import": "./dist/math.js",
       "types": "./dist/math.d.ts"
     },
+    "./mesh": {
+      "import": "./dist/mesh.js",
+      "types": "./dist/mesh.d.ts"
+    },
     "./move": {
       "import": "./dist/move.js",
       "types": "./dist/move.d.ts"
@@ -44,10 +53,6 @@
       "import": "./dist/resize.js",
       "types": "./dist/resize.d.ts"
     },
-    "./insert": {
-      "import": "./dist/insert.js",
-      "types": "./dist/insert.d.ts"
-    },
     "./clipboard": {
       "import": "./dist/clipboard.js",
       "types": "./dist/clipboard.d.ts"
@@ -68,25 +73,33 @@
       "import": "./dist/routing.js",
       "types": "./dist/routing.d.ts"
     },
+    "./test-seams": {
+      "import": "./dist/test-seams.js",
+      "types": "./dist/test-seams.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "vite build && tsup",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "react": ">=18",
-    "@weasel-js/font": "1.6.1"
+    "@weasel-js/font": "1.7.1",
+    "react": ">=18"
   },
   "dependencies": {
-    "@weasel-js/cursor": "1.6.1",
-    "@weasel-js/geom": "1.6.1",
-    "@weasel-js/gestures": "1.6.1",
-    "@weasel-js/history": "1.6.1",
-    "@weasel-js/paint": "1.6.1",
-    "@weasel-js/routing": "1.6.1",
-    "@weasel-js/text": "1.6.1",
-    "earcut": "2.2.4",
+    "@weasel-js/cursor": "1.7.1",
+    "@weasel-js/geom": "1.7.1",
+    "@weasel-js/gestures": "1.7.1",
+    "@weasel-js/history": "1.7.1",
+    "@weasel-js/modes": "1.7.1",
+    "@weasel-js/quantity": "1.7.1",
+    "@weasel-js/paint": "1.7.1",
+    "@weasel-js/react": "1.7.1",
+    "@weasel-js/registry": "1.7.1",
+    "@weasel-js/routing": "1.7.1",
+    "@weasel-js/text": "1.7.1",
+    "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
   "publishConfig": {
@@ -103,6 +116,6 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/modes": "1.6.1"
+    "@weasel-js/modes": "1.7.1"
   }
 }

package/dist/chunk-44EWMJV2.js

@@ -1,128 +0,0 @@
-import { RECT_ORIGIN_PROJECTION } from './chunk-HPFJUUTF.js';
-import { registerOpFactory, captureSlot, slotFromIndex, resolveSlot } from './chunk-4RJP2N2L.js';
-
-// src/core/ops/transform.ts
-function createTransformOp(args) {
-  const { id, from, to, label, coalesceKey = `transform:${id}` } = args;
-  return {
-    name: "transform",
-    args: { id, from, to, label, coalesceKey },
-    label,
-    coalesceKey,
-    apply(adapter) {
-      adapter.setPose(id, to);
-      if (poseShallowEqual(from, to)) return false;
-      return void 0;
-    },
-    invert() {
-      return createTransformOp({ id, from: to, to: from, label, coalesceKey });
-    }
-  };
-}
-registerOpFactory("transform", (args) => createTransformOp(args));
-function poseShallowEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
-  const ka = Object.keys(a);
-  const kb = Object.keys(b);
-  if (ka.length !== kb.length) return false;
-  for (const k of ka) {
-    if (a[k] !== b[k]) return false;
-  }
-  return true;
-}
-
-// src/core/ops/reparent.ts
-function placeAt(a, parentId, id, slot) {
-  if (!a.getChildren || !a.setChildOrder) return;
-  const current = a.getChildren(parentId);
-  const from = current.indexOf(id);
-  if (from < 0) return;
-  const next = current.slice();
-  next.splice(from, 1);
-  const resolved = resolveSlot(next, slot);
-  const to = resolved === void 0 ? next.length : Math.max(0, Math.min(resolved, next.length));
-  if (from === to) return;
-  next.splice(to, 0, id);
-  a.setChildOrder(parentId, next);
-}
-function optionalSlot(slot, index) {
-  if (slot) return slot;
-  return index === void 0 ? void 0 : slotFromIndex(index);
-}
-function createReparentOp(args) {
-  const {
-    id,
-    fromParentId,
-    toParentId,
-    label = "Reparent",
-    coalesceKey = `reparent:${id}`
-  } = args;
-  let fromSlot = optionalSlot(args.fromSlot, args.fromIndex);
-  const toSlot = optionalSlot(args.toSlot, args.toIndex);
-  const argsForSerial = {
-    id,
-    fromParentId,
-    toParentId,
-    fromSlot,
-    toSlot,
-    label,
-    coalesceKey
-  };
-  return {
-    name: "reparent",
-    args: argsForSerial,
-    label,
-    coalesceKey,
-    apply(adapter) {
-      const a = adapter;
-      const observed = captureSlot(a, fromParentId, id);
-      if (observed) {
-        fromSlot = observed;
-        argsForSerial.fromSlot = observed;
-      }
-      a.setParent(id, toParentId);
-      if (toSlot) placeAt(a, toParentId, id, toSlot);
-    },
-    invert() {
-      return createReparentOp({
-        id,
-        fromParentId: toParentId,
-        toParentId: fromParentId,
-        fromSlot: toSlot,
-        toSlot: fromSlot,
-        label,
-        coalesceKey
-      });
-    }
-  };
-}
-registerOpFactory("reparent", (args) => createReparentOp(args));
-
-// src/interactions/gestures/shared/snap.ts
-function snap(strategy, opts = {}) {
-  const { bypassKey } = opts;
-  const proj = opts.origin ?? RECT_ORIGIN_PROJECTION;
-  return {
-    onMove(ctx, transform) {
-      if (bypassKey && ctx.modifiers[bypassKey]) return;
-      if (transform.kind !== "translate") return;
-      const primaryId = ctx.draggedIds[0];
-      if (primaryId === void 0) return;
-      const originPose = ctx.origin.get(primaryId);
-      if (originPose === void 0) return;
-      const proposed = proj.translate(originPose, transform.dx, transform.dy);
-      const snapped = strategy.snap(proposed, ctx);
-      if (snapped === null) return;
-      const o0 = proj.getOrigin(originPose);
-      const o1 = proj.getOrigin(snapped);
-      return {
-        transform: { kind: "translate", dx: o1.x - o0.x, dy: o1.y - o0.y }
-      };
-    }
-  };
-}
-
-export { createReparentOp, createTransformOp, snap };
-//# sourceMappingURL=chunk-44EWMJV2.js.map
-//# sourceMappingURL=chunk-44EWMJV2.js.map

package/dist/chunk-44EWMJV2.js.map

@@ -1 +0,0 @@
-{"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-44EWMJV2.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"]}

package/dist/chunk-4RJP2N2L.js

@@ -1,143 +0,0 @@
-// src/core/ops/registry.ts
-var FACTORIES = /* @__PURE__ */ new Map();
-function registerOpFactory(name, build) {
-  FACTORIES.set(name, build);
-}
-function rebuildOp(name, args) {
-  const f = FACTORIES.get(name);
-  return f ? f(args) : null;
-}
-function registeredOpNames() {
-  return [...FACTORIES.keys()];
-}
-
-// src/core/ops/slot.ts
-function captureSlot(a, parentId, id) {
-  const siblings = a.getChildren?.(parentId);
-  if (!siblings) return null;
-  const i = siblings.indexOf(id);
-  if (i < 0) return null;
-  return { index: i, before: i + 1 < siblings.length ? siblings[i + 1] : null };
-}
-function resolveSlot(siblings, slot) {
-  if (slot.before === null) return void 0;
-  if (slot.before !== void 0 && siblings) {
-    const at = siblings.indexOf(slot.before);
-    if (at >= 0) return at;
-  }
-  return slot.index >= 0 ? slot.index : void 0;
-}
-function slotFromIndex(index) {
-  return { index: index ?? -1 };
-}
-function parentOf(node) {
-  return node.parent ?? null;
-}
-
-// src/core/ops/create.ts
-function createInsertOp(args) {
-  const { node, label } = args;
-  const slot = args.slot ?? slotFromIndex(args.index);
-  return {
-    name: "insert",
-    args: { node, label, slot },
-    label,
-    apply(adapter) {
-      const a = adapter;
-      const parentId = parentOf(node);
-      a.insertNode(node, resolveSlot(a.getChildren?.(parentId), slot));
-    },
-    invert() {
-      return createDeleteOp({ node, label, slot });
-    }
-  };
-}
-registerOpFactory("insert", (args) => createInsertOp(args));
-
-// src/core/ops/delete.ts
-function indexIn(a, parentId, id) {
-  return a.getChildren?.(parentId)?.indexOf(id) ?? -1;
-}
-function captureCascade(a, rootId) {
-  const { getChildren, getNode } = a;
-  if (!getChildren || !getNode) return null;
-  const closure = a.getRemovalClosure?.([rootId]);
-  const taken = /* @__PURE__ */ new Map();
-  if (closure) {
-    for (const id of closure) {
-      const node = getNode.call(a, id);
-      if (node) taken.set(id, node);
-    }
-  } else {
-    const walk = (id) => {
-      const node = getNode.call(a, id);
-      if (!node) return;
-      taken.set(id, node);
-      for (const kid of getChildren.call(a, id)) walk(kid);
-    };
-    walk(rootId);
-  }
-  const detachRoots = [...taken.values()].filter((n) => {
-    const p = parentOf(n);
-    return p === null || !taken.has(p);
-  }).map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) })).sort((l, r) => l.index - r.index);
-  const out = [];
-  const emitSubtree = (entry) => {
-    out.push(entry);
-    const kids = getChildren.call(a, entry.node.id);
-    for (let i = 0; i < kids.length; i++) {
-      const child = taken.get(kids[i]);
-      if (child) emitSubtree({ node: child, index: i });
-    }
-  };
-  for (const entry of detachRoots) emitSubtree(entry);
-  return out;
-}
-function createDeleteOp(args) {
-  const { node, label } = args;
-  let slot = args.slot ?? slotFromIndex(args.index);
-  const argsForSerial = { node, label, slot, cascaded: args.cascaded };
-  let captured = args.cascaded ?? [];
-  return {
-    name: "delete",
-    args: argsForSerial,
-    label,
-    apply(adapter) {
-      const a = adapter;
-      const observed = captureSlot(a, parentOf(node), node.id);
-      if (observed) {
-        slot = observed;
-        argsForSerial.slot = observed;
-      }
-      const snapshot = captureCascade(a, node.id);
-      if (snapshot) {
-        captured = snapshot;
-        argsForSerial.cascaded = snapshot;
-      }
-      a.removeNode(node.id);
-    },
-    invert() {
-      const cascaded = captured;
-      const restoredSlot = slot;
-      const reinsertRoot = createInsertOp({ node, label, slot: restoredSlot });
-      if (cascaded.length === 0) return reinsertRoot;
-      return {
-        label,
-        apply(adapter) {
-          const a = adapter;
-          for (const entry of cascaded) {
-            if (a.getNode?.(entry.node.id)) continue;
-            if (entry.node.id === node.id) reinsertRoot.apply(adapter);
-            else a.insertNode(entry.node, entry.index);
-          }
-        },
-        invert: () => createDeleteOp({ node, label, slot: restoredSlot, cascaded })
-      };
-    }
-  };
-}
-registerOpFactory("delete", (args) => createDeleteOp(args));
-
-export { captureSlot, createDeleteOp, createInsertOp, rebuildOp, registerOpFactory, registeredOpNames, resolveSlot, slotFromIndex };
-//# sourceMappingURL=chunk-4RJP2N2L.js.map
-//# sourceMappingURL=chunk-4RJP2N2L.js.map

package/dist/chunk-4RJP2N2L.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/ops/registry.ts","../src/core/ops/slot.ts","../src/core/ops/create.ts","../src/core/ops/delete.ts"],"names":[],"mappings":"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","file":"chunk-4RJP2N2L.js","sourcesContent":["// Op-factory registry — pairs a stable `name` (stamped onto each op by its\n// factory) with a `(args) => Op` rebuilder so a `{ name, args }` snapshot\n// can be reconstituted into a live `Op` whose `apply`/`invert` closures\n// behave identically to the original.\n//\n// The kit calls `registerOpFactory` at module-init time for every built-in\n// factory (see `./create.ts`, `./delete.ts`, `./transform.ts`, etc.).\n// Consumers wanting their custom ops to survive `History.serialize()` /\n// `History.restore()` register their factories at app bootstrap, before\n// `createHistory` is called.\n\nimport type { Op } from './types';\n\ntype Builder = (args: unknown) => Op;\n\nconst FACTORIES = new Map<string, Builder>();\n\n/** Register an op-factory builder under a stable name. The builder receives\n *  the serialized `args` and must return an `Op` equivalent to one freshly\n *  constructed at the original call site (`apply` and `invert` behave the\n *  same). Idempotent on the same `(name, build)` pair; a second registration\n *  with a different builder silently overwrites — kit modules import each\n *  factory exactly once at init, so this never races in practice. */\nexport function registerOpFactory<A>(name: string, build: (args: A) => Op): void {\n  FACTORIES.set(name, build as Builder);\n}\n\n/** Rebuild an op from its serialized `(name, args)`. Returns `null` when\n *  `name` isn't registered — callers handle this (typically by substituting\n *  a no-op placeholder so stack ordering survives across kit version skew). */\nexport function rebuildOp(name: string, args: unknown): Op | null {\n  const f = FACTORIES.get(name);\n  return f ? f(args) : null;\n}\n\n/** Test-only: drop all registrations. Not exported from the kit barrel — the\n *  built-in factories self-register at module init, so production code never\n *  needs to clear the table. Exposed for unit tests that want to assert the\n *  unknown-name fallback path. */\nexport function _clearOpFactoriesForTest(): void {\n  FACTORIES.clear();\n}\n\n/** Every op name currently registered, in registration order. The kit's\n *  built-ins self-register at module init, so importing the barrel is enough\n *  to see all of them; consumer factories appear once their module has run. */\nexport function registeredOpNames(): readonly string[] {\n  return [...FACTORIES.keys()];\n}\n","/**\n * A node's position among its siblings, recorded so an op can put it back.\n *\n * Recorded as an anchor (`before`) plus an ordinal (`index`). The anchor is\n * the source of truth: `History` replays a batch's inverses in reverse order,\n * so an ordinal captured before the mutation is replayed against a list that\n * has not been refilled yet and clamps to the end, while \"put this back before\n * `e`\" stays true however much else has already moved. The ordinal is the\n * fallback for the cases the anchor cannot cover — an adapter with no\n * `getChildren` seam, or an anchor that is itself gone by replay time.\n */\n\n/** Sibling-order read seam. Optional everywhere: a flat adapter has none. */\nexport interface OrderedReader {\n  getChildren?(parentId: string | null): string[];\n}\n\nexport interface Slot {\n  /** Ordinal among the siblings. `-1` means \"nowhere in particular\". */\n  index: number;\n  /** Id of the sibling that followed at capture time; `null` when the node\n   *  was last. Absent when nothing observed it — `null` survives JSON and\n   *  `undefined` does not, so the two stay distinguishable across a\n   *  serialize/restore round trip. */\n  before?: string | null;\n}\n\n/** Observe `id`'s slot among `parentId`'s children. `null` when the adapter\n *  has no ordering seam or `id` isn't there — callers keep whatever weaker\n *  slot they already had rather than overwriting it with a guess. */\nexport function captureSlot(\n  a: OrderedReader,\n  parentId: string | null,\n  id: string,\n): Slot | null {\n  const siblings = a.getChildren?.(parentId);\n  if (!siblings) return null;\n  const i = siblings.indexOf(id);\n  if (i < 0) return null;\n  return { index: i, before: i + 1 < siblings.length ? siblings[i + 1]! : null };\n}\n\n/**\n * Index `slot` denotes in `siblings`, which must NOT contain the node being\n * placed. `undefined` means \"no position\" — the caller appends, or lets the\n * adapter's default placement stand.\n */\nexport function resolveSlot(\n  siblings: readonly string[] | undefined,\n  slot: Slot,\n): number | undefined {\n  if (slot.before === null) return undefined;\n  if (slot.before !== undefined && siblings) {\n    const at = siblings.indexOf(slot.before);\n    if (at >= 0) return at;\n  }\n  return slot.index >= 0 ? slot.index : undefined;\n}\n\n/** Normalize the `index` sugar every op factory accepts into a `Slot`. */\nexport function slotFromIndex(index: number | undefined): Slot {\n  return { index: index ?? -1 };\n}\n\n/** The parent a node claims. Nodes in a flat adapter have none. */\nexport function parentOf(node: object): string | null {\n  return ((node as { parent?: unknown }).parent ?? null) as string | null;\n}\n","import type { Op } from './types';\nimport { createDeleteOp } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type Slot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  /** When `index` is supplied, insert at that position; adapters that ignore\n   *  the second arg (or don't expose it) fall back to their default\n   *  placement (typically append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** @internal */\ninterface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: Slot;\n}\n\n/** Op: insert `node` into the scene; inverts to a delete of the same id. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label } = args;\n  const slot: Slot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const parentId = parentOf(node);\n      a.insertNode(node, resolveSlot(a.getChildren?.(parentId), slot));\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n","import type { Op } from './types';\nimport { createInsertOp } from './create';\nimport { registerOpFactory } from './registry';\nimport { captureSlot, parentOf, slotFromIndex, type OrderedReader, type Slot } from './slot';\n\ninterface DeleteAdapter<TNode> extends OrderedReader {\n  removeNode(id: string): void;\n  /** Subtree reads, used to snapshot the cascade before it runs. Optional\n   *  — a flat adapter has neither, and a delete there is a single node. */\n  getNode?(id: string): TNode | undefined;\n  /** Every id `removeNode` would take with this one. Optional: a store whose\n   *  removal cascades along nothing but the subtree needs no such answer, and\n   *  `getChildren` is enough. A store that cascades further — the kit's scene\n   *  takes a deleted node's dependents too — must answer here, or the nodes it\n   *  cascades away are absent from the snapshot and undo brings back the named\n   *  node alone. */\n  getRemovalClosure?(ids: readonly string[]): readonly string[];\n}\n\ninterface InsertAdapter<TNode> {\n  insertNode(node: TNode, index?: number): void;\n  getNode?(id: string): TNode | undefined;\n}\n\n/** A captured node plus its slot in its own parent's child list. */\ninterface Placed<TNode> {\n  node: TNode;\n  index: number;\n}\n\n/** @internal */\ninterface DeleteArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal the node occupies at the moment of delete. Sugar for\n   *  `slot: { index }`, and only a seed: `apply` re-observes the node's full\n   *  slot through the adapter and that observation supersedes this. Kept\n   *  because it is the whole story for a flat adapter with no `getChildren`,\n   *  where nothing can be observed. */\n  index?: number;\n  /** Full slot, anchor included. Written by `apply`; supersedes `index`. */\n  slot?: Slot;\n  /** Everything `removeNode` takes, `node` itself included — its subtree, and\n   *  whatever else the adapter cascades. An inverse that re-inserts `node`\n   *  alone brings a container back empty and leaves every dependent deleted.\n   *  Ordered so a node's parent precedes it, which is the order they have to\n   *  be re-inserted in. Captured on apply; mirrored into the serialized args so\n   *  a rebuilt op can invert without having run. */\n  cascaded?: Placed<TNode>[];\n}\n\n/** `id`'s ordinal among `parentId`'s children, or `-1` when unobservable. */\nfunction indexIn(a: OrderedReader, parentId: string | null, id: string): number {\n  return a.getChildren?.(parentId)?.indexOf(id) ?? -1;\n}\n\n/**\n * Snapshot everything removing `rootId` takes with it, `rootId` included.\n *\n * Returns `null` when the adapter can't enumerate, which leaves any previously\n * captured snapshot in place rather than clobbering it with an empty one.\n *\n * The order is the whole point. A cascade unlinks several disjoint subtrees, so\n * the captured set is walked as a forest: a node whose parent is not also going\n * is a detach root, and each one is emitted — ascending sibling index first, so\n * every slot still means what it meant — followed by its captured descendants\n * preorder. The closure's own order will not do: it reaches a dependent before\n * the parent it sits under whenever that parent is in the closure as a\n * dependent too, and re-inserting a child under a parent that is not back yet\n * puts it in the wrong place.\n */\nfunction captureCascade<TNode extends { id: string }>(\n  a: DeleteAdapter<TNode>,\n  rootId: string,\n): Placed<TNode>[] | null {\n  const { getChildren, getNode } = a;\n  if (!getChildren || !getNode) return null;\n\n  const closure = a.getRemovalClosure?.([rootId]);\n  const taken = new Map<string, TNode>();\n  if (closure) {\n    for (const id of closure) {\n      const node = getNode.call(a, id);\n      if (node) taken.set(id, node);\n    }\n  } else {\n    // No closure read: the cascade is the subtree, discovered here.\n    const walk = (id: string): void => {\n      const node = getNode.call(a, id);\n      if (!node) return;\n      taken.set(id, node);\n      for (const kid of getChildren.call(a, id)) walk(kid);\n    };\n    walk(rootId);\n  }\n\n  const detachRoots = [...taken.values()]\n    .filter((n) => { const p = parentOf(n); return p === null || !taken.has(p); })\n    .map((n) => ({ node: n, index: indexIn(a, parentOf(n), n.id) }))\n    .sort((l, r) => l.index - r.index);\n\n  const out: Placed<TNode>[] = [];\n  const emitSubtree = (entry: Placed<TNode>): void => {\n    out.push(entry);\n    const kids = getChildren.call(a, entry.node.id);\n    for (let i = 0; i < kids.length; i++) {\n      const child = taken.get(kids[i]!);\n      if (child) emitSubtree({ node: child, index: i });\n    }\n  };\n  for (const entry of detachRoots) emitSubtree(entry);\n  return out;\n}\n\n/** Op: remove `node` and everything the adapter cascades with it; inverts to a\n *  re-insert of the whole set at its captured slots. */\nexport function createDeleteOp<TNode extends { id: string }>(args: DeleteArgs<TNode>): Op {\n  const { node, label } = args;\n  let slot: Slot = args.slot ?? slotFromIndex(args.index);\n  const argsForSerial: DeleteArgs<TNode> = { node, label, slot, cascaded: args.cascaded };\n  let captured: Placed<TNode>[] = args.cascaded ?? [];\n  return {\n    name: 'delete',\n    args: argsForSerial,\n    label,\n    apply(adapter) {\n      const a = adapter as DeleteAdapter<TNode>;\n      const observed = captureSlot(a, parentOf(node), node.id);\n      if (observed) {\n        slot = observed;\n        argsForSerial.slot = observed;\n      }\n      const snapshot = captureCascade(a, node.id);\n      if (snapshot) {\n        captured = snapshot;\n        argsForSerial.cascaded = snapshot;\n      }\n      a.removeNode(node.id);\n    },\n    invert() {\n      const cascaded = captured;\n      const restoredSlot = slot;\n      // The root's own placement keeps the anchor-bearing slot; the rest have\n      // only an ordinal, which is all `getChildren` can observe of them.\n      const reinsertRoot = createInsertOp<TNode>({ node, label, slot: restoredSlot });\n      if (cascaded.length === 0) return reinsertRoot;\n      return {\n        label,\n        apply(adapter) {\n          const a = adapter as InsertAdapter<TNode>;\n          for (const entry of cascaded) {\n            // A flat adapter's removeNode doesn't cascade, so its children\n            // were never gone — re-inserting them would duplicate them.\n            if (a.getNode?.(entry.node.id)) continue;\n            if (entry.node.id === node.id) reinsertRoot.apply(adapter);\n            else a.insertNode(entry.node, entry.index);\n          }\n        },\n        invert: () =>\n          createDeleteOp<TNode>({ node, label, slot: restoredSlot, cascaded }),\n      };\n    },\n  };\n}\n\nregisterOpFactory<DeleteArgs<{ id: string }>>('delete', (args) => createDeleteOp(args));\n"]}

package/dist/chunk-BJN5ZRIJ.js

@@ -1,167 +0,0 @@
-// src/renderer/textures/registerTexture.ts
-var counter = 0;
-var registry = /* @__PURE__ */ new Map();
-function getTexture(id) {
-  return registry.get(id) ?? null;
-}
-function registerTexture(image) {
-  const id = `tex_${++counter}`;
-  registry.set(id, { source: image });
-  return { id };
-}
-
-// src/features/patterns/tileGeometry.ts
-function tileSize(spec) {
-  if (spec.size !== void 0) return spec.size;
-  switch (spec.tile) {
-    case "hatch":
-      return 5;
-    case "crosshatch":
-      return 6;
-    case "dots":
-      return 6;
-    case "chunks":
-      return 48;
-    default:
-      return 8;
-  }
-}
-function mulberry32(seed) {
-  let s = seed | 0;
-  return () => {
-    s = s + 1831565813 | 0;
-    let t = Math.imul(s ^ s >>> 15, 1 | s);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-function tileGeometry(spec) {
-  const s = tileSize(spec);
-  const { color } = spec;
-  switch (spec.tile) {
-    case "hatch": {
-      const width = spec.lineWidth ?? 1;
-      return { size: s, shapes: forwardDiagonals(s, width, color) };
-    }
-    case "crosshatch": {
-      const width = spec.lineWidth ?? 0.8;
-      return {
-        size: s,
-        shapes: [...forwardDiagonals(s, width, color), ...backwardDiagonals(s, width, color)]
-      };
-    }
-    case "dots": {
-      const r = spec.radius ?? 1;
-      return { size: s, shapes: [{ kind: "circle", cx: s / 2, cy: s / 2, r, color }] };
-    }
-    case "chunks": {
-      const density = spec.density ?? 0.35;
-      const chunkSize = spec.chunkSize ?? 3;
-      const rand = mulberry32(spec.seed ?? 42);
-      const count = Math.round(s * s * density / (chunkSize * chunkSize));
-      const shapes = [];
-      if (spec.bg !== void 0) {
-        shapes.push({ kind: "rect", x: 0, y: 0, width: s, height: s, color: spec.bg });
-      }
-      for (let i = 0; i < count; i++) {
-        const cx = rand() * s;
-        const cy = rand() * s;
-        const w = chunkSize * (0.5 + rand());
-        const h = chunkSize * (0.5 + rand());
-        const rotation = rand() * Math.PI;
-        shapes.push({ kind: "ellipse", cx, cy, rx: w / 2, ry: h / 2, rotation, color });
-      }
-      return { size: s, shapes };
-    }
-    default:
-      return { size: s, shapes: [] };
-  }
-}
-function forwardDiagonals(s, width, color) {
-  return [
-    { kind: "line", x1: -1, y1: s + 1, x2: s + 1, y2: -1, width, color },
-    { kind: "line", x1: -1, y1: 1, x2: 1, y2: -1, width, color },
-    { kind: "line", x1: s - 1, y1: s + 1, x2: s + 1, y2: s - 1, width, color }
-  ];
-}
-function backwardDiagonals(s, width, color) {
-  return [
-    { kind: "line", x1: -1, y1: -1, x2: s + 1, y2: s + 1, width, color },
-    { kind: "line", x1: s - 1, y1: -1, x2: s + 1, y2: 1, width, color },
-    { kind: "line", x1: -1, y1: s - 1, x2: 1, y2: s + 1, width, color }
-  ];
-}
-function drawTileShapes(oc, geometry) {
-  for (const shape of geometry.shapes) {
-    if (shape.kind === "line") {
-      oc.strokeStyle = shape.color;
-      oc.lineWidth = shape.width;
-      oc.beginPath();
-      oc.moveTo(shape.x1, shape.y1);
-      oc.lineTo(shape.x2, shape.y2);
-      oc.stroke();
-      continue;
-    }
-    oc.fillStyle = shape.color;
-    if (shape.kind === "rect") {
-      oc.fillRect(shape.x, shape.y, shape.width, shape.height);
-      continue;
-    }
-    oc.beginPath();
-    if (shape.kind === "circle") {
-      oc.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);
-    } else {
-      oc.ellipse(shape.cx, shape.cy, shape.rx, shape.ry, shape.rotation, 0, Math.PI * 2);
-    }
-    oc.fill();
-  }
-}
-
-// src/features/patterns/index.ts
-function createTilePattern(opts) {
-  let off;
-  try {
-    off = new OffscreenCanvas(opts.size, opts.size);
-  } catch {
-    if (typeof document === "undefined") return null;
-    const c = document.createElement("canvas");
-    c.width = opts.size;
-    c.height = opts.size;
-    off = c;
-  }
-  const oc = off.getContext("2d");
-  if (!oc) return null;
-  opts.draw(oc, opts.size);
-  let bitmap;
-  if (typeof off.transferToImageBitmap === "function") {
-    bitmap = off.transferToImageBitmap();
-  } else {
-    return null;
-  }
-  return registerTexture(bitmap);
-}
-
-// src/features/patterns/patterns-builtin.ts
-function build(spec) {
-  const geometry = tileGeometry(spec);
-  return createTilePattern({
-    size: tileSize(spec),
-    draw: (oc) => drawTileShapes(oc, geometry)
-  });
-}
-function hatch(params) {
-  return build({ tile: "hatch", ...params });
-}
-function crosshatch(params) {
-  return build({ tile: "crosshatch", ...params });
-}
-function dots(params) {
-  return build({ tile: "dots", ...params });
-}
-function chunks(params) {
-  return build({ tile: "chunks", ...params });
-}
-
-export { chunks, createTilePattern, crosshatch, dots, drawTileShapes, getTexture, hatch, registerTexture, tileGeometry, tileSize };
-//# sourceMappingURL=chunk-BJN5ZRIJ.js.map
-//# sourceMappingURL=chunk-BJN5ZRIJ.js.map