@weasel-js/guides 1.9.2 → 1.9.4

package/dist/{chunk-5BCCIJY3.js → chunk-JETW4ZA3.js}

@@ -1,6 +1,6 @@
-import { AUTO_ORIGIN_PROJECTION, resolveUnit, fromPlane, toPlane } from '@weasel-js/core';
+import { roundToGridOn } from './chunk-NIEZTECL.js';
+import { AUTO_ORIGIN_PROJECTION, resolveUnit } from '@weasel-js/core';
 
-// src/strategies/grid.ts
 function gridSnapStrategy(spacing, arg) {
   const isOpts = typeof arg === "object" && arg !== null && ("origin" in arg || "debug" in arg || "unitSystem" in arg) && !("base" in arg);
   const optsArg = isOpts ? arg : null;
@@ -11,10 +11,8 @@ function gridSnapStrategy(spacing, arg) {
   return {
     snap(pose, ctx) {
       const o = proj.getOrigin(pose);
-      const m = ctx?.plane ?? null;
-      const w = m ? fromPlane(m, o) : o;
-      const cell = { x: Math.round(w.x / c) * c, y: Math.round(w.y / c) * c };
-      const { x: sx, y: sy } = m ? toPlane(m, cell) : cell;
+      const sx = roundToGridOn(o.x, "x", c, ctx?.plane);
+      const sy = roundToGridOn(o.y, "y", c, ctx?.plane);
       debug?.recordSnapCandidate({ x: sx, y: sy }, true);
       return proj.translate(pose, sx - o.x, sy - o.y);
     }
@@ -29,5 +27,5 @@ function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }) {
 }
 
 export { gridSnapStrategy, pointToGridCell };
-//# sourceMappingURL=chunk-5BCCIJY3.js.map
-//# sourceMappingURL=chunk-5BCCIJY3.js.map
+//# sourceMappingURL=chunk-JETW4ZA3.js.map
+//# sourceMappingURL=chunk-JETW4ZA3.js.map

package/dist/chunk-JETW4ZA3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strategies/grid.ts"],"names":[],"mappings":";;;AAgCO,SAAS,gBAAA,CACd,SACA,GAAA,EACqB;AACrB,EAAA,MAAM,MAAA,GACJ,OAAO,GAAA,KAAQ,QAAA,IACf,GAAA,KAAQ,IAAA,KACP,QAAA,IAAY,GAAA,IAAO,OAAA,IAAW,GAAA,IAAO,YAAA,IAAgB,GAAA,CAAA,IACtD,EAAE,MAAA,IAAU,GAAA,CAAA;AACd,EAAA,MAAM,OAAA,GAAU,SACX,GAAA,GACD,IAAA;AACJ,EAAA,MAAM,UAAA,GAAa,OAAA,GAAU,OAAA,CAAQ,UAAA,GAAc,GAAA;AACnD,EAAA,MAAM,IAAA,GAAgC,OAAA,IAAW,OAAA,CAAQ,MAAA,GACrD,QAAQ,MAAA,GACP,sBAAA;AACL,EAAA,MAAM,KAAA,GAA+B,OAAA,GAAU,OAAA,CAAQ,KAAA,GAAQ,MAAA;AAC/D,EAAA,MAAM,CAAA,GAAI,WAAA,CAAY,OAAA,EAAS,UAAU,CAAA;AACzC,EAAA,OAAO;AAAA,IACL,IAAA,CAAK,MAAM,GAAA,EAAK;AACd,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAC7B,MAAA,MAAM,KAAK,aAAA,CAAc,CAAA,CAAE,GAAG,GAAA,EAAK,CAAA,EAAG,KAAK,KAAK,CAAA;AAChD,MAAA,MAAM,KAAK,aAAA,CAAc,CAAA,CAAE,GAAG,GAAA,EAAK,CAAA,EAAG,KAAK,KAAK,CAAA;AAChD,MAAA,KAAA,EAAO,oBAAoB,EAAE,CAAA,EAAG,IAAI,CAAA,EAAG,EAAA,IAAM,IAAI,CAAA;AACjD,MAAA,OAAO,IAAA,CAAK,UAAU,IAAA,EAAM,EAAA,GAAK,EAAE,CAAA,EAAG,EAAA,GAAK,EAAE,CAAC,CAAA;AAAA,IAChD;AAAA,GACF;AACF;AAmBO,SAAS,eAAA,CACd,KAAA,EACA,OAAA,EACA,UAAA,EACA,MAAA,GAAmC,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,EAAE,EAClB;AAC9B,EAAA,MAAM,CAAA,GAAI,WAAA,CAAY,OAAA,EAAS,UAAU,CAAA;AACzC,EAAA,OAAO;AAAA,IACL,KAAK,IAAA,CAAK,KAAA,CAAA,CAAO,MAAM,CAAA,GAAI,MAAA,CAAO,KAAK,CAAC,CAAA;AAAA,IACxC,KAAK,IAAA,CAAK,KAAA,CAAA,CAAO,MAAM,CAAA,GAAI,MAAA,CAAO,KAAK,CAAC;AAAA,GAC1C;AACF","file":"chunk-JETW4ZA3.js","sourcesContent":["import {\n  AUTO_ORIGIN_PROJECTION,\n  resolveUnit,\n  type DebugSink,\n  type OriginProjection,\n  type SnapStrategy,\n  type UnitSystem,\n  type UnitValue,\n} from '@weasel-js/core';\nimport { roundToGridOn } from './onPlane';\n\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n): SnapStrategy<TPose>;\n/** As above, additionally reporting each candidate to a debug sink. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; origin: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  arg?: UnitSystem | { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose> {\n  const isOpts =\n    typeof arg === 'object' &&\n    arg !== null &&\n    ('origin' in arg || 'debug' in arg || 'unitSystem' in arg) &&\n    !('base' in arg);\n  const optsArg = isOpts\n    ? (arg as { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink })\n    : null;\n  const unitSystem = optsArg ? optsArg.unitSystem : (arg as UnitSystem | undefined);\n  const proj: OriginProjection<TPose> = optsArg && optsArg.origin\n    ? optsArg.origin\n    : (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const debug: DebugSink | undefined = optsArg ? optsArg.debug : undefined;\n  const c = resolveUnit(spacing, unitSystem);\n  return {\n    snap(pose, ctx) {\n      const o = proj.getOrigin(pose);\n      const sx = roundToGridOn(o.x, 'x', c, ctx?.plane);\n      const sy = roundToGridOn(o.y, 'y', c, ctx?.plane);\n      debug?.recordSnapCandidate({ x: sx, y: sy }, true);\n      return proj.translate(pose, sx - o.x, sy - o.y);\n    },\n  };\n}\n\n/**\n * Compute the integer cell `{col, row}` that contains `point`, given a grid\n * `spacing` and optional `origin` and `unitSystem`. Pair with\n * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target\n * preview that uses the same spacing as `gridSnapStrategy` — so the visual\n * and behavioral grids stay in lockstep:\n *\n *     const SPACING = 20;\n *     const snap = gridSnapStrategy(SPACING);\n *     // visual grid:\n *     createGridLayer({ spacing: SPACING, bounds: () => ... });\n *     // hover-preview overlay:\n *     createCellHighlightLayer({\n *       spacing: SPACING,\n *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),\n *     });\n */\nexport function pointToGridCell(\n  point: { x: number; y: number },\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n  origin: { x: number; y: number } = { x: 0, y: 0 },\n): { col: number; row: number } {\n  const s = resolveUnit(spacing, unitSystem);\n  return {\n    col: Math.floor((point.x - origin.x) / s),\n    row: Math.floor((point.y - origin.y) / s),\n  };\n}\n"]}

package/dist/chunk-NIEZTECL.js

@@ -0,0 +1,45 @@
+import { AUTO_ORIGIN_PROJECTION, screenTolerance } from '@weasel-js/core';
+
+// src/strategies/guides.ts
+
+// src/strategies/onPlane.ts
+function guideOffsetOn(g, plane) {
+  return plane ? g.offset * plane.scale[g.axis] + plane.offset[g.axis] : g.offset;
+}
+function nearestGuideDelta(guides, axis, value, tol, plane) {
+  let best = null;
+  for (const g of guides) {
+    if (g.axis !== axis) continue;
+    const d = guideOffsetOn(g, plane) - value;
+    if (Math.abs(d) <= tol && (best === null || Math.abs(d) < Math.abs(best))) best = d;
+  }
+  return best;
+}
+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/strategies/guides.ts
+var DEFAULT_GUIDE_TOLERANCE_PX = 6;
+function guideSnapStrategy(getGuides, options = {}) {
+  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;
+  const proj = options.origin ?? AUTO_ORIGIN_PROJECTION;
+  return {
+    snap(pose, ctx) {
+      const guides = getGuides();
+      if (guides.length === 0) return null;
+      const tol = screenTolerance(tolerance, ctx);
+      const o = proj.getOrigin(pose);
+      const dx = nearestGuideDelta(guides, "x", o.x, tol.x, ctx.plane) ?? 0;
+      const dy = nearestGuideDelta(guides, "y", o.y, tol.y, ctx.plane) ?? 0;
+      if (dx === 0 && dy === 0) return null;
+      return proj.translate(pose, dx, dy);
+    }
+  };
+}
+
+export { DEFAULT_GUIDE_TOLERANCE_PX, guideOffsetOn, guideSnapStrategy, nearestGuideDelta, roundToGridOn };
+//# sourceMappingURL=chunk-NIEZTECL.js.map
+//# sourceMappingURL=chunk-NIEZTECL.js.map

package/dist/chunk-NIEZTECL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strategies/onPlane.ts","../src/strategies/guides.ts"],"names":[],"mappings":";;;;;AAQO,SAAS,aAAA,CAAc,GAAU,KAAA,EAAsB;AAC5D,EAAA,OAAO,KAAA,GAAQ,CAAA,CAAE,MAAA,GAAS,KAAA,CAAM,KAAA,CAAM,CAAA,CAAE,IAAI,CAAA,GAAI,KAAA,CAAM,MAAA,CAAO,CAAA,CAAE,IAAI,IAAI,CAAA,CAAE,MAAA;AAC3E;AAGO,SAAS,iBAAA,CACd,MAAA,EACA,IAAA,EACA,KAAA,EACA,KACA,KAAA,EACe;AACf,EAAA,IAAI,IAAA,GAAsB,IAAA;AAC1B,EAAA,KAAA,MAAW,KAAK,MAAA,EAAQ;AACtB,IAAA,IAAI,CAAA,CAAE,SAAS,IAAA,EAAM;AACrB,IAAA,MAAM,CAAA,GAAI,aAAA,CAAc,CAAA,EAAG,KAAK,CAAA,GAAI,KAAA;AACpC,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA,IAAK,QAAQ,IAAA,KAAS,IAAA,IAAQ,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,IAAI,IAAI,IAAA,GAAO,CAAA;AAAA,EACpF;AACA,EAAA,OAAO,IAAA;AACT;AAGO,SAAS,aAAA,CAAc,KAAA,EAAe,IAAA,EAAY,OAAA,EAAiB,KAAA,EAAsB;AAC9F,EAAA,IAAI,CAAC,KAAA,EAAO,OAAO,KAAK,KAAA,CAAM,KAAA,GAAQ,OAAO,CAAA,GAAI,OAAA;AACjD,EAAA,MAAM,MAAA,GAAA,CAAU,QAAQ,KAAA,CAAM,MAAA,CAAO,IAAI,CAAA,IAAK,KAAA,CAAM,MAAM,IAAI,CAAA;AAC9D,EAAA,OAAO,IAAA,CAAK,KAAA,CAAM,MAAA,GAAS,OAAO,CAAA,GAAI,OAAA,GAAU,KAAA,CAAM,KAAA,CAAM,IAAI,CAAA,GAAI,KAAA,CAAM,MAAA,CAAO,IAAI,CAAA;AACvF;;;ACxBO,IAAM,0BAAA,GAA6B;AA0CnC,SAAS,iBAAA,CACd,SAAA,EACA,OAAA,GAAmC,EAAC,EACf;AACrB,EAAA,MAAM,SAAA,GAAY,QAAQ,SAAA,IAAa,0BAAA;AACvC,EAAA,MAAM,IAAA,GACJ,QAAQ,MAAA,IAAW,sBAAA;AAErB,EAAA,OAAO;AAAA,IACL,IAAA,CAAK,MAAM,GAAA,EAAK;AACd,MAAA,MAAM,SAAS,SAAA,EAAU;AACzB,MAAA,IAAI,MAAA,CAAO,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA;AAIhC,MAAA,MAAM,GAAA,GAAM,eAAA,CAAgB,SAAA,EAAW,GAAG,CAAA;AAE1C,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAC7B,MAAA,MAAM,EAAA,GAAK,iBAAA,CAAkB,MAAA,EAAQ,GAAA,EAAK,CAAA,CAAE,GAAG,GAAA,CAAI,CAAA,EAAG,GAAA,CAAI,KAAK,CAAA,IAAK,CAAA;AACpE,MAAA,MAAM,EAAA,GAAK,iBAAA,CAAkB,MAAA,EAAQ,GAAA,EAAK,CAAA,CAAE,GAAG,GAAA,CAAI,CAAA,EAAG,GAAA,CAAI,KAAK,CAAA,IAAK,CAAA;AACpE,MAAA,IAAI,EAAA,KAAO,CAAA,IAAK,EAAA,KAAO,CAAA,EAAG,OAAO,IAAA;AACjC,MAAA,OAAO,IAAA,CAAK,SAAA,CAAU,IAAA,EAAM,EAAA,EAAI,EAAE,CAAA;AAAA,IACpC;AAAA,GACF;AACF","file":"chunk-NIEZTECL.js","sourcesContent":["import type { GestureContext } from '@weasel-js/core';\nimport type { Guide } from '../guides/types';\n\n/** A gesture's `plane`: how the camera's world maps into the world its poses are in. */\ntype Plane = GestureContext<unknown>['plane'];\ntype Axis = 'x' | 'y';\n\n/** Where a guide the camera draws lies along its own axis in the world a gesture's poses are in. */\nexport function guideOffsetOn(g: Guide, plane: Plane): number {\n  return plane ? g.offset * plane.scale[g.axis] + plane.offset[g.axis] : g.offset;\n}\n\n/** The signed distance from `value` to the nearest guide on `axis` within `tol`, or null when none is. */\nexport function nearestGuideDelta(\n  guides: readonly Guide[],\n  axis: Axis,\n  value: number,\n  tol: number,\n  plane: Plane,\n): number | null {\n  let best: number | null = null;\n  for (const g of guides) {\n    if (g.axis !== axis) continue;\n    const d = guideOffsetOn(g, plane) - value;\n    if (Math.abs(d) <= tol && (best === null || Math.abs(d) < Math.abs(best))) best = d;\n  }\n  return best;\n}\n\n/** `value` on `axis` moved to the nearest line of the camera's grid, in the world a gesture's poses are in. */\nexport function roundToGridOn(value: number, axis: Axis, spacing: number, plane: Plane): number {\n  if (!plane) return Math.round(value / spacing) * spacing;\n  const camera = (value - plane.offset[axis]) / plane.scale[axis];\n  return Math.round(camera / spacing) * spacing * plane.scale[axis] + plane.offset[axis];\n}\n","import {\n  type SnapStrategy,\n  screenTolerance,\n  type OriginProjection,\n  AUTO_ORIGIN_PROJECTION,\n} from '@weasel-js/core';\nimport type { Guide } from '../guides/types';\nimport { nearestGuideDelta } from './onPlane';\n\n/** Default snap tolerance (screen pixels). */\nexport const DEFAULT_GUIDE_TOLERANCE_PX = 6;\n\n/** Options for `guideSnapStrategy`. */\nexport interface GuideSnapOptions<TPose> {\n  /**\n   * Tolerance in screen pixels, divided by the gesture view's scale so the\n   * trigger zone stays the same on screen at every zoom. Defaults to\n   * `DEFAULT_GUIDE_TOLERANCE_PX`.\n   */\n  tolerance?: number;\n  /**\n   * Projection used when `TPose` doesn't expose `{x, y}` directly (Path,\n   * polygon, etc.) — same contract as `gridSnapStrategy`. Defaults to the\n   * rect-pose identity projection.\n   */\n  origin?: OriginProjection<TPose>;\n}\n\n/**\n * Snap-strategy that snaps the pose's origin to the nearest guide line on\n * each axis when within tolerance. Each axis is considered independently:\n * a vertical guide (`axis: 'x'`) constrains X, a horizontal guide\n * (`axis: 'y'`) constrains Y. When multiple guides are within range on the\n * same axis, the closest wins.\n *\n * Pair with `useGuides` for storage and `createGuidesLayer` for rendering.\n *\n * **Composition:** combining with `gridSnapStrategy` is left to the\n * consumer in v1 — typically by picking one based on a modifier key, or\n * by stacking two move/resize/insert behaviors in priority order.\n */\nexport function guideSnapStrategy<TPose extends { x: number; y: number }>(\n  getGuides: () => readonly Guide[],\n  options?: Omit<GuideSnapOptions<TPose>, 'origin'>,\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> & { origin: OriginProjection<TPose> },\n): SnapStrategy<TPose>;\n/** Snap a pose's origin to the nearest guide line within tolerance, per axis. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> = {},\n): SnapStrategy<TPose> {\n  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;\n  const proj: OriginProjection<TPose> =\n    options.origin ?? (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n\n  return {\n    snap(pose, ctx) {\n      const guides = getGuides();\n      if (guides.length === 0) return null;\n\n      // Per axis: a guide on the x axis is matched by a horizontal distance,\n      // so it answers to `scale.x` alone.\n      const tol = screenTolerance(tolerance, ctx);\n\n      const o = proj.getOrigin(pose);\n      const dx = nearestGuideDelta(guides, 'x', o.x, tol.x, ctx.plane) ?? 0;\n      const dy = nearestGuideDelta(guides, 'y', o.y, tol.y, ctx.plane) ?? 0;\n      if (dx === 0 && dy === 0) return null;\n      return proj.translate(pose, dx, dy);\n    },\n  };\n}\n"]}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { RefObject } from 'react';
-import { ViewTransform, UnitValue, UnitSystem, Stroke, RenderLayer, FillStyle, SnapStrategy, DebugSink, OriginProjection, ModifierState, Bounds, PoseDescriptor, InsertBehavior, MoveBehavior, BoundsConstraint, LayoutSnap, LayoutStrategy, Vec2 } from '@weasel-js/core';
+import { ViewTransform, UnitValue, UnitSystem, CommandStroke, RenderLayer, CommandFill, SnapStrategy, DebugSink, OriginProjection, ModifierState, Bounds, PlaneMap, PoseDescriptor, InsertBehavior, MoveBehavior, BoundsConstraint, LayoutSnap, LayoutStrategy, Vec2 } from '@weasel-js/core';
 export { p as pointSnapToGrid } from './pointSnapToGrid-BaVEjV23.js';
 import { G as Guide, S as SpacingGap } from './types-DRSPiXfk.js';
 
@@ -97,9 +97,9 @@ interface GridLayerOpts {
     subdivisions?: number;
     /** Per-band stroke styles. Each is a FillStyle+width (etc.) — see `Stroke`. */
     style?: {
-        line?: Stroke;
-        accent?: Stroke;
-        sub?: Stroke;
+        line?: CommandStroke;
+        accent?: CommandStroke;
+        sub?: CommandStroke;
     };
 }
 /** Build a `RenderLayer` that draws a world-space grid with optional accent lines and subdivisions. */
@@ -128,7 +128,7 @@ interface CellHighlightLayerOpts {
         row: number;
     } | null;
     /** FillStyle strategy for the filled cell. Defaults to a soft green. */
-    fill?: FillStyle;
+    fill?: CommandFill;
 }
 /** Build a `RenderLayer` that fills a single grid cell — typically a snap-target preview. */
 declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderLayer<unknown>;
@@ -275,8 +275,14 @@ interface SpacingMatchResult {
 /** Which candidate lines to derive from a set of poses — edges, centers, or
  *  both, and whether the page box contributes its own. */
 interface DeriveAlignmentGuidesOptions<TPose = Bounds> {
-    /** Include the document/page box's edges + center as candidates. */
+    /** Include the document/page box's edges + center as candidates. It is in
+     *  the camera's world, as every line derived is. */
     page?: Bounds;
+    /** The parallax plane a target's pose is stored in, for a sibling on a
+     *  `parallax` layer (`view.planeOf(layer)`). Its box is carried out to the
+     *  camera's world, which is the world alignment candidates are in. Omit it,
+     *  or answer null, for a target already there. */
+    planeOf?: (target: TPose, index: number) => PlaneMap | null | undefined;
     /** Emit left/right (x) and top/bottom (y) edge guides. Default true. */
     edges?: boolean;
     /** Emit centerX (x) and centerY (y) guides. Default true. */
@@ -285,9 +291,17 @@ interface DeriveAlignmentGuidesOptions<TPose = Bounds> {
      *  gets, or the two sides disagree. Default `AUTO_POSE_DESCRIPTOR`. */
     poseDescriptor?: PoseDescriptor<TPose>;
 }
-/** Common options shared by the three alignment behavior factories. */
+/** Common options shared by the three alignment behavior factories.
+ *
+ *  Everything crossing this interface is in the camera's world, whatever
+ *  layer the gesture edits: the candidate lines and spacing boxes handed in,
+ *  and the lines and gaps published, which a layer the camera draws shows.
+ *  A gesture on a `parallax` layer carries them into its plane to match. */
 interface AlignmentBehaviorBase {
-    /** Live candidate lines — consumer derives from current siblings + page. */
+    /** Live candidate lines — consumer derives from current siblings + page.
+     *  A sibling on a parallax layer goes through `deriveAlignmentGuides`'
+     *  `planeOf`, or its lines land where its plane's numbers say, not where
+     *  it is drawn. */
     getCandidates: () => readonly Guide[];
     /** Publish the currently-matched line(s). Called every onMove; cleared
      *  (`[]`) on a miss and on onEnd. */
@@ -311,7 +325,9 @@ interface AlignmentBehaviorBase {
  *  edges and the center. Overlapping offsets collapse to one candidate, whose
  *  `span` covers every box that produced it.
  *  Poses go through the same descriptor `alignMoveBehavior` matches with, so
- *  a rotated sibling advertises its ink edges rather than its stored box. */
+ *  a rotated sibling advertises its ink edges rather than its stored box.
+ *  The lines are in the camera's world: a sibling on a parallax layer needs
+ *  `planeOf` to say which plane its pose is in. */
 declare function deriveAlignmentGuides<TPose = Bounds>(targets: readonly TPose[], opts?: DeriveAlignmentGuidesOptions<TPose>): Guide[];
 
 /** Move/insert test all three features per axis. */
@@ -378,10 +394,10 @@ interface AlignMoveArgs<TPose> extends AlignmentBehaviorBase {
  *  transform uniformly to every dragged id, so the selection shifts together
  *  and stays rigid. Single-select is the degenerate one-box union. Publishes
  *  the matched line(s); clears on miss, end and cancel. */
-declare function alignMoveBehavior<TPose>(args: AlignMoveArgs<TPose>): MoveBehavior<TPose>;
+declare function alignMoveBehavior<TPose>(given: AlignMoveArgs<TPose>): MoveBehavior<TPose>;
 /** Insert behavior: snap the live `current` point to candidates (treating it
  *  as a zero-size box). Publishes the matched line(s). */
-declare function alignInsertBehavior<TPose>(args: AlignmentBehaviorBase): InsertBehavior<TPose>;
+declare function alignInsertBehavior<TPose>(given: AlignmentBehaviorBase): InsertBehavior<TPose>;
 /** Resize constraint: snap the corner(s) the drag moves, as drawn, to
  *  candidates; the pinned corner stays fixed. On an unrotated pose that is
  *  the moving edge(s). On a rotated one the node's own axes set how the
@@ -389,7 +405,7 @@ declare function alignInsertBehavior<TPose>(args: AlignmentBehaviorBase): Insert
  *  slides its edge until the nearer of its two corners meets a line.
  *  `poseDescriptor` reads the origin pose's box and rotation, and must match
  *  the resize action's. Publishes the matched line(s). */
-declare function alignResizeBehavior<TPose extends Bounds>(args: AlignMoveArgs<TPose>): BoundsConstraint<TPose>;
+declare function alignResizeBehavior<TPose extends Bounds>(given: AlignMoveArgs<TPose>): BoundsConstraint<TPose>;
 
 /** Default snap tolerance (screen pixels). */
 declare const DEFAULT_GUIDE_TOLERANCE_PX = 6;

package/dist/index.js

@@ -1,9 +1,10 @@
-import { pointToGridCell } from './chunk-5BCCIJY3.js';
-export { gridSnapStrategy, pointToGridCell } from './chunk-5BCCIJY3.js';
+import { pointToGridCell } from './chunk-JETW4ZA3.js';
+export { gridSnapStrategy, pointToGridCell } from './chunk-JETW4ZA3.js';
 export { pointSnapToGrid } from './chunk-B25KFI3I.js';
-export { DEFAULT_GUIDE_TOLERANCE_PX, guideSnapStrategy } from './chunk-GEDAPTOM.js';
+import { guideOffsetOn } from './chunk-NIEZTECL.js';
+export { DEFAULT_GUIDE_TOLERANCE_PX, guideSnapStrategy } from './chunk-NIEZTECL.js';
 import { useState, useRef, useCallback, useEffect } from 'react';
-import { useLatest, resolveUnit, pxExtent, textCommandFromRuns, AUTO_POSE_DESCRIPTOR, visualBoundsViaDescriptor, translatePoseViaDescriptor, unionBounds, fixedCornerOf, createTransformOp, resolveStrokeWidth, screenToWorld, screenTolerance } from '@weasel-js/core';
+import { useLatest, resolveUnit, 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';
 
 // src/grid/roundToCell.ts
@@ -88,11 +89,11 @@ function createGridLayer(opts) {
           coords: new Float32Array([sx, sy, ex, ey]),
           fillRule: "nonzero"
         };
-        const across = sx === ex ? px.x : px.y;
+        const across2 = sx === ex ? px.x : px.y;
         children.push({
           kind: "path",
           path,
-          stroke: { ...s, width: resolveStrokeWidth(s.width ?? 1, 1) * across }
+          stroke: { ...s, width: resolveStrokeWidth(s.width ?? 1, 1) * across2 }
         });
       };
       if (subdivisions && subdivisions > 1) {
@@ -291,7 +292,11 @@ function deriveAlignmentGuides(targets, opts = {}) {
       add("y", b.y + b.height / 2, b);
     }
   };
-  for (const t of targets) emit(visualBoundsViaDescriptor(t, d));
+  targets.forEach((t, i) => {
+    const box = visualBoundsViaDescriptor(t, d);
+    const plane = opts.planeOf?.(t, i);
+    emit(plane ? rectFromPlane(plane, box) : box);
+  });
   if (opts.page) emit(opts.page);
   return [...seenX.values(), ...seenY.values()];
 }
@@ -460,6 +465,39 @@ 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;
+  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))) } : {}
+  };
+}
+
+// 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) {
@@ -491,10 +529,11 @@ function publish(args, r) {
 function worldTol(base, ctx) {
   return screenTolerance(base.tolerance ?? 6, ctx);
 }
-function alignMoveBehavior(args) {
-  const d = args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+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;
@@ -517,17 +556,18 @@ function alignMoveBehavior(args) {
       return { transform: { kind: "translate", dx: transform.dx + r.dx, dy: transform.dy + r.dy } };
     },
     onEnd() {
-      publish(args, null);
+      publish(given, null);
     },
     onCancel() {
-      publish(args, null);
+      publish(given, null);
     }
   };
 }
-function alignInsertBehavior(args) {
+function alignInsertBehavior(given) {
   const pointAnchors = { x: ["min"], y: ["min"] };
   return {
     onMove(ctx, { current }) {
+      const args = alignmentOnPlane(given, ctx.plane);
       if (args.bypassKey && ctx.modifiers[args.bypassKey]) {
         args.setActiveGuides([]);
         return;
@@ -542,17 +582,18 @@ function alignInsertBehavior(args) {
       return { current: { x: current.x + m.dx, y: current.y + m.dy } };
     },
     onEnd() {
-      args.setActiveGuides([]);
+      given.setActiveGuides([]);
     },
     onCancel() {
-      args.setActiveGuides([]);
+      given.setActiveGuides([]);
     }
   };
 }
-function alignResizeBehavior(args) {
-  const d = args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+function alignResizeBehavior(given) {
+  const d = given.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
   return {
     onMove(ctx, { pose, anchor }) {
+      const args = alignmentOnPlane(given, ctx.plane);
       if (args.bypassKey && ctx.modifiers[args.bypassKey]) {
         publish(args, null);
         return;
@@ -579,10 +620,10 @@ function alignResizeBehavior(args) {
       return { pose: { ...pose, x, y, width, height } };
     },
     onEnd() {
-      publish(args, null);
+      publish(given, null);
     },
     onCancel() {
-      publish(args, null);
+      publish(given, null);
     }
   };
 }
@@ -627,8 +668,8 @@ function matchRotatedCorners(pose, anchor, originBox, rotation, candidates, tol)
   const dir = along === "x" ? toWorld(1, 0) : toWorld(0, 1);
   const edge = movingEdge(along)[0];
   let best = null;
-  for (const across2 of movingEdge(along === "x" ? "y" : "x")) {
-    const c = along === "x" ? drawn(edge, across2) : drawn(across2, edge);
+  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;
@@ -638,8 +679,8 @@ function matchRotatedCorners(pose, anchor, originBox, rotation, candidates, tol)
     }
   }
   if (best === null) return null;
-  const across = best.guide.axis === "x" ? best.at.y + best.t * dir.y : best.at.x + best.t * dir.x;
-  const guides = [stretchSpan(best.guide, across, across)];
+  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: [] };
 }
 
@@ -798,7 +839,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 pack(from, into, children) {
+  function pack(from, into2, 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;
@@ -809,7 +850,7 @@ function tileGrid(opts) {
     });
     const out = /* @__PURE__ */ new Map();
     for (let i = 0; i < ordered.length; i++) {
-      out.set(ordered[i].c.id, cellToPose(into.rectAt(i), ordered[i].c.pose));
+      out.set(ordered[i].c.id, cellToPose(into2.rectAt(i), ordered[i].c.pose));
     }
     return out;
   }