aifsmjs 0.5.5 → 0.5.8

package/dist/chunk-FHTQ7LSQ.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var chunkI354FONA_cjs = require('./chunk-I354FONA.cjs');
+
+// src/replay/index.ts
+function replay(initial, events, def, impl) {
+  let snapshot = initial;
+  const effects = [];
+  for (const event of events) {
+    const r = chunkI354FONA_cjs.step(def, snapshot, event, impl);
+    snapshot = r.snapshot;
+    if (r.effects.length > 0) {
+      for (const eff of r.effects) effects.push(eff);
+    }
+  }
+  return Object.freeze({ snapshot, effects: Object.freeze(effects.slice()) });
+}
+
+exports.replay = replay;
+//# sourceMappingURL=chunk-FHTQ7LSQ.cjs.map
+//# sourceMappingURL=chunk-FHTQ7LSQ.cjs.map

package/dist/chunk-FHTQ7LSQ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/replay/index.ts"],"names":["step"],"mappings":";;;;;AAiBO,SAAS,MAAA,CACd,OAAA,EACA,MAAA,EACA,GAAA,EACA,IAAA,EAC2B;AAC3B,EAAA,IAAI,QAAA,GAAW,OAAA;AACf,EAAA,MAAM,UAAoB,EAAC;AAC3B,EAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,IAAA,MAAM,CAAA,GAAIA,sBAAA,CAAK,GAAA,EAAK,QAAA,EAAU,OAAO,IAAI,CAAA;AACzC,IAAA,QAAA,GAAW,CAAA,CAAE,QAAA;AACb,IAAA,IAAI,CAAA,CAAE,OAAA,CAAQ,MAAA,GAAS,CAAA,EAAG;AACxB,MAAA,KAAA,MAAW,GAAA,IAAO,CAAA,CAAE,OAAA,EAAS,OAAA,CAAQ,KAAK,GAAG,CAAA;AAAA,IAC/C;AAAA,EACF;AACA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,EAAE,QAAA,EAAU,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,CAAA,EAAG,CAAA;AAC5E","file":"chunk-FHTQ7LSQ.cjs","sourcesContent":["import { step } from \"../fsm/lifecycle.js\";\nimport type { Effect, Implementations, MachineDef, Snapshot } from \"../fsm/types.js\";\n\nexport type ReplayResult<Ctx, States extends string> = Readonly<{\n  snapshot: Snapshot<Ctx, States>;\n  effects: readonly Effect[];\n}>;\n\n/**\n * Fold an event log into a final snapshot via `step()`. Effects are collected\n * but never dispatched — this is a pure function, suitable for PBT, time\n * travel, and incident reproduction.\n *\n * Equivalent to:\n *   events.reduce((s, e) => step(def, s, e, impl).snapshot, initial)\n * but also accumulates the effects across all events.\n */\nexport function replay<Ctx, Evt extends { type: string }, States extends string>(\n  initial: Snapshot<Ctx, States>,\n  events: readonly Evt[],\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n): ReplayResult<Ctx, States> {\n  let snapshot = initial;\n  const effects: Effect[] = [];\n  for (const event of events) {\n    const r = step(def, snapshot, event, impl);\n    snapshot = r.snapshot;\n    if (r.effects.length > 0) {\n      for (const eff of r.effects) effects.push(eff);\n    }\n  }\n  return Object.freeze({ snapshot, effects: Object.freeze(effects.slice()) });\n}\n"]}

package/dist/chunk-I354FONA.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+var chunk3B2USJ3H_cjs = require('./chunk-3B2USJ3H.cjs');
+var chunkCDK25FTD_cjs = require('./chunk-CDK25FTD.cjs');
+
+// src/fsm/resolver.ts
+function normalizeTransition(entry) {
+  return typeof entry === "string" ? { target: entry } : entry;
+}
+function normalizeTransitions(entry) {
+  if (entry === void 0) return [];
+  if (Array.isArray(entry)) {
+    return entry.some((t) => typeof t === "string") ? entry.map((t) => normalizeTransition(t)) : entry;
+  }
+  return [normalizeTransition(entry)];
+}
+function resolveTransitions(def, stateValue, eventType) {
+  const state = def.states[stateValue];
+  if (!state || !state.on) return [];
+  return normalizeTransitions(state.on[eventType]);
+}
+
+// src/fsm/snapshot.ts
+var IS_DEV = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV !== "production";
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  if (Array.isArray(value)) {
+    for (const item of value) deepFreeze(item);
+  } else if (isPlainObject(value)) {
+    for (const key of Object.keys(value)) {
+      deepFreeze(value[key]);
+    }
+  }
+  return value;
+}
+function freezeSnapshot(snap) {
+  return IS_DEV ? deepFreeze(snap) : Object.freeze(snap);
+}
+function createSnapshot(args) {
+  return freezeSnapshot({
+    value: args.value,
+    context: args.context,
+    status: args.status ?? "active"
+  });
+}
+
+// src/fsm/updater.ts
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function assign(updater) {
+  return ({ context, event }) => updater({ context, event });
+}
+function mergeContext(current, patch) {
+  if (patch === void 0 || patch === null) return current;
+  if (isPlainRecord(current) && isPlainRecord(patch)) {
+    return { ...current, ...patch };
+  }
+  return patch;
+}
+
+// src/fsm/lifecycle.ts
+var UnknownActionError = class extends Error {
+  actionName;
+  constructor(actionName) {
+    super(`aifsmjs: action "${actionName}" not found in implementations.actions`);
+    this.name = "UnknownActionError";
+    this.actionName = actionName;
+  }
+};
+function resolveAction(ref, impl) {
+  if (typeof ref === "function") return ref;
+  const fn = impl.actions?.[ref];
+  if (!fn) throw new UnknownActionError(ref);
+  return fn;
+}
+function runActions(refs, ctx, event, impl, effectSink) {
+  if (!refs || refs.length === 0) return ctx;
+  const enqueue = chunk3B2USJ3H_cjs.createEnqueuer(effectSink);
+  let current = ctx;
+  for (const ref of refs) {
+    const fn = resolveAction(ref, impl);
+    const patch = fn({ context: current, event, enqueue });
+    current = mergeContext(current, patch);
+  }
+  return current;
+}
+function pickTransition(candidates, ctx, event, impl, value) {
+  for (const t of candidates) {
+    if (!t.guard) return t;
+    if (chunkCDK25FTD_cjs.evalGuard(t.guard, ctx, event, impl, value)) return t;
+  }
+  return void 0;
+}
+function step(def, snapshot, event, impl) {
+  if (snapshot.status === "final") {
+    return Object.freeze({ snapshot, effects: [], changed: false });
+  }
+  const state = def.states[snapshot.value];
+  if (!state) {
+    return Object.freeze({ snapshot, effects: [], changed: false });
+  }
+  const candidateList = normalizeTransitions(state.on?.[event.type]);
+  const chosen = pickTransition(candidateList, snapshot.context, event, impl, snapshot.value);
+  if (!chosen) {
+    return Object.freeze({ snapshot, effects: [], changed: false });
+  }
+  const isExternal = chosen.target !== void 0;
+  const nextStateValue = chosen.target ?? snapshot.value;
+  const nextState = def.states[nextStateValue];
+  const effectSink = [];
+  let ctx = snapshot.context;
+  if (isExternal) {
+    ctx = runActions(state.exit, ctx, event, impl, effectSink);
+  }
+  ctx = runActions(chosen.actions, ctx, event, impl, effectSink);
+  if (isExternal && nextState) {
+    ctx = runActions(nextState.entry, ctx, event, impl, effectSink);
+  }
+  const status = nextState?.final === true ? "final" : "active";
+  const nextSnapshot = freezeSnapshot({
+    value: nextStateValue,
+    context: ctx,
+    status
+  });
+  return Object.freeze({
+    snapshot: nextSnapshot,
+    effects: Object.freeze(effectSink.slice()),
+    changed: true
+  });
+}
+
+exports.UnknownActionError = UnknownActionError;
+exports.assign = assign;
+exports.createSnapshot = createSnapshot;
+exports.deepFreeze = deepFreeze;
+exports.freezeSnapshot = freezeSnapshot;
+exports.mergeContext = mergeContext;
+exports.normalizeTransition = normalizeTransition;
+exports.normalizeTransitions = normalizeTransitions;
+exports.resolveTransitions = resolveTransitions;
+exports.step = step;
+//# sourceMappingURL=chunk-I354FONA.cjs.map
+//# sourceMappingURL=chunk-I354FONA.cjs.map

package/dist/chunk-I354FONA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fsm/resolver.ts","../src/fsm/snapshot.ts","../src/fsm/updater.ts","../src/fsm/lifecycle.ts"],"names":["createEnqueuer","evalGuard"],"mappings":"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","file":"chunk-I354FONA.cjs","sourcesContent":["import type { MachineDef, TransitionConfig, TransitionDef } from \"./types.js\";\n\n/**\n * Normalize a single transition config into its object form. The string\n * shorthand `\"targetState\"` (à la XState) becomes `{ target: \"targetState\" }`;\n * the object form is returned unchanged. Centralised here so every consumer\n * (`step`, `resolveTransitions`, `can`, validation) sees the same shape.\n *\n * @since 0.5.3\n */\nexport function normalizeTransition<Ctx, Evt, States extends string>(\n  entry: TransitionConfig<Ctx, Evt, States>,\n): TransitionDef<Ctx, Evt, States> {\n  return typeof entry === \"string\" ? ({ target: entry } as TransitionDef<Ctx, Evt, States>) : entry;\n}\n\n/**\n * Normalize the raw `state.on[eventType]` value (object, string shorthand, or\n * an array mixing both) into an ordered list of {@link TransitionDef} objects.\n * Declaration order is preserved.\n *\n * @since 0.5.3\n */\nexport function normalizeTransitions<Ctx, Evt, States extends string>(\n  entry:\n    | TransitionConfig<Ctx, Evt, States>\n    | readonly TransitionConfig<Ctx, Evt, States>[]\n    | undefined,\n): readonly TransitionDef<Ctx, Evt, States>[] {\n  if (entry === undefined) return [];\n  if (Array.isArray(entry)) {\n    // Hot path (send/step/can run this per event): when no string shorthand is\n    // present, return the original array instead of allocating a normalized copy.\n    return entry.some((t) => typeof t === \"string\")\n      ? entry.map((t) => normalizeTransition(t))\n      : (entry as readonly TransitionDef<Ctx, Evt, States>[]);\n  }\n  return [normalizeTransition(entry as TransitionConfig<Ctx, Evt, States>)];\n}\n\n/**\n * Return all transition candidates for (state, eventType). Order is preserved\n * from the declaration so that guard fallthrough behaves predictably. String\n * shorthands are normalized to `{ target }` objects.\n *\n * If the event has no entry under the given state, an empty array is returned.\n */\nexport function resolveTransitions<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  stateValue: States,\n  eventType: string,\n): readonly TransitionDef<Ctx, Evt, States>[] {\n  const state = def.states[stateValue];\n  if (!state || !state.on) return [];\n  return normalizeTransitions(state.on[eventType]);\n}\n","import type { Snapshot } from \"./types.js\";\n\nconst IS_DEV =\n  typeof process !== \"undefined\" &&\n  typeof process.env !== \"undefined\" &&\n  process.env.NODE_ENV !== \"production\";\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\nexport function deepFreeze<T>(value: T): T {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Object.isFrozen(value)) return value;\n  Object.freeze(value);\n  if (Array.isArray(value)) {\n    for (const item of value) deepFreeze(item);\n  } else if (isPlainObject(value)) {\n    for (const key of Object.keys(value)) {\n      deepFreeze((value as Record<string, unknown>)[key]);\n    }\n  }\n  return value;\n}\n\n/**\n * Wrap a freshly built snapshot. In dev mode the whole tree is deep-frozen so\n * accidental mutation throws immediately. In production only the top object is\n * frozen, keeping the cost negligible.\n */\nexport function freezeSnapshot<C, S extends string>(snap: Snapshot<C, S>): Snapshot<C, S> {\n  // IS_DEV is always true in vitest; the production branch (`Object.freeze`)\n  // is exercised only when NODE_ENV === \"production\" and is intentionally\n  // left out of the coverage threshold.\n  return IS_DEV ? deepFreeze(snap) : Object.freeze(snap);\n}\n\nexport function createSnapshot<C, S extends string>(args: {\n  value: S;\n  context: C;\n  status?: \"active\" | \"final\";\n}): Snapshot<C, S> {\n  return freezeSnapshot({\n    value: args.value,\n    context: args.context,\n    status: args.status ?? \"active\",\n  });\n}\n","import type { Action } from \"./types.js\";\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n/**\n * Build an Action that returns a Partial<Ctx> from a pure updater.\n * The partial is merged into the current context by `step()`.\n */\nexport function assign<Ctx, Evt>(\n  updater: (args: { context: Ctx; event: Evt }) => Partial<Ctx>,\n): Action<Ctx, Evt> {\n  return ({ context, event }) => updater({ context, event });\n}\n\n/**\n * Merge a partial context update into the current context. Plain-object\n * contexts get a shallow merge; non-object contexts get replaced wholesale.\n *\n * The function never mutates either argument.\n */\nexport function mergeContext<Ctx>(current: Ctx, patch: Partial<Ctx> | void): Ctx {\n  if (patch === undefined || patch === null) return current;\n  if (isPlainRecord(current) && isPlainRecord(patch)) {\n    return { ...current, ...patch } as Ctx;\n  }\n  return patch as Ctx;\n}\n","import { createEnqueuer } from \"../effects/enqueuer.js\";\nimport { evalGuard } from \"./evaluator.js\";\nimport { normalizeTransitions } from \"./resolver.js\";\nimport { freezeSnapshot } from \"./snapshot.js\";\nimport type {\n  Action,\n  ActionRef,\n  Effect,\n  Implementations,\n  MachineDef,\n  Snapshot,\n  StepResult,\n  TransitionDef,\n} from \"./types.js\";\nimport { mergeContext } from \"./updater.js\";\n\nexport class UnknownActionError extends Error {\n  readonly actionName: string;\n  constructor(actionName: string) {\n    super(`aifsmjs: action \"${actionName}\" not found in implementations.actions`);\n    this.name = \"UnknownActionError\";\n    this.actionName = actionName;\n  }\n}\n\nfunction resolveAction<Ctx, Evt>(\n  ref: ActionRef<Ctx, Evt>,\n  impl: Implementations<Ctx, Evt>,\n): Action<Ctx, Evt> {\n  if (typeof ref === \"function\") return ref;\n  const fn = impl.actions?.[ref];\n  if (!fn) throw new UnknownActionError(ref);\n  return fn;\n}\n\nfunction runActions<Ctx, Evt>(\n  refs: readonly ActionRef<Ctx, Evt>[] | undefined,\n  ctx: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  effectSink: Effect[],\n): Ctx {\n  if (!refs || refs.length === 0) return ctx;\n  const enqueue = createEnqueuer(effectSink as { type: string; payload?: unknown }[]);\n  let current = ctx;\n  for (const ref of refs) {\n    const fn = resolveAction(ref, impl);\n    const patch = fn({ context: current, event, enqueue });\n    current = mergeContext(current, patch);\n  }\n  return current;\n}\n\nfunction pickTransition<Ctx, Evt, States extends string>(\n  candidates: readonly TransitionDef<Ctx, Evt, States>[],\n  ctx: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  value: States,\n): TransitionDef<Ctx, Evt, States> | undefined {\n  for (const t of candidates) {\n    if (!t.guard) return t;\n    if (evalGuard(t.guard, ctx, event, impl, value)) return t;\n  }\n  return undefined;\n}\n\n/**\n * Compute the next snapshot and collected effects from a single event.\n *\n * Order is fixed and uninterruptible:\n *   1. resolve candidate transitions for (state, event.type)\n *   2. evaluate guards in declaration order; pick the first passing one\n *   3. if external (target defined), run exit actions of the old state\n *   4. run transition.actions in declaration order\n *   5. if external, run entry actions of the new state\n *   6. return { snapshot, effects, changed }\n *\n * The function is pure: it never dispatches effects and never mutates inputs.\n */\nexport function step<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  snapshot: Snapshot<Ctx, States>,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n): StepResult<Ctx, States> {\n  // Final state is inert: it never reacts to events.\n  if (snapshot.status === \"final\") {\n    return Object.freeze({ snapshot, effects: [] as readonly Effect[], changed: false });\n  }\n\n  const state = def.states[snapshot.value];\n  /* v8 ignore next 3 — defensive: snapshot.value is always validated against def.states by defineMachine + initialSnapshot. */\n  if (!state) {\n    return Object.freeze({ snapshot, effects: [] as readonly Effect[], changed: false });\n  }\n\n  const candidateList = normalizeTransitions(state.on?.[event.type]);\n\n  const chosen = pickTransition(candidateList, snapshot.context, event, impl, snapshot.value);\n  if (!chosen) {\n    return Object.freeze({ snapshot, effects: [] as readonly Effect[], changed: false });\n  }\n\n  const isExternal = chosen.target !== undefined;\n  const nextStateValue = (chosen.target ?? snapshot.value) as States;\n  const nextState = def.states[nextStateValue];\n\n  const effectSink: Effect[] = [];\n  let ctx = snapshot.context;\n\n  if (isExternal) {\n    ctx = runActions(state.exit, ctx, event, impl, effectSink);\n  }\n  ctx = runActions(chosen.actions, ctx, event, impl, effectSink);\n  if (isExternal && nextState) {\n    ctx = runActions(nextState.entry, ctx, event, impl, effectSink);\n  }\n\n  const status: \"active\" | \"final\" = nextState?.final === true ? \"final\" : \"active\";\n  const nextSnapshot = freezeSnapshot({\n    value: nextStateValue,\n    context: ctx,\n    status,\n  });\n\n  return Object.freeze({\n    snapshot: nextSnapshot,\n    effects: Object.freeze(effectSink.slice()) as readonly Effect[],\n    changed: true,\n  });\n}\n"]}

package/dist/chunk-JKZAOPQC.js

@@ -0,0 +1,16 @@
+// src/effects/enqueuer.ts
+function createEnqueuer(sink) {
+  return Object.freeze({
+    effect(type, payload) {
+      if (payload === void 0) {
+        sink.push(Object.freeze({ type }));
+      } else {
+        sink.push(Object.freeze({ type, payload }));
+      }
+    }
+  });
+}
+
+export { createEnqueuer };
+//# sourceMappingURL=chunk-JKZAOPQC.js.map
+//# sourceMappingURL=chunk-JKZAOPQC.js.map

package/dist/chunk-JKZAOPQC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/effects/enqueuer.ts"],"names":[],"mappings":";AAUO,SAAS,eAAe,IAAA,EAAuD;AACpF,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,MAAA,CAAO,MAAc,OAAA,EAAmB;AACtC,MAAA,IAAI,YAAY,MAAA,EAAW;AACzB,QAAA,IAAA,CAAK,KAAK,MAAA,CAAO,MAAA,CAAO,EAAE,IAAA,EAAM,CAAC,CAAA;AAAA,MACnC,CAAA,MAAO;AACL,QAAA,IAAA,CAAK,KAAK,MAAA,CAAO,MAAA,CAAO,EAAE,IAAA,EAAM,OAAA,EAAS,CAAC,CAAA;AAAA,MAC5C;AAAA,IACF;AAAA,GACD,CAAA;AACH","file":"chunk-JKZAOPQC.js","sourcesContent":["import type { Enqueuer } from \"../fsm/types.js\";\n\n/**\n * Build a closure-based Enqueuer that pushes effects into the supplied sink.\n * Each `step()` invocation creates one such enqueuer and discards it\n * afterwards; the sink is the effects array later returned to the caller.\n *\n * Lives in `effects/` because the Enqueuer concept is the effects-domain API\n * — `step()` imports it from here.\n */\nexport function createEnqueuer(sink: { type: string; payload?: unknown }[]): Enqueuer {\n  return Object.freeze({\n    effect(type: string, payload?: unknown) {\n      if (payload === undefined) {\n        sink.push(Object.freeze({ type }));\n      } else {\n        sink.push(Object.freeze({ type, payload }));\n      }\n    },\n  });\n}\n"]}

package/dist/chunk-NEJYZAKR.js

@@ -0,0 +1,19 @@
+import { step } from './chunk-ZLQ7HZCE.js';
+
+// src/replay/index.ts
+function replay(initial, events, def, impl) {
+  let snapshot = initial;
+  const effects = [];
+  for (const event of events) {
+    const r = step(def, snapshot, event, impl);
+    snapshot = r.snapshot;
+    if (r.effects.length > 0) {
+      for (const eff of r.effects) effects.push(eff);
+    }
+  }
+  return Object.freeze({ snapshot, effects: Object.freeze(effects.slice()) });
+}
+
+export { replay };
+//# sourceMappingURL=chunk-NEJYZAKR.js.map
+//# sourceMappingURL=chunk-NEJYZAKR.js.map

package/dist/chunk-NEJYZAKR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/replay/index.ts"],"names":[],"mappings":";;;AAiBO,SAAS,MAAA,CACd,OAAA,EACA,MAAA,EACA,GAAA,EACA,IAAA,EAC2B;AAC3B,EAAA,IAAI,QAAA,GAAW,OAAA;AACf,EAAA,MAAM,UAAoB,EAAC;AAC3B,EAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,IAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,EAAK,QAAA,EAAU,OAAO,IAAI,CAAA;AACzC,IAAA,QAAA,GAAW,CAAA,CAAE,QAAA;AACb,IAAA,IAAI,CAAA,CAAE,OAAA,CAAQ,MAAA,GAAS,CAAA,EAAG;AACxB,MAAA,KAAA,MAAW,GAAA,IAAO,CAAA,CAAE,OAAA,EAAS,OAAA,CAAQ,KAAK,GAAG,CAAA;AAAA,IAC/C;AAAA,EACF;AACA,EAAA,OAAO,MAAA,CAAO,MAAA,CAAO,EAAE,QAAA,EAAU,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,CAAA,EAAG,CAAA;AAC5E","file":"chunk-NEJYZAKR.js","sourcesContent":["import { step } from \"../fsm/lifecycle.js\";\nimport type { Effect, Implementations, MachineDef, Snapshot } from \"../fsm/types.js\";\n\nexport type ReplayResult<Ctx, States extends string> = Readonly<{\n  snapshot: Snapshot<Ctx, States>;\n  effects: readonly Effect[];\n}>;\n\n/**\n * Fold an event log into a final snapshot via `step()`. Effects are collected\n * but never dispatched — this is a pure function, suitable for PBT, time\n * travel, and incident reproduction.\n *\n * Equivalent to:\n *   events.reduce((s, e) => step(def, s, e, impl).snapshot, initial)\n * but also accumulates the effects across all events.\n */\nexport function replay<Ctx, Evt extends { type: string }, States extends string>(\n  initial: Snapshot<Ctx, States>,\n  events: readonly Evt[],\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n): ReplayResult<Ctx, States> {\n  let snapshot = initial;\n  const effects: Effect[] = [];\n  for (const event of events) {\n    const r = step(def, snapshot, event, impl);\n    snapshot = r.snapshot;\n    if (r.effects.length > 0) {\n      for (const eff of r.effects) effects.push(eff);\n    }\n  }\n  return Object.freeze({ snapshot, effects: Object.freeze(effects.slice()) });\n}\n"]}

package/dist/chunk-PZ5AY32C.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };
+//# sourceMappingURL=chunk-PZ5AY32C.js.map
+//# sourceMappingURL=chunk-PZ5AY32C.js.map

package/dist/chunk-PZ5AY32C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-PZ5AY32C.js"}

package/dist/chunk-Q7SFCCGT.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+exports.__export = __export;
+//# sourceMappingURL=chunk-Q7SFCCGT.cjs.map
+//# sourceMappingURL=chunk-Q7SFCCGT.cjs.map

package/dist/chunk-Q7SFCCGT.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-Q7SFCCGT.cjs"}

package/dist/chunk-VZCSHTOI.js

@@ -0,0 +1,374 @@
+import { freezeSnapshot, step, normalizeTransitions, deepFreeze } from './chunk-ZLQ7HZCE.js';
+import { evalGuard, isAsyncGuardFn, isThenable } from './chunk-A7U7QQL5.js';
+
+// src/fsm/types.ts
+var RESET_EVENT_TYPE = "@@aifsmjs/RESET";
+
+// src/fsm/definition.ts
+var InvalidDefinitionError = class extends Error {
+  constructor(message) {
+    super(`aifsmjs: ${message}`);
+    this.name = "InvalidDefinitionError";
+  }
+};
+function validateDefinition(def) {
+  if (!def.id || typeof def.id !== "string") {
+    throw new InvalidDefinitionError("definition must have a non-empty string `id`");
+  }
+  if (!def.states || typeof def.states !== "object") {
+    throw new InvalidDefinitionError("definition must have a `states` object");
+  }
+  const stateKeys = Object.keys(def.states);
+  if (stateKeys.length === 0) {
+    throw new InvalidDefinitionError("`states` must declare at least one state");
+  }
+  if (!def.initial || !stateKeys.includes(def.initial)) {
+    throw new InvalidDefinitionError(
+      `\`initial\` "${String(def.initial)}" is not declared in states (${stateKeys.join(", ")})`
+    );
+  }
+  for (const [stateName, stateDef] of Object.entries(def.states)) {
+    if (stateDef.sub !== void 0) {
+      const sub = stateDef.sub;
+      const subStates = sub.states;
+      const subInitial = sub.initial;
+      if (typeof sub !== "object" || sub === null || typeof subStates !== "object" || subStates === null || typeof subInitial !== "string" || // initial must name one of the sub's own states — otherwise the child
+      // boots pointing at a non-existent state and no-ops forever (FSM-S-02).
+      !Object.hasOwn(subStates, subInitial)) {
+        throw new InvalidDefinitionError(
+          `state "${stateName}".sub is not a valid sub-machine definition (missing states or initial)`
+        );
+      }
+    }
+    if (!stateDef.on) continue;
+    for (const [evtType, entry] of Object.entries(stateDef.on)) {
+      const transitions = normalizeTransitions(entry);
+      for (const t of transitions) {
+        if (t.target !== void 0 && !stateKeys.includes(t.target)) {
+          throw new InvalidDefinitionError(
+            `transition ${stateName} -[${evtType}]-> "${String(t.target)}" targets an unknown state`
+          );
+        }
+        if (t.guard !== void 0 && isAsyncGuardFn(t.guard)) {
+          throw new InvalidDefinitionError(
+            `transition ${stateName} -[${evtType}]-> uses an async guard. Guards must be sync; move I/O into an effect.`
+          );
+        }
+      }
+    }
+  }
+}
+function defineMachine(def) {
+  const normalized = !("context" in def) ? { ...def, context: {} } : def;
+  validateDefinition(normalized);
+  return normalized;
+}
+function setup() {
+  return {
+    defineMachine: (def) => {
+      const cast = !("context" in def) ? { ...def, context: {} } : def;
+      validateDefinition(cast);
+      return cast;
+    }
+  };
+}
+function initialSnapshot(def) {
+  const isFinal = def.states[def.initial]?.final === true;
+  return freezeSnapshot({
+    value: def.initial,
+    context: def.context,
+    status: isFinal ? "final" : "active"
+  });
+}
+function createMachine(def, impl, opts) {
+  return createRuntime(defineMachine(def), impl, opts ?? {});
+}
+
+// src/fsm/runtime.ts
+var RuntimeDisposedError = class extends Error {
+  constructor() {
+    super("aifsmjs: runtime has been disposed; send()/reset() are not allowed");
+    this.name = "RuntimeDisposedError";
+  }
+};
+var SubMachineError = class extends Error {
+  parentState;
+  phase;
+  cause;
+  constructor(parentState, phase, cause) {
+    super(`aifsmjs: sub-machine ${phase} failed at parent state "${parentState}"`, { cause });
+    this.name = "SubMachineError";
+    this.parentState = parentState;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
+var RESET_EVENT = Object.freeze({ type: RESET_EVENT_TYPE });
+function composeMiddleware(middleware) {
+  return (ctx, finalNext) => {
+    let index = -1;
+    const dispatch = (i) => {
+      if (i <= index) throw new Error("aifsmjs: next() called multiple times in middleware");
+      index = i;
+      const fn = middleware[i];
+      if (!fn) {
+        finalNext();
+        return;
+      }
+      fn(ctx, () => dispatch(i + 1));
+    };
+    dispatch(0);
+  };
+}
+function createRuntime(def, impl, opts = {}) {
+  let snapshot = initialSnapshot(def);
+  const listeners = /* @__PURE__ */ new Set();
+  const middlewareChain = opts.middleware && opts.middleware.length > 0 ? composeMiddleware(opts.middleware) : void 0;
+  const shouldDispatch = opts.dispatchEffects !== false;
+  const controller = new AbortController();
+  let disposed = false;
+  let childRuntime;
+  let childAbortCleanup;
+  const eventListeners = {
+    transition: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    dispose: /* @__PURE__ */ new Set()
+  };
+  const externalAbortCleanups = /* @__PURE__ */ new Set();
+  function emit(type, payload) {
+    for (const fn of Array.from(eventListeners[type])) fn(payload);
+  }
+  function notify(committed) {
+    const captured = committed ?? snapshot;
+    for (const l of Array.from(listeners)) l(captured);
+  }
+  function runMiddleware(prev, event, effects, changed) {
+    if (!middlewareChain) return;
+    middlewareChain(deepFreeze({ prev, next: snapshot, event, effects, changed }), () => {
+    });
+  }
+  function dispatchEffects(effects, context, event) {
+    if (!impl.effects || effects.length === 0) return;
+    for (const eff of effects) {
+      const handler = impl.effects[eff.type];
+      if (!handler) continue;
+      const r = handler(eff, { context, event, signal: controller.signal });
+      if (isThenable(r)) {
+        Promise.resolve(r).catch((err) => {
+          emit("error", { error: err, event });
+        });
+      }
+    }
+  }
+  function wireChildAbort(child) {
+    if (controller.signal.aborted) {
+      try {
+        child.dispose();
+      } catch {
+      }
+      return () => {
+      };
+    }
+    const onAbort = () => {
+      try {
+        child.dispose();
+      } catch {
+      }
+    };
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+    return () => controller.signal.removeEventListener("abort", onAbort);
+  }
+  function initChildFor(stateValue) {
+    const stateDef = def.states[stateValue];
+    const sub = stateDef?.sub;
+    if (sub === void 0) return;
+    let newChild;
+    try {
+      newChild = createRuntime(sub, stateDef.subImpl ?? {});
+    } catch (cause) {
+      throw new SubMachineError(stateValue, "init", cause);
+    }
+    childRuntime = newChild;
+    childAbortCleanup = wireChildAbort(newChild);
+  }
+  function findChosenIsExternal(value, event, context) {
+    const state = def.states[value];
+    if (!state?.on) return false;
+    const list = normalizeTransitions(state.on[event.type]);
+    if (list.length === 0) return false;
+    for (const t of list) {
+      if (!t.guard || evalGuard(t.guard, context, event, impl, value)) {
+        return t.target !== void 0;
+      }
+    }
+    return false;
+  }
+  function applySubLifecycle(prevValue, nextValue) {
+    const prevStateDef = def.states[prevValue];
+    const nextStateDef = def.states[nextValue];
+    if (prevStateDef?.sub !== void 0 && childRuntime !== void 0) {
+      const child = childRuntime;
+      childRuntime = void 0;
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        child.dispose();
+      } catch (cause) {
+        throw new SubMachineError(prevValue, "dispose", cause);
+      }
+    }
+    if (nextStateDef?.sub !== void 0) {
+      initChildFor(nextValue);
+    }
+  }
+  function send(event) {
+    if (disposed) throw new RuntimeDisposedError();
+    const prev = snapshot;
+    const result = step(def, prev, event, impl);
+    const isExternal = result.changed && (prev.value !== result.snapshot.value || findChosenIsExternal(prev.value, event, prev.context));
+    if (result.changed && isExternal) applySubLifecycle(prev.value, result.snapshot.value);
+    snapshot = result.snapshot;
+    const committed = result.snapshot;
+    runMiddleware(prev, event, result.effects, result.changed);
+    if (shouldDispatch) dispatchEffects(result.effects, committed.context, event);
+    if (result.changed) {
+      notify(committed);
+      emit("transition", {
+        prev,
+        next: committed,
+        event,
+        effects: result.effects,
+        changed: true
+      });
+    }
+    return snapshot;
+  }
+  function reset(event) {
+    if (disposed) throw new RuntimeDisposedError();
+    const prev = snapshot;
+    const nextSnap = initialSnapshot(def);
+    const changed = prev.value !== nextSnap.value;
+    if (childRuntime) {
+      const child = childRuntime;
+      childRuntime = void 0;
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        child.dispose();
+      } catch (cause) {
+        throw new SubMachineError(prev.value, "dispose", cause);
+      }
+    }
+    const initStateDef = def.states[nextSnap.value];
+    if (initStateDef?.sub) {
+      initChildFor(nextSnap.value);
+    }
+    snapshot = nextSnap;
+    const committed = nextSnap;
+    const triggerEvent = event ?? RESET_EVENT;
+    runMiddleware(prev, triggerEvent, [], changed);
+    if (changed) {
+      notify(committed);
+      emit("transition", {
+        prev,
+        next: committed,
+        event: triggerEvent,
+        effects: [],
+        changed: true
+      });
+    }
+    return snapshot;
+  }
+  function can(event) {
+    if (disposed || snapshot.status === "final") return false;
+    const state = def.states[snapshot.value];
+    if (!state) return false;
+    const list = normalizeTransitions(state.on?.[event.type]);
+    if (list.length === 0) return false;
+    for (const t of list) {
+      if (!t.guard) return true;
+      if (evalGuard(t.guard, snapshot.context, event, impl, snapshot.value)) return true;
+    }
+    return false;
+  }
+  function on(type, listener, options) {
+    if (disposed || options?.signal?.aborted) return () => {
+    };
+    const target = eventListeners[type];
+    let detachAbort;
+    const cleanup = () => {
+      target.delete(wrapped);
+      if (detachAbort) {
+        detachAbort();
+        externalAbortCleanups.delete(detachAbort);
+      }
+    };
+    let wrapped = listener;
+    if (options?.once) {
+      wrapped = (payload) => {
+        cleanup();
+        listener(payload);
+      };
+    }
+    target.add(wrapped);
+    const signal = options?.signal;
+    if (signal) {
+      const onAbort = () => cleanup();
+      signal.addEventListener("abort", onAbort, { once: true });
+      detachAbort = () => signal.removeEventListener("abort", onAbort);
+      externalAbortCleanups.add(detachAbort);
+    }
+    return cleanup;
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    if (childRuntime) {
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        childRuntime.dispose();
+      } catch {
+      }
+      childRuntime = void 0;
+    }
+    controller.abort();
+    listeners.clear();
+    emit("dispose", void 0);
+    for (const set of Object.values(eventListeners)) set.clear();
+    for (const cleanup of externalAbortCleanups) cleanup();
+    externalAbortCleanups.clear();
+  }
+  const runtime = {
+    getSnapshot: () => snapshot,
+    snapshot: () => snapshot,
+    send,
+    can,
+    reset,
+    dispose,
+    on,
+    get disposed() {
+      return disposed;
+    },
+    get signal() {
+      return controller.signal;
+    },
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    subRuntime: () => childRuntime,
+    onTransition: (handler, options) => on("transition", handler, options)
+  };
+  const bootStateDef = def.states[snapshot.value];
+  if (bootStateDef?.sub) {
+    initChildFor(snapshot.value);
+  }
+  return runtime;
+}
+
+export { InvalidDefinitionError, RESET_EVENT_TYPE, RuntimeDisposedError, SubMachineError, createMachine, createRuntime, defineMachine, initialSnapshot, setup };
+//# sourceMappingURL=chunk-VZCSHTOI.js.map
+//# sourceMappingURL=chunk-VZCSHTOI.js.map