@weasel-js/core 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -75,18 +75,21 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "react": ">=18",
-    "@weasel-js/font": "1.6.0"
+    "@weasel-js/font": "1.7.0",
+    "react": ">=18"
   },
   "dependencies": {
-    "@weasel-js/cursor": "1.6.0",
-    "@weasel-js/geom": "1.6.0",
-    "@weasel-js/gestures": "1.6.0",
-    "@weasel-js/history": "1.6.0",
-    "@weasel-js/paint": "1.6.0",
-    "@weasel-js/routing": "1.6.0",
-    "@weasel-js/text": "1.6.0",
-    "earcut": "2.2.4",
+    "@weasel-js/cursor": "1.7.0",
+    "@weasel-js/geom": "1.7.0",
+    "@weasel-js/gestures": "1.7.0",
+    "@weasel-js/history": "1.7.0",
+    "@weasel-js/modes": "1.7.0",
+    "@weasel-js/quantity": "1.7.0",
+    "@weasel-js/paint": "1.7.0",
+    "@weasel-js/registry": "1.7.0",
+    "@weasel-js/routing": "1.7.0",
+    "@weasel-js/text": "1.7.0",
+    "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
   "publishConfig": {
@@ -103,6 +106,6 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/modes": "1.6.0"
+    "@weasel-js/modes": "1.7.0"
   }
 }

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.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/renderer/textures/registerTexture.ts","../src/features/patterns/tileGeometry.ts","../src/features/patterns/index.ts","../src/features/patterns/patterns-builtin.ts"],"names":[],"mappings":"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","file":"chunk-BJN5ZRIJ.js","sourcesContent":["/**\n * registerTexture — accepts an image source, assigns an opaque id, stores in\n * a module-level registry. Actual GL upload happens lazily at draw time in\n * drawShader() via GLTextureCache.upload (which is idempotent).\n *\n * Lifecycle: textures live for the renderer's lifetime. No unregister in v1.\n *\n * Convention §9: this registry stores image data only — no per-renderer state.\n * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).\n */\n\nimport type { TextureHandle } from '@weasel-js/paint';\n\nexport type { TextureHandle };\n\nexport interface TextureEntry {\n  source: HTMLImageElement | ImageBitmap;\n}\n\nlet counter = 0;\nlet registry = new Map<string, TextureEntry>();\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetTextureRegistryForTests(): void {\n  registry = new Map();\n  counter = 0;\n}\n\nexport function getTexture(id: string): TextureEntry | null {\n  return registry.get(id) ?? null;\n}\n\n/**\n * Register an image for use as a shader texture uniform.\n *\n * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.\n * The handle is valid for the lifetime of the renderer it will be used with.\n *\n * @param image  The image to register. HTMLImageElement must be fully loaded.\n * @returns      Opaque TextureHandle.\n */\nexport function registerTexture(\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  const id = `tex_${++counter}`;\n  registry.set(id, { source: image });\n  return { id };\n}\n","/**\n * The shapes a built-in tile is made of, as data.\n *\n * One description, two renderers: `patterns-builtin` strokes/fills these to\n * an `OffscreenCanvas` to build the GL texture, and `@weasel-js/svg` maps\n * them to `<pattern>` children. Duplicating the tile drawing in the\n * serializer would let the raster and vector forms drift apart silently.\n */\n\nimport type { TilePatternSpec } from '@weasel-js/paint';\n\n/** One primitive within a pattern tile, in tile-local coordinates. */\nexport type TileShape =\n  | { kind: 'line'; x1: number; y1: number; x2: number; y2: number; width: number; color: string }\n  | { kind: 'circle'; cx: number; cy: number; r: number; color: string }\n  | { kind: 'ellipse'; cx: number; cy: number; rx: number; ry: number; rotation: number; color: string }\n  | { kind: 'rect'; x: number; y: number; width: number; height: number; color: string };\n\n/** A built-in tile's shapes plus the edge length they're drawn within. */\nexport interface TileGeometry {\n  size: number;\n  shapes: TileShape[];\n}\n\n/** Defaults per tile kind, matching each factory's signature. */\nexport function tileSize(spec: TilePatternSpec): number {\n  if (spec.size !== undefined) return spec.size;\n  switch (spec.tile) {\n    case 'hatch': return 5;\n    case 'crosshatch': return 6;\n    case 'dots': return 6;\n    case 'chunks': return 48;\n    default: return 8;\n  }\n}\n\n/** Seeded PRNG (mulberry32) — `chunks` places its scatter with this, so the\n *  same `seed` yields the same tile in both the raster and vector paths. */\nfunction mulberry32(seed: number): () => number {\n  let s = seed | 0;\n  return () => {\n    s = (s + 0x6D2B79F5) | 0;\n    let t = Math.imul(s ^ (s >>> 15), 1 | s);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n/** Resolve a pattern spec to the shapes that make up one tile. Consumers that\n *  want to draw a pattern swatch themselves — a picker, an SVG export — read\n *  this rather than rasterizing a texture. */\nexport function tileGeometry(spec: TilePatternSpec): TileGeometry {\n  const s = tileSize(spec);\n  const { color } = spec;\n\n  switch (spec.tile) {\n    case 'hatch': {\n      const width = spec.lineWidth ?? 1;\n      return { size: s, shapes: forwardDiagonals(s, width, color) };\n    }\n    case 'crosshatch': {\n      const width = spec.lineWidth ?? 0.8;\n      return {\n        size: s,\n        shapes: [...forwardDiagonals(s, width, color), ...backwardDiagonals(s, width, color)],\n      };\n    }\n    case 'dots': {\n      const r = spec.radius ?? 1;\n      return { size: s, shapes: [{ kind: 'circle', cx: s / 2, cy: s / 2, r, color }] };\n    }\n    case 'chunks': {\n      const density = spec.density ?? 0.35;\n      const chunkSize = spec.chunkSize ?? 3;\n      const rand = mulberry32(spec.seed ?? 42);\n      const count = Math.round((s * s * density) / (chunkSize * chunkSize));\n      const shapes: TileShape[] = [];\n      if (spec.bg !== undefined) {\n        shapes.push({ kind: 'rect', x: 0, y: 0, width: s, height: s, color: spec.bg });\n      }\n      for (let i = 0; i < count; i++) {\n        const cx = rand() * s;\n        const cy = rand() * s;\n        const w = chunkSize * (0.5 + rand());\n        const h = chunkSize * (0.5 + rand());\n        const rotation = rand() * Math.PI;\n        shapes.push({ kind: 'ellipse', cx, cy, rx: w / 2, ry: h / 2, rotation, color });\n      }\n      return { size: s, shapes };\n    }\n    default:\n      return { size: s, shapes: [] };\n  }\n}\n\n/** The forward (`/`) diagonal, plus the two corner stubs that make it tile\n *  seamlessly across the edges. */\nfunction forwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: s + 1, x2: s + 1, y2: -1, width, color },\n    { kind: 'line', x1: -1, y1: 1, x2: 1, y2: -1, width, color },\n    { kind: 'line', x1: s - 1, y1: s + 1, x2: s + 1, y2: s - 1, width, color },\n  ];\n}\n\n/** The backward (`\\`) diagonal and its two stubs. */\nfunction backwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: -1, x2: s + 1, y2: s + 1, width, color },\n    { kind: 'line', x1: s - 1, y1: -1, x2: s + 1, y2: 1, width, color },\n    { kind: 'line', x1: -1, y1: s - 1, x2: 1, y2: s + 1, width, color },\n  ];\n}\n\n/** Draw a tile's shapes to a 2D context — the raster half of the pair. */\nexport function drawTileShapes(oc: CanvasRenderingContext2D, geometry: TileGeometry): void {\n  for (const shape of geometry.shapes) {\n    if (shape.kind === 'line') {\n      oc.strokeStyle = shape.color;\n      oc.lineWidth = shape.width;\n      oc.beginPath();\n      oc.moveTo(shape.x1, shape.y1);\n      oc.lineTo(shape.x2, shape.y2);\n      oc.stroke();\n      continue;\n    }\n    oc.fillStyle = shape.color;\n    if (shape.kind === 'rect') {\n      oc.fillRect(shape.x, shape.y, shape.width, shape.height);\n      continue;\n    }\n    oc.beginPath();\n    if (shape.kind === 'circle') {\n      oc.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);\n    } else {\n      oc.ellipse(shape.cx, shape.cy, shape.rx, shape.ry, shape.rotation, 0, Math.PI * 2);\n    }\n    oc.fill();\n  }\n}\n","/**\n * Tile-pattern primitive — a small helper for building repeating texture\n * tiles from a draw callback. The result plugs into a `FillStyle` of\n * `{ fill: 'pattern', pattern }` (see `@weasel-js/paint`).\n *\n * GL-backed: the tile is rendered to an `OffscreenCanvas` (with a 2D fallback\n * to a regular `<canvas>` for environments without `OffscreenCanvas`),\n * converted to an `ImageBitmap`, and registered with `registerTexture()`.\n * The returned `TextureHandle` is what `FillStyle.pattern` accepts.\n *\n * For ready-to-use named patterns (hatch, crosshatch, dots, chunks),\n * see the `@weasel-js/core/patterns-builtin` subpath.\n */\n\nimport { registerTexture } from '../../renderer/textures/registerTexture';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\n\n/** Options for `createTilePattern`. */\nexport interface TilePatternOpts {\n  /** Edge length (in pixels) of the square offscreen tile. */\n  size: number;\n  /** FillStyle one tile at integer-pixel coordinates `(0, 0) .. (size, size)`. */\n  draw: (oc: CanvasRenderingContext2D, size: number) => void;\n}\n\n/**\n * Render a single tile to an offscreen canvas and register it as a GL\n * texture, returning a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }`. Returns `null` only when an\n * `OffscreenCanvas`/2D context can't be acquired (very rare; same fallback\n * semantics as the prior `CanvasPattern`-based implementation).\n */\nexport function createTilePattern(opts: TilePatternOpts): TextureHandle | null {\n  // Prefer OffscreenCanvas; fall back to <canvas> for environments without it\n  // (tests in jsdom may need that fallback — try OffscreenCanvas first).\n  let off: OffscreenCanvas | HTMLCanvasElement;\n  try {\n    off = new OffscreenCanvas(opts.size, opts.size);\n  } catch {\n    if (typeof document === 'undefined') return null;\n    const c = document.createElement('canvas');\n    c.width = opts.size;\n    c.height = opts.size;\n    off = c;\n  }\n  const oc = off.getContext('2d') as CanvasRenderingContext2D | null;\n  if (!oc) return null;\n  opts.draw(oc, opts.size);\n\n  // Convert to ImageBitmap so registerTexture can store it.\n  // OffscreenCanvas.transferToImageBitmap() is the fast path; the\n  // synchronous path requires OffscreenCanvas. If we got here without it,\n  // the env doesn't support OffscreenCanvas — fail gracefully.\n  let bitmap: ImageBitmap;\n  if (typeof (off as OffscreenCanvas).transferToImageBitmap === 'function') {\n    bitmap = (off as OffscreenCanvas).transferToImageBitmap();\n  } else {\n    return null;\n  }\n  return registerTexture(bitmap);\n}\n","/**\n * Built-in pattern factories — generic line/dot/scatter textures. Each\n * returns a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }` and pass to anything that accepts a `FillStyle`\n * (`FillStyle`-aware layers, path fills, etc.).\n * Imported from a subpath so consumers that ship their own catalog can\n * avoid the bundle cost.\n *\n * All factories require an explicit `color` (and `bg` for `chunks`). No\n * defaults are baked in — the caller's design system is the source of truth\n * for palette decisions.\n *\n * Each is a thin wrapper over `tileGeometry`, which describes the tile as\n * shapes so `@weasel-js/svg` can emit the same tile as a `<pattern>`.\n * Prefer naming a tile in a `TilePatternSpec` over calling these directly —\n * a spec serializes, a `TextureHandle` does not.\n */\n\nexport { tileGeometry, tileSize, drawTileShapes } from './tileGeometry';\nexport type { TileShape, TileGeometry } from './tileGeometry';\n\nimport { createTilePattern } from '.';\nimport { tileGeometry, drawTileShapes, tileSize } from './tileGeometry';\nimport type { TilePatternSpec } from '@weasel-js/paint';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\n\nfunction build(spec: TilePatternSpec): TextureHandle | null {\n  const geometry = tileGeometry(spec);\n  return createTilePattern({\n    size: tileSize(spec),\n    draw: (oc) => drawTileShapes(oc, geometry),\n  });\n}\n\n/** Diagonal hatch (forward slash). */\nexport interface HatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a diagonal-hatch pattern texture. */\nexport function hatch(params: HatchParams): TextureHandle | null {\n  return build({ tile: 'hatch', ...params });\n}\n\n/** Diagonal hatch in both directions. */\nexport interface CrosshatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a crosshatch pattern texture. */\nexport function crosshatch(params: CrosshatchParams): TextureHandle | null {\n  return build({ tile: 'crosshatch', ...params });\n}\n\n/** Regular grid of filled dots. */\nexport interface DotsParams {\n  color: string;\n  size?: number;\n  radius?: number;\n}\n\n/** Build a dot-grid pattern texture. */\nexport function dots(params: DotsParams): TextureHandle | null {\n  return build({ tile: 'dots', ...params });\n}\n\n/**\n * Random scatter of small ellipses on top of a solid background. Driven by a\n * seeded PRNG so the same `seed` produces a deterministic tile.\n *\n * Note: the `bg` field is optional — omit it for a transparent background\n * (the scatter shapes draw directly onto whatever sits beneath the overlay).\n */\nexport interface ChunksParams {\n  color: string;\n  bg?: string;\n  size?: number;\n  /** Coverage: `chunks * chunkSize²` per `size²` tile. Range ~[0, 1]. */\n  density?: number;\n  chunkSize?: number;\n  seed?: number;\n}\n\n/** Build a seeded random-scatter pattern texture. */\nexport function chunks(params: ChunksParams): TextureHandle | null {\n  return build({ tile: 'chunks', ...params });\n}\n"]}

package/dist/chunk-HPFJUUTF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/units.ts","../src/interactions/gestures/shared/strategies/grid.ts","../src/core/viewport/pxExtent.ts","../src/interactions/gestures/shared/strategies/guides.ts"],"names":[],"mappings":"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","file":"chunk-HPFJUUTF.js","sourcesContent":["/**\n * Units — a tiny customizable unit system for canvas-kit APIs.\n *\n * The kit stores all coordinates as bare numbers in a single base unit\n * chosen by the consumer app. To make API call sites self-documenting,\n * the public surface accepts `UnitValue` — either a bare number (interpreted\n * as base units) or a `{ value, unit }` tag that's resolved against a\n * `UnitSystem` at the API boundary. Internals never see units.\n *\n * An entry is affine — `base = value * factor + offset` — so a scale that\n * puts zero somewhere else (degC against K) is expressible. No per-axis\n * units. No mixed-unit arithmetic.\n */\n\n/** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */\nexport type Unit = string;\n\n/** What one unit is worth in base units: `base = value * factor + offset`. */\nexport interface UnitScale {\n  factor: number;\n  /** Where this unit puts zero, in base units. Absent is 0 — a pure scale. */\n  offset?: number;\n}\n\n/** One unit's conversion. A bare number is the `{ factor }` shorthand. */\nexport type UnitEntry = number | UnitScale;\n\n/** Conversion table mapping unit names to their scale against a base unit. */\nexport interface UnitSystem {\n  /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */\n  base: Unit;\n  /** How to reach base units from each unit. The base unit's entry is 1. */\n  units: Record<Unit, UnitEntry>;\n}\n\n/**\n * One unit's scale, with the bare-number shorthand widened and the offset\n * defaulted — what every conversion in the kit reads. Throws if the system\n * does not carry the unit.\n */\nexport function unitScale(unitSystem: UnitSystem, unit: Unit): Required<UnitScale> {\n  const entry = unitSystem.units[unit];\n  if (entry === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `unknown unit '${unit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  return typeof entry === 'number'\n    ? { factor: entry, offset: 0 }\n    : { factor: entry.factor, offset: entry.offset ?? 0 };\n}\n\n/** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */\nexport type UnitValue = number | { value: number; unit: Unit };\n\n/**\n * Resolve a UnitValue to a number in base units.\n *  - bare number: returned as-is (assumed base)\n *  - tagged: looks up factor; throws if unit not in unit system\n */\nexport function resolveUnit(v: UnitValue, unitSystem?: UnitSystem): number {\n  if (typeof v === 'number') return v;\n  if (!unitSystem) {\n    throw new Error(\n      `resolveUnit: tagged value { value: ${v.value}, unit: '${v.unit}' } requires a UnitSystem`,\n    );\n  }\n  const { factor, offset } = scaleOrThrow('resolveUnit', unitSystem, v.unit);\n  return v.value * factor + offset;\n}\n\n/**\n * Format a base-unit number as a string in the named display unit.\n *  e.g. formatUnit(36, 'ft', IMPERIAL_INCHES) => '3ft'\n *  Default precision: 2. Trailing zeros trimmed.\n */\nexport function formatUnit(\n  baseValue: number,\n  displayUnit: Unit,\n  unitSystem: UnitSystem,\n  opts?: { precision?: number; suffix?: boolean },\n): string {\n  const { factor, offset } = scaleOrThrow('formatUnit', unitSystem, displayUnit);\n  const precision = opts?.precision ?? 2;\n  const suffix = opts?.suffix ?? true;\n  const display = (baseValue - offset) / factor;\n  // Trim trailing zeros (and a dangling decimal point) without losing precision.\n  let s = display.toFixed(precision);\n  if (s.includes('.')) {\n    s = s.replace(/0+$/, '').replace(/\\.$/, '');\n  }\n  return suffix ? `${s}${displayUnit}` : s;\n}\n\n/** `unitScale`, with the caller's name in front of the message. */\nfunction scaleOrThrow(caller: string, unitSystem: UnitSystem, unit: Unit): Required<UnitScale> {\n  try {\n    return unitScale(unitSystem, unit);\n  } catch (e) {\n    throw new Error(`${caller}: ${e instanceof Error ? e.message : String(e)}`);\n  }\n}\n\n/** Imperial unit system with base 'in'. */\nexport const IMPERIAL_INCHES: UnitSystem = {\n  base: 'in',\n  units: { in: 1, ft: 12, yd: 36, mi: 63360 },\n};\n\n/** Metric unit system with base 'mm'. */\nexport const METRIC_MM: UnitSystem = {\n  base: 'mm',\n  units: { mm: 1, cm: 10, m: 1000, km: 1_000_000 },\n};\n\n/** Angle unit system with base 'rad'. */\nexport const ANGLE_RADIANS: UnitSystem = {\n  base: 'rad',\n  units: { rad: 1, deg: Math.PI / 180, turn: Math.PI * 2 },\n};\n\n/** Pixel unit system — sole unit is the base. */\nexport const PIXELS: UnitSystem = {\n  base: 'px',\n  units: { px: 1 },\n};\n","import type { SnapStrategy } from '../../types';\nimport { resolveUnit, type UnitSystem, type UnitValue } from 'core/units';\nimport type { DebugSink } from '../../../../debug/types';\nimport { isPathLike } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { boundsOfPath } from 'features/paths/bounds';\nimport { translatePath } from 'features/paths/transform';\nimport type { Path } from 'features/paths/types';\n\n/**\n * Projection used by `gridSnapStrategy` when `TPose` doesn't expose `{x,y}`\n * directly (Path, polygon, etc.). The strategy reads the snap point via\n * `getOrigin`, rounds it to the grid, then asks `translate` to move the\n * pose by the resulting delta.\n */\nexport interface OriginProjection<TPose> {\n  getOrigin(pose: TPose): { x: number; y: number };\n  translate(pose: TPose, dx: number, dy: number): TPose;\n}\n\n/** Identity projection for `TPose extends { x; y }`. */\nexport const RECT_ORIGIN_PROJECTION: OriginProjection<{ x: number; y: number }> = {\n  getOrigin: (p) => ({ x: p.x, y: p.y }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n};\n\n/** Per-call dispatch: routes Path-shaped poses to the path origin/translate\n *  helpers and everything else to `RECT_ORIGIN_PROJECTION`. Default for\n *  `gridSnapStrategy` so consumers with Path TPose don't have to thread\n *  `pathOriginProjection` explicitly. */\nexport const AUTO_ORIGIN_PROJECTION: OriginProjection<unknown> = {\n  getOrigin: (p) => {\n    if (isPathLike(p)) {\n      const b = boundsOfPath(p as Path);\n      return { x: b.x, y: b.y };\n    }\n    const r = p as { x: number; y: number };\n    return { x: r.x, y: r.y };\n  },\n  translate: (p, dx, dy) => {\n    if (isPathLike(p)) return translatePath(p as Path, dx, dy);\n    const r = p as { x: number; y: number };\n    return { ...r, x: r.x + dx, y: r.y + dy };\n  },\n};\n\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n): SnapStrategy<TPose>;\n/** As above, additionally reporting each candidate to a debug sink. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; origin: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  arg?: UnitSystem | { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose> {\n  const isOpts =\n    typeof arg === 'object' &&\n    arg !== null &&\n    ('origin' in arg || 'debug' in arg || 'unitSystem' in arg) &&\n    !('base' in arg);\n  const optsArg = isOpts\n    ? (arg as { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink })\n    : null;\n  const unitSystem = optsArg ? optsArg.unitSystem : (arg as UnitSystem | undefined);\n  const proj: OriginProjection<TPose> = optsArg && optsArg.origin\n    ? optsArg.origin\n    : (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const debug: DebugSink | undefined = optsArg ? optsArg.debug : undefined;\n  const c = resolveUnit(spacing, unitSystem);\n  return {\n    snap(pose) {\n      const o = proj.getOrigin(pose);\n      const sx = Math.round(o.x / c) * c;\n      const sy = Math.round(o.y / c) * c;\n      debug?.recordSnapCandidate({ x: sx, y: sy }, true);\n      return proj.translate(pose, sx - o.x, sy - o.y);\n    },\n  };\n}\n\n/**\n * Compute the integer cell `{col, row}` that contains `point`, given a grid\n * `spacing` and optional `origin` and `unitSystem`. Pair with\n * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target\n * preview that uses the same spacing as `gridSnapStrategy` — so the visual\n * and behavioral grids stay in lockstep:\n *\n *     const SPACING = 20;\n *     const snap = gridSnapStrategy(SPACING);\n *     // visual grid:\n *     createGridLayer({ spacing: SPACING, bounds: () => ... });\n *     // hover-preview overlay:\n *     createCellHighlightLayer({\n *       spacing: SPACING,\n *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),\n *     });\n */\nexport function pointToGridCell(\n  point: { x: number; y: number },\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n  origin: { x: number; y: number } = { x: 0, y: 0 },\n): { col: number; row: number } {\n  const s = resolveUnit(spacing, unitSystem);\n  return {\n    col: Math.floor((point.x - origin.x) / s),\n    row: Math.floor((point.y - origin.y) / s),\n  };\n}\n","/**\n * Screen-pixel lengths in world units, per axis.\n *\n * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at\n * every zoom, because it paints in screen space. Converting one such length to\n * world units with a single scalar (see `meanScale`) is exact only under\n * uniform zoom; per-axis it is too generous on one axis and too mean on the\n * other, so the pickable region stops matching the painted one.\n *\n * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen\n * space and so can't drift from the paint at all. {@link pxExtent} is for the\n * cases that must stay in world units — a tolerance handed to geometry that\n * doesn't know about the view.\n */\n\nexport interface Scale2 {\n  x: number;\n  y: number;\n}\n\n/** One screen-pixel length as world-space extents, per axis. `scale` is a\n *  view's, so neither axis is zero (see `View`). */\nexport function pxExtent(px: number, scale: Scale2): { x: number; y: number } {\n  return {\n    x: px / Math.abs(scale.x),\n    y: px / Math.abs(scale.y),\n  };\n}\n\n/** World delta → screen delta. Only the scale participates: translation\n *  cancels in a difference, and the kit's views carry no skew. */\nexport function scaleDelta(dx: number, dy: number, scale: Scale2): { x: number; y: number } {\n  return { x: dx * scale.x, y: dy * scale.y };\n}\n\n/**\n * Is a world-space delta inside a screen-space square of half-extent `px`?\n *\n * The square is axis-aligned **on screen**, which is what a handle painted in\n * screen space actually is — so this stays true under non-uniform zoom and\n * under a rotated target, where an axis-aligned world-space test is a rotated\n * rectangle on screen.\n */\nexport function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;\n}\n\n/** Is a world-space delta inside a screen-space circle of radius `px`? */\nexport function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return s.x * s.x + s.y * s.y <= px * px;\n}\n","import type { SnapStrategy } from '../../types';\nimport type { Guide } from 'features/guides/types';\nimport type { View } from 'core/viewport/view';\nimport { pxExtent } from 'core/viewport/pxExtent';\nimport type { OriginProjection } from './grid';\nimport { RECT_ORIGIN_PROJECTION } from './grid';\n\n/** Default snap tolerance (screen pixels). */\nexport const DEFAULT_GUIDE_TOLERANCE_PX = 6;\n\n/** Options for `guideSnapStrategy`. */\nexport interface GuideSnapOptions<TPose> {\n  /**\n   * Tolerance, in screen pixels (CSS px) when `getView` is provided, or in\n   * world units otherwise. Defaults to `DEFAULT_GUIDE_TOLERANCE_PX`.\n   */\n  tolerance?: number;\n  /**\n   * Read the active view transform. When supplied, `tolerance` is interpreted\n   * in screen pixels and divided by `view.scale` so the trigger zone stays\n   * the same on screen as the user zooms in/out. Without it, `tolerance`\n   * is treated as world units.\n   */\n  getView?: () => View;\n  /**\n   * Projection used when `TPose` doesn't expose `{x, y}` directly (Path,\n   * polygon, etc.) — same contract as `gridSnapStrategy`. Defaults to the\n   * rect-pose identity projection.\n   */\n  origin?: OriginProjection<TPose>;\n}\n\n/**\n * Snap-strategy that snaps the pose's origin to the nearest guide line on\n * each axis when within tolerance. Each axis is considered independently:\n * a vertical guide (`axis: 'x'`) constrains X, a horizontal guide\n * (`axis: 'y'`) constrains Y. When multiple guides are within range on the\n * same axis, the closest wins.\n *\n * Pair with `useGuides` for storage and `createGuidesLayer` for rendering.\n *\n * **Composition:** combining with `gridSnapStrategy` is left to the\n * consumer in v1 — typically by picking one based on a modifier key, or\n * by stacking two move/resize/insert behaviors in priority order.\n */\nexport function guideSnapStrategy<TPose extends { x: number; y: number }>(\n  getGuides: () => readonly Guide[],\n  options?: Omit<GuideSnapOptions<TPose>, 'origin'>,\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> & { origin: OriginProjection<TPose> },\n): SnapStrategy<TPose>;\n/** Snap a pose's origin to the nearest guide line within tolerance, per axis. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> = {},\n): SnapStrategy<TPose> {\n  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;\n  const getView = options.getView;\n  const proj: OriginProjection<TPose> =\n    options.origin ?? (RECT_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n\n  return {\n    snap(pose) {\n      const guides = getGuides();\n      if (guides.length === 0) return null;\n\n      // Convert tolerance to world units, per axis: a guide on the x axis is\n      // matched by a horizontal distance, so it answers to `scale.x` alone.\n      // With no view, treat tolerance as already-world.\n      const tol = getView ? pxExtent(tolerance, getView().scale) : { x: tolerance, y: tolerance };\n\n      const o = proj.getOrigin(pose);\n\n      let bestDx = 0;\n      let bestAbsDx = Infinity;\n      let bestDy = 0;\n      let bestAbsDy = Infinity;\n\n      for (const g of guides) {\n        if (g.axis === 'x') {\n          const d = g.offset - o.x;\n          const ad = Math.abs(d);\n          if (ad <= tol.x && ad < bestAbsDx) {\n            bestAbsDx = ad;\n            bestDx = d;\n          }\n        } else {\n          const d = g.offset - o.y;\n          const ad = Math.abs(d);\n          if (ad <= tol.y && ad < bestAbsDy) {\n            bestAbsDy = ad;\n            bestDy = d;\n          }\n        }\n      }\n\n      if (bestAbsDx === Infinity && bestAbsDy === Infinity) return null;\n      const dx = bestAbsDx === Infinity ? 0 : bestDx;\n      const dy = bestAbsDy === Infinity ? 0 : bestDy;\n      if (dx === 0 && dy === 0) return null;\n      return proj.translate(pose, dx, dy);\n    },\n  };\n}\n"]}

package/dist/chunk-T3UQ3F6R.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/applyOps.ts","../src/debug/flag.ts","../src/features/pointer/PointerContext.tsx","../src/interactions/actions/clipboard/wireFormat.ts","../src/interactions/actions/clipboard/materializePaste.ts","../src/interactions/actions/clipboard/clipboardOps.ts"],"names":["useRef"],"mappings":";;;;;;AAYO,SAAS,UAAA,CAAc,OAAA,EAAY,GAAA,EAAW,MAAA,EAAuB;AAC1E,EAAA,KAAA,MAAW,EAAA,IAAM,GAAA,EAAK,EAAA,CAAG,KAAA,CAAM,OAAO,CAAA;AACxC;AAOO,SAAS,kBAAA,CACd,OAAA,EACA,GAAA,EACA,KAAA,EACM;AACN,EAAA,MAAM,CAAA,GAAI,OAAA;AACV,EAAA,IAAI,CAAA,CAAE,QAAA,EAAU,CAAA,CAAE,QAAA,CAAS,KAAK,KAAK,CAAA;AAAA,OAChC,UAAA,CAAW,OAAA,EAAS,GAAU,CAAA;AACrC;;;ACFA,IAAM,IAAA,GAAO,CAAC,cAAA,EAAgB,kBAAkB,CAAA;AAOhD,IAAI,MAAA,GAAwB,IAAA;AAE5B,SAAS,IAAA,GAAe;AACtB,EAAA,MAAM,QAAgB,EAAE,GAAA,EAAK,OAAO,GAAA,kBAAK,IAAI,KAAI,EAAE;AACnD,EAAA,IAAI,OAAO,YAAA,KAAiB,WAAA,EAAa,OAAO,KAAA;AAChD,EAAA,IAAI;AACF,IAAA,KAAA,MAAW,KAAK,IAAA,EAAM;AACpB,MAAA,MAAM,CAAA,GAAI,YAAA,CAAa,OAAA,CAAQ,CAAC,CAAA;AAChC,MAAA,IAAI,CAAA,IAAK,IAAA,IAAQ,CAAA,KAAM,EAAA,EAAI;AAC3B,MAAA,IAAI,CAAA,KAAM,GAAA,IAAO,CAAA,KAAM,MAAA,IAAU,CAAA,KAAM,GAAA,EAAK,OAAO,EAAE,GAAA,EAAK,IAAA,EAAM,GAAA,kBAAK,IAAI,KAAI,EAAE;AAC/E,MAAA,OAAO,EAAE,GAAA,EAAK,KAAA,EAAO,GAAA,EAAK,IAAI,GAAA,CAAI,CAAA,CAAE,KAAA,CAAM,QAAQ,CAAA,CAAE,MAAA,CAAO,OAAO,CAAC,CAAA,EAAE;AAAA,IACvE;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,KAAA;AAAA,EACT;AACF;AAEA,SAAS,GAAA,GAAc;AACrB,EAAA,IAAI,MAAA,KAAW,IAAA,EAAM,MAAA,GAAS,IAAA,EAAK;AACnC,EAAA,OAAO,MAAA;AACT;AAIO,SAAS,eAAe,SAAA,EAA6B;AAC1D,EAAA,MAAM,IAAI,GAAA,EAAI;AACd,EAAA,IAAI,CAAA,CAAE,KAAK,OAAO,IAAA;AAClB,EAAA,IAAI,SAAA,KAAc,MAAA,EAAW,OAAO,CAAA,CAAE,IAAI,IAAA,GAAO,CAAA;AACjD,EAAA,OAAO,CAAA,CAAE,GAAA,CAAI,GAAA,CAAI,SAAS,CAAA;AAC5B;AAIO,SAAS,IAAA,CAAK,cAAsB,IAAA,EAAuB;AAChE,EAAA,IAAI,CAAC,cAAA,CAAe,SAAS,CAAA,EAAG;AAEhC,EAAA,OAAA,CAAQ,KAAA,CAAM,CAAA,CAAA,EAAI,SAAS,CAAA,CAAA,CAAA,EAAK,GAAG,IAAI,CAAA;AACzC;AAKO,SAAS,KAAA,CAAM,cAAsB,IAAA,EAAuB;AACjE,EAAA,IAAI,CAAC,cAAA,CAAe,SAAS,CAAA,EAAG;AAChC,EAAA,OAAA,CAAQ,IAAA,CAAK,CAAA,CAAA,EAAI,SAAS,CAAA,CAAA,CAAA,EAAK,GAAG,IAAI,CAAA;AACxC;AC9CA,IAAM,cAAA,GAAiB,cAA0C,IAAI,CAAA;AAa9D,SAAS,sBAAA,CAAuB,EAAE,QAAA,EAAS,EAAuC;AACvF,EAAA,MAAM,UAAA,GAAa,OAAwB,IAAI,CAAA;AAC/C,EAAA,MAAM,KAAA,GAAQ,QAA6B,OAAO;AAAA,IAChD,UAAA;AAAA,IACA,YAAA,EAAc,MAAM,UAAA,CAAW;AAAA,GACjC,CAAA,EAAI,EAAE,CAAA;AACN,EAAA,uBAAO,GAAA,CAAC,cAAA,CAAe,QAAA,EAAf,EAAwB,OAAe,QAAA,EAAS,CAAA;AAC1D;AAIO,SAAS,iBAAA,GAAgD;AAC9D,EAAA,OAAO,WAAW,cAAc,CAAA;AAClC;;;ACvDO,IAAM,qBAAA,GAAwB;AAE9B,IAAM,yBAAA,GAA4B,OAAO,qBAAqB,CAAA;AAc9D,SAAS,wBAAA,CAAyB,OAAkB,QAAA,EAA6B;AACtF,EAAA,MAAM,OAAA,GAAkC,EAAE,eAAA,EAAiB,CAAA,EAAG,OAAO,KAAA,EAAM;AAC3E,EAAA,OAAO,IAAA,CAAK,SAAA,CAAU,OAAA,EAAS,QAAgD,CAAA;AACjF;AAIO,SAAS,yBAAyB,IAAA,EAAuB;AAC9D,EAAA,IAAI,CAAC,IAAA,CAAK,QAAA,CAAS,mBAAmB,GAAG,OAAO,KAAA;AAChD,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,IAAI,CAAA;AAC9B,IAAA,OAAO,CAAC,CAAC,MAAA,IAAU,MAAA,CAAO,eAAA,KAAoB,CAAA;AAAA,EAChD,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,KAAA;AAAA,EACT;AACF;AAKA,IAAM,YAAA,GAAe,oBAAA;AAgBd,SAAS,wBAAA,CAAyB,SAAiB,WAAA,EAA6B;AACrF,EAAA,MAAM,IAAA,GAAO,YAAA,CAAa,IAAA,CAAK,OAAO,CAAA;AACtC,EAAA,IAAI,CAAC,IAAA,EAAM;AACT,IAAA,KAAA,CAAM,aAAa,wFAAmF,CAAA;AACtG,IAAA,OAAO,OAAA;AAAA,EACT;AACA,EAAA,MAAM,QAAQ,CAAA,SAAA,EAAY,WAAA,CAAY,UAAA,CAAW,KAAA,EAAO,iBAAiB,CAAC,CAAA,GAAA,CAAA;AAC1E,EAAA,MAAM,EAAA,GAAK,IAAA,CAAK,KAAA,GAAQ,IAAA,CAAK,CAAC,CAAA,CAAE,MAAA;AAChC,EAAA,OAAO,CAAA,EAAG,OAAA,CAAQ,KAAA,CAAM,CAAA,EAAG,EAAE,CAAC,CAAA,UAAA,EAAa,KAAK,CAAA,WAAA,EAAc,OAAA,CAAQ,KAAA,CAAM,EAAE,CAAC,CAAA,CAAA;AACjF;AAWO,SAAS,8BAA8B,OAAA,EAAgC;AAC5E,EAAA,MAAM,KAAA,GAAQ,+CAAA,CAAgD,IAAA,CAAK,OAAO,CAAA;AAC1E,EAAA,IAAI,CAAC,OAAO,OAAO,IAAA;AACnB,EAAA,MAAM,KAAA,GAAQ,MAAM,CAAC,CAAA;AACrB,EAAA,MAAM,UAAU,KAAA,CAAM,QAAA,CAAS,WAAW,CAAA,GACtC,KAAA,CAAM,KAAK,KAAA,CAAM,QAAA,CAAS,6BAA6B,CAAA,EAAG,CAAC,MAAM,CAAA,CAAE,CAAC,CAAC,CAAA,CAAE,IAAA,CAAK,EAAE,CAAA,GAC9E,KAAA;AACJ,EAAA,OAAO,wBAAA,CAAyB,OAAO,CAAA,GAAI,OAAA,GAAU,IAAA;AACvD;AAIO,SAAS,wBAAA,CAAyB,MAAc,OAAA,EAAqC;AAC1F,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,IAAA,EAAM,OAA2C,CAAA;AAE3E,IAAA,IAAI,CAAC,MAAA,IAAU,MAAA,CAAO,eAAA,KAAoB,CAAA,IAAK,CAAC,KAAA,CAAM,OAAA,CAAQ,MAAA,CAAO,KAAK,CAAA,EAAG,OAAO,IAAA;AACpF,IAAA,OAAO,MAAA,CAAO,KAAA;AAAA,EAChB,SAAS,GAAA,EAAK;AACZ,IAAA,KAAA,CAAM,WAAA,EAAa,CAAA,gCAAA,EAAmC,MAAA,CAAO,GAAG,CAAC,CAAA,CAAE,CAAA;AACnE,IAAA,OAAO,IAAA;AAAA,EACT;AACF;;;AC/EO,SAAS,gBAAA,CACd,OAAA,EACA,QAAA,EACA,IAAA,EAI0D;AAC1D,EAAA,MAAM,cAAc,OAAA,CAAQ,WAAA;AAC5B,EAAA,IAAI,CAAC,aAAa,OAAO,IAAA;AACzB,EAAA,MAAM,MAAA,GAAS,QAAQ,cAAA,GAAiB,QAAQ,KAAK,EAAE,EAAA,EAAI,CAAA,EAAG,EAAA,EAAI,CAAA,EAAE;AACpE,EAAA,MAAM,GAAA,GAAM,KAAK,SAAA,IAAa,IAAA,GAAO,EAAE,SAAA,EAAW,IAAA,CAAK,WAAU,GAAI,MAAA;AACrE,EAAA,MAAM,UAAU,WAAA,CAAY,IAAA,CAAK,OAAA,EAAS,QAAA,EAAU,QAAQ,GAAG,CAAA;AAC/D,EAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA;AACjC,EAAA,MAAM,SAAS,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,KAAM,EAAE,EAAE,CAAA;AACtC,EAAA,MAAM,GAAA,GAAY;AAAA,IAChB,GAAG,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,KAAM,eAAe,EAAE,IAAA,EAAM,CAAA,EAAG,CAAC,CAAA;AAAA,IACjD,qBAAqB,EAAE,IAAA,EAAM,KAAK,gBAAA,EAA8B,EAAA,EAAI,QAAoB;AAAA,GAC1F;AACA,EAAA,OAAO,EAAE,GAAA,EAAK,MAAA,EAAQ,OAAA,EAAQ;AAChC;;;ACKA,IAAM,KAAA,GAA2B,EAAE,KAAA,EAAO,EAAC,EAAE;AAGtC,SAAS,eAAA,CACd,SACA,OAAA,EACuB;AACvB,EAAA,MAAM,EAAE,cAAc,OAAA,EAAS,UAAA,GAAa,SAAS,YAAA,EAAc,cAAA,EAAgB,cAAa,GAAI,OAAA;AAKpG,EAAA,MAAM,aAAa,iBAAA,EAAkB;AACrC,EAAA,MAAM,qBAAA,GAAwB,gBAAgB,UAAA,EAAY,YAAA;AAC1D,EAAA,MAAM,YAAA,GAAeA,OAA0B,KAAK,CAAA;AAEpD,EAAA,MAAM,UAAA,GAAaA,OAAO,OAAO,CAAA;AACjC,EAAA,UAAA,CAAW,OAAA,GAAU,OAAA;AACrB,EAAA,MAAM,UAAUA,MAAAA,CAAO;AAAA,IACrB,YAAA;AAAA,IAAc,OAAA;AAAA,IAAS,UAAA;AAAA,IAAY,YAAA,EAAc,qBAAA;AAAA,IAAuB,cAAA;AAAA,IAAgB;AAAA,GACzF,CAAA;AACD,EAAA,OAAA,CAAQ,OAAA,GAAU;AAAA,IAChB,YAAA;AAAA,IAAc,OAAA;AAAA,IAAS,UAAA;AAAA,IAAY,YAAA,EAAc,qBAAA;AAAA,IAAuB,cAAA;AAAA,IAAgB;AAAA,GAC1F;AAEA,EAAA,MAAM,IAAA,GAAO,YAAY,MAAM;AAC7B,IAAA,MAAM,GAAA,GAAM,OAAA,CAAQ,OAAA,CAAQ,YAAA,EAAa;AACzC,IAAA,IAAI,GAAA,CAAI,WAAW,CAAA,EAAG;AACtB,IAAA,MAAM,IAAA,GAAO,WAAW,OAAA,CAAQ,iBAAA;AAChC,IAAA,IAAI,CAAC,IAAA,EAAM;AACX,IAAA,YAAA,CAAa,OAAA,GAAU,KAAK,GAAG,CAAA;AAO/B,IAAA,IAAI,OAAA,GAAyC,IAAA;AAC7C,IAAA,IAAI;AACF,MAAA,OAAA,GAAU,OAAA,CAAQ,OAAA,CAAQ,cAAA,GAAiB,YAAA,CAAa,OAAO,CAAA,IAC1D,cAAA,CAAe,YAAA,CAAa,OAAA,EAAS,OAAA,CAAQ,OAAA,CAAQ,YAAY,CAAA;AAAA,IACxE,SAAS,GAAA,EAAK;AACZ,MAAA,KAAA,CAAM,WAAA,EAAa,CAAA,gDAAA,EAA8C,MAAA,CAAO,GAAG,CAAC,CAAA,CAAE,CAAA;AAAA,IAChF;AACA,IAAA,IAAI,OAAA,EAAS,KAAK,gBAAA,CAAiB,OAAO,CAAA;AAAA,EAC5C,CAAA,EAAG,EAAE,CAAA;AAEL,EAAA,MAAM,KAAA,GAAQ,YAAY,MAAM;AAC9B,IAAA,MAAM,KAAK,YAAA,CAAa,OAAA;AACxB,IAAA,IAAI,EAAA,CAAG,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG;AAC3B,IAAA,MAAM,IAAI,UAAA,CAAW,OAAA;AACrB,IAAA,MAAM,MAAA,GAAS,gBAAA,CAAiB,CAAA,EAAG,EAAA,EAAI;AAAA,MACrC,gBAAA,EAAkB,OAAA,CAAQ,OAAA,CAAQ,YAAA,EAAa;AAAA,MAC/C,SAAA,EAAW,OAAA,CAAQ,OAAA,CAAQ,YAAA;AAAe,KAC3C,CAAA;AACD,IAAA,IAAI,CAAC,MAAA,EAAQ;AACb,IAAA,kBAAA,CAAmB,CAAA,EAAG,MAAA,CAAO,GAAA,EAAK,OAAA,CAAQ,QAAQ,UAAU,CAAA;AAM5D,IAAA,YAAA,CAAa,OAAA,GAAU,EAAE,KAAA,EAAO,MAAA,CAAO,OAAA,EAAQ;AAC/C,IAAA,OAAA,CAAQ,OAAA,CAAQ,OAAA,GAAU,MAAA,CAAO,MAAkB,CAAA;AAAA,EACrD,CAAA,EAAG,EAAE,CAAA;AAEL,EAAA,MAAM,OAAA,GAAU,YAAY,MAAM,YAAA,CAAa,QAAQ,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG,EAAE,CAAA;AAE7E,EAAA,OAAO,EAAE,IAAA,EAAM,KAAA,EAAO,OAAA,EAAQ;AAChC;AAEA,SAAS,cAAA,CAAe,UAA6B,QAAA,EAA6C;AAChG,EAAA,MAAM,IAAA,GAAO,wBAAA,CAAyB,QAAA,CAAS,KAAA,EAAO,QAAQ,CAAA;AAC9D,EAAA,OAAO,EAAE,CAAC,qBAAqB,GAAG,IAAA,EAAM,cAAc,IAAA,EAAK;AAC7D;AAMA,IAAM,6CAA6B,IAAI,GAAA,CAAI,CAAC,YAAA,EAAc,WAAA,EAAa,WAAW,CAAC,CAAA;AAOnF,eAAsB,iBAAiB,OAAA,EAAgD;AACrF,EAAA,MAAM,OAAA,GAAU,MAAA,CAAO,OAAA,CAAQ,OAAO,CAAA;AACtC,EAAA,IAAI,OAAA,CAAQ,WAAW,CAAA,EAAG;AAC1B,EAAA,MAAM,EAAA,GAAK,OAAO,SAAA,KAAc,WAAA,GAAc,UAAU,SAAA,GAAY,MAAA;AACpE,EAAA,IAAI,CAAC,EAAA,EAAI,KAAA,IAAS,OAAO,kBAAkB,WAAA,EAAa;AACxD,EAAA,MAAM,QAAA,GAAW,CAAC,IAAA,KAAkB,0BAAA,CAA2B,IAAI,IAAI,CAAA,GAAI,IAAA,GAAO,CAAA,IAAA,EAAO,IAAI,CAAA,CAAA;AAC7F,EAAA,MAAM,MAAA,GAAS,CAAC,EAAA,KAA2B,IAAI,cAAc,MAAA,CAAO,WAAA;AAAA,IAClE,GAAG,GAAA,CAAI,CAAC,CAAC,IAAA,EAAM,IAAI,CAAA,KAAM;AACvB,MAAA,MAAM,IAAA,GAAO,SAAS,IAAI,CAAA;AAC1B,MAAA,OAAO,CAAC,IAAA,EAAM,IAAI,IAAA,CAAK,CAAC,IAAI,CAAA,EAAG,EAAE,IAAA,EAAM,IAAA,EAAM,CAAC,CAAA;AAAA,IAChD,CAAC;AAAA,GACF,CAAA;AACD,EAAA,IAAI;AACF,IAAA,MAAM,GAAG,KAAA,CAAM,CAAC,MAAA,CAAO,OAAO,CAAC,CAAC,CAAA;AAAA,EAClC,CAAA,CAAA,MAAQ;AACN,IAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,MAAA,CAAO,CAAC,CAAC,IAAI,CAAA,KAAM,0BAAA,CAA2B,GAAA,CAAI,IAAI,CAAC,CAAA;AAChF,IAAA,IAAI,QAAA,CAAS,WAAW,CAAA,EAAG;AAAE,MAAA,KAAA,CAAM,aAAa,sDAAsD,CAAA;AAAG,MAAA;AAAA,IAAQ;AACjH,IAAA,IAAI;AACF,MAAA,MAAM,GAAG,KAAA,CAAM,CAAC,MAAA,CAAO,QAAQ,CAAC,CAAC,CAAA;AAAA,IACnC,SAAS,GAAA,EAAK;AACZ,MAAA,KAAA,CAAM,WAAA,EAAa,CAAA,kEAAA,EAAgE,MAAA,CAAO,GAAG,CAAC,CAAA,CAAE,CAAA;AAAA,IAClG;AAAA,EACF;AACF","file":"chunk-T3UQ3F6R.js","sourcesContent":["import type { Op } from './ops/types';\n\n/**\n * Default `applyOps` implementation: apply each op in order against\n * `adapter`. Used by hooks when an adapter omits `applyOps`. Apps that\n * need history integration (checkpoint + push entry) supply their own\n * `applyOps` instead.\n *\n * The `_label` parameter mirrors the `applyOps(ops, label)` signature so\n * call-sites can dispatch through `(adapter.applyOps ?? applyOpsTo)` with\n * matching arguments. The default ignores it.\n */\nexport function applyOpsTo<A>(adapter: A, ops: Op[], _label?: string): void {\n  for (const op of ops) op.apply(adapter);\n}\n\n/**\n * Dispatcher: invokes `adapter.applyOps` if present, otherwise falls back\n * to `applyOpsTo`. Convenience for hooks so they don't repeat the\n * `?? applyOpsTo` pattern at every call site.\n */\nexport function dispatchApplyBatch<A>(\n  adapter: A,\n  ops: Op[],\n  label?: string,\n): void {\n  const a = adapter as { applyOps?: (ops: Op[], label?: string) => void };\n  if (a.applyOps) a.applyOps(ops, label);\n  else applyOpsTo(adapter, ops, label);\n}\n","/**\n * Namespaced, opt-in console tracing for the kit.\n *\n * Enable in the browser:\n *\n *   localStorage.setItem('weasel.debug', '*')                 // all namespaces\n *   localStorage.setItem('weasel.debug', 'tools,dispatch')    // specific ones\n *   localStorage.setItem('weasel.debug', '1')                 // legacy \"all\"\n *\n * Each call site picks a stable namespace string. Off by default; the flag\n * is read once and cached per page session — reload to pick up a change.\n *\n * Mirrors `packages/ui/src/dlog.ts`. The two impls live in separate\n * packages because weasel-ui doesn't depend on the kit, but both read the\n * same localStorage keys so behavior is uniform from a debugger's POV.\n *\n * Known kit namespaces:\n *   - tools           — active-tool + hotkey transitions (useTools)\n *   - dispatch        — gesture start / end / cancel (dispatcher)\n *   - drag-rect       — useDragRect lifecycle\n *   - drag-radial     — useDragRadial lifecycle\n *   - scene           — restored-op replay gaps (history persistence)\n *   - scene-canvas    — SceneCanvas mount / unmount; adapter paste-translation warnings\n *   - history         — applyOps push, no-op suppression, serialize/restore\n *   - clipboard       — OS clipboard write/read failures, malformed payloads\n */\n\nconst KEYS = ['weasel.debug', 'weaseldraw.debug'] as const;\n\ninterface Cached {\n  all: boolean;\n  set: Set<string>;\n}\n\nlet cached: Cached | null = null;\n\nfunction read(): Cached {\n  const empty: Cached = { all: false, set: new Set() };\n  if (typeof localStorage === 'undefined') return empty;\n  try {\n    for (const k of KEYS) {\n      const v = localStorage.getItem(k);\n      if (v == null || v === '') continue;\n      if (v === '1' || v === 'true' || v === '*') return { all: true, set: new Set() };\n      return { all: false, set: new Set(v.split(/[\\s,]+/).filter(Boolean)) };\n    }\n    return empty;\n  } catch {\n    return empty;\n  }\n}\n\nfunction get(): Cached {\n  if (cached === null) cached = read();\n  return cached;\n}\n\n/** True when `namespace` (or `*`) is enabled. Pass no argument to test\n *  whether *any* namespace is on (legacy global-flag semantics). */\nexport function isDebugEnabled(namespace?: string): boolean {\n  const c = get();\n  if (c.all) return true;\n  if (namespace === undefined) return c.set.size > 0;\n  return c.set.has(namespace);\n}\n\n/** Conditional `console.debug` — no-op unless `namespace` (or `*`) is enabled.\n *  Each call is prefixed with `[namespace]` so the source is searchable. */\nexport function dlog(namespace: string, ...args: unknown[]): void {\n  if (!isDebugEnabled(namespace)) return;\n  // eslint-disable-next-line no-console\n  console.debug(`[${namespace}]`, ...args);\n}\n\n/** Conditional `console.warn` — like `dlog` but at warn level. Use for\n *  diagnostics that indicate something worth surfacing during debugging\n *  (e.g. no-op op batches suppressed). */\nexport function dwarn(namespace: string, ...args: unknown[]): void {\n  if (!isDebugEnabled(namespace)) return;\n  console.warn(`[${namespace}]`, ...args);\n}\n","/**\n * @experimental\n * PointerContext — a tiny ambient context that publishes the world-space\n * position of the canvas pointer, refreshed on every `pointermove` over\n * the canvas. Cleared (set to `null`) on `pointerleave`.\n *\n * Why ref-based and not state-based: cursor moves fire dozens of times per\n * second; routing those through React state would re-render every consumer\n * in the tree. The context exposes a stable `pointerRef` whose `.current`\n * is mutated directly by the publisher, plus a thunk `getDropPoint()` that\n * reads it on demand. Consumers (e.g. `useClipboard`) pull via the thunk\n * inside their callbacks — no subscription, no re-render.\n *\n * `<SceneCanvas>` publishes automatically. `useClipboardOps` consumes when\n * the caller didn't pass an explicit `getDropPoint` option. Other future\n * hit-on-cursor consumers (drop-zone hover, context-menu anchor) can reuse\n * the same context.\n */\nimport { createContext, useContext, useMemo, useRef, type MutableRefObject, type ReactNode } from 'react';\n\n/** @experimental World-space pointer position, or `null` when the pointer\n *  isn't over the publishing canvas. */\nexport type PointerWorldPos = { worldX: number; worldY: number } | null;\n\n/** @experimental */\nexport interface PointerContextValue {\n  /** Live ref — mutate to publish, read for the latest snapshot. The\n   *  identity is stable for the lifetime of the provider. */\n  readonly pointerRef: MutableRefObject<PointerWorldPos>;\n  /** Convenience thunk equivalent to `() => pointerRef.current`. Stable\n   *  identity for the lifetime of the provider; safe to pass to hooks. */\n  readonly getDropPoint: () => PointerWorldPos;\n}\n\nconst PointerContext = createContext<PointerContextValue | null>(null);\n\n/**\n * @experimental\n * Wrap the part of the React tree that should share a pointer-position\n * context. Usually placed at the demo / app root, alongside\n * `<ActionsProvider>` and `<SelectionContextProvider>`.\n *\n * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts\n * an internal provider when no parent provider is in scope, so child hooks\n * (`useClipboard` without an explicit `getDropPoint`) read the canvas's\n * tracked pointer for free.\n */\nexport function PointerContextProvider({ children }: { children: ReactNode }): ReactNode {\n  const pointerRef = useRef<PointerWorldPos>(null);\n  const value = useMemo<PointerContextValue>(() => ({\n    pointerRef,\n    getDropPoint: () => pointerRef.current,\n  }), []);\n  return <PointerContext.Provider value={value}>{children}</PointerContext.Provider>;\n}\n\n/** @experimental Read the surrounding pointer-context value, or `null` when\n *  no provider is in scope. */\nexport function usePointerContext(): PointerContextValue | null {\n  return useContext(PointerContext);\n}\n","import { dwarn } from 'debug/flag';\n\n/** MIME type the kit writes its full-fidelity clipboard payload under, so a\n *  copy/paste between two weasel canvases round-trips scene nodes rather than\n *  the SVG or text flavors other apps read. */\nexport const WEASEL_CLIPBOARD_MIME = 'application/x-weasel-clipboard+json';\n/** Chromium's async-clipboard spelling for custom formats. */\nexport const WEASEL_CLIPBOARD_MIME_WEB = `web ${WEASEL_CLIPBOARD_MIME}`;\n\ninterface WeaselClipboardPayload { weaselClipboard: 1; nodes: unknown[] }\n\ntype Replacer = (key: string, value: unknown) => unknown;\ntype Reviver = (key: string, value: unknown) => unknown;\n\n/** Serialize snapshot items into the versioned wire text.\n *\n *  Function-valued fields (e.g. a container's `clipFromPose`) are dropped by\n *  JSON serialization — OS-pasted clip containers arrive unclipped.\n *  Consumers who need clips to survive the OS round-trip can translate\n *  function ↔ registry key in their `jsonReplacer`/reviver pair (the\n *  scene-serialization `clipFromPoseKey` precedent). */\nexport function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string {\n  const payload: WeaselClipboardPayload = { weaselClipboard: 1, nodes: items };\n  return JSON.stringify(payload, replacer as Parameters<typeof JSON.stringify>[1]);\n}\n\n/** Cheap check: could this text be a weasel clipboard payload? Substring\n *  pre-check, then a guarded parse + marker/version test. */\nexport function sniffWeaselClipboardText(text: string): boolean {\n  if (!text.includes('\"weaselClipboard\"')) return false;\n  try {\n    const parsed = JSON.parse(text) as Partial<WeaselClipboardPayload> | null;\n    return !!parsed && parsed.weaselClipboard === 1;\n  } catch {\n    return false;\n  }\n}\n\n// Opening `<svg ...>` tag of a serialized document. `[^>]*` is safe for OUR\n// serializer's output (attribute values are XML-escaped, so no raw `>` can\n// appear inside the tag) — see embedWeaselMetadataInSvg's contract note.\nconst SVG_OPEN_TAG = /<svg(?:\\s[^>]*)?>/i;\n\n/**\n * Embed a weasel clipboard payload in an SVG document as a `<metadata>`\n * child of the root — legal SVG 1.1, ignored by external tools — so one\n * `text/plain` flavor serves both audiences: external tools parse the SVG,\n * weasel extracts the JSON for full fidelity on draw→draw DOM paste.\n *\n * The payload rides in CDATA so JSON's `<` / `&` need no entity escaping; a\n * literal `]]>` inside the payload is split across CDATA sections\n * (`]]]]><![CDATA[>`), which {@link extractWeaselClipboardFromSvg} rejoins.\n *\n * Intended for OUR serializer's output only (`serializeSvg` — single\n * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found\n * the input is returned unchanged with a debug warning.\n */\nexport function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string {\n  const open = SVG_OPEN_TAG.exec(svgText);\n  if (!open) {\n    dwarn('clipboard', 'embedWeaselMetadataInSvg: no <svg ...> open tag found — returning input unchanged');\n    return svgText;\n  }\n  const cdata = `<![CDATA[${payloadText.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`;\n  const at = open.index + open[0].length;\n  return `${svgText.slice(0, at)}<metadata>${cdata}</metadata>${svgText.slice(at)}`;\n}\n\n/**\n * Recover an embedded weasel clipboard payload from SVG text: read the first\n * `<metadata>` block, rejoin its CDATA sections (concatenation restores the\n * `]]>` split by {@link embedWeaselMetadataInSvg}; plain non-CDATA content\n * passes through as-is), and return the payload text iff it sniffs as the\n * weasel wire format — else null (external/non-weasel metadata declines).\n *\n * A text scan, not an XML parse — the payload is small and ours.\n */\nexport function extractWeaselClipboardFromSvg(svgText: string): string | null {\n  const block = /<metadata(?:\\s[^>]*)?>([\\s\\S]*?)<\\/metadata>/i.exec(svgText);\n  if (!block) return null;\n  const inner = block[1];\n  const payload = inner.includes('<![CDATA[')\n    ? Array.from(inner.matchAll(/<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>/g), (m) => m[1]).join('')\n    : inner;\n  return sniffWeaselClipboardText(payload) ? payload : null;\n}\n\n/** Parse wire text to snapshot items, or null when malformed/mismatched\n *  (callers decline to the next content handler). */\nexport function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null {\n  try {\n    const parsed = JSON.parse(text, reviver as Parameters<typeof JSON.parse>[1]) as\n      Partial<WeaselClipboardPayload> | null;\n    if (!parsed || parsed.weaselClipboard !== 1 || !Array.isArray(parsed.nodes)) return null;\n    return parsed.nodes;\n  } catch (err) {\n    dwarn('clipboard', `weasel payload failed to parse: ${String(err)}`);\n    return null;\n  }\n}\n","/**\n * Shared paste materialization — the one place the paste recipe lives:\n * offset policy → `commitPaste` → the op batch (InsertOps parents-first +\n * a SetSelectionOp). Both `useClipboardOps.paste` (in-memory paste) and the\n * kit weasel-JSON content handler (OS-clipboard paste) dispatch exactly this\n * batch, so the two arrival paths stay indistinguishable in history.\n *\n * Pure: no dispatching here — callers own how the ops are applied\n * (`dispatchApplyBatch` vs `IngestCtx.applyOps`) and any post-paste\n * bookkeeping (the hook's cascade re-snapshot, the handler's selection set).\n */\nimport { createInsertOp } from 'core/ops/create';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type { ClipboardSnapshot, InsertAdapter } from 'core/adapters/types';\n\n/** Shared paste materialization: offset policy → commitPaste → the op batch\n *  both the in-memory paste and the OS-paste handler dispatch. Returns null\n *  when the adapter can't paste or nothing was created. */\nexport function materializePaste<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  snapshot: ClipboardSnapshot,\n  opts: {\n    currentSelection: string[];\n    dropPoint?: { worldX: number; worldY: number } | null;\n  },\n): { ops: Op[]; newIds: string[]; created: TNode[] } | null {\n  const commitPaste = adapter.commitPaste;\n  if (!commitPaste) return null;\n  const offset = adapter.getPasteOffset?.(snapshot) ?? { dx: 0, dy: 0 };\n  const ctx = opts.dropPoint != null ? { dropPoint: opts.dropPoint } : undefined;\n  const created = commitPaste.call(adapter, snapshot, offset, ctx);\n  if (created.length === 0) return null;\n  const newIds = created.map((o) => o.id);\n  const ops: Op[] = [\n    ...created.map((o) => createInsertOp({ node: o })),\n    createSetSelectionOp({ from: opts.currentSelection as NodeId[], to: newIds as NodeId[] }),\n  ];\n  return { ops, newIds, created };\n}\n","import { useCallback, useRef } from 'react';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { InsertAdapter } from 'core/adapters/types';\nimport type { ClipboardSnapshot } from './types';\nimport { usePointerContext } from 'features/pointer/PointerContext';\nimport { dwarn } from 'debug/flag';\nimport { materializePaste } from './materializePaste';\nimport { WEASEL_CLIPBOARD_MIME, buildWeaselClipboardText } from './wireFormat';\n\ntype Replacer = (key: string, value: unknown) => unknown;\n\n/** Options for `useClipboardOps`. */\nexport interface UseClipboardOpsOptions {\n  /** How the hook reads \"current selection\" for copy. The kit doesn't assume\n   *  a global selection store; each consumer wires this. */\n  getSelection: () => NodeId[];\n  /** Called after a successful paste with the ids of the newly inserted objects. */\n  onPaste?: (newIds: NodeId[]) => void;\n  /** Label for the history entry produced by paste. Default 'Paste'. */\n  pasteLabel?: string;\n  /** Pulled once per paste() call. When non-null, threaded to commitPaste\n   *  as `ctx.dropPoint`; adapters typically use it as the cluster origin\n   *  (ignoring `offset`). When null/undefined, the hook falls back to the\n   *  existing cascade-offset behavior. */\n  getDropPoint?: () => { worldX: number; worldY: number } | null;\n  /** Produce the OS-clipboard flavor map for a copied snapshot. Keys are MIME\n   *  types, values the serialized payload. The kit default emits\n   *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the\n   *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to\n   *  replace the text flavor. Return an empty object to skip the OS write\n   *  entirely. */\n  produceFlavors?: (snapshot: ClipboardSnapshot) => Record<string, string>;\n  /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored\n   *  when `produceFlavors` is supplied. */\n  jsonReplacer?: Replacer;\n}\n\n/** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */\nexport interface UseClipboardOpsReturn {\n  copy(): void;\n  paste(): void;\n  isEmpty(): boolean;\n}\n\nconst EMPTY: ClipboardSnapshot = { items: [] };\n\n/** In-memory copy/paste of selections via `InsertAdapter.snapshotSelection` / `commitPaste`. */\nexport function useClipboardOps<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  options: UseClipboardOpsOptions,\n): UseClipboardOpsReturn {\n  const { getSelection, onPaste, pasteLabel = 'Paste', getDropPoint, produceFlavors, jsonReplacer } = options;\n  // Fall back to the ambient pointer context (auto-published by SceneCanvas)\n  // when the caller didn't supply an explicit `getDropPoint`. Null context\n  // (no provider in scope) and no caller-supplied thunk together mean\n  // \"no drop point\" — paste uses the cascade offset instead.\n  const pointerCtx = usePointerContext();\n  const effectiveGetDropPoint = getDropPoint ?? pointerCtx?.getDropPoint;\n  const clipboardRef = useRef<ClipboardSnapshot>(EMPTY);\n  // Keep callbacks stable across renders.\n  const adapterRef = useRef(adapter);\n  adapterRef.current = adapter;\n  const optsRef = useRef({\n    getSelection, onPaste, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors, jsonReplacer,\n  });\n  optsRef.current = {\n    getSelection, onPaste, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors, jsonReplacer,\n  };\n\n  const copy = useCallback(() => {\n    const ids = optsRef.current.getSelection();\n    if (ids.length === 0) return;\n    const snap = adapterRef.current.snapshotSelection;\n    if (!snap) return;\n    clipboardRef.current = snap(ids);\n    // Best-effort OS write. Never blocks or throws — the in-memory ref is\n    // already set, and OS clipboard support varies (custom formats are\n    // Chromium-only via the \"web \" prefix; jsdom/non-secure contexts have\n    // no API at all). The flavor producer itself is untrusted consumer code\n    // (`produceFlavors`), so guard its call too — a throwing producer must\n    // not break `copy()`, it just skips the OS write.\n    let flavors: Record<string, string> | null = null;\n    try {\n      flavors = optsRef.current.produceFlavors?.(clipboardRef.current)\n        ?? defaultFlavors(clipboardRef.current, optsRef.current.jsonReplacer);\n    } catch (err) {\n      dwarn('clipboard', `flavor producer threw — skipping OS write: ${String(err)}`);\n    }\n    if (flavors) void writeOsClipboard(flavors);\n  }, []);\n\n  const paste = useCallback(() => {\n    const cb = clipboardRef.current;\n    if (cb.items.length === 0) return;\n    const a = adapterRef.current;\n    const result = materializePaste(a, cb, {\n      currentSelection: optsRef.current.getSelection(),\n      dropPoint: optsRef.current.getDropPoint?.(),\n    });\n    if (!result) return;\n    dispatchApplyBatch(a, result.ops, optsRef.current.pasteLabel);\n    // Use the just-created objects as the next cascade source. Re-snapshotting\n    // via `adapter.snapshotSelection(newIds)` would read adapter state, but\n    // React-state adapters haven't flushed yet — `itemsRef.current` still\n    // points at the pre-insert array, so the snapshot would come back empty\n    // and the next paste would no-op.\n    clipboardRef.current = { items: result.created };\n    optsRef.current.onPaste?.(result.newIds as NodeId[]);\n  }, []);\n\n  const isEmpty = useCallback(() => clipboardRef.current.items.length === 0, []);\n\n  return { copy, paste, isEmpty };\n}\n\nfunction defaultFlavors(snapshot: ClipboardSnapshot, replacer?: Replacer): Record<string, string> {\n  const text = buildWeaselClipboardText(snapshot.items, replacer);\n  return { [WEASEL_CLIPBOARD_MIME]: text, 'text/plain': text };\n}\n\n/** MIME types the async Clipboard API accepts unprefixed. Every other type\n *  (including our own custom MIME, and app-supplied flavors like\n *  `image/svg+xml`) must carry Chromium's `web ` prefix or `ClipboardItem`'s\n *  constructor throws. */\nconst WELL_KNOWN_CLIPBOARD_MIMES = new Set(['text/plain', 'text/html', 'image/png']);\n\n/** Degradation ladder: full map (every non-well-known MIME web-prefixed) →\n *  well-known-only → give up with a dwarn.\n *  @internal test seam — exported so unit tests can await the fire-and-forget\n *  write directly; tests should still exercise this at least once through\n *  the public `copy()` (see clipboardOps.test.tsx). */\nexport async function writeOsClipboard(flavors: Record<string, string>): Promise<void> {\n  const entries = Object.entries(flavors);\n  if (entries.length === 0) return;\n  const cb = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;\n  if (!cb?.write || typeof ClipboardItem === 'undefined') return;\n  const wireMime = (mime: string) => (WELL_KNOWN_CLIPBOARD_MIMES.has(mime) ? mime : `web ${mime}`);\n  const toItem = (fs: [string, string][]) => new ClipboardItem(Object.fromEntries(\n    fs.map(([mime, text]) => {\n      const wire = wireMime(mime);\n      return [wire, new Blob([text], { type: wire })];\n    }),\n  ));\n  try {\n    await cb.write([toItem(entries)]);\n  } catch {\n    const standard = entries.filter(([mime]) => WELL_KNOWN_CLIPBOARD_MIMES.has(mime));\n    if (standard.length === 0) { dwarn('clipboard', 'OS write failed; no standard flavors to fall back to'); return; }\n    try {\n      await cb.write([toItem(standard)]);\n    } catch (err) {\n      dwarn('clipboard', `OS clipboard write failed twice — copy stays in-memory only: ${String(err)}`);\n    }\n  }\n}\n"]}