@weasel-js/guides 1.9.3 → 1.10.0

package/README.md

@@ -52,7 +52,7 @@ import { snapToGrid } from '@weasel-js/guides/insert';
 |---|---|
 | Grid | `createGridLayer`, `createCellHighlightLayer`, `useGridCellHover`, `gridSnapStrategy`, `pointToGridCell`, `pointSnapToGrid`, `roundToCell` |
 | Guides | `useGuides`, `createGuidesLayer`, `guideSnapStrategy`, `deriveAlignmentGuides`, `matchAlignment`, `alignMoveBehavior`, `alignResizeBehavior`, `alignInsertBehavior` |
-| Layout | `freeform`, `tileGrid`, `snapPoint`, and the drop-target pickers `none`, `nearest`, `nearestWithin`, `containedThenNearest`, `cellAt` |
+| Layout | `freeform`, `tileGrid`, `snapPoint`, `slots` (with the `rowSlots`, `gridSlots`, and `ringSlots` arrangements), `pack`, `quadtree`, `perContainer` for a strategy that keeps state, and the drop-target pickers `none`, `nearest`, `nearestWithin`, `containedThenNearest`, `cellAt` |
 
 ## License
 

package/dist/chunk-LOFNN7EQ.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-LOFNN7EQ.js.map
+//# sourceMappingURL=chunk-LOFNN7EQ.js.map

package/dist/chunk-LOFNN7EQ.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;AAuCnC,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-LOFNN7EQ.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 * Combining with `gridSnapStrategy` is left to the consumer.\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/{chunk-5BCCIJY3.js → chunk-TLFMAZ6M.js}

@@ -1,33 +1,31 @@
-import { AUTO_ORIGIN_PROJECTION, resolveUnit, fromPlane, toPlane } from '@weasel-js/core';
+import { roundToGridOn } from './chunk-LOFNN7EQ.js';
+import { AUTO_ORIGIN_PROJECTION, resolveAxes } 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 isOpts = typeof arg === "object" && arg !== null && ("origin" in arg || "debug" in arg || "unitSystem" in arg) && !("base" in arg) && !("x" in arg);
   const optsArg = isOpts ? arg : null;
   const unitSystem = optsArg ? optsArg.unitSystem : arg;
   const proj = optsArg && optsArg.origin ? optsArg.origin : AUTO_ORIGIN_PROJECTION;
   const debug = optsArg ? optsArg.debug : void 0;
-  const c = resolveUnit(spacing, unitSystem);
+  const c = resolveAxes(spacing, unitSystem);
   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.x, ctx?.plane);
+      const sy = roundToGridOn(o.y, "y", c.y, ctx?.plane);
       debug?.recordSnapCandidate({ x: sx, y: sy }, true);
       return proj.translate(pose, sx - o.x, sy - o.y);
     }
   };
 }
 function pointToGridCell(point, spacing, unitSystem, origin = { x: 0, y: 0 }) {
-  const s = resolveUnit(spacing, unitSystem);
+  const s = resolveAxes(spacing, unitSystem);
   return {
-    col: Math.floor((point.x - origin.x) / s),
-    row: Math.floor((point.y - origin.y) / s)
+    col: Math.floor((point.x - origin.x) / s.x),
+    row: Math.floor((point.y - origin.y) / s.y)
   };
 }
 
 export { gridSnapStrategy, pointToGridCell };
-//# sourceMappingURL=chunk-5BCCIJY3.js.map
-//# sourceMappingURL=chunk-5BCCIJY3.js.map
+//# sourceMappingURL=chunk-TLFMAZ6M.js.map
+//# sourceMappingURL=chunk-TLFMAZ6M.js.map

package/dist/chunk-TLFMAZ6M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strategies/grid.ts"],"names":[],"mappings":";;;AAkCO,SAAS,gBAAA,CACd,SACA,GAAA,EACqB;AACrB,EAAA,MAAM,SACJ,OAAO,GAAA,KAAQ,QAAA,IACf,GAAA,KAAQ,SACP,QAAA,IAAY,GAAA,IAAO,OAAA,IAAW,GAAA,IAAO,gBAAgB,GAAA,CAAA,IACtD,EAAE,MAAA,IAAU,GAAA,CAAA,IACZ,EAAE,GAAA,IAAO,GAAA,CAAA;AACX,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,EAAA,GAAK,cAAc,CAAA,CAAE,CAAA,EAAG,KAAK,CAAA,CAAE,CAAA,EAAG,KAAK,KAAK,CAAA;AAClD,MAAA,MAAM,EAAA,GAAK,cAAc,CAAA,CAAE,CAAA,EAAG,KAAK,CAAA,CAAE,CAAA,EAAG,KAAK,KAAK,CAAA;AAClD,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;AAOO,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,GAAA,EAAK,KAAK,KAAA,CAAA,CAAO,KAAA,CAAM,IAAI,MAAA,CAAO,CAAA,IAAK,EAAE,CAAC,CAAA;AAAA,IAC1C,GAAA,EAAK,KAAK,KAAA,CAAA,CAAO,KAAA,CAAM,IAAI,MAAA,CAAO,CAAA,IAAK,EAAE,CAAC;AAAA,GAC5C;AACF","file":"chunk-TLFMAZ6M.js","sourcesContent":["import {\n  AUTO_ORIGIN_PROJECTION,\n  resolveAxes,\n  type DebugSink,\n  type OriginProjection,\n  type SnapStrategy,\n  type PlaneUnits,\n  type PlaneValue,\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`). Either may be per axis —\n *  `{ x, y }` — for a grid whose axes have different pitches or units. For\n *  non-rect TPose pass an `OriginProjection` so the strategy knows how to\n *  read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: PlaneValue,\n  unitSystem?: PlaneUnits,\n): SnapStrategy<TPose>;\n/** As above, additionally reporting each candidate to a debug sink. */\nexport function gridSnapStrategy<TPose>(\n  spacing: PlaneValue,\n  opts: { unitSystem?: PlaneUnits; 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: PlaneValue,\n  opts: { unitSystem?: PlaneUnits; 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: PlaneValue,\n  arg?: PlaneUnits | { unitSystem?: PlaneUnits; 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    !('x' in arg);\n  const optsArg = isOpts\n    ? (arg as { unitSystem?: PlaneUnits; origin?: OriginProjection<TPose>; debug?: DebugSink })\n    : null;\n  const unitSystem = optsArg ? optsArg.unitSystem : (arg as PlaneUnits | 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 = resolveAxes(spacing, unitSystem);\n  return {\n    snap(pose, ctx) {\n      const o = proj.getOrigin(pose);\n      const sx = roundToGridOn(o.x, 'x', c.x, ctx?.plane);\n      const sy = roundToGridOn(o.y, 'y', c.y, 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 * The integer cell `{col, row}` that contains `point`. Pair with\n * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target\n * preview that uses the same spacing as `gridSnapStrategy`.\n */\nexport function pointToGridCell(\n  point: { x: number; y: number },\n  spacing: PlaneValue,\n  unitSystem?: PlaneUnits,\n  origin: { x: number; y: number } = { x: 0, y: 0 },\n): { col: number; row: number } {\n  const s = resolveAxes(spacing, unitSystem);\n  return {\n    col: Math.floor((point.x - origin.x) / s.x),\n    row: Math.floor((point.y - origin.y) / s.y),\n  };\n}\n"]}

package/dist/index.d.ts

@@ -1,21 +1,15 @@
 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, PlaneValue, PlaneUnits, CommandStroke, RenderLayer, CommandFill, SnapStrategy, DebugSink, OriginProjection, ModifierState, Bounds, PlaneMap, PoseDescriptor, InsertBehavior, MoveBehavior, BoundsConstraint, LayoutSnap, LayoutStrategy, LayoutContainer, Vec2, ContainerBounds, LayoutChild } from '@weasel-js/core';
 export { p as pointSnapToGrid } from './pointSnapToGrid-BaVEjV23.js';
 import { G as Guide, S as SpacingGap } from './types-DRSPiXfk.js';
+import { Rect } from '@weasel-js/geom';
 
 /** Round `value` to the nearest multiple of `cellSize`. Returns 0 when the result would be -0. */
 declare function roundToCell(value: number, cellSize: number): number;
 
 /**
  * Pointer-tracking glue that turns hover position into a grid cell, suitable
- * for dropping straight into `createCellHighlightLayer({ getCell })`. Pairs
- * with `gridSnapStrategy` / `createGridLayer` so the visual hover preview
- * uses the exact same spacing as the snap behavior.
- *
- * Wires three things you'd otherwise glue by hand:
- *   1. pointermove on a target element → client coords
- *   2. client coords → world coords via your `ViewTransform`
- *   3. world coords → integer `{col, row}` via `pointToGridCell`
+ * for dropping straight into `createCellHighlightLayer({ getCell })`.
  *
  * State updates only fire when the cell actually changes (not on every
  * pointer tick). Pass `onChange` to trigger a canvas redraw on each transition.
@@ -30,9 +24,9 @@ interface UseGridCellHoverOptions {
     view: () => ViewTransform;
     /** Cell spacing in world units. Same value you pass to `createGridLayer`
      *  and `createCellHighlightLayer`. */
-    spacing: UnitValue;
+    spacing: PlaneValue;
     /** Required if `spacing` is tagged (e.g. `{ value: 1, unit: 'ft' }`). */
-    unitSystem?: UnitSystem;
+    unitSystem?: PlaneUnits;
     /** Origin the cell grid is anchored to, in world units. Default `(0, 0)`. */
     origin?: {
         x: number;
@@ -80,10 +74,11 @@ interface GridLayerOpts {
      * Distance between adjacent grid lines (also known as grid pitch),
      * in world (base) units. Accepts a bare number or a tagged
      * `{ value, unit }`. Tagged values require `unitSystem` to be supplied.
+     * Either may be per axis — `{ x, y }`.
      */
-    spacing: UnitValue;
+    spacing: PlaneValue;
     /** Optional unit system for resolving tagged `spacing` values. */
-    unitSystem?: UnitSystem;
+    unitSystem?: PlaneUnits;
     /** Bounds of the area to cover, in world units. */
     bounds: () => {
         x: number;
@@ -95,11 +90,11 @@ interface GridLayerOpts {
     accentEvery?: number;
     /** Optional finer subdivisions per cell. e.g. 4 -> 4 sub-lines per cell. */
     subdivisions?: number;
-    /** Per-band stroke styles. Each is a FillStyle+width (etc.) — see `Stroke`. */
+    /** Per-band stroke styles. Each is a Paint+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. */
@@ -114,9 +109,9 @@ declare function createGridLayer(opts: GridLayerOpts): RenderLayer<unknown>;
 /** Options for `createCellHighlightLayer`. */
 interface CellHighlightLayerOpts {
     /** Cell size in world units (matches the grid's `spacing`). */
-    spacing: UnitValue;
+    spacing: PlaneValue;
     /** Optional unit system for resolving tagged `spacing` values. */
-    unitSystem?: UnitSystem;
+    unitSystem?: PlaneUnits;
     /** Origin the cell grid is anchored to, in world units. Defaults to (0,0). */
     origin?: () => {
         x: number;
@@ -127,49 +122,39 @@ interface CellHighlightLayerOpts {
         col: number;
         row: number;
     } | null;
-    /** FillStyle strategy for the filled cell. Defaults to a soft green. */
-    fill?: FillStyle;
+    /** Fill for the highlighted cell. Defaults to a soft green. */
+    fill?: CommandFill;
 }
 /** Build a `RenderLayer` that fills a single grid cell — typically a snap-target preview. */
 declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderLayer<unknown>;
 
 /** Snap-strategy that rounds the pose's origin to the nearest multiple of
- *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an
- *  `OriginProjection` so the strategy knows how to read/write the origin. */
-declare function gridSnapStrategy<TPose>(spacing: UnitValue, unitSystem?: UnitSystem): SnapStrategy<TPose>;
+ *  `spacing` (resolved through `unitSystem`). Either may be per axis —
+ *  `{ x, y }` — for a grid whose axes have different pitches or units. For
+ *  non-rect TPose pass an `OriginProjection` so the strategy knows how to
+ *  read/write the origin. */
+declare function gridSnapStrategy<TPose>(spacing: PlaneValue, unitSystem?: PlaneUnits): SnapStrategy<TPose>;
 /** As above, additionally reporting each candidate to a debug sink. */
-declare function gridSnapStrategy<TPose>(spacing: UnitValue, opts: {
-    unitSystem?: UnitSystem;
+declare function gridSnapStrategy<TPose>(spacing: PlaneValue, opts: {
+    unitSystem?: PlaneUnits;
     debug?: DebugSink;
 }): SnapStrategy<TPose>;
 /** As above, for a `TPose` that is not a rect: `origin` tells the strategy how
  *  to read and write the pose's origin. */
-declare function gridSnapStrategy<TPose>(spacing: UnitValue, opts: {
-    unitSystem?: UnitSystem;
+declare function gridSnapStrategy<TPose>(spacing: PlaneValue, opts: {
+    unitSystem?: PlaneUnits;
     origin: OriginProjection<TPose>;
     debug?: DebugSink;
 }): SnapStrategy<TPose>;
 /**
- * Compute the integer cell `{col, row}` that contains `point`, given a grid
- * `spacing` and optional `origin` and `unitSystem`. Pair with
+ * The integer cell `{col, row}` that contains `point`. Pair with
  * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target
- * preview that uses the same spacing as `gridSnapStrategy` — so the visual
- * and behavioral grids stay in lockstep:
- *
- *     const SPACING = 20;
- *     const snap = gridSnapStrategy(SPACING);
- *     // visual grid:
- *     createGridLayer({ spacing: SPACING, bounds: () => ... });
- *     // hover-preview overlay:
- *     createCellHighlightLayer({
- *       spacing: SPACING,
- *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),
- *     });
+ * preview that uses the same spacing as `gridSnapStrategy`.
  */
 declare function pointToGridCell(point: {
     x: number;
     y: number;
-}, spacing: UnitValue, unitSystem?: UnitSystem, origin?: {
+}, spacing: PlaneValue, unitSystem?: PlaneUnits, origin?: {
     x: number;
     y: number;
 }): {
@@ -275,8 +260,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 +276,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 +310,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. */
@@ -328,9 +329,8 @@ declare const MOVE_ANCHORS: {
  * from the aligned siblings to the box being dragged.
  *
  * `worldTolerance` is per axis because a screen-pixel tolerance is not one
- * world distance under non-uniform zoom — and each axis here is matched by a
- * distance along that axis alone, so there is an exact answer rather than an
- * approximation. Pass the same number twice for a world-space tolerance.
+ * world distance under non-uniform zoom. Pass the same number twice for a
+ * world-space tolerance.
  */
 declare function matchAlignment(bounds: Bounds, candidates: readonly Guide[], worldTolerance: {
     x: number;
@@ -340,14 +340,13 @@ declare function matchAlignment(bounds: Bounds, candidates: readonly Guide[], wo
     y: readonly AlignAnchor[];
 }): AlignMatchResult;
 
-type Axis = 'x' | 'y';
 /**
  * The visible gaps between neighboring boxes along `axis`: for `'x'`, each box
  * and the nearest box to its right that shares some of its vertical range, as
  * long as no third box stands in the strip between them. These are the gaps an
  * equal-spacing snap can reproduce.
  */
-declare function measureGaps(targets: readonly Bounds[], axis: Axis): SpacingGap[];
+declare function measureGaps(targets: readonly Bounds[], axis: 'x' | 'y'): SpacingGap[];
 /**
  * Match a box against the gaps between `targets`, Figma's "equal spacing":
  * on each axis, find where the box's gap to a neighbor equals a gap that
@@ -378,10 +377,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 +388,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;
@@ -416,10 +415,7 @@ interface GuideSnapOptions<TPose> {
  * same axis, the closest wins.
  *
  * Pair with `useGuides` for storage and `createGuidesLayer` for rendering.
- *
- * **Composition:** combining with `gridSnapStrategy` is left to the
- * consumer in v1 — typically by picking one based on a modifier key, or
- * by stacking two move/resize/insert behaviors in priority order.
+ * Combining with `gridSnapStrategy` is left to the consumer.
  */
 declare function guideSnapStrategy<TPose extends {
     x: number;
@@ -460,6 +456,34 @@ declare function containedThenNearest<TPose>(): LayoutSnap<TPose>;
  */
 declare function cellAt<TPose>(): LayoutSnap<TPose>;
 
+/** Options for `perContainer`. */
+interface PerContainerOptions<TPose> {
+    /** The snap every container shares: a strategy's `snap` is read with no
+     *  container in hand, so it cannot come from the one the factory builds. */
+    snap: LayoutSnap<TPose>;
+    /** Shared for the same reason. Absent, a container's body is its bounds. */
+    contains?: LayoutStrategy<TPose>['contains'];
+    /** How many containers' strategies to keep. Past it, the one used longest
+     *  ago is dropped and built again when next asked for. Default 256. */
+    max?: number;
+}
+/** A strategy `perContainer` built, and the way to drop one container's state. */
+type PerContainerStrategy<TPose> = LayoutStrategy<TPose> & {
+    /** Drop what was built for `containerId`: for a container that is gone, or
+     *  whose cached state no longer describes it. */
+    forget(containerId: string): void;
+};
+/**
+ * A layout strategy that keeps state, as one strategy value: `factory` runs
+ * once for each container the layout is asked about, and what it returns
+ * serves that container from then on, closing over whatever it caches — a
+ * spatial index, the last arrangement, a solver's warm start.
+ *
+ * Declare the result on as many containers as you like. A method the built
+ * strategy leaves out behaves as its absence would.
+ */
+declare function perContainer<TPose>(factory: (container: LayoutContainer) => LayoutStrategy<TPose>, opts: PerContainerOptions<TPose>): PerContainerStrategy<TPose>;
+
 /** Options for `freeform`. */
 interface FreeformOptions<TPose> {
     snap?: LayoutSnap<TPose>;
@@ -472,12 +496,6 @@ interface FreeformOptions<TPose> {
  */
 declare function freeform<TPose>(opts?: FreeformOptions<TPose>): LayoutStrategy<TPose>;
 
-type Rect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
 /**
  * What a `tileGrid` does with a child past its `cols × rows` cells.
  *
@@ -508,10 +526,8 @@ interface TileGridOptions<TPose> {
     snap?: LayoutSnap<TPose>;
     /** Optional: map a cell rect + the dragged pose to the new pose. Default
      *  writes `{ x, y, width, height }` into the dragged pose (assumes
-     *  `RectPose`). Override for point-only poses or other shapes. The
-     *  `dragged` argument is the pre-drop pose of the child being placed —
-     *  use it to preserve fields the cell rect doesn't carry (e.g. rotation,
-     *  domain metadata). */
+     *  `RectPose`). `dragged` is the pre-drop pose of the child being placed —
+     *  use it to preserve fields the cell rect doesn't carry (e.g. rotation). */
     cellToPose?(cellRect: Rect, dragged: TPose): TPose;
     /** Optional: the point that decides which cell a child occupies — a child
      *  occupies the cell containing it. Default reads `x`/`y` plus half of
@@ -550,4 +566,194 @@ interface SnapPointOptions<TPose> {
  *  child to land on. */
 declare function snapPoint<TPose extends Vec2>(opts: SnapPointOptions<TPose>): LayoutStrategy<TPose>;
 
-export { type AlignAnchor, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type CellHighlightLayerOpts, DEFAULT_GUIDE_TOLERANCE_PX, type DeriveAlignmentGuidesOptions, type FreeformOptions, type GridLayerOpts, Guide, type GuideSnapOptions, type GuidesLayerOpts, MOVE_ANCHORS, type SnapPattern, type SnapPointOptions, type SpacingEdge, SpacingGap, type SpacingMatchResult, type TileGridOptions, type TileGridOverflow, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, cellAt, containedThenNearest, createCellHighlightLayer, createGridLayer, createGuidesLayer, deriveAlignmentGuides, freeform, gridSnapStrategy, guideSnapStrategy, matchAlignment, matchSpacing, measureGaps, nearest, nearestWithin, none, pointToGridCell, roundToCell, snapPoint, tileGrid, useGridCellHover, useGuides };
+/** One place a child's center goes. */
+interface Slot {
+    x: number;
+    y: number;
+    /** The direction the slot faces, in radians, where the arrangement has one
+     *  — outward from the center on a ring. `slotToPose` decides what to do
+     *  with it; the default ignores it. */
+    angle?: number;
+}
+/**
+ * Where a container's slots are when it holds `count` children, in fill
+ * order. Returning fewer than `count` caps the container: `slots` refuses
+ * whatever would not fit.
+ */
+type Arrangement = (bounds: ContainerBounds, count: number) => Slot[];
+/** Options for `rowSlots`. */
+interface RowSlotsOptions {
+    /** The axis the row runs along. Default `'x'`. */
+    axis?: 'x' | 'y';
+    /** Distance between neighboring slots, in world units, the row centered in
+     *  the container. Absent, the slots divide the container's length evenly. */
+    pitch?: number;
+}
+/** Slots in a line, centered across the container. */
+declare function rowSlots(opts?: RowSlotsOptions): Arrangement;
+/** Options for `gridSlots`. */
+interface GridSlotsOptions {
+    cols: number;
+    /** Rows the grid has before any child needs one. Default 1. */
+    rows?: number;
+}
+/** Slots at the centers of a grid that fills row by row, adding a row when the
+ *  last fills; the rows always divide the container's height. */
+declare function gridSlots(opts: GridSlotsOptions): Arrangement;
+/** Options for `ringSlots`. */
+interface RingSlotsOptions {
+    /** Angle of the first slot, in radians, 0 pointing along +x and positive
+     *  turning toward +y. Default −π/2: the top, on a y-down canvas. */
+    start?: number;
+    /** How far round the slots run. Default a full turn, which spaces them
+     *  evenly; anything less puts a slot on each end of the arc. */
+    sweep?: number;
+    /** Distance to pull the ring in from the container's edges. Default 0. */
+    inset?: number;
+}
+/** Slots around the ellipse inscribed in the container, each facing outward. */
+declare function ringSlots(opts?: RingSlotsOptions): Arrangement;
+
+/** Options for `slots`. */
+interface SlotsOptions<TPose> {
+    /** Where the slots are for a given child count: `rowSlots`, `gridSlots`,
+     *  `ringSlots`, or a function of your own. */
+    arrangement: Arrangement;
+    /** Which slot a drag means. Default `nearest()`. */
+    snap?: LayoutSnap<TPose>;
+    /** The pose a child takes in a slot. Default centers the child's own
+     *  `width`/`height` on the slot and keeps every other field. */
+    slotToPose?(slot: Slot, pose: TPose): TPose;
+    /** The point that decides which slot a child sits in. Default is the
+     *  center of a `RectPose`, and the point itself for a point pose. */
+    centerOf?(pose: TPose): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Layout strategy that keeps its children in a sequence of slots — a row, a
+ * grid, a ring — whose positions depend on how many children there are, so
+ * the arrangement re-spaces itself as children come and go.
+ *
+ * A child's place in the sequence is the slot it sits nearest. Dropping a
+ * drag on a slot inserts it there and shifts the children between; a drag
+ * from outside is offered one slot more than the container holds. An insert
+ * or reparent lands at the slot nearest where the child was put.
+ */
+declare function slots<TPose>(opts: SlotsOptions<TPose>): LayoutStrategy<TPose>;
+
+/**
+ * What `pack` does when its shelves run past the container's height.
+ *
+ * - `'reject'` (default) — refuse the child that would not fit, by any route.
+ * - `'grow'` — the container's height follows its content, never below
+ *   `minHeight`.
+ * - `'scroll'` — the container keeps its size and the shelves run on below
+ *   it; `contentExtent` reports the region they cover.
+ */
+type PackOverflow = 'reject' | 'grow' | 'scroll';
+/** Options for `pack`. */
+interface PackOptions<TPose> {
+    /** Space between neighbors on a shelf and between shelves, in world units. Default 0. */
+    gap?: number;
+    /** What happens past the container's height. Default `'reject'`. */
+    overflow?: PackOverflow;
+    /** The least height a `'grow'` container shrinks to. Default 0. */
+    minHeight?: number;
+    /** Which index a drag means. Default `nearest()`. */
+    snap?: LayoutSnap<TPose>;
+    /** A child's box. Default reads `x`, `y`, `width`, and `height` off the pose. */
+    rectOf?(pose: TPose): Rect;
+    /** `pose` with its box's top-left at `at`. Default writes `x` and `y`. */
+    moveTo?(pose: TPose, at: {
+        x: number;
+        y: number;
+    }): TPose;
+}
+/**
+ * Layout strategy that packs children of any size onto shelves: left to
+ * right at their own sizes, wrapping at the container's width, each shelf as
+ * tall as its tallest child. A child wider than the container is refused.
+ *
+ * The children's order is the order they read in — shelf by shelf, left to
+ * right. A drop inserts at the index nearest the pointer and everything after
+ * it reflows.
+ */
+declare function pack<TPose>(opts?: PackOptions<TPose>): LayoutStrategy<TPose>;
+
+/** Options for `quadtree`. */
+interface QuadtreeOptions<TPose> {
+    /** How many times the container may be quartered. Default 4, a 16 × 16 grid at its finest. */
+    maxDepth?: number;
+    /** Which free cell a drag means. Default `containedThenNearest()`. */
+    snap?: LayoutSnap<TPose>;
+    /** The length a cell's shorter side must reach to hold the child. Default
+     *  is the larger of the pose's `width` and `height`. */
+    sizeOf?(pose: TPose): number;
+    /** The pose a child takes in a cell. Default centers the child's own size
+     *  in the cell and keeps every other field. */
+    cellToPose?(cell: Rect, pose: TPose): TPose;
+    /** The point that decides which cell a child sits in. Default is the
+     *  center of a `RectPose`, and the point itself for a point pose. */
+    centerOf?(pose: TPose): {
+        x: number;
+        y: number;
+    };
+}
+/** One cell a child holds: {@link QuadtreeStrategy.cells}. */
+interface QuadtreeCell {
+    id: string;
+    /** How many times the container was quartered to reach the cell. */
+    depth: number;
+    rect: Rect;
+}
+/** A `quadtree` layout, which also reports the cells it has given out. */
+interface QuadtreeStrategy<TPose> extends LayoutStrategy<TPose> {
+    /** The cell each child holds, largest first: what a debug overlay draws. */
+    cells(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>): QuadtreeCell[];
+}
+/**
+ * Layout strategy that quarters its container as far as each child needs: a
+ * child holds the smallest cell that fits it, so large and small children
+ * share one container without a fixed grid. A cell is free while it, the
+ * cells it sits inside, and the cells inside it hold nobody.
+ *
+ * A drag is offered the free cells of its own size. Children never move to
+ * make room: a child that finds its cell covered goes to the nearest free
+ * one, and an arrival with no free cell of its size is refused.
+ */
+declare function quadtree<TPose>(opts?: QuadtreeOptions<TPose>): QuadtreeStrategy<TPose>;
+
+/** What makes a sequence layout a row of slots or a shelf-packed flow. */
+interface Sequencer<TPose> {
+    /** `children` in sequence, read off the poses they were given when the
+     *  container was last arranged for `count` children. */
+    order(container: LayoutContainer, children: ReadonlyArray<LayoutChild<TPose>>, count: number): LayoutChild<TPose>[];
+    /** A pose for every child of `sequence`, or `null` when the container
+     *  cannot hold them all. */
+    place(container: LayoutContainer, sequence: ReadonlyArray<LayoutChild<TPose>>): Map<string, TPose> | null;
+    /** The bounds the container takes to hold `sequence`, for one that sizes
+     *  itself to its children. */
+    resize?(container: LayoutContainer, sequence: ReadonlyArray<LayoutChild<TPose>>): ContainerBounds | undefined;
+    centerOf(pose: TPose): {
+        x: number;
+        y: number;
+    };
+    snap: LayoutSnap<TPose>;
+    /** Labels for the two kinds of op a drop writes. */
+    labels: {
+        drop: string;
+        shift: string;
+    };
+}
+/**
+ * The behavior every layout that keeps its children in one ordered sequence
+ * shares: a drop inserts at an index and shifts the children after it, an
+ * arrival goes in at the index that lands it nearest where it was put, and a
+ * departure closes the gap. The `Sequencer` says what the order is and where
+ * a sequence sits.
+ */
+declare function sequenceLayout<TPose>(seq: Sequencer<TPose>): LayoutStrategy<TPose>;
+
+export { type AlignAnchor, type AlignMatchResult, type AlignMoveArgs, type AlignmentBehaviorBase, type Arrangement, type CellHighlightLayerOpts, DEFAULT_GUIDE_TOLERANCE_PX, type DeriveAlignmentGuidesOptions, type FreeformOptions, type GridLayerOpts, type GridSlotsOptions, Guide, type GuideSnapOptions, type GuidesLayerOpts, MOVE_ANCHORS, type PackOptions, type PackOverflow, type PerContainerOptions, type PerContainerStrategy, type QuadtreeCell, type QuadtreeOptions, type QuadtreeStrategy, type RingSlotsOptions, type RowSlotsOptions, type Sequencer, type Slot, type SlotsOptions, type SnapPattern, type SnapPointOptions, type SpacingEdge, SpacingGap, type SpacingMatchResult, type TileGridOptions, type TileGridOverflow, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, cellAt, containedThenNearest, createCellHighlightLayer, createGridLayer, createGuidesLayer, deriveAlignmentGuides, freeform, gridSlots, gridSnapStrategy, guideSnapStrategy, matchAlignment, matchSpacing, measureGaps, nearest, nearestWithin, none, pack, perContainer, pointToGridCell, quadtree, ringSlots, roundToCell, rowSlots, sequenceLayout, slots, snapPoint, tileGrid, useGridCellHover, useGuides };