@weasel-js/guides 1.14.1 → 1.15.0

package/README.md

@@ -42,9 +42,25 @@ source it is built from, `createGridLayer` and `gridSnapSource`, go to
 `<SceneCanvas layers>` and `snap.sources` on their own where a canvas wants
 only one of them.
 
+`spacing` is a pitch for both axes, or a rule per axis. An axis left out has
+no lines, so it neither draws nor snaps:
+
+```ts
+createGridPreset({ spacing: { y: 25 } });                                  // slatwall: rows only
+createGridPreset({ spacing: { x: { at: [0, 40, 55, 100] }, y: 10 } });     // uneven bays
+createGridPreset({ spacing: { x: { pitch: 25.4, offset: 12.7, from: 12.7, to: 600 }, y: 25.4 } });
+```
+
+A container can run a grid of its own, which its children snap to in its frame
+(from its corner, turned and scaled as it is): pass `gridOf` to the snap source
+(or the preset's `snap`), and the same `gridOf` to `sceneGridRegions` for the
+layer's `regions`. A node declaring snap anchors (`<SceneCanvas snap={{ anchors }}>`)
+lands those on the grid instead of its box, and `gridFit` checks whether a set of
+points sits on its crossings.
+
 | Area | Exports |
 |---|---|
-| Grid | `createGridPreset`, `createGridLayer`, `createCellHighlightLayer`, `useGridCellHover`, `pointToGridCell`, `roundToCell` |
+| Grid | `createGridPreset`, `createGridLayer`, `createCellHighlightLayer`, `useGridCellHover`, `pointToGridCell`, `roundToCell`, `sceneGridRegions`, `gridLines`, `gridFit` |
 | Guides | `useGuides`, `createGuidesLayer`, `deriveAlignmentGuides`, `matchSpacing`, `measureGaps`, `siblingBounds`, `worldBoundsOf`, `worldUnionOf` |
 | Snap sources | `gridSnapSource`, `guideSnapSource`, `alignmentSnapSource`, `spacingSnapSource`, for `<SceneCanvas snap={{ sources }}>` or a preset's `snapSources` |
 | Spacing hints | `createSpacingHintsPreset` (below), `distanceReadout`, `measureDistances` |

package/dist/index.d.ts

@@ -1,23 +1,123 @@
 import { RefObject } from 'react';
-import { UnitScope, Scene, NodeId, PlaneValue, PlaneUnits, PerAxis, ViewTransform, View, Dims, CommandStroke, RenderLayer, CommandFill, SnapSource, FeaturePreset, Bounds, PlaneMap, PoseDescriptor, SceneNode, SurfaceContribution, LayoutSnap, LayoutStrategy, LayoutContainer, Vec2, ContainerBounds, LayoutChild } from '@weasel-js/core';
+import { PlaneValue, PerAxis, UnitScope, PlaneUnits, NodeId, ScopedScene, Scene, ViewTransform, View, Dims, CommandStroke, RenderLayer, CommandFill, SnapSource, FeaturePreset, Bounds, PlaneMap, PoseDescriptor, SceneNode, SurfaceContribution, LayoutSnap, LayoutStrategy, LayoutContainer, Vec2, ContainerBounds, LayoutChild } from '@weasel-js/core';
 import { Affine, Rect as Rect$1 } 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;
 
-type Point$1 = {
+/** A length on a grid: a bare number, or a value tagged with a unit. */
+type GridLength = Exclude<PlaneValue, PerAxis<unknown>>;
+/**
+ * One axis of a grid: a pitch from zero; a pitch with an `offset` its lines
+ * pass through, limited to `from`..`to` (inclusive); or lines at explicit
+ * positions, for uneven bays. Positions are measured from the grid's origin:
+ * a container's corner, or the root's origin. A pitch that is not a positive
+ * finite number gives the axis no lines.
+ */
+type GridAxis = GridLength | {
+    pitch: GridLength;
+    offset?: GridLength;
+    from?: GridLength;
+    to?: GridLength;
+} | {
+    at: readonly GridLength[];
+};
+/** A grid's lines: one rule for both axes, or one per axis. An axis left out
+ *  has no lines: it draws none and nothing snaps on it. */
+type GridSpacing = GridLength | {
+    x?: GridAxis;
+    y?: GridAxis;
+};
+/** An axis's lines, resolved to numbers in the space the grid runs in. */
+type AxisLines = {
+    pitch: number;
+    offset: number;
+    from: number;
+    to: number;
+} | {
+    at: readonly number[];
+};
+/** A grid's lines on each axis, `null` where it has none. */
+type GridLines = PerAxis<AxisLines | null>;
+type Axis = 'x' | 'y';
+/** `spacing`'s lines, each length read by `read` for its axis. */
+declare function resolveGridLines(spacing: GridSpacing, read: (v: GridLength, axis: Axis) => number): GridLines;
+/** The line at or before `v` and the one after it, nearer first, the upper
+ *  on a tie; at an end of the lines, the two nearest. Empty where the axis
+ *  has no line. */
+declare function linesNear(a: AxisLines, v: number): number[];
+/** The line nearest `v`, or `null` where the axis has none. */
+declare function nearestLine(a: AxisLines, v: number): number | null;
+/** Every line from `lo` to `hi`, in order. The caller bounds how many a
+ *  pitch gives over the span. */
+declare function linesIn(a: AxisLines, lo: number, hi: number): number[];
+/** The cell holding `v`: the gap between two adjacent lines, numbered from
+ *  the line through the offset (or the first explicit line). An axis with
+ *  no lines is one cell, `0`, without end. `null` outside the lines. */
+declare function cellOf(a: AxisLines | null, v: number): {
+    index: number;
+    lo: number;
+    hi: number;
+} | null;
+/** `a` with every position `p` moved to `p * scale + shift`. */
+declare function mapLines(a: AxisLines, scale: number, shift: number): AxisLines;
+
+/** An axis-aligned rectangle, in whatever coordinates a lattice is drawn in. */
+type Rect = {
     x: number;
     y: number;
+    width: number;
+    height: number;
 };
-/** A container that declares its own unit scope, where a grid draws and
- *  hit-tests that scope's lattice instead of its parent's. */
+
+/** How a grid reads the unit scopes a scene's containers declare
+ *  (`GroupNode.units`). */
+interface GridScopes {
+    /** The scene's outermost scope, as `sceneUnitScopes` is handed it. The grid's
+     *  `spacing` is read in its system, in place of `unitSystem`. */
+    root: UnitScope;
+    /** The grid inside a container's scope, written in that scope's units.
+     *  Default: the grid's `spacing`, read there, so a bare 10 is ten of its
+     *  base units. */
+    spacing?: (scope: UnitScope) => GridSpacing;
+}
+/**
+ * A grid's lines in world units: read in `chain` (the root alone by default)
+ * when `scopes` is given, else against `unitSystem`. What every grid reader
+ * that takes both asks.
+ */
+declare function gridLines(spacing: GridSpacing, unitSystem: PlaneUnits | undefined, scopes: GridScopes | undefined, chain?: readonly UnitScope[]): GridLines;
+/** A container's lattice in its own coordinates: its `own` grid (`gridOf`;
+ *  `null` for none), else the one its scope gives, read in `chain`. */
+declare function containerLines(own: GridSpacing | null | undefined, spacing: GridSpacing, unitSystem: PlaneUnits | undefined, scopes: GridScopes | undefined, chain: readonly UnitScope[] | undefined): GridLines | null;
+
+type Point$2 = {
+    x: number;
+    y: number;
+};
+/** Which of a scene's containers run a grid of their own. */
+interface GridOwners {
+    /** The scene's outermost unit scope: given, every container declaring a
+     *  scope (`GroupNode.units`) runs that scope's lattice, and lengths inside
+     *  a container are read in its scope. */
+    root?: UnitScope;
+    /** A container's own grid: `undefined` to leave it to the container's
+     *  parent, `null` for no grid inside it at all. Its children snap on it,
+     *  in the container's frame. */
+    gridOf?: (id: NodeId) => GridSpacing | null | undefined;
+}
+/** A container running its own lattice, where a grid draws and hit-tests it
+ *  instead of its parent's. */
 interface GridRegion {
     /** The container's outline in world units, as a closed polygon. */
-    outline: readonly Point$1[];
-    /** The scopes its lattice is read in, outermost first, rooted at the
-     *  grid's `scopes.root`, the container's own scope last. */
-    chain: readonly UnitScope[];
-    /** Scoped containers inside this one. */
+    outline: readonly Point$2[];
+    /** The scopes its lattice is read in, outermost first, rooted at
+     *  `GridOwners.root`, the container's own scope last. Absent without one. */
+    chain?: readonly UnitScope[];
+    /** Its own grid, from `gridOf`: `null` for none. Absent, it runs the grid's
+     *  `spacing`, or its scope's (`GridScopes.spacing`). */
+    spacing?: GridSpacing | null;
+    /** Containers inside this one running their own. */
     regions?: readonly GridRegion[];
     /** The container's frame, its own coordinates to world (`sceneBoxFrames`):
      *  its lattice runs from the frame's origin along its axes, in its units,
@@ -26,68 +126,51 @@ interface GridRegion {
     frame?: Affine;
 }
 /**
- * Every container in `scene` declaring a unit scope, as `GridRegion`s nested
+ * Every container in `scene` running its own grid, as `GridRegion`s nested
  * the way the containers are, each in its box frame. `outlineOf` gives a
- * node's world outline, or `null` to leave it, and every scope inside it,
+ * node's world outline, or `null` to leave it, and every region inside it,
  * out; by default, a box pose's outline as it is drawn, and none for any
  * other pose.
  */
-declare function sceneGridRegions(scene: Scene<unknown, string, unknown>, root: UnitScope, outlineOf?: (id: NodeId) => readonly Point$1[] | null): GridRegion[];
+declare function sceneGridRegions(scene: Scene<unknown, string, unknown>, owners: GridOwners, outlineOf?: (id: NodeId) => readonly Point$2[] | null): GridRegion[];
+/** The nearest container above `id` running its own grid, or `null` for the
+ *  root's: whose lattice `id` sits on. `inclusive` counts `id` itself. */
+declare function gridOwner(scene: ScopedScene, id: NodeId, owners: GridOwners, inclusive?: boolean): NodeId | null;
 /** The innermost region holding `point`, or `null` outside them all. */
-declare function regionAt(regions: readonly GridRegion[] | undefined, point: Point$1): GridRegion | null;
+declare function regionAt(regions: readonly GridRegion[] | undefined, point: Point$2): GridRegion | null;
 
-/** How a grid reads the unit scopes a scene's containers declare
- *  (`GroupNode.units`). */
-interface GridScopes {
-    /** The scene's outermost scope, as `sceneUnitScopes` is handed it. The grid's
-     *  `spacing` is read in its system, in place of `unitSystem`. */
-    root: UnitScope;
-    /** The pitch inside a container's scope, written in that scope's units.
-     *  Default: the grid's `spacing`, read there, so a bare 10 is ten of its
-     *  base units. */
-    spacing?: (scope: UnitScope) => PlaneValue;
-}
-/**
- * A grid's pitch on each axis, in world units, where `chain` (outermost
- * first, rooted at `scopes.root`) encloses it: `spacing` in the root, and
- * `scopes.spacing` of the innermost scope inside a container's.
- */
-declare function scopedGridPitch(spacing: PlaneValue, scopes: GridScopes, chain: readonly UnitScope[]): PerAxis<number>;
-/**
- * A grid's pitch in world units: read in `chain` (the root alone by default)
- * when `scopes` is given, else against `unitSystem`. What every grid reader
- * that takes both asks.
- */
-declare function gridPitch(spacing: PlaneValue, unitSystem: PlaneUnits | undefined, scopes: GridScopes | undefined, chain?: readonly UnitScope[]): PerAxis<number>;
-
-/** A cell of a grid. `pitch` names the lattice it belongs to, in world units,
- *  where a grid reads unit scopes; without it, the cell is the grid's own.
- *  `frame` is that lattice's region's frame, the cell counted from its origin. */
+/** A cell of a grid: the gap between two adjacent lines on each axis,
+ *  numbered from the line through each axis's offset (or its first explicit
+ *  line). `box` is the cell in the grid's space: world, or `frame`'s, the
+ *  frame of the region whose lattice it is on. An axis with no lines is one
+ *  cell, `0`, spanning the region, or without end at the root. */
 interface GridCell {
     col: number;
     row: number;
-    pitch?: PerAxis<number>;
+    box: Rect;
     frame?: Affine;
 }
-/** Where a grid reads unit scopes: `scopes`, and the containers declaring them. */
+/** Where a grid's containers run lattices of their own: the unit `scopes`
+ *  it reads, and the `regions` (`sceneGridRegions`) running them. */
 interface GridScoping {
-    scopes: GridScopes;
+    scopes?: GridScopes;
     regions?: readonly GridRegion[];
 }
 /**
- * The integer cell `{col, row}` that contains `point`. Pair with
+ * The cell holding `point`, on the lattice of the innermost region holding
+ * it, else the root's, which runs through `origin`. Pair with
  * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target
- * preview that uses the same spacing as `gridSnapSource`. Given `scoped`,
- * the cell is on the lattice of the innermost region holding `point`, and
- * carries that lattice's `pitch`, and its `frame` where the region has one.
+ * preview on the lattice `gridSnapSource` snaps to. `null` where `point` is
+ * outside the lines: past a range a pitch is limited to, or the explicit
+ * lines, or in a region with no grid.
  */
 declare function pointToGridCell(point: {
     x: number;
     y: number;
-}, spacing: PlaneValue, unitSystem?: PlaneUnits, origin?: {
+}, spacing: GridSpacing, unitSystem?: PlaneUnits, origin?: {
     x: number;
     y: number;
-}, scoped?: GridScoping): GridCell;
+}, scoped?: GridScoping): GridCell | null;
 
 /**
  * Pointer-tracking glue that turns hover position into a grid cell, suitable
@@ -104,9 +187,8 @@ interface UseGridCellHoverOptions {
     /** Read the current view transform. Called on every pointermove so it can
      *  reflect live pan/zoom without a re-binding step. */
     view: () => ViewTransform;
-    /** Cell spacing in world units. Same value you pass to `createGridLayer`
-     *  and `createCellHighlightLayer`. */
-    spacing: PlaneValue;
+    /** The grid's lines. Same value you pass to `createGridLayer`. */
+    spacing: GridSpacing;
     /** Required if `spacing` is tagged (e.g. `{ value: 1, unit: 'ft' }`). */
     unitSystem?: PlaneUnits;
     /** Origin the cell grid is anchored to, in world units. Default `(0, 0)`. */
@@ -114,10 +196,10 @@ interface UseGridCellHoverOptions {
         x: number;
         y: number;
     };
-    /** Read `spacing` in these scopes, as `createGridLayer` does: a cell inside
-     *  one of `regions` is on its scope's lattice and carries that `pitch`. */
+    /** Read `spacing` in these scopes, as `createGridLayer` does. */
     scopes?: GridScopes;
-    /** The containers declaring scopes, read on every pointermove. */
+    /** The containers running lattices of their own, read on every
+     *  pointermove: a cell inside one is on its lattice, in its frame. */
     regions?: () => readonly GridRegion[];
     /** Fires when the hovered cell changes (including to/from `null`). Use it
      *  to invalidate your layer renderer. */
@@ -136,14 +218,6 @@ interface UseGridCellHoverReturn {
 /** Track which grid cell the pointer is over; pairs with `createCellHighlightLayer`. */
 declare function useGridCellHover(opts: UseGridCellHoverOptions): UseGridCellHoverReturn;
 
-/** An axis-aligned rectangle, in whatever coordinates a lattice is drawn in. */
-type Rect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-
 /**
  * Grid overlay — a reusable render layer that draws a world-space grid with
  * optional finer subdivisions and accent lines every N cells.
@@ -157,26 +231,26 @@ type Rect = {
 /** Options for `createGridLayer`. */
 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 }`.
+     * The grid's lines: a pitch for both axes, or a rule per axis (`{ x, y }`,
+     * see `GridAxis`), an axis left out drawing none. Lengths are a bare
+     * number in world (base) units or a tagged `{ value, unit }`, which needs
+     * `unitSystem`.
      */
-    spacing: PlaneValue;
+    spacing: GridSpacing;
     /** Optional unit system for resolving tagged `spacing` values. */
     unitSystem?: PlaneUnits;
     /** Read `spacing` in these scopes, in place of `unitSystem`: the root's
      *  system outside every region, and each region's own scope inside it. */
     scopes?: GridScopes;
-    /** The containers drawing their own scope's lattice, read every paint,
-     *  each cut out of the lattice around it and drawn in its own `frame`.
-     *  Read only with `scopes`; `sceneGridRegions` builds them from a scene. */
+    /** The containers drawing a lattice of their own, read every paint, each
+     *  cut out of the lattice around it and drawn in its own `frame`:
+     *  `sceneGridRegions` builds them from a scene. */
     regions?: () => readonly GridRegion[];
     /**
      * The area to cover, in world units, read every paint with that paint's
      * view and canvas size. Lines start at its own `x`/`y`. Omitted, the grid
-     * covers whatever the canvas shows, with its lines on world multiples of
-     * `spacing` so they stay put as the view pans.
+     * covers whatever the canvas shows, with its lines measured from world
+     * zero so they stay put as the view pans.
      */
     bounds?: (view: View, dims: Dims) => Rect;
     /** Lines every N cells get the accent style. 0/undef = no accent. */
@@ -201,18 +275,8 @@ declare function createGridLayer(opts: GridLayerOpts): RenderLayer<unknown>;
 
 /** Options for `createCellHighlightLayer`. */
 interface CellHighlightLayerOpts {
-    /** Cell size in world units (matches the grid's `spacing`). */
-    spacing: PlaneValue;
-    /** Optional unit system for resolving tagged `spacing` values. */
-    unitSystem?: PlaneUnits;
-    /** Origin the cell grid is anchored to, in world units. Defaults to (0,0). */
-    origin?: () => {
-        x: number;
-        y: number;
-    };
-    /** Cell to highlight, or `null` to skip drawing. A cell carrying its
-     *  lattice's `pitch` (`useGridCellHover` with `scopes`) is drawn at it,
-     *  and one carrying a `frame` is drawn in it, from its origin. */
+    /** Cell to highlight, or `null` to skip drawing: its `box`, in its
+     *  `frame` where it has one (`pointToGridCell`, `useGridCellHover`). */
     getCell: () => GridCell | null;
     /** Fill for the highlighted cell. Defaults to a soft green. */
     fill?: CommandFill;
@@ -220,30 +284,60 @@ interface CellHighlightLayerOpts {
 /** Build a `RenderLayer` that fills a single grid cell — typically a snap-target preview. */
 declare function createCellHighlightLayer(opts: CellHighlightLayerOpts): RenderLayer<unknown>;
 
+type Point$1 = {
+    x: number;
+    y: number;
+};
+/** A point of `gridFit` off its line on one axis, by `distance`. */
+interface GridMiss {
+    index: number;
+    axis: 'x' | 'y';
+    distance: number;
+}
+/**
+ * Whether every one of `points` sits within `tolerance` of a line on each
+ * axis `lines` has lines on, so on a crossing where it has both: a hanger's
+ * holes on a pegboard's. Points and tolerance are in the grid's own space,
+ * measured from its origin; `gridLines` resolves a `GridSpacing` into it.
+ */
+declare function gridFit(points: readonly Point$1[], lines: GridLines, tolerance?: number): {
+    fits: boolean;
+    misses: GridMiss[];
+};
+
 type Point = {
     x: number;
     y: number;
 };
 /** Options for `gridSnapSource`. */
 interface GridSnapSourceOptions {
-    /** The grid's pitch, or one per axis, in `unitSystem`'s units. */
-    spacing: PlaneValue;
-    /** A point the lattice passes through. Default `(0, 0)`. */
+    /** The grid's lines, one rule for both axes or one per axis, in
+     *  `unitSystem`'s units. */
+    spacing: GridSpacing;
+    /** A point the root's lattice passes through. Default `(0, 0)`. */
     origin?: Point;
     unitSystem?: PlaneUnits;
     /** Read the unit scope the subject sits in: a node inside a millimeter
-     *  sub-assembly snaps on that scope's pitch. The subject's scope is the one
-     *  all its nodes share; for a gesture with none, the scope of the
-     *  container it draws into (`SnapCollect.parent`), else the root. When that
-     *  scope is one container's, the lattice runs in its frame
-     *  (`SnapCollect.frameOf`): from its corner, turned as it is. */
+     *  sub-assembly snaps on that scope's lattice, in that container's frame. */
     scopes?: GridScopes;
+    /** A container's own grid, which its children snap on in its frame (from
+     *  its corner, turned and scaled as it is): the nearest container above
+     *  the subject with one, or with a unit scope under `scopes`. `null` for a
+     *  container with no grid inside it. */
+    gridOf?: GridOwners['gridOf'];
+    /** The source's id, so two grids can snap on one canvas. Default `'grid'`. */
+    id?: string;
 }
 /**
- * A grid as snap targets: for each origin or pointer probe, the grid line on
- * either side of it on each axis. Its reach is unlimited and it is a
- * fallback, so it holds every axis no target claims and never displaces one.
- * Its lines are the camera's, carried into the plane a gesture runs in.
+ * A grid as snap targets: for each probe, the grid line on either side of it
+ * on each axis the grid has lines on, so a move lands the drawn box, stroke
+ * included, with an edge or its center on a line; on a turned container's
+ * lattice, which no world-axis box lines up with, its pose origin. A subject
+ * declaring snap anchors (`SceneCanvasSnap.anchors`) lands those instead of
+ * its box. Nodes spread over containers snap on the lattice they all run,
+ * along the world's axes, and on none where those differ. Its reach is unlimited and it is a fallback,
+ * so it holds every axis no target claims and never displaces one. Its lines
+ * are the camera's, carried into the plane a gesture runs in.
  */
 declare function gridSnapSource(opts: GridSnapSourceOptions): SnapSource;
 
@@ -252,9 +346,11 @@ interface GridPresetOptions extends GridLayerOpts {
     /** Preset id. Default `'grid'`. */
     id?: string;
     /** Snap gestures to the grid's lines, on its `spacing`, `unitSystem` and
-     *  `scopes`; `origin` is where the snap lattice starts. `false` draws the
-     *  grid without snapping to it. Default on, from `(0, 0)`. */
-    snap?: false | Pick<GridSnapSourceOptions, 'origin'>;
+     *  `scopes`; `origin` is where the snap lattice starts, and `gridOf` gives
+     *  containers their own (pair it with `regions` from `sceneGridRegions`
+     *  with the same `gridOf`, so what is drawn is what snaps). `false` draws
+     *  the grid without snapping to it. Default on, from `(0, 0)`. */
+    snap?: false | Pick<GridSnapSourceOptions, 'origin' | 'gridOf'>;
 }
 /**
  * A grid as one `<SceneCanvas features>` preset: the lattice drawn in the
@@ -459,8 +555,9 @@ declare function worldUnionOf(scene: Scene<unknown, string, unknown>, ids: Itera
 declare function siblingBounds(scene: Scene<unknown, string, unknown>, ids: readonly NodeId[], opts?: SceneBoundsOptions): Bounds[];
 
 /**
- * Ruler guides as snap targets: each guide within reach of an origin or
- * pointer probe is a line it may land on. Reads `getGuides` every frame, so
+ * Ruler guides as snap targets: each guide within reach of a box or
+ * pointer probe is a line it may land on: a moved box's edges and center,
+ * stroke included. Reads `getGuides` every frame, so
  * a guide added mid-drag counts at once.
  */
 declare function guideSnapSource(getGuides: () => readonly Guide[]): SnapSource;
@@ -506,8 +603,9 @@ interface SpacingSnapSourceOptions {
  * Equal spacing as snap targets, Figma's: on each axis, the positions of the
  * subject's box that make its gap to a neighbor equal one already between
  * two siblings, or center it between its two neighbors. A resize moves only
- * the edges it drags. When the result meets one, it marks every gap of that
- * size, the box's own included.
+ * the sides it drags; on a turned or skewed box, the sides of its
+ * axis-aligned extent the drag moves. When the result meets one, it marks
+ * every gap of that size, the box's own included, where the box lands.
  */
 declare function spacingSnapSource(opts?: SpacingSnapSourceOptions): SnapSource;
 
@@ -913,4 +1011,4 @@ interface Sequencer<TPose> {
  */
 declare function sequenceLayout<TPose>(seq: Sequencer<TPose>): LayoutStrategy<TPose>;
 
-export { type AlignmentSnapSourceOptions, type Arrangement, type CellHighlightLayerOpts, type DeriveAlignmentGuidesOptions, type DistanceReadout, type DistanceReadoutContribution, type DistanceReadoutOptions, type FreeformOptions, type GridCell, type GridLayerOpts, type GridPresetOptions, type GridRegion, type GridScopes, type GridScoping, type GridSlotsOptions, type GridSnapSourceOptions, type Guide, type GuidesLayerOpts, type PackOptions, type PackOverflow, type PerContainerOptions, type PerContainerStrategy, type QuadtreeCell, type QuadtreeOptions, type QuadtreeStrategy, type RingSlotsOptions, type RowSlotsOptions, type SceneBoundsOptions, type Sequencer, type Slot, type SlotsOptions, type SnapPattern, type SnapPointOptions, type SpacingEdge, type SpacingGap, type SpacingHintsOptions, type SpacingMatchResult, type SpacingSnapSourceOptions, type TargetFilter, type TileGridOptions, type TileGridOverflow, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, 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 };
+export { type AlignmentSnapSourceOptions, type Arrangement, type AxisLines, type CellHighlightLayerOpts, type DeriveAlignmentGuidesOptions, type DistanceReadout, type DistanceReadoutContribution, type DistanceReadoutOptions, type FreeformOptions, type GridAxis, type GridCell, type GridLayerOpts, type GridLength, type GridLines, type GridMiss, type GridOwners, type GridPresetOptions, type GridRegion, type GridScopes, type GridScoping, type GridSlotsOptions, type GridSnapSourceOptions, type GridSpacing, type Guide, type GuidesLayerOpts, type PackOptions, type PackOverflow, type PerContainerOptions, type PerContainerStrategy, type QuadtreeCell, type QuadtreeOptions, type QuadtreeStrategy, type RingSlotsOptions, type RowSlotsOptions, type SceneBoundsOptions, type Sequencer, type Slot, type SlotsOptions, type SnapPattern, type SnapPointOptions, type SpacingEdge, type SpacingGap, type SpacingHintsOptions, type SpacingMatchResult, type SpacingSnapSourceOptions, type TargetFilter, type TileGridOptions, type TileGridOverflow, type UseGridCellHoverOptions, type UseGridCellHoverReturn, type UseGuidesReturn, alignmentSnapSource, cellAt, cellOf, containedThenNearest, containerLines, createCellHighlightLayer, createGridLayer, createGridPreset, createGuidesLayer, createSpacingHintsPreset, deriveAlignmentGuides, distanceReadout, freeform, gridFit, gridLines, gridOwner, gridSlots, gridSnapSource, guideSnapSource, linesIn, linesNear, mapLines, matchSpacing, measureDistances, measureGaps, nearest, nearestLine, nearestWithin, none, pack, perContainer, pointToGridCell, quadtree, regionAt, resolveGridLines, ringSlots, roundToCell, rowSlots, sceneGridRegions, sequenceLayout, siblingBounds, slots, snapPoint, spacingSnapSource, tileGrid, useGridCellHover, useGuides, worldBoundsOf, worldUnionOf };