@weasel-js/core 1.7.0 → 1.7.2

package/dist/mesh.d.ts

@@ -0,0 +1,268 @@
+import { GradientUnits, ColorSpace, FillStyle, GradStop } from '@weasel-js/paint';
+
+/**
+ * Coons and tensor-product patch surfaces — PDF's shading types 6 and 7, as
+ * pure geometry.
+ *
+ * A patch is a curved quadrilateral: four cubic Bézier edges and a color at
+ * each corner. The interior is what the edges imply — a Coons patch reads it
+ * off the boundary alone; a tensor patch adds four interior control points
+ * that pull it around. Both evaluate at a `(u, v)` in the unit square, which
+ * is what lets the renderer subdivide a patch into as many triangles as it
+ * wants without the patch knowing.
+ *
+ * Nothing here touches GL, a color string, or a scene. `evalPatch` is the
+ * whole contract.
+ */
+/** A point in the patch's own space. */
+interface MeshPoint {
+    x: number;
+    y: number;
+}
+/**
+ * One patch.
+ *
+ * `points` walks the boundary: corner 0, the two control points of the edge
+ * leaving it, corner 1, its two, and so on — twelve points, ending with the
+ * two controls that return to corner 0. A tensor patch appends its four
+ * interior points, in the order `(1,1)`, `(1,2)`, `(2,2)`, `(2,1)` of the
+ * bicubic control net, which is PDF's own order.
+ *
+ * Twelve points is a Coons patch and sixteen is a tensor patch; there is no
+ * flag, because the count already says which it is.
+ *
+ * `colors` are the corner colors in the same walk order, as whatever color
+ * form the caller resolves — the renderer hands premultiplied RGBA in, the
+ * serializer hands CSS strings.
+ */
+interface MeshPatch<TColor = string> {
+    points: readonly MeshPoint[];
+    colors: readonly [TColor, TColor, TColor, TColor];
+}
+/** Corner `i` of the boundary walk. */
+declare function patchCorner(patch: MeshPatch<unknown>, i: number): MeshPoint;
+/** `true` when the patch carries the four interior points a tensor patch adds. */
+declare function isTensorPatch(patch: MeshPatch<unknown>): boolean;
+/** A patch is twelve boundary points, or sixteen with the interior. Anything
+ *  else cannot be evaluated, and saying so here beats painting nonsense. */
+declare function isValidPatch(patch: MeshPatch<unknown>): boolean;
+/**
+ * The patch surface at `(u, v)`, both in `0..1`.
+ *
+ * `u` runs along the edge leaving corner 0 and `v` along the edge leaving
+ * corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and
+ * `(0,1)` corner 3 — the same walk `colors` is in.
+ */
+declare function evalPatch(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint;
+/**
+ * The four corner weights at `(u, v)` — bilinear, in the corner walk order.
+ *
+ * Color is separate from position on purpose: it interpolates in whatever
+ * space the caller chose, which is not a thing the surface can do for it.
+ */
+declare function cornerWeights(u: number, v: number): [number, number, number, number];
+/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone
+ *  bound a Bézier but not tightly, and a mesh paint is baked into a texture
+ *  sized from this — a loose box wastes texels on every side. */
+declare function patchBounds(patch: MeshPatch<unknown>, steps?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+/**
+ * The `mesh-gradient` paint kind — PDF's shading types 6 and 7 as a registered
+ * paint.
+ *
+ * A mesh gradient is a set of curved quadrilateral patches, each with a color
+ * at every corner. It is the paint SVG tried to standardize as
+ * `<meshgradient>` and abandoned, and the one PDF has had since 1993; what it
+ * buys over the three gradients is a color field that bends, so a highlight
+ * can follow a form instead of running straight across it.
+ *
+ * This is a registered kind rather than a sixth branch in the renderer, and
+ * deliberately: it uses only the slots `registerPaintKind` gives a consumer, so
+ * whatever it can do, a consumer's own kind can do too. Its one concession is
+ * living in this package, because that is where the shader registry is.
+ *
+ * `docs/proposals/2026-09-17-paint-kinds-beyond-svg.md` is the design.
+ */
+
+/**
+ * A mesh gradient paint.
+ *
+ * `patches` are in the space `units` names, the same way a gradient's
+ * geometry is — under `'bounds'` every point is a fraction of the painted
+ * node's box, which is what lets the paint survive a resize.
+ *
+ * `interpolate` is the space corner colors blend through, matching the three
+ * gradients. It is more visible here than there: a mesh blends in two
+ * directions at once, so an sRGB blend's muddy middle covers area rather than
+ * a line.
+ */
+interface MeshGradientFill {
+    fill: 'mesh-gradient';
+    patches: MeshPatch[];
+    units?: GradientUnits;
+    interpolate?: ColorSpace;
+    opacity?: number;
+}
+/** The kind's id, as `FillStyle['fill']` carries it. */
+declare const MESH_GRADIENT_KIND = "mesh-gradient";
+/** A mesh paint, narrowed. */
+declare function isMeshGradientFill(fill: FillStyle | null | undefined): fill is FillStyle & MeshGradientFill;
+/** A one-patch square covering the unit box, its four corners four readings of
+ *  `color` — a mesh seeded from a solid has to show *something* curved, or
+ *  switching kind looks like nothing happened. */
+declare function seedMeshPatch(color: string): MeshGradientFill;
+/**
+ * A stop list as a mesh: one full-height band per gap between neighboring
+ * stops, colored left to right. The bands blend exactly the way the ramp
+ * does, so a horizontal gradient survives the switch unchanged. A zero-width
+ * gap is a hard break and gets no band.
+ */
+declare function meshFromStops(stops: readonly GradStop[]): MeshGradientFill;
+/**
+ * A mesh read as a stop list: every patch's top edge — corner 0 to corner 1 —
+ * placed by its `x` across the mesh's horizontal extent. The inverse of
+ * `meshFromStops`, and for any other mesh the ramp across its top.
+ */
+declare function meshStops(mesh: MeshGradientFill): GradStop[];
+/**
+ * The `<defs>` entry for a mesh paint, in weasel's own namespace.
+ *
+ * Not SVG's abandoned `<meshgradient>`: that vocabulary only reaches Coons
+ * patches, shares patch edges implicitly — a reader that gets the sharing
+ * wrong tears the surface rather than failing outright — and has exactly one
+ * implementation in the world. Ours writes every patch's points in full.
+ * `@weasel-js/svg` puts the paint fallback color beside the reference, so a
+ * foreign renderer paints flat instead of nothing.
+ */
+declare function meshGradientXml(id: string, mesh: MeshGradientFill): string;
+
+/**
+ * A mesh paint baked into one RGBA bitmap.
+ *
+ * A patch is a surface over `(u, v)`, but a paint has to answer "what color is
+ * this fragment", which is the inverse question — and inverting a bicubic is
+ * Newton iteration per fragment. Every renderer that draws these instead
+ * subdivides the patch into small quads and rasterizes them forward, which is
+ * what this does, once per paint, into a texture the shader then samples. The
+ * cost is a texture and a resolution; the gain is that the paint composes with
+ * every fill the renderer already knows how to draw, clipping included.
+ *
+ * The bitmap is straight (non-premultiplied) RGBA, matching the ramp atlas;
+ * the fragment shader premultiplies.
+ */
+
+/** Texels on a side of a bake when the caller names no size. The renderer
+ *  sizes each bake from how large the paint draws — see `meshBakeSize`. */
+declare const MESH_BAKE_SIZE = 256;
+/** The box a bake covers, in the paint's own space. */
+interface MeshBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The bitmap `bakeMesh` produces, and the paint-space box it covers. */
+interface BakedMesh {
+    /** `size` × `size` texels, straight RGBA. */
+    pixels: Uint8ClampedArray;
+    /** Texels on a side; `MESH_BAKE_SIZE` unless the caller asked otherwise. */
+    size: number;
+    /** Where the bitmap sits in paint space, which is what the shader maps a
+     *  fragment through. */
+    box: MeshBox;
+}
+/** The union of every patch's bounds, or `null` when nothing is drawable. */
+declare function meshBounds(patches: readonly MeshPatch[]): MeshBox | null;
+/**
+ * Rasterize `patches` into a square bitmap covering their union.
+ *
+ * Returns `null` when no patch is drawable, which is the caller's cue to paint
+ * nothing rather than a blank square.
+ */
+declare function bakeMesh(patches: readonly MeshPatch[], space?: ColorSpace, size?: number): BakedMesh | null;
+
+/**
+ * How large a mesh bake is, and the bounded cache the bakes live in.
+ *
+ * A gradient's ramp is one-dimensional, so 256 texels cover it at any size. A
+ * mesh's bake is two-dimensional and is stretched over whatever the paint
+ * covers, so a fixed size shows its texels once the paint draws large. The
+ * bake is sized from the device pixels it covers instead, in power-of-two
+ * buckets so a zoom inside one bucket reuses the bake it already has.
+ */
+/** The smallest bake: below this a texture costs more in bookkeeping than in
+ *  bytes. */
+declare const MESH_BAKE_MIN = 32;
+/** The largest bake, whatever the context allows: 16 MiB of RGBA, and a bake
+ *  that already takes a noticeable moment on the CPU. */
+declare const MESH_BAKE_MAX = 2048;
+/**
+ * The bake side for a paint drawn `devicePx` device pixels across, on a
+ * context accepting `maxTextureSize`: the next power of two at or above it,
+ * clamped to `[MESH_BAKE_MIN, MESH_BAKE_MAX]` and to the context. A size that
+ * cannot be measured gets `MESH_BAKE_SIZE`.
+ */
+declare function meshBakeSize(devicePx: number, maxTextureSize: number): number;
+
+/**
+ * The draggable points of a mesh paint, as pure geometry — what an on-canvas
+ * editor lists, and what moving one of them does to the paint.
+ *
+ * Nothing here knows a frame: the handles are in whatever space the mesh's
+ * points are, so a caller resolves a `'bounds'` mesh onto its box first
+ * (`fillInPoseFrame`) and normalizes the result back (`fillToBoundsFrame`).
+ */
+
+/** What a handle moves: a patch corner, one of the two controls of an edge,
+ *  or one of a tensor patch's four interior points. */
+type MeshHandleKind = 'corner' | 'control' | 'interior';
+/** One stored point: `patches[patch].points[index]`. */
+interface MeshPointRef {
+    patch: number;
+    index: number;
+}
+/**
+ * One draggable point.
+ *
+ * Patches store their points in full rather than sharing edges, so two
+ * patches that meet each carry a copy of the corner and controls they meet
+ * at. Those copies are one handle, with a `ref` per copy — dragging one of
+ * them alone would tear the surface open along the seam.
+ */
+interface MeshHandle {
+    /** Stable while the handle moves: its first ref, as `"patch:index"`. */
+    id: string;
+    kind: MeshHandleKind;
+    at: MeshPoint;
+    refs: readonly MeshPointRef[];
+}
+/**
+ * Every draggable point of `mesh`, in walk order: each patch's corners and
+ * edge controls, then a tensor patch's interior. Coincident points of one
+ * kind merge into one handle. A patch that cannot be evaluated has none.
+ */
+declare function meshHandles(mesh: MeshGradientFill): MeshHandle[];
+/**
+ * `mesh` with `handle` moved to `to`. A corner carries its edge controls
+ * and interior neighbor along by the same offset, the way a path editor's
+ * anchor carries its handles; a control or interior point moves alone.
+ * Returns a new paint; `mesh` is not modified.
+ */
+declare function moveMeshHandle(mesh: MeshGradientFill, handle: MeshHandle, to: MeshPoint): MeshGradientFill;
+/** The lines an editor draws under the handles, as control polygons. */
+interface MeshGuides {
+    /** Every patch edge as its four cubic control points, from the corner it
+     *  leaves to the corner it reaches. */
+    edges: [MeshPoint, MeshPoint, MeshPoint, MeshPoint][];
+    /** Corner to each point it carries — an edge control or interior point. */
+    arms: [MeshPoint, MeshPoint][];
+}
+/** The guides for `mesh`'s valid patches. Shared edges appear once per patch. */
+declare function meshGuides(mesh: MeshGradientFill): MeshGuides;
+
+export { type BakedMesh, MESH_BAKE_MAX, MESH_BAKE_MIN, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, type MeshBox, type MeshGradientFill, type MeshGuides, type MeshHandle, type MeshHandleKind, type MeshPatch, type MeshPoint, type MeshPointRef, bakeMesh, cornerWeights, evalPatch, isMeshGradientFill, isTensorPatch, isValidPatch, meshBakeSize, meshBounds, meshFromStops, meshGradientXml, meshGuides, meshHandles, meshStops, moveMeshHandle, patchBounds, patchCorner, seedMeshPatch };

package/dist/mesh.js

@@ -0,0 +1,7 @@
+import { cornerWeights as e, evalPatch as t, isTensorPatch as n, isValidPatch as r, patchBounds as i, patchCorner as a } from "./features/meshPaint/surface.js";
+import { MESH_BAKE_SIZE as o, bakeMesh as s, meshBounds as c } from "./features/meshPaint/bake.js";
+import { MESH_BAKE_MAX as l, MESH_BAKE_MIN as u, meshBakeSize as d } from "./features/meshPaint/bakeCache.js";
+import { MESH_GRADIENT_KIND as f, isMeshGradientFill as p, meshFromStops as m, meshGradientXml as h, meshStops as g, seedMeshPatch as _ } from "./features/meshPaint/meshPaint.js";
+import "./features/meshPaint/register.js";
+import { meshGuides as v, meshHandles as y, moveMeshHandle as b } from "./features/meshPaint/handles.js";
+export { l as MESH_BAKE_MAX, u as MESH_BAKE_MIN, o as MESH_BAKE_SIZE, f as MESH_GRADIENT_KIND, s as bakeMesh, e as cornerWeights, t as evalPatch, p as isMeshGradientFill, n as isTensorPatch, r as isValidPatch, d as meshBakeSize, c as meshBounds, m as meshFromStops, h as meshGradientXml, v as meshGuides, y as meshHandles, g as meshStops, b as moveMeshHandle, i as patchBounds, a as patchCorner, _ as seedMeshPatch };

package/dist/move.d.ts

@@ -1,23 +1,10 @@
-import { O as OriginProjection } from './grid-CY5UKlZh.js';
-export { U as UseMoveOptions } from './grid-CY5UKlZh.js';
-import { M as MoveBehavior } from './types-qYpyTAiZ.js';
-import { ModifierState, View } from '@weasel-js/routing';
-import { S as SnapTarget } from './types-D-9QWBy5.js';
-import { G as Guide } from './types-D2tTKEU0.js';
-import '@weasel-js/quantity';
+import { O as OriginProjection } from './originProjection-DEklpDc_.js';
+export { U as UseMoveOptions } from './originProjection-DEklpDc_.js';
+import { S as SnapTarget } from './types-A37hYkeR.js';
+import { M as MoveBehavior } from './types-B_9g6hMM.js';
 import '@weasel-js/history';
-import './path-JEV2c5If.js';
-
-type ModKey$1 = keyof ModifierState;
-/** Move behavior that snaps the dragged pose's origin to a grid. Hold
- *  `bypassKey` to drag freely. */
-declare function snapToGrid<TPose extends {
-    x: number;
-    y: number;
-}>(args: {
-    spacing: number;
-    bypassKey?: ModKey$1;
-}): MoveBehavior<TPose>;
+import '@weasel-js/geom';
+import '@weasel-js/routing';
 
 /**
  * Move behavior that drops the dragged node into a container it hovers over
@@ -59,33 +46,4 @@ declare function snapBackOrDelete<TPose>(args: {
     origin: OriginProjection<TPose>;
 }): MoveBehavior<TPose>;
 
-type ModKey = keyof ModifierState;
-/** Options for the move-flavored `snapToGuides`. */
-interface SnapToGuidesMoveArgs<TPose> {
-    /** Stable getter into the live guide list (typically from `useGuides`). */
-    getGuides: () => readonly Guide[];
-    /** Snap tolerance (screen px when `getView` is set, world units otherwise). */
-    tolerance?: number;
-    /** Read the active view; required for screen-pixel tolerance. */
-    getView?: () => View;
-    /** Modifier key that bypasses snapping while held. */
-    bypassKey?: ModKey;
-    /** Origin projection for non-rect TPose (e.g. Path). */
-    origin?: OriginProjection<TPose>;
-}
-/**
- * Move behavior that snaps the dragged pose's origin to the nearest world-space
- * guide line within `tolerance`. Closest-guide-per-axis wins; the two axes are
- * considered independently. Pair with `useGuides` and `createGuidesLayer`.
- */
-declare function snapToGuides<TPose extends {
-    x: number;
-    y: number;
-}>(args: Omit<SnapToGuidesMoveArgs<TPose>, 'origin'>): MoveBehavior<TPose>;
-/** As above, for a `TPose` that is not a rect: `origin` tells the behavior how
- *  to read and write the pose's origin. */
-declare function snapToGuides<TPose>(args: SnapToGuidesMoveArgs<TPose> & {
-    origin: OriginProjection<TPose>;
-}): MoveBehavior<TPose>;
-
-export { snapBackOrDelete, snapToContainer, snapToGrid, snapToGuides };
+export { snapBackOrDelete, snapToContainer };

package/dist/move.js

@@ -1,142 +1,3 @@
-import { snap, createTransformOp, createReparentOp } from './chunk-XMAWPGTK.js';
-import { gridSnapStrategy, AUTO_ORIGIN_PROJECTION, guideSnapStrategy } from './chunk-LU4IJ52W.js';
-import './chunk-L5YNZYEG.js';
-import { createDeleteOp } from './chunk-NE27EOLP.js';
-import { scratchKey, getScratch, setScratch } from '@weasel-js/routing';
-
-// src/interactions/actions/move/behaviors/snapToGrid.ts
-function snapToGrid(args) {
-  return snap(gridSnapStrategy(args.spacing), { bypassKey: args.bypassKey });
-}
-var STATE = scratchKey("snapToContainer");
-function getState(ctx) {
-  let s = getScratch(ctx.scratch, STATE);
-  if (!s) {
-    s = { pendingTargetId: null, pendingTimer: null, committedSnap: null };
-    setScratch(ctx.scratch, STATE, s);
-  }
-  return s;
-}
-function clearTimer(s) {
-  if (s.pendingTimer !== null) {
-    clearTimeout(s.pendingTimer);
-    s.pendingTimer = null;
-  }
-  s.pendingTargetId = null;
-}
-function snapToContainer(args) {
-  const { dwellMs, findTarget, isInstant, moveLabel = "Move", reparentLabel = "Move and reparent" } = args;
-  return {
-    onMove(ctx, _proposed) {
-      const s = getState(ctx);
-      const target = findTarget(ctx.draggedIds[0], ctx.pointer.worldX, ctx.pointer.worldY);
-      if (s.committedSnap) {
-        if (target && target.parentId === s.committedSnap.parentId) {
-          return { pose: s.committedSnap.slotPose, snap: s.committedSnap };
-        }
-        s.committedSnap = null;
-      }
-      if (!target) {
-        clearTimer(s);
-        return;
-      }
-      if (isInstant?.(target)) {
-        clearTimer(s);
-        s.committedSnap = target;
-        return { pose: target.slotPose, snap: target };
-      }
-      if (s.pendingTargetId === target.parentId) {
-        return;
-      }
-      clearTimer(s);
-      s.pendingTargetId = target.parentId;
-      s.pendingTimer = setTimeout(() => {
-        s.committedSnap = target;
-        s.pendingTimer = null;
-      }, dwellMs);
-      return;
-    },
-    onEnd(ctx) {
-      const s = getState(ctx);
-      clearTimer(s);
-      const snap2 = s.committedSnap ?? ctx.snap;
-      if (!snap2) return;
-      const draggedId = ctx.draggedIds[0];
-      const oldParent = ctx.adapter.getParent?.(draggedId) ?? null;
-      const fromPose = ctx.origin.get(draggedId);
-      const ops = [
-        createTransformOp({
-          id: draggedId,
-          from: fromPose,
-          to: snap2.slotPose,
-          label: moveLabel
-        })
-      ];
-      if (oldParent !== snap2.parentId) {
-        ops.push(createReparentOp({
-          id: draggedId,
-          fromParentId: oldParent,
-          toParentId: snap2.parentId,
-          label: reparentLabel
-        }));
-      }
-      return ops;
-    }
-  };
-}
-var SNAPSHOTS = scratchKey("snapBackOrDelete.snapshots");
-var INDEXES = scratchKey("snapBackOrDelete.indexes");
-function snapBackOrDelete(args) {
-  const { radius, onFreeRelease, deleteLabel = "Delete" } = args;
-  const proj = args.origin ?? AUTO_ORIGIN_PROJECTION;
-  const r2 = radius * radius;
-  return {
-    onStart(ctx) {
-      const snapshots = /* @__PURE__ */ new Map();
-      const indexes = /* @__PURE__ */ new Map();
-      const nodes = ctx.adapter.getNodes();
-      for (const id of ctx.draggedIds) {
-        const obj = ctx.adapter.getNode(id) ?? { id };
-        snapshots.set(id, obj);
-        indexes.set(id, nodes.findIndex((n) => n.id === id));
-      }
-      setScratch(ctx.scratch, SNAPSHOTS, snapshots);
-      setScratch(ctx.scratch, INDEXES, indexes);
-    },
-    onEnd(ctx) {
-      if (ctx.snap) return;
-      const id = ctx.draggedIds[0];
-      const o0 = proj.getOrigin(ctx.origin.get(id));
-      const o1 = proj.getOrigin(ctx.current.get(id));
-      const dx = o1.x - o0.x;
-      const dy = o1.y - o0.y;
-      const within = dx * dx + dy * dy <= r2;
-      if (within) {
-        return null;
-      }
-      if (onFreeRelease === "delete") {
-        const snapshots = getScratch(ctx.scratch, SNAPSHOTS);
-        const indexes = getScratch(ctx.scratch, INDEXES);
-        const obj = snapshots?.get(id) ?? { id };
-        const index = indexes?.get(id) ?? -1;
-        const ops = [createDeleteOp({ node: obj, label: deleteLabel, index })];
-        return ops;
-      }
-      return null;
-    }
-  };
-}
-
-// src/interactions/actions/move/behaviors/snapToGuides.ts
-function snapToGuides(args) {
-  const strategy = guideSnapStrategy(args.getGuides, {
-    tolerance: args.tolerance,
-    getView: args.getView,
-    origin: args.origin
-  });
-  return snap(strategy, { bypassKey: args.bypassKey });
-}
-
-export { snapBackOrDelete, snapToContainer, snapToGrid, snapToGuides };
-//# sourceMappingURL=move.js.map
-//# sourceMappingURL=move.js.map
+import { snapToContainer as e } from "./interactions/actions/move/behaviors/snapToContainer.js";
+import { snapBackOrDelete as t } from "./interactions/actions/move/behaviors/snapBackOrDelete.js";
+export { t as snapBackOrDelete, e as snapToContainer };

package/dist/originProjection-DEklpDc_.d.ts

@@ -0,0 +1,57 @@
+import { M as MoveBehavior } from './types-B_9g6hMM.js';
+
+/** Option surface for the `move` action. */
+
+/** Options for the `move` action: the behaviors (snapping, momentum) layered
+ *  over the raw drag, the ids a drag carries, and its history and lifecycle.
+ *  `selectionMoveBindings` threads them into the move bindings. */
+interface UseMoveOptions<TPose> {
+    behaviors?: MoveBehavior<TPose>[];
+    /** Screen travel, in CSS pixels, before the drag moves anything. Default
+     *  `DRAG_THRESHOLD_PX`. The dispatcher opens no drag before that, so a
+     *  smaller value has no effect; a larger one holds the selection in place
+     *  until the pointer has gone that far. */
+    dragThresholdPx?: number;
+    /** History label for the committed move. Unset, a behavior's or a layout
+     *  drop's own op label names it, else `'Move'`. */
+    moveLabel?: string;
+    /** Commit without an undo entry (`scene.untracked`), bypassing the
+     *  consumer `applyOps` hook. Unset, a behavior's `defaultTransient` decides. */
+    transient?: boolean;
+    /** Fired once the drag passes its threshold, with the ids it moves. */
+    onGestureStart?(ids: string[]): void;
+    /** Fired once per `onGestureStart`: `true` when the move wrote to the
+     *  document, `false` on cancel, a behavior abort, or no net movement. */
+    onGestureEnd?(committed: boolean): void;
+    /** Replace the selection with the ids the drag moves — to carry linked
+     *  nodes along, say. Called once at drag start; the result is what
+     *  behaviors see as `draggedIds` and what the commit writes (each id's
+     *  descendants follow it as usual). Returning `[]` declines the drag.
+     *  Default: the selection. */
+    expandIds?: (ids: string[]) => string[];
+}
+
+/**
+ * How a snap reads and moves a pose that doesn't expose `{x,y}` directly
+ * (Path, polygon, etc.): `getOrigin` gives the point a snap strategy rounds,
+ * and `translate` moves the pose by the resulting delta.
+ */
+interface OriginProjection<TPose> {
+    getOrigin(pose: TPose): {
+        x: number;
+        y: number;
+    };
+    translate(pose: TPose, dx: number, dy: number): TPose;
+}
+/** Identity projection for `TPose extends { x; y }`. */
+declare const RECT_ORIGIN_PROJECTION: OriginProjection<{
+    x: number;
+    y: number;
+}>;
+/** Per-call dispatch: routes Path-shaped poses to the path origin/translate
+ *  helpers and everything else to `RECT_ORIGIN_PROJECTION`. The default for
+ *  `snap` and the snap strategies, so consumers with Path TPose don't have to
+ *  thread `pathOriginProjection` explicitly. */
+declare const AUTO_ORIGIN_PROJECTION: OriginProjection<unknown>;
+
+export { AUTO_ORIGIN_PROJECTION as A, type OriginProjection as O, RECT_ORIGIN_PROJECTION as R, type UseMoveOptions as U };

package/dist/patterns-builtin.js

@@ -1,3 +1,3 @@
-export { chunks, crosshatch, dots, drawTileShapes, hatch, tileGeometry, tileSize } from './chunk-3TY6FHAF.js';
-//# sourceMappingURL=patterns-builtin.js.map
-//# sourceMappingURL=patterns-builtin.js.map
+import { drawTileShapes as e, tileGeometry as t, tileSize as n } from "./features/patterns/tileGeometry.js";
+import { chunks as r, crosshatch as i, dots as a, hatch as o } from "./features/patterns/patterns-builtin.js";
+export { r as chunks, i as crosshatch, a as dots, e as drawTileShapes, o as hatch, t as tileGeometry, n as tileSize };

package/dist/{poseDescriptor-rZa9W5hJ.d.ts → poseDescriptor-D-OH-tu5.d.ts}

@@ -27,10 +27,6 @@ interface PoseDescriptor<TPose, TNode = unknown> {
      *  back to a translation derived from `remapBounds` (origin shifted, no
      *  scale). Path-shaped poses should provide this for performance. */
     translate?(pose: TPose, dx: number, dy: number): TPose;
-    /** True iff any portion of the pose's geometry intersects `rect`. Optional
-     *  — when omitted, area-select and similar callers test against `getBounds`
-     *  AABB (looser, but correct for axis-aligned rect poses). */
-    intersectsRect?(pose: TPose, rect: Bounds): boolean;
     /** Interpolate between two poses. Optional — animation helpers fall back to
      *  rect-shape lerp when omitted (which fails for non-rect poses). */
     lerp?(a: TPose, b: TPose, t: number): TPose;