@weasel-js/guides 1.10.1 → 1.11.1

package/dist/index.js

@@ -1,16 +1,20 @@
-import { pointToGridCell } from './chunk-TLFMAZ6M.js';
-export { gridSnapStrategy, pointToGridCell } from './chunk-TLFMAZ6M.js';
-export { pointSnapToGrid } from './chunk-B25KFI3I.js';
-import { guideOffsetOn } from './chunk-LOFNN7EQ.js';
-export { DEFAULT_GUIDE_TOLERANCE_PX, guideSnapStrategy } from './chunk-LOFNN7EQ.js';
 import { useState, useRef, useCallback, useEffect } from 'react';
-import { useLatest, resolveAxes, pxExtent, textCommandFromRuns, AUTO_POSE_DESCRIPTOR, visualBoundsViaDescriptor, rectFromPlane, translatePoseViaDescriptor, unionBounds, fixedCornerOf, createTransformOp, resolveStrokeWidth, screenToWorld, rectToPlane, screenTolerance } from '@weasel-js/core';
-import { rectPath, PATH_M, PATH_L } from '@weasel-js/geom';
+import { resolveAxes, useLatest, viewportWorldRect, pxExtent, tickedSegment, measuredSegmentCommands, AUTO_POSE_DESCRIPTOR, visualBoundsViaDescriptor, rectFromPlane, scenePoseFrame, unionAABB, createTransformOp, sceneSharedUnitScopes, asNodeId, sceneUnitScopes, screenToWorld, nodeGates, resolveStrokeWidth, resolveScoped } from '@weasel-js/core';
+import { PATH_M, PATH_L } from '@weasel-js/geom';
 
 // src/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
   return Math.round(value / cellSize) * cellSize || 0;
 }
+function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }) {
+  const s = resolveAxes(spacing, unitSystem);
+  return {
+    col: Math.floor((point.x - origin.x) / s.x),
+    row: Math.floor((point.y - origin.y) / s.y)
+  };
+}
+
+// src/grid/useGridCellHover.ts
 function cellsEqual(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
@@ -64,6 +68,7 @@ var DEFAULT_SUB = {
   paint: { kind: "solid", color: "rgba(255, 255, 255, 0.04)" },
   width: 1
 };
+var MIN_SCREEN_SPACING = 4;
 function createGridLayer(opts) {
   const line = opts.style?.line ?? DEFAULT_LINE;
   const accent = opts.style?.accent ?? DEFAULT_ACCENT;
@@ -71,11 +76,11 @@ function createGridLayer(opts) {
   return {
     id: "grid",
     label: "Grid",
-    draw: (_data, view) => {
-      const b = opts.bounds();
-      if (b.width <= 0 || b.height <= 0) return [];
+    draw: (_data, view, dims) => {
       const { accentEvery, subdivisions } = opts;
       const spacing = resolveAxes(opts.spacing, opts.unitSystem);
+      const b = opts.bounds ? opts.bounds(view, dims) : onLattice(viewportWorldRect(view, dims), spacing, accentEvery && accentEvery > 0 ? accentEvery : 1);
+      if (!(b.width > 0 && b.height > 0 && Number.isFinite(b.width) && Number.isFinite(b.height))) return [];
       const x0 = b.x;
       const y0 = b.y;
       const x1 = b.x + b.width;
@@ -89,55 +94,47 @@ function createGridLayer(opts) {
           coords: new Float32Array([sx, sy, ex, ey]),
           fillRule: "nonzero"
         };
-        const across2 = sx === ex ? px.x : px.y;
+        const across = sx === ex ? px.x : px.y;
         children.push({
           kind: "path",
           path,
-          stroke: { ...s, width: resolveStrokeWidth(s.width ?? 1, 1) * across2 }
+          stroke: { ...s, width: resolveStrokeWidth(s.width ?? 1, 1) * across }
         });
       };
-      if (subdivisions && subdivisions > 1) {
-        const stepX = spacing.x / subdivisions;
-        for (let x = x0; x <= x1 + 1e-9; x += stepX) {
-          const k = Math.round((x - x0) / stepX);
-          if (k % subdivisions === 0) continue;
-          pushSegment(x, y0, x, y1, sub);
-        }
-        const stepY = spacing.y / subdivisions;
-        for (let y = y0; y <= y1 + 1e-9; y += stepY) {
-          const k = Math.round((y - y0) / stepY);
-          if (k % subdivisions === 0) continue;
-          pushSegment(x0, y, x1, y, sub);
+      const family = (axis, step, skipEvery, s) => {
+        if (!(step * Math.abs(view.scale[axis]) >= MIN_SCREEN_SPACING)) return;
+        const [from, to] = axis === "x" ? [x0, x1] : [y0, y1];
+        for (let k = 0; from + k * step <= to + 1e-9; k++) {
+          if (skipEvery > 0 && k % skipEvery === 0) continue;
+          const at = from + k * step;
+          if (axis === "x") pushSegment(at, y0, at, y1, s);
+          else pushSegment(x0, at, x1, at, s);
         }
+      };
+      const accentOn = accentEvery !== void 0 && accentEvery > 0;
+      for (const axis of ["x", "y"]) {
+        if (subdivisions && subdivisions > 1) family(axis, spacing[axis] / subdivisions, subdivisions, sub);
       }
-      let idx = 0;
-      for (let x = x0; x <= x1 + 1e-9; x += spacing.x) {
-        const isAccent = !!accentEvery && accentEvery > 0 && idx % accentEvery === 0;
-        if (!isAccent) pushSegment(x, y0, x, y1, line);
-        idx++;
-      }
-      idx = 0;
-      for (let y = y0; y <= y1 + 1e-9; y += spacing.y) {
-        const isAccent = !!accentEvery && accentEvery > 0 && idx % accentEvery === 0;
-        if (!isAccent) pushSegment(x0, y, x1, y, line);
-        idx++;
-      }
-      if (accentEvery && accentEvery > 0) {
-        idx = 0;
-        for (let x = x0; x <= x1 + 1e-9; x += spacing.x) {
-          if (idx % accentEvery === 0) pushSegment(x, y0, x, y1, accent);
-          idx++;
-        }
-        idx = 0;
-        for (let y = y0; y <= y1 + 1e-9; y += spacing.y) {
-          if (idx % accentEvery === 0) pushSegment(x0, y, x1, y, accent);
-          idx++;
-        }
+      for (const axis of ["x", "y"]) family(axis, spacing[axis], accentOn ? accentEvery : 0, line);
+      if (accentOn) {
+        for (const axis of ["x", "y"]) family(axis, spacing[axis] * accentEvery, 0, accent);
       }
       return children;
     }
   };
 }
+function onLattice(r, spacing, accentEvery) {
+  const px = spacing.x * accentEvery;
+  const py = spacing.y * accentEvery;
+  const x = Math.floor(r.x / px) * px;
+  const y = Math.floor(r.y / py) * py;
+  return {
+    x,
+    y,
+    width: Math.ceil((r.x + r.width) / px) * px - x,
+    height: Math.ceil((r.y + r.height) / py) * py - y
+  };
+}
 var DEFAULT_FILL = { paint: { kind: "solid", color: "rgba(127,176,105,0.15)" } };
 function createCellHighlightLayer(opts) {
   const fill = opts.fill ?? DEFAULT_FILL;
@@ -162,6 +159,23 @@ function createCellHighlightLayer(opts) {
     }
   };
 }
+function span(v, chain) {
+  const zero = typeof v === "number" ? 0 : { ...v, value: 0 };
+  return resolveScoped(v, chain) - resolveScoped(zero, chain);
+}
+function scopedGridPitch(spacing, scopes, chain) {
+  const inner = chain.length > 1 ? chain[chain.length - 1] : null;
+  const v = inner && scopes.spacing ? scopes.spacing(inner) : spacing;
+  const on = (axis) => {
+    const a = typeof v === "object" && "x" in v ? v[axis] : v;
+    try {
+      return span(a, chain);
+    } catch (e) {
+      throw new Error(`${axis} axis: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+  return { x: on("x"), y: on("y") };
+}
 function useGuides(initial = []) {
   const [guides, setGuides] = useState(initial);
   const ref = useLatest(guides);
@@ -190,24 +204,6 @@ function useGuides(initial = []) {
   return { guides, getGuides, addGuide, removeGuide, clearGuides };
 }
 var DEFAULT_COLOR = "#3aa0ff";
-var LABEL_FONT = { fontSize: 10 };
-var LABEL_CHAR_W = 6;
-var LABEL_H = 14;
-var LABEL_PAD_X = 4;
-function tickedSegment(x0, y0, x1, y1, t) {
-  const h = t / 2;
-  const vertical = x0 === x1;
-  const ends = t <= 0 ? [] : vertical ? [x0 - h, y0, x0 + h, y0, x1 - h, y1, x1 + h, y1] : [x0, y0 - h, x0, y0 + h, x1, y1 - h, x1, y1 + h];
-  const coords = [x0, y0, x1, y1, ...ends];
-  const commands = [];
-  for (let i = 0; i < coords.length; i += 4) commands.push(PATH_M, PATH_L);
-  return {
-    kind: "polygon",
-    commands: new Uint8Array(commands),
-    coords: new Float32Array(coords),
-    fillRule: "nonzero"
-  };
-}
 function createGuidesLayer(opts) {
   const lineWidth = opts.lineWidth ?? 1;
   const color = opts.color ?? DEFAULT_COLOR;
@@ -229,34 +225,22 @@ function createGuidesLayer(opts) {
       const sy = (y) => (y - view.y) * view.scale.y;
       const out = [];
       for (const g of guides) {
-        const span = spanned ? g.span : void 0;
+        const span2 = spanned ? g.span : void 0;
         if (g.axis === "x") {
           const x = sx(g.offset);
           if (x < -lineWidth || x > dims.width + lineWidth) continue;
-          const path = span ? tickedSegment(x, sy(span.min), x, sy(span.max), ticks) : tickedSegment(x, 0, x, dims.height, 0);
+          const path = span2 ? tickedSegment(x, sy(span2.min), x, sy(span2.max), ticks) : tickedSegment(x, 0, x, dims.height, 0);
           out.push({ kind: "path", path, stroke });
         } else {
           const y = sy(g.offset);
           if (y < -lineWidth || y > dims.height + lineWidth) continue;
-          const path = span ? tickedSegment(sx(span.min), y, sx(span.max), y, ticks) : tickedSegment(0, y, dims.width, y, 0);
+          const path = span2 ? tickedSegment(sx(span2.min), y, sx(span2.max), y, ticks) : tickedSegment(0, y, dims.width, y, 0);
           out.push({ kind: "path", path, stroke });
         }
       }
       for (const g of gaps) {
         const [x0, y0, x1, y1] = g.axis === "x" ? [sx(g.min), sy(g.at), sx(g.max), sy(g.at)] : [sx(g.at), sy(g.min), sx(g.at), sy(g.max)];
-        out.push({ kind: "path", path: tickedSegment(x0, y0, x1, y1, ticks), stroke: gapStroke });
-        if (format === null) continue;
-        const text = format(g.max - g.min);
-        const w = text.length * LABEL_CHAR_W + LABEL_PAD_X * 2;
-        const left = (x0 + x1) / 2 - w / 2;
-        const top = (y0 + y1) / 2 - LABEL_H / 2;
-        out.push({ kind: "path", path: rectPath(left, top, w, LABEL_H), fill: { paint: { kind: "solid", color: gapColor } } });
-        out.push(textCommandFromRuns(
-          left + LABEL_PAD_X,
-          top + 2,
-          [{ text, fill: { paint: { kind: "solid", color: "#fff" } } }],
-          LABEL_FONT
-        ));
+        out.push(...measuredSegmentCommands(x0, y0, x1, y1, ticks, gapStroke, format?.(g.max - g.min) ?? null, gapColor));
       }
       return out;
     }
@@ -302,57 +286,6 @@ function deriveAlignmentGuides(targets, opts = {}) {
   return [...seenX.values(), ...seenY.values()];
 }
 
-// src/guides/alignment/match.ts
-var MOVE_ANCHORS = {
-  x: ["min", "center", "max"],
-  y: ["min", "center", "max"]
-};
-function featureOffset(b, axis, anchor) {
-  if (axis === "x") {
-    if (anchor === "min") return b.x;
-    if (anchor === "center") return b.x + b.width / 2;
-    return b.x + b.width;
-  }
-  if (anchor === "min") return b.y;
-  if (anchor === "center") return b.y + b.height / 2;
-  return b.y + b.height;
-}
-function bestAxis(b, axis, anchors, candidates, worldTolerance) {
-  let bestAbs = Infinity;
-  let bestDelta = 0;
-  let bestGuide = null;
-  for (const anchor of anchors) {
-    const o = featureOffset(b, axis, anchor);
-    for (const g of candidates) {
-      if (g.axis !== axis) continue;
-      const d = g.offset - o;
-      const ad = Math.abs(d);
-      if (ad <= worldTolerance && ad < bestAbs) {
-        bestAbs = ad;
-        bestDelta = d;
-        bestGuide = g;
-      }
-    }
-  }
-  return { delta: bestGuide ? bestDelta : 0, guide: bestGuide };
-}
-function matchAlignment(bounds, candidates, worldTolerance, anchors) {
-  const x = bestAxis(bounds, "x", anchors.x, candidates, worldTolerance.x);
-  const y = bestAxis(bounds, "y", anchors.y, candidates, worldTolerance.y);
-  const top = bounds.y + y.delta;
-  const left = bounds.x + x.delta;
-  return {
-    dx: x.delta,
-    dy: y.delta,
-    activeX: stretchSpan(x.guide, top, top + bounds.height),
-    activeY: stretchSpan(y.guide, left, left + bounds.width)
-  };
-}
-function stretchSpan(g, min, max) {
-  if (g === null || g.span === void 0) return g;
-  return { ...g, span: { min: Math.min(g.span.min, min), max: Math.max(g.span.max, max) } };
-}
-
 // src/guides/alignment/spacing.ts
 var EPS2 = 1e-6;
 var lo = (b, a) => a === "x" ? b.x : b.y;
@@ -368,14 +301,14 @@ function gapBetween(a, b, axis) {
   if (shared === null) return null;
   return { axis, min: hi(a, axis), max: lo(b, axis), at: (shared[0] + shared[1]) / 2 };
 }
-function hitsStrip(g, b, span) {
+function hitsStrip(g, b, span2) {
   const c = cross(g.axis);
-  return lo(b, g.axis) < g.max - EPS2 && hi(b, g.axis) > g.min + EPS2 && lo(b, c) < span[1] - EPS2 && hi(b, c) > span[0] + EPS2;
+  return lo(b, g.axis) < g.max - EPS2 && hi(b, g.axis) > g.min + EPS2 && lo(b, c) < span2[1] - EPS2 && hi(b, c) > span2[0] + EPS2;
 }
 function measureGaps(targets, axis) {
-  return measure(targets, axis).map((m) => m.gap);
+  return measureGapSpans(targets, axis).map((m) => m.gap);
 }
-function measure(targets, axis) {
+function measureGapSpans(targets, axis) {
   const out = [];
   for (const a of targets) {
     let next = null;
@@ -386,13 +319,13 @@ function measure(targets, axis) {
     }
     if (next === null) continue;
     const gap = gapBetween(a, next, axis);
-    const span = overlap(a, next, cross(axis));
-    if (targets.some((t) => t !== a && t !== next && hitsStrip(gap, t, span))) continue;
-    out.push({ gap, span });
+    const span2 = overlap(a, next, cross(axis));
+    if (targets.some((t) => t !== a && t !== next && hitsStrip(gap, t, span2))) continue;
+    out.push({ gap, span: span2 });
   }
   return out.sort((p, q) => p.gap.min - q.gap.min || p.gap.at - q.gap.at);
 }
-function bestAxis2(b, axis, edge, targets, refs, tol) {
+function spacingOffers(b, axis, edge, targets, refs) {
   const bLo = lo(b, axis);
   const bHi = hi(b, axis);
   const size = bHi - bLo;
@@ -405,10 +338,9 @@ function bestAxis2(b, axis, edge, targets, refs, tol) {
     if (lo(t, axis) >= center && (right === null || lo(t, axis) < lo(right, axis))) right = t;
   }
   const sizes = refs.map((g) => g.max - g.min);
-  let best = null;
+  const out = [];
   const offer = (delta, gap) => {
-    if (gap <= EPS2 || Math.abs(delta) > tol) return;
-    if (best === null || Math.abs(delta) < Math.abs(best.delta)) best = { delta, size: gap };
+    if (gap > EPS2) out.push({ delta, size: gap });
   };
   const L = left === null ? null : hi(left, axis);
   const R = right === null ? null : lo(right, axis);
@@ -428,28 +360,39 @@ function bestAxis2(b, axis, edge, targets, refs, tol) {
     const own = R !== null ? [R - bHi] : [];
     for (const g of [...sizes, ...own]) if (L + g < bHi - EPS2) offer(L + g - bLo, g);
   }
+  return out;
+}
+function bestAxis(b, axis, edge, targets, refs, tol) {
+  let best = null;
+  for (const o of spacingOffers(b, axis, edge, targets, refs)) {
+    if (Math.abs(o.delta) > tol) continue;
+    if (best === null || Math.abs(o.delta) < Math.abs(best.delta)) best = o;
+  }
   return best;
 }
-function markers(b, axis, size, targets, refs) {
+function equalGaps(b, axis, size, targets, refs) {
   const eq = (g) => Math.abs(g.max - g.min - size) < 1e-3;
   const out = refs.filter(eq);
-  const own = measureGaps([...targets, b], axis).filter((g) => (Math.abs(g.max - lo(b, axis)) < EPS2 || Math.abs(g.min - hi(b, axis)) < EPS2) && eq(g));
+  const near = targets.filter((t) => hi(t, axis) > lo(b, axis) - size - EPS2 && lo(t, axis) < hi(b, axis) + size + EPS2);
+  const own = measureGaps([...near, b], axis).filter((g) => (Math.abs(g.max - lo(b, axis)) < EPS2 || Math.abs(g.min - hi(b, axis)) < EPS2) && eq(g));
   return [...out, ...own];
 }
+function referenceGaps(bounds, measured) {
+  return measured.filter((m) => !hitsStrip(m.gap, bounds, m.span)).map((m) => m.gap);
+}
 function matchSpacing(bounds, targets, worldTolerance, moving = { x: "both", y: "both" }) {
-  const refsFor = (axis) => measure(targets, axis).filter((m) => !hitsStrip(m.gap, bounds, m.span)).map((m) => m.gap);
-  const refsX = refsFor("x");
-  const refsY = refsFor("y");
-  const x = moving.x === null ? null : bestAxis2(bounds, "x", moving.x, targets, refsX, worldTolerance.x);
-  const y = moving.y === null ? null : bestAxis2(bounds, "y", moving.y, targets, refsY, worldTolerance.y);
+  const refsX = referenceGaps(bounds, measureGapSpans(targets, "x"));
+  const refsY = referenceGaps(bounds, measureGapSpans(targets, "y"));
+  const x = moving.x === null ? null : bestAxis(bounds, "x", moving.x, targets, refsX, worldTolerance.x);
+  const y = moving.y === null ? null : bestAxis(bounds, "y", moving.y, targets, refsY, worldTolerance.y);
   const dx = x?.delta ?? 0;
   const dy = y?.delta ?? 0;
   const final = applyEdges(bounds, dx, dy, moving);
   return {
     dx,
     dy,
-    gapsX: x === null ? [] : markers(final, "x", x.size, targets, refsX),
-    gapsY: y === null ? [] : markers(final, "y", y.size, targets, refsY)
+    gapsX: x === null ? [] : equalGaps(final, "x", x.size, targets, refsX),
+    gapsY: y === null ? [] : equalGaps(final, "y", y.size, targets, refsY)
   };
 }
 function applyEdges(b, dx, dy, moving) {
@@ -466,223 +409,397 @@ function applyEdges(b, dx, dy, moving) {
   } else if (moving.y === "max") height += dy;
   return { x, y, width, height };
 }
-var across = (axis) => axis === "x" ? "y" : "x";
-var into = (m, axis, v) => v * m.scale[axis] + m.offset[axis];
-var outOf = (m, axis, v) => (v - m.offset[axis]) / m.scale[axis];
-function range(r, map) {
-  const a = map(r.min);
-  const b = map(r.max);
-  return { ...r, min: Math.min(a, b), max: Math.max(a, b) };
-}
-function guideToPlane(g, m) {
-  const span = g.span && range(g.span, (v) => into(m, across(g.axis), v));
-  return { ...g, offset: guideOffsetOn(g, m), ...span ? { span } : {} };
-}
-function guideFromPlane(g, m) {
-  const span = g.span && range(g.span, (v) => outOf(m, across(g.axis), v));
-  return { ...g, offset: outOf(m, g.axis, g.offset), ...span ? { span } : {} };
-}
-function gapFromPlane(g, m) {
-  return { ...range(g, (v) => outOf(m, g.axis, v)), at: outOf(m, across(g.axis), g.at) };
-}
-function alignmentOnPlane(args, plane) {
-  if (!plane) return args;
-  const spacing = args.getSpacingTargets;
-  const setGaps = args.setActiveGaps;
+function worldBoundsOf(scene, ids, opts = {}) {
+  const d = opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+  const frame = scenePoseFrame(scene);
+  const out = [];
+  for (const id of ids) {
+    if (scene.get(id) === void 0) continue;
+    out.push(visualBoundsViaDescriptor(frame.world(id), d));
+  }
+  return out;
+}
+function worldUnionOf(scene, ids, opts = {}) {
+  const boxes = worldBoundsOf(scene, ids, opts);
+  return boxes.length === 0 ? null : unionAABB(boxes);
+}
+function siblingIds(scene, ids) {
+  const moving = new Set(ids);
+  const gates = nodeGates(scene);
+  const parents = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    const node = scene.get(id);
+    if (node !== void 0) parents.add(node.parent);
+  }
+  const siblings = [];
+  for (const parent of parents) {
+    for (const id of parent === null ? scene.roots : scene.childrenOf(parent)) {
+      const node = scene.get(id);
+      if (moving.has(id) || node === void 0 || gates.hidden(id)) continue;
+      siblings.push(id);
+    }
+  }
+  return siblings;
+}
+function siblingBounds(scene, ids, opts = {}) {
+  return worldBoundsOf(scene, siblingIds(scene, ids), opts);
+}
+
+// src/strategies/onPlane.ts
+function guideOffsetOn(g, plane) {
+  return plane ? g.offset * plane.scale[g.axis] + plane.offset[g.axis] : g.offset;
+}
+function roundToGridOn(value, axis, spacing, plane) {
+  if (!plane) return Math.round(value / spacing) * spacing;
+  const camera = (value - plane.offset[axis]) / plane.scale[axis];
+  return Math.round(camera / spacing) * spacing * plane.scale[axis] + plane.offset[axis];
+}
+
+// src/sources/lines.ts
+function axisLine(axis, offset, near) {
+  return axis === "x" ? { at: { x: offset, y: near.y }, dirs: [{ x: 0, y: 1 }] } : { at: { x: near.x, y: offset }, dirs: [{ x: 1, y: 0 }] };
+}
+function landedShift(q, delta) {
+  return { x: delta.x - q.delta0.x, y: delta.y - q.delta0.y };
+}
+
+// src/sources/grid.ts
+function gridSnapSource(opts) {
+  const { scopes } = opts;
+  const rootPitch = scopes ? scopedGridPitch(opts.spacing, scopes, [scopes.root]) : resolveAxes(opts.spacing, opts.unitSystem);
+  const pitchFor = (q) => {
+    if (!scopes || !q.scene) return rootPitch;
+    if (q.ids?.length) return scopedGridPitch(opts.spacing, scopes, sceneSharedUnitScopes(q.scene, q.ids.map(asNodeId), scopes.root));
+    if (q.parent === void 0) return rootPitch;
+    return scopedGridPitch(opts.spacing, scopes, sceneUnitScopes(q.scene, asNodeId(q.parent), scopes.root, { inclusive: true }));
+  };
+  const o = opts.origin ?? { x: 0, y: 0 };
+  const lines = (v, axis, pitch, plane) => {
+    const s = plane ? plane.scale[axis] : 1;
+    const near = roundToGridOn(v - o[axis] * s, axis, pitch[axis], plane) + o[axis] * s;
+    const step = pitch[axis] * s;
+    return [near, near + (v >= near ? step : -step)];
+  };
   return {
-    ...args,
-    getCandidates: () => args.getCandidates().map((g) => guideToPlane(g, plane)),
-    setActiveGuides: (guides) => args.setActiveGuides(guides.map((g) => guideFromPlane(g, plane))),
-    ...spacing ? { getSpacingTargets: () => spacing().map((b) => rectToPlane(plane, b)) } : {},
-    ...setGaps ? { setActiveGaps: (gaps) => setGaps(gaps.map((g) => gapFromPlane(g, plane))) } : {}
+    id: "grid",
+    tier: "fallback",
+    reachPx: Infinity,
+    roles: ["origin", "pointer"],
+    *collect(q) {
+      const pitch = pitchFor(q);
+      for (const p of q.probes) {
+        for (const axis of ["x", "y"]) {
+          for (const at of lines(p.at[axis], axis, pitch, q.plane ?? null)) yield { probe: p.id, locus: axisLine(axis, at, p.at) };
+        }
+      }
+    }
   };
 }
 
-// src/guides/alignment/behaviors.ts
-var activeList = (m) => [m.activeX, m.activeY].filter((g) => g !== null);
-var EXACT = { x: 1e-6, y: 1e-6 };
-function resolve(b, args, tol, anchors, edges) {
-  const candidates = args.getCandidates();
-  const m = matchAlignment(b, candidates, tol, anchors);
-  const targets = args.getSpacingTargets?.();
-  if (targets === void 0) {
-    if (m.activeX === null && m.activeY === null) return null;
-    return { dx: m.dx, dy: m.dy, guides: activeList(m), gaps: [] };
-  }
-  const s = matchSpacing(b, targets, tol, edges);
-  const pick = (hit, d, spaced, sd) => hit && (!spaced || Math.abs(d) <= Math.abs(sd)) ? d : spaced ? sd : null;
-  const dx = pick(m.activeX !== null, m.dx, s.gapsX.length > 0, s.dx);
-  const dy = pick(m.activeY !== null, m.dy, s.gapsY.length > 0, s.dy);
-  if (dx === null && dy === null) return null;
-  const settled = applyEdges(b, dx ?? 0, dy ?? 0, edges);
-  const shown = matchSpacing(settled, targets, EXACT, edges);
+// src/sources/guides.ts
+function guideSnapSource(getGuides) {
   return {
-    dx: dx ?? 0,
-    dy: dy ?? 0,
-    guides: activeList(matchAlignment(settled, candidates, EXACT, anchors)),
-    gaps: [...shown.gapsX, ...shown.gapsY]
+    id: "guides",
+    roles: ["origin", "pointer"],
+    *collect(q) {
+      const guides = getGuides();
+      if (guides.length === 0) return;
+      const reach = q.reachWorld(q.reachPx);
+      for (const p of q.probes) {
+        for (const g of guides) {
+          const offset = guideOffsetOn(g, q.plane ?? null);
+          if (Math.abs(p.at[g.axis] - offset) > reach) continue;
+          yield { probe: p.id, locus: axisLine(g.axis, offset, p.at) };
+        }
+      }
+    }
   };
 }
-function publish(args, r) {
-  args.setActiveGuides(r?.guides ?? []);
-  args.setActiveGaps?.(r?.gaps ?? []);
+
+// src/guides/alignment/match.ts
+function stretchSpan(g, min, max) {
+  if (g === null || g.span === void 0) return g;
+  return { ...g, span: { min: Math.min(g.span.min, min), max: Math.max(g.span.max, max) } };
 }
-function worldTol(base, ctx) {
-  return screenTolerance(base.tolerance ?? 6, ctx);
+function visibleRoots(scene) {
+  const gates = nodeGates(scene);
+  return scene.roots.filter((id) => !gates.hidden(id));
 }
-function alignMoveBehavior(given) {
-  const d = given.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
-  return {
-    onMove(ctx, transform) {
-      const args = alignmentOnPlane(given, ctx.plane);
-      if (args.bypassKey && ctx.modifiers[args.bypassKey]) {
-        publish(args, null);
-        return;
-      }
-      if (transform.kind !== "translate") return;
-      const boxes = [];
-      for (const id of ctx.draggedIds) {
-        const originPose = ctx.origin.get(id);
-        if (originPose === void 0) continue;
-        boxes.push(visualBoundsViaDescriptor(
-          translatePoseViaDescriptor(originPose, transform.dx, transform.dy, d),
-          d
-        ));
-      }
-      const union = unionBounds(boxes);
-      if (union === null) return;
-      const r = resolve(union, args, worldTol(args, ctx), MOVE_ANCHORS, { x: "both", y: "both" });
-      publish(args, r);
-      if (r === null) return;
-      return { transform: { kind: "translate", dx: transform.dx + r.dx, dy: transform.dy + r.dy } };
-    },
-    onEnd() {
-      publish(given, null);
-    },
-    onCancel() {
-      publish(given, null);
+function targetIds(scene, exclude, filter) {
+  const ids = exclude.length > 0 ? siblingIds(scene, exclude) : visibleRoots(scene);
+  if (!filter) return ids;
+  return ids.filter((id) => {
+    const node = scene.get(id);
+    return node !== void 0 && filter(node);
+  });
+}
+function targetBoxes(q, scene, filter) {
+  const drawn = q.drawnBox;
+  return drawn ? targetIds(scene, q.exclude, filter).flatMap((id) => drawn(id) ?? []) : [];
+}
+function cachedPerScene(derive, filter) {
+  let key = null;
+  let value = null;
+  return (q) => {
+    const scene = q.scene;
+    if (!scene) return null;
+    const version = scene.getVersion();
+    const exclude = q.exclude.join("\n");
+    if (key === null || key.scene !== scene || key.version !== version || key.exclude !== exclude) {
+      value = derive(targetBoxes(q, scene, filter));
+      key = { scene, version, exclude };
     }
+    return value;
   };
 }
-function alignInsertBehavior(given) {
-  const pointAnchors = { x: ["min"], y: ["min"] };
+
+// src/sources/alignment.ts
+function indexLines(lines) {
+  const sorted = [...lines].sort((a, b) => a.offset - b.offset);
+  return { x: sorted.filter((g) => g.axis === "x"), y: sorted.filter((g) => g.axis === "y") };
+}
+function* inReach(lines, v, reach) {
+  let lo3 = 0;
+  let hi3 = lines.length;
+  while (lo3 < hi3) {
+    const mid2 = lo3 + hi3 >> 1;
+    if (lines[mid2].offset < v - reach) lo3 = mid2 + 1;
+    else hi3 = mid2;
+  }
+  for (let i = lo3; i < lines.length && lines[i].offset <= v + reach; i++) yield lines[i];
+}
+var cross2 = (a) => a === "x" ? "y" : "x";
+function lineMark(g, extent, color) {
+  const span2 = stretchSpan(g, extent[0], extent[1])?.span ?? { min: extent[0], max: extent[1] };
+  const ends = g.axis === "x" ? { from: { x: g.offset, y: span2.min }, to: { x: g.offset, y: span2.max } } : { from: { x: span2.min, y: g.offset }, to: { x: span2.max, y: g.offset } };
+  return { kind: "line", ...ends, ...color === void 0 ? {} : { color } };
+}
+function alignmentSnapSource(opts = {}) {
+  const page = () => (typeof opts.page === "function" ? opts.page() : opts.page) ?? void 0;
+  const fromScene = cachedPerScene((boxes) => indexLines(deriveAlignmentGuides(boxes)), opts.filter);
+  const linesFor = (q) => {
+    const pageBox = page();
+    const own = opts.getCandidates ? indexLines(opts.getCandidates()) : fromScene(q);
+    return [...own ? [own] : [], ...pageBox ? [indexLines(deriveAlignmentGuides([], { page: pageBox }))] : []];
+  };
   return {
-    onMove(ctx, { current }) {
-      const args = alignmentOnPlane(given, ctx.plane);
-      if (args.bypassKey && ctx.modifiers[args.bypassKey]) {
-        args.setActiveGuides([]);
-        return;
-      }
-      const box = { x: current.x, y: current.y, width: 0, height: 0 };
-      const m = matchAlignment(box, args.getCandidates(), worldTol(args, ctx), pointAnchors);
-      if (m.activeX === null && m.activeY === null) {
-        args.setActiveGuides([]);
-        return;
+    id: "alignment",
+    ...opts.reachPx === void 0 ? {} : { reachPx: opts.reachPx },
+    roles: ["box", "pointer"],
+    *collect(q) {
+      const indexes = linesFor(q);
+      if (indexes.length === 0) return;
+      const reach = q.reachWorld(q.reachPx);
+      const box = q.box ?? null;
+      const probes = q.probes.some((p) => p.role === "box") ? q.probes.filter((p) => p.role === "box") : q.probes;
+      for (const p of probes) {
+        for (const axis of ["x", "y"]) {
+          for (const index of indexes) {
+            for (const g of inReach(index[axis], p.at[axis], reach)) {
+              yield {
+                probe: p.id,
+                locus: axisLine(axis, g.offset, p.at),
+                mark: (delta) => lineMark(g, extentAcross(p, box, axis, landedShift(q, delta), q.edges), opts.color)
+              };
+            }
+          }
+        }
       }
-      args.setActiveGuides(activeList(m));
-      return { current: { x: current.x + m.dx, y: current.y + m.dy } };
-    },
-    onEnd() {
-      given.setActiveGuides([]);
-    },
-    onCancel() {
-      given.setActiveGuides([]);
     }
   };
 }
-function alignResizeBehavior(given) {
-  const d = given.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+function extentAcross(p, box, axis, shift, edges = { x: "both", y: "both" }) {
+  const c = cross2(axis);
+  if (p.role !== "box" || box === null) return [p.at[c] + shift[c], p.at[c] + shift[c]];
+  const landed = applyEdges(box, shift.x, shift.y, edges);
+  const lo3 = c === "x" ? landed.x : landed.y;
+  return [lo3, lo3 + (c === "x" ? landed.width : landed.height)];
+}
+
+// src/sources/spacing.ts
+var measureAll = (boxes) => ({ boxes, x: measureGapSpans(boxes, "x"), y: measureGapSpans(boxes, "y") });
+function gapMark(g, color) {
+  const ends = g.axis === "x" ? { from: { x: g.min, y: g.at }, to: { x: g.max, y: g.at } } : { from: { x: g.at, y: g.min }, to: { x: g.at, y: g.max } };
+  return { kind: "gap", ...ends, value: g.max - g.min, ...color === void 0 ? {} : { color } };
+}
+function spacingSnapSource(opts = {}) {
+  const fromScene = cachedPerScene(measureAll, opts.filter);
   return {
-    onMove(ctx, { pose, anchor }) {
-      const args = alignmentOnPlane(given, ctx.plane);
-      if (args.bypassKey && ctx.modifiers[args.bypassKey]) {
-        publish(args, null);
-        return;
-      }
-      const origin = ctx.origin.get(ctx.draggedIds[0]);
-      const rotation = origin === void 0 ? 0 : d.getRotation?.(origin) ?? 0;
-      const m = rotation === 0 ? matchMovingEdges(pose, anchor, args, worldTol(args, ctx)) : matchRotatedCorners(pose, anchor, d.getBounds(origin), rotation, args.getCandidates(), worldTol(args, ctx));
-      if (m === null) {
-        publish(args, null);
-        return;
-      }
-      let { x, y, width, height } = pose;
-      if (anchor.x === "min") width += m.lx;
-      else if (anchor.x === "max") {
-        x += m.lx;
-        width -= m.lx;
-      }
-      if (anchor.y === "min") height += m.ly;
-      else if (anchor.y === "max") {
-        y += m.ly;
-        height -= m.ly;
+    id: "spacing",
+    ...opts.reachPx === void 0 ? {} : { reachPx: opts.reachPx },
+    roles: ["box"],
+    gestures: ["move", "resize"],
+    *collect(q) {
+      const box = q.box;
+      const probe = q.probes.find((p) => p.role === "box");
+      const measured = opts.getTargets ? measureAll(opts.getTargets()) : fromScene(q);
+      if (!box || !probe || !measured) return;
+      const reach = q.reachWorld(q.reachPx);
+      const edges = q.edges ?? { x: "both", y: "both" };
+      for (const axis of ["x", "y"]) {
+        const edge = edges[axis];
+        if (edge === null) continue;
+        const refs = referenceGaps(box, measured[axis]);
+        const seen = /* @__PURE__ */ new Set();
+        for (const o of spacingOffers(box, axis, edge, measured.boxes, refs)) {
+          const key = `${o.delta.toFixed(6)}:${o.size.toFixed(6)}`;
+          if (Math.abs(o.delta) > reach || seen.has(key)) continue;
+          seen.add(key);
+          yield {
+            probe: probe.id,
+            locus: axisLine(axis, probe.at[axis] + o.delta, probe.at),
+            mark: (delta) => {
+              const shift = landedShift(q, delta);
+              const landed = applyEdges(box, shift.x, shift.y, edges);
+              return equalGaps(landed, axis, o.size, measured.boxes, refs).map((g) => gapMark(g, opts.color));
+            }
+          };
+        }
       }
-      publish(args, { guides: m.guides, gaps: m.gaps });
-      return { pose: { ...pose, x, y, width, height } };
-    },
-    onEnd() {
-      publish(given, null);
-    },
-    onCancel() {
-      publish(given, null);
     }
   };
 }
-function matchMovingEdges(pose, anchor, args, tol) {
-  const moving = (a) => a === "min" ? "max" : a === "max" ? "min" : null;
-  const edges = { x: moving(anchor.x), y: moving(anchor.y) };
-  const anchors = {
-    x: edges.x === null ? [] : [edges.x],
-    y: edges.y === null ? [] : [edges.y]
-  };
-  const r = resolve(pose, args, tol, anchors, edges);
-  return r === null ? null : { lx: r.dx, ly: r.dy, guides: r.guides, gaps: r.gaps };
-}
-function matchRotatedCorners(pose, anchor, originBox, rotation, candidates, tol) {
-  const cos = Math.cos(rotation);
-  const sin = Math.sin(rotation);
-  const toWorld = (lx, ly) => ({ x: lx * cos - ly * sin, y: lx * sin + ly * cos });
-  const fixedLocal = fixedCornerOf(pose, anchor);
-  const f0 = fixedCornerOf(originBox, anchor);
-  const pivot = toWorld(f0.x - originBox.x - originBox.width / 2, f0.y - originBox.y - originBox.height / 2);
-  const fixedWorld = { x: originBox.x + originBox.width / 2 + pivot.x, y: originBox.y + originBox.height / 2 + pivot.y };
-  const drawn = (lx, ly) => {
-    const o = toWorld(lx - fixedLocal.x, ly - fixedLocal.y);
-    return { x: fixedWorld.x + o.x, y: fixedWorld.y + o.y };
-  };
-  const movingEdge = (axis) => {
-    const lo2 = axis === "x" ? pose.x : pose.y;
-    const hi2 = lo2 + (axis === "x" ? pose.width : pose.height);
-    const a = anchor[axis];
-    return a === "min" ? [hi2] : a === "max" ? [lo2] : [lo2, hi2];
+
+// src/spacingHints/distance.ts
+var EPS3 = 1e-6;
+var lo2 = (b, a) => a === "x" ? b.x : b.y;
+var hi2 = (b, a) => a === "x" ? b.x + b.width : b.y + b.height;
+var mid = (b, a) => (lo2(b, a) + hi2(b, a)) / 2;
+var cross3 = (a) => a === "x" ? "y" : "x";
+function measureDistances(from, to) {
+  const out = { gaps: [], leaders: [] };
+  for (const axis of ["x", "y"]) measureAxis(from, to, axis, out);
+  return out;
+}
+function measureAxis(from, to, axis, out) {
+  const c = cross3(axis);
+  const sharedMin = Math.max(lo2(from, c), lo2(to, c));
+  const sharedMax = Math.min(hi2(from, c), hi2(to, c));
+  const shares = sharedMax - sharedMin > EPS3;
+  const push = (min, max, at2) => {
+    if (max - min > EPS3) out.gaps.push({ axis, min, max, at: at2 });
   };
-  if (anchor.x !== "free" && anchor.y !== "free") {
-    const c = drawn(movingEdge("x")[0], movingEdge("y")[0]);
-    const m = matchAlignment({ x: c.x, y: c.y, width: 0, height: 0 }, candidates, tol, { x: ["min"], y: ["min"] });
-    if (m.activeX === null && m.activeY === null) return null;
-    const lx = m.dx * cos + m.dy * sin;
-    const ly = -m.dx * sin + m.dy * cos;
-    return { lx, ly, guides: activeList(m), gaps: [] };
-  }
-  if (anchor.x === "free" && anchor.y === "free") return null;
-  const along = anchor.x === "free" ? "y" : "x";
-  const dir = along === "x" ? toWorld(1, 0) : toWorld(0, 1);
-  const edge = movingEdge(along)[0];
-  let best = null;
-  for (const across3 of movingEdge(along === "x" ? "y" : "x")) {
-    const c = along === "x" ? drawn(edge, across3) : drawn(across3, edge);
-    for (const g of candidates) {
-      const reach = g.axis === "x" ? dir.x : dir.y;
-      if (Math.abs(reach) < 1e-9) continue;
-      const t = (g.offset - (g.axis === "x" ? c.x : c.y)) / reach;
-      if (Math.abs(t * dir.x) > tol.x || Math.abs(t * dir.y) > tol.y) continue;
-      if (best === null || Math.abs(t) < Math.abs(best.t)) best = { t, guide: g, at: c };
+  const before = hi2(from, axis) <= lo2(to, axis) + EPS3;
+  const after = hi2(to, axis) <= lo2(from, axis) + EPS3;
+  if (before || after) {
+    const [min, max] = before ? [hi2(from, axis), lo2(to, axis)] : [hi2(to, axis), lo2(from, axis)];
+    if (max - min <= EPS3) return;
+    const at2 = shares ? (sharedMin + sharedMax) / 2 : mid(from, c);
+    push(min, max, at2);
+    if (!shares) {
+      const edge = before ? lo2(to, axis) : hi2(to, axis);
+      const span2 = at2 < lo2(to, c) ? { min: at2, max: lo2(to, c) } : { min: hi2(to, c), max: at2 };
+      out.leaders.push({ id: `distance:${axis}`, axis, offset: edge, span: span2 });
     }
+    return;
+  }
+  if (!shares) return;
+  const [inner, outer] = lo2(from, axis) >= lo2(to, axis) - EPS3 && hi2(from, axis) <= hi2(to, axis) + EPS3 ? [from, to] : lo2(to, axis) >= lo2(from, axis) - EPS3 && hi2(to, axis) <= hi2(from, axis) + EPS3 ? [to, from] : [null, null];
+  if (inner === null || outer === null) return;
+  const at = mid(inner, c);
+  push(lo2(outer, axis), lo2(inner, axis), at);
+  push(hi2(inner, axis), hi2(outer, axis), at);
+}
+
+// src/spacingHints/distanceReadout.ts
+function marksOf(r, color) {
+  const c = color === void 0 ? {} : { color };
+  return [
+    ...r.gaps.map((g) => g.axis === "x" ? { kind: "distance", from: { x: g.min, y: g.at }, to: { x: g.max, y: g.at }, value: g.max - g.min, ...c } : { kind: "distance", from: { x: g.at, y: g.min }, to: { x: g.at, y: g.max }, value: g.max - g.min, ...c }),
+    ...r.leaders.flatMap((l) => {
+      if (l.span === void 0) return [];
+      return [l.axis === "x" ? { kind: "line", from: { x: l.offset, y: l.span.min }, to: { x: l.offset, y: l.span.max }, ...c } : { kind: "line", from: { x: l.span.min, y: l.offset }, to: { x: l.span.max, y: l.offset }, ...c }];
+    })
+  ];
+}
+var EMPTY = { gaps: [], leaders: [] };
+var MODIFIERS = ["alt", "ctrl", "meta", "shift"];
+function subtreeOf(scene, ids) {
+  const out = /* @__PURE__ */ new Set();
+  const stack = [...ids];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (out.has(id)) continue;
+    out.add(id);
+    stack.push(...scene.childrenOf(id));
   }
-  if (best === null) return null;
-  const across2 = best.guide.axis === "x" ? best.at.y + best.t * dir.y : best.at.x + best.t * dir.x;
-  const guides = [stretchSpan(best.guide, across2, across2)];
-  return along === "x" ? { lx: best.t, ly: 0, guides, gaps: [] } : { lx: 0, ly: best.t, guides, gaps: [] };
+  return out;
+}
+function distanceReadout(opts = {}) {
+  const id = opts.id ?? "distanceReadout";
+  const modifier = opts.modifier ?? "alt";
+  let shown = EMPTY;
+  let store = null;
+  const show = (next) => {
+    if (next === shown || next.gaps.length === 0 && shown.gaps.length === 0) return;
+    shown = next;
+    store?.set(marksOf(next, opts.color));
+  };
+  const action = {
+    id: `${id}.measure`,
+    label: "Measure distance to the shape under the pointer",
+    requires: ["selection", "scene", "nodeAtPoint", "poseDescriptor", "snapReadout"],
+    invoker: {
+      timing: "immediate",
+      run: (deps, params) => {
+        const p = params;
+        const { selection, scene, nodeAtPoint, poseDescriptor, snapReadout } = deps;
+        if (snapReadout !== void 0) store = snapReadout.store;
+        const ids = selection?.get() ?? [];
+        if (p?.show !== true || p.worldX === void 0 || p.worldY === void 0 || scene === void 0 || nodeAtPoint === void 0 || ids.length === 0) {
+          show(EMPTY);
+          return;
+        }
+        const hit = nodeAtPoint({ x: p.worldX, y: p.worldY }, subtreeOf(scene, ids));
+        const from = worldUnionOf(scene, ids, { poseDescriptor });
+        const [to] = hit === null ? [] : worldBoundsOf(scene, [hit], { poseDescriptor });
+        show(from === null || to === void 0 ? EMPTY : measureDistances(from, to));
+      }
+    }
+  };
+  const mods = (held) => Object.fromEntries(
+    MODIFIERS.map((m) => [m, m === modifier ? held : "optional"])
+  );
+  const bindings = [
+    { spec: { kind: "hover", mods: mods(true) }, actionId: action.id, opts: { params: { show: true } } },
+    { spec: { kind: "hover", mods: mods(false) }, actionId: action.id, opts: { params: { show: false } } },
+    { spec: { kind: "hover", motion: "leave" }, actionId: action.id, opts: { params: { show: false } } }
+  ];
+  return {
+    id,
+    eligibility: { always: true },
+    actions: [action],
+    bindings,
+    attach: (api) => {
+      const el = api.element;
+      const hide = () => show(EMPTY);
+      el?.addEventListener("pointerdown", hide, true);
+      return () => {
+        el?.removeEventListener("pointerdown", hide, true);
+        show(EMPTY);
+        store = null;
+      };
+    },
+    read: () => shown
+  };
+}
+
+// src/spacingHints/preset.ts
+function createSpacingHintsPreset(opts = {}) {
+  const id = opts.id ?? "spacingHints";
+  const color = opts.color === void 0 ? {} : { color: opts.color };
+  const own = {
+    ...color,
+    ...opts.filter === void 0 ? {} : { filter: opts.filter },
+    ...opts.tolerance === void 0 ? {} : { reachPx: opts.tolerance }
+  };
+  const snapSources = [
+    ...opts.spacing ?? true ? [spacingSnapSource(own)] : [],
+    ...opts.align ?? false ? [alignmentSnapSource(own)] : []
+  ];
+  const contributions = [];
+  if (opts.readout !== false) contributions.push(distanceReadout({ ...opts.readout, ...color }));
+  return { id, snapSources, contributions };
 }
 
 // src/layout/snaps.ts
@@ -875,7 +992,7 @@ function tileGrid(opts) {
     if (fromIdx === null || fromIdx === idx) return null;
     return { occupant: occupant.id, from: occupant.pose, newPose: cellToPose(grid.rectAt(fromIdx), occupant.pose) };
   }
-  function pack2(from, into2, children) {
+  function pack2(from, into, children) {
     const ordered = children.map((c) => ({ c, cell: from.indexOf(c.pose) })).sort((a, b) => {
       if (a.cell !== b.cell) {
         if (a.cell === null) return 1;
@@ -886,7 +1003,7 @@ function tileGrid(opts) {
     });
     const out = /* @__PURE__ */ new Map();
     for (let i = 0; i < ordered.length; i++) {
-      out.set(ordered[i].c.id, cellToPose(into2.rectAt(i), ordered[i].c.pose));
+      out.set(ordered[i].c.id, cellToPose(into.rectAt(i), ordered[i].c.pose));
     }
     return out;
   }
@@ -1457,6 +1574,6 @@ function ringSlots(opts = {}) {
   };
 }
 
-export { MOVE_ANCHORS, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, cellAt, containedThenNearest, createCellHighlightLayer, createGridLayer, createGuidesLayer, deriveAlignmentGuides, freeform, gridSlots, matchAlignment, matchSpacing, measureGaps, nearest, nearestWithin, none, pack, perContainer, quadtree, ringSlots, roundToCell, rowSlots, sequenceLayout, slots, snapPoint, tileGrid, useGridCellHover, useGuides };
+export { alignmentSnapSource, cellAt, containedThenNearest, createCellHighlightLayer, createGridLayer, createGuidesLayer, createSpacingHintsPreset, deriveAlignmentGuides, distanceReadout, freeform, gridSlots, gridSnapSource, guideSnapSource, matchSpacing, measureDistances, measureGaps, nearest, nearestWithin, none, pack, perContainer, pointToGridCell, quadtree, ringSlots, roundToCell, rowSlots, scopedGridPitch, sequenceLayout, siblingBounds, slots, snapPoint, spacingSnapSource, tileGrid, useGridCellHover, useGuides, worldBoundsOf, worldUnionOf };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map