@typeonce/effect-machine 0.2.0 → 0.4.0

package/dist/Machine.js

@@ -3,16 +3,9 @@
  *
  * @since 4.0.0
  */
-import * as Effect from "effect/Effect";
-import * as Inspectable from "effect/Inspectable";
-import * as Option from "effect/Option";
-import { Prototype as PipeablePrototype } from "effect/Pipeable";
 import { hasProperty } from "effect/Predicate";
-import { ProcessLocalError as ProcessLocalErrorValue } from "./internal/machineErrors.js";
-import * as Model from "./internal/machineModel.js";
-import * as internalPlanner from "./internal/machinePlanner.js";
-import * as internalProcess from "./internal/machineProcess.js";
-import * as internalRuntime from "./internal/machineRuntime.js";
+import * as internal from "./internal/machine/machine.js";
+import { InitialEventTypeId } from "./internal/machine/machine.js";
 /**
  * Runtime type identifier attached to `Machine` values.
  *
@@ -27,14 +20,14 @@ export const TypeId = "~effect/Machine";
  * @category type IDs
  * @since 4.0.0
  */
-export const InitialEventTypeId = internalPlanner.InitialEventTypeId;
+export { InitialEventTypeId };
 /**
  * Synthetic event value used while the machine settles its initial state.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const InitialEvent = internalPlanner.InitialEvent;
+export const InitialEvent = { _tag: InitialEventTypeId };
 /**
  * Returns `true` if a value is the synthetic machine initial event.
  *
@@ -98,252 +91,29 @@ StartupError,
  * @category errors
  * @since 4.0.0
  */
-StoppedError } from "./internal/machineErrors.js";
+StoppedError } from "./internal/machine/machine.js";
 const RuntimeRequirementTypeId = "~effect/Machine/RuntimeRequirement";
 const ActionRequirementTypeId = "~effect/Machine/ActionRequirement";
-const RuntimeCompatibilityErrorTypeId = "~effect/Machine/RuntimeCompatibilityError";
-const InvokeTypeId = Symbol.for("effect/Machine/Invoke");
-const SnapshotBuilderStateTypeId = Symbol("effect/Machine/SnapshotBuilderState");
+const InvokeTypeId = internal.InvokeTypeId;
+const SnapshotBuilderStateTypeId = internal.SnapshotBuilderStateTypeId;
+const SnapshotBuilderConstructionTypeId = Symbol("effect/Machine/SnapshotBuilderConstruction");
 const ChildAddressTypeId = "~effect/Machine/ChildAddress";
 const ChildAddressCompatibilityErrorTypeId = "~effect/Machine/ChildAddressCompatibilityError";
 const ChildMachineTypeId = "~effect/Machine/ChildMachine";
-const Proto = {
-    ...Inspectable.BaseProto,
-    ...PipeablePrototype,
-    [TypeId]: TypeId,
-    toJSON() {
-        return {
-            _id: "Machine"
-        };
-    }
-};
-const cloneWithHandlers = (self, handlers) => {
-    const machine = Object.create(Proto);
-    machine.states = self.states;
-    machine.events = self.events;
-    machine.internalEvents = self.internalEvents;
-    machine.emits = self.emits;
-    machine.input = self.input;
-    machine.id = self.id;
-    machine.initial = self.initial;
-    machine.stateNodes = self.stateNodes;
-    machine.makeTargetBuilder = self.makeTargetBuilder;
-    machine.handlers = handlers;
-    machine.handle = makeHandle(machine);
-    Model.copyProtocol(self, machine);
-    return machine;
-};
-const flattenHandlers = (handlers, states, prefix, config) => {
-    for (const key of Object.keys(config)) {
-        const path = prefix === "" ? key : `${prefix}.${key}`;
-        if (!hasProperty(states, key)) {
-            throw new Error(`Machine received handler for unknown state "${path}"`);
-        }
-        const nodeConfig = config[key];
-        if (typeof nodeConfig !== "object" || nodeConfig === null) {
-            throw new Error(`Machine expected state "${path}" handler to be an object`);
-        }
-        const { states: childConfig, ...stateConfig } = nodeConfig;
-        handlers[path] = stateConfig;
-        if (childConfig !== undefined) {
-            const node = Model.getStateNodeDefinition(path, states[key]);
-            if (node.states === undefined) {
-                throw new Error(`Machine expected state "${path}" to declare child states`);
-            }
-            if (typeof childConfig !== "object" || childConfig === null) {
-                throw new Error(`Machine expected state "${path}" child handlers to be an object`);
-            }
-            flattenHandlers(handlers, node.states, path, childConfig);
-        }
-    }
-};
-const makeHandle = (self) => ((config) => {
-    const handlers = Object.assign(Object.create(null), self.handlers);
-    flattenHandlers(handlers, self.states, "", config);
-    return cloneWithHandlers(self, handlers);
-});
 /**
  * Returns `true` if a value is a `Machine`.
  *
  * @category guards
  * @since 4.0.0
  */
-export const isMachine = (u) => hasProperty(u, TypeId);
+export const isMachine = internal.isMachine;
 /**
  * Returns `true` if a state snapshot is final for a machine.
  *
  * @category guards
  * @since 4.0.0
  */
-export const isFinal = (machine, state) => internalPlanner.isFinal(machine, state);
-const makeSnapshotBuilder = (states, options) => {
-    const builder = {};
-    for (const key of Object.keys(states)) {
-        builder[key] = (value, selector) => makeSnapshotForNode(states[key], key, value, selector, options);
-    }
-    return builder;
-};
-const makeParallelSnapshotBuilder = (states, options, regions) => {
-    const builder = {};
-    Object.defineProperty(builder, SnapshotBuilderStateTypeId, {
-        value: regions,
-        enumerable: false
-    });
-    for (const key of Object.keys(states)) {
-        if (hasProperty(regions, key)) {
-            continue;
-        }
-        builder[key] = (value, selector) => {
-            const nextRegions = {};
-            for (const regionKey of Object.keys(regions)) {
-                nextRegions[regionKey] = regions[regionKey];
-            }
-            nextRegions[key] = makeSnapshotForNode(states[key], key, value, selector, options);
-            return makeParallelSnapshotBuilder(states, options, nextRegions);
-        };
-    }
-    return builder;
-};
-const getParallelSnapshotBuilderRegions = (path, states, builder) => {
-    if (typeof builder !== "object" || builder === null || !hasProperty(builder, SnapshotBuilderStateTypeId)) {
-        throw new Error(`Machine expected parallel state "${path}" builder callback to return a builder`);
-    }
-    const regions = builder[SnapshotBuilderStateTypeId];
-    for (const key of Object.keys(states)) {
-        if (!hasProperty(regions, key)) {
-            throw new Error(`Machine expected parallel state "${path}" builder callback to provide region "${key}"`);
-        }
-    }
-    return regions;
-};
-const makeSnapshotForNode = (definition, key, value, selector, options) => {
-    const path = options.prefix === "" ? key : `${options.prefix}.${key}`;
-    const node = Model.getStateNodeDefinition(path, definition);
-    const snapshot = {
-        path,
-        value
-    };
-    if (node.states === undefined) {
-        return snapshot;
-    }
-    if (selector === undefined) {
-        throw new Error(`Machine expected state "${path}" builder to provide active child states`);
-    }
-    if (node.type === "parallel") {
-        const builder = makeParallelSnapshotBuilder(node.states, { ...options, prefix: path }, {});
-        snapshot.states = getParallelSnapshotBuilderRegions(path, node.states, selector(builder));
-        return snapshot;
-    }
-    const childStates = options.mode === "initial" && node.initial !== undefined
-        ? { [node.initial]: node.states[node.initial] }
-        : node.states;
-    snapshot.state = selector(makeSnapshotBuilder(childStates, { ...options, prefix: path }));
-    return snapshot;
-};
-const getTargetBuilderNode = (stateNodes, path) => {
-    const node = stateNodes.byPath.get(path);
-    if (node === undefined) {
-        throw new Error(`Machine expected state path "${path}" to exist`);
-    }
-    return node;
-};
-const getLocalTargetScope = (stateNodes, source) => {
-    let current = source;
-    while (current !== undefined) {
-        const node = stateNodes.byPath.get(current);
-        if (node === undefined) {
-            return undefined;
-        }
-        if (node.type === "compound") {
-            return node.path;
-        }
-        current = node.parent;
-    }
-    return undefined;
-};
-const hasTargetValues = (values) => values !== undefined && Object.keys(values).length > 0;
-const makeTargetWithValues = (path, value, values) => hasTargetValues(values)
-    ? Model.makeTarget(path, value, { values: values })
-    : Model.makeTarget(path, value);
-const extendTargetValues = (values, path, value) => {
-    const next = {};
-    if (values !== undefined) {
-        for (const key of Object.keys(values)) {
-            next[key] = values[key];
-        }
-    }
-    next[path] = value;
-    return next;
-};
-const makeLocalTargetChildBuilder = (stateNodes, parentPath, values) => {
-    const parent = getTargetBuilderNode(stateNodes, parentPath);
-    const builder = {};
-    for (const childPath of parent.children) {
-        const child = getTargetBuilderNode(stateNodes, childPath);
-        builder[child.key] = (value, selector) => {
-            if (child.type === "atomic" || child.type === "final") {
-                return makeTargetWithValues(child.path, value, values);
-            }
-            if (selector === undefined) {
-                throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`);
-            }
-            return selector(makeLocalTargetChildBuilder(stateNodes, child.path, extendTargetValues(values, child.path, value)));
-        };
-    }
-    return builder;
-};
-const makeLocalTargetBuilder = (stateNodes, source) => {
-    const scope = getLocalTargetScope(stateNodes, source);
-    if (scope === undefined) {
-        return {};
-    }
-    const builder = makeLocalTargetChildBuilder(stateNodes, scope, undefined);
-    builder.with = (value, selector) => {
-        if (selector === undefined) {
-            throw new Error(`Machine expected target "${scope}" builder to provide an active child state`);
-        }
-        return selector(makeLocalTargetChildBuilder(stateNodes, scope, { [scope]: value }));
-    };
-    return builder;
-};
-const addBranchTargetChildren = (builder, stateNodes, parentPath, values) => {
-    const parent = getTargetBuilderNode(stateNodes, parentPath);
-    for (const childPath of parent.children) {
-        const child = getTargetBuilderNode(stateNodes, childPath);
-        builder[child.key] = makeBranchTargetNodeBuilder(stateNodes, child.path, values);
-    }
-};
-const makeBranchTargetNodeBuilder = (stateNodes, path, values) => {
-    const node = getTargetBuilderNode(stateNodes, path);
-    if (node.type === "atomic" || node.type === "final") {
-        return (value) => makeTargetWithValues(node.path, value, values);
-    }
-    const builder = ((value, selector) => {
-        if (selector === undefined) {
-            throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`);
-        }
-        const nextBuilder = {};
-        addBranchTargetChildren(nextBuilder, stateNodes, node.path, extendTargetValues(values, node.path, value));
-        return selector(nextBuilder);
-    });
-    addBranchTargetChildren(builder, stateNodes, node.path, values);
-    return builder;
-};
-const makeBranchTargetBuilder = (stateNodes, source) => {
-    const rootPath = source.split(".")[0];
-    const root = getTargetBuilderNode(stateNodes, rootPath);
-    return {
-        [root.key]: makeBranchTargetNodeBuilder(stateNodes, root.path, undefined)
-    };
-};
-const makeTargetBuilder = (states, stateNodes) => {
-    const full = makeSnapshotBuilder(states, { mode: "full", prefix: "" });
-    return (source) => ({
-        local: makeLocalTargetBuilder(stateNodes, source),
-        branch: makeBranchTargetBuilder(stateNodes, source),
-        full
-    });
-};
+export const isFinal = internal.isFinal;
 /**
  * Defines a state tree while preserving literal state paths.
  *
@@ -371,24 +141,14 @@ const makeTargetBuilder = (states, stateNodes) => {
  * Machine.make({
  *   states: States.states,
  *   events: [],
- *   initial: () => States.initial.idle(new Idle({}))
+ *   initial: () => States.initial.idle.from()
  * })
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export const defineStates = (states, ..._validation) => ({
-    states: states,
-    initial: makeSnapshotBuilder(states, { mode: "initial", prefix: "" }),
-    get: ((snapshot, path) => Model.getSnapshotByPath(snapshot, path).pipe(Option.map((snapshot) => snapshot.value))),
-    getWithParents: ((snapshot, path) => {
-        const parents = {};
-        return Model.getSnapshotByPath(snapshot, path, parents).pipe(Option.map((snapshot) => ({ value: snapshot.value, parents })));
-    }),
-    getSnapshot: Model.getSnapshotByPath,
-    matches: (snapshot, path) => Option.isSome(Model.getSnapshotByPath(snapshot, path))
-});
+export const defineStates = internal.defineStates;
 /**
  * Creates a schema-first machine definition.
  *
@@ -439,22 +199,33 @@ export const defineStates = (states, ..._validation) => ({
  * @category constructors
  * @since 4.0.0
  */
-export const make = (config, ..._validation) => {
-    const self = Object.create(Proto);
-    self.states = config.states;
-    self.events = config.events;
-    self.internalEvents = config.internalEvents ?? [];
-    self.emits = config.emits ?? [];
-    self.input = config.input;
-    self.id = config.id;
-    self.initial = config.initial;
-    self.stateNodes = Model.compileStateNodes(config.states);
-    self.makeTargetBuilder = makeTargetBuilder(config.states, self.stateNodes);
-    self.handlers = Object.create(null);
-    self.handle = makeHandle(self);
-    Model.setProtocol(self);
-    return self;
-};
+export const make = internal.make;
+/**
+ * Constructs an event from a schema owned by a machine's protocol.
+ *
+ * **Details**
+ *
+ * The schema constructor runs exactly once. The resulting decoded event is
+ * trusted by this machine and definitions derived from it with `handle`, so
+ * repeated delivery does not decode the same already-constructed value again.
+ * Events supplied through ordinary `send` and `plan` calls remain untrusted
+ * and continue through full runtime schema validation.
+ * Treat the returned event as immutable after construction.
+ *
+ * The schema must be one of the machine's configured public or internal event
+ * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * const increment = Machine.event(counter, Increment, { by: 1 })
+ * yield* ref.send(increment)
+ * ```
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const event = internal.event;
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -482,7 +253,7 @@ export const make = (config, ..._validation) => {
  * @category encoding
  * @since 4.0.0
  */
-export const encodeSnapshot = Model.encodeSnapshot;
+export const encodeSnapshot = internal.encodeSnapshot;
 /**
  * Decodes a normalized data representation into a validated machine snapshot.
  *
@@ -506,7 +277,7 @@ export const encodeSnapshot = Model.encodeSnapshot;
  * @category decoding
  * @since 4.0.0
  */
-export const decodeSnapshot = Model.decodeSnapshot;
+export const decodeSnapshot = internal.decodeSnapshot;
 /**
  * Creates an invoked child process configuration for an active state.
  *
@@ -550,7 +321,7 @@ export const decodeSnapshot = Model.decodeSnapshot;
  * @category constructors
  * @since 4.0.0
  */
-export const invoke = (config) => ({ ...config, [InvokeTypeId]: undefined });
+export const invoke = internal.invoke;
 /**
  * Invokes one Effect and maps its typed outcome into machine-local events.
  *
@@ -569,15 +340,7 @@ export const invoke = (config) => ({ ...config, [InvokeTypeId]: undefined });
  * @category constructors
  * @since 4.0.0
  */
-export const invokeEffect = (config) => ((config) => invoke({
-    id: config.id,
-    src: () => effect(config.onFailure === undefined
-        ? Effect.map(config.effect, config.onSuccess)
-        : Effect.matchEffect(config.effect, {
-            onFailure: (error) => Effect.succeed(config.onFailure(error)),
-            onSuccess: (value) => Effect.succeed(config.onSuccess(value))
-        }))
-}))(config);
+export const invokeEffect = internal.invokeEffect;
 /**
  * Creates a cancellable state-scoped delayed event.
  *
@@ -588,10 +351,7 @@ export const invokeEffect = (config) => ((config) => invoke({
  * @category constructors
  * @since 4.0.0
  */
-export const after = (duration, event, options) => invoke({
-    id: options?.id ?? `Machine.after:${String(event._tag)}`,
-    src: () => effect(Effect.as(Effect.sleep(duration), event))
-});
+export const after = internal.after;
 /**
  * Constructs another tagged case from compatible source fields.
  *
@@ -605,10 +365,7 @@ export const after = (duration, event, options) => invoke({
  * @category constructors
  * @since 4.0.0
  */
-export const retag = (target, source, ...args) => {
-    const { _tag: _, ...fields } = source;
-    return target.make({ ...fields, ...(args[0] ?? {}) });
-};
+export const retag = internal.retag;
 /**
  * Creates an invoked child process from a complete statechart machine.
  *
@@ -634,153 +391,118 @@ export const retag = (target, source, ...args) => {
  * @category constructors
  * @since 4.0.0
  */
-export const invokeMachine = ((config) => {
-    const machine = config.child.machine;
-    return {
-        id: config.child.id,
-        address: config.child.id,
-        descriptor: config.child,
-        src: () => machine.input === undefined
-            ? internalProcess.toProcessLogic(machine)
-            : internalProcess.toProcessLogic(machine, config.input),
-        snapshot: config.snapshot,
-        onDone: config.onDone,
-        [InvokeTypeId]: undefined
-    };
-});
+export const invokeMachine = internal.invokeMachine;
 /**
- * Plans the initial state for a machine without running deferred actions.
+ * Plans the initial state for a machine without executing actor commands.
  *
  * **Details**
  *
- * The returned plan contains the settled initial snapshot, staged actions,
- * emitted events, and optional final output. Planning may evaluate transition
- * logic and follow completion, eventless, and raised-event steps, but it does
- * not execute effects passed to `action`.
+ * The returned plan contains the settled initial snapshot, actor commands,
+ * emitted events, optional final output, and every startup microstep. Planning
+ * may evaluate transition logic and follow completion, eventless, and
+ * raised-event steps. Transition callbacks are evaluated synchronously.
+ * `startingState` and `initialEntryPaths` describe the normalized
+ * configuration before entry callbacks and settlement begin.
  *
  * **Gotchas**
  *
- * Callers that execute a plan manually must run actions sequentially before
- * publishing its state or delivering its emitted events. `start` performs this
- * protocol automatically.
+ * `start` executes the closed command list as part of the managed actor commit
+ * protocol. Manual planners may inspect commands but need a running actor scope
+ * to execute child-addressed operations.
  *
  * @see {@link plan} for planning a received event.
  * @see {@link start} for the managed runtime protocol.
  * @category constructors
  * @since 4.0.0
  */
-export const planInitial = internalPlanner.planInitial;
+export const planInitial = internal.planInitial;
 /**
- * Returns the event tags handled by the current state snapshot.
+ * Returns every compiled state node in definition order.
+ *
+ * **Details**
+ *
+ * The result includes atomic, compound, parallel, final, history, and choice
+ * nodes together with their resolved descriptive annotations. Use each node's
+ * `parent` property to reconstruct the complete hierarchy. Pseudo-states are
+ * intentionally omitted from `children` because they can never appear in an
+ * active configuration.
  *
  * @category getters
  * @since 4.0.0
  */
-export const enabled = (machine, state) => internalPlanner.enabled(machine, state);
+export const stateNodes = internal.stateNodes;
 /**
- * Plans the next state snapshot without running deferred actions.
+ * Returns every registered transition handler in state definition order.
  *
  * **Details**
  *
- * Planning selects child transitions before conflicting ancestors, permits
- * non-conflicting transitions in parallel regions, processes completion and
- * eventless transitions, and drains raised events in FIFO order. Exit paths
- * are deepest-first and entry paths are parent-first.
- *
- * **Gotchas**
- *
- * `plan` returns data; it does not implement the runtime commit protocol. Run
- * actions sequentially, publish `next` only after they succeed, and then
- * deliver `emittedEvents`. A failed action must retain the previously
- * published state and suppress emissions. Events with no enabled transition
- * are ignored and produce an unchanged plan.
+ * Event handlers retain their handler-key order within each source state and
+ * are followed by eventless and completion handlers. This function does not
+ * execute handlers. Object-form event, eventless, and completion handlers with
+ * a `targets` declaration expose those possible paths; handlers without one
+ * remain dynamic.
  *
- * @see {@link planInitial} for planning machine startup.
- * @see {@link start} for managed execution and lifecycle observation.
- * @category combinators
+ * @category getters
  * @since 4.0.0
  */
-export const plan = internalPlanner.plan;
+export const transitionDefinitions = internal.transitionDefinitions;
 /**
- * Defers an effectful action until the current machine step is planned.
+ * Returns serializable descriptions of every state-owned activity.
  *
  * **Details**
  *
- * The action's error and service requirements are retained in the machine
- * type without becoming requirements of `plan` or `planInitial`. The managed
- * runtime executes staged actions sequentially before publishing the planned
- * state. Pass a second argument when the planning Effect should return that
- * value after staging.
+ * Static `invoke`, `invokeEffect`, `after`, and `invokeMachine` descriptors
+ * expose stable ownership and lifecycle metadata without serializing runtime
+ * values. Function-valued invoke factories are represented as dynamic and are
+ * never evaluated during inspection.
  *
- * **Example** (Typed staged action)
+ * @category getters
+ * @since 4.0.0
+ */
+export const activityDefinitions = internal.activityDefinitions;
+/**
+ * Returns every state node active in a decoded snapshot, in definition order.
  *
- * ```ts
- * import { Context, Effect } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
+ * **Details**
  *
- * class Audit extends Context.Service<Audit, {
- *   readonly write: Effect.Effect<void, "AuditError">
- * }>()("example/Audit") {}
+ * Active compound ancestors and parallel regions are included together with
+ * their active descendants. History and choice pseudo-states are never active
+ * and are not returned.
  *
- * const writeAudit = Machine.action(
- *   Effect.flatMap(Audit, (audit) => audit.write)
- * )
- * ```
+ * @category getters
+ * @since 4.0.0
+ */
+export const configuration = internal.configuration;
+/**
+ * Returns the event tags handled by the current state snapshot.
  *
- * @see {@link plan} for inspecting staged actions without executing them.
- * @category combinators
+ * @category getters
  * @since 4.0.0
  */
-export const action = ((effect, ...next) => {
-    const staged = internalPlanner.action(effect);
-    return next.length === 0 ? staged : Effect.as(staged, next[0]);
-});
-const processLocal = (operation) => Effect.die(new ProcessLocalErrorValue({ operation }));
-const standaloneProcessRuntime = internalRuntime.MachineRuntime.of({
-    self: {
-        id: "Machine.runActions",
-        sessionId: "Machine.runActions",
-        stop: processLocal("stop self"),
-        send: () => processLocal("send to self")
-    },
-    parent: undefined,
-    spawn: () => processLocal("spawn"),
-    sendParent: () => processLocal("send to parent"),
-    sendTo: () => processLocal("send to child"),
-    stopChild: () => processLocal("stop child"),
-    failCause: () => processLocal("fail process")
-});
-/**
- * Runs staged machine actions sequentially with the supplied runtime.
+export const enabled = internal.enabled;
+/**
+ * Plans the next state snapshot synchronously.
  *
- * **When to use**
+ * **Details**
  *
- * Use when you implement a commit protocol around `plan` or `planInitial` and
- * need to execute their staged actions before publishing the planned snapshot.
+ * Planning selects child transitions before conflicting ancestors, permits
+ * non-conflicting transitions in parallel regions, processes completion and
+ * eventless transitions, and drains raised events in FIFO order. Exit paths
+ * are deepest-first and entry paths are parent-first.
  *
  * **Gotchas**
  *
- * This function only runs actions. The caller remains responsible for
- * publishing the planned state and delivering planned emitted events after all
- * actions succeed. Process-local operations such as `spawn`, `sendTo`, and
- * `stopChild` fail with `ProcessLocalError` because no managed machine process
- * owns the actions.
- *
- * @see {@link plan} for creating a transition plan.
- * @see {@link planInitial} for creating an initial plan.
- * @category running
- * @since 4.0.0
- */
-export const runActions = (actions, runtime) => internalRuntime.provideMachineRuntime(internalPlanner.runActions(actions, runtime), standaloneProcessRuntime).pipe(Effect.catchDefect((defect) => defect instanceof ProcessLocalErrorValue
-    ? Effect.fail(defect)
-    : Effect.die(defect)));
-/**
- * Returns the typed runtime capability for the current machine.
+ * `plan` returns data; it does not implement the actor commit protocol.
+ * `start` executes child commands, publishes `next`, and then delivers
+ * `emittedEvents`. Events with no enabled transition are ignored and produce
+ * an unchanged plan.
  *
+ * @see {@link planInitial} for planning machine startup.
+ * @see {@link start} for managed execution and lifecycle observation.
  * @category combinators
  * @since 4.0.0
  */
-export const runtime = () => internalPlanner.runtime();
+export const plan = internal.plan;
 /**
  * Creates a one-shot child process from an Effect.
  *
@@ -823,10 +545,7 @@ export const runtime = () => internalPlanner.runtime();
  * @category constructors
  * @since 4.0.0
  */
-export const effect = (effect) => ({
-    initial: () => Effect.void,
-    run: () => effect
-});
+export const effect = internal.effect;
 /**
  * Creates advanced stateful process logic from explicit initialization and
  * execution methods.
@@ -855,12 +574,7 @@ export const effect = (effect) => ({
  * @category constructors
  * @since 4.0.0
  */
-export const logic = (options) => ({
-    initial: (scope) => typeof options.initial === "function"
-        ? options.initial(scope)
-        : Effect.succeed(options.initial),
-    run: options.run
-});
+export const logic = internal.logic;
 /**
  * Creates child process logic from an initial state and a transition function.
  *
@@ -879,10 +593,7 @@ export const logic = (options) => ({
  * @category constructors
  * @since 4.0.0
  */
-export const transition = (initial, transition) => logic({
-    initial,
-    run: ({ receive, updateState }) => receive.pipe(Effect.flatMap((event) => updateState((state) => transition(state, event))), Effect.forever)
-});
+export const transition = internal.transition;
 /**
  * Creates a typed descriptor for a complete child machine.
  *
@@ -892,11 +603,7 @@ export const transition = (initial, transition) => logic({
  * @category constructors
  * @since 4.0.0
  */
-export const child = (id, machine) => ({
-    [ChildMachineTypeId]: ChildMachineTypeId,
-    id,
-    machine
-});
+export const child = internal.child;
 /**
  * Creates a typed parent-local address for lower-level child process logic.
  *
@@ -906,49 +613,48 @@ export const child = (id, machine) => ({
  * @category constructors
  * @since 4.0.0
  */
-export const childAddress = (id) => id;
+export const childAddress = internal.childAddress;
 /**
  * Spawns a child process owned by the currently running machine.
  *
  * **When to use**
  *
- * Use to create child processes from machine actions when the child
- * should be addressed or stopped by the owning machine instead of tied to a
- * single state's `invoke` lifecycle.
+ * Use from lower-level process logic to create children that should be
+ * addressed or stopped by the owning process instead of tied to a single
+ * state's `invoke` lifecycle.
  *
  * **Gotchas**
  *
- * This effect requires the machine runtime, so it only runs from machine
- * actions. A named child id must be unique for the current parent machine until
- * that child stops.
+ * This Effect requires a managed process runtime. A named child id must be
+ * unique for the current parent until that child stops.
  *
  * @see {@link invoke} for children that start and stop with a state.
  * @see {@link sendTo} for sending events to named children.
  * @category runtime
  * @since 4.0.0
  */
-export const spawn = ((logic, options) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => options === undefined ? runtime.spawn(logic) : runtime.spawn(logic, options)));
+export const spawn = internal.spawn;
 /**
  * Sends an event to a named child process of the running machine.
  *
  * @category runtime
  * @since 4.0.0
  */
-export const sendTo = ((child, event) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => runtime.sendTo(child, event)));
+export const sendTo = internal.sendTo;
 /**
  * Stops a named child process of the running machine.
  *
  * @category runtime
  * @since 4.0.0
  */
-export const stopChild = ((child) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => runtime.stopChild(child)));
+export const stopChild = internal.stopChild;
 /**
  * Returns a stream of terminal lifecycle outcomes for a running machine.
  *
  * @category combinators
  * @since 4.0.0
  */
-export const watch = (ref) => internalRuntime.watch(ref);
+export const watch = internal.watch;
 /**
  * Starts a machine.
  *
@@ -959,11 +665,10 @@ export const watch = (ref) => internalRuntime.watch(ref);
  *
  * **Details**
  *
- * For each accepted event the runtime plans the complete macrostep, runs staged
- * actions sequentially, stops invokes for exited states, publishes the new
- * state, delivers emitted events, and then starts invokes for entered states.
- * If an action fails, the previous published state is retained and emissions
- * from that plan are suppressed.
+ * For each accepted event the runtime plans the complete synchronous
+ * macrostep, executes closed actor commands, stops invokes for exited states,
+ * publishes the new state, delivers emitted events, and then starts invokes
+ * for entered states.
  *
  * **Gotchas**
  *
@@ -977,5 +682,35 @@ export const watch = (ref) => internalRuntime.watch(ref);
  * @category constructors
  * @since 4.0.0
  */
-export const start = internalProcess.start;
+export const start = internal.start;
+/**
+ * Starts a fresh managed runtime from a decoded logical snapshot.
+ *
+ * **Details**
+ *
+ * `resume` validates and normalizes the supplied snapshot before publishing it
+ * as the first state. It does not call the machine's initial function, replay
+ * entry or transition actions, re-deliver raised or emitted events, or
+ * re-evaluate historical completion and eventless transitions. Active-state
+ * invokes start once in ancestor and document order with {@link InitialEvent};
+ * delayed invokes restart their complete duration and invoked machines start
+ * from their own initial state.
+ *
+ * Only logical state, completion, and history metadata are resumed. Queues,
+ * scopes, subscriptions, fibers, spawned children, invoke progress, and prior
+ * runtime status are process-local and are not restored. A final snapshot
+ * immediately produces a completed ref with its current-machine output.
+ *
+ * Decode encoded data explicitly with {@link decodeSnapshot} before calling
+ * this function. Stable snapshots are hosted as supplied; newly enabled
+ * eventless or completion transitions in a changed machine definition are not
+ * evaluated merely because the runtime was resumed; only ordinary subsequent
+ * transition planning can enter and stabilize states.
+ *
+ * @see {@link decodeSnapshot} for the schema and transport boundary.
+ * @see {@link start} for ordinary initial startup.
+ * @category constructors
+ * @since 4.0.0
+ */
+export const resume = internal.resume;
 //# sourceMappingURL=Machine.js.map