@weasel-js/core 1.0.2 → 1.0.4

package/dist/{types-Ch0Goo-j.d.ts → types-DpQ0cWYC.d.ts}

@@ -1,15 +1,20 @@
 import { Op } from '@weasel-js/history';
 
+/** A layout container's extent in world units. */
 type ContainerBounds = {
     x: number;
     y: number;
     width: number;
     height: number;
 };
+/** A child a layout strategy is arranging. */
 interface LayoutChild<TPose> {
     id: string;
     pose: TPose;
 }
+/** One place a dragged child could land. A strategy offers these as the drag
+ *  moves, a `LayoutSnap` picks between them, and the chosen one decides both
+ *  the preview and the committed poses. */
 interface DropTarget<TPose> {
     /** Where the dragged child lands if this target is picked. */
     pose: TPose;
@@ -33,16 +38,22 @@ interface DropTarget<TPose> {
     /** Strategy-private metadata (e.g. cell coords for tile-grid). */
     meta?: unknown;
 }
+/** Chooses which of a strategy's drop targets the pointer means, or `null`
+ *  to reject the drop. Separate from the strategy so the same arrangement can
+ *  be paired with different snapping rules. */
 interface LayoutSnap<TPose> {
     pickTarget(targets: DropTarget<TPose>[], pointer: {
         x: number;
         y: number;
     }): DropTarget<TPose> | null;
 }
+/** The container a layout strategy is arranging children within. */
 interface LayoutContainer {
     id: string;
     bounds: ContainerBounds;
 }
+/** The child currently being dragged: where it started, where the pointer
+ *  currently proposes it goes, and which container it came from. */
 interface LayoutDragged<TPose> {
     id: string;
     /** The pose the dragged child currently has (pre-drop). */
@@ -51,6 +62,15 @@ interface LayoutDragged<TPose> {
     pose: TPose;
     sourceContainerId: string | null;
 }
+/**
+ * How a container arranges its children, and what happens when one is dragged
+ * into or around it.
+ *
+ * The four required methods cover the whole cycle: `childPoses` is the resting
+ * arrangement, `getDropTargets` enumerates where a drag could land,
+ * `reflowPoses` is the live preview once a target is picked, and `commitDrop`
+ * turns the result into ops so the drop is undoable.
+ */
 interface LayoutStrategy<TPose> {
     childPoses(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>): Map<string, TPose>;
     getDropTargets(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, dragged: LayoutDragged<TPose>): DropTarget<TPose>[];

package/dist/{types-Kh_osAq9.d.ts → types-vqxpCFVp.d.ts}

@@ -80,9 +80,13 @@ interface NodeBase<TData, TLayer extends string, TPose> {
     data: TData;
     parent: NodeId | null;
 }
+/** A node with no children — a shape, a label, an image. */
 interface LeafNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
     kind: 'leaf';
 }
+/** A node with an ordered list of children. This is the real group: what
+ *  Cmd+G creates, what SVG `<g>` round-trips to. A container has its own pose,
+ *  which its children's poses are relative to, and may optionally clip them. */
 interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends NodeBase<TData, TLayer, TPose> {
     kind: 'container';
     children: NodeId[];
@@ -93,20 +97,30 @@ interface ContainerNode<TData, TLayer extends string, TPose = RectPose> extends
      *  paints descendants only where it covers. */
     clipFromPose?: (pose: TPose) => Path | null;
 }
+/** A node in the scene tree: either a leaf or a container. Re-exported
+ *  publicly as `SceneNode`, to avoid colliding with the DOM's `Node`. */
 type Node<TData, TLayer extends string, TPose = RectPose> = LeafNode<TData, TLayer, TPose> | ContainerNode<TData, TLayer, TPose>;
 interface LayerRecordBase<TLayer extends string> {
     id: TLayer;
     visible: boolean;
     locked: boolean;
 }
+/** A layer declared when the scene was created. Fixed set, no display name —
+ *  these are the kit's own render bands, not something a user manages. */
 interface SystemLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
     kind: 'system';
 }
+/** A layer the user created and can rename, reorder or delete. */
 interface UserLayerRecord<TLayer extends string> extends LayerRecordBase<TLayer> {
     kind: 'user';
     name: string;
 }
+/** Per-layer metadata held by the scene: whether it is visible and locked,
+ *  and where it sits in the render stack. Distinct from a node's `layer` tag,
+ *  which merely names one of these. */
 type LayerRecord<TLayer extends string> = SystemLayerRecord<TLayer> | UserLayerRecord<TLayer>;
+/** What `Scene.add` needs to mint a node. Everything except the id is
+ *  required; the id is generated unless one is supplied. */
 interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
     kind: 'leaf' | 'container';
     layer: TLayer;
@@ -120,10 +134,13 @@ interface AddNodeSpec<TData, TLayer extends string, TPose = RectPose> {
      *  to the node; ignored for leaves. Mirrors `ContainerNode.clipFromPose`. */
     clipFromPose?: (pose: TPose) => Path | null;
 }
+/** A custom scene mutation registered with `Scene.registerOp`: how to apply
+ *  it and how to undo it. The pair is what makes it participate in history. */
 interface RegisteredOp<P> {
     apply: (payload: P) => void;
     revert: (payload: P) => void;
 }
+/** One of the layers a scene is created with. */
 interface SystemLayerSpec<TLayer extends string> {
     id: TLayer;
     visible?: boolean;
@@ -171,6 +188,8 @@ interface SceneRegistry<TPose> {
     /** Maps registry keys to `clipFromPose` factory functions for container nodes. */
     clipFromPose?: Readonly<Record<string, (pose: TPose) => Path | null>>;
 }
+/** Options for `useScene` — the layers the scene has, what it starts out
+ *  holding, and how its history behaves. */
 interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
     systemLayers: readonly SystemLayerSpec<TLayer>[];
     initial?: readonly AddNodeSpec<TData, TLayer, TPose>[];
@@ -204,6 +223,18 @@ interface UseSceneOptions<TData, TLayer extends string, TPose = RectPose> {
      *  wire it after construction via `scene.setActiveJournalAccessor(fn)`. */
     getActiveJournal?: () => _weasel_js_history.Journal | null;
 }
+/**
+ * The kit-owned scene tree: nodes, layers, and the undo history over both.
+ *
+ * A scene is logical, not visual — it says what exists and where, and nothing
+ * about how it is painted. Every mutating method is undoable, and reads are
+ * snapshots rather than live views. Nodes are addressed by `NodeId`; hold ids
+ * across mutations, not node objects.
+ *
+ * Three type parameters keep it domain-agnostic: `TData` is the app's payload,
+ * which the kit never inspects; `TPose` is the transform shape, `RectPose` by
+ * default; `TLayer` is the union of layer names.
+ */
 interface Scene<TData, TLayer extends string, TPose = RectPose> {
     readonly nodes: ReadonlyMap<NodeId, Node<TData, TLayer, TPose>>;
     readonly roots: readonly NodeId[];

package/dist/{viewToMat3-BvaWCN99.d.ts → viewToMat3-CQW_YqDw.d.ts}

@@ -1,4 +1,4 @@
-import { M as Mat3 } from './DrawCommand-DCmiNkBj.js';
+import { M as Mat3 } from './DrawCommand-BbPrSTra.js';
 
 /**
  * GL texture upload cache for ImageBitmap objects.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -74,11 +74,11 @@
     "react": ">=18"
   },
   "dependencies": {
-    "@weasel-js/font": "1.0.2",
-    "@weasel-js/geom": "1.0.2",
-    "@weasel-js/gestures": "1.0.2",
-    "@weasel-js/history": "1.0.2",
-    "@weasel-js/modes": "1.0.2",
+    "@weasel-js/font": "1.0.4",
+    "@weasel-js/geom": "1.0.4",
+    "@weasel-js/gestures": "1.0.4",
+    "@weasel-js/history": "1.0.4",
+    "@weasel-js/modes": "1.0.4",
     "earcut": "2.2.4",
     "polygon-clipping": "^0.15.7"
   },

package/dist/chunk-6SHZHXXR.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/units.ts","../src/core/geometry/path.ts","../src/features/paths/bounds.ts","../src/features/paths/flatten.ts","../src/features/paths/hitTest.ts","../src/features/paths/builder.ts","../src/features/paths/transformPath.ts","../src/features/paths/transform.ts","../src/interactions/actions/resize/geometry.ts","../src/features/paths/poseDescriptor.ts","../src/interactions/actions/resize/autoPoseDescriptor.ts","../src/interactions/gestures/shared/strategies/grid.ts","../src/core/viewport/pxExtent.ts","../src/interactions/gestures/shared/strategies/guides.ts"],"names":["ex","ey","COORD_COUNT"],"mappings":"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","file":"chunk-6SHZHXXR.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 * Linear factors only. No per-axis 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/** Conversion table mapping unit names to factors 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  /** Factor to multiply a value in `unit` by to get base units. base unit's factor is 1. */\n  units: Record<Unit, number>;\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 = unitSystem.units[v.unit];\n  if (factor === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `resolveUnit: unknown unit '${v.unit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  return v.value * factor;\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 = unitSystem.units[displayUnit];\n  if (factor === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `formatUnit: unknown unit '${displayUnit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  const precision = opts?.precision ?? 2;\n  const suffix = opts?.suffix ?? true;\n  const display = baseValue / 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/** 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/** Pixel unit system — sole unit is the base. */\nexport const PIXELS: UnitSystem = {\n  base: 'px',\n  units: { px: 1 },\n};\n","/**\n * Path data model. Vector-graphics primitive used kit-wide as the canonical\n * shape (replacing per-shape ad-hoc poses). SVG-style command stream so we\n * cover lines, polygons, beziers, and multi-contour shapes (think the inner\n * hole of an \"O\") under one type.\n *\n * Storage: command codes in a `Uint8Array`, parameters in a `Float32Array`.\n * Each command consumes a fixed number of float coords from the parameter\n * array; the parser walks both arrays in lockstep. This keeps interaction\n * hot loops monomorphic and keeps GC pressure low under heavy edits.\n *\n * Two path subtypes are distinguished at the type level so common-case\n * machinery (selection AABBs, area-select intersection, hit-testing rect\n * silhouettes) can short-circuit on `RectPath` without paying the polygon\n * kernel cost. Polymorphic kernels accept either via the `Path` union and\n * dispatch on `kind`.\n */\n\n/** Command code: moveTo. */\nexport const PATH_M = 0;\n/** Command code: lineTo. */\nexport const PATH_L = 1;\n/** Command code: cubic bezier (`bezierCurveTo`). */\nexport const PATH_C = 2;\n/** Command code: quadratic bezier (`quadraticCurveTo`). */\nexport const PATH_Q = 3;\n/** Command code: close subpath. */\nexport const PATH_Z = 4;\n\n/** Float coords consumed by each command, indexed by command code. */\nexport const PATH_CMD_LENGTHS: readonly number[] = [2, 2, 6, 4, 0];\n\n/** Fill rule used by polygon path hit-testing and `ctx.fill()`. */\nexport type PathFillRule = 'nonzero' | 'evenodd';\n\n/**\n * Polygon path with arbitrary contours and optional bezier segments.\n * Multi-contour: each `M` opens a new subpath; `Z` closes the current one.\n * Open subpaths (no `Z`) render as polylines and don't contribute to fills.\n */\nexport interface PolygonPath {\n  kind: 'polygon';\n  commands: Uint8Array;\n  coords: Float32Array;\n  fillRule: PathFillRule;\n}\n\n/**\n * Axis-aligned rectangle. Fast path for the (very common) case where the\n * shape is just a rect — preserves O(1) bounds and hit-test, avoids the\n * polygon kernel entirely. Promote to `PolygonPath` only when the shape\n * grows beyond what a rect can express.\n */\nexport interface RectPath {\n  kind: 'rect';\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Canonical path shape — either an axis-aligned rect (fast path) or a polygon command stream. */\nexport type Path = PolygonPath | RectPath;\n","/**\n * AABB bounds of a `Path`. Returned as `RectPath` for direct reuse with the\n * rect fast path machinery (selection AABB, area-select intersection).\n *\n * `RectPath` is its own bounds — O(1). For `PolygonPath`, walk segment by\n * segment, computing the tight bound per segment:\n *\n *   - `M` / `L`: just the endpoint.\n *   - `Q`: quadratic Bezier — endpoints plus axis-aligned extrema (one\n *     possible inflection per axis).\n *   - `C`: cubic Bezier — endpoints plus axis-aligned extrema (up to two\n *     possible inflections per axis, found via the quadratic formula on\n *     the derivative).\n *\n * Control points are NOT included directly; they're used only to compute\n * extrema that actually lie on the curve. This avoids the classic \"AABB\n * extends past where the curve visibly reaches\" bug for curved paths whose\n * control points poke outside the visible extent.\n *\n * Empty paths (no commands) return a zero-size rect anchored at the\n * origin — the convention used elsewhere in the kit for missing geometry.\n */\n\nimport { cubicBounds, elevateQuadraticToCubic } from '@weasel-js/geom';\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type RectPath,\n} from './types';\n\n/** AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery. */\nexport function boundsOfPath(path: Path): RectPath {\n  if (path.kind === 'rect') return path;\n\n  const { commands, coords } = path;\n  if (commands.length === 0) {\n    return { kind: 'rect', x: 0, y: 0, width: 0, height: 0 };\n  }\n\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  let ci = 0;\n  let seen = false;\n  // Pen position carried across segments — needed because curves are\n  // defined relative to the previous endpoint, which is itself the start\n  // of the next segment but not re-encoded in `coords`.\n  let px = 0, py = 0;\n\n  const include = (x: number, y: number) => {\n    if (x < minX) minX = x;\n    if (x > maxX) maxX = x;\n    if (y < minY) minY = y;\n    if (y > maxY) maxY = y;\n    seen = true;\n  };\n\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M:\n      case PATH_L: {\n        const x = coords[ci], y = coords[ci + 1];\n        include(x, y);\n        px = x; py = y;\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, x1, y1, x2, y2, x3, y3);\n        include(bMinX, bMinY);\n        include(bMaxX, bMaxY);\n        px = x3; py = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const qx1 = coords[ci],     qy1 = coords[ci + 1];\n        const qx2 = coords[ci + 2], qy2 = coords[ci + 3];\n        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(px, py, qx1, qy1, qx2, qy2);\n        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, c1x, c1y, c2x, c2y, qx2, qy2);\n        include(bMinX, bMinY);\n        include(bMaxX, bMaxY);\n        px = qx2; py = qy2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z:\n        break;\n      default:\n        throw new Error(`boundsOfPath: unknown command ${cmd}`);\n    }\n  }\n\n  if (!seen) return { kind: 'rect', x: 0, y: 0, width: 0, height: 0 };\n  return { kind: 'rect', x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n","/**\n * Bezier flattening — subdivide cubic and quadratic segments into polyline\n * approximations within a flatness tolerance. Used by hit-testing and\n * (eventually) any kernel that doesn't want to special-case curves.\n *\n * The flatness metric is the maximum perpendicular distance from any\n * control point to the chord between endpoints. When that distance falls\n * below `tolerance`, the segment is \"flat enough\" and emitted as a single\n * line segment.\n *\n * Tolerance is in world units. 0.5 is a sensible default for screen-rate\n * rendering at 1× zoom; consumers that zoom in heavily should pass a\n * tighter tolerance.\n */\n\nexport const DEFAULT_FLATTEN_TOLERANCE = 0.5;\n\n/** Distance from point P to line AB (perpendicular). */\nfunction distPointToLine(px: number, py: number, ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax;\n  const dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) {\n    const ex = px - ax;\n    const ey = py - ay;\n    return Math.sqrt(ex * ex + ey * ey);\n  }\n  const cross = (px - ax) * dy - (py - ay) * dx;\n  return Math.abs(cross) / Math.sqrt(len2);\n}\n\n/**\n * Recursively subdivide a cubic bezier (P0..P3) and append `lineTo`-style\n * vertices to `out` (interleaved x,y). The starting endpoint is *not*\n * appended — callers usually emitted it as the segment's previous vertex.\n */\nexport function flattenCubic(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  x3: number, y3: number,\n  tolerance: number,\n  out: number[],\n): void {\n  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);\n  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);\n  if (Math.max(d1, d2) <= tolerance) {\n    out.push(x3, y3);\n    return;\n  }\n  // De Casteljau split at t=0.5\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;\n  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;\n  flattenCubic(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);\n  flattenCubic(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);\n}\n\n/** Recursively subdivide a quadratic bezier (P0, P1, P2). */\nexport function flattenQuadratic(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  tolerance: number,\n  out: number[],\n): void {\n  const d = distPointToLine(x1, y1, x0, y0, x2, y2);\n  if (d <= tolerance) {\n    out.push(x2, y2);\n    return;\n  }\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  flattenQuadratic(x0, y0, x01, y01, x012, y012, tolerance, out);\n  flattenQuadratic(x012, y012, x12, y12, x2, y2, tolerance, out);\n}\n\n/**\n * Like `flattenCubic` but also appends, for each new flattened point, its\n * arc-length fraction `t` (relative to the polyline distance accumulated so\n * far inside this curve) to `arcOut`. Caller then post-processes the segment's\n * `arcOut` range by dividing each by the segment's total flattened arc length\n * to yield t ∈ (0, 1].\n *\n * The returned values are *cumulative distance from the segment start*, not\n * normalized fractions. Two-pass design (accumulate, then divide) keeps the\n * recursive splitter simple — it doesn't need to know the total length up\n * front.\n */\nexport function flattenCubicWithArcLen(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  x3: number, y3: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n): number {\n  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, 0);\n}\n\nfunction flattenCubicArcRec(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  x3: number, y3: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n  accum: number,\n): number {\n  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);\n  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);\n  if (Math.max(d1, d2) <= tolerance) {\n    const lastX = out.length >= 2 ? out[out.length - 2] : x0;\n    const lastY = out.length >= 2 ? out[out.length - 1] : y0;\n    const seg = Math.hypot(x3 - lastX, y3 - lastY);\n    accum += seg;\n    out.push(x3, y3);\n    arcOut.push(accum);\n    return accum;\n  }\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;\n  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;\n  accum = flattenCubicArcRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out, arcOut, accum);\n  accum = flattenCubicArcRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out, arcOut, accum);\n  return accum;\n}\n\nexport function flattenQuadraticWithArcLen(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n): number {\n  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, 0);\n}\n\nfunction flattenQuadraticArcRec(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n  accum: number,\n): number {\n  const d = distPointToLine(x1, y1, x0, y0, x2, y2);\n  if (d <= tolerance) {\n    const lastX = out.length >= 2 ? out[out.length - 2] : x0;\n    const lastY = out.length >= 2 ? out[out.length - 1] : y0;\n    const seg = Math.hypot(x2 - lastX, y2 - lastY);\n    accum += seg;\n    out.push(x2, y2);\n    arcOut.push(accum);\n    return accum;\n  }\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  accum = flattenQuadraticArcRec(x0, y0, x01, y01, x012, y012, tolerance, out, arcOut, accum);\n  accum = flattenQuadraticArcRec(x012, y012, x12, y12, x2, y2, tolerance, out, arcOut, accum);\n  return accum;\n}\n\n","/**\n * Point-in-path hit-testing. `RectPath` short-circuits to AABB compare\n * (O(1)). `PolygonPath` walks the command stream, flattening any bezier\n * segments to line segments, then runs ray-casting (even-odd) or\n * winding-number (non-zero) per the path's `fillRule`.\n *\n * Open subpaths (no `Z`) are skipped for filled hit-testing — they have\n * no enclosed area. For open polylines (strokes), use `strokeHitTest`\n * which computes point-to-segment distance against the flattened\n * polyline and returns true within a configurable threshold.\n */\n\nimport { flattenCubic, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE } from './flatten';\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n} from './types';\n\n/** Options for `pointInPath`. */\nexport interface PointInPathOptions {\n  /** Bezier flattening tolerance in world units. Default 0.5. */\n  tolerance?: number;\n}\n\n/** Filled-region hit-test for a `Path`. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */\nexport function pointInPath(\n  path: Path,\n  x: number,\n  y: number,\n  opts: PointInPathOptions = {},\n): boolean {\n  if (path.kind === 'rect') {\n    return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;\n  }\n  return pointInPolygonPath(path, x, y, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);\n}\n\nfunction pointInPolygonPath(path: PolygonPath, x: number, y: number, tolerance: number): boolean {\n  const { commands, coords, fillRule } = path;\n  if (commands.length === 0) return false;\n\n  // Walk the command stream; flatten beziers into per-subpath vertex arrays.\n  // For each closed subpath, accumulate winding/crossings against (x, y).\n  let crossings = 0;\n  let winding = 0;\n\n  let subStartX = 0, subStartY = 0;\n  let curX = 0, curY = 0;\n  let subVerts: number[] = []; // flat [x, y, x, y, ...] for current subpath\n  let subOpen = false;\n\n  const flushSubpath = (closed: boolean) => {\n    if (closed && subVerts.length >= 4) {\n      // Close the subpath back to its start.\n      subVerts.push(subStartX, subStartY);\n      // Now subVerts is a closed polyline; tally crossings/winding.\n      for (let i = 0; i < subVerts.length - 2; i += 2) {\n        const ax = subVerts[i],     ay = subVerts[i + 1];\n        const bx = subVerts[i + 2], by = subVerts[i + 3];\n        if (segmentCrossesRayRight(x, y, ax, ay, bx, by)) {\n          crossings++;\n          if (ay <= y && by > y) winding++;\n          else if (by <= y && ay > y) winding--;\n        }\n      }\n    }\n    subVerts = [];\n    subOpen = false;\n  };\n\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M: {\n        if (subOpen) flushSubpath(false);\n        subStartX = coords[ci]; subStartY = coords[ci + 1];\n        curX = subStartX; curY = subStartY;\n        subVerts.push(curX, curY);\n        subOpen = true;\n        ci += 2;\n        break;\n      }\n      case PATH_L: {\n        curX = coords[ci]; curY = coords[ci + 1];\n        subVerts.push(curX, curY);\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, subVerts);\n        curX = x3; curY = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, subVerts);\n        curX = x2; curY = y2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z: {\n        flushSubpath(true);\n        curX = subStartX; curY = subStartY;\n        break;\n      }\n      default:\n        throw new Error(`pointInPath: unknown command ${cmd}`);\n    }\n  }\n  if (subOpen) flushSubpath(false);\n\n  return fillRule === 'evenodd' ? (crossings & 1) === 1 : winding !== 0;\n}\n\n/**\n * Does the rightward horizontal ray from (x, y) cross segment (ax,ay)→(bx,by)?\n * Standard half-open rule (segments touching from above count, from below\n * don't) — avoids double-counting at shared vertices.\n */\nfunction segmentCrossesRayRight(\n  x: number, y: number,\n  ax: number, ay: number,\n  bx: number, by: number,\n): boolean {\n  if ((ay > y) === (by > y)) return false;\n  const xCross = ax + ((y - ay) / (by - ay)) * (bx - ax);\n  return x < xCross;\n}\n\n/** Options for {@link strokeHitTest}. */\nexport interface StrokeHitTestOptions {\n  /** Bezier flattening tolerance in world units. Default 0.5. */\n  tolerance?: number;\n}\n\n/**\n * Stroke-distance hit-test. Returns true when (x, y) lies within\n * `threshold` world units of the path's outline — i.e. when a stroke\n * of total width `2 * threshold` drawn along the path would cover the\n * point.\n *\n * Works for both closed and open subpaths — unlike {@link pointInPath},\n * which only tests filled regions. Use this for picking on open\n * polylines / curves and for adding stroke-clickability to closed\n * shapes (logical OR with `pointInPath` when both behaviors are\n * desired).\n *\n * `threshold` is typically the stroke's half-width plus a small slop\n * (e.g. `strokeWidth / 2 + 4`). Cap segments are approximated by the\n * threshold radius around each anchor — the test treats every flattened\n * segment as a capsule of width `2 * threshold`.\n */\nexport function strokeHitTest(\n  path: Path,\n  x: number,\n  y: number,\n  threshold: number,\n  opts: StrokeHitTestOptions = {},\n): boolean {\n  const t2 = threshold * threshold;\n  if (path.kind === 'rect') {\n    const { x: rx, y: ry, width: w, height: h } = path;\n    return (\n      pointSegmentDist2(x, y, rx, ry, rx + w, ry) <= t2\n      || pointSegmentDist2(x, y, rx + w, ry, rx + w, ry + h) <= t2\n      || pointSegmentDist2(x, y, rx + w, ry + h, rx, ry + h) <= t2\n      || pointSegmentDist2(x, y, rx, ry + h, rx, ry) <= t2\n    );\n  }\n  return polylineWithinThreshold(path, x, y, t2, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);\n}\n\nfunction polylineWithinThreshold(\n  path: PolygonPath,\n  px: number, py: number,\n  t2: number,\n  tolerance: number,\n): boolean {\n  const { commands, coords } = path;\n  if (commands.length === 0) return false;\n\n  // Reuse pointInPath's command-stream + flatten walk; check distance from\n  // (px, py) to each emitted segment instead of accumulating crossings.\n  let subStartX = 0, subStartY = 0;\n  let curX = 0, curY = 0;\n  let subVerts: number[] = [];\n  let subOpen = false;\n\n  const checkSegments = (closed: boolean): boolean => {\n    if (closed && subVerts.length >= 4) subVerts.push(subStartX, subStartY);\n    for (let i = 0; i < subVerts.length - 2; i += 2) {\n      if (pointSegmentDist2(px, py, subVerts[i], subVerts[i + 1], subVerts[i + 2], subVerts[i + 3]) <= t2) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M: {\n        if (subOpen) {\n          if (checkSegments(false)) return true;\n          subVerts = [];\n        }\n        subStartX = coords[ci]; subStartY = coords[ci + 1];\n        curX = subStartX; curY = subStartY;\n        subVerts.push(curX, curY);\n        subOpen = true;\n        ci += 2;\n        break;\n      }\n      case PATH_L: {\n        curX = coords[ci]; curY = coords[ci + 1];\n        subVerts.push(curX, curY);\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, subVerts);\n        curX = x3; curY = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, subVerts);\n        curX = x2; curY = y2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z: {\n        if (checkSegments(true)) return true;\n        subVerts = [];\n        subOpen = false;\n        curX = subStartX; curY = subStartY;\n        break;\n      }\n      default:\n        throw new Error(`strokeHitTest: unknown command ${cmd}`);\n    }\n  }\n  if (subOpen && checkSegments(false)) return true;\n  return false;\n}\n\n/** Squared distance from (px, py) to the closest point on segment (ax,ay)→(bx,by). */\nfunction pointSegmentDist2(\n  px: number, py: number,\n  ax: number, ay: number,\n  bx: number, by: number,\n): number {\n  const dx = bx - ax;\n  const dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) {\n    const ex = px - ax, ey = py - ay;\n    return ex * ex + ey * ey;\n  }\n  let t = ((px - ax) * dx + (py - ay) * dy) / len2;\n  if (t < 0) t = 0; else if (t > 1) t = 1;\n  const cx = ax + t * dx;\n  const cy = ay + t * dy;\n  const ex = px - cx, ey = py - cy;\n  return ex * ex + ey * ey;\n}\n","/**\n * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`\n * encoding behind move/line/curve/close calls and a final `build()`. Use\n * this to construct paths in tests and demos; production callers that need\n * to mutate large paths in place should reach for the raw arrays directly.\n *\n * Numeric capacity grows by doubling — typical for amortized O(1) push.\n *\n * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common\n * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.\n */\n\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type PathFillRule,\n  type PolygonPath,\n  type RectPath,\n} from './types';\n\n/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */\nexport class PathBuilder {\n  private cmds: number[] = [];\n  private xs: number[] = [];\n  private fillRule: PathFillRule = 'nonzero';\n\n  /** Seed a builder with an existing `PolygonPath`. Useful for extending\n   *  an in-flight path with another segment (e.g. appending a cubic to\n   *  the end of a curve in response to a user action) without hand-\n   *  reaching into the `commands` / `coords` typed arrays.\n   *\n   *  ```ts\n   *  const next = PathBuilder.fromPath(current).curveTo(...).build();\n   *  ```\n   */\n  static fromPath(path: PolygonPath): PathBuilder {\n    const b = new PathBuilder();\n    b.cmds = Array.from(path.commands);\n    b.xs = Array.from(path.coords);\n    b.fillRule = path.fillRule;\n    return b;\n  }\n\n  setFillRule(rule: PathFillRule): this {\n    this.fillRule = rule;\n    return this;\n  }\n\n  moveTo(x: number, y: number): this {\n    this.cmds.push(PATH_M);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  lineTo(x: number, y: number): this {\n    this.cmds.push(PATH_L);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */\n  curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this {\n    this.cmds.push(PATH_C);\n    this.xs.push(x1, y1, x2, y2, x, y);\n    return this;\n  }\n\n  /** Quadratic bezier to (x, y) with control point (x1, y1). */\n  quadTo(x1: number, y1: number, x: number, y: number): this {\n    this.cmds.push(PATH_Q);\n    this.xs.push(x1, y1, x, y);\n    return this;\n  }\n\n  close(): this {\n    this.cmds.push(PATH_Z);\n    return this;\n  }\n\n  build(): PolygonPath {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(this.cmds),\n      coords: new Float32Array(this.xs),\n      fillRule: this.fillRule,\n    };\n  }\n}\n\n/** Construct a `RectPath` (the fast-path subtype). */\nexport function rectPath(x: number, y: number, width: number, height: number): RectPath {\n  return { kind: 'rect', x, y, width, height };\n}\n\n/** Build a closed polygon from a flat list of points. */\nexport function polygonFromPoints(\n  points: readonly { x: number; y: number }[],\n  opts: { fillRule?: PathFillRule } = {},\n): PolygonPath {\n  if (points.length === 0) {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(),\n      coords: new Float32Array(),\n      fillRule: opts.fillRule ?? 'nonzero',\n    };\n  }\n  const b = new PathBuilder();\n  if (opts.fillRule) b.setFillRule(opts.fillRule);\n  b.moveTo(points[0].x, points[0].y);\n  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);\n  b.close();\n  return b.build();\n}\n\n/** Cubic-Bezier kappa for circular-quadrant approximation (<1% max error). */\nconst ELLIPSE_KAPPA = 0.5522847498307936;\n\n/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.\n *  Matches the geometry `useEllipseTool`'s overlay paints. */\nexport function ellipsePath(\n  bounds: { x: number; y: number; width: number; height: number },\n): PolygonPath {\n  const cx = bounds.x + bounds.width / 2;\n  const cy = bounds.y + bounds.height / 2;\n  const rx = bounds.width / 2;\n  const ry = bounds.height / 2;\n  const ox = rx * ELLIPSE_KAPPA;\n  const oy = ry * ELLIPSE_KAPPA;\n  const b = new PathBuilder();\n  b.moveTo(cx + rx, cy);\n  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);\n  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);\n  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);\n  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);\n  b.close();\n  return b.build();\n}\n\n/** Closed regular n-gon centered at `center`, circumscribed by `radius`.\n *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */\nexport function regularPolygonPath(\n  center: { x: number; y: number },\n  radius: number,\n  sides: number,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  for (let i = 0; i < sides; i++) {\n    const a = rotation + (i / sides) * Math.PI * 2;\n    const x = center.x + radius * Math.cos(a);\n    const y = center.y + radius * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Closed n-pointed star centered at `center`, alternating `outerRadius` and\n *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */\nexport function starPath(\n  center: { x: number; y: number },\n  outerRadius: number,\n  points = 5,\n  innerRadius: number = outerRadius / 2,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  const n = points * 2;\n  for (let i = 0; i < n; i++) {\n    const a = rotation + (i / n) * Math.PI * 2;\n    const r = i % 2 === 0 ? outerRadius : innerRadius;\n    const x = center.x + r * Math.cos(a);\n    const y = center.y + r * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */\nexport function linePath(\n  a: { x: number; y: number },\n  b: { x: number; y: number },\n): PolygonPath {\n  const pb = new PathBuilder();\n  pb.moveTo(a.x, a.y);\n  pb.lineTo(b.x, b.y);\n  return pb.build();\n}\n","import { type Mat3, transformCoords } from '@weasel-js/geom';\nimport { PathBuilder } from './builder';\nimport { type Path, type PolygonPath } from './types';\n\n/** Apply an affine `Mat3` to a path's geometry.\n *\n * Axis-aligned maps (no rotation/shear, i.e. `m[1] === 0 && m[2] === 0`) keep a\n * `RectPath` a rect — the four corners stay axis-aligned, so we transform the\n * two diagonal corners and normalize negative extent (mirror). Rotation or\n * shear promotes the rect's four corners to a `PolygonPath`. Polygon paths map\n * every coord via the kernel's `transformCoords`, preserving the command stream\n * and `fillRule`. Never mutates the input.\n *\n * `Mat3` here is the 6-tuple `number[]` from `@weasel-js/geom` (DOMMatrix order:\n * `[a, b, c, d, e, f]` where `x' = a·x + c·y + e`, `y' = b·x + d·y + f`),\n * not the renderer's 9-element `Float32Array`. */\nexport function transformPath(path: Path, m: Mat3): Path {\n  const [a, b, c, d, e, f] = m;\n  if (path.kind === 'rect') {\n    if (b === 0 && c === 0) {\n      // Pure scale + translate — corners remain axis-aligned.\n      const x0 = a * path.x + e;\n      const y0 = d * path.y + f;\n      const x1 = a * (path.x + path.width) + e;\n      const y1 = d * (path.y + path.height) + f;\n      return {\n        kind: 'rect',\n        x: Math.min(x0, x1),\n        y: Math.min(y0, y1),\n        width: Math.abs(x1 - x0),\n        height: Math.abs(y1 - y0),\n      };\n    }\n    // Rotation / shear — promote to polygon with the four rect corners.\n    const poly = new PathBuilder()\n      .moveTo(path.x, path.y)\n      .lineTo(path.x + path.width, path.y)\n      .lineTo(path.x + path.width, path.y + path.height)\n      .lineTo(path.x, path.y + path.height)\n      .close()\n      .build();\n    return transformPolygon(poly, m);\n  }\n  return transformPolygon(path, m);\n}\n\nfunction transformPolygon(path: PolygonPath, m: Mat3): PolygonPath {\n  // transformCoords returns Float64Array; PolygonPath.coords is Float32Array.\n  const mapped = transformCoords(path.coords, m);\n  return { ...path, coords: Float32Array.from(mapped) };\n}\n","/**\n * In-place and copy-out path transforms. Translation is the most common —\n * called every pointermove during a drag — so the polygon variant mutates\n * the float buffer directly to keep allocation pressure off the GC.\n *\n * `scalePathToBounds` is for the resize interaction: given the path's\n * current AABB and the desired new AABB, scales every coordinate\n * proportionally. Degenerate source bounds (zero width/height) collapse\n * the corresponding axis to the new origin — preferable to dividing by\n * zero or refusing to resize.\n */\n\nimport { boxToBox } from '@weasel-js/geom';\nimport { boundsOfPath } from './bounds';\nimport { transformPath } from './transformPath';\nimport { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type Path, type PolygonPath, type RectPath } from './types';\n\n/**\n * Translate a path by (dx, dy). Returns a new instance — the kit's pose\n * model treats poses as immutable to keep React state-update semantics\n * predictable. Polygon coords are copied into a fresh `Float32Array`.\n */\nexport function translatePath(path: Path, dx: number, dy: number): Path {\n  if (path.kind === 'rect') {\n    return { kind: 'rect', x: path.x + dx, y: path.y + dy, width: path.width, height: path.height };\n  }\n  return translatePolygonCopy(path, dx, dy);\n}\n\nfunction translatePolygonCopy(path: PolygonPath, dx: number, dy: number): PolygonPath {\n  const next = new Float32Array(path.coords.length);\n  const { commands, coords } = path;\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const len = COORD_COUNT[commands[i]];\n    for (let k = 0; k < len; k += 2) {\n      next[ci + k] = coords[ci + k] + dx;\n      next[ci + k + 1] = coords[ci + k + 1] + dy;\n    }\n    ci += len;\n  }\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\n/**\n * Translate a polygon path's coords *in place*. Returns the same\n * `PolygonPath` reference. Use only for transient overlay buffers — never\n * for committed scene state, which must remain immutable for React.\n */\nexport function translatePolygonInPlace(path: PolygonPath, dx: number, dy: number): PolygonPath {\n  const { commands, coords } = path;\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const len = COORD_COUNT[commands[i]];\n    for (let k = 0; k < len; k += 2) {\n      coords[ci + k] += dx;\n      coords[ci + k + 1] += dy;\n    }\n    ci += len;\n  }\n  return path;\n}\n\n/**\n * Scale a path's coords so its current AABB maps to `target`. Resize\n * interactions use this to make a polygon follow a corner-handle drag.\n *\n * Degenerate source axes (width or height == 0) collapse to `target.x` /\n * `target.y` — every coord on that axis becomes the new origin. Avoids\n * division by zero without throwing.\n */\nexport function scalePathToBounds(path: Path, target: RectPath): Path {\n  if (path.kind === 'rect') {\n    return { kind: 'rect', x: target.x, y: target.y, width: target.width, height: target.height };\n  }\n  const src = boundsOfPath(path);\n  return scalePolygon(path, src, target);\n}\n\nfunction scalePolygon(path: PolygonPath, src: RectPath, dst: RectPath): PolygonPath {\n  const m = boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height);\n  // src/dst are axis-aligned, so the polygon stays a polygon after this pure scale+translate.\n  return transformPath(path, m) as PolygonPath;\n}\n\nconst COORD_COUNT: Readonly<Record<number, number>> = {\n  [PATH_M]: 2,\n  [PATH_L]: 2,\n  [PATH_C]: 6,\n  [PATH_Q]: 4,\n  [PATH_Z]: 0,\n};\n","import type { ResizePose, RotatedPose } from '../../gestures/types';\n\n/**\n * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.\n * The hook reads bounds via `getBounds`, runs anchor-relative math on those\n * bounds, then asks `remapBounds` to project the result back into TPose.\n *\n * `remapBounds(pose, src, dst)` is a single operation that subsumes both\n * \"set my own AABB to dst\" (single-leaf resize) and \"scale me as a leaf\n * inside parent's src→dst rect\" (group resize) — they're the same affine\n * map. For rect-shaped poses the default geometry interprets the pose as\n * its own bounds; for Path or polygon poses the consumer supplies a\n * projection that knows how to read and rewrite the underlying geometry.\n */\nexport interface PoseProjection<TPose> {\n  getBounds(pose: TPose): ResizePose;\n  remapBounds(pose: TPose, src: ResizePose, dst: ResizePose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** True iff any portion of the pose's geometry intersects `rect`. Optional\n   *  — when omitted, area-select and similar callers test against `getBounds`\n   *  AABB (looser, but correct for axis-aligned rect poses). */\n  intersectsRect?(pose: TPose, rect: ResizePose): boolean;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted — descriptor\n   *  declares \"this pose has no rotation.\" When supplied and non-zero,\n   *  `useResize` projects the drag delta into the leaf's local frame,\n   *  runs anchor math there, and translates the resulting pose so the\n   *  diagonally opposite world-space corner is pinned. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation. Consulted by the\n   *  rotation affordance to decide whether to render the rotate cursor /\n   *  drag-band over a selection. When omitted, the kit assumes `true` for\n   *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`\n   *  fields (e.g. polygon Paths) should return `false` so the affordance\n   *  hides instead of exposing a non-functional rotate cursor. */\n  supportsRotation?(pose: TPose): boolean;\n}\n\n/** AABB-vs-AABB overlap. Exported for callers building a default\n *  `intersectsRect` from `getBounds`. */\nexport function aabbIntersectsRect(b: ResizePose, r: ResizePose): boolean {\n  return b.x < r.x + r.width && b.x + b.width > r.x && b.y < r.y + r.height && b.y + b.height > r.y;\n}\n\n/** Identity geometry for `TPose extends ResizePose`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseProjection<ResizePose> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  intersectsRect: (p, r) => aabbIntersectsRect(p, r),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n};\n\n/** Identity geometry for `RotatedPose`. Inherits rect-shape projection\n *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends ResizePose`\n *  subtype lets the rect descriptor's methods apply directly; `remapBounds`\n *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so\n *  `useResize` knows to take the rotation-aware math path. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseProjection<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseProjection<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseProjection<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseProjection<RotatedPose>['translate'],\n  intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect as PoseProjection<RotatedPose>['intersectsRect'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseProjection<RotatedPose>['lerp'],\n  getRotation: (p) => p.rotation,\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are already expressed in the leaf's own frame — the\n * single-leaf resize path, where the drag delta was projected into that frame\n * before the anchor math ran. In a group resize they are world-frame, so the\n * leaf's local axes do not line up with the axes being scaled: at 90° a\n * horizontal stretch should grow the leaf's `height`, and the naive map grows\n * its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model is `{x, y, width, height, rotation}`\n * and cannot represent the parallelogram a non-uniform scale of a rotated box\n * actually produces. The centre moves exactly; each local axis takes the\n * length of its own image; the rotation follows the image of the local x-axis.\n *\n * Degenerates to the naive map at `rotation === 0`, and to a plain uniform\n * scale when `sx === sy`, both exactly.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: ResizePose,\n  dst: ResizePose,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The centre is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n","import { boundsOfPath } from './bounds';\nimport { pointInPath } from './hitTest';\nimport { translatePath } from './transform';\nimport { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type Path, type PolygonPath } from './types';\nimport { aabbIntersectsRect, type PoseProjection } from 'interactions/actions/resize/geometry';\nimport type { ResizePose } from 'interactions/gestures/types';\n\n/**\n * `PoseProjection` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses; `remapBounds` does an affine scale of every\n * coord against `src`/`dst`. Degenerate axes (zero src extent) collapse to\n * the new origin so resize from a flat edge doesn't produce NaN.\n *\n * Mirrors `scalePathToBounds` but takes `src` explicitly: the resize hook\n * knows the group's origin AABB and uses it for every leaf, instead of\n * each leaf scaling against its own AABB (which would ignore group context).\n */\nexport const pathPoseDescriptor: PoseProjection<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => {\n    const sx = src.width === 0 ? 0 : dst.width / src.width;\n    const sy = src.height === 0 ? 0 : dst.height / src.height;\n    if (path.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: dst.x + (path.x - src.x) * sx,\n        y: dst.y + (path.y - src.y) * sy,\n        width: path.width * sx,\n        height: path.height * sy,\n      };\n    }\n    return remapPolygon(path, src, dst, sx, sy);\n  },\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  // WHY: AABB pre-test is cheap; only fall through to per-corner pointInPath\n  //      when the rect is fully inside the AABB (silhouette test).\n  intersectsRect: (path, rect) => {\n    const b = boundsOfPath(path);\n    if (!aabbIntersectsRect(b, rect)) return false;\n    if (path.kind === 'rect') return true;\n    // Sample the rect's four corners; any inside the polygon ⇒ overlap.\n    if (\n      pointInPath(path, rect.x, rect.y) ||\n      pointInPath(path, rect.x + rect.width, rect.y) ||\n      pointInPath(path, rect.x, rect.y + rect.height) ||\n      pointInPath(path, rect.x + rect.width, rect.y + rect.height)\n    ) return true;\n    // Conservative fallback: AABB overlap counts. Tighter edge-vs-edge test\n    // would be the next step; defer until a demo demands it.\n    return true;\n  },\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { kind: 'polygon', commands: a.commands, coords: next, fillRule: a.fillRule };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n\nfunction remapPolygon(path: PolygonPath, src: ResizePose, dst: ResizePose, sx: number, sy: number): PolygonPath {\n  const next = new Float32Array(path.coords.length);\n  const { commands, coords } = path;\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const len = COORD_COUNT[commands[i]];\n    for (let k = 0; k < len; k += 2) {\n      next[ci + k] = dst.x + (coords[ci + k] - src.x) * sx;\n      next[ci + k + 1] = dst.y + (coords[ci + k + 1] - src.y) * sy;\n    }\n    ci += len;\n  }\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\nconst COORD_COUNT: Readonly<Record<number, number>> = {\n  [PATH_M]: 2,\n  [PATH_L]: 2,\n  [PATH_C]: 6,\n  [PATH_Q]: 4,\n  [PATH_Z]: 0,\n};\n","import type { Path } from 'features/paths/types';\nimport { pathPoseDescriptor } from 'features/paths/poseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseProjection } from './geometry';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire `geometry`\n *  explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `geometry={pathPoseDescriptor}` explicitly.\n *  `getRotation` surfaces a `pose.rotation` field on non-Path poses so demos\n *  using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to wire\n *  `geometry={ROTATED_POSE_DESCRIPTOR}` just to get rotated selection chrome\n *  and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseProjection<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  intersectsRect: (p, rect) => isPathLike(p)\n    ? pathPoseDescriptor.intersectsRect!(p, rect)\n    : RECT_POSE_DESCRIPTOR.intersectsRect!(p as { x: number; y: number; width: number; height: number }, rect),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\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>;\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; debug?: DebugSink },\n): SnapStrategy<TPose>;\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/** Guard against a degenerate axis: a zero scale would send the extent to\n *  infinity and make every point a hit. */\nconst MIN_SCALE = 1e-9;\n\n/** One screen-pixel length as world-space extents, per axis. */\nexport function pxExtent(px: number, scale: Scale2): { x: number; y: number } {\n  return {\n    x: px / Math.max(MIN_SCALE, Math.abs(scale.x)),\n    y: px / Math.max(MIN_SCALE, 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>;\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> & { origin: OriginProjection<TPose> },\n): SnapStrategy<TPose>;\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-IO5Z75X4.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":";AAmBA,IAAI,OAAA,GAAU,CAAA;AACd,IAAI,QAAA,uBAAe,GAAA,EAA0B;AAQtC,SAAS,WAAW,EAAA,EAAiC;AAC1D,EAAA,OAAO,QAAA,CAAS,GAAA,CAAI,EAAE,CAAA,IAAK,IAAA;AAC7B;AAWO,SAAS,gBACd,KAAA,EACe;AACf,EAAA,MAAM,EAAA,GAAK,CAAA,IAAA,EAAO,EAAE,OAAO,CAAA,CAAA;AAC3B,EAAA,QAAA,CAAS,GAAA,CAAI,EAAA,EAAI,EAAE,MAAA,EAAQ,OAAO,CAAA;AAClC,EAAA,OAAO,EAAE,EAAA,EAAG;AACd;;;ACvBO,SAAS,SAAS,IAAA,EAA+B;AACtD,EAAA,IAAI,IAAA,CAAK,IAAA,KAAS,MAAA,EAAW,OAAO,IAAA,CAAK,IAAA;AACzC,EAAA,QAAQ,KAAK,IAAA;AAAM,IACjB,KAAK,OAAA;AAAS,MAAA,OAAO,CAAA;AAAA,IACrB,KAAK,YAAA;AAAc,MAAA,OAAO,CAAA;AAAA,IAC1B,KAAK,MAAA;AAAQ,MAAA,OAAO,CAAA;AAAA,IACpB,KAAK,QAAA;AAAU,MAAA,OAAO,EAAA;AAAA,IACtB;AAAS,MAAA,OAAO,CAAA;AAAA;AAEpB;AAIA,SAAS,WAAW,IAAA,EAA4B;AAC9C,EAAA,IAAI,IAAI,IAAA,GAAO,CAAA;AACf,EAAA,OAAO,MAAM;AACX,IAAA,CAAA,GAAK,IAAI,UAAA,GAAc,CAAA;AACvB,IAAA,IAAI,IAAI,IAAA,CAAK,IAAA,CAAK,IAAK,CAAA,KAAM,EAAA,EAAK,IAAI,CAAC,CAAA;AACvC,IAAA,CAAA,GAAK,CAAA,GAAI,KAAK,IAAA,CAAK,CAAA,GAAK,MAAM,CAAA,EAAI,EAAA,GAAK,CAAC,CAAA,GAAK,CAAA;AAC7C,IAAA,OAAA,CAAA,CAAS,CAAA,GAAK,CAAA,KAAM,EAAA,MAAS,CAAA,IAAK,UAAA;AAAA,EACpC,CAAA;AACF;AAEO,SAAS,aAAa,IAAA,EAAqC;AAChE,EAAA,MAAM,CAAA,GAAI,SAAS,IAAI,CAAA;AACvB,EAAA,MAAM,EAAE,OAAM,GAAI,IAAA;AAElB,EAAA,QAAQ,KAAK,IAAA;AAAM,IACjB,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,KAAA,GAAQ,KAAK,SAAA,IAAa,CAAA;AAChC,MAAA,OAAO,EAAE,MAAM,CAAA,EAAG,MAAA,EAAQ,iBAAiB,CAAA,EAAG,KAAA,EAAO,KAAK,CAAA,EAAE;AAAA,IAC9D;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,MAAM,KAAA,GAAQ,KAAK,SAAA,IAAa,GAAA;AAChC,MAAA,OAAO;AAAA,QACL,IAAA,EAAM,CAAA;AAAA,QACN,MAAA,EAAQ,CAAC,GAAG,gBAAA,CAAiB,CAAA,EAAG,KAAA,EAAO,KAAK,CAAA,EAAG,GAAG,iBAAA,CAAkB,CAAA,EAAG,KAAA,EAAO,KAAK,CAAC;AAAA,OACtF;AAAA,IACF;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,CAAA,GAAI,KAAK,MAAA,IAAU,CAAA;AACzB,MAAA,OAAO,EAAE,IAAA,EAAM,CAAA,EAAG,MAAA,EAAQ,CAAC,EAAE,IAAA,EAAM,QAAA,EAAU,EAAA,EAAI,CAAA,GAAI,GAAG,EAAA,EAAI,CAAA,GAAI,GAAG,CAAA,EAAG,KAAA,EAAO,CAAA,EAAE;AAAA,IACjF;AAAA,IACA,KAAK,QAAA,EAAU;AACb,MAAA,MAAM,OAAA,GAAU,KAAK,OAAA,IAAW,IAAA;AAChC,MAAA,MAAM,SAAA,GAAY,KAAK,SAAA,IAAa,CAAA;AACpC,MAAA,MAAM,IAAA,GAAO,UAAA,CAAW,IAAA,CAAK,IAAA,IAAQ,EAAE,CAAA;AACvC,MAAA,MAAM,QAAQ,IAAA,CAAK,KAAA,CAAO,IAAI,CAAA,GAAI,OAAA,IAAY,YAAY,SAAA,CAAU,CAAA;AACpE,MAAA,MAAM,SAAsB,EAAC;AAC7B,MAAA,IAAI,IAAA,CAAK,OAAO,MAAA,EAAW;AACzB,QAAA,MAAA,CAAO,IAAA,CAAK,EAAE,IAAA,EAAM,MAAA,EAAQ,GAAG,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,KAAA,EAAO,GAAG,MAAA,EAAQ,CAAA,EAAG,KAAA,EAAO,IAAA,CAAK,IAAI,CAAA;AAAA,MAC/E;AACA,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,KAAA,EAAO,CAAA,EAAA,EAAK;AAC9B,QAAA,MAAM,EAAA,GAAK,MAAK,GAAI,CAAA;AACpB,QAAA,MAAM,EAAA,GAAK,MAAK,GAAI,CAAA;AACpB,QAAA,MAAM,CAAA,GAAI,SAAA,IAAa,GAAA,GAAM,IAAA,EAAK,CAAA;AAClC,QAAA,MAAM,CAAA,GAAI,SAAA,IAAa,GAAA,GAAM,IAAA,EAAK,CAAA;AAClC,QAAA,MAAM,QAAA,GAAW,IAAA,EAAK,GAAI,IAAA,CAAK,EAAA;AAC/B,QAAA,MAAA,CAAO,IAAA,CAAK,EAAE,IAAA,EAAM,SAAA,EAAW,IAAI,EAAA,EAAI,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,QAAA,EAAU,OAAO,CAAA;AAAA,MAChF;AACA,MAAA,OAAO,EAAE,IAAA,EAAM,CAAA,EAAG,MAAA,EAAO;AAAA,IAC3B;AAAA,IACA;AACE,MAAA,OAAO,EAAE,IAAA,EAAM,CAAA,EAAG,MAAA,EAAQ,EAAC,EAAE;AAAA;AAEnC;AAIA,SAAS,gBAAA,CAAiB,CAAA,EAAW,KAAA,EAAe,KAAA,EAA4B;AAC9E,EAAA,OAAO;AAAA,IACL,EAAE,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,IAAI,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,EAAA,EAAI,OAAO,KAAA,EAAM;AAAA,IACnE,EAAE,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,EAAA,EAAI,EAAA,EAAI,CAAA,EAAG,EAAA,EAAI,CAAA,EAAG,EAAA,EAAI,EAAA,EAAI,KAAA,EAAO,KAAA,EAAM;AAAA,IAC3D,EAAE,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,CAAA,GAAI,GAAG,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,IAAI,CAAA,EAAG,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,OAAO,KAAA;AAAM,GAC3E;AACF;AAGA,SAAS,iBAAA,CAAkB,CAAA,EAAW,KAAA,EAAe,KAAA,EAA4B;AAC/E,EAAA,OAAO;AAAA,IACL,EAAE,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,IAAI,EAAA,EAAI,EAAA,EAAI,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,OAAO,KAAA,EAAM;AAAA,IACnE,EAAE,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,IAAI,CAAA,EAAG,EAAA,EAAI,EAAA,EAAI,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,CAAA,EAAG,OAAO,KAAA,EAAM;AAAA,IAClE,EAAE,IAAA,EAAM,MAAA,EAAQ,EAAA,EAAI,IAAI,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,EAAA,EAAI,CAAA,EAAG,EAAA,EAAI,CAAA,GAAI,CAAA,EAAG,OAAO,KAAA;AAAM,GACpE;AACF;AAGO,SAAS,cAAA,CAAe,IAA8B,QAAA,EAA8B;AACzF,EAAA,KAAA,MAAW,KAAA,IAAS,SAAS,MAAA,EAAQ;AACnC,IAAA,IAAI,KAAA,CAAM,SAAS,MAAA,EAAQ;AACzB,MAAA,EAAA,CAAG,cAAc,KAAA,CAAM,KAAA;AACvB,MAAA,EAAA,CAAG,YAAY,KAAA,CAAM,KAAA;AACrB,MAAA,EAAA,CAAG,SAAA,EAAU;AACb,MAAA,EAAA,CAAG,MAAA,CAAO,KAAA,CAAM,EAAA,EAAI,KAAA,CAAM,EAAE,CAAA;AAC5B,MAAA,EAAA,CAAG,MAAA,CAAO,KAAA,CAAM,EAAA,EAAI,KAAA,CAAM,EAAE,CAAA;AAC5B,MAAA,EAAA,CAAG,MAAA,EAAO;AACV,MAAA;AAAA,IACF;AACA,IAAA,EAAA,CAAG,YAAY,KAAA,CAAM,KAAA;AACrB,IAAA,IAAI,KAAA,CAAM,SAAS,MAAA,EAAQ;AACzB,MAAA,EAAA,CAAG,QAAA,CAAS,MAAM,CAAA,EAAG,KAAA,CAAM,GAAG,KAAA,CAAM,KAAA,EAAO,MAAM,MAAM,CAAA;AACvD,MAAA;AAAA,IACF;AACA,IAAA,EAAA,CAAG,SAAA,EAAU;AACb,IAAA,IAAI,KAAA,CAAM,SAAS,QAAA,EAAU;AAC3B,MAAA,EAAA,CAAG,GAAA,CAAI,KAAA,CAAM,EAAA,EAAI,KAAA,CAAM,EAAA,EAAI,MAAM,CAAA,EAAG,CAAA,EAAG,IAAA,CAAK,EAAA,GAAK,CAAC,CAAA;AAAA,IACpD,CAAA,MAAO;AACL,MAAA,EAAA,CAAG,OAAA,CAAQ,KAAA,CAAM,EAAA,EAAI,KAAA,CAAM,IAAI,KAAA,CAAM,EAAA,EAAI,KAAA,CAAM,EAAA,EAAI,KAAA,CAAM,QAAA,EAAU,CAAA,EAAG,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,IACnF;AACA,IAAA,EAAA,CAAG,IAAA,EAAK;AAAA,EACV;AACF;;;ACvGO,SAAS,kBAAkB,IAAA,EAA6C;AAG7E,EAAA,IAAI,GAAA;AACJ,EAAA,IAAI;AACF,IAAA,GAAA,GAAM,IAAI,eAAA,CAAgB,IAAA,CAAK,IAAA,EAAM,KAAK,IAAI,CAAA;AAAA,EAChD,CAAA,CAAA,MAAQ;AACN,IAAA,IAAI,OAAO,QAAA,KAAa,WAAA,EAAa,OAAO,IAAA;AAC5C,IAAA,MAAM,CAAA,GAAI,QAAA,CAAS,aAAA,CAAc,QAAQ,CAAA;AACzC,IAAA,CAAA,CAAE,QAAQ,IAAA,CAAK,IAAA;AACf,IAAA,CAAA,CAAE,SAAS,IAAA,CAAK,IAAA;AAChB,IAAA,GAAA,GAAM,CAAA;AAAA,EACR;AACA,EAAA,MAAM,EAAA,GAAK,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA;AAC9B,EAAA,IAAI,CAAC,IAAI,OAAO,IAAA;AAChB,EAAA,IAAA,CAAK,IAAA,CAAK,EAAA,EAAI,IAAA,CAAK,IAAI,CAAA;AAMvB,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI,OAAQ,GAAA,CAAwB,qBAAA,KAA0B,UAAA,EAAY;AACxE,IAAA,MAAA,GAAU,IAAwB,qBAAA,EAAsB;AAAA,EAC1D,CAAA,MAAO;AACL,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,OAAO,gBAAgB,MAAM,CAAA;AAC/B;;;AClCA,SAAS,MAAM,IAAA,EAA6C;AAC1D,EAAA,MAAM,QAAA,GAAW,aAAa,IAAI,CAAA;AAClC,EAAA,OAAO,iBAAA,CAAkB;AAAA,IACvB,IAAA,EAAM,SAAS,IAAI,CAAA;AAAA,IACnB,IAAA,EAAM,CAAC,EAAA,KAAO,cAAA,CAAe,IAAI,QAAQ;AAAA,GAC1C,CAAA;AACH;AASO,SAAS,MAAM,MAAA,EAA2C;AAC/D,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,OAAA,EAAS,GAAG,QAAQ,CAAA;AAC3C;AASO,SAAS,WAAW,MAAA,EAAgD;AACzE,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,YAAA,EAAc,GAAG,QAAQ,CAAA;AAChD;AASO,SAAS,KAAK,MAAA,EAA0C;AAC7D,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,MAAA,EAAQ,GAAG,QAAQ,CAAA;AAC1C;AAmBO,SAAS,OAAO,MAAA,EAA4C;AACjE,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,QAAA,EAAU,GAAG,QAAQ,CAAA;AAC5C","file":"chunk-IO5Z75X4.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\nexport interface TextureHandle {\n  readonly id: string;\n}\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 '../../core/paint-types';\n\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\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 `../../core/paint-types.ts`).\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 '../../core/paint-types';\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\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\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\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\nexport function chunks(params: ChunksParams): TextureHandle | null {\n  return build({ tile: 'chunks', ...params });\n}\n"]}