machinalayout 0.1.0 → 0.3.0

package/dist/chunk-ZVDE7PX4.js

@@ -0,0 +1,222 @@
+import {
+  getMachinaDebugOverlayBehavior
+} from "./chunk-2ZQ2RFFI.js";
+import {
+  toResolvedTree
+} from "./chunk-SVWYWI7I.js";
+
+// src/react/MachinaReactView.tsx
+import React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function normalizeLayerZ(value) {
+  if (value === void 0 || !Number.isFinite(value) || !Number.isInteger(value) || value < -5 || value > 5) {
+    return 0;
+  }
+  return value;
+}
+function getEffectiveLayer(node, defaultLayer) {
+  return node.layer ?? defaultLayer;
+}
+function getEffectiveLayerZ(node, layers, defaultLayer) {
+  const layerName = getEffectiveLayer(node, defaultLayer);
+  return normalizeLayerZ(layers[layerName]?.z);
+}
+function renderNode(node, parentRect, views, viewData, nodeData, nodeClassName, debug, nodeContainment, nodeContentVisibility, nodeContainIntrinsicSize, nodesById, layers, defaultLayer) {
+  const viewKey = node.view ?? node.slot;
+  const View = viewKey ? views[viewKey] : void 0;
+  const selectedViewData = viewKey ? viewData?.[viewKey] : void 0;
+  const selectedNodeData = nodeData?.[node.id];
+  const left = node.rect.x - parentRect.x;
+  const top = node.rect.y - parentRect.y;
+  const effectiveLayer = getEffectiveLayer(node, defaultLayer);
+  const effectiveLayerZ = getEffectiveLayerZ(node, layers, defaultLayer);
+  const style = {
+    position: "absolute",
+    left,
+    top,
+    width: node.rect.width,
+    height: node.rect.height,
+    boxSizing: "border-box",
+    zIndex: effectiveLayerZ * 100 + (node.z ?? 0),
+    ...nodeContainment === "layout-paint" ? { contain: "layout paint" } : null,
+    ...nodeContainment === "strict" ? { contain: "strict" } : null,
+    ...nodeContentVisibility === "auto" ? { contentVisibility: "auto" } : null,
+    ...nodeContainIntrinsicSize !== void 0 ? { containIntrinsicSize: nodeContainIntrinsicSize } : null,
+    ...debug ? { outline: "1px dashed rgba(59, 130, 246, 0.9)" } : null
+  };
+  const renderedSlot = View && nodesById[node.id] ? React.createElement(View, {
+    id: node.id,
+    rect: { ...node.rect },
+    debugLabel: node.debugLabel,
+    node: { ...nodesById[node.id], rect: { ...nodesById[node.id].rect } },
+    viewKey,
+    viewData: selectedViewData,
+    nodeData: selectedNodeData
+  }) : null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": `machina-node-${node.id}`,
+      className: nodeClassName,
+      style,
+      "data-machina-node-id": node.id,
+      "data-machina-slot": node.slot,
+      "data-machina-view": viewKey,
+      "data-machina-debug-label": node.debugLabel,
+      "data-machina-layer": effectiveLayer,
+      children: [
+        debug ? /* @__PURE__ */ jsx("small", { children: node.debugLabel ?? node.id }) : null,
+        renderedSlot,
+        [...node.children].map((child, index) => ({ child, index })).sort(
+          (a, b) => getEffectiveLayerZ(a.child, layers, defaultLayer) - getEffectiveLayerZ(b.child, layers, defaultLayer) || (a.child.z ?? 0) - (b.child.z ?? 0) || a.index - b.index
+        ).map(
+          ({ child }) => renderNode(
+            child,
+            node.rect,
+            views,
+            viewData,
+            nodeData,
+            nodeClassName,
+            debug,
+            nodeContainment,
+            nodeContentVisibility,
+            nodeContainIntrinsicSize,
+            nodesById,
+            layers,
+            defaultLayer
+          )
+        )
+      ]
+    },
+    node.id
+  );
+}
+function collectOverlayNodes(node) {
+  return [node, ...node.children.flatMap((child) => collectOverlayNodes(child))];
+}
+function renderDebugOverlay(tree, options) {
+  const board = {
+    mode: options.mode ?? "collapsed",
+    labels: options.labels ?? true,
+    borders: options.borders ?? true,
+    selectedNodeId: options.selectedNodeId
+  };
+  const behavior = getMachinaDebugOverlayBehavior(board);
+  if (!behavior.visible) return null;
+  const nodes = collectOverlayNodes(tree);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": "machina-debug-overlay",
+      "data-machina-debug-overlay-mode": board.mode,
+      style: {
+        position: "absolute",
+        inset: 0,
+        pointerEvents: behavior.pointerEvents,
+        zIndex: 1e4,
+        boxSizing: "border-box"
+      },
+      children: [
+        nodes.map((node) => /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-testid": `machina-debug-overlay-node-${node.id}`,
+            "data-machina-debug-overlay-node-id": node.id,
+            style: {
+              position: "absolute",
+              left: node.rect.x - tree.rect.x,
+              top: node.rect.y - tree.rect.y,
+              width: node.rect.width,
+              height: node.rect.height,
+              boxSizing: "border-box",
+              border: behavior.showBorders ? "1px solid rgba(14, 165, 233, 0.9)" : "0",
+              pointerEvents: behavior.pointerEvents
+            },
+            children: behavior.showLabels ? /* @__PURE__ */ jsx(
+              "span",
+              {
+                style: {
+                  position: "absolute",
+                  left: 0,
+                  top: 0,
+                  fontSize: 10,
+                  lineHeight: "12px",
+                  background: "rgba(14, 165, 233, 0.9)",
+                  color: "white",
+                  padding: "0 3px"
+                },
+                children: node.debugLabel ?? node.id
+              }
+            ) : null
+          },
+          node.id
+        )),
+        behavior.showPanel ? /* @__PURE__ */ jsxs(
+          "div",
+          {
+            "data-testid": "machina-debug-overlay-panel",
+            style: {
+              position: "absolute",
+              right: 8,
+              top: 8,
+              background: "rgba(15, 23, 42, 0.92)",
+              color: "white",
+              padding: 8
+            },
+            children: [
+              "Debug overlay",
+              board.selectedNodeId ? `: ${board.selectedNodeId}` : ""
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function MachinaReactView(props) {
+  const {
+    layout,
+    views = {},
+    viewData,
+    nodeData,
+    className,
+    style,
+    nodeClassName,
+    debug,
+    nodeContainment = "layout-paint",
+    nodeContentVisibility = "none",
+    nodeContainIntrinsicSize,
+    layers = { base: { z: 0 } },
+    defaultLayer = "base",
+    debugOverlay
+  } = props;
+  const tree = toResolvedTree(layout);
+  const wrapperStyle = {
+    position: "relative",
+    width: tree.rect.width,
+    height: tree.rect.height,
+    ...style
+  };
+  return /* @__PURE__ */ jsxs("div", { className, style: wrapperStyle, "data-machina-root-id": tree.id, children: [
+    renderNode(
+      tree,
+      tree.rect,
+      views,
+      viewData,
+      nodeData,
+      nodeClassName,
+      debug,
+      nodeContainment,
+      nodeContentVisibility,
+      nodeContainIntrinsicSize,
+      layout.nodes,
+      layers,
+      defaultLayer
+    ),
+    debugOverlay ? renderDebugOverlay(tree, debugOverlay) : null
+  ] });
+}
+
+export {
+  MachinaReactView
+};

package/dist/debugOverlay-pJpj0n5H.d.ts

@@ -0,0 +1,125 @@
+declare class DeusMachinaError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+type UtilityScore<TContext> = number | ((context: TContext) => number);
+type UtilityCandidate<TContext, TKey extends string = string> = {
+    key: TKey;
+    when?: (context: TContext) => boolean;
+    score: UtilityScore<TContext>;
+    reason?: string | ((context: TContext) => string);
+};
+type UtilityCandidateResult<TKey extends string = string> = {
+    key: TKey;
+    eligible: boolean;
+    score: number;
+    index: number;
+    reason?: string;
+};
+type UtilityJudgment<TKey extends string = string> = {
+    selected: UtilityCandidateResult<TKey> | null;
+    candidates: UtilityCandidateResult<TKey>[];
+};
+type JudgeUtilityOptions<TKey extends string = string> = {
+    previousKey?: TKey;
+    hysteresis?: number;
+};
+type DeusStatePath = readonly string[];
+type DeusEvent = {
+    type: string;
+};
+type DeusAction<TBoard, TEvent extends DeusEvent> = (board: TBoard, event: TEvent) => void;
+type DeusStateRow<TBoard, TEvent extends DeusEvent> = {
+    path: DeusStatePath;
+    onEnter?: DeusAction<TBoard, TEvent>;
+    onExit?: DeusAction<TBoard, TEvent>;
+};
+type DeusUtilityTransitionCandidate<TBoard, TEvent extends DeusEvent, TKey extends string = string> = {
+    key: TKey;
+    when?: (board: TBoard, event: TEvent) => boolean;
+    score: number | ((board: TBoard, event: TEvent) => number);
+    do?: DeusAction<TBoard, TEvent>;
+    reason?: string | ((board: TBoard, event: TEvent) => string);
+};
+type DeusTransitionRow<TBoard, TEvent extends DeusEvent> = {
+    key: string;
+    from: DeusStatePath;
+    event?: TEvent["type"];
+    to?: DeusStatePath | ((board: TBoard, event: TEvent) => DeusStatePath);
+    when?: (board: TBoard, event: TEvent) => boolean;
+    score?: number | ((board: TBoard, event: TEvent) => number);
+    do?: DeusAction<TBoard, TEvent>;
+    reason?: string | ((board: TBoard, event: TEvent) => string);
+    utility?: readonly DeusUtilityTransitionCandidate<TBoard, TEvent>[];
+    hysteresis?: {
+        previous: (board: TBoard) => string | undefined;
+        margin: number;
+    };
+};
+type DeusMachine<TBoard, TEvent extends DeusEvent> = {
+    initial: DeusStatePath;
+    states: readonly DeusStateRow<TBoard, TEvent>[];
+    transitions: readonly DeusTransitionRow<TBoard, TEvent>[];
+};
+type DeusSnapshot<TBoard> = {
+    state: DeusStatePath;
+    board: TBoard;
+    stepIndex: number;
+};
+type DeusTransitionTrace = {
+    key: string;
+    from: DeusStatePath;
+    to?: DeusStatePath;
+    event?: string;
+    eligible: boolean;
+    score: number;
+    index: number;
+    reason?: string;
+    utility?: UtilityJudgment<string>;
+};
+type DeusStepTrace = {
+    stateBefore: DeusStatePath;
+    stateAfter: DeusStatePath;
+    event: string;
+    selectedTransition?: DeusTransitionTrace;
+    transitions: DeusTransitionTrace[];
+};
+type DeusStepResult<TBoard> = {
+    snapshot: DeusSnapshot<TBoard>;
+    trace: DeusStepTrace;
+};
+
+type MachinaDebugOverlayMode = "collapsed" | "nonInteractiveOverlay" | "interactivePanel";
+type MachinaDebugOverlayBoard = {
+    mode: MachinaDebugOverlayMode;
+    labels: boolean;
+    borders: boolean;
+    selectedNodeId?: string;
+};
+type MachinaDebugOverlayEvent = {
+    type: "showOverlay";
+} | {
+    type: "openPanel";
+    nodeId?: string;
+} | {
+    type: "collapse";
+} | {
+    type: "toggleLabels";
+} | {
+    type: "toggleBorders";
+} | {
+    type: "selectNode";
+    nodeId: string;
+};
+type MachinaDebugOverlayBehavior = {
+    visible: boolean;
+    pointerEvents: "none" | "auto";
+    consumesLayoutSpace: boolean;
+    showPanel: boolean;
+    showLabels: boolean;
+    showBorders: boolean;
+};
+declare function createMachinaDebugOverlayMachine(): DeusMachine<MachinaDebugOverlayBoard, MachinaDebugOverlayEvent>;
+declare function getMachinaDebugOverlayBehavior(board: MachinaDebugOverlayBoard): MachinaDebugOverlayBehavior;
+
+export { type DeusEvent as D, type JudgeUtilityOptions as J, type MachinaDebugOverlayBehavior as M, type UtilityCandidate as U, type UtilityJudgment as a, type DeusMachine as b, type DeusSnapshot as c, type DeusStatePath as d, type DeusStepTrace as e, type DeusStepResult as f, type DeusAction as g, DeusMachinaError as h, type DeusStateRow as i, type DeusTransitionRow as j, type DeusTransitionTrace as k, type DeusUtilityTransitionCandidate as l, type MachinaDebugOverlayBoard as m, type MachinaDebugOverlayEvent as n, type MachinaDebugOverlayMode as o, type UtilityCandidateResult as p, type UtilityScore as q, createMachinaDebugOverlayMachine as r, getMachinaDebugOverlayBehavior as s };

package/dist/deus/index.d.ts

@@ -0,0 +1,14 @@
+import { U as UtilityCandidate, J as JudgeUtilityOptions, a as UtilityJudgment, D as DeusEvent, b as DeusMachine, c as DeusSnapshot, d as DeusStatePath, e as DeusStepTrace, f as DeusStepResult } from '../debugOverlay-pJpj0n5H.js';
+export { g as DeusAction, h as DeusMachinaError, i as DeusStateRow, j as DeusTransitionRow, k as DeusTransitionTrace, l as DeusUtilityTransitionCandidate, M as MachinaDebugOverlayBehavior, m as MachinaDebugOverlayBoard, n as MachinaDebugOverlayEvent, o as MachinaDebugOverlayMode, p as UtilityCandidateResult, q as UtilityScore, r as createMachinaDebugOverlayMachine, s as getMachinaDebugOverlayBehavior } from '../debugOverlay-pJpj0n5H.js';
+
+declare function judgeUtility<TContext, TKey extends string = string>(context: TContext, candidates: readonly UtilityCandidate<TContext, TKey>[], options?: JudgeUtilityOptions<TKey>): UtilityJudgment<TKey>;
+
+declare function formatDeusPath(path: DeusStatePath): string;
+declare function sameDeusPath(a: DeusStatePath, b: DeusStatePath): boolean;
+declare function isDeusAncestorPath(ancestor: DeusStatePath, path: DeusStatePath): boolean;
+declare function defineDeusMachine<TBoard, TEvent extends DeusEvent>(machine: DeusMachine<TBoard, TEvent>): DeusMachine<TBoard, TEvent>;
+declare function createDeusSnapshot<TBoard, TEvent extends DeusEvent>(machine: DeusMachine<TBoard, TEvent>, board: TBoard): DeusSnapshot<TBoard>;
+declare function stepDeusMachine<TBoard, TEvent extends DeusEvent>(machine: DeusMachine<TBoard, TEvent>, snapshot: DeusSnapshot<TBoard>, event: NoInfer<TEvent>): DeusStepResult<TBoard>;
+declare function formatDeusStepTrace(trace: DeusStepTrace): string;
+
+export { DeusEvent, DeusMachine, DeusSnapshot, DeusStatePath, DeusStepResult, DeusStepTrace, JudgeUtilityOptions, UtilityCandidate, UtilityJudgment, createDeusSnapshot, defineDeusMachine, formatDeusPath, formatDeusStepTrace, isDeusAncestorPath, judgeUtility, sameDeusPath, stepDeusMachine };

package/dist/deus/index.js

@@ -0,0 +1,26 @@
+import {
+  DeusMachinaError,
+  createDeusSnapshot,
+  createMachinaDebugOverlayMachine,
+  defineDeusMachine,
+  formatDeusPath,
+  formatDeusStepTrace,
+  getMachinaDebugOverlayBehavior,
+  isDeusAncestorPath,
+  judgeUtility,
+  sameDeusPath,
+  stepDeusMachine
+} from "../chunk-2ZQ2RFFI.js";
+export {
+  DeusMachinaError,
+  createDeusSnapshot,
+  createMachinaDebugOverlayMachine,
+  defineDeusMachine,
+  formatDeusPath,
+  formatDeusStepTrace,
+  getMachinaDebugOverlayBehavior,
+  isDeusAncestorPath,
+  judgeUtility,
+  sameDeusPath,
+  stepDeusMachine
+};

package/dist/dispatch/index.d.ts

@@ -0,0 +1,49 @@
+type SetDispatchTable<TState> = {
+    events: readonly string[];
+    fields: readonly (keyof TState)[];
+    values: readonly unknown[];
+};
+type ToggleDispatchTable<TState> = {
+    events: readonly string[];
+    fields: readonly (keyof TState)[];
+};
+type IncrementDispatchTable<TState> = {
+    events: readonly string[];
+    fields: readonly (keyof TState)[];
+    by?: readonly number[];
+};
+type PrefixSetDispatchTable<TState> = {
+    prefixes: readonly string[];
+    fields: readonly (keyof TState)[];
+    allowedSuffixes?: readonly (readonly string[] | undefined)[];
+};
+type PrefixIncrementDispatchTable<TState> = {
+    prefixes: readonly string[];
+    fields: readonly (keyof TState)[];
+    by?: readonly number[];
+    allowedSuffixes?: readonly (readonly string[] | undefined)[];
+};
+type MachinaDispatchTables<TState> = {
+    set?: SetDispatchTable<TState>;
+    toggle?: ToggleDispatchTable<TState>;
+    increment?: IncrementDispatchTable<TState>;
+    setSuffix?: PrefixSetDispatchTable<TState>;
+    incrementSuffix?: PrefixIncrementDispatchTable<TState>;
+};
+
+declare function dispatchEvent<TState extends Record<string, unknown>>(state: TState, event: string, tables: MachinaDispatchTables<TState>): TState;
+
+type MachinaDispatchErrorCode = "InvalidDispatchTable" | "InvalidDispatchField" | "InvalidDispatchValue" | "InvalidDispatchEvent";
+declare class MachinaDispatchError extends Error {
+    readonly code: MachinaDispatchErrorCode;
+    constructor(code: MachinaDispatchErrorCode, message: string);
+}
+
+declare function defineDispatchTables<TState>(tables: MachinaDispatchTables<TState>): MachinaDispatchTables<TState>;
+declare function resolveEventValue<TValue>(event: string, table: {
+    events: readonly string[];
+    values: readonly TValue[];
+}): TValue | undefined;
+declare function matchEventPrefix(event: string, prefix: string, allowedSuffixes?: readonly string[]): string | undefined;
+
+export { type IncrementDispatchTable, MachinaDispatchError, type MachinaDispatchErrorCode, type MachinaDispatchTables, type PrefixIncrementDispatchTable, type PrefixSetDispatchTable, type SetDispatchTable, type ToggleDispatchTable, defineDispatchTables, dispatchEvent, matchEventPrefix, resolveEventValue };

package/dist/dispatch/index.js

@@ -0,0 +1,217 @@
+// src/dispatch/errors.ts
+var MachinaDispatchError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "MachinaDispatchError";
+    this.code = code;
+  }
+};
+
+// src/dispatch/helpers.ts
+var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+var validateLengths = (name, ...columns) => {
+  const expected = columns[0]?.length ?? 0;
+  if (!columns.every((column) => Array.isArray(column) && column.length === expected)) {
+    throw new MachinaDispatchError("InvalidDispatchTable", `${name} column lengths must match`);
+  }
+};
+var validateAllowedSuffixes = (allowedSuffixes, expectedLength, tableName) => {
+  if (allowedSuffixes === void 0) return;
+  if (!Array.isArray(allowedSuffixes) || allowedSuffixes.length !== expectedLength) {
+    throw new MachinaDispatchError(
+      "InvalidDispatchTable",
+      `${tableName}.allowedSuffixes length mismatch`
+    );
+  }
+  for (const row of allowedSuffixes) {
+    if (row !== void 0 && !isStringArray(row)) {
+      throw new MachinaDispatchError(
+        "InvalidDispatchTable",
+        `${tableName}.allowedSuffixes must be string arrays`
+      );
+    }
+  }
+};
+var validateBy = (by, expectedLength, tableName) => {
+  if (by === void 0) return;
+  if (!Array.isArray(by) || by.length !== expectedLength) {
+    throw new MachinaDispatchError("InvalidDispatchTable", `${tableName}.by length mismatch`);
+  }
+  for (const value of by) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new MachinaDispatchError(
+        "InvalidDispatchTable",
+        `${tableName}.by must contain finite numbers`
+      );
+    }
+  }
+};
+var validateSetTable = (table) => {
+  validateLengths("set", table.events, table.fields, table.values);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "set.events must be strings");
+};
+var validateToggleTable = (table) => {
+  validateLengths("toggle", table.events, table.fields);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "toggle.events must be strings");
+};
+var validateIncrementTable = (table) => {
+  validateLengths("increment", table.events, table.fields);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "increment.events must be strings");
+  validateBy(table.by, table.events.length, "increment");
+};
+var validatePrefixSetTable = (table) => {
+  validateLengths("setSuffix", table.prefixes, table.fields);
+  if (!isStringArray(table.prefixes))
+    throw new MachinaDispatchError("InvalidDispatchTable", "setSuffix.prefixes must be strings");
+  validateAllowedSuffixes(table.allowedSuffixes, table.prefixes.length, "setSuffix");
+};
+var validatePrefixIncrementTable = (table) => {
+  validateLengths("incrementSuffix", table.prefixes, table.fields);
+  if (!isStringArray(table.prefixes))
+    throw new MachinaDispatchError(
+      "InvalidDispatchTable",
+      "incrementSuffix.prefixes must be strings"
+    );
+  validateBy(table.by, table.prefixes.length, "incrementSuffix");
+  validateAllowedSuffixes(table.allowedSuffixes, table.prefixes.length, "incrementSuffix");
+};
+function defineDispatchTables(tables) {
+  if (tables.set) validateSetTable(tables.set);
+  if (tables.toggle) validateToggleTable(tables.toggle);
+  if (tables.increment) validateIncrementTable(tables.increment);
+  if (tables.setSuffix) validatePrefixSetTable(tables.setSuffix);
+  if (tables.incrementSuffix) validatePrefixIncrementTable(tables.incrementSuffix);
+  return tables;
+}
+function resolveEventValue(event, table) {
+  validateLengths("resolveEventValue", table.events, table.values);
+  if (!isStringArray(table.events))
+    throw new MachinaDispatchError("InvalidDispatchTable", "events must be strings");
+  for (let i = 0; i < table.events.length; i += 1) {
+    if (table.events[i] === event) return table.values[i];
+  }
+  return void 0;
+}
+function matchEventPrefix(event, prefix, allowedSuffixes) {
+  if (typeof event !== "string" || typeof prefix !== "string") {
+    throw new MachinaDispatchError("InvalidDispatchEvent", "event and prefix must be strings");
+  }
+  if (allowedSuffixes !== void 0 && !isStringArray(allowedSuffixes)) {
+    throw new MachinaDispatchError(
+      "InvalidDispatchTable",
+      "allowedSuffixes must be a string array"
+    );
+  }
+  if (!event.startsWith(prefix)) return void 0;
+  const suffix = event.slice(prefix.length);
+  if (allowedSuffixes && !allowedSuffixes.includes(suffix)) return void 0;
+  return suffix;
+}
+
+// src/dispatch/dispatchEvent.ts
+var hasOwn = (state, field) => Object.hasOwn(state, field);
+function dispatchEvent(state, event, tables) {
+  if (typeof event !== "string") {
+    throw new MachinaDispatchError("InvalidDispatchEvent", "event must be a string");
+  }
+  const base = state;
+  if (tables.set) {
+    validateSetTable(tables.set);
+    for (let i = 0; i < tables.set.events.length; i += 1) {
+      if (tables.set.events[i] !== event) continue;
+      const field = tables.set.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const nextValue = tables.set.values[i];
+      if (Object.is(base[field], nextValue)) return state;
+      return { ...state, [field]: nextValue };
+    }
+  }
+  if (tables.toggle) {
+    validateToggleTable(tables.toggle);
+    for (let i = 0; i < tables.toggle.events.length; i += 1) {
+      if (tables.toggle.events[i] !== event) continue;
+      const field = tables.toggle.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const current = base[field];
+      if (typeof current !== "boolean")
+        throw new MachinaDispatchError(
+          "InvalidDispatchValue",
+          `field must be boolean: ${String(field)}`
+        );
+      return { ...state, [field]: !current };
+    }
+  }
+  if (tables.increment) {
+    validateIncrementTable(tables.increment);
+    for (let i = 0; i < tables.increment.events.length; i += 1) {
+      if (tables.increment.events[i] !== event) continue;
+      const field = tables.increment.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const current = base[field];
+      if (typeof current !== "number")
+        throw new MachinaDispatchError(
+          "InvalidDispatchValue",
+          `field must be number: ${String(field)}`
+        );
+      const delta = tables.increment.by?.[i] ?? 1;
+      if (!Number.isFinite(delta))
+        throw new MachinaDispatchError("InvalidDispatchValue", "increment delta must be finite");
+      return { ...state, [field]: current + delta };
+    }
+  }
+  if (tables.setSuffix) {
+    validatePrefixSetTable(tables.setSuffix);
+    for (let i = 0; i < tables.setSuffix.prefixes.length; i += 1) {
+      const suffix = matchEventPrefix(
+        event,
+        tables.setSuffix.prefixes[i],
+        tables.setSuffix.allowedSuffixes?.[i]
+      );
+      if (suffix === void 0) continue;
+      const field = tables.setSuffix.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      if (Object.is(base[field], suffix)) return state;
+      return { ...state, [field]: suffix };
+    }
+  }
+  if (tables.incrementSuffix) {
+    validatePrefixIncrementTable(tables.incrementSuffix);
+    for (let i = 0; i < tables.incrementSuffix.prefixes.length; i += 1) {
+      const suffix = matchEventPrefix(
+        event,
+        tables.incrementSuffix.prefixes[i],
+        tables.incrementSuffix.allowedSuffixes?.[i]
+      );
+      if (suffix === void 0) continue;
+      const field = tables.incrementSuffix.fields[i];
+      if (!hasOwn(base, field))
+        throw new MachinaDispatchError("InvalidDispatchField", `missing field: ${String(field)}`);
+      const current = base[field];
+      if (typeof current !== "number")
+        throw new MachinaDispatchError(
+          "InvalidDispatchValue",
+          `field must be number: ${String(field)}`
+        );
+      const delta = tables.incrementSuffix.by?.[i] ?? 1;
+      if (!Number.isFinite(delta))
+        throw new MachinaDispatchError("InvalidDispatchValue", "increment delta must be finite");
+      return { ...state, [field]: current + delta };
+    }
+  }
+  return state;
+}
+export {
+  MachinaDispatchError,
+  defineDispatchTables,
+  dispatchEvent,
+  matchEventPrefix,
+  resolveEventValue
+};