@dashfoo/core 1.0.0 → 1.1.0

package/README.md

@@ -183,10 +183,10 @@ getFirstTabset(model): TabsetNode | undefined;
 findTabset(model, tabsetId): TabsetNode | undefined;
 findTab(model, tabId): TabLocation | undefined; // searches tabsets
 findFloat(model, floatId): FloatNode | undefined;
-findRow(row, rowId): RowNode | undefined;       // pass a root (model.layout or a float's layout)
+findRow(model, rowId): RowNode | undefined;
 findRootContaining(model, nodeId): RowNode | undefined; // which root holds a node
 findAttributedNode(model, id): AttributedNode | undefined; // row, tabset, or tab
-findTabsetParent(row, tabsetId): { index: number; parent: RowNode } | undefined;
+findTabsetParent(model, tabsetId): { index: number; parent: RowNode } | undefined;
 findDuplicateIds(model): Array<string>;         // ids used more than once
 ```
 
@@ -225,14 +225,14 @@ indicator rect. The @dnd-kit adapter in `@dashfoo/react` feeds them rects; you c
 call them directly for custom drag logic.
 
 ```ts
-resolveDockTarget(pointer, rect, opts?): DockTarget;
+resolveDockTarget(pointer, rect, opts?): DockLocation;
 dockZonePolygons(rect, opts?): Array<DockZone>;
 zoneRect(rect, location): Rect;
 ```
 
-`resolveDockTarget` decides where a drag over a tabset should land: `{ kind: "tab" }`
-when the pointer is in the interior, or `{ kind: "split", edge }` when it is within
-an outer band of one of the four edges (default 22%; the closer edge wins in
+`resolveDockTarget` decides where a drag over a tabset should land: `"center"`
+when the pointer is in the interior, or `split-${edge}` when it is within an
+outer band of one of the four edges (default 22%; the closer edge wins in
 corners). It accepts `{ bandFraction }` to tune the band. `zoneRect` returns the
 region the dock indicator highlights for a `DockLocation`: the whole tabset for a
 `center` stack, the matching half for a split. `Point` and `Rect` are exported.
@@ -252,8 +252,9 @@ these arrays and supplies the dragged boundary index.
 
 ```ts
 resolveSnapTargets(config: SnapConfig, panelCount: number): number[]; // grid positions inside 0..100
-snapSizes(sizes: number[], boundaryIndex: number, config: SnapConfig): { sizes: number[]; snapped: boolean };
-snapEnabled(config: SnapConfig | null): boolean;
+resolveSnapGrid(config: SnapConfig | null, panelCount: number): SnapGrid;
+snapSizes(sizes: number[], boundaryIndex: number, grid: SnapGrid): { sizes: number[]; snapped: boolean };
+snapEnabled(grid: SnapGrid): boolean;
 ```
 
 `resolveSnapTargets` builds the grid for a row from its config and panel count: the
@@ -262,8 +263,14 @@ union of the `step` grid (multiples of a fixed percent) and the `divisions` grid
 the panel count). `snapSizes` snaps the boundary between panel `boundaryIndex` and
 the next onto the nearest target within `threshold` (default `4`), moving only that
 pair so siblings keep their size. It is a no-op when the grid is empty, the index
-is out of range, or the correction would drive a panel negative. `snapEnabled`
-reports whether a config produces any grid. `SnapConfig` is the
+is out of range, or the correction would drive a panel negative.
+
+`resolveSnapGrid` is the entry point: it resolves the targets once for a row and
+carries the threshold alongside them, and every other function takes that
+`SnapGrid`. `snapEnabled` is then just "does this grid have any target", which
+is why a config with no reachable target (`{ step: 100 }`, or
+`{ divisions: "panels" }` on a one-panel row) reports off rather than arming the
+per-move snap path. `SnapConfig` is the
 `{ step?, divisions?, threshold? }` shape carried by `global.snap` and
 `RowNode.snap`.
 
@@ -370,9 +377,9 @@ layout, carrying the `TabNode` to insert), which the React layer forwards to
 types `AttributedNode`, `TabContainer`, `TabLocation`.
 
 `geometry`: `resolveDockTarget`, `dockZonePolygons`, `zoneRect`; types
-`DockTarget`, `DockZone`, `BandOptions`, `Point`, `Rect`.
+`DockZone`, `BandOptions`, `Point`, `Rect`.
 
-`snap`: `resolveSnapTargets`, `snapSizes`, `snapEnabled`, `DEFAULT_SNAP_THRESHOLD`;
+`snap`: `resolveSnapGrid`, `resolveSnapTargets`, `snapSizes`, `snapEnabled`, `DEFAULT_SNAP_THRESHOLD`;
 type `SnapResult`.
 
 `history`: `createHistory`, `dispatch`, `undo`, `redo`, `canUndo`, `canRedo`;

package/dist/index.d.ts

@@ -1,13 +1,8 @@
 import { z } from "zod";
 //#region src/state/node-attrs.d.ts
 /**
- * One all-optional object carrying every mutable key of every node kind, not a
- * union of the three: a union whose members are all fully optional matches on
- * its first member and strips the keys the others own, which erased every
- * tabset and row attribute at the parse boundary. The four keys that two kinds
- * share (`enableClose`, `max`, `min`, `weight`) declare the same type on both
- * sides, so merging widens nothing. Which keys are legal for a given node is
- * enforced by the reducer against that node's own schema.
+ * Merged, not a union: a union of all-optional members matches its first member
+ * and strips the rest. The reducer enforces which keys a given node accepts.
  */
 declare const mutableNodeAttrsSchema: z.ZodObject<{
   name: z.ZodOptional<z.ZodString>;
@@ -189,7 +184,6 @@ declare const actionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   targetId: z.ZodString;
   type: z.ZodLiteral<"moveNode">;
 }, z.core.$strip>, z.ZodObject<{
-  index: z.ZodOptional<z.ZodNumber>;
   location: z.ZodEnum<{
     center: "center";
     "split-bottom": "split-bottom";
@@ -397,23 +391,16 @@ type DropIntent = {
 };
 //#endregion
 //#region src/model/schema.d.ts
-/**
- * Weights are relative shares, and every reader that rendered one already
- * treated a missing weight as a single share (`row-view` summed `weight ?? 1`),
- * so filling it in at the boundary changes nothing on screen. The one place that
- * read a missing weight as a percentage was `placeBesideTarget`, which is why
- * docking beside an unweighted target halved it to `50` and left its unweighted
- * siblings rendering as a sliver of the row.
- */
+/** Weights are relative shares of a row, not percentages. */
 declare const DEFAULT_WEIGHT = 1;
 type JsonValue = string | number | boolean | null | Array<JsonValue> | {
   [key: string]: JsonValue;
 };
 declare const jsonValueSchema: z.ZodType<JsonValue>;
 declare const edgeSchema: z.ZodEnum<{
-  left: "left";
   top: "top";
   bottom: "bottom";
+  left: "left";
   right: "right";
 }>;
 declare const unitSchema: z.ZodEnum<{
@@ -455,11 +442,8 @@ declare const tabNodeSchema: z.ZodObject<{
   type: z.ZodLiteral<"tab">;
 }, z.core.$strip>;
 /**
- * The pre-transform object, kept separate so `node-attrs` can `.pick()` mutable
- * keys off it. Picking from the transformed schema is impossible (a pipe has no
- * `.pick`), and picking `weight` with its default attached would inject that
- * default: `.partial()` over a defaulted field still fills it in, which would
- * rewrite a tabset's weight on every unrelated attribute update.
+ * Kept pre-transform so `node-attrs` can `.pick()` from it: a pipe has no
+ * `.pick`, and `.partial()` over a defaulted field still fills the default in.
  */
 declare const tabsetNodeObjectSchema: z.ZodObject<{
   children: z.ZodArray<z.ZodObject<{
@@ -595,27 +579,46 @@ declare const tabsetNodeSchema: z.ZodPipe<z.ZodObject<{
   } | undefined;
   name?: string | undefined;
 }>>;
-type RowNode = {
-  children: Array<RowNode | z.infer<typeof tabsetNodeSchema>>;
-  id: string;
-  max?: z.infer<typeof dimensionSchema>;
-  min?: z.infer<typeof dimensionSchema>;
-  orientation: z.infer<typeof orientationSchema>;
-  snap?: z.infer<typeof snapSchema>;
-  type: "row";
-  weight: number;
-};
-type RowNodeInput = {
-  children: Array<RowNodeInput | z.input<typeof tabsetNodeSchema>>;
-  id: string;
-  max?: z.infer<typeof dimensionSchema>;
-  min?: z.infer<typeof dimensionSchema>;
-  orientation: z.infer<typeof orientationSchema>;
-  snap?: z.infer<typeof snapSchema>;
-  type: "row";
-  weight?: number;
-};
-declare const rowNodeSchema: z.ZodType<RowNode, RowNodeInput>;
+/** The getter's explicit return type is required: without it, TS7023. */
+declare const rowNodeSchema: z.ZodObject<{
+  children: z.ZodArray<z.ZodUnion<[typeof rowNodeSchema, typeof tabsetNodeSchema]>>;
+  id: z.ZodString;
+  max: z.ZodOptional<z.ZodObject<{
+    unit: z.ZodEnum<{
+      px: "px";
+      "%": "%";
+      em: "em";
+      rem: "rem";
+      vh: "vh";
+      vw: "vw";
+    }>;
+    value: z.ZodNumber;
+  }, z.core.$strip>>;
+  min: z.ZodOptional<z.ZodObject<{
+    unit: z.ZodEnum<{
+      px: "px";
+      "%": "%";
+      em: "em";
+      rem: "rem";
+      vh: "vh";
+      vw: "vw";
+    }>;
+    value: z.ZodNumber;
+  }, z.core.$strip>>;
+  orientation: z.ZodEnum<{
+    row: "row";
+    column: "column";
+  }>;
+  snap: z.ZodOptional<z.ZodObject<{
+    divisions: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"panels">]>>;
+    step: z.ZodOptional<z.ZodNumber>;
+    threshold: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  type: z.ZodLiteral<"row">;
+  weight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type RowNode = z.infer<typeof rowNodeSchema>;
+type RowNodeInput = z.input<typeof rowNodeSchema>;
 declare const geometrySchema: z.ZodObject<{
   height: z.ZodNumber;
   left: z.ZodNumber;
@@ -630,7 +633,43 @@ declare const floatNodeSchema: z.ZodObject<{
     width: z.ZodNumber;
   }, z.core.$strip>;
   id: z.ZodString;
-  layout: z.ZodType<RowNode, RowNodeInput, z.core.$ZodTypeInternals<RowNode, RowNodeInput>>;
+  layout: z.ZodObject<{
+    children: z.ZodArray<z.ZodUnion<[typeof rowNodeSchema, typeof tabsetNodeSchema]>>;
+    id: z.ZodString;
+    max: z.ZodOptional<z.ZodObject<{
+      unit: z.ZodEnum<{
+        px: "px";
+        "%": "%";
+        em: "em";
+        rem: "rem";
+        vh: "vh";
+        vw: "vw";
+      }>;
+      value: z.ZodNumber;
+    }, z.core.$strip>>;
+    min: z.ZodOptional<z.ZodObject<{
+      unit: z.ZodEnum<{
+        px: "px";
+        "%": "%";
+        em: "em";
+        rem: "rem";
+        vh: "vh";
+        vw: "vw";
+      }>;
+      value: z.ZodNumber;
+    }, z.core.$strip>>;
+    orientation: z.ZodEnum<{
+      row: "row";
+      column: "column";
+    }>;
+    snap: z.ZodOptional<z.ZodObject<{
+      divisions: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"panels">]>>;
+      step: z.ZodOptional<z.ZodNumber>;
+      threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"row">;
+    weight: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>;
   minimized: z.ZodOptional<z.ZodBoolean>;
   name: z.ZodOptional<z.ZodString>;
   type: z.ZodLiteral<"float">;
@@ -665,7 +704,43 @@ declare const dashfooSchema: z.ZodObject<{
       width: z.ZodNumber;
     }, z.core.$strip>;
     id: z.ZodString;
-    layout: z.ZodType<RowNode, RowNodeInput, z.core.$ZodTypeInternals<RowNode, RowNodeInput>>;
+    layout: z.ZodObject<{
+      children: z.ZodArray<z.ZodUnion<[typeof rowNodeSchema, typeof tabsetNodeSchema]>>;
+      id: z.ZodString;
+      max: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+          px: "px";
+          "%": "%";
+          em: "em";
+          rem: "rem";
+          vh: "vh";
+          vw: "vw";
+        }>;
+        value: z.ZodNumber;
+      }, z.core.$strip>>;
+      min: z.ZodOptional<z.ZodObject<{
+        unit: z.ZodEnum<{
+          px: "px";
+          "%": "%";
+          em: "em";
+          rem: "rem";
+          vh: "vh";
+          vw: "vw";
+        }>;
+        value: z.ZodNumber;
+      }, z.core.$strip>>;
+      orientation: z.ZodEnum<{
+        row: "row";
+        column: "column";
+      }>;
+      snap: z.ZodOptional<z.ZodObject<{
+        divisions: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"panels">]>>;
+        step: z.ZodOptional<z.ZodNumber>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+      type: z.ZodLiteral<"row">;
+      weight: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
     minimized: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"float">;
@@ -690,7 +765,43 @@ declare const dashfooSchema: z.ZodObject<{
     tabSetEnableTabStrip: z.ZodOptional<z.ZodBoolean>;
     tabSetMinSize: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strip>;
-  layout: z.ZodType<RowNode, RowNodeInput, z.core.$ZodTypeInternals<RowNode, RowNodeInput>>;
+  layout: z.ZodObject<{
+    children: z.ZodArray<z.ZodUnion<[typeof rowNodeSchema, typeof tabsetNodeSchema]>>;
+    id: z.ZodString;
+    max: z.ZodOptional<z.ZodObject<{
+      unit: z.ZodEnum<{
+        px: "px";
+        "%": "%";
+        em: "em";
+        rem: "rem";
+        vh: "vh";
+        vw: "vw";
+      }>;
+      value: z.ZodNumber;
+    }, z.core.$strip>>;
+    min: z.ZodOptional<z.ZodObject<{
+      unit: z.ZodEnum<{
+        px: "px";
+        "%": "%";
+        em: "em";
+        rem: "rem";
+        vh: "vh";
+        vw: "vw";
+      }>;
+      value: z.ZodNumber;
+    }, z.core.$strip>>;
+    orientation: z.ZodEnum<{
+      row: "row";
+      column: "column";
+    }>;
+    snap: z.ZodOptional<z.ZodObject<{
+      divisions: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"panels">]>>;
+      step: z.ZodOptional<z.ZodNumber>;
+      threshold: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"row">;
+    weight: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>;
   maximizedTabsetId: z.ZodOptional<z.ZodString>;
   version: z.ZodLiteral<1>;
 }, z.core.$strip>;
@@ -763,12 +874,6 @@ type Rect = {
   x: number;
   y: number;
 };
-type DockTarget = {
-  kind: "tab";
-} | {
-  edge: Edge;
-  kind: "split";
-};
 type BandOptions = {
   bandFraction?: number;
 };
@@ -776,21 +881,25 @@ type DockZone = {
   location: DockLocation;
   points: Array<Point>;
 };
-declare const dockLocationFor: (target: DockTarget) => DockLocation;
 declare const splitEdge: (location: DockLocation) => Edge | undefined;
-declare const resolveDockTarget: (pointer: Point, rect: Rect, opts?: BandOptions) => DockTarget;
+declare const resolveDockTarget: (pointer: Point, rect: Rect, opts?: BandOptions) => DockLocation;
 declare const dockZonePolygons: (rect: Rect, opts?: BandOptions) => Array<DockZone>;
 declare const zoneRect: (rect: Rect, location: DockLocation) => Rect;
 //#endregion
 //#region src/geometry/snap.d.ts
 declare const DEFAULT_SNAP_THRESHOLD = 4;
 declare const resolveSnapTargets: (config: SnapConfig, panelCount: number) => Array<number>;
-declare const snapEnabled: (config: SnapConfig | null) => boolean;
+type SnapGrid = {
+  targets: Array<number>;
+  threshold: number;
+};
+declare const resolveSnapGrid: (config: SnapConfig | null, panelCount: number) => SnapGrid;
+declare const snapEnabled: (grid: SnapGrid) => boolean;
 type SnapResult = {
   sizes: Array<number>;
   snapped: boolean;
 };
-declare const snapSizes: (sizes: Array<number>, boundaryIndex: number, config: SnapConfig) => SnapResult;
+declare const snapSizes: (sizes: Array<number>, boundaryIndex: number, grid: SnapGrid) => SnapResult;
 type SnapDecision = {
   kind: "inactive";
 } | {
@@ -799,8 +908,8 @@ type SnapDecision = {
   kind: "engage";
   sizes: Array<number>;
 };
-declare const decideSnap: (sizes: Array<number>, boundaryIndex: number | null, config: SnapConfig | null) => SnapDecision;
-declare const settleSnap: (sizes: Array<number>, boundaryIndex: number | null, config: SnapConfig | null) => Array<number>;
+declare const decideSnap: (sizes: Array<number>, boundaryIndex: number | null, grid: SnapGrid) => SnapDecision;
+declare const settleSnap: (sizes: Array<number>, boundaryIndex: number | null, grid: SnapGrid) => Array<number>;
 //#endregion
 //#region src/state/history.d.ts
 type History = {
@@ -812,6 +921,11 @@ declare const HISTORY_LIMIT = 100;
 declare const createHistory: (present: Dashfoo) => History;
 declare const canUndo: (history: History) => boolean;
 declare const canRedo: (history: History) => boolean;
+/**
+ * An action that changed nothing is not an edit: recording it would spend an
+ * undo slot and clear a redo stack the user just built. Not coalescing (ADR
+ * 0002): two distinct edits are still two entries.
+ */
 declare const dispatch: (history: History, action: Action) => History;
 declare const undo: (history: History) => History;
 declare const redo: (history: History) => History;
@@ -827,17 +941,6 @@ declare const normalize: (model: Dashfoo) => Dashfoo;
 type DashfooContext = {
   history: History;
 };
-type DashfooEvent = {
-  action: Action;
-  type: "DISPATCH";
-} | {
-  model: Dashfoo;
-  type: "SET_MODEL";
-} | {
-  type: "REDO";
-} | {
-  type: "UNDO";
-};
 type DashfooMachineInput = {
   model: Dashfoo;
 };
@@ -867,27 +970,34 @@ type DragSubject = {
   kind: "external";
   tab: TabNode;
 };
-type DragContext = {
-  intent: DropIntent | null;
-  subject: DragSubject | null;
+/** `scope` names whoever resolved the intent, echoed back on `COMMIT` so the host can route the action. */
+type DropResolution = {
+  intent: DropIntent;
+  scope: string;
 };
-type DragEvent = {
-  intent: DropIntent | null;
-  type: "OVER";
-} | {
+/** One value, so a drop target without a subject is unrepresentable. See ADR 0002. */
+type DragState = {
+  drop: DropResolution | null;
+  kind: "dragging";
   subject: DragSubject;
-  type: "START";
-} | {
-  type: "CANCEL";
 } | {
-  type: "DROP";
+  kind: "idle";
+};
+type DragContext = {
+  drag: DragState;
 };
 type DragEmitted = {
   action: Action;
+  scope: string;
   type: "COMMIT";
 };
+/** One definition of both "is this drop valid" and "what does it do", so the guard and the emit agree. */
+declare const dropAction: (drag: DragState) => {
+  action: Action;
+  scope: string;
+} | null;
 declare const dragDockMachine: import("xstate").StateMachine<DragContext, {
-  intent: DropIntent | null;
+  drop: DropResolution | null;
   type: "OVER";
 } | {
   subject: DragSubject;
@@ -899,7 +1009,7 @@ declare const dragDockMachine: import("xstate").StateMachine<DragContext, {
 }, {}, never, never, {
   type: "hasValidDrop";
   params: unknown;
-}, never, "idle" | "dragging", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, DragEmitted, import("xstate").MetaObject, {
+}, never, "dragging" | "idle", string, import("xstate").NonReducibleUnknown, import("xstate").NonReducibleUnknown, DragEmitted, import("xstate").MetaObject, {
   id: "dragDock";
   states: {
     readonly dragging: {};
@@ -908,6 +1018,8 @@ declare const dragDockMachine: import("xstate").StateMachine<DragContext, {
 }>;
 //#endregion
 //#region src/state/reducer.d.ts
+/** Identity-equal output means "no edit". A rejected action skips `normalize`, so
+ * pass a model that has already been through it. */
 declare const reducer: (model: Dashfoo, action: Action) => Dashfoo;
 //#endregion
 //#region src/model/serialize.d.ts
@@ -933,14 +1045,14 @@ declare const collectTabsets: (model: Dashfoo) => Array<TabsetNode>;
 declare const getFirstTabset: (model: Dashfoo) => TabsetNode | undefined;
 declare const findTabset: (model: Dashfoo, tabsetId: string) => TabsetNode | undefined;
 declare const findTab: (model: Dashfoo, tabId: string) => TabLocation | undefined;
-declare const findRow: (row: RowNode, id: string) => RowNode | undefined;
+declare const findRow: (model: Dashfoo, id: string) => RowNode | undefined;
 declare const findAttributedNode: (model: Dashfoo, id: string) => AttributedNode | undefined;
 declare const findRootContaining: (model: Dashfoo, nodeId: string) => RowNode | undefined;
-declare const findTabsetParent: (row: RowNode, tabsetId: string) => {
+declare const findTabsetParent: (model: Dashfoo, tabsetId: string) => {
   index: number;
   parent: RowNode;
 } | undefined;
 declare const findDuplicateIds: (model: Dashfoo) => Array<string>;
 //#endregion
-export { type Action, type AttributedNode, type BandOptions, DEFAULT_SNAP_THRESHOLD, DEFAULT_WEIGHT, type Dashfoo, type DashfooContext, type DashfooEvent, type DashfooInput, type DashfooMachineInput, type Dimension, type DockLocation, type DockTarget, type DockZone, type DragContext, type DragEmitted, type DragEvent, type DragSubject, type DropIntent, type Edge, type FloatNode, type FloatOptions, type Geometry, type GlobalAttributes, HISTORY_LIMIT, type History, type Json, type ModelOptions, type MutableNodeAttrs, type Node, type Orientation, type Point, type Rect, type RowNode, type RowNodeInput, type RowOptions, type SnapConfig, type SnapDecision, type SnapResult, type TabContainer, type TabLocation, type TabNode, type TabOptions, type TabsetNode, type TabsetOptions, type Unit, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, decideSnap, dimensionSchema, dispatch, dockLocationFor, dockLocationSchema, dockZonePolygons, dragDockMachine, edgeSchema, findAttributedNode, findDuplicateIds, findFloat, findRootContaining, findRow, findTab, findTabset, findTabsetParent, floatNode, floatNodeSchema, fromJSON, geometrySchema, getFirstTabset, globalAttributesSchema, jsonValueSchema, model, mutableNodeAttrsSchema, normalize, orientationSchema, parseModel, redo, reducer, resolveDockTarget, resolveSnapTargets, row, rowNodeSchema, settleSnap, snapEnabled, snapSchema, snapSizes, splitEdge, stackModel, tab, tabNodeSchema, tabset, tabsetNodeObjectSchema, tabsetNodeSchema, toJSON, undo, unitSchema, zoneRect };
+export { type Action, type AttributedNode, type BandOptions, DEFAULT_SNAP_THRESHOLD, DEFAULT_WEIGHT, type Dashfoo, type DashfooInput, type Dimension, type DockLocation, type DockZone, type DragState, type DragSubject, type DropIntent, type DropResolution, type Edge, type FloatNode, type FloatOptions, type Geometry, type GlobalAttributes, HISTORY_LIMIT, type History, type Json, type ModelOptions, type MutableNodeAttrs, type Node, type Orientation, type Point, type Rect, type RowNode, type RowNodeInput, type RowOptions, type SnapConfig, type SnapDecision, type SnapGrid, type SnapResult, type TabContainer, type TabLocation, type TabNode, type TabOptions, type TabsetNode, type TabsetOptions, type Unit, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, decideSnap, dimensionSchema, dispatch, dockLocationSchema, dockZonePolygons, dragDockMachine, dropAction, edgeSchema, findAttributedNode, findDuplicateIds, findFloat, findRootContaining, findRow, findTab, findTabset, findTabsetParent, floatNode, floatNodeSchema, fromJSON, geometrySchema, getFirstTabset, globalAttributesSchema, jsonValueSchema, model, mutableNodeAttrsSchema, normalize, orientationSchema, parseModel, redo, reducer, resolveDockTarget, resolveSnapGrid, resolveSnapTargets, row, rowNodeSchema, settleSnap, snapEnabled, snapSchema, snapSizes, splitEdge, stackModel, tab, tabNodeSchema, tabset, tabsetNodeObjectSchema, tabsetNodeSchema, toJSON, undo, unitSchema, zoneRect };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/state/node-attrs.ts","../src/state/actions.ts","../src/model/schema.ts","../src/model/builders.ts","../src/geometry/geometry.ts","../src/geometry/snap.ts","../src/state/history.ts","../src/model/ids.ts","../src/model/invariants.ts","../src/machines/dashfoo-machine.ts","../src/machines/drag-dock-machine.ts","../src/state/reducer.ts","../src/model/serialize.ts","../src/model/stack.ts","../src/model/tree.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/state/node-attrs.ts","../src/state/actions.ts","../src/model/schema.ts","../src/model/builders.ts","../src/geometry/geometry.ts","../src/geometry/snap.ts","../src/state/history.ts","../src/model/ids.ts","../src/model/invariants.ts","../src/machines/dashfoo-machine.ts","../src/machines/drag-dock-machine.ts","../src/state/reducer.ts","../src/model/serialize.ts","../src/model/stack.ts","../src/model/tree.ts"],"mappings":"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"}