@typeonce/effect-machine 0.3.0 → 0.5.0

package/dist/internal/machine/runtime.js

@@ -0,0 +1,1489 @@
+/**
+ * Internal machine process runtime helpers.
+ *
+ * @since 0.4.0
+ */
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Option from "effect/Option";
+import * as PubSub from "effect/PubSub";
+import * as Queue from "effect/Queue";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as SynchronizedRef from "effect/SynchronizedRef";
+import { ChildAlreadyExistsError, StoppedError } from "./errors.js";
+/** @internal */
+export const activeSnapshotObserver = Symbol.for("effect/Machine/activeSnapshotObserver");
+/** @internal */
+export const sendParentOverride = Symbol.for("effect/Machine/sendParentOverride");
+/** @internal */
+export const acknowledgedSend = Symbol.for("effect/Machine/acknowledgedSend");
+const AcknowledgedMessageTypeId = Symbol("effect/Machine/AcknowledgedMessage");
+/** @internal */
+export const isAcknowledgedMessage = (message) => typeof message === "object" && message !== null && AcknowledgedMessageTypeId in message;
+/** @internal */
+export const messageEvent = (message) => isAcknowledgedMessage(message) ? message.event : message;
+const succeedAcknowledgedMessage = (message, delivery) => {
+    if (message !== undefined && isAcknowledgedMessage(message)) {
+        Deferred.doneUnsafe(message.deferred, Effect.succeed(delivery));
+    }
+};
+const failAcknowledgedMessage = (message, cause) => {
+    if (message !== undefined && isAcknowledgedMessage(message)) {
+        Deferred.doneUnsafe(message.deferred, Effect.failCause(cause));
+    }
+};
+const stopAcknowledgedMessage = (message) => {
+    if (message !== undefined && isAcknowledgedMessage(message)) {
+        Deferred.doneUnsafe(message.deferred, Effect.fail(new StoppedError()));
+    }
+};
+const offerChildObservation = (observer, value) => {
+    if (observer.values === undefined) {
+        observer.values = [value];
+    }
+    else {
+        observer.values.push(value);
+    }
+    if (observer.waiter !== undefined) {
+        const waiter = observer.waiter;
+        observer.waiter = undefined;
+        Deferred.doneUnsafe(waiter, Effect.void);
+    }
+};
+const takeChildObservations = (observer) => Effect.suspend(() => {
+    if (observer.values !== undefined) {
+        const values = observer.values;
+        observer.values = undefined;
+        return Effect.succeed(values);
+    }
+    const waiter = Deferred.makeUnsafe();
+    observer.waiter = waiter;
+    return Deferred.await(waiter).pipe(Effect.andThen(takeChildObservations(observer)));
+});
+const matchesChild = (entry, child) => entry._tag === "Started" && (typeof child === "string" || (entry.descriptor !== undefined &&
+    entry.descriptor.id === child.id &&
+    entry.descriptor.machine === child.machine));
+const selectRegistryChild = (registry, id, child) => {
+    if (registry.closed)
+        return Option.none();
+    const entry = registry.children.get(id);
+    return entry !== undefined && matchesChild(entry, child) ? Option.some(entry.ref) : Option.none();
+};
+const publishRegistryChange = (registry) => {
+    if (registry.observers === undefined)
+        return;
+    for (const observer of registry.observers) {
+        offerChildObservation(observer, selectRegistryChild(registry, observer.id, observer.child));
+    }
+};
+const unregisterChild = (registry, key, token) => {
+    const entry = registry.children.get(key);
+    if (entry === undefined || entry.token !== token)
+        return;
+    registry.children.delete(key);
+    if (typeof key === "string")
+        publishRegistryChange(registry);
+};
+const registerChild = (registry, key, token, ref, descriptor) => {
+    const entry = registry.children.get(key);
+    if (registry.closed || entry === undefined || entry._tag !== "Starting" || entry.token !== token) {
+        return false;
+    }
+    registry.children.delete(key);
+    const started = entry.ownerKey === undefined
+        ? { _tag: "Started", token, descriptor, ref }
+        : {
+            _tag: "Started",
+            token,
+            descriptor,
+            ref,
+            ownerKey: entry.ownerKey,
+            ownerPath: entry.ownerPath,
+            ownerActive: entry.ownerActive === true
+        };
+    registry.children.set(key, started);
+    if (typeof key === "string")
+        publishRegistryChange(registry);
+    return true;
+};
+const executionIsChildless = (execution) => execution?._tag === "Childless" || execution?.childless === true;
+const offerCompactMailbox = (mailbox, event) => {
+    const items = mailbox.items ?? [];
+    mailbox.items = items;
+    items.push(event);
+};
+const pollCompactMailbox = (mailbox) => {
+    if (mailbox.items === undefined) {
+        return Option.none();
+    }
+    const event = mailbox.items[mailbox.index];
+    mailbox.index += 1;
+    if (mailbox.index === mailbox.items.length) {
+        mailbox.items = undefined;
+        mailbox.index = 0;
+    }
+    return Option.some(event);
+};
+const closeCompactMailbox = (mailbox) => {
+    if (mailbox.items !== undefined) {
+        for (let index = mailbox.index; index < mailbox.items.length; index += 1) {
+            stopAcknowledgedMessage(mailbox.items[index]);
+        }
+    }
+    mailbox.closed = true;
+    mailbox.items = undefined;
+    mailbox.index = 0;
+};
+export class MachineRuntime extends Context.Service()("effect/Machine/MachineRuntime") {
+}
+export const provideMachineRuntime = (effect, scope) => Effect.provideService(effect, MachineRuntime, scope);
+const classifyOutcome = (snapshot) => {
+    switch (snapshot.status) {
+        case "active": {
+            return undefined;
+        }
+        case "done": {
+            return {
+                _tag: "Done",
+                output: snapshot.output,
+                snapshot
+            };
+        }
+        case "error": {
+            const failure = snapshot.cause.reasons.find(Cause.isFailReason);
+            if (failure !== undefined) {
+                return {
+                    _tag: "Failure",
+                    error: failure.error,
+                    cause: snapshot.cause,
+                    snapshot
+                };
+            }
+            const defect = snapshot.cause.reasons.find(Cause.isDieReason);
+            if (defect !== undefined) {
+                return {
+                    _tag: "Defect",
+                    defect: defect.defect,
+                    cause: snapshot.cause,
+                    snapshot
+                };
+            }
+            const interrupted = snapshot.cause.reasons.find(Cause.isInterruptReason);
+            if (interrupted !== undefined) {
+                return {
+                    _tag: "Interrupted",
+                    cause: snapshot.cause,
+                    snapshot
+                };
+            }
+            return {
+                _tag: "Cause",
+                cause: snapshot.cause,
+                snapshot
+            };
+        }
+        case "stopped": {
+            return {
+                _tag: "Stopped",
+                snapshot
+            };
+        }
+    }
+};
+const notifyActiveSnapshot = (onSnapshot, snapshot) => Effect.suspend(() => onSnapshot(snapshot)).pipe(Effect.exit, Effect.asVoid);
+export const watch = (ref) => ref.changes.pipe(Stream.filter((snapshot) => snapshot.status !== "active"), Stream.map((snapshot) => classifyOutcome(snapshot)), Stream.take(1));
+const makeProcessRuntime = Effect.sync(() => {
+    let sessionIdCounter = 0;
+    return {
+        nextSessionId: Effect.sync(() => `machine:${sessionIdCounter++}`)
+    };
+});
+class OwnedChildRuntimeImpl {
+    registry;
+    self;
+    runtime;
+    services;
+    scopedServices;
+    constructor(registry, self, runtime, services) {
+        this.registry = registry;
+        this.self = self;
+        this.runtime = runtime;
+        this.services = services;
+    }
+    has(key) {
+        for (const entry of this.registry.children.values()) {
+            if (entry.ownerActive && entry.ownerKey === key)
+                return true;
+        }
+        return false;
+    }
+    stopEntry(entry) {
+        entry.ownerActive = false;
+        return entry._tag === "Started" ? entry.ref.stop : Effect.void;
+    }
+    spawn(makeLogic, options) {
+        const token = Symbol();
+        let startedChild;
+        const isCurrent = () => {
+            const entry = this.registry.children.get(options.id);
+            return entry?.token === token && entry.ownerKey === options.key && entry.ownerActive === true;
+        };
+        return Effect.suspend(() => {
+            if (this.registry.closed)
+                return Effect.interrupt;
+            if (this.has(options.key) || this.registry.children.has(options.id)) {
+                return Effect.fail(new ChildAlreadyExistsError({ id: options.duplicateId }));
+            }
+            const logic = makeLogic();
+            const scope = this.registry.scope ??= Scope.makeUnsafe("parallel");
+            this.registry.children.set(options.id, {
+                _tag: "Starting",
+                token,
+                ownerKey: options.key,
+                ownerPath: options.path,
+                ownerActive: true
+            });
+            const startOptions = {
+                detached: true,
+                id: options.id,
+                sendParent: (event) => options.sendParent(isCurrent, event),
+                onOutcome: (outcome) => options.onOutcome(isCurrent, outcome),
+                ...(options.onSnapshot === undefined
+                    ? undefined
+                    : { onSnapshot: (snapshot) => options.onSnapshot(isCurrent, snapshot) }),
+                onReadySync: (child) => {
+                    startedChild = child;
+                    return registerChild(this.registry, options.id, token, child, options.descriptor);
+                },
+                onStopSync: () => unregisterChild(this.registry, options.id, token),
+                skipStoppedOutcome: true,
+                parent: this.self,
+                runtime: this.runtime
+            };
+            const execution = logic.execution;
+            const synchronous = this.services !== undefined && options.onSnapshot === undefined &&
+                execution?._tag === "Compiled" && execution.childless && execution.drain._tag === "Owned" &&
+                execution.initialSync !== undefined;
+            const start = synchronous
+                ? Effect.flatMap(this.runtime.nextSessionId, (sessionId) => new CompiledProcess(logic, startOptions, this.scopedServices ??= Context.add(this.services, Scope.Scope, scope), sessionId).initializeCompiledSync())
+                : startLogicInternal(logic, startOptions);
+            const guarded = start.pipe(Effect.onExit((exit) => {
+                if (Exit.isSuccess(exit))
+                    return Effect.void;
+                unregisterChild(this.registry, options.id, token);
+                return startedChild === undefined ? Effect.void : startedChild.stop;
+            }));
+            return (synchronous ? guarded : Scope.provide(guarded, scope)).pipe(Effect.asVoid);
+        });
+    }
+    stopAll() {
+        return Effect.suspend(() => {
+            const effects = [];
+            for (const entry of this.registry.children.values()) {
+                if (entry.ownerActive)
+                    effects.push(this.stopEntry(entry));
+            }
+            return effects.length === 0
+                ? Effect.void
+                : effects.length === 1
+                    ? effects[0]
+                    : Effect.all(effects, { concurrency: "unbounded", discard: true });
+        });
+    }
+    stopPaths(paths) {
+        if (paths.length === 0)
+            return undefined;
+        const pathSet = new Set(paths);
+        const effects = [];
+        for (const entry of this.registry.children.values()) {
+            if (entry.ownerActive && entry.ownerPath !== undefined && pathSet.has(entry.ownerPath)) {
+                effects.push(this.stopEntry(entry));
+            }
+        }
+        return effects.length === 0
+            ? undefined
+            : effects.length === 1
+                ? effects[0]
+                : Effect.all(effects, { concurrency: "unbounded", discard: true });
+    }
+}
+const noChildChanges = Stream.succeed(Option.none()).pipe(Stream.concat(Stream.never));
+const noParentSend = (_event) => Effect.void;
+const childlessRuntime = {
+    close: () => Effect.void,
+    spawn: (() => Effect.die(new Error("Childless machine logic cannot spawn a process"))),
+    get: () => Effect.succeed(Option.none()),
+    changes: () => noChildChanges,
+    sendTo: () => Effect.void,
+    stop: () => Effect.void,
+    owned: {
+        spawn: () => Effect.die(new Error("Childless machine logic cannot spawn an owned process")),
+        stopAll: () => Effect.void,
+        stopPaths: () => undefined
+    }
+};
+const makeChildRuntimeSync = (self, runtime, services) => {
+    // Child-registry decisions are synchronous and every access below runs in
+    // one Effect.sync / Effect.suspend step. Keep the unobserved representation
+    // compact; selector-specific handoffs are installed only while
+    // childChanges streams are running.
+    const registry = {
+        closed: false,
+        children: new Map(),
+        observers: undefined,
+        scope: undefined
+    };
+    const close = (exit) => Effect.suspend(() => {
+        if (registry.closed) {
+            return Effect.void;
+        }
+        registry.closed = true;
+        if (registry.scope === undefined) {
+            return Effect.void;
+        }
+        const finalizers = Scope.closeUnsafe(registry.scope, exit);
+        let first;
+        let rest;
+        for (const entry of registry.children.values()) {
+            if (entry._tag !== "Started") {
+                continue;
+            }
+            if (first === undefined) {
+                first = entry.ref.stop;
+            }
+            else {
+                rest ??= [first];
+                rest.push(entry.ref.stop);
+            }
+        }
+        if (finalizers !== undefined) {
+            if (first === undefined) {
+                first = finalizers;
+            }
+            else {
+                rest ??= [first];
+                rest.push(finalizers);
+            }
+        }
+        const cleanup = rest ?? first;
+        return cleanup === undefined
+            ? Effect.void
+            : Array.isArray(cleanup)
+                ? Effect.all(cleanup, { concurrency: "unbounded", discard: true })
+                : cleanup;
+    });
+    const unregister = (key, token) => Effect.sync(() => unregisterChild(registry, key, token));
+    const register = (key, token, ref, descriptor) => Effect.sync(() => registerChild(registry, key, token, ref, descriptor));
+    const get = (child) => {
+        const id = typeof child === "string" ? child : child.id;
+        return Effect.sync(() => {
+            if (registry.closed) {
+                return Option.none();
+            }
+            const entry = registry.children.get(id);
+            return entry !== undefined && matchesChild(entry, child)
+                ? Option.some(entry.ref)
+                : Option.none();
+        });
+    };
+    const changes = (child) => {
+        const id = typeof child === "string" ? child : child.id;
+        return Stream.fromChannel(Channel.fromTransform((_, streamScope) => Effect.sync(() => ({ child, id, values: undefined, waiter: undefined })).pipe(Effect.flatMap((observer) => {
+            const removeObserver = Effect.sync(() => {
+                if (registry.observers !== undefined) {
+                    registry.observers.delete(observer);
+                    if (registry.observers.size === 0) {
+                        registry.observers = undefined;
+                    }
+                }
+                observer.values = undefined;
+                observer.waiter = undefined;
+            });
+            return Scope.addFinalizer(streamScope, removeObserver).pipe(Effect.andThen(Effect.sync(() => {
+                if (!registry.closed && streamScope.state._tag !== "Closed") {
+                    registry.observers ??= new Set();
+                    registry.observers.add(observer);
+                }
+                offerChildObservation(observer, selectRegistryChild(registry, id, child));
+            })), Effect.as(takeChildObservations(observer)));
+        }))));
+    };
+    const sendTo = (child, event) => {
+        const id = typeof child === "string" ? child : child.id;
+        return Effect.suspend(() => {
+            if (registry.closed) {
+                return Effect.void;
+            }
+            const entry = registry.children.get(id);
+            return entry !== undefined && matchesChild(entry, child)
+                ? entry.ref.send(event)
+                : Effect.void;
+        });
+    };
+    const stop = (child) => {
+        const id = typeof child === "string" ? child : child.id;
+        return Effect.suspend(() => {
+            if (registry.closed) {
+                return Effect.void;
+            }
+            const entry = registry.children.get(id);
+            return entry !== undefined && matchesChild(entry, child)
+                ? entry.ref.stop
+                : Effect.void;
+        });
+    };
+    function spawn(logic, spawnOptions) {
+        const token = Symbol();
+        const key = spawnOptions?.id ?? token;
+        let startedChild;
+        return Effect.suspend(() => {
+            if (registry.closed) {
+                return Effect.interrupt;
+            }
+            if (typeof key === "string" && registry.children.has(key)) {
+                return Effect.fail(new ChildAlreadyExistsError({ id: key }));
+            }
+            registry.scope ??= Scope.makeUnsafe("parallel");
+            registry.children.set(key, { _tag: "Starting", token });
+            return startLogicInternal(logic, {
+                detached: true,
+                ...(spawnOptions?.id === undefined ? undefined : { id: spawnOptions.id }),
+                ...(spawnOptions?.onOutcome === undefined ? undefined : { onOutcome: spawnOptions.onOutcome }),
+                ...(spawnOptions?.[activeSnapshotObserver] === undefined
+                    ? undefined
+                    : { onSnapshot: spawnOptions[activeSnapshotObserver] }),
+                ...(spawnOptions?.[sendParentOverride] === undefined
+                    ? undefined
+                    : { sendParent: spawnOptions[sendParentOverride] }),
+                onReady: (child, requestChildStop) => Effect.sync(() => {
+                    startedChild = child;
+                }).pipe(Effect.andThen(register(key, token, child, spawnOptions?.descriptor)), Effect.flatMap((registered) => registered ? Effect.void : requestChildStop)),
+                onStop: unregister(key, token),
+                parent: self,
+                runtime
+            }).pipe(Effect.onExit((exit) => Exit.isFailure(exit)
+                ? unregister(key, token).pipe(Effect.andThen(startedChild === undefined ? Effect.void : startedChild.stop))
+                : Effect.void), Scope.provide(registry.scope));
+        });
+    }
+    return {
+        close,
+        spawn,
+        get,
+        changes,
+        sendTo,
+        stop,
+        owned: new OwnedChildRuntimeImpl(registry, self, runtime, services)
+    };
+};
+const makeChildRuntime = (self, runtime, services) => Effect.sync(() => makeChildRuntimeSync(self, runtime, services));
+// `Machine.logic` permits an arbitrary Effect program, including programs that
+// suspend or supervise their own fibers. Keep its two-fiber worker/supervisor
+// protocol as the general contract rather than weakening it for statecharts.
+const startGenericInternal = Effect.fnUntraced(function* (logic, options) {
+    const { detached, id: requestedId, onOutcome, onReady, onReadySync, onSnapshot, onStop, onStopSync, parent, runtime, sendParent: overrideSendParent } = options;
+    const sessionId = yield* runtime.nextSessionId;
+    const id = requestedId ?? sessionId;
+    const queue = yield* Queue.unbounded();
+    const termination = yield* Deferred.make();
+    const done = yield* Deferred.make();
+    const awaitCompletion = Deferred.await(done).pipe(Effect.exit, Effect.asVoid);
+    let initializing = true;
+    let inFlightMessage;
+    const requestStop = Deferred.succeed(termination, { _tag: "Stopped" }).pipe(Effect.asVoid);
+    const self = {
+        id,
+        sessionId,
+        // Initialization must finish constructing a state before a stopped
+        // snapshot can be published. A stop requested there is therefore recorded
+        // and returns so initialization can finish. Once running, the requesting
+        // process waits forever and is interrupted by the supervisor after the
+        // stop request wins, so execution never continues after `self.stop`.
+        stop: Effect.suspend(() => initializing
+            ? requestStop
+            : requestStop.pipe(Effect.andThen(Effect.never))),
+        send: (event) => Queue.offer(queue, event).pipe(Effect.flatMap((accepted) => accepted ? Effect.void : Effect.fail(new StoppedError())))
+    };
+    const sendAcknowledged = logic.execution?._tag !== "Compiled"
+        ? undefined
+        : (event) => Effect.uninterruptibleMask((restore) => Deferred.make().pipe(Effect.flatMap((deferred) => Queue.offer(queue, {
+            [AcknowledgedMessageTypeId]: true,
+            event,
+            deferred
+        }).pipe(Effect.flatMap((accepted) => accepted
+            ? restore(Deferred.await(deferred))
+            : Effect.fail(new StoppedError())))), Effect.map((delivery) => delivery)));
+    let { changes: childChanges, close: closeChildren, get: getChild, owned: ownedChildren, sendTo, spawn, stop: stopChild } = childlessRuntime;
+    if (!executionIsChildless(logic.execution)) {
+        ;
+        ({
+            changes: childChanges,
+            close: closeChildren,
+            get: getChild,
+            owned: ownedChildren,
+            sendTo,
+            spawn,
+            stop: stopChild
+        } = yield* makeChildRuntime(self, runtime));
+    }
+    const cleanupStartupFailure = (exit) => Exit.isFailure(exit)
+        ? closeChildren(exit)
+        : Effect.void;
+    const cleanup = onStopSync === undefined ? onStop ?? Effect.void : Effect.sync(onStopSync);
+    const sendParent = overrideSendParent ?? (parent === undefined ? noParentSend : parent.send);
+    const scope = {
+        self,
+        parent,
+        spawn,
+        sendParent,
+        sendTo,
+        stopChild,
+        failCause: (cause) => Deferred.succeed(termination, {
+            _tag: "Failure",
+            cause: cause
+        }).pipe(Effect.asVoid)
+    };
+    const initial = yield* logic.initial(scope).pipe(Effect.onExit(cleanupStartupFailure), Effect.ensuring(Effect.sync(() => {
+        initializing = false;
+    })));
+    const current = yield* SynchronizedRef.make({
+        revision: 0,
+        terminalizing: false,
+        changes: undefined,
+        snapshot: {
+            status: "active",
+            state: initial
+        }
+    });
+    const publishSnapshot = onSnapshot === undefined
+        ? (snapshot) => snapshot.changes === undefined
+            ? Effect.succeed(snapshot)
+            : PubSub.publish(snapshot.changes, [snapshot]).pipe(Effect.as(snapshot))
+        : (snapshot) => {
+            const publish = snapshot.changes === undefined
+                ? Effect.succeed(snapshot)
+                : PubSub.publish(snapshot.changes, [snapshot]).pipe(Effect.as(snapshot));
+            const runtimeSnapshot = snapshot.snapshot;
+            return runtimeSnapshot.status !== "active"
+                ? publish
+                : publish.pipe(Effect.tap(() => notifyActiveSnapshot(onSnapshot, runtimeSnapshot)));
+        };
+    const completeChanges = (snapshot) => snapshot.changes === undefined
+        ? Effect.void
+        : PubSub.publish(snapshot.changes, Exit.succeed(undefined)).pipe(Effect.asVoid);
+    const completeIfTerminal = (snapshot) => {
+        if (snapshot.snapshot.status === "active") {
+            return Effect.succeed(snapshot);
+        }
+        return completeChanges(snapshot).pipe(Effect.as(snapshot));
+    };
+    const publishIfCurrent = (snapshot) => SynchronizedRef.get(current).pipe(Effect.flatMap((currentSnapshot) => currentSnapshot.revision === snapshot.revision
+        ? publishSnapshot(snapshot).pipe(Effect.flatMap(completeIfTerminal))
+        : Effect.succeed(undefined)));
+    const updateSnapshot = (f) => SynchronizedRef.modifyEffect(current, (current) => current.terminalizing
+        ? Effect.succeed([undefined, current])
+        : Effect.map(f(current.snapshot), (next) => {
+            if (next === undefined) {
+                return [undefined, current];
+            }
+            const versioned = {
+                revision: current.revision + 1,
+                snapshot: next,
+                terminalizing: false,
+                changes: current.changes
+            };
+            return [versioned, versioned];
+        })).pipe(Effect.flatMap((versioned) => versioned === undefined ? Effect.succeed(undefined) : publishIfCurrent(versioned)), Effect.map((published) => published?.snapshot));
+    const reserveTerminalSnapshot = (f) => SynchronizedRef.modify(current, (current) => {
+        if (current.terminalizing || current.snapshot.status !== "active") {
+            return [undefined, current];
+        }
+        return [
+            {
+                revision: current.revision + 1,
+                snapshot: f(current.snapshot),
+                terminalizing: true,
+                changes: current.changes
+            },
+            { ...current, terminalizing: true }
+        ];
+    }).pipe(Effect.map((versioned) => versioned?.snapshot));
+    const setAndPublishSnapshot = (snapshot) => SynchronizedRef.updateAndGet(current, (current) => ({
+        revision: current.revision + 1,
+        snapshot,
+        terminalizing: true,
+        changes: current.changes
+    })).pipe(Effect.flatMap(publishSnapshot), Effect.flatMap(completeIfTerminal), Effect.asVoid);
+    const setActiveState = (state) => updateSnapshot((snapshot) => Effect.succeed(snapshot.status === "active"
+        ? {
+            status: "active",
+            state
+        }
+        : undefined)).pipe(Effect.asVoid);
+    const terminalizeWith = (snapshot, exit, completeDone) => {
+        const notifyOutcome = onOutcome === undefined || (snapshot.status === "stopped" && options.skipStoppedOutcome === true)
+            ? Effect.void
+            : Effect.suspend(() => onOutcome(classifyOutcome(snapshot))).pipe(Effect.exit, Effect.asVoid);
+        return Effect.uninterruptible(Effect.sync(() => {
+            while (true) {
+                const pending = Queue.takeUnsafe(queue);
+                if (pending === undefined || Exit.isFailure(pending))
+                    break;
+                stopAcknowledgedMessage(pending.value);
+            }
+        }).pipe(Effect.andThen(Queue.shutdown(queue)), Effect.andThen(closeChildren(exit)), Effect.andThen(setAndPublishSnapshot(snapshot)), Effect.andThen(Effect.sync(() => {
+            if (Exit.isFailure(exit)) {
+                failAcknowledgedMessage(inFlightMessage, exit.cause);
+            }
+            else {
+                stopAcknowledgedMessage(inFlightMessage);
+            }
+            inFlightMessage = undefined;
+        })), Effect.andThen(notifyOutcome), Effect.andThen(cleanup), Effect.andThen(completeDone)));
+    };
+    const reserveStoppedSnapshot = reserveTerminalSnapshot((snapshot) => ({
+        status: "stopped",
+        state: snapshot.state
+    }));
+    const reserveFailureSnapshot = (cause) => reserveTerminalSnapshot((snapshot) => ({
+        status: "error",
+        state: snapshot.state,
+        cause
+    }));
+    const reserveSuccessSnapshot = (output) => reserveTerminalSnapshot((snapshot) => ({
+        status: "done",
+        state: snapshot.state,
+        output
+    }));
+    const terminalizeReservedStop = (snapshot) => {
+        const exit = Exit.void;
+        return terminalizeWith(snapshot, exit, Deferred.fail(done, new StoppedError()));
+    };
+    const terminalizeReservedFailure = (snapshot, cause) => {
+        const exit = Exit.failCause(cause);
+        return terminalizeWith(snapshot, exit, Deferred.failCause(done, cause));
+    };
+    const terminalizeReservedSuccess = (snapshot, output) => {
+        const exit = Exit.succeed(output);
+        return terminalizeWith(snapshot, exit, Deferred.succeed(done, output));
+    };
+    const stop = Effect.uninterruptible(requestStop.pipe(Effect.andThen(awaitCompletion)));
+    const acknowledgedContext = logic.execution?._tag !== "Compiled" ? undefined : {
+        receiveMessage: Queue.take(queue).pipe(Effect.tap((message) => Effect.sync(() => {
+            inFlightMessage = isAcknowledgedMessage(message) ? message : undefined;
+        }))),
+        pollMessage: Queue.poll(queue).pipe(Effect.tap((message) => Effect.sync(() => {
+            if (Option.isSome(message)) {
+                inFlightMessage = isAcknowledgedMessage(message.value) ? message.value : undefined;
+            }
+        }))),
+        completeMessage: (delivery) => {
+            succeedAcknowledgedMessage(inFlightMessage, delivery);
+            inFlightMessage = undefined;
+        }
+    };
+    const context = {
+        ...scope,
+        ...(logic.execution?._tag === "Compiled" && !logic.execution.childless ? { ownedChildren } : undefined),
+        ...acknowledgedContext,
+        receive: Queue.take(queue).pipe(Effect.map(messageEvent)),
+        poll: Queue.poll(queue).pipe(Effect.map(Option.map(messageEvent))),
+        state: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot.state)),
+        setState: setActiveState,
+        updateState: (f) => updateSnapshot((snapshot) => snapshot.status === "active"
+            ? f(snapshot.state).pipe(Effect.map((state) => ({
+                status: "active",
+                state
+            })))
+            : Effect.succeed(undefined)).pipe(Effect.asVoid)
+    };
+    const getOrCreateChanges = SynchronizedRef.modifyEffect(current, (current) => {
+        if (current.snapshot.status !== "active") {
+            return Effect.succeed([undefined, current]);
+        }
+        if (current.changes !== undefined) {
+            return Effect.succeed([current.changes, current]);
+        }
+        return PubSub.unbounded({ replay: 1 }).pipe(Effect.map((changes) => [changes, { ...current, changes }]));
+    });
+    const changesStream = Stream.unwrap(Effect.gen(function* () {
+        const changes = yield* getOrCreateChanges;
+        if (changes === undefined) {
+            return Stream.succeed((yield* SynchronizedRef.get(current)).snapshot);
+        }
+        const subscription = yield* PubSub.subscribe(changes);
+        const captured = yield* SynchronizedRef.get(current);
+        if (captured.snapshot.status !== "active") {
+            return Stream.succeed(captured.snapshot);
+        }
+        return Stream.succeed(captured.snapshot).pipe(Stream.concat(Stream.fromChannel(Channel.fromEffectTake(PubSub.take(subscription))).pipe(Stream.filter((next) => next.revision > captured.revision), Stream.map((next) => next.snapshot))));
+    }));
+    const ref = {
+        id,
+        sessionId,
+        state: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot.state)),
+        snapshot: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot)),
+        changes: changesStream,
+        join: Deferred.await(done),
+        stop,
+        send: self.send,
+        ...(sendAcknowledged === undefined ? undefined : { [acknowledgedSend]: sendAcknowledged }),
+        child: getChild,
+        childChanges
+    };
+    if (onReadySync !== undefined && !onReadySync(ref)) {
+        yield* requestStop;
+    }
+    else if (onReady !== undefined) {
+        yield* onReady(ref, requestStop);
+    }
+    if (onSnapshot !== undefined) {
+        yield* notifyActiveSnapshot(onSnapshot, { status: "active", state: initial });
+    }
+    const reserveTermination = (termination) => {
+        switch (termination._tag) {
+            case "Stopped":
+                return reserveStoppedSnapshot;
+            case "Done":
+                return reserveSuccessSnapshot(termination.output);
+            case "Failure":
+                return reserveFailureSnapshot(termination.cause);
+        }
+    };
+    const completeTermination = (termination, snapshot) => {
+        switch (termination._tag) {
+            case "Stopped":
+                return terminalizeReservedStop(snapshot);
+            case "Done":
+                return terminalizeReservedSuccess(snapshot, termination.output);
+            case "Failure":
+                return terminalizeReservedFailure(snapshot, termination.cause);
+        }
+    };
+    const forkRuntime = (effect) => detached === true
+        ? Effect.forkDetach(effect)
+        : Effect.forkChild(effect);
+    const pendingTermination = yield* Deferred.poll(termination);
+    const worker = Option.isNone(pendingTermination)
+        ? yield* Effect.uninterruptibleMask((restore) => restore(Effect.suspend(() => logic.run(context))).pipe(Effect.exit, Effect.flatMap((exit) => Deferred.succeed(termination, Exit.isFailure(exit)
+            ? { _tag: "Failure", cause: exit.cause }
+            : { _tag: "Done", output: exit.value })))).pipe(forkRuntime)
+        : undefined;
+    // One Deferred arbitrates all terminal causes. The supervisor reserves the
+    // terminal snapshot before interrupting the worker, so worker finalizers
+    // cannot mutate the frozen state. It then waits for those finalizers before
+    // publishing and completing `join` / `stop`.
+    const runFiber = Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+        const requested = Option.isSome(pendingTermination)
+            ? yield* pendingTermination.value
+            : yield* restore(Deferred.await(termination));
+        const snapshot = yield* reserveTermination(requested);
+        if (worker !== undefined) {
+            yield* Fiber.interrupt(worker);
+        }
+        if (snapshot === undefined) {
+            return yield* awaitCompletion;
+        }
+        return yield* completeTermination(requested, snapshot);
+    }));
+    yield* forkRuntime(runFiber);
+    yield* Effect.yieldNow;
+    return ref;
+});
+// Stopping is commonly used only for resource cleanup. Keep that path free of
+// Error stack capture and materialize the typed join failure only if observed.
+const CompiledStoppedCompletion = Symbol("effect/Machine/CompiledStoppedCompletion");
+/**
+ * Compact runtime for compiled statecharts.
+ *
+ * All long-lived state is stored directly on this object. Operations are
+ * implemented by shared prototype methods, and public Effect / Stream values
+ * are materialized only when accessed. Arbitrary process logic continues to
+ * use the general runtime above.
+ */
+class CompiledProcess {
+    logic;
+    options;
+    services;
+    id;
+    sessionId;
+    send;
+    [acknowledgedSend](event) {
+        return this.sendAcknowledgedEffect(event);
+    }
+    mailbox = {
+        items: undefined,
+        index: 0,
+        closed: false
+    };
+    address;
+    childRuntime = childlessRuntime;
+    processScope;
+    processContext;
+    compiledContext;
+    current;
+    /**
+     * `Active` has no terminal payload, `TerminationRequested` owns
+     * `termination` and its optional reserved snapshot, and `Completed` owns
+     * `completion`. `runState` independently tracks worker activity.
+     */
+    lifecycle = "Active";
+    runState = "Initializing";
+    completion;
+    waiter;
+    termination;
+    terminationSnapshot;
+    worker;
+    interruptRequested = false;
+    offerRevision = 0;
+    inFlightMessage;
+    constructor(logic, options, services, sessionId) {
+        this.logic = logic;
+        this.options = options;
+        this.services = services;
+        this.sessionId = sessionId;
+        this.id = options.id ?? sessionId;
+        this.send = (event) => this.offerMessage(event);
+        this.address = {
+            id: this.id,
+            sessionId,
+            stop: Effect.suspend(() => this.stopFromProcess()),
+            send: this.send
+        };
+    }
+    get execution() {
+        return this.logic.execution;
+    }
+    initializeCompiledSync() {
+        if (!this.execution.childless) {
+            this.childRuntime = makeChildRuntimeSync(this.address, this.options.runtime, this.services);
+        }
+        const parent = this.options.parent;
+        const sendParent = this.options.sendParent ?? (parent === undefined ? noParentSend : parent.send);
+        this.processScope = {
+            self: this.address,
+            parent,
+            spawn: this.childRuntime.spawn,
+            sendParent,
+            sendTo: this.childRuntime.sendTo,
+            stopChild: this.childRuntime.stop,
+            failCause: (cause) => this.failCause(cause)
+        };
+        const compiledInitial = this.execution.initialSync;
+        let initialized;
+        try {
+            initialized = compiledInitial(this.processScope);
+        }
+        catch (error) {
+            this.runState = "Idle";
+            return Effect.fail(error);
+        }
+        this.runState = "Idle";
+        this.current = {
+            revision: 0,
+            terminalizing: false,
+            changes: undefined,
+            snapshot: { status: "active", state: initialized.state }
+        };
+        this.compiledContext = new CompiledProcessContextImpl(this.processScope, this.childRuntime.owned, this);
+        if ("executionState" in initialized) {
+            this.compiledContext.executionState = initialized.executionState;
+        }
+        if (this.options.onReadySync !== undefined && !this.options.onReadySync(this)) {
+            this.requestTerminationSync({ _tag: "Stopped" });
+        }
+        if (initialized.done === true && this.lifecycle === "Active") {
+            this.requestTerminationSync({ _tag: "Done", output: initialized.output });
+        }
+        if (initialized.done === false && this.execution.childless &&
+            this.lifecycle === "Active" &&
+            this.mailbox.items === undefined) {
+            return Effect.succeed(this);
+        }
+        this.runState = "Draining";
+        return Effect.provideContext(this.drainRuntime(), this.services).pipe(Effect.as(this));
+    }
+    initialize() {
+        const self = this;
+        return Effect.gen(function* () {
+            if (!self.execution.childless) {
+                self.childRuntime = yield* makeChildRuntime(self.address, self.options.runtime, self.services);
+            }
+            const parent = self.options.parent;
+            const sendParent = self.options.sendParent ?? (parent === undefined ? noParentSend : parent.send);
+            self.processScope = {
+                self: self.address,
+                parent,
+                spawn: self.childRuntime.spawn,
+                sendParent,
+                sendTo: self.childRuntime.sendTo,
+                stopChild: self.childRuntime.stop,
+                failCause: (cause) => self.failCause(cause)
+            };
+            const cleanupStartupFailure = (exit) => Exit.isFailure(exit) ? self.childRuntime.close(exit) : Effect.void;
+            const compiledInitial = self.execution.initial;
+            const initializeEffect = compiledInitial === undefined
+                ? self.logic.initial(self.processScope).pipe(Effect.map((state) => ({ state, done: undefined, output: undefined })))
+                : compiledInitial(self.processScope);
+            const initialized = yield* initializeEffect.pipe(Effect.onExit(cleanupStartupFailure), Effect.ensuring(Effect.sync(() => {
+                self.runState = "Idle";
+            })));
+            const initial = initialized.state;
+            self.current = {
+                revision: 0,
+                terminalizing: false,
+                changes: undefined,
+                snapshot: { status: "active", state: initial }
+            };
+            if (self.execution.drain._tag === "Process") {
+                self.processContext = {
+                    ...self.processScope,
+                    receive: Effect.never,
+                    poll: Effect.sync(() => Option.map(pollCompactMailbox(self.mailbox), messageEvent)),
+                    receiveMessage: Effect.never,
+                    pollMessage: Effect.sync(() => self.pollCompiledMessage()),
+                    completeMessage: (delivery) => self.completeCompiledMessage(delivery),
+                    state: Effect.sync(() => self.current.snapshot.state),
+                    setState: (state) => self.setActiveState(state),
+                    updateState: (f) => self.updateState(f)
+                };
+            }
+            else {
+                self.compiledContext = new CompiledProcessContextImpl(self.processScope, self.childRuntime.owned, self);
+                if ("executionState" in initialized) {
+                    self.compiledContext.executionState = initialized.executionState;
+                }
+            }
+            if (self.options.onReadySync !== undefined && !self.options.onReadySync(self)) {
+                yield* self.requestTermination({ _tag: "Stopped" });
+            }
+            else if (self.options.onReady !== undefined) {
+                yield* self.options.onReady(self, self.requestTermination({ _tag: "Stopped" }).pipe(Effect.asVoid));
+            }
+            if (self.options.onSnapshot !== undefined) {
+                yield* notifyActiveSnapshot(self.options.onSnapshot, { status: "active", state: initial });
+            }
+            if (initialized.done === true && self.lifecycle === "Active") {
+                yield* self.requestTermination({ _tag: "Done", output: initialized.output });
+            }
+            // A compiled machine startup plan has already settled entry actions,
+            // raised events, and eventless transitions. If it is known active and
+            // neither startup hooks nor emitted work queued an event, there is no
+            // first drain to perform. Future sends observe an idle run state and
+            // schedule the ordinary compiled worker.
+            if (initialized.done === false && self.execution.childless &&
+                self.lifecycle === "Active" && self.mailbox.items === undefined) {
+                return self;
+            }
+            self.runState = "Draining";
+            yield* self.drainRuntime();
+            return self;
+        });
+    }
+    get state() {
+        return Effect.sync(() => this.current.snapshot.state);
+    }
+    get snapshot() {
+        return Effect.sync(() => this.current.snapshot);
+    }
+    get changes() {
+        return this.changesStream();
+    }
+    get join() {
+        return Effect.suspend(() => {
+            if (this.lifecycle === "Completed") {
+                return this.resolveCompletion(this.completion);
+            }
+            this.waiter ??= Deferred.makeUnsafe();
+            return Deferred.await(this.waiter);
+        });
+    }
+    get stop() {
+        return Effect.uninterruptible(this.stopEffect());
+    }
+    child(child) {
+        return this.childRuntime.get(child);
+    }
+    childChanges(child) {
+        return this.childRuntime.changes(child);
+    }
+    requestTermination(requested) {
+        return Effect.sync(() => this.requestTerminationSync(requested));
+    }
+    hasTerminationRequest() {
+        return this.lifecycle === "TerminationRequested";
+    }
+    requestTerminationSync(requested) {
+        if (this.lifecycle !== "Active") {
+            return false;
+        }
+        this.lifecycle = "TerminationRequested";
+        this.termination = requested;
+        this.terminationSnapshot = this.reserveTermination(requested);
+        return true;
+    }
+    reserveTermination(requested) {
+        const latest = this.current;
+        if (latest === undefined || latest.terminalizing || latest.snapshot.status !== "active") {
+            return undefined;
+        }
+        const snapshot = requested._tag === "Stopped"
+            ? { status: "stopped", state: latest.snapshot.state }
+            : requested._tag === "Done"
+                ? { status: "done", state: latest.snapshot.state, output: requested.output }
+                : { status: "error", state: latest.snapshot.state, cause: requested.cause };
+        this.current = { ...latest, terminalizing: true };
+        return snapshot;
+    }
+    stopFromProcess() {
+        const request = this.requestTermination({ _tag: "Stopped" }).pipe(Effect.asVoid);
+        return this.runState === "Initializing" ? request : request.pipe(Effect.andThen(Effect.interrupt));
+    }
+    failCause(cause) {
+        const requested = { _tag: "Failure", cause };
+        return this.requestTermination(requested).pipe(Effect.flatMap((accepted) => accepted
+            ? Effect.forkDetach(this.settleRequestedTermination()).pipe(Effect.asVoid)
+            : Effect.void));
+    }
+    sendAcknowledgedEffect(event) {
+        return Effect.uninterruptibleMask((restore) => Deferred.make().pipe(Effect.flatMap((deferred) => this.offerMessage({
+            [AcknowledgedMessageTypeId]: true,
+            event,
+            deferred
+        }).pipe(Effect.andThen(restore(Deferred.await(deferred)))))));
+    }
+    offerMessage(message) {
+        return Effect.uninterruptible(Effect.suspend(() => {
+            if (this.mailbox.closed || this.lifecycle !== "Active") {
+                return Effect.fail(new StoppedError());
+            }
+            offerCompactMailbox(this.mailbox, message);
+            this.offerRevision += 1;
+            if (this.runState === "Draining") {
+                return Effect.void;
+            }
+            this.runState = "Draining";
+            const scheduled = Effect.yieldNow.pipe(Effect.andThen(Effect.provideContext(this.drainRuntime(), this.services)));
+            const fork = this.options.detached === true
+                ? Effect.forkDetach(scheduled, { startImmediately: true })
+                : Effect.forkChild(scheduled, { startImmediately: true });
+            return fork.pipe(Effect.flatMap((fiber) => Effect.sync(() => {
+                this.worker = fiber;
+                if (!this.interruptRequested) {
+                    return false;
+                }
+                this.interruptRequested = false;
+                return true;
+            }).pipe(Effect.flatMap((interrupt) => interrupt ? this.interruptAndFinish(fiber) : Effect.void))), Effect.asVoid);
+        }));
+    }
+    stopEffect() {
+        return Effect.suspend(() => {
+            if (this.lifecycle === "Completed") {
+                return Effect.void;
+            }
+            if (this.finishIdleChildlessStop()) {
+                return Effect.void;
+            }
+            const requested = { _tag: "Stopped" };
+            return this.requestTermination(requested).pipe(Effect.flatMap((accepted) => accepted
+                ? this.settleRequestedTermination()
+                : this.awaitCompletion()));
+        });
+    }
+    finishIdleChildlessStop() {
+        if (!this.execution.childless || this.runState !== "Idle" || this.worker !== undefined ||
+            this.lifecycle !== "Active" ||
+            (this.options.onOutcome !== undefined && this.options.skipStoppedOutcome !== true) ||
+            this.options.onStop !== undefined ||
+            this.current.changes !== undefined ||
+            this.current.terminalizing || this.current.snapshot.status !== "active") {
+            return false;
+        }
+        const snapshot = { status: "stopped", state: this.current.snapshot.state };
+        this.lifecycle = "TerminationRequested";
+        this.termination = { _tag: "Stopped" };
+        this.terminationSnapshot = snapshot;
+        closeCompactMailbox(this.mailbox);
+        this.current = {
+            revision: this.current.revision + 1,
+            terminalizing: true,
+            changes: undefined,
+            snapshot
+        };
+        stopAcknowledgedMessage(this.inFlightMessage);
+        this.inFlightMessage = undefined;
+        this.interruptRequested = false;
+        if (this.compiledContext !== undefined) {
+            this.compiledContext.executionState = undefined;
+        }
+        this.options.onStopSync?.();
+        this.completion = CompiledStoppedCompletion;
+        this.lifecycle = "Completed";
+        if (this.waiter !== undefined) {
+            Deferred.doneUnsafe(this.waiter, this.resolveCompletion(CompiledStoppedCompletion));
+            this.waiter = undefined;
+        }
+        return true;
+    }
+    settleRequestedTermination() {
+        return Effect.suspend(() => {
+            if (this.runState !== "Draining") {
+                return this.finishRequestedTermination();
+            }
+            if (this.worker === undefined) {
+                this.interruptRequested = true;
+                return this.awaitCompletion();
+            }
+            return this.interruptAndFinish(this.worker).pipe(Effect.andThen(this.awaitCompletion()));
+        });
+    }
+    interruptAndFinish(worker) {
+        return Fiber.interrupt(worker).pipe(Effect.andThen(Effect.suspend(() => this.lifecycle !== "Completed"
+            ? this.finishRequestedTermination()
+            : Effect.void)));
+    }
+    awaitCompletion() {
+        return this.lifecycle !== "Completed"
+            ? this.join.pipe(Effect.exit, Effect.asVoid)
+            : Effect.void;
+    }
+    resolveCompletion(completion) {
+        if (completion !== CompiledStoppedCompletion) {
+            return completion;
+        }
+        const stopped = Effect.fail(new StoppedError());
+        this.completion = stopped;
+        return stopped;
+    }
+    drainRuntime() {
+        const self = this;
+        return Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+            let observedRevision = self.offerRevision;
+            while (true) {
+                if (self.hasTerminationRequest()) {
+                    return yield* self.finishRequestedTermination();
+                }
+                const exit = yield* restore(Effect.suspend(() => {
+                    const drain = self.execution.drain;
+                    return drain._tag === "Process"
+                        ? drain.run(self.processContext)
+                        : drain.run(self.compiledContext);
+                })).pipe(Effect.exit);
+                self.flushPendingChanges();
+                if (Exit.isFailure(exit)) {
+                    if (self.lifecycle === "Active") {
+                        yield* self.requestTermination({ _tag: "Failure", cause: exit.cause });
+                    }
+                    return yield* self.finishRequestedTermination();
+                }
+                if (Option.isSome(exit.value)) {
+                    yield* self.requestTermination({ _tag: "Done", output: exit.value.value });
+                    return yield* self.finishRequestedTermination();
+                }
+                if (self.hasTerminationRequest()) {
+                    return yield* self.finishRequestedTermination();
+                }
+                if (self.offerRevision !== observedRevision) {
+                    observedRevision = self.offerRevision;
+                    continue;
+                }
+                self.runState = "Idle";
+                self.worker = undefined;
+                return;
+            }
+        }));
+    }
+    finishRequestedTermination() {
+        return Effect.suspend(() => {
+            if (this.lifecycle !== "TerminationRequested") {
+                return Effect.void;
+            }
+            const requested = this.termination;
+            if (requested === undefined) {
+                return Effect.void;
+            }
+            const snapshot = this.terminationSnapshot ?? this.reserveTermination(requested);
+            if (snapshot === undefined) {
+                return this.awaitCompletion();
+            }
+            const exit = requested._tag === "Stopped"
+                ? Exit.void
+                : requested._tag === "Done"
+                    ? Exit.succeed(requested.output)
+                    : Exit.failCause(requested.cause);
+            const completion = requested._tag === "Stopped"
+                ? CompiledStoppedCompletion
+                : requested._tag === "Done"
+                    ? Effect.succeed(requested.output)
+                    : Effect.failCause(requested.cause);
+            const notifyOutcome = this.options.onOutcome === undefined ||
+                (requested._tag === "Stopped" && this.options.skipStoppedOutcome === true)
+                ? Effect.void
+                : Effect.suspend(() => this.options.onOutcome(classifyOutcome(snapshot))).pipe(Effect.exit, Effect.asVoid);
+            return Effect.uninterruptible(Effect.sync(() => {
+                closeCompactMailbox(this.mailbox);
+            }).pipe(Effect.andThen(this.childRuntime.close(exit)), Effect.andThen(this.setAndPublishSnapshot(snapshot)), Effect.andThen(Effect.sync(() => {
+                if (requested._tag === "Failure") {
+                    failAcknowledgedMessage(this.inFlightMessage, requested.cause);
+                }
+                else {
+                    stopAcknowledgedMessage(this.inFlightMessage);
+                }
+                this.inFlightMessage = undefined;
+            })), Effect.andThen(notifyOutcome), Effect.andThen(this.options.onStop ?? Effect.void), Effect.andThen(Effect.sync(() => {
+                this.options.onStopSync?.();
+                this.runState = "Idle";
+                this.worker = undefined;
+                this.interruptRequested = false;
+                if (this.compiledContext !== undefined) {
+                    this.compiledContext.executionState = undefined;
+                }
+                this.completion = completion;
+                this.lifecycle = "Completed";
+                if (this.waiter !== undefined) {
+                    Deferred.doneUnsafe(this.waiter, this.resolveCompletion(completion));
+                    this.waiter = undefined;
+                }
+            }))));
+        });
+    }
+    publishSnapshot(snapshot) {
+        const publish = snapshot.changes === undefined
+            ? Effect.succeed(snapshot)
+            : PubSub.publish(snapshot.changes, [snapshot]).pipe(Effect.as(snapshot));
+        const current = snapshot.snapshot;
+        return this.options.onSnapshot === undefined || current.status !== "active"
+            ? publish
+            : publish.pipe(Effect.tap(() => notifyActiveSnapshot(this.options.onSnapshot, current)));
+    }
+    completeChanges(snapshot) {
+        return snapshot.changes === undefined
+            ? Effect.void
+            : PubSub.publish(snapshot.changes, Exit.succeed(undefined)).pipe(Effect.asVoid);
+    }
+    setAndPublishSnapshot(snapshot) {
+        return Effect.suspend(() => {
+            this.flushPendingChanges();
+            const versioned = {
+                revision: this.current.revision + 1,
+                snapshot,
+                terminalizing: true,
+                changes: this.current.changes
+            };
+            this.current = versioned;
+            return this.publishSnapshot(versioned).pipe(Effect.flatMap((published) => this.completeChanges(published)), Effect.asVoid);
+        });
+    }
+    setActiveState(state) {
+        return Effect.suspend(() => this.commitActiveState(state) ?? Effect.void);
+    }
+    pollCompiledMessage() {
+        const message = pollCompactMailbox(this.mailbox);
+        if (Option.isSome(message)) {
+            this.inFlightMessage = isAcknowledgedMessage(message.value) ? message.value : undefined;
+        }
+        return message;
+    }
+    completeCompiledMessage(delivery) {
+        succeedAcknowledgedMessage(this.inFlightMessage, delivery);
+        this.inFlightMessage = undefined;
+    }
+    compiledState() {
+        return this.current.snapshot.state;
+    }
+    commitCompiledState(state) {
+        return this.commitActiveState(state, true);
+    }
+    commitActiveState(state, batchChanges = false) {
+        const latest = this.current;
+        if (latest.terminalizing || latest.snapshot.status !== "active") {
+            return undefined;
+        }
+        const pendingChanges = latest.pendingChanges;
+        if (pendingChanges !== undefined) {
+            latest.pendingChanges = undefined;
+        }
+        const activeSnapshot = { status: "active", state };
+        const versioned = {
+            revision: latest.revision + 1,
+            snapshot: activeSnapshot,
+            terminalizing: false,
+            changes: latest.changes
+        };
+        this.current = versioned;
+        if (versioned.changes !== undefined) {
+            if (pendingChanges === undefined) {
+                if (batchChanges) {
+                    versioned.pendingChanges = [versioned];
+                }
+                else {
+                    PubSub.publishUnsafe(versioned.changes, [versioned]);
+                }
+            }
+            else {
+                pendingChanges.push(versioned);
+                if (batchChanges) {
+                    versioned.pendingChanges = pendingChanges;
+                }
+                else {
+                    PubSub.publishUnsafe(versioned.changes, pendingChanges);
+                }
+            }
+        }
+        return this.options.onSnapshot === undefined
+            ? undefined
+            : notifyActiveSnapshot(this.options.onSnapshot, activeSnapshot);
+    }
+    flushPendingChanges() {
+        const current = this.current;
+        const pendingChanges = current?.pendingChanges;
+        if (pendingChanges === undefined || current.changes === undefined) {
+            return;
+        }
+        current.pendingChanges = undefined;
+        PubSub.publishUnsafe(current.changes, pendingChanges);
+    }
+    updateState(f) {
+        return Effect.suspend(() => {
+            const observed = this.current;
+            if (observed.terminalizing || observed.snapshot.status !== "active") {
+                return Effect.void;
+            }
+            return f(observed.snapshot.state).pipe(Effect.flatMap((state) => {
+                const latest = this.current;
+                return latest.terminalizing || latest.revision !== observed.revision
+                    ? Effect.void
+                    : this.setActiveState(state);
+            }));
+        });
+    }
+    getOrCreateChanges() {
+        return Effect.suspend(() => {
+            const observed = this.current;
+            if (observed.snapshot.status !== "active") {
+                return Effect.succeed(undefined);
+            }
+            if (observed.changes !== undefined) {
+                return Effect.succeed(observed.changes);
+            }
+            return PubSub.unbounded({ replay: 1 }).pipe(Effect.flatMap((candidate) => Effect.sync(() => {
+                const latest = this.current;
+                if (latest.snapshot.status !== "active") {
+                    return [undefined, true];
+                }
+                if (latest.changes !== undefined) {
+                    return [latest.changes, true];
+                }
+                this.current = { ...latest, changes: candidate };
+                return [candidate, false];
+            }).pipe(Effect.flatMap(([changes, discard]) => discard ? PubSub.shutdown(candidate).pipe(Effect.as(changes)) : Effect.succeed(changes)))));
+        });
+    }
+    changesStream() {
+        const self = this;
+        return Stream.unwrap(Effect.gen(function* () {
+            const changes = yield* self.getOrCreateChanges();
+            if (changes === undefined) {
+                return Stream.succeed(self.current.snapshot);
+            }
+            const subscription = yield* PubSub.subscribe(changes);
+            const captured = self.current;
+            if (captured.snapshot.status !== "active") {
+                return Stream.succeed(captured.snapshot);
+            }
+            return Stream.succeed(captured.snapshot).pipe(Stream.concat(Stream.fromChannel(Channel.fromEffectTake(PubSub.take(subscription))).pipe(Stream.filter((next) => next.revision > captured.revision), Stream.map((next) => next.snapshot))));
+        }));
+    }
+}
+class CompiledProcessContextImpl {
+    scope;
+    ownedChildren;
+    process;
+    executionState;
+    constructor(scope, ownedChildren, process) {
+        this.scope = scope;
+        this.ownedChildren = ownedChildren;
+        this.process = process;
+    }
+    poll() {
+        return Option.map(this.process.pollCompiledMessage(), messageEvent);
+    }
+    pollMessage() {
+        return this.process.pollCompiledMessage();
+    }
+    state() {
+        return this.process.compiledState();
+    }
+    completeMessage(delivery) {
+        this.process.completeCompiledMessage(delivery);
+    }
+    commit(state) {
+        return this.process.commitCompiledState(state);
+    }
+    runAfterChanges(effect) {
+        this.process.flushPendingChanges();
+        return effect;
+    }
+}
+const startCompactCompiledInternal = Effect.fnUntraced(function* (logic, options) {
+    const sessionId = yield* options.runtime.nextSessionId;
+    const services = yield* Effect.context();
+    const execution = logic.execution;
+    const process = new CompiledProcess(logic, options, services, sessionId);
+    // A compiled initializer is synchronous by construction. Only startup
+    // callbacks that themselves return Effects need the generic initialization
+    // program; the compiled drain is still provided the complete service context.
+    return yield* execution.initialSync !== undefined &&
+        options.onReady === undefined && options.onSnapshot === undefined
+        ? process.initializeCompiledSync()
+        : process.initialize();
+});
+const startLogicInternal = ((logic, options) => logic.execution?._tag === "Compiled"
+    ? startCompactCompiledInternal(logic, options)
+    : startGenericInternal(logic, options));
+const startProcessWithStrategy = Effect.fnUntraced(function* (logic, strategy, options) {
+    const runtime = yield* makeProcessRuntime;
+    const internalOptions = options === undefined
+        ? {
+            detached: true,
+            runtime
+        }
+        : {
+            ...options,
+            detached: true,
+            runtime
+        };
+    if (strategy === "generic") {
+        return yield* startGenericInternal(logic, internalOptions);
+    }
+    if (strategy === "compiled") {
+        if (logic.execution?._tag !== "Compiled") {
+            return yield* Effect.die(new Error("Machine cannot force the compiled runtime for generic process logic"));
+        }
+        return yield* startCompactCompiledInternal(logic, internalOptions);
+    }
+    return yield* startLogicInternal(logic, internalOptions);
+});
+/** @internal Test-only startup strategy selection. */
+export const startProcessWithStrategyForTesting = (logic, strategy, options) => startProcessWithStrategy(logic, strategy, options);
+export const startProcess = Effect.fnUntraced(function* (logic, options) {
+    const runtime = yield* makeProcessRuntime;
+    return yield* startLogicInternal(logic, options === undefined
+        ? {
+            detached: true,
+            runtime
+        }
+        : {
+            ...options,
+            detached: true,
+            runtime
+        });
+});
+//# sourceMappingURL=runtime.js.map