aifsmjs 0.5.3 → 0.5.6

package/dist/replay/index.js

@@ -1,200 +1,7 @@
-// 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/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 };
+export { replay } from '../chunk-NEJYZAKR.js';
+import '../chunk-ZLQ7HZCE.js';
+import '../chunk-JKZAOPQC.js';
+import '../chunk-A7U7QQL5.js';
+import '../chunk-PZ5AY32C.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/replay/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/effects/enqueuer.ts","../../src/fsm/evaluator.ts","../../src/fsm/resolver.ts","../../src/fsm/snapshot.ts","../../src/fsm/updater.ts","../../src/fsm/lifecycle.ts","../../src/replay/index.ts"],"names":[],"mappings":"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","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 { 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 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","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"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/timer/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+require('../chunk-Q7SFCCGT.cjs');
+
 // src/timer/scheduler.ts
 var NOOP = Object.freeze({ cancel: () => {
 } });
@@ -37,20 +39,39 @@ function createScheduler(defaults) {
   const sched = {
     after(ms, fn, opts) {
       const merged = { ...defaults, ...opts };
+      const { signal, ...innerOpts } = merged;
+      if (signal?.aborted) return NOOP;
       const slot = {};
-      const wrapped = () => {
+      let fired = false;
+      let settled = false;
+      const detachAbort = () => {
+        if (signal) signal.removeEventListener("abort", onAbort);
+      };
+      const settle = () => {
+        if (settled) return;
+        settled = true;
         if (slot.ref) pending.delete(slot.ref);
+        detachAbort();
+      };
+      const wrapped = () => {
+        fired = true;
+        settle();
         fn();
       };
-      const inner = after(ms, wrapped, merged);
-      const handle = Object.freeze({
-        cancel() {
-          inner.cancel();
-          if (slot.ref) pending.delete(slot.ref);
-        }
-      });
+      const cancel = () => {
+        inner.cancel();
+        settle();
+      };
+      function onAbort() {
+        cancel();
+      }
+      const inner = after(ms, wrapped, innerOpts);
+      const handle = Object.freeze({ cancel });
       slot.ref = handle;
-      pending.add(handle);
+      if (!fired) {
+        pending.add(handle);
+        if (signal) signal.addEventListener("abort", onAbort, { once: true });
+      }
       return handle;
     },
     cancelAll() {

package/dist/timer/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/timer/scheduler.ts"],"names":[],"mappings":"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","file":"index.cjs","sourcesContent":["export type AfterHandle = Readonly<{\n  cancel(): void;\n}>;\n\nexport type SetTimeoutFn = (fn: () => void, ms: number) => unknown;\nexport type ClearTimeoutFn = (handle: unknown) => void;\n\nexport type AfterOptions = Readonly<{\n  /**\n   * If supplied and aborted, the callback never runs and any pending timer is\n   * cleared. Aborting after fire is a no-op.\n   */\n  signal?: AbortSignal;\n  /**\n   * Override `setTimeout` (testing, SSR, custom loops). Defaults to globalThis.\n   */\n  setTimeout?: SetTimeoutFn;\n  /**\n   * Override `clearTimeout`. Must match the `setTimeout` you injected.\n   */\n  clearTimeout?: ClearTimeoutFn;\n}>;\n\nconst NOOP: AfterHandle = Object.freeze({ cancel: () => {} });\n\nfunction resolveTimers(opts: AfterOptions | undefined): {\n  st: SetTimeoutFn;\n  ct: ClearTimeoutFn;\n} {\n  return {\n    st: opts?.setTimeout ?? ((fn, ms) => globalThis.setTimeout(fn, ms)),\n    ct: opts?.clearTimeout ?? ((h) => globalThis.clearTimeout(h as number)),\n  };\n}\n\n/**\n * Schedule `fn` to run after `ms` milliseconds. Returns a handle whose\n * `cancel()` clears the pending timer. Optional `signal` aborts the timer when\n * triggered. Aborting after the callback fires is a no-op.\n *\n * The abort listener is registered with `{ once: true }` as a baseline, but\n * `{ once: true }` alone does NOT prevent listener accumulation when the same\n * signal is reused across many timers: it only removes the listener when the\n * signal aborts, not when the timer fires normally or `cancel()` is called.\n * We therefore explicitly call `signal.removeEventListener(\"abort\", cancel)`\n * inside the fire callback and at the end of `cancel()` so that a shared,\n * long-lived signal never accumulates dead listeners across timer reuse.\n */\nexport function after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle {\n  if (opts?.signal?.aborted) return NOOP;\n\n  const { st, ct } = resolveTimers(opts);\n  let fired = false;\n  let cancelled = false;\n  // `cancel` and the timer handle reference each other. A const cell holds the\n  // handle so `cancel` can be defined BEFORE `st(...)` runs (letting a custom\n  // `st` that fires its callback synchronously reference `cancel` without\n  // hitting the temporal-dead-zone) while still being able to clear the handle\n  // assigned afterwards. A synchronous fire sets `fired=true`, so cancel() never\n  // reads the still-unset handle in that path.\n  const timer: { handle?: ReturnType<typeof st> } = {};\n\n  const cancel = () => {\n    if (fired || cancelled) return;\n    cancelled = true;\n    if (timer.handle !== undefined) ct(timer.handle);\n    // Detach the abort listener so a reused signal does not accumulate dead\n    // closures after this timer is cancelled.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n  };\n\n  timer.handle = st(() => {\n    fired = true;\n    /* v8 ignore next — defensive race guard: cancel() sets cancelled=true and clears the timer, but if a custom setTimeout fires after clear, this short-circuits fn(). */\n    if (cancelled) return;\n    // Detach the abort listener now that the timer has fired — the listener\n    // will never be invoked and must not accumulate on a reused signal.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n    fn();\n  }, ms);\n\n  // Attach only if the timer has not already fired synchronously (a custom `st`\n  // may fire inline); otherwise the listener would be registered AFTER the fire\n  // path's removal ran and would then leak until the signal aborts.\n  if (opts?.signal && !fired) {\n    opts.signal.addEventListener(\"abort\", cancel, { once: true });\n  }\n\n  return Object.freeze({ cancel });\n}\n\nexport type Scheduler = Readonly<{\n  after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle;\n  cancelAll(): void;\n  readonly size: number;\n}>;\n\n/**\n * Build a scheduler that tracks every pending `after()` so they can be\n * cancelled together (e.g. on machine destroy). Each `after` returns a handle\n * whose `cancel()` also removes it from the tracking set.\n *\n * `defaults` are merged into every call — typically you inject `setTimeout` /\n * `clearTimeout` once at construction.\n */\nexport function createScheduler(defaults?: AfterOptions): Scheduler {\n  const pending = new Set<AfterHandle>();\n\n  const sched: Scheduler = {\n    after(ms, fn, opts) {\n      const merged: AfterOptions = { ...defaults, ...opts };\n      // Forward-reference slot so `wrapped` can find the tracked handle\n      // before it is constructed below.\n      const slot: { ref?: AfterHandle } = {};\n      const wrapped = () => {\n        if (slot.ref) pending.delete(slot.ref);\n        fn();\n      };\n      const inner = after(ms, wrapped, merged);\n      const handle: AfterHandle = Object.freeze({\n        cancel() {\n          inner.cancel();\n          if (slot.ref) pending.delete(slot.ref);\n        },\n      });\n      slot.ref = handle;\n      pending.add(handle);\n      return handle;\n    },\n    cancelAll() {\n      for (const h of pending) h.cancel();\n      pending.clear();\n    },\n    get size() {\n      return pending.size;\n    },\n  };\n  return sched;\n}\n"]}
+{"version":3,"sources":["../../src/timer/scheduler.ts"],"names":[],"mappings":"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","file":"index.cjs","sourcesContent":["export type AfterHandle = Readonly<{\n  cancel(): void;\n}>;\n\nexport type SetTimeoutFn = (fn: () => void, ms: number) => unknown;\nexport type ClearTimeoutFn = (handle: unknown) => void;\n\nexport type AfterOptions = Readonly<{\n  /**\n   * If supplied and aborted, the callback never runs and any pending timer is\n   * cleared. Aborting after fire is a no-op.\n   */\n  signal?: AbortSignal;\n  /**\n   * Override `setTimeout` (testing, SSR, custom loops). Defaults to globalThis.\n   */\n  setTimeout?: SetTimeoutFn;\n  /**\n   * Override `clearTimeout`. Must match the `setTimeout` you injected.\n   */\n  clearTimeout?: ClearTimeoutFn;\n}>;\n\nconst NOOP: AfterHandle = Object.freeze({ cancel: () => {} });\n\nfunction resolveTimers(opts: AfterOptions | undefined): {\n  st: SetTimeoutFn;\n  ct: ClearTimeoutFn;\n} {\n  return {\n    st: opts?.setTimeout ?? ((fn, ms) => globalThis.setTimeout(fn, ms)),\n    ct: opts?.clearTimeout ?? ((h) => globalThis.clearTimeout(h as number)),\n  };\n}\n\n/**\n * Schedule `fn` to run after `ms` milliseconds. Returns a handle whose\n * `cancel()` clears the pending timer. Optional `signal` aborts the timer when\n * triggered. Aborting after the callback fires is a no-op.\n *\n * The abort listener is registered with `{ once: true }` as a baseline, but\n * `{ once: true }` alone does NOT prevent listener accumulation when the same\n * signal is reused across many timers: it only removes the listener when the\n * signal aborts, not when the timer fires normally or `cancel()` is called.\n * We therefore explicitly call `signal.removeEventListener(\"abort\", cancel)`\n * inside the fire callback and at the end of `cancel()` so that a shared,\n * long-lived signal never accumulates dead listeners across timer reuse.\n */\nexport function after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle {\n  if (opts?.signal?.aborted) return NOOP;\n\n  const { st, ct } = resolveTimers(opts);\n  let fired = false;\n  let cancelled = false;\n  // `cancel` and the timer handle reference each other. A const cell holds the\n  // handle so `cancel` can be defined BEFORE `st(...)` runs (letting a custom\n  // `st` that fires its callback synchronously reference `cancel` without\n  // hitting the temporal-dead-zone) while still being able to clear the handle\n  // assigned afterwards. A synchronous fire sets `fired=true`, so cancel() never\n  // reads the still-unset handle in that path.\n  const timer: { handle?: ReturnType<typeof st> } = {};\n\n  const cancel = () => {\n    if (fired || cancelled) return;\n    cancelled = true;\n    if (timer.handle !== undefined) ct(timer.handle);\n    // Detach the abort listener so a reused signal does not accumulate dead\n    // closures after this timer is cancelled.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n  };\n\n  timer.handle = st(() => {\n    fired = true;\n    /* v8 ignore next — defensive race guard: cancel() sets cancelled=true and clears the timer, but if a custom setTimeout fires after clear, this short-circuits fn(). */\n    if (cancelled) return;\n    // Detach the abort listener now that the timer has fired — the listener\n    // will never be invoked and must not accumulate on a reused signal.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n    fn();\n  }, ms);\n\n  // Attach only if the timer has not already fired synchronously (a custom `st`\n  // may fire inline); otherwise the listener would be registered AFTER the fire\n  // path's removal ran and would then leak until the signal aborts.\n  if (opts?.signal && !fired) {\n    opts.signal.addEventListener(\"abort\", cancel, { once: true });\n  }\n\n  return Object.freeze({ cancel });\n}\n\nexport type Scheduler = Readonly<{\n  after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle;\n  cancelAll(): void;\n  readonly size: number;\n}>;\n\n/**\n * Build a scheduler that tracks every pending `after()` so they can be\n * cancelled together (e.g. on machine destroy). Each `after` returns a handle\n * whose `cancel()` also removes it from the tracking set.\n *\n * `defaults` are merged into every call — typically you inject `setTimeout` /\n * `clearTimeout` once at construction.\n */\nexport function createScheduler(defaults?: AfterOptions): Scheduler {\n  const pending = new Set<AfterHandle>();\n\n  const sched: Scheduler = {\n    after(ms, fn, opts) {\n      const merged: AfterOptions = { ...defaults, ...opts };\n      // Signal handling is lifted to the scheduler layer: we own one abort\n      // listener per timer and route it through the scheduler-level cancel so\n      // the abort path also removes the handle from `pending`. The inner\n      // after() therefore must NOT see the signal — otherwise it would clear\n      // its timer on abort without ever touching `pending`, leaking the entry\n      // (FSM-R-01, path a).\n      const { signal, ...innerOpts } = merged;\n\n      // Path b: scheduling on an already-aborted signal must not grow the Set.\n      // after() returns NOOP in that case; tracking it would be a permanent\n      // dead entry. Return the same NOOP without adding.\n      if (signal?.aborted) return NOOP;\n\n      // Forward-reference slot so `wrapped`/`cancel` can find the tracked\n      // handle before it is constructed below.\n      const slot: { ref?: AfterHandle } = {};\n      let fired = false;\n      let settled = false; // true once removed from pending (fire or cancel)\n\n      const detachAbort = () => {\n        if (signal) signal.removeEventListener(\"abort\", onAbort);\n      };\n\n      // Single removal path shared by fire, explicit cancel, and abort.\n      const settle = () => {\n        if (settled) return;\n        settled = true;\n        if (slot.ref) pending.delete(slot.ref);\n        detachAbort();\n      };\n\n      const wrapped = () => {\n        fired = true;\n        settle();\n        fn();\n      };\n\n      // Scheduler-level cancel: cancel the inner timer AND drop from pending\n      // AND detach the abort listener. Registered on the abort path too.\n      const cancel = () => {\n        inner.cancel();\n        settle();\n      };\n      function onAbort() {\n        cancel();\n      }\n\n      const inner = after(ms, wrapped, innerOpts);\n\n      const handle: AfterHandle = Object.freeze({ cancel });\n      slot.ref = handle;\n\n      // Path c (sync-fire): a custom setTimeout may fire `wrapped` inline,\n      // during the after() call above — before we reach here. In that case the\n      // timer is already done; adding it now would leave a permanent dead\n      // entry. Only track timers that are still live.\n      if (!fired) {\n        pending.add(handle);\n        // Attach the abort listener only for a live timer on a real signal.\n        // { once: true } removes it on abort; settle()/detachAbort() remove it\n        // on fire/cancel so a long-lived shared signal never accumulates dead\n        // listeners.\n        if (signal) signal.addEventListener(\"abort\", onAbort, { once: true });\n      }\n\n      return handle;\n    },\n    cancelAll() {\n      for (const h of pending) h.cancel();\n      pending.clear();\n    },\n    get size() {\n      return pending.size;\n    },\n  };\n  return sched;\n}\n"]}

package/dist/timer/index.js

@@ -1,3 +1,5 @@
+import '../chunk-PZ5AY32C.js';
+
 // src/timer/scheduler.ts
 var NOOP = Object.freeze({ cancel: () => {
 } });
@@ -35,20 +37,39 @@ function createScheduler(defaults) {
   const sched = {
     after(ms, fn, opts) {
       const merged = { ...defaults, ...opts };
+      const { signal, ...innerOpts } = merged;
+      if (signal?.aborted) return NOOP;
       const slot = {};
-      const wrapped = () => {
+      let fired = false;
+      let settled = false;
+      const detachAbort = () => {
+        if (signal) signal.removeEventListener("abort", onAbort);
+      };
+      const settle = () => {
+        if (settled) return;
+        settled = true;
         if (slot.ref) pending.delete(slot.ref);
+        detachAbort();
+      };
+      const wrapped = () => {
+        fired = true;
+        settle();
         fn();
       };
-      const inner = after(ms, wrapped, merged);
-      const handle = Object.freeze({
-        cancel() {
-          inner.cancel();
-          if (slot.ref) pending.delete(slot.ref);
-        }
-      });
+      const cancel = () => {
+        inner.cancel();
+        settle();
+      };
+      function onAbort() {
+        cancel();
+      }
+      const inner = after(ms, wrapped, innerOpts);
+      const handle = Object.freeze({ cancel });
       slot.ref = handle;
-      pending.add(handle);
+      if (!fired) {
+        pending.add(handle);
+        if (signal) signal.addEventListener("abort", onAbort, { once: true });
+      }
       return handle;
     },
     cancelAll() {

package/dist/timer/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/timer/scheduler.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["export type AfterHandle = Readonly<{\n  cancel(): void;\n}>;\n\nexport type SetTimeoutFn = (fn: () => void, ms: number) => unknown;\nexport type ClearTimeoutFn = (handle: unknown) => void;\n\nexport type AfterOptions = Readonly<{\n  /**\n   * If supplied and aborted, the callback never runs and any pending timer is\n   * cleared. Aborting after fire is a no-op.\n   */\n  signal?: AbortSignal;\n  /**\n   * Override `setTimeout` (testing, SSR, custom loops). Defaults to globalThis.\n   */\n  setTimeout?: SetTimeoutFn;\n  /**\n   * Override `clearTimeout`. Must match the `setTimeout` you injected.\n   */\n  clearTimeout?: ClearTimeoutFn;\n}>;\n\nconst NOOP: AfterHandle = Object.freeze({ cancel: () => {} });\n\nfunction resolveTimers(opts: AfterOptions | undefined): {\n  st: SetTimeoutFn;\n  ct: ClearTimeoutFn;\n} {\n  return {\n    st: opts?.setTimeout ?? ((fn, ms) => globalThis.setTimeout(fn, ms)),\n    ct: opts?.clearTimeout ?? ((h) => globalThis.clearTimeout(h as number)),\n  };\n}\n\n/**\n * Schedule `fn` to run after `ms` milliseconds. Returns a handle whose\n * `cancel()` clears the pending timer. Optional `signal` aborts the timer when\n * triggered. Aborting after the callback fires is a no-op.\n *\n * The abort listener is registered with `{ once: true }` as a baseline, but\n * `{ once: true }` alone does NOT prevent listener accumulation when the same\n * signal is reused across many timers: it only removes the listener when the\n * signal aborts, not when the timer fires normally or `cancel()` is called.\n * We therefore explicitly call `signal.removeEventListener(\"abort\", cancel)`\n * inside the fire callback and at the end of `cancel()` so that a shared,\n * long-lived signal never accumulates dead listeners across timer reuse.\n */\nexport function after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle {\n  if (opts?.signal?.aborted) return NOOP;\n\n  const { st, ct } = resolveTimers(opts);\n  let fired = false;\n  let cancelled = false;\n  // `cancel` and the timer handle reference each other. A const cell holds the\n  // handle so `cancel` can be defined BEFORE `st(...)` runs (letting a custom\n  // `st` that fires its callback synchronously reference `cancel` without\n  // hitting the temporal-dead-zone) while still being able to clear the handle\n  // assigned afterwards. A synchronous fire sets `fired=true`, so cancel() never\n  // reads the still-unset handle in that path.\n  const timer: { handle?: ReturnType<typeof st> } = {};\n\n  const cancel = () => {\n    if (fired || cancelled) return;\n    cancelled = true;\n    if (timer.handle !== undefined) ct(timer.handle);\n    // Detach the abort listener so a reused signal does not accumulate dead\n    // closures after this timer is cancelled.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n  };\n\n  timer.handle = st(() => {\n    fired = true;\n    /* v8 ignore next — defensive race guard: cancel() sets cancelled=true and clears the timer, but if a custom setTimeout fires after clear, this short-circuits fn(). */\n    if (cancelled) return;\n    // Detach the abort listener now that the timer has fired — the listener\n    // will never be invoked and must not accumulate on a reused signal.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n    fn();\n  }, ms);\n\n  // Attach only if the timer has not already fired synchronously (a custom `st`\n  // may fire inline); otherwise the listener would be registered AFTER the fire\n  // path's removal ran and would then leak until the signal aborts.\n  if (opts?.signal && !fired) {\n    opts.signal.addEventListener(\"abort\", cancel, { once: true });\n  }\n\n  return Object.freeze({ cancel });\n}\n\nexport type Scheduler = Readonly<{\n  after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle;\n  cancelAll(): void;\n  readonly size: number;\n}>;\n\n/**\n * Build a scheduler that tracks every pending `after()` so they can be\n * cancelled together (e.g. on machine destroy). Each `after` returns a handle\n * whose `cancel()` also removes it from the tracking set.\n *\n * `defaults` are merged into every call — typically you inject `setTimeout` /\n * `clearTimeout` once at construction.\n */\nexport function createScheduler(defaults?: AfterOptions): Scheduler {\n  const pending = new Set<AfterHandle>();\n\n  const sched: Scheduler = {\n    after(ms, fn, opts) {\n      const merged: AfterOptions = { ...defaults, ...opts };\n      // Forward-reference slot so `wrapped` can find the tracked handle\n      // before it is constructed below.\n      const slot: { ref?: AfterHandle } = {};\n      const wrapped = () => {\n        if (slot.ref) pending.delete(slot.ref);\n        fn();\n      };\n      const inner = after(ms, wrapped, merged);\n      const handle: AfterHandle = Object.freeze({\n        cancel() {\n          inner.cancel();\n          if (slot.ref) pending.delete(slot.ref);\n        },\n      });\n      slot.ref = handle;\n      pending.add(handle);\n      return handle;\n    },\n    cancelAll() {\n      for (const h of pending) h.cancel();\n      pending.clear();\n    },\n    get size() {\n      return pending.size;\n    },\n  };\n  return sched;\n}\n"]}
+{"version":3,"sources":["../../src/timer/scheduler.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["export type AfterHandle = Readonly<{\n  cancel(): void;\n}>;\n\nexport type SetTimeoutFn = (fn: () => void, ms: number) => unknown;\nexport type ClearTimeoutFn = (handle: unknown) => void;\n\nexport type AfterOptions = Readonly<{\n  /**\n   * If supplied and aborted, the callback never runs and any pending timer is\n   * cleared. Aborting after fire is a no-op.\n   */\n  signal?: AbortSignal;\n  /**\n   * Override `setTimeout` (testing, SSR, custom loops). Defaults to globalThis.\n   */\n  setTimeout?: SetTimeoutFn;\n  /**\n   * Override `clearTimeout`. Must match the `setTimeout` you injected.\n   */\n  clearTimeout?: ClearTimeoutFn;\n}>;\n\nconst NOOP: AfterHandle = Object.freeze({ cancel: () => {} });\n\nfunction resolveTimers(opts: AfterOptions | undefined): {\n  st: SetTimeoutFn;\n  ct: ClearTimeoutFn;\n} {\n  return {\n    st: opts?.setTimeout ?? ((fn, ms) => globalThis.setTimeout(fn, ms)),\n    ct: opts?.clearTimeout ?? ((h) => globalThis.clearTimeout(h as number)),\n  };\n}\n\n/**\n * Schedule `fn` to run after `ms` milliseconds. Returns a handle whose\n * `cancel()` clears the pending timer. Optional `signal` aborts the timer when\n * triggered. Aborting after the callback fires is a no-op.\n *\n * The abort listener is registered with `{ once: true }` as a baseline, but\n * `{ once: true }` alone does NOT prevent listener accumulation when the same\n * signal is reused across many timers: it only removes the listener when the\n * signal aborts, not when the timer fires normally or `cancel()` is called.\n * We therefore explicitly call `signal.removeEventListener(\"abort\", cancel)`\n * inside the fire callback and at the end of `cancel()` so that a shared,\n * long-lived signal never accumulates dead listeners across timer reuse.\n */\nexport function after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle {\n  if (opts?.signal?.aborted) return NOOP;\n\n  const { st, ct } = resolveTimers(opts);\n  let fired = false;\n  let cancelled = false;\n  // `cancel` and the timer handle reference each other. A const cell holds the\n  // handle so `cancel` can be defined BEFORE `st(...)` runs (letting a custom\n  // `st` that fires its callback synchronously reference `cancel` without\n  // hitting the temporal-dead-zone) while still being able to clear the handle\n  // assigned afterwards. A synchronous fire sets `fired=true`, so cancel() never\n  // reads the still-unset handle in that path.\n  const timer: { handle?: ReturnType<typeof st> } = {};\n\n  const cancel = () => {\n    if (fired || cancelled) return;\n    cancelled = true;\n    if (timer.handle !== undefined) ct(timer.handle);\n    // Detach the abort listener so a reused signal does not accumulate dead\n    // closures after this timer is cancelled.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n  };\n\n  timer.handle = st(() => {\n    fired = true;\n    /* v8 ignore next — defensive race guard: cancel() sets cancelled=true and clears the timer, but if a custom setTimeout fires after clear, this short-circuits fn(). */\n    if (cancelled) return;\n    // Detach the abort listener now that the timer has fired — the listener\n    // will never be invoked and must not accumulate on a reused signal.\n    if (opts?.signal) opts.signal.removeEventListener(\"abort\", cancel);\n    fn();\n  }, ms);\n\n  // Attach only if the timer has not already fired synchronously (a custom `st`\n  // may fire inline); otherwise the listener would be registered AFTER the fire\n  // path's removal ran and would then leak until the signal aborts.\n  if (opts?.signal && !fired) {\n    opts.signal.addEventListener(\"abort\", cancel, { once: true });\n  }\n\n  return Object.freeze({ cancel });\n}\n\nexport type Scheduler = Readonly<{\n  after(ms: number, fn: () => void, opts?: AfterOptions): AfterHandle;\n  cancelAll(): void;\n  readonly size: number;\n}>;\n\n/**\n * Build a scheduler that tracks every pending `after()` so they can be\n * cancelled together (e.g. on machine destroy). Each `after` returns a handle\n * whose `cancel()` also removes it from the tracking set.\n *\n * `defaults` are merged into every call — typically you inject `setTimeout` /\n * `clearTimeout` once at construction.\n */\nexport function createScheduler(defaults?: AfterOptions): Scheduler {\n  const pending = new Set<AfterHandle>();\n\n  const sched: Scheduler = {\n    after(ms, fn, opts) {\n      const merged: AfterOptions = { ...defaults, ...opts };\n      // Signal handling is lifted to the scheduler layer: we own one abort\n      // listener per timer and route it through the scheduler-level cancel so\n      // the abort path also removes the handle from `pending`. The inner\n      // after() therefore must NOT see the signal — otherwise it would clear\n      // its timer on abort without ever touching `pending`, leaking the entry\n      // (FSM-R-01, path a).\n      const { signal, ...innerOpts } = merged;\n\n      // Path b: scheduling on an already-aborted signal must not grow the Set.\n      // after() returns NOOP in that case; tracking it would be a permanent\n      // dead entry. Return the same NOOP without adding.\n      if (signal?.aborted) return NOOP;\n\n      // Forward-reference slot so `wrapped`/`cancel` can find the tracked\n      // handle before it is constructed below.\n      const slot: { ref?: AfterHandle } = {};\n      let fired = false;\n      let settled = false; // true once removed from pending (fire or cancel)\n\n      const detachAbort = () => {\n        if (signal) signal.removeEventListener(\"abort\", onAbort);\n      };\n\n      // Single removal path shared by fire, explicit cancel, and abort.\n      const settle = () => {\n        if (settled) return;\n        settled = true;\n        if (slot.ref) pending.delete(slot.ref);\n        detachAbort();\n      };\n\n      const wrapped = () => {\n        fired = true;\n        settle();\n        fn();\n      };\n\n      // Scheduler-level cancel: cancel the inner timer AND drop from pending\n      // AND detach the abort listener. Registered on the abort path too.\n      const cancel = () => {\n        inner.cancel();\n        settle();\n      };\n      function onAbort() {\n        cancel();\n      }\n\n      const inner = after(ms, wrapped, innerOpts);\n\n      const handle: AfterHandle = Object.freeze({ cancel });\n      slot.ref = handle;\n\n      // Path c (sync-fire): a custom setTimeout may fire `wrapped` inline,\n      // during the after() call above — before we reach here. In that case the\n      // timer is already done; adding it now would leave a permanent dead\n      // entry. Only track timers that are still live.\n      if (!fired) {\n        pending.add(handle);\n        // Attach the abort listener only for a live timer on a real signal.\n        // { once: true } removes it on abort; settle()/detachAbort() remove it\n        // on fire/cancel so a long-lived shared signal never accumulates dead\n        // listeners.\n        if (signal) signal.addEventListener(\"abort\", onAbort, { once: true });\n      }\n\n      return handle;\n    },\n    cancelAll() {\n      for (const h of pending) h.cancel();\n      pending.clear();\n    },\n    get size() {\n      return pending.size;\n    },\n  };\n  return sched;\n}\n"]}