@mantaq/core 0.1.0 → 0.3.0

package/README.md

@@ -10,19 +10,19 @@ npm install @mantaq/core
 
 ## Quick Reference
 
-| Pattern         | Correct                                | Anti-pattern                          |
-| --------------- | -------------------------------------- | ------------------------------------- |
-| Type context    | `context: {} as MyContext`             | casting in every handler              |
-| Write context   | `context.set({ ...context.get() })`    | mutate without `set()`                |
-| Type events     | `event("ID")<Payload>()`               | `event("ID")()` without generic       |
-| Send events     | `actor.send(signInEvent.create(data))` | raw `{ type: "ID", payload }` objects |
-| Effect data     | Use state payload                      | Depend on `event` in effect           |
-| Error handling  | Emit internal event                    | Throw in effect or transition         |
-| Internal events | Declare in `internal: [...]`           | Put user events in internal           |
-| Signal check    | `if (signal.aborted) return`           | Skip abort check in async work        |
-| Regions         | Child outputs in parent `internal`     | Forget to declare child outputs       |
-| Snapshot        | `snapshot()` carries path + context    | Re-serialize context by hand          |
-| Any handler     | Universal events only (CANCEL)         | State-specific logic in `onAny`       |
+| Pattern         | Correct                                            | Anti-pattern                          |
+| --------------- | -------------------------------------------------- | ------------------------------------- |
+| Type context    | `context: {} as MyContext`                         | casting in every handler              |
+| Write context   | `const s = context.get(); s.x = y; context.set(s)` | mutate without `set()`                |
+| Type events     | `event("ID")<Payload>()`                           | `event("ID")()` without generic       |
+| Send events     | `actor.send(signInEvent.create(data))`             | raw `{ type: "ID", payload }` objects |
+| Effect data     | Use state payload                                  | Depend on `event` in effect           |
+| Error handling  | Emit internal event                                | Throw in effect or transition         |
+| Internal events | Declare in `internal: [...]`                       | Put user events in internal           |
+| Signal check    | `if (signal.aborted) return`                       | Skip abort check in async work        |
+| Regions         | Child outputs in parent `internal`                 | Forget to declare child outputs       |
+| Snapshot        | `snapshot()` carries path + context + payload      | Re-serialize context by hand          |
+| Any handler     | Universal events only (CANCEL)                     | State-specific logic in `onAny`       |
 
 ## Contents
 
@@ -42,6 +42,7 @@ npm install @mantaq/core
   - [Any Handler](#any-handler)
   - [Testing with VirtualClock](#testing-with-virtualclock)
 - [Development](#development)
+- [Testing](#testing)
 - [License](#license)
 
 ## Quick Start
@@ -96,20 +97,24 @@ const actor = new Actor({
   setup: (m) => {
     m.on(idleState, signInEvent, (event, opts) => {
       // ✅ typed — context.get()/set() flow the constructor type
-      opts!.context.set({ ...opts!.context.get(), phoneNumber: event.payload.phoneNumber });
+      const s = opts!.context.get();
+      s.phoneNumber = event.payload.phoneNumber;
+      opts!.context.set(s);
       return { state: signingInState };
     });
   },
 });
 ```
 
-`set()` is the write signal — always call it to write, even when the new value is the same reference. Any `set()` triggers `change`. Spread the current value:
+Context is user land — mutate it freely. `set()` is the write signal: any `set()` triggers `change`, even with the same reference. Call it after you mutate:
 
 ```ts
-opts.context.set({ ...opts.context.get(), phoneNumber: event.payload.phoneNumber });
+const s = opts.context.get();
+s.phoneNumber = event.payload.phoneNumber;
+opts.context.set(s);
 ```
 
-**Never mutate in place:**
+**Never mutate without `set()`:**
 
 ```ts
 // ❌ mutation without set() — never signals; subscribers and persistence stay silent
@@ -122,7 +127,9 @@ opts!.context.phoneNumber = event.payload.phoneNumber;
 setup: (m) => {
   m.on(idleState, signInEvent, (event, opts) => {
     const c = opts!.context as AuthContext; // ❌ unnecessary — already typed
-    c.set({ ...c.get(), phoneNumber: event.payload.phoneNumber });
+    const s = c.get();
+    s.phoneNumber = event.payload.phoneNumber;
+    c.set(s);
     return { state: signingInState };
   });
 },
@@ -213,7 +220,9 @@ const actor = new Actor({
 return { state: loadingState.create({ url: event.payload.url }) };
 
 // ⚠️ context — works but shared across all states
-opts!.context.set({ ...opts!.context.get(), url: event.payload.url });
+const s = opts!.context.get();
+s.url = event.payload.url;
+opts!.context.set(s);
 return { state: loadingState };
 ```
 
@@ -303,10 +312,9 @@ function createActor() {
       m.on(idleState, startEvent, () => ({ state: workingState }));
       m.on(workingState, doneEvent, () => ({ state: doneState }));
       m.on(workingState, failedEvent, (_event, opts) => {
-        opts!.context.set({
-          ...opts!.context.get(),
-          retryCount: opts!.context.get().retryCount + 1,
-        });
+        const s = opts!.context.get();
+        s.retryCount += 1;
+        opts!.context.set(s);
         return { state: errorState };
       });
     },
@@ -337,7 +345,7 @@ m.effect(workingState, ({ signal, emit, clock }) => {
 
 ### Snapshot & Restore
 
-`actor.snapshot()` returns a `Snapshot` — `{ path, context, regions, done?, error? }`. Context is included. Use it to save/restore actor state across sessions.
+`actor.snapshot()` returns a `Snapshot` — `{ path, context, payload?, regions, done?, error? }`. Context is included; `payload` is the payload the current state was entered with (present only when the transition carried one). Use it to save/restore actor state across sessions.
 
 ```ts
 // Snapshot carries path, context, and regions — serialize it directly
@@ -425,17 +433,24 @@ const parent = new Actor({
 
 ### Error Handling
 
-Never throw from effects or transitions. Emit an error as an internal event and let a transition handle it. If user code throws anyway, the machine does **not** misbehave silently: it dies into a built-in terminal `__error` state, records `snapshot().error` (the thrown value, the last known good state/context, the bad event), drops remaining events, and ignores later `send`s. Errors never escape `send()` and the machine stays deterministic — same inputs, same trace.
+Never throw from effects or transitions. Emit an error as an internal event and let a transition handle it. If user code throws anyway, the machine does **not** misbehave silently: it dies into a built-in terminal `__error` state, records `snapshot().error` (the thrown value, the state/context at the point of failure, the bad event), drops remaining events, and ignores later `send`s. Errors never escape `send()` and the machine stays deterministic — same inputs, same trace.
 
 ```ts
 const snap = actor.snapshot();
 if (snap.error) {
-  snap.error.reason; // "transition" | "effect" | "budget" | "output" | "internal" | "async"
-  snap.error.state.name; // last known good state
+  snap.error.reason; // "transition" | "effect" | "budget" | "output" | "internal" | "async" | "unhandled"
+  snap.error.state.name; // the state at the point of failure
   snap.error.event.type; // the bad event
 }
 ```
 
+Two deliberate exceptions to "every failure is loud":
+
+- **Subscribers only watch.** They read snapshots and never change the machine, so a throwing `on("change")`/`on("done")`/`on("transition")`/`on("error")` callback is swallowed — the machine and its callers are unaffected.
+- **Unhandled external events are ignored.** An event with no handler in the current state is dropped by design (broadcast fan-out, cross-state sends). An **internal** event with no handler, however, is a machine-authoring bug and routes to the error state (`reason: "unhandled"`).
+
+A dead machine can be manually resumed with `actor.recover({ state, context })` — an explicit, **inherently dangerous** escape hatch (the caller injects state and context, so determinism no longer holds). Effects are not re-run and timers are not re-armed; processing resumes on the next event. Prefer fixing the root cause and recreating the actor.
+
 Catch errors inside effects and emit recovery events:
 
 ```ts
@@ -488,7 +503,9 @@ Prefer storing the error in context and transitioning to an error state:
 ```ts
 m.on(idleState, submitEvent, (event, opts) => {
   if (!event.payload.data) {
-    opts!.context.set({ ...opts!.context.get(), error: "missing data" });
+    const s = opts!.context.get();
+    s.error = "missing data";
+    opts!.context.set(s);
     return { state: errorState };
   }
   return { state: doneState };
@@ -503,7 +520,9 @@ Use `onAny` to intercept events across all states — useful for universal error
 setup: (m) => {
   // CANCEL works from any state
   m.onAny(cancelEvent, (_event, opts) => {
-    opts!.context.set({ ...opts!.context.get(), cancelled: true });
+    const s = opts!.context.get();
+    s.cancelled = true;
+    opts!.context.set(s);
     return { state: cancelledState };
   });
   // State-specific handlers still run for their state
@@ -517,13 +536,17 @@ setup: (m) => {
 setup: (m) => {
   // ❌ state-specific logic in onAny defeats the purpose
   m.onAny(submitBasicInfoEvent, (event, opts) => {
-    opts!.context.set({ ...opts!.context.get(), basicInfo: event }); // wrong — only makes sense in basicInfo state
+    const s = opts!.context.get();
+    s.basicInfo = event; // wrong — only makes sense in basicInfo state
+    opts!.context.set(s);
     return { state: shippingAddressState };
   });
 
   // ✅ keep state-specific logic in state handlers
   m.on(basicInfoState, submitBasicInfoEvent, (event, opts) => {
-    opts!.context.set({ ...opts!.context.get(), basicInfo: event });
+    const s = opts!.context.get();
+    s.basicInfo = event;
+    opts!.context.set(s);
     return { state: shippingAddressState };
   });
 },
@@ -662,6 +685,25 @@ vp test
 vp pack
 ```
 
+## Testing
+
+The package ships with a full test suite you can run and audit:
+
+```bash
+vp test          # feature + error + property tests
+vp check         # format, lint, typecheck (includes type-level contract tests)
+vp run mutation:core   # mutation score must stay ≥ 90
+```
+
+**Test contract.** Behavior is pinned by four kinds of tests, split by filename:
+
+- `*.test.ts` — features and happy paths, hand-maintained.
+- `*.error.test.ts` — failure paths: warnings, budgets, abort, unregistered, the `__error` state.
+- `*.property.test.ts` — property-based invariants against a reference model (fast-check, replayable via `MANTAQ_SEED`).
+- `*.mutation.test.ts` — directed tests that kill specific mutants; regenerable and thrown away between stryker runs.
+
+Coverage is analyzed per test (stryker `perTest` coverage analysis) so every mutant is attributed to the test that pins it. The mutation break threshold is 90 — a change that drops the score below 90 fails the build.
+
 ## License
 
 MIT

package/dist/index.d.mts

@@ -1,4 +1,68 @@
-import { _ as AnyStateRef, a as EffectInput, c as NonFinalStateRef, d as Clock, f as AnyEventRef, g as event, h as InternalEvent, i as EffectFn, l as TransitionResult, m as EventRef, n as Snapshot, o as ErrorInfo, p as CreatedOfEvent, r as CreatedOf, s as ErrorState, t as AnyActor, u as Context, v as StateRef, y as state } from "./actor-internal-DYAL1iYK.mjs";
+//#region src/state.d.ts
+declare function state<const T extends string>(id: T): <Payload = unknown>() => StateRef<T, Payload, false>;
+type AnyStateRef = StateRef<string, unknown, boolean>;
+interface RegionOptions {
+  initial: string;
+  states: Record<string, AnyStateRef>;
+}
+type RegionsOptions = Record<string, RegionOptions>;
+declare class StateRef<T extends string, Payload = unknown, IsFinal extends boolean = false> {
+  readonly name: T;
+  readonly isFinal: IsFinal;
+  /** @internal */ _regions: RegionsOptions | undefined;
+  constructor(name: T, isFinal: IsFinal);
+  regions(options: RegionsOptions): this;
+  final(): StateRef<T, Payload, true>;
+  create(payload: Payload): {
+    state: StateRef<T, Payload, IsFinal>;
+    payload: Payload;
+  };
+}
+//#endregion
+//#region src/event.d.ts
+declare function event<const T extends string>(type: T): <Payload extends object | void = void>() => EventRef<T, Payload>;
+type AnyEventRef = EventRef<string, object | void>;
+type InternalEvent = {
+  type: string;
+  payload?: unknown;
+};
+type CreatedOfEvent<T extends string, P> = P extends void ? {
+  type: T;
+} : {
+  type: T;
+  payload: P;
+};
+declare class EventRef<const T extends string, Payload extends object | void = void> {
+  readonly type: T;
+  constructor(type: T);
+  is(anyEvent: unknown): anyEvent is CreatedOfEvent<T, Payload>;
+  create(): Payload extends void ? {
+    type: T;
+  } : void;
+  create(payload: Payload): Payload extends void ? {
+    type: T;
+  } : {
+    type: T;
+    payload: Payload;
+  };
+}
+//#endregion
+//#region src/clock.d.ts
+interface Clock {
+  setTimeout(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+    eventName?: string;
+  }): number;
+  clearTimeout(id: number): void;
+  setInterval(ms: number, cb: () => void, options?: {
+    signal?: AbortSignal;
+  }): number;
+  clearInterval(id: number): void;
+  now(): number;
+  /** Optional hook for draining queues after clock advances (VirtualClock). */
+  setDrain?(fn: () => void): void;
+}
+//#endregion
 //#region src/real-clock.d.ts
 declare class RealClock implements Clock {
   #private;
@@ -38,6 +102,96 @@ declare class VirtualClock implements Clock {
   setDrain(fn: () => void): void;
 }
 //#endregion
+//#region src/context.d.ts
+declare class Context<T> {
+  #private;
+  constructor(get: () => T, set: (value: T) => void);
+  get(): T;
+  set(value: T): void;
+}
+//#endregion
+//#region src/actor-types.d.ts
+type CreatedOf<E extends AnyEventRef> = E extends EventRef<infer Type, infer P> ? CreatedOfEvent<Type, P> : never;
+type NonFinalStateRef<States extends AnyStateRef[]> = Extract<States[number], {
+  isFinal: false;
+}>;
+interface EffectInput<ActorContext, Payload = unknown> {
+  signal: AbortSignal;
+  state: {
+    name: string;
+    payload: Payload;
+  };
+  event: InternalEvent;
+  context: Context<ActorContext>;
+  emit: (event: InternalEvent) => void;
+  clock: Clock;
+}
+type EffectFn<ActorContext, Payload = unknown> = (input: EffectInput<ActorContext, Payload>) => void | Promise<void>;
+type ErrorReason = "transition" | "effect" | "budget" | "output" | "internal" | "async" | "unhandled";
+interface ErrorInfo {
+  error: unknown;
+  state: AnyStateRef;
+  context: unknown;
+  event: InternalEvent;
+  reason: ErrorReason;
+}
+interface TransitionInfo {
+  event: InternalEvent;
+  from: string;
+  to: string;
+  transitioned: boolean;
+}
+type ErrorState = StateRef<"__error", unknown, true>;
+type TransitionResult<AllowedState extends AnyStateRef = AnyStateRef, AllowedEmit extends string = string> = {
+  state?: AllowedState | {
+    state: AllowedState;
+    payload?: unknown;
+  };
+  payload?: unknown;
+  emit?: Array<{
+    type: AllowedEmit;
+    payload?: unknown;
+  }>;
+};
+//#endregion
+//#region src/actor-internal.d.ts
+interface Snapshot<C = unknown> {
+  path: string[];
+  context: C;
+  payload?: unknown;
+  regions: Record<string, Snapshot<unknown>>;
+  done?: boolean;
+  error?: ErrorInfo;
+}
+interface AnyActor<C = Record<string, unknown>> {
+  state: AnyStateRef;
+  clock: Clock;
+  regions: Record<string, AnyActor>;
+  send(event: AnyEventRef | InternalEvent): void;
+  snapshot(): Snapshot<C>;
+  on(event: "change", fn: (snapshot: Snapshot<C>, prev: Snapshot<C>) => void): () => void;
+  on(event: "done", fn: () => void): () => void;
+  on(event: "transition", fn: (info: TransitionInfo) => void): () => void;
+  on(event: "error", fn: (info: ErrorInfo) => void): () => void;
+  on(event: "output", fn: (event: InternalEvent) => void): () => void;
+  recover(target: {
+    state: AnyStateRef;
+    context: C;
+  }): void;
+  settled(): Promise<void>;
+  context?: C;
+  options?: {
+    transitions?: Record<string, Record<string, unknown>>;
+    effects?: Record<string, unknown[]>;
+    states?: ReadonlyArray<{
+      name: string;
+      isFinal: boolean;
+    }>;
+  };
+  inject(event: InternalEvent): void;
+  dispose(): void;
+}
+//#endregion
 //#region src/builder.d.ts
 type EventTypeOf<E extends AnyEventRef> = E extends EventRef<infer Type, object | void> ? Type : never;
 type PayloadOf<S extends AnyStateRef> = S extends StateRef<infer _Name, infer Payload, infer _IsFinal> ? Payload : never;
@@ -101,10 +255,26 @@ declare class Actor<const States extends readonly AnyStateRef[], const Inputs ex
   get regions(): Record<string, AnyActor>;
   get options(): InternalActorOptions<States, Inputs, Internal, Outputs, ActorContext>;
   constructor(options: ActorOptions<States, Inputs, Internal, Outputs, ActorContext>);
-  on(event: "change" | "done", fn: ((snapshot: Snapshot<ActorContext>, prev: Snapshot<ActorContext>) => void) | (() => void)): () => void;
+  on(event: "change", fn: (snapshot: Snapshot<ActorContext>, prev: Snapshot<ActorContext>) => void): () => void;
+  on(event: "done", fn: () => void): () => void;
+  on(event: "transition", fn: (info: TransitionInfo) => void): () => void;
+  on(event: "error", fn: (info: ErrorInfo) => void): () => void;
+  on(event: "output", fn: (event: InternalEvent) => void): () => void;
   settled(): Promise<void>;
   send(event: CreatedOf$1<Inputs[number]>): void;
+  /**
+   * Restore a live state after `__error`. DANGER: caller supplies state+context,
+   * breaking determinism. Effects not re-run; processing resumes on next event.
+   */
+  recover(target: {
+    state: States[number];
+    context: ActorContext;
+  }): void;
   snapshot(): Snapshot<ActorContext>;
+  /** Push an internal event and drain. Unknown types route to output subscribers. */
+  inject(event: InternalEvent): void;
+  /** Stop for good: abort effect, clear queue and subscribers. Later sends/injects ignored. */
+  dispose(): void;
 }
 //#endregion
-export { Actor, type ActorBuilder, type AnyActor, type AnyEventRef, type AnyStateRef, type Clock, Context, type CreatedOf, type CreatedOfEvent, type EffectFn, type EffectInput, type ErrorInfo, type ErrorState, EventRef, type InternalEvent, type NonFinalStateRef, RealClock, type SetupFn, type Snapshot, StateRef, VirtualClock, event, state };
+export { Actor, type ActorBuilder, type ActorOptions, type AnyActor, type AnyEventRef, type AnyStateRef, type BuiltMaps, type Clock, Context, type CreatedOf, type CreatedOfEvent, type EffectFn, type EffectInput, type ErrorInfo, type ErrorReason, type ErrorState, EventRef, type EventTypeOf, type InitialState, type InternalEvent, type NonFinalStateRef, type PayloadOf, RealClock, type SetupFn, type Snapshot, StateRef, type TransitionHandler, type TransitionInfo, type TransitionResult, VirtualClock, event, state };

package/dist/index.mjs

@@ -1,658 +1 @@
-import { registerActor, setOutputHandler } from "./internal.mjs";
-import { Either } from "@mantaq/utils";
-//#region src/state.ts
-function state(id) {
-	return () => new StateRef(id, false);
-}
-var StateRef = class StateRef {
-	name;
-	isFinal;
-	/** @internal */ _regions;
-	constructor(name, isFinal) {
-		this.name = name;
-		this.isFinal = isFinal;
-	}
-	regions(options) {
-		this._regions = options;
-		return this;
-	}
-	final() {
-		const next = new StateRef(this.name, true);
-		next._regions = this._regions;
-		return next;
-	}
-	create(payload) {
-		return {
-			state: this,
-			payload
-		};
-	}
-};
-//#endregion
-//#region src/real-clock.ts
-var RealClock = class {
-	#start = Date.now();
-	now() {
-		return Date.now() - this.#start;
-	}
-	setTimeout(ms, cb, options) {
-		if (options?.signal?.aborted) return -1;
-		let onAbort;
-		const id = Number(globalThis.setTimeout(() => {
-			if (onAbort && options?.signal) options.signal.removeEventListener("abort", onAbort);
-			cb();
-		}, ms));
-		if (options?.signal) {
-			onAbort = () => globalThis.clearTimeout(id);
-			options.signal.addEventListener("abort", onAbort, { once: true });
-		}
-		return id;
-	}
-	clearTimeout(id) {
-		globalThis.clearTimeout(id);
-	}
-	setInterval(ms, cb, options) {
-		const id = Number(globalThis.setInterval(cb, ms));
-		if (options?.signal) {
-			const onAbort = () => globalThis.clearInterval(id);
-			options.signal.addEventListener("abort", onAbort, { once: true });
-		}
-		return id;
-	}
-	clearInterval(id) {
-		globalThis.clearInterval(id);
-	}
-};
-//#endregion
-//#region src/abort-tracker.ts
-function trackAbort(signal, id, map) {
-	const onAbort = signal ? () => {
-		map.delete(id);
-	} : void 0;
-	if (signal && onAbort) signal.addEventListener("abort", onAbort, { once: true });
-	return onAbort;
-}
-function clearAbort(timer) {
-	if (timer.signal && timer.onAbort) timer.signal.removeEventListener("abort", timer.onAbort);
-}
-//#endregion
-//#region src/virtual-clock.ts
-var VirtualClock = class {
-	#now = 0;
-	#timers = /* @__PURE__ */ new Map();
-	#intervals = /* @__PURE__ */ new Map();
-	#nextId = 1;
-	#drain = null;
-	now() {
-		return this.#now;
-	}
-	setTimeout(ms, cb, options) {
-		const signal = options?.signal;
-		if (signal?.aborted) return -1;
-		const id = this.#nextId++;
-		const onAbort = trackAbort(signal, id, this.#timers);
-		this.#timers.set(id, {
-			deadline: this.#now + ms,
-			cb,
-			signal,
-			onAbort,
-			eventName: options?.eventName
-		});
-		return id;
-	}
-	clearTimeout(id) {
-		const timer = this.#timers.get(id);
-		if (timer) {
-			clearAbort(timer);
-			this.#timers.delete(id);
-		}
-	}
-	setInterval(ms, cb, options) {
-		const signal = options?.signal;
-		if (signal?.aborted) return -1;
-		const id = this.#nextId++;
-		const onAbort = trackAbort(signal, id, this.#intervals);
-		this.#intervals.set(id, {
-			ms,
-			next: this.#now + ms,
-			cb,
-			signal,
-			onAbort
-		});
-		return id;
-	}
-	clearInterval(id) {
-		const interval = this.#intervals.get(id);
-		if (interval) {
-			clearAbort(interval);
-			this.#intervals.delete(id);
-		}
-	}
-	#findEarliestDeadline(target) {
-		let earliest = target;
-		let found = false;
-		for (const t of this.#timers.values()) if (t.deadline <= target && t.deadline <= earliest) {
-			earliest = t.deadline;
-			found = true;
-		}
-		for (const t of this.#intervals.values()) if (t.next <= target && t.next <= earliest) {
-			earliest = t.next;
-			found = true;
-		}
-		return found ? earliest : null;
-	}
-	#fireTimersAt(deadline) {
-		const ids = [];
-		for (const [id, t] of this.#timers) if (t.deadline === deadline) ids.push(id);
-		for (const id of ids) {
-			const timer = this.#timers.get(id);
-			if (timer) {
-				clearAbort(timer);
-				this.#timers.delete(id);
-				timer.cb();
-			}
-		}
-	}
-	#fireIntervalsAt(deadline) {
-		const ids = [];
-		for (const [id, t] of this.#intervals) if (t.next === deadline) ids.push(id);
-		for (const id of ids) {
-			const interval = this.#intervals.get(id);
-			if (interval) {
-				interval.cb();
-				if (this.#intervals.has(id)) interval.next = this.#now + interval.ms;
-			}
-		}
-	}
-	advance(ms) {
-		const target = this.#now + ms;
-		while (true) {
-			const deadline = this.#findEarliestDeadline(target);
-			if (deadline === null) break;
-			this.#now = deadline;
-			this.#fireTimersAt(deadline);
-			this.#fireIntervalsAt(deadline);
-		}
-		this.#now = target;
-		this.#drain?.();
-	}
-	hasPending() {
-		return this.#timers.size > 0 || this.#intervals.size > 0;
-	}
-	pendingTimers() {
-		const result = [];
-		for (const [id, t] of this.#timers) result.push({
-			id,
-			deadline: t.deadline,
-			ms: t.deadline - this.#now,
-			eventName: t.eventName
-		});
-		return result;
-	}
-	setDrain(fn) {
-		this.#drain = fn;
-	}
-};
-//#endregion
-//#region src/queue.ts
-var InternalQueue = class {
-	#queue = [];
-	#index = 0;
-	#processing = false;
-	#stopped = false;
-	#settledResolvers = [];
-	get length() {
-		return this.#queue.length - this.#index;
-	}
-	push(...events) {
-		if (this.#stopped) return;
-		this.#queue.push(...events);
-	}
-	settled() {
-		if (this.length === 0 && !this.#processing) return Promise.resolve();
-		return new Promise((resolve) => {
-			this.#settledResolvers.push(resolve);
-		});
-	}
-	processCancellable(processEvent) {
-		this.#process(processEvent);
-	}
-	#process(processEvent) {
-		if (this.#processing) return;
-		this.#processing = true;
-		try {
-			while (this.#index < this.#queue.length) {
-				if (this.#stopped) break;
-				const event = this.#queue[this.#index++];
-				if (!processEvent(event)) {
-					this.#stopped = true;
-					break;
-				}
-			}
-		} finally {
-			this.#queue.length = 0;
-			this.#index = 0;
-			this.#processing = false;
-			this.#stopped = false;
-			if (this.#settledResolvers.length > 0) {
-				const resolvers = this.#settledResolvers.splice(0);
-				for (const resolve of resolvers) resolve();
-			}
-		}
-	}
-};
-//#endregion
-//#region src/subscribers.ts
-var Subscribers = class {
-	change = /* @__PURE__ */ new Set();
-	done = /* @__PURE__ */ new Set();
-	#last = null;
-	seed(snapshot) {
-		this.#last = snapshot;
-	}
-	addChange(fn) {
-		this.change.add(fn);
-		const last = this.#last;
-		if (last) this.#safe(() => fn(last, last));
-		return () => this.change.delete(fn);
-	}
-	addDone(fn) {
-		this.done.add(fn);
-		return () => this.done.delete(fn);
-	}
-	emitChange(snapshot) {
-		const prev = this.#last ?? snapshot;
-		this.#last = snapshot;
-		for (const fn of this.change) this.#safe(() => fn(snapshot, prev));
-	}
-	emitDone() {
-		for (const fn of this.done) this.#safe(fn);
-	}
-	clear() {
-		this.change.clear();
-		this.done.clear();
-	}
-	#safe(fn) {
-		const err = Either.from(fn);
-		if (err[0] !== void 0) console.warn(`[Actor] subscriber threw: ${err[0] instanceof Error ? err[0].message : "unknown error"}`);
-	}
-};
-//#endregion
-//#region src/snapshot.ts
-function buildSnapshot(s, regions, context, error) {
-	const path = [s.name];
-	const regionSnapshots = {};
-	for (const [regionName, child] of Object.entries(regions)) regionSnapshots[regionName] = child.snapshot();
-	const snap = {
-		path,
-		context,
-		regions: regionSnapshots
-	};
-	if (s.isFinal) snap.done = true;
-	if (error !== void 0) snap.error = error;
-	return snap;
-}
-//#endregion
-//#region src/effects.ts
-function runEffects(options) {
-	const pending = [];
-	if (options.state.isFinal) return { pending };
-	const list = options.effects[options.state.name];
-	if (!list) return { pending };
-	for (const effectFn of list) {
-		if (options.abort.signal.aborted) break;
-		const attempt = Either.from(() => effectFn({
-			signal: options.abort.signal,
-			state: {
-				name: options.state.name,
-				payload: options.statePayload
-			},
-			event: options.event,
-			context: options.context,
-			emit: options.emit,
-			clock: options.clock
-		}));
-		if (attempt[0] !== void 0) {
-			options.onError(attempt[0], options.lastGood);
-			break;
-		}
-		const out = attempt[1];
-		if (out instanceof Promise) pending.push(out.catch((error) => {
-			if (options.abort.signal.aborted) return;
-			options.onError(error, options.lastGood);
-		}));
-	}
-	return { pending };
-}
-//#endregion
-//#region src/dispatch.ts
-function parseTarget(step) {
-	if (!step.state) return void 0;
-	if (step.state instanceof StateRef) return {
-		state: step.state,
-		payload: step.payload
-	};
-	return {
-		state: step.state.state,
-		payload: step.state.payload
-	};
-}
-//#endregion
-//#region src/context.ts
-var Context = class {
-	#get;
-	#set;
-	constructor(get, set) {
-		this.#get = get;
-		this.#set = set;
-	}
-	get() {
-		return this.#get();
-	}
-	set(value) {
-		this.#set(value);
-	}
-};
-//#endregion
-//#region src/builder.ts
-var ActorBuilder = class {
-	#transitions = {};
-	#effects = {};
-	on(stateRef, eventRef, fn) {
-		const sName = stateRef.name;
-		const eType = eventRef.type;
-		(this.#transitions[sName] ??= {})[eType] = fn;
-		return this;
-	}
-	onAny(eventRef, fn) {
-		const eType = eventRef.type;
-		(this.#transitions["Any"] ??= {})[eType] = fn;
-		return this;
-	}
-	effect(stateRef, fn) {
-		(this.#effects[stateRef.name] ??= []).push(fn);
-		return this;
-	}
-	/** @internal */ build() {
-		return {
-			transitions: this.#transitions,
-			effects: this.#effects
-		};
-	}
-};
-//#endregion
-//#region src/actor.ts
-function resolveInitial(initial) {
-	return initial instanceof StateRef ? initial : initial.state;
-}
-var Actor = class {
-	state;
-	clock;
-	#context;
-	#contextHandle;
-	#contextWritten = false;
-	#lastState;
-	#options;
-	#regions = {};
-	#children = /* @__PURE__ */ new Map();
-	#queue = new InternalQueue();
-	#subs = new Subscribers();
-	#effectAbort = null;
-	#outputHandler = null;
-	#internalIds;
-	#inputIds;
-	#internalBudget;
-	#draining = false;
-	get context() {
-		return this.#context;
-	}
-	get regions() {
-		return this.#regions;
-	}
-	get options() {
-		return this.#options;
-	}
-	constructor(options) {
-		registerActor(this, {
-			children: this.#children,
-			getOutputHandler: () => this.#outputHandler,
-			setOutputHandler: (fn) => {
-				this.#outputHandler = fn;
-			},
-			pushInternal: (event) => this.#queue.push(event),
-			drainInternal: () => this.#drainInternal(),
-			abortEffects: () => this.#abortEffects()
-		});
-		const builder = new ActorBuilder();
-		options.setup(builder);
-		const built = builder.build();
-		this.#options = {
-			...options,
-			transitions: built.transitions,
-			effects: built.effects
-		};
-		this.#internalIds = new Set((options.internal ?? []).map((e) => e.type));
-		this.#inputIds = new Set(options.inputs.map((e) => e.type));
-		this.#internalBudget = options.internalBudget ?? 1e4;
-		this.clock = options.clock ?? new RealClock();
-		this.clock.setDrain?.(() => this.#drainInternal());
-		const initState = resolveInitial(options.initial);
-		const stateNames = new Set(options.states.map((s) => s.name));
-		if (!stateNames.has(initState.name)) console.warn(`[Actor] initial state "${initState.name}" not found in declared states [${[...stateNames].join(", ")}]`);
-		this.state = initState;
-		this.#context = options.context ?? {};
-		this.#lastState = initState;
-		this.#contextHandle = new Context(() => this.#context, (value) => {
-			this.#context = value;
-			this.#contextWritten = true;
-		});
-		this.#subs.seed(this.snapshot());
-		if (options.regions) for (const [key, child] of Object.entries(options.regions)) {
-			this.#regions[key] = child;
-			const result = setOutputHandler(child, (event) => {
-				this.#queue.push(event);
-				this.#drainInternal();
-			});
-			if (result[0] !== void 0) console.error(result[0].message);
-			this.#children.set(key, child);
-		}
-	}
-	on(event, fn) {
-		if (event === "change") {
-			const cb = fn;
-			return this.#subs.addChange(cb);
-		}
-		const cb = fn;
-		return this.#subs.addDone(cb);
-	}
-	settled() {
-		return Promise.all([this.#queue.settled(), ...this.#pendingEffects]).then(() => void 0);
-	}
-	send(event) {
-		this.#dispatch(event);
-		this.#emitChangeIfDirty();
-	}
-	#emitChangeIfDirty() {
-		if (this.state === this.#lastState && !this.#contextWritten) return;
-		this.#lastState = this.state;
-		this.#contextWritten = false;
-		this.#subs.emitChange(this.snapshot());
-	}
-	#dispatch(event) {
-		if (this.#error !== null || this.state.isFinal) return;
-		const prev = this.#entry;
-		this.#entry = {
-			state: this.state,
-			context: this.#context
-		};
-		try {
-			const transitions = this.#options.transitions;
-			const stateTransition = transitions[this.state.name]?.[event.type];
-			const anyTransition = transitions["Any"]?.[event.type];
-			const transitionApplied = stateTransition ? this.#applyStateStep(event, stateTransition) : false;
-			if ((this.#error === null ? this.#applyAnyStep(event, anyTransition, !transitionApplied) : false) || this.#queue.length > 0) this.#drainInternal();
-			else if (!stateTransition && !anyTransition) console.warn(`[Actor] no transition for event "${event.type}" in state "${this.state.name}". Event dropped.`);
-		} finally {
-			this.#entry = prev;
-		}
-	}
-	#applyStateStep(event, transition) {
-		let applied = false;
-		this.#safe("transition", event, () => {
-			const step = transition(event, {
-				context: this.#contextHandle,
-				actor: this
-			});
-			if (step.emit) this.#queue.push(...step.emit);
-			if (step.state) {
-				this.#applyTransition(event, step);
-				applied = true;
-			}
-		});
-		return applied;
-	}
-	#applyAnyStep(event, transition, allowTransition) {
-		if (transition === void 0) return false;
-		let emitted = false;
-		this.#safe("transition", event, () => {
-			const step = transition(event, {
-				context: this.#contextHandle,
-				actor: this
-			});
-			if (step.state && allowTransition) this.#applyTransition(event, step);
-			if (step.emit) {
-				this.#queue.push(...step.emit);
-				emitted = true;
-			}
-		});
-		return emitted;
-	}
-	snapshot() {
-		return buildSnapshot(this.state, this.#regions, this.#context, this.#error ?? void 0);
-	}
-	#abortEffects() {
-		this.#effectAbort?.abort();
-		this.#subs.clear();
-	}
-	#applyTransition(event, step) {
-		if (this.#error !== null || !step.state) return;
-		const resolved = parseTarget(step);
-		if (!resolved) return;
-		if (!(resolved.state instanceof StateRef)) {
-			this.#enterError("transition", event, /* @__PURE__ */ new Error("invalid transition target"));
-			return;
-		}
-		this.#effectAbort?.abort();
-		this.state = resolved.state;
-		this.#runEffects(event, resolved.payload);
-		if (this.state.isFinal) this.#subs.emitDone();
-	}
-	#runEffects(event, statePayload) {
-		const list = this.#options.effects[this.state.name];
-		if (!list) {
-			this.#effectAbort = null;
-			return;
-		}
-		const abort = new AbortController();
-		this.#effectAbort = abort;
-		const lastGood = this.#entry ?? {
-			state: this.state,
-			context: this.#context
-		};
-		const result = runEffects({
-			effects: { [this.state.name]: list },
-			state: this.state,
-			statePayload,
-			event,
-			context: this.#contextHandle,
-			emit: (e) => {
-				if (this.#error !== null) return;
-				this.#queue.push(e);
-				this.#drainInternal();
-			},
-			clock: this.clock,
-			abort,
-			lastGood,
-			onError: (error) => this.#enterError("effect", event, error, lastGood)
-		});
-		this.#pendingEffects.push(...result.pending);
-	}
-	#drainInternal() {
-		if (this.#draining) return;
-		this.#draining = true;
-		try {
-			const budget = this.#internalBudget;
-			let count = 0;
-			this.#queue.processCancellable((event) => {
-				if (this.#error !== null) return false;
-				if (count >= budget) {
-					this.#enterError("budget", event, /* @__PURE__ */ new Error("internal event budget exceeded"));
-					return false;
-				}
-				count++;
-				if (this.#internalIds.has(event.type) || this.#inputIds.has(event.type)) this.#dispatch(event);
-				else {
-					const outputHandler = this.#outputHandler;
-					if (outputHandler) {
-						if (!this.#safe("output", event, () => outputHandler(event))) return false;
-					}
-				}
-				return true;
-			});
-		} finally {
-			this.#draining = false;
-			this.#emitChangeIfDirty();
-		}
-	}
-	#errorState = new StateRef("__error", false);
-	#error = null;
-	#entry = null;
-	#pendingEffects = [];
-	#safe(reason, event, fn) {
-		const attempt = Either.from(fn);
-		if (attempt[0] === void 0) return true;
-		this.#enterError(reason, event, attempt[0]);
-		return false;
-	}
-	#enterError(reason, event, error, lastGood) {
-		if (this.#error !== null) return;
-		const entry = lastGood ?? this.#entry ?? {
-			state: this.state,
-			context: this.#context
-		};
-		this.#error = {
-			error,
-			state: entry.state,
-			context: entry.context,
-			event,
-			reason
-		};
-		this.#effectAbort?.abort();
-		this.state = this.#errorState;
-		this.#lastState = this.#errorState;
-		this.#contextWritten = false;
-		this.#subs.emitChange(this.snapshot());
-	}
-};
-//#endregion
-//#region src/event.ts
-function event(type) {
-	return () => new EventRef(type);
-}
-var EventRef = class {
-	type;
-	constructor(type) {
-		this.type = type;
-	}
-	is(anyEvent) {
-		return !!anyEvent && typeof anyEvent === "object" && "type" in anyEvent && anyEvent.type === this.type;
-	}
-	create(payload) {
-		return payload === void 0 ? { type: this.type } : {
-			type: this.type,
-			payload
-		};
-	}
-};
-//#endregion
-export { Actor, Context, EventRef, RealClock, StateRef, VirtualClock, event, state };
+import{Either as e}from"@mantaq/utils";function t(e){return()=>new n(e,!1)}var n=class e{name;isFinal;_regions;constructor(e,t){this.name=e,this.isFinal=t}regions(e){return this._regions=e,this}final(){let t=new e(this.name,!0);return t._regions=this._regions,t}create(e){return{state:this,payload:e}}},r=class{#e=Date.now();now(){return Date.now()-this.#e}setTimeout(e,t,n){if(n?.signal?.aborted)return-1;let r,i=Number(globalThis.setTimeout(()=>{r&&n?.signal&&n.signal.removeEventListener(`abort`,r),t()},e));return n?.signal&&(r=()=>globalThis.clearTimeout(i),n.signal.addEventListener(`abort`,r,{once:!0})),i}clearTimeout(e){globalThis.clearTimeout(e)}setInterval(e,t,n){let r=Number(globalThis.setInterval(t,e));return n?.signal&&n.signal.addEventListener(`abort`,()=>globalThis.clearInterval(r),{once:!0}),r}clearInterval(e){globalThis.clearInterval(e)}};function i(e,t,n){let r=e?()=>{n.delete(t)}:void 0;return e&&r&&e.addEventListener(`abort`,r,{once:!0}),r}function a(e){e.signal&&e.onAbort&&e.signal.removeEventListener(`abort`,e.onAbort)}var o=class{#e=0;#t=new Map;#n=new Map;#r=1;#i=null;now(){return this.#e}#a(e,t,n){if(!Number.isFinite(e))throw RangeError(`[VirtualClock] invalid ${t} ms value: ${e}`);return e<=0?+!!n:e}setTimeout(e,t,n){let r=n?.signal;if(r?.aborted)return-1;let a=this.#r++,o=i(r,a,this.#t);return this.#t.set(a,{deadline:this.#e+this.#a(e,`setTimeout`,!1),cb:t,signal:r,onAbort:o,eventName:n?.eventName}),a}clearTimeout(e){let t=this.#t.get(e);t&&(a(t),this.#t.delete(e))}setInterval(e,t,n){let r=n?.signal;if(r?.aborted)return-1;let a=this.#r++,o=i(r,a,this.#n),s=this.#a(e,`setInterval`,!0);return this.#n.set(a,{ms:s,next:this.#e+s,cb:t,signal:r,onAbort:o}),a}clearInterval(e){let t=this.#n.get(e);t&&(a(t),this.#n.delete(e))}#o(e){let t=e,n=!1;for(let r of this.#t.values())r.deadline<=e&&r.deadline<=t&&(t=r.deadline,n=!0);for(let r of this.#n.values())r.next<=e&&r.next<=t&&(t=r.next,n=!0);return n?t:null}#s(e){let t=[];for(let[n,r]of this.#t)r.deadline===e&&t.push(n);for(let e of t){let t=this.#t.get(e);t&&(a(t),this.#t.delete(e),t.cb())}}#c(e){let t=[];for(let[n,r]of this.#n)r.next===e&&t.push(n);for(let e of t){let t=this.#n.get(e);t&&(t.cb(),this.#n.has(e)&&(t.next=this.#e+t.ms))}}advance(e){if(!Number.isFinite(e))throw RangeError(`[VirtualClock] invalid advance ms value: ${e}`);let t=this.#e+Math.max(0,e);for(;;){let e=this.#o(t);if(e===null)break;this.#e=e,this.#s(e),this.#c(e)}this.#e=t,this.#i?.()}hasPending(){return this.#t.size>0||this.#n.size>0}pendingTimers(){let e=[];for(let[t,n]of this.#t)e.push({id:t,deadline:n.deadline,ms:n.deadline-this.#e,eventName:n.eventName});return e}setDrain(e){this.#i=e}},s=class{#e=[];#t=0;#n=!1;#r=!1;#i=[];get length(){return this.#e.length-this.#t}push(...e){this.#r||this.#e.push(...e)}clear(){let e=this.#i.splice(0);this.#e.length=0,this.#t=0;for(let t of e)t()}settled(){return this.length===0&&!this.#n?Promise.resolve():new Promise(e=>{this.#i.push(e)})}processCancellable(e){this.#a(e)}#a(e){if(!this.#n){this.#n=!0;try{for(;this.#t<this.#e.length&&!this.#r;){let t=this.#e[this.#t++];if(!e(t)){this.#r=!0;break}}}finally{this.#e.length=0,this.#t=0,this.#n=!1,this.#r=!1;let e=this.#i.splice(0);for(let t of e)t()}}}},c=class{change=new Set;done=new Set;transition=new Set;error=new Set;#e=null;seed(e){this.#e=e}addChange(e){this.change.add(e);let t=this.#e;return t&&this.#t(()=>e(t,t)),()=>this.change.delete(e)}addDone(e){return this.done.add(e),()=>this.done.delete(e)}addTransition(e){return this.transition.add(e),()=>this.transition.delete(e)}addError(e){this.error.add(e);let t=this.#e?.error;return t&&this.#t(()=>e(t)),()=>this.error.delete(e)}emitChange(e){let t=this.#e??e;this.#e=e;for(let n of this.change)this.#t(()=>n(e,t))}emitDone(){for(let e of this.done)this.#t(e)}emitTransition(e){for(let t of this.transition)this.#t(()=>t(e))}emitError(e){for(let t of this.error)this.#t(()=>t(e))}clear(){this.change.clear(),this.done.clear(),this.transition.clear(),this.error.clear(),this.output.clear()}#t(t){e.from(t)}output=new Set;addOutput(e){return this.output.add(e),()=>this.output.delete(e)}emitOutput(e){for(let t of this.output)t(e)}};function l(e,t,n,r={}){let i=[e.name],a={};for(let[e,n]of Object.entries(t))a[e]=n.snapshot();let o={path:i,context:n,regions:a};return r.payload!==void 0&&(o.payload=r.payload),e.isFinal&&(o.done=!0),r.error!==void 0&&(o.error=r.error),o}function u(t){let n=[],r=t.effects[t.state.name];if(!r)return{pending:n};for(let i of r){if(t.abort.signal.aborted)break;let r=e.from(()=>i({signal:t.abort.signal,state:{name:t.state.name,payload:t.statePayload},event:t.event,context:t.context,emit:t.emit,clock:t.clock}));if(r[0]!==void 0){t.onError(r[0],t.lastGood);break}let a=r[1];a instanceof Promise&&n.push(a.catch(e=>{t.abort.signal.aborted||t.onError(e,t.lastGood)}))}return{pending:n}}function d(e){if(e.state)return e.state instanceof n?{state:e.state,payload:e.payload}:{state:e.state.state,payload:e.state.payload}}var f=class{#e;#t;constructor(e,t){this.#e=e,this.#t=t}get(){return this.#e()}set(e){this.#t(e)}},p=class{#e={};#t={};on(e,t,n){let r=e.name,i=t.type;return(this.#e[r]??={})[i]=n,this}onAny(e,t){let n=e.type;return(this.#e.Any??={})[n]=t,this}effect(e,t){return(this.#t[e.name]??=[]).push(t),this}build(){return{transitions:this.#e,effects:this.#t}}};function m(e){return e instanceof n?e:e.state}var h=class{state;clock;#e;#t;#n=!1;#r;#i;#a={};#o=new s;#s=new c;#c=null;#l;#u;#d;#f=!1;get context(){return this.#e}get regions(){return this.#a}get options(){return this.#i}constructor(e){let t=new p;e.setup(t);let i=t.build();this.#i={...e,transitions:i.transitions,effects:i.effects},this.#l=new Set((e.internal??[]).map(e=>e.type)),this.#u=new Set(e.inputs.map(e=>e.type)),this.#d=e.internalBudget??1e4,this.clock=e.clock??new r,this.clock.setDrain?.(()=>this.#x());let a=m(e.initial),o=new Set(e.states.map(e=>e.name));if(!o.has(a.name))throw Error(`[Actor] initial state "${a.name}" not found in declared states [${[...o].join(`, `)}]`);if(this.state=a,this.#S=e.initial instanceof n?void 0:e.initial.payload,this.#e=e.context??{},this.#r=a,this.#t=new f(()=>this.#e,e=>{this.#e=e,this.#n=!0}),e.regions)for(let[t,n]of Object.entries(e.regions))this.#a[t]=n,n.on(`output`,e=>{this.#o.push(e),this.#x()});this.#b({type:`__init`},this.#S),this.#s.seed(this.snapshot())}on(e,t){return{change:e=>this.#s.addChange(e),done:e=>this.#s.addDone(e),transition:e=>this.#s.addTransition(e),error:e=>this.#s.addError(e),output:e=>this.#s.addOutput(e)}[e](t)}settled(){return Promise.all([this.#o.settled(),...this.#C]).then(()=>void 0)}send(e){this.#k||(this.#m(e),this.#p())}recover(e){this.#T===null||this.#k||(this.#T=null,this.#o=new s,this.#c=null,this.state=e.state,this.#S=void 0,this.#e=e.context,this.#r=e.state,this.#n=!1,this.#E=null,this.#C=[],this.#s.emitChange(this.snapshot()))}#p(){this.state===this.#r&&!this.#n||(this.#r=this.state,this.#n=!1,this.#s.emitChange(this.snapshot()))}#m(e){if(this.#T!==null||this.state.isFinal)return;let t={...e,payload:e.payload??{}},n=this.state.name,r=this.#E;this.#E={state:this.state,context:this.#e};try{let r=this.#i.transitions,i=r[this.state.name]?.[e.type],a=r.Any?.[e.type],o=this.#h(t,i,a);this.#g(t,n,!!(i||a),o),o.emitted||this.#o.length>0?this.#x():!i&&!a&&this.#l.has(e.type)&&this.#O(`unhandled`,e,Error(`[Actor] internal event "${e.type}" emitted but no handler in state "${this.state.name}"`))}finally{this.#E=r}}#h(e,t,n){let r=t?this.#_(e,t):{applied:!1};if(this.#T===null){let t=this.#v(e,n,!r.applied);return{emitted:t.emitted,transitioned:r.applied||t.transitioned,target:r.target??t.target}}return{emitted:!1,transitioned:!1}}#g(e,t,n,r){this.#T===null&&n&&this.#s.emitTransition({event:e,from:t,to:r.target??this.state.name,transitioned:r.transitioned})}#_(e,t){let n=!1,r;return this.#D(`transition`,e,()=>{let i=t(e,{context:this.#t,actor:this});i.emit&&this.#o.push(...i.emit),i.state&&(r=this.#y(e,i),n=!0)}),{applied:n,target:r}}#v(e,t,n){if(t===void 0)return{emitted:!1,transitioned:!1};let r=!1,i=!1,a;return this.#D(`transition`,e,()=>{let o=t(e,{context:this.#t,actor:this});o.state&&n&&(a=this.#y(e,o),i=!0),o.emit&&(this.#o.push(...o.emit),r=!0)}),{emitted:r,transitioned:i,target:a}}snapshot(){return l(this.state,this.#a,this.#e,{error:this.#T??void 0,payload:this.#S})}#y(e,t){if(this.#T!==null||!t.state)return;let r=d(t);if(!r)return;if(!(r.state instanceof n)){this.#O(`transition`,e,Error(`invalid transition target`));return}this.#c?.abort(),this.state=r.state;let i=this.state.name;return this.#S=r.payload,this.#E={state:this.state,context:this.#e},this.#b(e,r.payload),r.state.isFinal&&this.#T===null&&this.#s.emitDone(),i}#b(e,t){if(this.#k)return;let n=this.#i.effects[this.state.name];if(!n){this.#c=null;return}let r=new AbortController;this.#c=r;let i=this.#E??{state:this.state,context:this.#e},a=u({effects:{[this.state.name]:n},state:this.state,statePayload:t,event:e,context:this.#t,emit:e=>{this.#T!==null||r.signal.aborted||(this.#o.push(e),this.#x())},clock:this.clock,abort:r,lastGood:i,onError:t=>this.#O(`effect`,e,t,i)});this.#C.push(...a.pending)}#x(){if(!(this.#f||this.#k)){this.#f=!0;try{let e=this.#d,t=0;this.#o.processCancellable(n=>{if(this.#T!==null)return!1;if(t>=e)return this.#O(`budget`,n,Error(`internal event budget exceeded`)),!1;if(t++,this.#l.has(n.type)||this.#u.has(n.type))this.#m(n);else if(!this.#D(`output`,n,()=>this.#s.emitOutput(n)))return!1;return!0})}finally{this.#f=!1,this.#p()}}}#S;#C=[];#w=new n(`__error`,!0);#T=null;#E=null;#D(t,n,r){let i=e.from(r);return i[0]===void 0||(this.#O(t,n,i[0]),!1)}#O(e,t,n,r){if(this.#T!==null)return;let i=r??this.#E??{state:this.state,context:this.#e};this.#T={error:n,state:i.state,context:i.context,event:t,reason:e},this.#c?.abort(),this.state=this.#w,this.#S=void 0,this.#r=this.#w,this.#n=!1,this.#s.emitError(this.#T),this.#s.emitChange(this.snapshot()),this.#s.emitDone()}inject(e){this.#k||(this.#o.push(e),this.#x())}dispose(){this.#k||(this.#k=!0,this.#c?.abort(),this.#c=null,this.#o.clear(),this.#s.clear())}#k=!1};function g(e){return()=>new _(e)}var _=class{type;constructor(e){this.type=e}is(e){return!!e&&typeof e==`object`&&`type`in e&&e.type===this.type}create(e){return e===void 0?{type:this.type}:{type:this.type,payload:e}}};export{h as Actor,f as Context,_ as EventRef,r as RealClock,n as StateRef,o as VirtualClock,g as event,t as state};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantaq/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "State machine runtime with actor model, event system, state hierarchy, effects, and virtual clock.",
   "license": "MIT",
   "repository": {
@@ -12,16 +12,16 @@
     "dist"
   ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": "./dist/index.mjs",
-    "./internal": "./dist/internal.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@mantaq/utils": "0.0.2"
+    "@mantaq/utils": "0.0.3"
   },
   "devDependencies": {
     "@stryker-mutator/core": "^9",

package/dist/actor-internal-DYAL1iYK.d.mts

@@ -1,139 +0,0 @@
-//#region src/state.d.ts
-declare function state<const T extends string>(id: T): <Payload = unknown>() => StateRef<T, Payload, false>;
-type AnyStateRef = StateRef<string, unknown, boolean>;
-interface RegionOptions {
-  initial: string;
-  states: Record<string, AnyStateRef>;
-}
-type RegionsOptions = Record<string, RegionOptions>;
-declare class StateRef<T extends string, Payload = unknown, IsFinal extends boolean = false> {
-  readonly name: T;
-  readonly isFinal: IsFinal;
-  /** @internal */ _regions: RegionsOptions | undefined;
-  constructor(name: T, isFinal: IsFinal);
-  regions(options: RegionsOptions): this;
-  final(): StateRef<T, Payload, true>;
-  create(payload: Payload): {
-    state: StateRef<T, Payload, IsFinal>;
-    payload: Payload;
-  };
-}
-//#endregion
-//#region src/event.d.ts
-declare function event<const T extends string>(type: T): <Payload extends object | void = void>() => EventRef<T, Payload>;
-type AnyEventRef = EventRef<string, object | void>;
-type InternalEvent = {
-  type: string;
-  payload?: unknown;
-};
-type CreatedOfEvent<T extends string, P> = P extends void ? {
-  type: T;
-} : {
-  type: T;
-  payload: P;
-};
-declare class EventRef<const T extends string, Payload extends object | void = void> {
-  readonly type: T;
-  constructor(type: T);
-  is(anyEvent: unknown): anyEvent is CreatedOfEvent<T, Payload>;
-  create(): Payload extends void ? {
-    type: T;
-  } : void;
-  create(payload: Payload): Payload extends void ? {
-    type: T;
-  } : {
-    type: T;
-    payload: Payload;
-  };
-}
-//#endregion
-//#region src/clock.d.ts
-interface Clock {
-  setTimeout(ms: number, cb: () => void, options?: {
-    signal?: AbortSignal;
-    eventName?: string;
-  }): number;
-  clearTimeout(id: number): void;
-  setInterval(ms: number, cb: () => void, options?: {
-    signal?: AbortSignal;
-  }): number;
-  clearInterval(id: number): void;
-  now(): number;
-  /** Optional hook for draining queues after clock advances (VirtualClock). */
-  setDrain?(fn: () => void): void;
-}
-//#endregion
-//#region src/context.d.ts
-declare class Context<T> {
-  #private;
-  constructor(get: () => T, set: (value: T) => void);
-  get(): T;
-  set(value: T): void;
-}
-//#endregion
-//#region src/actor-types.d.ts
-type CreatedOf<E extends AnyEventRef> = E extends EventRef<infer Type, infer P> ? CreatedOfEvent<Type, P> : never;
-type NonFinalStateRef<States extends AnyStateRef[]> = Extract<States[number], {
-  isFinal: false;
-}>;
-interface EffectInput<ActorContext, Payload = unknown> {
-  signal: AbortSignal;
-  state: {
-    name: string;
-    payload: Payload;
-  };
-  event: InternalEvent;
-  context: Context<ActorContext>;
-  emit: (event: InternalEvent) => void;
-  clock: Clock;
-}
-type EffectFn<ActorContext, Payload = unknown> = (input: EffectInput<ActorContext, Payload>) => void | Promise<void>;
-type ErrorReason = "transition" | "effect" | "budget" | "output" | "internal" | "async";
-interface ErrorInfo {
-  error: unknown;
-  state: AnyStateRef;
-  context: unknown;
-  event: InternalEvent;
-  reason: ErrorReason;
-}
-type ErrorState = StateRef<"__error", unknown, false>;
-type TransitionResult<AllowedState extends AnyStateRef = AnyStateRef, AllowedEmit extends string = string> = {
-  state?: AllowedState | {
-    state: AllowedState;
-    payload?: unknown;
-  };
-  payload?: unknown;
-  emit?: Array<{
-    type: AllowedEmit;
-  }>;
-};
-//#endregion
-//#region src/actor-internal.d.ts
-interface Snapshot<C = unknown> {
-  path: string[];
-  context: C;
-  regions: Record<string, Snapshot<unknown>>;
-  done?: boolean;
-  error?: ErrorInfo;
-}
-interface AnyActor<C = Record<string, unknown>> {
-  state: AnyStateRef;
-  clock: Clock;
-  regions: Record<string, AnyActor>;
-  send(event: AnyEventRef | InternalEvent): void;
-  snapshot(): Snapshot<C>;
-  on(event: "change", fn: (snapshot: Snapshot<C>, prev: Snapshot<C>) => void): () => void;
-  on(event: "done", fn: () => void): () => void;
-  settled(): Promise<void>;
-  context?: C;
-  options?: {
-    transitions?: Record<string, Record<string, unknown>>;
-    effects?: Record<string, unknown[]>;
-    states?: ReadonlyArray<{
-      name: string;
-      isFinal: boolean;
-    }>;
-  };
-}
-//#endregion
-export { AnyStateRef as _, EffectInput as a, NonFinalStateRef as c, Clock as d, AnyEventRef as f, event as g, InternalEvent as h, EffectFn as i, TransitionResult as l, EventRef as m, Snapshot as n, ErrorInfo as o, CreatedOfEvent as p, CreatedOf as r, ErrorState as s, AnyActor as t, Context as u, StateRef as v, state as y };

package/dist/internal.d.mts

@@ -1,26 +0,0 @@
-import { h as InternalEvent, t as AnyActor } from "./actor-internal-DYAL1iYK.mjs";
-import { Either } from "@mantaq/utils";
-//#region src/internal-registry.d.ts
-interface ActorInternal {
-  children: Map<string, AnyActor>;
-  getOutputHandler(): ((event: InternalEvent) => void) | null;
-  setOutputHandler(fn: ((event: InternalEvent) => void) | null): void;
-  pushInternal(event: InternalEvent): void;
-  drainInternal(): void;
-  abortEffects(): void;
-}
-interface RegistryError {
-  message: string;
-}
-declare global {
-  var __mantaqCoreInternalRegistry: WeakMap<object, ActorInternal> | undefined;
-}
-declare function registerActor(actor: object, internal: ActorInternal): void;
-declare function getChildren(actor: object): Either<RegistryError, Map<string, AnyActor>>;
-declare function getOutputHandler(actor: object): Either<RegistryError, ((event: InternalEvent) => void) | null>;
-declare function setOutputHandler(actor: object, fn: ((event: InternalEvent) => void) | null): Either<RegistryError, void>;
-declare function pushInternal(actor: object, event: InternalEvent): Either<RegistryError, void>;
-declare function drainInternal(actor: object): Either<RegistryError, void>;
-declare function abortEffects(actor: object): Either<RegistryError, void>;
-//#endregion
-export { ActorInternal, RegistryError, abortEffects, drainInternal, getChildren, getOutputHandler, pushInternal, registerActor, setOutputHandler };

package/dist/internal.mjs

@@ -1,31 +0,0 @@
-import { Either } from "@mantaq/utils";
-//#region src/internal-registry.ts
-const registry = globalThis.__mantaqCoreInternalRegistry ??= /* @__PURE__ */ new WeakMap();
-const UNREGISTERED = { message: "[mantaq] actor is not registered with the internal registry" };
-function withInternal(actor, fn) {
-	const internal = registry.get(actor);
-	return internal === void 0 ? Either.left(UNREGISTERED) : [void 0, fn(internal)];
-}
-function registerActor(actor, internal) {
-	registry.set(actor, internal);
-}
-function getChildren(actor) {
-	return withInternal(actor, (internal) => internal.children);
-}
-function getOutputHandler(actor) {
-	return withInternal(actor, (internal) => internal.getOutputHandler());
-}
-function setOutputHandler(actor, fn) {
-	return withInternal(actor, (internal) => internal.setOutputHandler(fn));
-}
-function pushInternal(actor, event) {
-	return withInternal(actor, (internal) => internal.pushInternal(event));
-}
-function drainInternal(actor) {
-	return withInternal(actor, (internal) => internal.drainInternal());
-}
-function abortEffects(actor) {
-	return withInternal(actor, (internal) => internal.abortEffects());
-}
-//#endregion
-export { abortEffects, drainInternal, getChildren, getOutputHandler, pushInternal, registerActor, setOutputHandler };