@weasel-js/guides 1.13.0-rc.0 → 1.14.0

package/dist/index.js

@@ -1,16 +1,92 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
-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';
+import { sceneBoxFrames, scenePoseFrame, resolveAxes, useLatest, viewportWorldRect, tickedSegment, measuredSegmentCommands, AUTO_POSE_DESCRIPTOR, visualBoundsViaDescriptor, rectFromPlane, unionAABB, createTransformOp, asNodeId, sceneSharedUnitScopes, sceneUnitScopes, screenToWorld, nodeGates, resolveScoped, resolveStrokeWidth } from '@weasel-js/core';
+import { pointInPolygon, invert, applyToPoint, mat3, pxExtent, PATH_M, PATH_L, PATH_Z, pxExtentInFrame } 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);
+function sceneGridRegions(scene, root, outlineOf) {
+  const frames = sceneBoxFrames(scene);
+  const poses = scenePoseFrame(scene);
+  const boxOutline = (id, frame) => {
+    const { width, height } = poses.world(id);
+    return [[0, 0], [width, 0], [width, height], [0, height]].map(([x, y]) => {
+      const [wx, wy] = applyToPoint(frame, x, y);
+      return { x: wx, y: wy };
+    });
+  };
+  const children = /* @__PURE__ */ new Map();
+  for (const id of scene.nodes.keys()) {
+    if (scene.get(id)?.units === void 0) continue;
+    const parent = scopeOwner(scene, id);
+    children.set(parent, [...children.get(parent) ?? [], id]);
+  }
+  const build = (parent) => {
+    const out = [];
+    for (const id of children.get(parent) ?? []) {
+      const frame = frames(id);
+      const outline = outlineOf ? outlineOf(id) : frame && boxOutline(id, frame);
+      if (!outline) continue;
+      const inner = build(id);
+      out.push({
+        outline,
+        chain: sceneUnitScopes(scene, id, root, { inclusive: true }),
+        ...inner.length ? { regions: inner } : {},
+        ...frame ? { frame } : {}
+      });
+    }
+    return out;
+  };
+  return build(null);
+}
+function scopeOwner(scene, id, inclusive = false) {
+  for (let at = inclusive ? id : scene.get(id)?.parent ?? null; at !== null; at = scene.get(at)?.parent ?? null) {
+    if (scene.get(at)?.units !== void 0) return at;
+  }
+  return null;
+}
+function regionAt(regions, point) {
+  for (const r of regions ?? []) {
+    const flat = r.outline.flatMap((p) => [p.x, p.y]);
+    if (pointInPolygon(flat, point.x, point.y)) return regionAt(r.regions, point) ?? r;
+  }
+  return null;
+}
+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 gridPitch(spacing, unitSystem, scopes, chain) {
+  return scopes ? scopedGridPitch(spacing, scopes, chain ?? [scopes.root]) : resolveAxes(spacing, unitSystem);
+}
+
+// src/grid/pointToGridCell.ts
+function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }, scoped) {
+  const region = scoped ? regionAt(scoped.regions, point) : null;
+  const s = gridPitch(spacing, unitSystem, scoped?.scopes, region?.chain);
+  const back = region?.frame && invert(region.frame);
+  if (region?.frame && back) {
+    const [x, y] = applyToPoint(back, point.x, point.y);
+    return { col: Math.floor(x / s.x), row: Math.floor(y / s.y), pitch: s, frame: region.frame };
+  }
   return {
     col: Math.floor((point.x - origin.x) / s.x),
-    row: Math.floor((point.y - origin.y) / s.y)
+    row: Math.floor((point.y - origin.y) / s.y),
+    ...scoped ? { pitch: s } : {}
   };
 }
 
@@ -18,7 +94,7 @@ function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }) {
 function cellsEqual(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
-  return a.col === b.col && a.row === b.row;
+  return a.col === b.col && a.row === b.row && a.pitch?.x === b.pitch?.x && a.pitch?.y === b.pitch?.y && (a.frame === b.frame || !!a.frame && !!b.frame && a.frame.every((v, i) => v === b.frame[i]));
 }
 function useGridCellHover(opts) {
   const [cell, setCell] = useState(null);
@@ -42,7 +118,8 @@ function useGridCellHover(opts) {
       const sx = e.clientX - rect.left;
       const sy = e.clientY - rect.top;
       const [wx, wy] = screenToWorld(sx, sy, o.view());
-      update(pointToGridCell({ x: wx, y: wy }, o.spacing, o.unitSystem, o.origin));
+      const scoped = o.scopes ? { scopes: o.scopes, ...o.regions ? { regions: o.regions() } : {} } : void 0;
+      update(pointToGridCell({ x: wx, y: wy }, o.spacing, o.unitSystem, o.origin, scoped));
     };
     const onLeave = () => update(null);
     el.addEventListener("pointermove", onMove);
@@ -56,6 +133,66 @@ function useGridCellHover(opts) {
   }, [enabled, opts.ref, optsRef]);
   return { cell, getCell };
 }
+var MIN_SCREEN_SPACING = 4;
+function hasArea(r) {
+  return r.width > 0 && r.height > 0 && Number.isFinite(r.width) && Number.isFinite(r.height);
+}
+function lattice(b, spacing, shape, view, styles, frame) {
+  const { accentEvery, subdivisions } = shape;
+  const x0 = b.x;
+  const y0 = b.y;
+  const x1 = b.x + b.width;
+  const y1 = b.y + b.height;
+  const px = frame ? pxExtentInFrame(1, view.scale, frame) : pxExtent(1, view.scale);
+  const children = [];
+  const pushSegment = (sx, sy, ex, ey, s) => {
+    const path = {
+      kind: "polygon",
+      commands: new Uint8Array([PATH_M, PATH_L]),
+      coords: new Float32Array([sx, sy, ex, ey]),
+      fillRule: "nonzero"
+    };
+    const across = sx === ex ? px.x : px.y;
+    children.push({
+      kind: "path",
+      path,
+      stroke: { ...s, width: resolveStrokeWidth(s.width ?? 1, 1) * across }
+    });
+  };
+  const family = (axis, step, skipEvery, s) => {
+    if (!(step / px[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, styles.sub);
+  }
+  for (const axis of ["x", "y"]) family(axis, spacing[axis], accentOn ? accentEvery : 0, styles.line);
+  if (accentOn) {
+    for (const axis of ["x", "y"]) family(axis, spacing[axis] * accentEvery, 0, styles.accent);
+  }
+  return children;
+}
+function onLattice(r, spacing, accentEvery, anchor) {
+  const px = spacing.x * accentEvery;
+  const py = spacing.y * accentEvery;
+  const x = anchor.x + Math.floor((r.x - anchor.x) / px) * px;
+  const y = anchor.y + Math.floor((r.y - anchor.y) / py) * py;
+  return {
+    x,
+    y,
+    width: anchor.x + Math.ceil((r.x + r.width - anchor.x) / px) * px - x,
+    height: anchor.y + Math.ceil((r.y + r.height - anchor.y) / py) * py - y
+  };
+}
+
+// src/grid/layer.ts
 var DEFAULT_LINE = {
   paint: { kind: "solid", color: "rgba(255, 255, 255, 0.08)" },
   width: 1
@@ -68,72 +205,85 @@ 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;
-  const sub = opts.style?.sub ?? DEFAULT_SUB;
+  const styles = {
+    line: opts.style?.line ?? DEFAULT_LINE,
+    accent: opts.style?.accent ?? DEFAULT_ACCENT,
+    sub: opts.style?.sub ?? DEFAULT_SUB
+  };
   return {
     id: "grid",
     label: "Grid",
     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;
-      const y1 = b.y + b.height;
-      const px = pxExtent(1, view.scale);
-      const children = [];
-      const pushSegment = (sx, sy, ex, ey, s) => {
-        const path = {
-          kind: "polygon",
-          commands: new Uint8Array([PATH_M, PATH_L]),
-          coords: new Float32Array([sx, sy, ex, ey]),
-          fillRule: "nonzero"
-        };
-        const across = sx === ex ? px.x : px.y;
-        children.push({
-          kind: "path",
-          path,
-          stroke: { ...s, width: resolveStrokeWidth(s.width ?? 1, 1) * across }
-        });
+      const every = opts.accentEvery && opts.accentEvery > 0 ? opts.accentEvery : 1;
+      const spacing = gridPitch(opts.spacing, opts.unitSystem, opts.scopes);
+      const shown = viewportWorldRect(view, dims);
+      const b = opts.bounds ? opts.bounds(view, dims) : onLattice(shown, spacing, every, { x: 0, y: 0 });
+      if (!hasArea(b)) return [];
+      const root = lattice(b, spacing, opts, view, styles);
+      const regions = opts.scopes && opts.regions ? opts.regions() : [];
+      if (regions.length === 0) return root;
+      const anchor = opts.bounds ? { x: b.x, y: b.y } : { x: 0, y: 0 };
+      const area = opts.bounds ? b : shown;
+      const children = [{ kind: "group", clip: withHoles(rectOutline(b), regions), children: root }];
+      const visit = (r) => {
+        const pitch = gridPitch(opts.spacing, opts.unitSystem, opts.scopes, r.chain);
+        const lines = regionLattice(r, area, (box, frame) => lattice(onLattice(box, pitch, every, frame ? { x: 0, y: 0 } : anchor), pitch, opts, view, styles, frame));
+        if (lines.length) children.push({ kind: "group", clip: withHoles(r.outline, r.regions ?? []), children: lines });
+        for (const inner of r.regions ?? []) visit(inner);
       };
-      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);
-      }
-      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);
-      }
+      for (const r of regions) visit(r);
       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
-  };
+function rectOutline(r) {
+  return [
+    { x: r.x, y: r.y },
+    { x: r.x + r.width, y: r.y },
+    { x: r.x + r.width, y: r.y + r.height },
+    { x: r.x, y: r.y + r.height }
+  ];
+}
+function withHoles(outline, holes) {
+  const commands = [];
+  const coords = [];
+  for (const contour of [outline, ...holes.map((h) => h.outline)]) {
+    contour.forEach((p, i) => {
+      commands.push(i === 0 ? PATH_M : PATH_L);
+      coords.push(p.x, p.y);
+    });
+    commands.push(PATH_Z);
+  }
+  return { kind: "polygon", commands: new Uint8Array(commands), coords: new Float32Array(coords), fillRule: "evenodd" };
+}
+function regionLattice(r, area, draw) {
+  if (!r.frame) {
+    const box2 = intersect(outlineBox(r.outline), area);
+    return hasArea(box2) ? draw(box2) : [];
+  }
+  const back = invert(r.frame);
+  if (!back) return [];
+  const local = (ps) => outlineBox(ps.map((p) => {
+    const [x, y] = applyToPoint(back, p.x, p.y);
+    return { x, y };
+  }));
+  const box = intersect(local(r.outline), local(rectOutline(area)));
+  if (!hasArea(box)) return [];
+  const lines = draw(box, r.frame);
+  return lines.length ? [{ kind: "group", transform: mat3.fromAffine(r.frame), children: lines }] : [];
+}
+function outlineBox(outline) {
+  const xs = outline.map((p) => p.x);
+  const ys = outline.map((p) => p.y);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+}
+function intersect(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  return { x, y, width: Math.min(a.x + a.width, b.x + b.width) - x, height: Math.min(a.y + a.height, b.y + b.height) - y };
 }
 var DEFAULT_FILL = { paint: { kind: "solid", color: "rgba(127,176,105,0.15)" } };
 function createCellHighlightLayer(opts) {
@@ -144,8 +294,8 @@ function createCellHighlightLayer(opts) {
     draw: () => {
       const cell = opts.getCell();
       if (!cell) return [];
-      const spacing = resolveAxes(opts.spacing, opts.unitSystem);
-      const o = opts.origin ? opts.origin() : { x: 0, y: 0 };
+      const spacing = cell.pitch ?? resolveAxes(opts.spacing, opts.unitSystem);
+      const o = cell.frame || !opts.origin ? { x: 0, y: 0 } : opts.origin();
       const x = o.x + cell.col * spacing.x;
       const y = o.y + cell.row * spacing.y;
       const children = [
@@ -155,26 +305,112 @@ function createCellHighlightLayer(opts) {
           fill
         }
       ];
-      return children;
+      return cell.frame ? [{ kind: "group", transform: mat3.fromAffine(cell.frame), children }] : children;
     }
   };
 }
-function span(v, chain) {
-  const zero = typeof v === "number" ? 0 : { ...v, value: 0 };
-  return resolveScoped(v, chain) - resolveScoped(zero, chain);
+
+// src/strategies/onPlane.ts
+function guideOffsetOn(g, plane) {
+  return plane ? g.offset * plane.scale[g.axis] + plane.offset[g.axis] : g.offset;
 }
-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)}`);
+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 frameLine(frame, axis, offset, near) {
+  const on = axis === "x" ? { x: offset, y: near.y } : { x: near.x, y: offset };
+  const at = frame.toWorld(on);
+  const tip = frame.toWorld(axis === "x" ? { x: offset, y: near.y + 1 } : { x: near.x + 1, y: offset });
+  return { at, dirs: [{ x: tip.x - at.x, y: tip.y - at.y }] };
+}
+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 = gridPitch(opts.spacing, opts.unitSystem, scopes);
+  const latticeFor = (q) => {
+    const scene = q.scene;
+    if (!scopes || !scene) return { pitch: rootPitch };
+    const within = (owner) => owner === null ? void 0 : q.frameOf?.(owner);
+    if (q.ids?.length) {
+      const ids = q.ids.map(asNodeId);
+      const owners = new Set(ids.map((id) => scopeOwner(scene, id)));
+      return {
+        pitch: scopedGridPitch(opts.spacing, scopes, sceneSharedUnitScopes(scene, ids, scopes.root)),
+        // Nodes in two containers share no one lattice, whatever their scopes.
+        frame: owners.size === 1 ? within([...owners][0]) : void 0
+      };
     }
+    if (q.parent === void 0) return { pitch: rootPitch };
+    const parent = asNodeId(q.parent);
+    return {
+      pitch: scopedGridPitch(opts.spacing, scopes, sceneUnitScopes(scene, parent, scopes.root, { inclusive: true })),
+      frame: within(scopeOwner(scene, parent, 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 {
+    id: "grid",
+    tier: "fallback",
+    reachPx: Infinity,
+    roles: ["origin", "pointer"],
+    *collect(q) {
+      const { pitch, frame } = latticeFor(q);
+      const plane = q.plane ?? null;
+      for (const p of q.probes) {
+        if (frame) {
+          yield* framedLines(p.id, p.at, pitch, frame, plane);
+          continue;
+        }
+        for (const axis of ["x", "y"]) {
+          for (const at of lines(p.at[axis], axis, pitch, plane)) yield { probe: p.id, locus: axisLine(axis, at, p.at) };
+        }
+      }
+    }
+  };
+}
+function* framedLines(probe, at, pitch, frame, plane) {
+  const local = frame.toLocal(at);
+  if (!local) return;
+  for (const axis of ["x", "y"]) {
+    const step = pitch[axis] * (plane ? plane.scale[axis] : 1);
+    const near = Math.round(local[axis] / step) * step;
+    for (const offset of [near, near + (local[axis] >= near ? step : -step)]) {
+      yield { probe, locus: frameLine(frame, axis, offset, local) };
+    }
+  }
+}
+
+// src/grid/preset.ts
+function createGridPreset(opts) {
+  const { id = "grid", snap = {}, ...layer } = opts;
+  const { spacing, unitSystem, scopes } = layer;
+  return {
+    id,
+    layers: { grid: { layer: createGridLayer(layer) } },
+    snapSources: snap === false ? [] : [gridSnapSource({
+      spacing,
+      ...unitSystem === void 0 ? {} : { unitSystem },
+      ...scopes === void 0 ? {} : { scopes },
+      ...snap
+    })]
   };
-  return { x: on("x"), y: on("y") };
 }
 function useGuides(initial = []) {
   const [guides, setGuides] = useState(initial);
@@ -445,57 +681,6 @@ 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 {
-    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/sources/guides.ts
 function guideSnapSource(getGuides) {
   return {
@@ -746,11 +931,11 @@ function distanceReadout(opts = {}) {
         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) {
+        if (p?.show !== true || p.world === 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 hit = nodeAtPoint(p.world, 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));
@@ -1574,6 +1759,6 @@ function ringSlots(opts = {}) {
   };
 }
 
-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 };
+export { alignmentSnapSource, cellAt, containedThenNearest, createCellHighlightLayer, createGridLayer, createGridPreset, createGuidesLayer, createSpacingHintsPreset, deriveAlignmentGuides, distanceReadout, freeform, gridPitch, gridSlots, gridSnapSource, guideSnapSource, matchSpacing, measureDistances, measureGaps, nearest, nearestWithin, none, pack, perContainer, pointToGridCell, quadtree, regionAt, ringSlots, roundToCell, rowSlots, sceneGridRegions, scopedGridPitch, sequenceLayout, siblingBounds, slots, snapPoint, spacingSnapSource, tileGrid, useGridCellHover, useGuides, worldBoundsOf, worldUnionOf };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map