aifsmjs 0.5.5 → 0.5.8

package/dist/pbt/index.js

@@ -1,195 +1,11 @@
+import { createRuntime, initialSnapshot } from '../chunk-VZCSHTOI.js';
+import { replay } from '../chunk-NEJYZAKR.js';
+import { step, mergeContext, normalizeTransitions } from '../chunk-ZLQ7HZCE.js';
+import '../chunk-JKZAOPQC.js';
+import '../chunk-A7U7QQL5.js';
+import { __export } from '../chunk-PZ5AY32C.js';
 import * as fc2 from 'fast-check';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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 }));
-      }
-    }
-  });
-}
-
-// src/fsm/evaluator.ts
-var UnknownGuardError = class extends Error {
-  guardName;
-  constructor(guardName) {
-    super(`aifsmjs: guard "${guardName}" not found in implementations.guards`);
-    this.name = "UnknownGuardError";
-    this.guardName = guardName;
-  }
-};
-var AsyncGuardError = class extends Error {
-  guardName;
-  constructor(guardName) {
-    super(
-      `aifsmjs: guard "${guardName}" must be sync; received a Promise. Async guards break determinism and replay. Move I/O into an effect.`
-    );
-    this.name = "AsyncGuardError";
-    this.guardName = guardName;
-  }
-};
-function isAsyncGuardFn(fn) {
-  if (typeof fn !== "function") return false;
-  return fn.constructor?.name === "AsyncFunction";
-}
-function isThenable(x) {
-  return x !== null && (typeof x === "object" || typeof x === "function") && typeof x.then === "function";
-}
-function resolveGuard(ref, impl) {
-  if (typeof ref === "function") return ref;
-  const fn = impl.guards?.[ref];
-  if (!fn) throw new UnknownGuardError(ref);
-  return fn;
-}
-function evalGuard(ref, context, event, impl, value) {
-  const fn = resolveGuard(ref, impl);
-  const guardName = typeof ref === "string" ? ref : fn.name || "<inline>";
-  if (isAsyncGuardFn(fn)) {
-    throw new AsyncGuardError(guardName);
-  }
-  const args = { context, event };
-  const guardsMap = impl.guards;
-  if (guardsMap) args.guards = guardsMap;
-  if (value !== void 0) args.value = value;
-  const result = fn(args);
-  if (isThenable(result)) {
-    throw new AsyncGuardError(guardName);
-  }
-  return result;
-}
-
-// 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)];
-}
-
-// 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);
-}
-
-// 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 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 = 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 (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
-  });
-}
-
-// src/pbt/commands.ts
 function initialModel(def) {
   return {
     value: def.initial,
@@ -248,327 +64,6 @@ __export(properties_exports, {
   snapshotAlwaysFrozen: () => snapshotAlwaysFrozen,
   unknownEventNoOp: () => unknownEventNoOp
 });
-
-// src/fsm/types.ts
-var RESET_EVENT_TYPE = "@@aifsmjs/RESET";
-
-// 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 eventListeners[type]) fn(payload);
-  }
-  function notify(committed) {
-    const captured = committed ?? snapshot;
-    for (const l of 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 (r instanceof Promise) {
-        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 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) {
-      let newChild;
-      try {
-        newChild = createRuntime(nextStateDef.sub, nextStateDef.subImpl ?? {});
-      } catch (cause) {
-        throw new SubMachineError(nextValue, "init", cause);
-      }
-      childRuntime = newChild;
-      childAbortCleanup = wireChildAbort(newChild);
-    }
-  }
-  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) {
-      let newChild;
-      try {
-        newChild = createRuntime(initStateDef.sub, initStateDef.subImpl ?? {});
-      } catch (cause) {
-        throw new SubMachineError(nextSnap.value, "init", cause);
-      }
-      childRuntime = newChild;
-      childAbortCleanup = wireChildAbort(newChild);
-    }
-    snapshot = nextSnap;
-    const triggerEvent = event ?? RESET_EVENT;
-    runMiddleware(prev, triggerEvent, [], changed);
-    if (changed) {
-      notify();
-      emit("transition", {
-        prev,
-        next: snapshot,
-        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) {
-    let newChild;
-    try {
-      newChild = createRuntime(bootStateDef.sub, bootStateDef.subImpl ?? {});
-    } catch (cause) {
-      throw new SubMachineError(snapshot.value, "init", cause);
-    }
-    childRuntime = newChild;
-    childAbortCleanup = wireChildAbort(newChild);
-  }
-  return runtime;
-}
-
-// src/fsm/definition.ts
-function initialSnapshot(def) {
-  const isFinal = def.states[def.initial]?.final === true;
-  return freezeSnapshot({
-    value: def.initial,
-    context: def.context,
-    status: isFinal ? "final" : "active"
-  });
-}
-
-// 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()) });
-}
-
-// src/pbt/properties.ts
 function buildAssertOpts(opts) {
   const out = {};
   if (opts?.numRuns !== void 0) out.numRuns = opts.numRuns;
@@ -636,13 +131,19 @@ function guardsFalseNoTransition(def, impl, eventArbitraries, opts) {
     ...impl,
     guards: blockedGuards
   };
+  const isFullyGuarded = (value, eventType) => {
+    const candidates = normalizeTransitions(def.states[value]?.on?.[eventType]);
+    return candidates.length > 0 && candidates.every((t) => t.guard !== void 0);
+  };
   fc2.assert(
     fc2.property(
       fc2.array(fc2.oneof(...Object.values(eventArbitraries)), { maxLength: 16 }),
       (events) => {
         let snap = initialSnapshot(def);
         for (const e of events) {
+          const fullyGuarded = isFullyGuarded(snap.value, e.type);
           const r = step(def, snap, e, blockedImpl);
+          if (fullyGuarded && r.changed !== false) return false;
           snap = r.snapshot;
         }
         return true;