aifsmjs 0.5.5 → 0.5.6

package/dist/effects/index.cjs

@@ -1,17 +1,8 @@
 'use strict';
 
-// 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 }));
-      }
-    }
-  });
-}
+var chunk3B2USJ3H_cjs = require('../chunk-3B2USJ3H.cjs');
+var chunkCDK25FTD_cjs = require('../chunk-CDK25FTD.cjs');
+require('../chunk-Q7SFCCGT.cjs');
 
 // src/effects/dispatcher.ts
 var NEVER_SIGNAL;
@@ -28,12 +19,15 @@ function runEffects(effects, handlers, args) {
     const h = handlers[eff.type];
     if (!h) continue;
     const r = h(eff, handlerArgs);
-    if (r instanceof Promise) promises.push(r);
+    if (chunkCDK25FTD_cjs.isThenable(r)) promises.push(Promise.resolve(r));
   }
   return promises;
 }
 
-exports.createEnqueuer = createEnqueuer;
+Object.defineProperty(exports, "createEnqueuer", {
+  enumerable: true,
+  get: function () { return chunk3B2USJ3H_cjs.createEnqueuer; }
+});
 exports.runEffects = runEffects;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/effects/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/effects/enqueuer.ts","../../src/effects/dispatcher.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;;;AChBA,IAAI,YAAA;AACJ,SAAS,WAAA,GAA2B;AAClC,EAAA,IAAI,CAAC,YAAA,EAAc,YAAA,GAAe,IAAI,iBAAgB,CAAE,MAAA;AACxD,EAAA,OAAO,YAAA;AACT;AAgBO,SAAS,UAAA,CACd,OAAA,EACA,QAAA,EACA,IAAA,EAC0B;AAC1B,EAAA,IAAI,CAAC,QAAA,IAAY,OAAA,CAAQ,MAAA,KAAW,CAAA,SAAU,EAAC;AAC/C,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,MAAA,IAAU,WAAA,EAAY;AAC1C,EAAA,MAAM,WAAA,GAAc,EAAE,OAAA,EAAS,IAAA,CAAK,SAAS,KAAA,EAAO,IAAA,CAAK,OAAO,MAAA,EAAO;AACvE,EAAA,MAAM,WAA4B,EAAC;AACnC,EAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,IAAA,MAAM,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA;AAC3B,IAAA,IAAI,CAAC,CAAA,EAAG;AACR,IAAA,MAAM,CAAA,GAAI,CAAA,CAAE,GAAA,EAAK,WAAW,CAAA;AAC5B,IAAA,IAAI,CAAA,YAAa,OAAA,EAAS,QAAA,CAAS,IAAA,CAAK,CAAC,CAAA;AAAA,EAC3C;AACA,EAAA,OAAO,QAAA;AACT","file":"index.cjs","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","import type { Effect, EffectHandler } from \"../fsm/types.js\";\n\n// Lazily-built never-aborting signal for callers who don't supply one. Reused\n// across runEffects() invocations to avoid allocating a controller per call.\nlet NEVER_SIGNAL: AbortSignal | undefined;\nfunction neverSignal(): AbortSignal {\n  if (!NEVER_SIGNAL) NEVER_SIGNAL = new AbortController().signal;\n  return NEVER_SIGNAL;\n}\n\n/**\n * Dispatch a batch of effects through the supplied handler map. Effects whose\n * `type` has no handler are silently skipped (the runtime treats unhandled\n * effects as informational).\n *\n * Returns the array of Promise results (if any handler is async) so callers\n * can `await Promise.all(...)` when they need flushing — the default runtime\n * is fire-and-forget and discards them.\n *\n * Each handler receives an `AbortSignal`. When called from `createRuntime`,\n * the signal is the runtime's own controller. Stand-alone callers may omit\n * `args.signal` (a never-aborting placeholder is supplied) or pass their own\n * (e.g. `AbortSignal.timeout(5000)`, `AbortSignal.any([...])`).\n */\nexport function runEffects<Ctx, Evt>(\n  effects: readonly Effect[],\n  handlers: Readonly<Record<string, EffectHandler<Ctx, Evt>>> | undefined,\n  args: { context: Ctx; event: Evt; signal?: AbortSignal },\n): readonly Promise<void>[] {\n  if (!handlers || effects.length === 0) return [];\n  const signal = args.signal ?? neverSignal();\n  const handlerArgs = { context: args.context, event: args.event, signal };\n  const promises: Promise<void>[] = [];\n  for (const eff of effects) {\n    const h = handlers[eff.type];\n    if (!h) continue;\n    const r = h(eff, handlerArgs);\n    if (r instanceof Promise) promises.push(r);\n  }\n  return promises;\n}\n"]}
+{"version":3,"sources":["../../src/effects/dispatcher.ts"],"names":["isThenable"],"mappings":";;;;;;;AAKA,IAAI,YAAA;AACJ,SAAS,WAAA,GAA2B;AAClC,EAAA,IAAI,CAAC,YAAA,EAAc,YAAA,GAAe,IAAI,iBAAgB,CAAE,MAAA;AACxD,EAAA,OAAO,YAAA;AACT;AAgBO,SAAS,UAAA,CACd,OAAA,EACA,QAAA,EACA,IAAA,EAC0B;AAC1B,EAAA,IAAI,CAAC,QAAA,IAAY,OAAA,CAAQ,MAAA,KAAW,CAAA,SAAU,EAAC;AAC/C,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,MAAA,IAAU,WAAA,EAAY;AAC1C,EAAA,MAAM,WAAA,GAAc,EAAE,OAAA,EAAS,IAAA,CAAK,SAAS,KAAA,EAAO,IAAA,CAAK,OAAO,MAAA,EAAO;AACvE,EAAA,MAAM,WAA4B,EAAC;AACnC,EAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,IAAA,MAAM,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA;AAC3B,IAAA,IAAI,CAAC,CAAA,EAAG;AACR,IAAA,MAAM,CAAA,GAAI,CAAA,CAAE,GAAA,EAAK,WAAW,CAAA;AAI5B,IAAA,IAAIA,4BAAA,CAAW,CAAC,CAAA,EAAG,QAAA,CAAS,KAAK,OAAA,CAAQ,OAAA,CAAQ,CAAC,CAAC,CAAA;AAAA,EACrD;AACA,EAAA,OAAO,QAAA;AACT","file":"index.cjs","sourcesContent":["import { isThenable } from \"../fsm/evaluator.js\";\nimport type { Effect, EffectHandler } from \"../fsm/types.js\";\n\n// Lazily-built never-aborting signal for callers who don't supply one. Reused\n// across runEffects() invocations to avoid allocating a controller per call.\nlet NEVER_SIGNAL: AbortSignal | undefined;\nfunction neverSignal(): AbortSignal {\n  if (!NEVER_SIGNAL) NEVER_SIGNAL = new AbortController().signal;\n  return NEVER_SIGNAL;\n}\n\n/**\n * Dispatch a batch of effects through the supplied handler map. Effects whose\n * `type` has no handler are silently skipped (the runtime treats unhandled\n * effects as informational).\n *\n * Returns the array of Promise results (if any handler is async) so callers\n * can `await Promise.all(...)` when they need flushing — the default runtime\n * is fire-and-forget and discards them.\n *\n * Each handler receives an `AbortSignal`. When called from `createRuntime`,\n * the signal is the runtime's own controller. Stand-alone callers may omit\n * `args.signal` (a never-aborting placeholder is supplied) or pass their own\n * (e.g. `AbortSignal.timeout(5000)`, `AbortSignal.any([...])`).\n */\nexport function runEffects<Ctx, Evt>(\n  effects: readonly Effect[],\n  handlers: Readonly<Record<string, EffectHandler<Ctx, Evt>>> | undefined,\n  args: { context: Ctx; event: Evt; signal?: AbortSignal },\n): readonly Promise<void>[] {\n  if (!handlers || effects.length === 0) return [];\n  const signal = args.signal ?? neverSignal();\n  const handlerArgs = { context: args.context, event: args.event, signal };\n  const promises: Promise<void>[] = [];\n  for (const eff of effects) {\n    const h = handlers[eff.type];\n    if (!h) continue;\n    const r = h(eff, handlerArgs);\n    // isThenable (not instanceof Promise) so cross-realm Promises and\n    // user-defined PromiseLike results are also awaitable by callers;\n    // Promise.resolve() normalises them to a real Promise (FSM-B-03).\n    if (isThenable(r)) promises.push(Promise.resolve(r));\n  }\n  return promises;\n}\n"]}

package/dist/effects/index.js

@@ -1,15 +1,6 @@
-// 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 } from '../chunk-JKZAOPQC.js';
+import { isThenable } from '../chunk-A7U7QQL5.js';
+import '../chunk-PZ5AY32C.js';
 
 // src/effects/dispatcher.ts
 var NEVER_SIGNAL;
@@ -26,11 +17,11 @@ function runEffects(effects, handlers, args) {
     const h = handlers[eff.type];
     if (!h) continue;
     const r = h(eff, handlerArgs);
-    if (r instanceof Promise) promises.push(r);
+    if (isThenable(r)) promises.push(Promise.resolve(r));
   }
   return promises;
 }
 
-export { createEnqueuer, runEffects };
+export { runEffects };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/effects/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/effects/enqueuer.ts","../../src/effects/dispatcher.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;;;AChBA,IAAI,YAAA;AACJ,SAAS,WAAA,GAA2B;AAClC,EAAA,IAAI,CAAC,YAAA,EAAc,YAAA,GAAe,IAAI,iBAAgB,CAAE,MAAA;AACxD,EAAA,OAAO,YAAA;AACT;AAgBO,SAAS,UAAA,CACd,OAAA,EACA,QAAA,EACA,IAAA,EAC0B;AAC1B,EAAA,IAAI,CAAC,QAAA,IAAY,OAAA,CAAQ,MAAA,KAAW,CAAA,SAAU,EAAC;AAC/C,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,MAAA,IAAU,WAAA,EAAY;AAC1C,EAAA,MAAM,WAAA,GAAc,EAAE,OAAA,EAAS,IAAA,CAAK,SAAS,KAAA,EAAO,IAAA,CAAK,OAAO,MAAA,EAAO;AACvE,EAAA,MAAM,WAA4B,EAAC;AACnC,EAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,IAAA,MAAM,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA;AAC3B,IAAA,IAAI,CAAC,CAAA,EAAG;AACR,IAAA,MAAM,CAAA,GAAI,CAAA,CAAE,GAAA,EAAK,WAAW,CAAA;AAC5B,IAAA,IAAI,CAAA,YAAa,OAAA,EAAS,QAAA,CAAS,IAAA,CAAK,CAAC,CAAA;AAAA,EAC3C;AACA,EAAA,OAAO,QAAA;AACT","file":"index.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","import type { Effect, EffectHandler } from \"../fsm/types.js\";\n\n// Lazily-built never-aborting signal for callers who don't supply one. Reused\n// across runEffects() invocations to avoid allocating a controller per call.\nlet NEVER_SIGNAL: AbortSignal | undefined;\nfunction neverSignal(): AbortSignal {\n  if (!NEVER_SIGNAL) NEVER_SIGNAL = new AbortController().signal;\n  return NEVER_SIGNAL;\n}\n\n/**\n * Dispatch a batch of effects through the supplied handler map. Effects whose\n * `type` has no handler are silently skipped (the runtime treats unhandled\n * effects as informational).\n *\n * Returns the array of Promise results (if any handler is async) so callers\n * can `await Promise.all(...)` when they need flushing — the default runtime\n * is fire-and-forget and discards them.\n *\n * Each handler receives an `AbortSignal`. When called from `createRuntime`,\n * the signal is the runtime's own controller. Stand-alone callers may omit\n * `args.signal` (a never-aborting placeholder is supplied) or pass their own\n * (e.g. `AbortSignal.timeout(5000)`, `AbortSignal.any([...])`).\n */\nexport function runEffects<Ctx, Evt>(\n  effects: readonly Effect[],\n  handlers: Readonly<Record<string, EffectHandler<Ctx, Evt>>> | undefined,\n  args: { context: Ctx; event: Evt; signal?: AbortSignal },\n): readonly Promise<void>[] {\n  if (!handlers || effects.length === 0) return [];\n  const signal = args.signal ?? neverSignal();\n  const handlerArgs = { context: args.context, event: args.event, signal };\n  const promises: Promise<void>[] = [];\n  for (const eff of effects) {\n    const h = handlers[eff.type];\n    if (!h) continue;\n    const r = h(eff, handlerArgs);\n    if (r instanceof Promise) promises.push(r);\n  }\n  return promises;\n}\n"]}
+{"version":3,"sources":["../../src/effects/dispatcher.ts"],"names":[],"mappings":";;;;;AAKA,IAAI,YAAA;AACJ,SAAS,WAAA,GAA2B;AAClC,EAAA,IAAI,CAAC,YAAA,EAAc,YAAA,GAAe,IAAI,iBAAgB,CAAE,MAAA;AACxD,EAAA,OAAO,YAAA;AACT;AAgBO,SAAS,UAAA,CACd,OAAA,EACA,QAAA,EACA,IAAA,EAC0B;AAC1B,EAAA,IAAI,CAAC,QAAA,IAAY,OAAA,CAAQ,MAAA,KAAW,CAAA,SAAU,EAAC;AAC/C,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,MAAA,IAAU,WAAA,EAAY;AAC1C,EAAA,MAAM,WAAA,GAAc,EAAE,OAAA,EAAS,IAAA,CAAK,SAAS,KAAA,EAAO,IAAA,CAAK,OAAO,MAAA,EAAO;AACvE,EAAA,MAAM,WAA4B,EAAC;AACnC,EAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,IAAA,MAAM,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA;AAC3B,IAAA,IAAI,CAAC,CAAA,EAAG;AACR,IAAA,MAAM,CAAA,GAAI,CAAA,CAAE,GAAA,EAAK,WAAW,CAAA;AAI5B,IAAA,IAAI,UAAA,CAAW,CAAC,CAAA,EAAG,QAAA,CAAS,KAAK,OAAA,CAAQ,OAAA,CAAQ,CAAC,CAAC,CAAA;AAAA,EACrD;AACA,EAAA,OAAO,QAAA;AACT","file":"index.js","sourcesContent":["import { isThenable } from \"../fsm/evaluator.js\";\nimport type { Effect, EffectHandler } from \"../fsm/types.js\";\n\n// Lazily-built never-aborting signal for callers who don't supply one. Reused\n// across runEffects() invocations to avoid allocating a controller per call.\nlet NEVER_SIGNAL: AbortSignal | undefined;\nfunction neverSignal(): AbortSignal {\n  if (!NEVER_SIGNAL) NEVER_SIGNAL = new AbortController().signal;\n  return NEVER_SIGNAL;\n}\n\n/**\n * Dispatch a batch of effects through the supplied handler map. Effects whose\n * `type` has no handler are silently skipped (the runtime treats unhandled\n * effects as informational).\n *\n * Returns the array of Promise results (if any handler is async) so callers\n * can `await Promise.all(...)` when they need flushing — the default runtime\n * is fire-and-forget and discards them.\n *\n * Each handler receives an `AbortSignal`. When called from `createRuntime`,\n * the signal is the runtime's own controller. Stand-alone callers may omit\n * `args.signal` (a never-aborting placeholder is supplied) or pass their own\n * (e.g. `AbortSignal.timeout(5000)`, `AbortSignal.any([...])`).\n */\nexport function runEffects<Ctx, Evt>(\n  effects: readonly Effect[],\n  handlers: Readonly<Record<string, EffectHandler<Ctx, Evt>>> | undefined,\n  args: { context: Ctx; event: Evt; signal?: AbortSignal },\n): readonly Promise<void>[] {\n  if (!handlers || effects.length === 0) return [];\n  const signal = args.signal ?? neverSignal();\n  const handlerArgs = { context: args.context, event: args.event, signal };\n  const promises: Promise<void>[] = [];\n  for (const eff of effects) {\n    const h = handlers[eff.type];\n    if (!h) continue;\n    const r = h(eff, handlerArgs);\n    // isThenable (not instanceof Promise) so cross-realm Promises and\n    // user-defined PromiseLike results are also awaitable by callers;\n    // Promise.resolve() normalises them to a real Promise (FSM-B-03).\n    if (isThenable(r)) promises.push(Promise.resolve(r));\n  }\n  return promises;\n}\n"]}

package/dist/guards/index.cjs

@@ -1,21 +1,17 @@
 'use strict';
 
-// 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 chunkCDK25FTD_cjs = require('../chunk-CDK25FTD.cjs');
+require('../chunk-Q7SFCCGT.cjs');
 
 // src/guards/index.ts
 function resolveItem(item, args) {
-  if (typeof item === "function") return item(args);
-  const fn = args.guards?.[item];
-  if (!fn) throw new UnknownGuardError(item);
-  return fn(args);
+  const fn = typeof item === "function" ? item : args.guards?.[item];
+  if (!fn) throw new chunkCDK25FTD_cjs.UnknownGuardError(item);
+  const result = fn(args);
+  if (chunkCDK25FTD_cjs.isThenable(result)) {
+    throw new chunkCDK25FTD_cjs.AsyncGuardError(typeof item === "string" ? item : fn.name || "<inline>");
+  }
+  return result;
 }
 function and(items) {
   return (args) => {

package/dist/guards/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fsm/evaluator.ts","../../src/guards/index.ts"],"names":[],"mappings":";;;AAEO,IAAM,iBAAA,GAAN,cAAgC,KAAA,CAAM;AAAA,EAClC,SAAA;AAAA,EACT,YAAY,SAAA,EAAmB;AAC7B,IAAA,KAAA,CAAM,CAAA,gBAAA,EAAmB,SAAS,CAAA,qCAAA,CAAuC,CAAA;AACzE,IAAA,IAAA,CAAK,IAAA,GAAO,mBAAA;AACZ,IAAA,IAAA,CAAK,SAAA,GAAY,SAAA;AAAA,EACnB;AACF,CAAA;;;ACNA,SAAS,WAAA,CAAsB,MAA0B,IAAA,EAAoC;AAC3F,EAAA,IAAI,OAAO,IAAA,KAAS,UAAA,EAAY,OAAO,KAAK,IAAI,CAAA;AAChD,EAAA,MAAM,EAAA,GAAK,IAAA,CAAK,MAAA,GAAS,IAAI,CAAA;AAC7B,EAAA,IAAI,CAAC,EAAA,EAAI,MAAM,IAAI,kBAAkB,IAAI,CAAA;AACzC,EAAA,OAAO,GAAG,IAAI,CAAA;AAChB;AAGO,SAAS,IAAc,KAAA,EAAuD;AACnF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,CAAC,WAAA,CAAY,IAAA,EAAM,IAAI,GAAG,OAAO,KAAA;AAAA,IACvC;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,GAAa,KAAA,EAAuD;AAClF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,WAAA,CAAY,IAAA,EAAM,IAAI,CAAA,EAAG,OAAO,IAAA;AAAA,IACtC;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,IAAc,IAAA,EAA2C;AACvE,EAAA,OAAO,CAAC,IAAA,KAAS,CAAC,WAAA,CAAY,MAAM,IAAI,CAAA;AAC1C;AAQO,SAAS,WAAqB,MAAA,EAA4C;AAC/E,EAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAY,MAAM,CAAA;AAClC,EAAA,OAAO,CAAC,EAAE,KAAA,EAAM,KAAM,OAAO,KAAA,KAAU,QAAA,IAAY,GAAA,CAAI,GAAA,CAAI,KAAK,CAAA;AAClE","file":"index.cjs","sourcesContent":["import type { Guard, GuardRef, Implementations } from \"./types.js\";\n\nexport class UnknownGuardError extends Error {\n  readonly guardName: string;\n  constructor(guardName: string) {\n    super(`aifsmjs: guard \"${guardName}\" not found in implementations.guards`);\n    this.name = \"UnknownGuardError\";\n    this.guardName = guardName;\n  }\n}\n\nexport class AsyncGuardError extends Error {\n  readonly guardName: string;\n  constructor(guardName: string) {\n    super(\n      `aifsmjs: guard \"${guardName}\" must be sync; received a Promise. Async guards break determinism and replay. Move I/O into an effect.`,\n    );\n    this.name = \"AsyncGuardError\";\n    this.guardName = guardName;\n  }\n}\n\n/**\n * Detect declared-async guards at definition time. Catches the common case of\n * `async (args) => ...` inline guards. Combinator builders or arrow returns of\n * a Promise still slip past — those are caught at `evalGuard` runtime via\n * the `isThenable` check.\n *\n * Caveat: this relies on `Function.prototype.constructor.name === \"AsyncFunction\"`,\n * which is reliable in ES2017+ runtimes. If your bundler transpiles `async`\n * to generator-based code (e.g. ES5 / very old TypeScript targets), this\n * check returns `false` for those forms — the runtime `evalGuard` thenable\n * check still catches them.\n */\nexport function isAsyncGuardFn(fn: unknown): boolean {\n  if (typeof fn !== \"function\") return false;\n  return fn.constructor?.name === \"AsyncFunction\";\n}\n\n/**\n * Detect a thenable (PromiseLike) — anything with a callable `then`. Used in\n * place of `instanceof Promise` so cross-realm Promises (iframe / worker /\n * vm context) and user-defined thenables are also rejected.\n */\nfunction isThenable(x: unknown): x is PromiseLike<unknown> {\n  return (\n    x !== null &&\n    (typeof x === \"object\" || typeof x === \"function\") &&\n    typeof (x as { then?: unknown }).then === \"function\"\n  );\n}\n\n/**\n * Resolve a guard ref to a Guard function. String refs are looked up in the\n * implementations map; inline functions are returned as-is.\n */\nexport function resolveGuard<Ctx, Evt>(\n  ref: GuardRef<Ctx, Evt>,\n  impl: Implementations<Ctx, Evt>,\n): Guard<Ctx, Evt> {\n  if (typeof ref === \"function\") return ref;\n  const fn = impl.guards?.[ref];\n  if (!fn) throw new UnknownGuardError(ref);\n  return fn;\n}\n\n/**\n * Evaluate a guard ref against (context, event). Guards must be sync and pure;\n * TypeScript blocks declared-async signatures at compile time, but JS callers\n * or casts can still slip through. This function checks two ways:\n *   1. Inline AsyncFunction (declared `async`) → throw AsyncGuardError.\n *   2. Return value is a Promise → throw AsyncGuardError.\n * Both throws are user errors; they would otherwise silently pass the guard\n * (Promise is truthy) and break determinism.\n *\n * The optional `value` argument is the current state value, threaded so the\n * `stateIn` combinator and similar predicates can introspect it.\n */\nexport function evalGuard<Ctx, Evt>(\n  ref: GuardRef<Ctx, Evt>,\n  context: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  value?: string,\n): boolean {\n  const fn = resolveGuard(ref, impl);\n  // Function.prototype.name is \"\" for anonymous arrows — use `||` not `??`\n  // so the empty string falls back to \"<inline>\" for readable error messages.\n  const guardName = typeof ref === \"string\" ? ref : fn.name || \"<inline>\";\n  if (isAsyncGuardFn(fn)) {\n    throw new AsyncGuardError(guardName);\n  }\n  // Build args while honouring exactOptionalPropertyTypes: omit fields that\n  // would otherwise be assigned `undefined`.\n  type Args = {\n    context: Ctx;\n    event: Evt;\n    guards?: Readonly<Record<string, Guard<Ctx, Evt>>>;\n    value?: string;\n  };\n  const args: Args = { context, event };\n  const guardsMap = impl.guards;\n  if (guardsMap) args.guards = guardsMap;\n  if (value !== undefined) args.value = value;\n  const result = fn(args);\n  // TS narrows `result` to boolean from Guard's return type, but a JS caller\n  // or a cast can slip a Promise / PromiseLike through. We accept anything\n  // thenable (native Promise, cross-realm Promise, user-defined thenable),\n  // not just same-realm `instanceof Promise`.\n  if (isThenable(result)) {\n    throw new AsyncGuardError(guardName);\n  }\n  return result;\n}\n","import { UnknownGuardError } from \"../fsm/evaluator.js\";\nimport type { Guard, GuardArgs, GuardRef } from \"../fsm/types.js\";\n\nfunction resolveItem<Ctx, Evt>(item: GuardRef<Ctx, Evt>, args: GuardArgs<Ctx, Evt>): boolean {\n  if (typeof item === \"function\") return item(args);\n  const fn = args.guards?.[item];\n  if (!fn) throw new UnknownGuardError(item);\n  return fn(args);\n}\n\n/** Logical AND over guards. Short-circuits on the first `false`. */\nexport function and<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (!resolveItem(item, args)) return false;\n    }\n    return true;\n  };\n}\n\n/** Logical OR over guards. Short-circuits on the first `true`. */\nexport function or<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (resolveItem(item, args)) return true;\n    }\n    return false;\n  };\n}\n\n/** Logical NOT. */\nexport function not<Ctx, Evt>(item: GuardRef<Ctx, Evt>): Guard<Ctx, Evt> {\n  return (args) => !resolveItem(item, args);\n}\n\n/**\n * Predicate that passes when the current state value is one of the listed\n * states. Reads `args.value`, which `evalGuard` threads from the live\n * snapshot. When called outside of `evalGuard` (e.g. unit tests), `value` is\n * `undefined` and the guard returns `false`.\n */\nexport function stateIn<Ctx, Evt>(...states: readonly string[]): Guard<Ctx, Evt> {\n  const set = new Set<string>(states);\n  return ({ value }) => typeof value === \"string\" && set.has(value);\n}\n"]}
+{"version":3,"sources":["../../src/guards/index.ts"],"names":["UnknownGuardError","isThenable","AsyncGuardError"],"mappings":";;;;;;AAGA,SAAS,WAAA,CAAsB,MAA0B,IAAA,EAAoC;AAC3F,EAAA,MAAM,KAAK,OAAO,IAAA,KAAS,aAAa,IAAA,GAAO,IAAA,CAAK,SAAS,IAAI,CAAA;AACjE,EAAA,IAAI,CAAC,EAAA,EAAI,MAAM,IAAIA,oCAAkB,IAAc,CAAA;AACnD,EAAA,MAAM,MAAA,GAAS,GAAG,IAAI,CAAA;AAItB,EAAA,IAAIC,4BAAA,CAAW,MAAM,CAAA,EAAG;AAGtB,IAAA,MAAM,IAAIC,kCAAgB,OAAO,IAAA,KAAS,WAAW,IAAA,GAAO,EAAA,CAAG,QAAQ,UAAU,CAAA;AAAA,EACnF;AACA,EAAA,OAAO,MAAA;AACT;AAGO,SAAS,IAAc,KAAA,EAAuD;AACnF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,CAAC,WAAA,CAAY,IAAA,EAAM,IAAI,GAAG,OAAO,KAAA;AAAA,IACvC;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,GAAa,KAAA,EAAuD;AAClF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,WAAA,CAAY,IAAA,EAAM,IAAI,CAAA,EAAG,OAAO,IAAA;AAAA,IACtC;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,IAAc,IAAA,EAA2C;AACvE,EAAA,OAAO,CAAC,IAAA,KAAS,CAAC,WAAA,CAAY,MAAM,IAAI,CAAA;AAC1C;AAQO,SAAS,WAAqB,MAAA,EAA4C;AAC/E,EAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAY,MAAM,CAAA;AAClC,EAAA,OAAO,CAAC,EAAE,KAAA,EAAM,KAAM,OAAO,KAAA,KAAU,QAAA,IAAY,GAAA,CAAI,GAAA,CAAI,KAAK,CAAA;AAClE","file":"index.cjs","sourcesContent":["import { AsyncGuardError, UnknownGuardError, isThenable } from \"../fsm/evaluator.js\";\nimport type { Guard, GuardArgs, GuardRef } from \"../fsm/types.js\";\n\nfunction resolveItem<Ctx, Evt>(item: GuardRef<Ctx, Evt>, args: GuardArgs<Ctx, Evt>): boolean {\n  const fn = typeof item === \"function\" ? item : args.guards?.[item];\n  if (!fn) throw new UnknownGuardError(item as string);\n  const result = fn(args);\n  // Mirror evalGuard's safety net: a guard that returns a thenable breaks\n  // determinism. Checked here too so a thenable nested inside and/or/not is\n  // rejected rather than coerced truthy by the combinator (FSM-S-01).\n  if (isThenable(result)) {\n    // Function.prototype.name is \"\" for anonymous arrows — fall back to\n    // \"<inline>\" so the message stays readable (matches evalGuard).\n    throw new AsyncGuardError(typeof item === \"string\" ? item : fn.name || \"<inline>\");\n  }\n  return result;\n}\n\n/** Logical AND over guards. Short-circuits on the first `false`. */\nexport function and<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (!resolveItem(item, args)) return false;\n    }\n    return true;\n  };\n}\n\n/** Logical OR over guards. Short-circuits on the first `true`. */\nexport function or<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (resolveItem(item, args)) return true;\n    }\n    return false;\n  };\n}\n\n/** Logical NOT. */\nexport function not<Ctx, Evt>(item: GuardRef<Ctx, Evt>): Guard<Ctx, Evt> {\n  return (args) => !resolveItem(item, args);\n}\n\n/**\n * Predicate that passes when the current state value is one of the listed\n * states. Reads `args.value`, which `evalGuard` threads from the live\n * snapshot. When called outside of `evalGuard` (e.g. unit tests), `value` is\n * `undefined` and the guard returns `false`.\n */\nexport function stateIn<Ctx, Evt>(...states: readonly string[]): Guard<Ctx, Evt> {\n  const set = new Set<string>(states);\n  return ({ value }) => typeof value === \"string\" && set.has(value);\n}\n"]}

package/dist/guards/index.js

@@ -1,19 +1,15 @@
-// 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;
-  }
-};
+import { UnknownGuardError, isThenable, AsyncGuardError } from '../chunk-A7U7QQL5.js';
+import '../chunk-PZ5AY32C.js';
 
 // src/guards/index.ts
 function resolveItem(item, args) {
-  if (typeof item === "function") return item(args);
-  const fn = args.guards?.[item];
+  const fn = typeof item === "function" ? item : args.guards?.[item];
   if (!fn) throw new UnknownGuardError(item);
-  return fn(args);
+  const result = fn(args);
+  if (isThenable(result)) {
+    throw new AsyncGuardError(typeof item === "string" ? item : fn.name || "<inline>");
+  }
+  return result;
 }
 function and(items) {
   return (args) => {

package/dist/guards/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fsm/evaluator.ts","../../src/guards/index.ts"],"names":[],"mappings":";AAEO,IAAM,iBAAA,GAAN,cAAgC,KAAA,CAAM;AAAA,EAClC,SAAA;AAAA,EACT,YAAY,SAAA,EAAmB;AAC7B,IAAA,KAAA,CAAM,CAAA,gBAAA,EAAmB,SAAS,CAAA,qCAAA,CAAuC,CAAA;AACzE,IAAA,IAAA,CAAK,IAAA,GAAO,mBAAA;AACZ,IAAA,IAAA,CAAK,SAAA,GAAY,SAAA;AAAA,EACnB;AACF,CAAA;;;ACNA,SAAS,WAAA,CAAsB,MAA0B,IAAA,EAAoC;AAC3F,EAAA,IAAI,OAAO,IAAA,KAAS,UAAA,EAAY,OAAO,KAAK,IAAI,CAAA;AAChD,EAAA,MAAM,EAAA,GAAK,IAAA,CAAK,MAAA,GAAS,IAAI,CAAA;AAC7B,EAAA,IAAI,CAAC,EAAA,EAAI,MAAM,IAAI,kBAAkB,IAAI,CAAA;AACzC,EAAA,OAAO,GAAG,IAAI,CAAA;AAChB;AAGO,SAAS,IAAc,KAAA,EAAuD;AACnF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,CAAC,WAAA,CAAY,IAAA,EAAM,IAAI,GAAG,OAAO,KAAA;AAAA,IACvC;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,GAAa,KAAA,EAAuD;AAClF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,WAAA,CAAY,IAAA,EAAM,IAAI,CAAA,EAAG,OAAO,IAAA;AAAA,IACtC;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,IAAc,IAAA,EAA2C;AACvE,EAAA,OAAO,CAAC,IAAA,KAAS,CAAC,WAAA,CAAY,MAAM,IAAI,CAAA;AAC1C;AAQO,SAAS,WAAqB,MAAA,EAA4C;AAC/E,EAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAY,MAAM,CAAA;AAClC,EAAA,OAAO,CAAC,EAAE,KAAA,EAAM,KAAM,OAAO,KAAA,KAAU,QAAA,IAAY,GAAA,CAAI,GAAA,CAAI,KAAK,CAAA;AAClE","file":"index.js","sourcesContent":["import type { Guard, GuardRef, Implementations } from \"./types.js\";\n\nexport class UnknownGuardError extends Error {\n  readonly guardName: string;\n  constructor(guardName: string) {\n    super(`aifsmjs: guard \"${guardName}\" not found in implementations.guards`);\n    this.name = \"UnknownGuardError\";\n    this.guardName = guardName;\n  }\n}\n\nexport class AsyncGuardError extends Error {\n  readonly guardName: string;\n  constructor(guardName: string) {\n    super(\n      `aifsmjs: guard \"${guardName}\" must be sync; received a Promise. Async guards break determinism and replay. Move I/O into an effect.`,\n    );\n    this.name = \"AsyncGuardError\";\n    this.guardName = guardName;\n  }\n}\n\n/**\n * Detect declared-async guards at definition time. Catches the common case of\n * `async (args) => ...` inline guards. Combinator builders or arrow returns of\n * a Promise still slip past — those are caught at `evalGuard` runtime via\n * the `isThenable` check.\n *\n * Caveat: this relies on `Function.prototype.constructor.name === \"AsyncFunction\"`,\n * which is reliable in ES2017+ runtimes. If your bundler transpiles `async`\n * to generator-based code (e.g. ES5 / very old TypeScript targets), this\n * check returns `false` for those forms — the runtime `evalGuard` thenable\n * check still catches them.\n */\nexport function isAsyncGuardFn(fn: unknown): boolean {\n  if (typeof fn !== \"function\") return false;\n  return fn.constructor?.name === \"AsyncFunction\";\n}\n\n/**\n * Detect a thenable (PromiseLike) — anything with a callable `then`. Used in\n * place of `instanceof Promise` so cross-realm Promises (iframe / worker /\n * vm context) and user-defined thenables are also rejected.\n */\nfunction isThenable(x: unknown): x is PromiseLike<unknown> {\n  return (\n    x !== null &&\n    (typeof x === \"object\" || typeof x === \"function\") &&\n    typeof (x as { then?: unknown }).then === \"function\"\n  );\n}\n\n/**\n * Resolve a guard ref to a Guard function. String refs are looked up in the\n * implementations map; inline functions are returned as-is.\n */\nexport function resolveGuard<Ctx, Evt>(\n  ref: GuardRef<Ctx, Evt>,\n  impl: Implementations<Ctx, Evt>,\n): Guard<Ctx, Evt> {\n  if (typeof ref === \"function\") return ref;\n  const fn = impl.guards?.[ref];\n  if (!fn) throw new UnknownGuardError(ref);\n  return fn;\n}\n\n/**\n * Evaluate a guard ref against (context, event). Guards must be sync and pure;\n * TypeScript blocks declared-async signatures at compile time, but JS callers\n * or casts can still slip through. This function checks two ways:\n *   1. Inline AsyncFunction (declared `async`) → throw AsyncGuardError.\n *   2. Return value is a Promise → throw AsyncGuardError.\n * Both throws are user errors; they would otherwise silently pass the guard\n * (Promise is truthy) and break determinism.\n *\n * The optional `value` argument is the current state value, threaded so the\n * `stateIn` combinator and similar predicates can introspect it.\n */\nexport function evalGuard<Ctx, Evt>(\n  ref: GuardRef<Ctx, Evt>,\n  context: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  value?: string,\n): boolean {\n  const fn = resolveGuard(ref, impl);\n  // Function.prototype.name is \"\" for anonymous arrows — use `||` not `??`\n  // so the empty string falls back to \"<inline>\" for readable error messages.\n  const guardName = typeof ref === \"string\" ? ref : fn.name || \"<inline>\";\n  if (isAsyncGuardFn(fn)) {\n    throw new AsyncGuardError(guardName);\n  }\n  // Build args while honouring exactOptionalPropertyTypes: omit fields that\n  // would otherwise be assigned `undefined`.\n  type Args = {\n    context: Ctx;\n    event: Evt;\n    guards?: Readonly<Record<string, Guard<Ctx, Evt>>>;\n    value?: string;\n  };\n  const args: Args = { context, event };\n  const guardsMap = impl.guards;\n  if (guardsMap) args.guards = guardsMap;\n  if (value !== undefined) args.value = value;\n  const result = fn(args);\n  // TS narrows `result` to boolean from Guard's return type, but a JS caller\n  // or a cast can slip a Promise / PromiseLike through. We accept anything\n  // thenable (native Promise, cross-realm Promise, user-defined thenable),\n  // not just same-realm `instanceof Promise`.\n  if (isThenable(result)) {\n    throw new AsyncGuardError(guardName);\n  }\n  return result;\n}\n","import { UnknownGuardError } from \"../fsm/evaluator.js\";\nimport type { Guard, GuardArgs, GuardRef } from \"../fsm/types.js\";\n\nfunction resolveItem<Ctx, Evt>(item: GuardRef<Ctx, Evt>, args: GuardArgs<Ctx, Evt>): boolean {\n  if (typeof item === \"function\") return item(args);\n  const fn = args.guards?.[item];\n  if (!fn) throw new UnknownGuardError(item);\n  return fn(args);\n}\n\n/** Logical AND over guards. Short-circuits on the first `false`. */\nexport function and<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (!resolveItem(item, args)) return false;\n    }\n    return true;\n  };\n}\n\n/** Logical OR over guards. Short-circuits on the first `true`. */\nexport function or<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (resolveItem(item, args)) return true;\n    }\n    return false;\n  };\n}\n\n/** Logical NOT. */\nexport function not<Ctx, Evt>(item: GuardRef<Ctx, Evt>): Guard<Ctx, Evt> {\n  return (args) => !resolveItem(item, args);\n}\n\n/**\n * Predicate that passes when the current state value is one of the listed\n * states. Reads `args.value`, which `evalGuard` threads from the live\n * snapshot. When called outside of `evalGuard` (e.g. unit tests), `value` is\n * `undefined` and the guard returns `false`.\n */\nexport function stateIn<Ctx, Evt>(...states: readonly string[]): Guard<Ctx, Evt> {\n  const set = new Set<string>(states);\n  return ({ value }) => typeof value === \"string\" && set.has(value);\n}\n"]}
+{"version":3,"sources":["../../src/guards/index.ts"],"names":[],"mappings":";;;;AAGA,SAAS,WAAA,CAAsB,MAA0B,IAAA,EAAoC;AAC3F,EAAA,MAAM,KAAK,OAAO,IAAA,KAAS,aAAa,IAAA,GAAO,IAAA,CAAK,SAAS,IAAI,CAAA;AACjE,EAAA,IAAI,CAAC,EAAA,EAAI,MAAM,IAAI,kBAAkB,IAAc,CAAA;AACnD,EAAA,MAAM,MAAA,GAAS,GAAG,IAAI,CAAA;AAItB,EAAA,IAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAGtB,IAAA,MAAM,IAAI,gBAAgB,OAAO,IAAA,KAAS,WAAW,IAAA,GAAO,EAAA,CAAG,QAAQ,UAAU,CAAA;AAAA,EACnF;AACA,EAAA,OAAO,MAAA;AACT;AAGO,SAAS,IAAc,KAAA,EAAuD;AACnF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,CAAC,WAAA,CAAY,IAAA,EAAM,IAAI,GAAG,OAAO,KAAA;AAAA,IACvC;AACA,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,GAAa,KAAA,EAAuD;AAClF,EAAA,OAAO,CAAC,IAAA,KAAS;AACf,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,WAAA,CAAY,IAAA,EAAM,IAAI,CAAA,EAAG,OAAO,IAAA;AAAA,IACtC;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAA;AACF;AAGO,SAAS,IAAc,IAAA,EAA2C;AACvE,EAAA,OAAO,CAAC,IAAA,KAAS,CAAC,WAAA,CAAY,MAAM,IAAI,CAAA;AAC1C;AAQO,SAAS,WAAqB,MAAA,EAA4C;AAC/E,EAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAY,MAAM,CAAA;AAClC,EAAA,OAAO,CAAC,EAAE,KAAA,EAAM,KAAM,OAAO,KAAA,KAAU,QAAA,IAAY,GAAA,CAAI,GAAA,CAAI,KAAK,CAAA;AAClE","file":"index.js","sourcesContent":["import { AsyncGuardError, UnknownGuardError, isThenable } from \"../fsm/evaluator.js\";\nimport type { Guard, GuardArgs, GuardRef } from \"../fsm/types.js\";\n\nfunction resolveItem<Ctx, Evt>(item: GuardRef<Ctx, Evt>, args: GuardArgs<Ctx, Evt>): boolean {\n  const fn = typeof item === \"function\" ? item : args.guards?.[item];\n  if (!fn) throw new UnknownGuardError(item as string);\n  const result = fn(args);\n  // Mirror evalGuard's safety net: a guard that returns a thenable breaks\n  // determinism. Checked here too so a thenable nested inside and/or/not is\n  // rejected rather than coerced truthy by the combinator (FSM-S-01).\n  if (isThenable(result)) {\n    // Function.prototype.name is \"\" for anonymous arrows — fall back to\n    // \"<inline>\" so the message stays readable (matches evalGuard).\n    throw new AsyncGuardError(typeof item === \"string\" ? item : fn.name || \"<inline>\");\n  }\n  return result;\n}\n\n/** Logical AND over guards. Short-circuits on the first `false`. */\nexport function and<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (!resolveItem(item, args)) return false;\n    }\n    return true;\n  };\n}\n\n/** Logical OR over guards. Short-circuits on the first `true`. */\nexport function or<Ctx, Evt>(items: readonly GuardRef<Ctx, Evt>[]): Guard<Ctx, Evt> {\n  return (args) => {\n    for (const item of items) {\n      if (resolveItem(item, args)) return true;\n    }\n    return false;\n  };\n}\n\n/** Logical NOT. */\nexport function not<Ctx, Evt>(item: GuardRef<Ctx, Evt>): Guard<Ctx, Evt> {\n  return (args) => !resolveItem(item, args);\n}\n\n/**\n * Predicate that passes when the current state value is one of the listed\n * states. Reads `args.value`, which `evalGuard` threads from the live\n * snapshot. When called outside of `evalGuard` (e.g. unit tests), `value` is\n * `undefined` and the guard returns `false`.\n */\nexport function stateIn<Ctx, Evt>(...states: readonly string[]): Guard<Ctx, Evt> {\n  const set = new Set<string>(states);\n  return ({ value }) => typeof value === \"string\" && set.has(value);\n}\n"]}