@mantaq/core 0.2.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 + payload | 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
 
@@ -97,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
@@ -123,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 };
   });
 },
@@ -214,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 };
 ```
 
@@ -304,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 };
       });
     },
@@ -439,7 +446,7 @@ if (snap.error) {
 
 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")` callback is swallowed — the machine and its callers are unaffected.
+- **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.
@@ -496,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 };
@@ -511,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
@@ -525,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 };
   });
 },

package/dist/index.d.mts

@@ -1,4 +1,68 @@
-import { _ as InternalEvent, a as EffectInput, b as StateRef, c as ErrorState, d as TransitionResult, f as Context, g as EventRef, h as CreatedOfEvent, i as EffectFn, l as NonFinalStateRef, m as AnyEventRef, n as Snapshot, o as ErrorInfo, p as Clock, r as CreatedOf, s as ErrorReason, t as AnyActor, u as TransitionInfo, v as event, x as state, y as AnyStateRef } from "./actor-internal-B4iAxUG_.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;
@@ -104,19 +258,23 @@ declare class Actor<const States extends readonly AnyStateRef[], const Inputs ex
   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;
   /**
-   * Manually restore the actor to a live state after a fatal `__error`.
-   * DANGER: the caller supplies state and context, so the trajectory is no
-   * longer deterministic ("same inputs, same trace"). Effects are not re-run
-   * and timers are not re-armed — processing resumes on the next event.
+   * 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 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,766 +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;
-	}
-	/**
-	* Delay normalization: NaN and ±Infinity throw (programmer error); negative
-	* and 0 clamp to 0 for timeouts like the platform, to a 1ms floor for
-	* intervals (a 0ms interval would spin the synchronous advance loop
-	* forever). Finite positive values schedule at their real deadline.
-	*/
-	#delay(ms, method, interval) {
-		if (!Number.isFinite(ms)) throw new RangeError(`[VirtualClock] invalid ${method} ms value: ${ms}`);
-		return ms <= 0 ? interval ? 1 : 0 : ms;
-	}
-	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 + this.#delay(ms, "setTimeout", false),
-			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);
-		const d = this.#delay(ms, "setInterval", true);
-		this.#intervals.set(id, {
-			ms: d,
-			next: this.#now + d,
-			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) {
-		if (!Number.isFinite(ms)) throw new RangeError(`[VirtualClock] invalid advance ms value: ${ms}`);
-		const target = this.#now + Math.max(0, 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();
-	transition = /* @__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);
-	}
-	addTransition(fn) {
-		this.transition.add(fn);
-		return () => this.transition.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);
-	}
-	emitTransition(info) {
-		for (const fn of this.transition) this.#safe(() => fn(info));
-	}
-	clear() {
-		this.change.clear();
-		this.done.clear();
-		this.transition.clear();
-	}
-	#safe(fn) {
-		Either.from(fn);
-	}
-};
-//#endregion
-//#region src/snapshot.ts
-function buildSnapshot(s, regions, context, opts = {}) {
-	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 (opts.payload !== void 0) snap.payload = opts.payload;
-	if (s.isFinal) snap.done = true;
-	if (opts.error !== void 0) snap.error = opts.error;
-	return snap;
-}
-//#endregion
-//#region src/effects.ts
-function runEffects(options) {
-	const 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)) throw new Error(`[Actor] initial state "${initState.name}" not found in declared states [${[...stateNames].join(", ")}]`);
-		this.state = initState;
-		this.#statePayload = options.initial instanceof StateRef ? void 0 : options.initial.payload;
-		this.#context = options.context ?? {};
-		this.#lastState = initState;
-		this.#contextHandle = new Context(() => this.#context, (value) => {
-			this.#context = value;
-			this.#contextWritten = true;
-		});
-		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) throw new Error(result[0].message);
-			this.#children.set(key, child);
-		}
-		this.#runEffects({ type: "__init" }, this.#statePayload);
-		this.#subs.seed(this.snapshot());
-	}
-	on(event, fn) {
-		if (event === "change") {
-			const cb = fn;
-			return this.#subs.addChange(cb);
-		}
-		if (event === "done") {
-			const cb = fn;
-			return this.#subs.addDone(cb);
-		}
-		const cb = fn;
-		return this.#subs.addTransition(cb);
-	}
-	settled() {
-		return Promise.all([this.#queue.settled(), ...this.#pendingEffects]).then(() => void 0);
-	}
-	send(event) {
-		this.#dispatch(event);
-		this.#emitChangeIfDirty();
-	}
-	/**
-	* Manually restore the actor to a live state after a fatal `__error`.
-	* DANGER: the caller supplies state and context, so the trajectory is no
-	* longer deterministic ("same inputs, same trace"). Effects are not re-run
-	* and timers are not re-armed — processing resumes on the next event.
-	*/
-	recover(target) {
-		if (this.#error === null) return;
-		this.#error = null;
-		this.#queue = new InternalQueue();
-		this.#effectAbort = null;
-		this.state = target.state;
-		this.#statePayload = void 0;
-		this.#context = target.context;
-		this.#lastState = target.state;
-		this.#contextWritten = false;
-		this.#entry = null;
-		this.#pendingEffects = [];
-		this.#subs.emitChange(this.snapshot());
-	}
-	#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 normalized = {
-			...event,
-			payload: event.payload ?? {}
-		};
-		const from = this.state.name;
-		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 result = this.#step(normalized, stateTransition, anyTransition);
-			this.#maybeEmitTransition(normalized, from, Boolean(stateTransition || anyTransition), result);
-			if (result.emitted || this.#queue.length > 0) this.#drainInternal();
-			else if (!stateTransition && !anyTransition) {
-				if (this.#internalIds.has(event.type)) this.#enterError("unhandled", event, /* @__PURE__ */ new Error(`[Actor] internal event "${event.type}" emitted but no handler in state "${this.state.name}"`));
-			}
-		} finally {
-			this.#entry = prev;
-		}
-	}
-	#step(normalized, stateTransition, anyTransition) {
-		const stateOutcome = stateTransition ? this.#applyStateStep(normalized, stateTransition) : { applied: false };
-		if (this.#error === null) {
-			const anyOutcome = this.#applyAnyStep(normalized, anyTransition, !stateOutcome.applied);
-			return {
-				emitted: anyOutcome.emitted,
-				transitioned: stateOutcome.applied || anyOutcome.transitioned,
-				target: stateOutcome.target ?? anyOutcome.target
-			};
-		}
-		return {
-			emitted: false,
-			transitioned: false
-		};
-	}
-	#maybeEmitTransition(event, from, handled, outcome) {
-		if (this.#error !== null) return;
-		if (!handled) return;
-		this.#subs.emitTransition({
-			event,
-			from,
-			to: outcome.target ?? this.state.name,
-			transitioned: outcome.transitioned
-		});
-	}
-	#applyStateStep(event, transition) {
-		let applied = false;
-		let target;
-		this.#safe("transition", event, () => {
-			const step = transition(event, {
-				context: this.#contextHandle,
-				actor: this
-			});
-			if (step.emit) this.#queue.push(...step.emit);
-			if (step.state) {
-				target = this.#applyTransition(event, step);
-				applied = true;
-			}
-		});
-		return {
-			applied,
-			target
-		};
-	}
-	#applyAnyStep(event, transition, allowTransition) {
-		if (transition === void 0) return {
-			emitted: false,
-			transitioned: false
-		};
-		let emitted = false;
-		let transitioned = false;
-		let target;
-		this.#safe("transition", event, () => {
-			const step = transition(event, {
-				context: this.#contextHandle,
-				actor: this
-			});
-			if (step.state && allowTransition) {
-				target = this.#applyTransition(event, step);
-				transitioned = true;
-			}
-			if (step.emit) {
-				this.#queue.push(...step.emit);
-				emitted = true;
-			}
-		});
-		return {
-			emitted,
-			transitioned,
-			target
-		};
-	}
-	snapshot() {
-		return buildSnapshot(this.state, this.#regions, this.#context, {
-			error: this.#error ?? void 0,
-			payload: this.#statePayload
-		});
-	}
-	#abortEffects() {
-		this.#effectAbort?.abort();
-		this.#subs.clear();
-	}
-	#applyTransition(event, step) {
-		if (this.#error !== null || !step.state) return void 0;
-		const resolved = parseTarget(step);
-		if (!resolved) return void 0;
-		if (!(resolved.state instanceof StateRef)) {
-			this.#enterError("transition", event, /* @__PURE__ */ new Error("invalid transition target"));
-			return;
-		}
-		this.#effectAbort?.abort();
-		this.state = resolved.state;
-		const target = this.state.name;
-		this.#statePayload = resolved.payload;
-		this.#entry = {
-			state: this.state,
-			context: this.#context
-		};
-		this.#runEffects(event, resolved.payload);
-		if (resolved.state.isFinal && this.#error === null) this.#subs.emitDone();
-		return target;
-	}
-	#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 || abort.signal.aborted) 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();
-		}
-	}
-	#statePayload;
-	#pendingEffects = [];
-	#errorState = new StateRef("__error", true);
-	#error = null;
-	#entry = null;
-	#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.#statePayload = void 0;
-		this.#lastState = this.#errorState;
-		this.#contextWritten = false;
-		this.#subs.emitChange(this.snapshot());
-		this.#subs.emitDone();
-	}
-};
-//#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.2.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-B4iAxUG_.d.mts

@@ -1,152 +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" | "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;
-  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;
-    }>;
-  };
-}
-//#endregion
-export { InternalEvent as _, EffectInput as a, StateRef as b, ErrorState as c, TransitionResult as d, Context as f, EventRef as g, CreatedOfEvent as h, EffectFn as i, NonFinalStateRef as l, AnyEventRef as m, Snapshot as n, ErrorInfo as o, Clock as p, CreatedOf as r, ErrorReason as s, AnyActor as t, TransitionInfo as u, event as v, state as x, AnyStateRef as y };

package/dist/internal.d.mts

@@ -1,26 +0,0 @@
-import { _ as InternalEvent, t as AnyActor } from "./actor-internal-B4iAxUG_.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 };