@typeonce/effect-machine 0.2.0 → 0.4.0

package/dist/internal/machinePlanner.js

@@ -1,621 +0,0 @@
-/**
- * Internal machine planning helpers.
- *
- * @since 4.0.0
- */
-import * as Cause from "effect/Cause";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { InfiniteTransitionError, MachineSchemaDecodeError, StartupError } from "./machineErrors.js";
-import { compareDocumentOrder, completeConfigurationEffect, decodeEmit, decodeEvent, decodeInput, getActiveLeafPathFrom, getActiveLeafPaths, getActiveValue, getInitialEntryPaths, getLeafPath, getNode, getParentValue, getParentValues, getPathToRoot, getRootPath, isActiveFinalConfiguration, isDescendantOf, isSnapshot, isTarget, normalizeConfiguration, normalizeConfigurationEffect, normalizeTargetConfigurationEffect, pathDepth, snapshotFromConfiguration, validateInitialConfiguration } from "./machineModel.js";
-class DeferredActions extends Context.Service()("effect/Machine/DeferredActions") {
-}
-class DeferredRaisedEvents extends Context.Service()("effect/Machine/DeferredRaisedEvents") {
-}
-class RuntimeContext extends Context.Service()("effect/Machine/Runtime") {
-}
-const makeDeferredQueue = () => Effect.sync(() => {
-    const values = [];
-    return {
-        read: Effect.sync(() => values),
-        add: (value) => Effect.sync(() => {
-            values.push(value);
-        })
-    };
-});
-const makeDeferredActions = Effect.map(makeDeferredQueue(), (queue) => DeferredActions.of({
-    read: queue.read,
-    add: (effect) => queue.add(effect)
-}));
-const makeDeferredRaisedEvents = Effect.gen(function* () {
-    const raised = yield* makeDeferredQueue();
-    const emitted = yield* makeDeferredQueue();
-    return (DeferredRaisedEvents.of({
-        read: raised.read,
-        readEmitted: emitted.read,
-        add: (event) => raised.add(event),
-        addEmitted: (event) => emitted.add(event)
-    }));
-});
-const provideDeferredServices = (effect, machine, deferredActions, deferredRaisedEvents) => effect.pipe(Effect.provideService(DeferredActions, deferredActions), Effect.provideService(DeferredRaisedEvents, deferredRaisedEvents), Effect.provideService(RuntimeContext, makePlanningRuntime(machine, deferredRaisedEvents)));
-const provideRuntimeContext = (effect, runtime) => Effect.provideService(effect, RuntimeContext, runtime);
-const makePlanningRuntime = (machine, deferredRaisedEvents) => RuntimeContext.of({
-    raise: (event) => decodeEvent(machine, event).pipe(Effect.flatMap((event) => deferredRaisedEvents.add(event))),
-    sendParent: (event) => decodeEmit(machine, event).pipe(Effect.flatMap((event) => deferredRaisedEvents.addEmitted(event)))
-});
-export const makeLiveRuntime = (machine, scope) => RuntimeContext.of({
-    raise: (event) => decodeEvent(machine, event).pipe(Effect.flatMap((event) => scope.self.send(event))),
-    sendParent: (event) => decodeEmit(machine, event).pipe(Effect.flatMap((event) => scope.sendParent(event)))
-});
-export const runActions = (actions, runtime) => Effect.all(Array.from(actions, (action) => provideRuntimeContext(action, runtime)), { discard: true });
-export const runEmittedEvents = (events, runtime) => Effect.all(Array.from(events, (event) => runtime.sendParent(event)), { discard: true });
-export const runtimeFor = () => runtime();
-const normalizeEventTransition = (transition) => {
-    if (transition === undefined) {
-        return undefined;
-    }
-    return typeof transition === "function"
-        ? { reenter: false, transition }
-        : { reenter: transition.reenter === true, transition: transition.transition };
-};
-const collectStateAction = Effect.fnUntraced(function* (machine, handler, context) {
-    const deferredActions = yield* makeDeferredActions;
-    const deferredRaisedEvents = yield* makeDeferredRaisedEvents;
-    if (handler !== undefined) {
-        const result = handler(context);
-        if (Effect.isEffect(result)) {
-            yield* provideDeferredServices(result, machine, deferredActions, deferredRaisedEvents);
-        }
-    }
-    const actions = yield* deferredActions.read;
-    const raisedEvents = yield* deferredRaisedEvents.read;
-    const emittedEvents = yield* deferredRaisedEvents.readEmitted;
-    return {
-        actions: actions,
-        raisedEvents: raisedEvents,
-        emittedEvents
-    };
-});
-const collectTransition = Effect.fnUntraced(function* (machine, transition, context) {
-    const deferredActions = yield* makeDeferredActions;
-    const deferredRaisedEvents = yield* makeDeferredRaisedEvents;
-    const result = transition(context);
-    const state = Effect.isEffect(result)
-        ? yield* provideDeferredServices(result, machine, deferredActions, deferredRaisedEvents)
-        : result;
-    const actions = yield* deferredActions.read;
-    const raisedEvents = yield* deferredRaisedEvents.read;
-    const emittedEvents = yield* deferredRaisedEvents.readEmitted;
-    return {
-        state,
-        actions: actions,
-        raisedEvents: raisedEvents,
-        emittedEvents
-    };
-});
-const getCandidatePaths = (machine, configuration) => Array.from(configuration.active)
-    .sort((left, right) => {
-    const depth = pathDepth(machine, right) - pathDepth(machine, left);
-    return depth === 0 ? compareDocumentOrder(machine, left, right) : depth;
-});
-const getLeafCandidatePaths = (machine, leaf) => [...getPathToRoot(machine, leaf)].reverse();
-const getLeastCommonAncestor = (machine, left, right) => {
-    const leftPath = getPathToRoot(machine, left);
-    const rightPath = getPathToRoot(machine, right);
-    let ancestor = undefined;
-    const length = Math.min(leftPath.length, rightPath.length);
-    for (let index = 0; index < length; index++) {
-        if (leftPath[index] !== rightPath[index]) {
-            break;
-        }
-        ancestor = leftPath[index];
-    }
-    return ancestor;
-};
-const getExitPaths = (machine, configuration, boundary) => sortExitPaths(machine, Array.from(configuration.active)
-    .filter((path) => boundary === undefined || isDescendantOf(path, boundary)));
-const getEntryPaths = (machine, configuration, boundary) => sortEntryPaths(machine, Array.from(configuration.active).filter((path) => boundary === undefined || isDescendantOf(path, boundary)));
-const hasSameActivePaths = (left, right) => left.active.size === right.active.size && Array.from(left.active).every((path) => right.active.has(path));
-export const sortExitPaths = (machine, paths) => Array.from(new Set(paths))
-    .sort((left, right) => {
-    const depth = getPathToRoot(machine, right).length - getPathToRoot(machine, left).length;
-    return depth === 0 ? getNode(machine, right).order - getNode(machine, left).order : depth;
-});
-export const sortEntryPaths = (machine, paths) => Array.from(new Set(paths))
-    .sort((left, right) => {
-    const depth = getPathToRoot(machine, left).length - getPathToRoot(machine, right).length;
-    return depth === 0 ? compareDocumentOrder(machine, left, right) : depth;
-});
-const makePlanningCapabilities = () => {
-    const runtimeEffect = runtimeFor();
-    return {
-        runtime: runtimeEffect,
-        raise: (event) => Effect.flatMap(runtimeEffect, (runtime) => runtime.raise(event)),
-        emit: (event) => Effect.flatMap(runtimeEffect, (runtime) => runtime.sendParent(event))
-    };
-};
-const makeStateActionContext = (machine, configuration, path, event) => ({
-    state: getActiveValue(configuration, path),
-    parent: getParentValue(machine, configuration, path),
-    parents: getParentValues(machine, configuration, path),
-    event,
-    ...makePlanningCapabilities()
-});
-const makeTransitionContext = (machine, configuration, path, event) => ({
-    state: getActiveValue(configuration, path),
-    parent: getParentValue(machine, configuration, path),
-    parents: getParentValues(machine, configuration, path),
-    event,
-    ...makePlanningCapabilities(),
-    target: machine.makeTargetBuilder(path)
-});
-const makeDoneContext = (machine, configuration, path, event, output) => ({
-    state: getActiveValue(configuration, path),
-    parent: getParentValue(machine, configuration, path),
-    parents: getParentValues(machine, configuration, path),
-    event,
-    output: output,
-    ...makePlanningCapabilities(),
-    target: machine.makeTargetBuilder(path)
-});
-const collectStateActions = Effect.fnUntraced(function* (machine, configuration, paths, event, key) {
-    const actions = [];
-    const raisedEvents = [];
-    const emittedEvents = [];
-    for (const path of paths) {
-        const collected = yield* collectStateAction(machine, machine.handlers[path]?.[key], makeStateActionContext(machine, configuration, path, event));
-        actions.push(...collected.actions);
-        raisedEvents.push(...collected.raisedEvents);
-        emittedEvents.push(...collected.emittedEvents);
-    }
-    return { actions, emittedEvents, raisedEvents };
-});
-const selectAlwaysTransitions = (machine, configuration, event) => {
-    const selected = [];
-    const selectedSources = new Set();
-    for (const leaf of getActiveLeafPaths(machine, configuration)) {
-        for (const path of getLeafCandidatePaths(machine, leaf)) {
-            const always = machine.handlers[path]?.always;
-            if (always !== undefined) {
-                if (!selectedSources.has(path)) {
-                    selectedSources.add(path);
-                    selected.push({
-                        sourcePath: path,
-                        leafPath: leaf,
-                        transition: { reenter: false, transition: always },
-                        context: {
-                            state: getActiveValue(configuration, path),
-                            parent: getParentValue(machine, configuration, path),
-                            parents: getParentValues(machine, configuration, path),
-                            event,
-                            ...makePlanningCapabilities(),
-                            target: machine.makeTargetBuilder(path)
-                        }
-                    });
-                }
-                break;
-            }
-        }
-    }
-    return selected;
-};
-const selectDoneTransitions = (machine, configuration, event, completions) => {
-    const selected = [];
-    const selectedSources = new Set();
-    for (const completion of completions) {
-        const onDone = machine.handlers[completion.path]?.onDone;
-        if (onDone !== undefined && !selectedSources.has(completion.path)) {
-            selectedSources.add(completion.path);
-            selected.push({
-                sourcePath: completion.path,
-                leafPath: getActiveLeafPathFrom(machine, configuration, completion.path),
-                transition: { reenter: false, transition: onDone },
-                context: makeDoneContext(machine, configuration, completion.path, event, completion.output)
-            });
-        }
-    }
-    return selected;
-};
-const selectEventTransitions = (machine, configuration, event) => {
-    const selected = [];
-    const selectedSources = new Set();
-    for (const leaf of getActiveLeafPaths(machine, configuration)) {
-        for (const path of getLeafCandidatePaths(machine, leaf)) {
-            const transition = normalizeEventTransition(machine.handlers[path]?.on?.[event._tag]);
-            if (transition !== undefined) {
-                if (!selectedSources.has(path)) {
-                    selectedSources.add(path);
-                    selected.push({
-                        sourcePath: path,
-                        leafPath: leaf,
-                        transition: transition,
-                        context: makeTransitionContext(machine, configuration, path, event)
-                    });
-                }
-                break;
-            }
-        }
-    }
-    return selected;
-};
-const getTargetNodePath = (target) => {
-    if (isTarget(target)) {
-        return String(target.path);
-    }
-    if (isSnapshot(target)) {
-        return String(target.path);
-    }
-    throw new Error("Machine expected transition target to be a snapshot or target builder result");
-};
-const hasPathIntersection = (left, right) => {
-    for (const path of left) {
-        if (right.includes(path)) {
-            return true;
-        }
-    }
-    return false;
-};
-const sortEvaluatedTransitions = (machine, transitions) => Array.from(transitions)
-    .sort((left, right) => compareDocumentOrder(machine, left.selection.sourcePath, right.selection.sourcePath));
-const removePreemptedAncestorSelections = (selections) => selections.filter((selection) => !selections.some((other) => other.sourcePath !== selection.sourcePath && isDescendantOf(other.sourcePath, selection.sourcePath)));
-const removeConflictingTransitions = (machine, transitions) => {
-    const filtered = [];
-    for (const transition of sortEvaluatedTransitions(machine, transitions)) {
-        let preempted = false;
-        const transitionsToRemove = new Set();
-        for (const selected of filtered) {
-            if (hasPathIntersection(transition.exitPaths, selected.exitPaths)) {
-                if (isDescendantOf(transition.selection.sourcePath, selected.selection.sourcePath)) {
-                    transitionsToRemove.add(selected);
-                }
-                else {
-                    preempted = true;
-                    break;
-                }
-            }
-        }
-        if (!preempted) {
-            for (const removed of transitionsToRemove) {
-                const index = filtered.indexOf(removed);
-                if (index >= 0) {
-                    filtered.splice(index, 1);
-                }
-            }
-            filtered.push(transition);
-        }
-    }
-    return filtered;
-};
-const collectEvaluatedTransition = Effect.fnUntraced(function* (machine, state, selection) {
-    const stateIdentifier = selection.leafPath;
-    const transitionResult = yield* collectTransition(machine, selection.transition.transition, selection.context);
-    const target = transitionResult.state === undefined
-        ? undefined
-        : transitionResult.state;
-    const targetPath = target === undefined ? undefined : getTargetNodePath(target);
-    const stateAfterTransition = target === undefined
-        ? state
-        : yield* normalizeTargetConfigurationEffect(machine, state, target);
-    const changed = selection.transition.reenter || !hasSameActivePaths(state, stateAfterTransition);
-    if (!changed) {
-        return {
-            selection,
-            target,
-            actions: transitionResult.actions,
-            raisedEvents: transitionResult.raisedEvents,
-            emittedEvents: transitionResult.emittedEvents,
-            changed,
-            exitPaths: [],
-            entryPaths: []
-        };
-    }
-    const boundary = selection.transition.reenter
-        ? getNode(machine, selection.sourcePath).parent
-        : getLeastCommonAncestor(machine, stateIdentifier, targetPath);
-    return {
-        selection,
-        target,
-        actions: transitionResult.actions,
-        raisedEvents: transitionResult.raisedEvents,
-        emittedEvents: transitionResult.emittedEvents,
-        changed,
-        exitPaths: getExitPaths(machine, state, boundary),
-        entryPaths: getEntryPaths(machine, stateAfterTransition, boundary)
-    };
-});
-const MaxMacrostepIterations = 1000;
-export const InitialEventTypeId = Symbol("effect/Machine/InitialEvent");
-export const InitialEvent = { _tag: InitialEventTypeId };
-const catchStartup = (effect) => Effect.catchCause(effect, (cause) => {
-    if (Cause.hasDies(cause)) {
-        return Effect.fail(new StartupError({ cause }));
-    }
-    return Effect.failCause(cause);
-});
-export const isFinalState = (machine, state) => isActiveFinalConfiguration(machine, normalizeConfiguration(machine, state));
-export const getFinalOutputEffect = (machine, state, event) => normalizeConfigurationEffect(machine, state).pipe(Effect.flatMap((configuration) => completeConfigurationEffect(machine, configuration, event)), Effect.flatMap((completed) => {
-    const root = getRootPath(machine, completed.configuration);
-    if (!isActiveFinalConfiguration(machine, completed.configuration)
-        || !completed.configuration.outputs.has(root)) {
-        return Effect.die(new Error("Machine attempted to read terminal output from a non-terminal configuration"));
-    }
-    return Effect.succeed(completed.configuration.outputs.get(root));
-}));
-export const isFinal = (machine, state) => isFinalState(machine, state);
-export const planInitial = Effect.fnUntraced(function* (machine, ...args) {
-    return yield* catchStartup(Effect.gen(function* () {
-        const deferredActions = yield* makeDeferredActions;
-        const deferredRaisedEvents = yield* makeDeferredRaisedEvents;
-        const inputArgs = machine.input === undefined
-            ? args
-            : args.length === 0
-                ? (yield* decodeInput(machine, machine.input, undefined), args)
-                : [yield* decodeInput(machine, machine.input, args[0])];
-        const result = machine.initial(...inputArgs);
-        const state = Effect.isEffect(result)
-            ? yield* provideDeferredServices(result, machine, deferredActions, deferredRaisedEvents)
-            : result;
-        const configuration = yield* normalizeConfigurationEffect(machine, state);
-        validateInitialConfiguration(machine, configuration);
-        const actions = yield* deferredActions.read;
-        const raisedEvents = yield* deferredRaisedEvents.read;
-        const emittedEvents = yield* deferredRaisedEvents.readEmitted;
-        const settled = yield* Effect.gen(function* () {
-            const entry = yield* collectStateActions(machine, configuration, getInitialEntryPaths(machine, configuration), InitialEvent, "entry");
-            return yield* settle(machine, configuration, InitialEvent, [...entry.actions], [...raisedEvents, ...entry.raisedEvents], [...emittedEvents, ...entry.emittedEvents], []);
-        });
-        const planned = {
-            state: snapshotFromConfiguration(machine, settled.next),
-            actions: [
-                ...actions,
-                ...settled.actions
-            ],
-            emittedEvents: settled.emittedEvents
-        };
-        return settled.done
-            ? { ...planned, done: true, output: settled.output }
-            : { ...planned, done: false, output: undefined };
-    }));
-});
-export const enabled = (machine, state) => {
-    if (isFinalState(machine, state)) {
-        return [];
-    }
-    const configuration = normalizeConfiguration(machine, state);
-    const tags = [];
-    const seen = new Set();
-    for (const path of getCandidatePaths(machine, configuration)) {
-        for (const tag of Reflect.ownKeys(machine.handlers[path]?.on ?? {})) {
-            if (!seen.has(tag)) {
-                seen.add(tag);
-                tags.push(tag);
-            }
-        }
-    }
-    return tags;
-};
-const microstep = Effect.fnUntraced(function* (machine, state, event, selections) {
-    if (selections.length === 0) {
-        return {
-            next: state,
-            event,
-            actions: [],
-            raisedEvents: [],
-            emittedEvents: [],
-            exitPaths: [],
-            entryPaths: [],
-            changed: false
-        };
-    }
-    const activeSelections = removePreemptedAncestorSelections(selections);
-    const evaluatedTransitions = [];
-    for (const selection of activeSelections) {
-        evaluatedTransitions.push(yield* collectEvaluatedTransition(machine, state, selection));
-    }
-    const transitions = removeConflictingTransitions(machine, evaluatedTransitions);
-    const sortedTransitions = sortEvaluatedTransitions(machine, transitions);
-    let stateAfterTransition = state;
-    for (const transition of sortedTransitions) {
-        if (transition.target !== undefined) {
-            stateAfterTransition = yield* normalizeTargetConfigurationEffect(machine, stateAfterTransition, transition.target);
-        }
-    }
-    const changed = transitions.some((transition) => transition.changed);
-    const transitionActions = sortedTransitions
-        .flatMap((transition) => transition.actions);
-    const transitionRaisedEvents = sortedTransitions
-        .flatMap((transition) => transition.raisedEvents);
-    const transitionEmittedEvents = sortedTransitions
-        .flatMap((transition) => transition.emittedEvents);
-    if (!changed) {
-        return {
-            next: stateAfterTransition,
-            event,
-            actions: transitionActions,
-            raisedEvents: transitionRaisedEvents,
-            emittedEvents: transitionEmittedEvents,
-            exitPaths: [],
-            entryPaths: [],
-            changed: false
-        };
-    }
-    const exitPaths = sortExitPaths(machine, sortedTransitions.flatMap((transition) => transition.exitPaths));
-    const entryPaths = sortEntryPaths(machine, sortedTransitions.flatMap((transition) => transition.entryPaths));
-    const exit = yield* collectStateActions(machine, state, exitPaths, event, "exit");
-    const entry = yield* collectStateActions(machine, stateAfterTransition, entryPaths, event, "entry");
-    return {
-        next: stateAfterTransition,
-        event,
-        actions: [...exit.actions, ...transitionActions, ...entry.actions],
-        raisedEvents: [...exit.raisedEvents, ...transitionRaisedEvents, ...entry.raisedEvents],
-        emittedEvents: [...exit.emittedEvents, ...transitionEmittedEvents, ...entry.emittedEvents],
-        exitPaths,
-        entryPaths,
-        changed: true
-    };
-});
-const settle = Effect.fnUntraced(function* (machine, state, event, actions, raisedEvents, emittedEvents, microsteps) {
-    let currentState = state;
-    let currentEvent = event;
-    let shouldRunAlways = true;
-    let iterations = 0;
-    let raisedEventIndex = 0;
-    let completedTerminal = false;
-    let finalOutput = undefined;
-    const pendingCompletions = [];
-    while (true) {
-        iterations += 1;
-        if (iterations > MaxMacrostepIterations) {
-            return yield* new InfiniteTransitionError({
-                machineId: machine.id,
-                state: String(getLeafPath(machine, currentState)),
-                maxIterations: MaxMacrostepIterations
-            });
-        }
-        const completed = yield* completeConfigurationEffect(machine, currentState, currentEvent);
-        currentState = completed.configuration;
-        pendingCompletions.push(...completed.completions.filter((completion) => machine.handlers[completion.path]?.onDone !== undefined));
-        while (pendingCompletions.length > 0 && !currentState.active.has(pendingCompletions[0].path)) {
-            pendingCompletions.shift();
-        }
-        const done = selectDoneTransitions(machine, currentState, currentEvent, pendingCompletions.length === 0 ? [] : [pendingCompletions.shift()]);
-        if (done.length > 0) {
-            const doneStep = yield* microstep(machine, currentState, currentEvent, done);
-            actions.push(...doneStep.actions);
-            raisedEvents.push(...doneStep.raisedEvents);
-            emittedEvents.push(...doneStep.emittedEvents);
-            microsteps.push(doneStep);
-            currentState = doneStep.next;
-            shouldRunAlways = doneStep.changed;
-            continue;
-        }
-        if (isActiveFinalConfiguration(machine, currentState)) {
-            const root = getRootPath(machine, currentState);
-            if (!currentState.outputs.has(root)) {
-                return yield* Effect.die(new Error("Machine reached a terminal configuration without a completed root output"));
-            }
-            completedTerminal = true;
-            finalOutput = currentState.outputs.get(root);
-            break;
-        }
-        const always = shouldRunAlways
-            ? selectAlwaysTransitions(machine, currentState, currentEvent)
-            : [];
-        if (always.length > 0) {
-            const alwaysStep = yield* microstep(machine, currentState, currentEvent, always);
-            actions.push(...alwaysStep.actions);
-            raisedEvents.push(...alwaysStep.raisedEvents);
-            emittedEvents.push(...alwaysStep.emittedEvents);
-            microsteps.push(alwaysStep);
-            currentState = alwaysStep.next;
-            shouldRunAlways = alwaysStep.changed;
-            continue;
-        }
-        const raisedEventValue = raisedEvents[raisedEventIndex];
-        if (raisedEventValue === undefined) {
-            break;
-        }
-        raisedEventIndex += 1;
-        // Planning runtime validates and normalizes every event before it enters this
-        // internal queue, so decoding it again here only repeats schema work.
-        const raisedEvent = raisedEventValue;
-        currentEvent = raisedEvent;
-        const raisedSelections = selectEventTransitions(machine, currentState, raisedEvent);
-        if (raisedSelections.length === 0) {
-            shouldRunAlways = true;
-            continue;
-        }
-        const raisedStep = yield* microstep(machine, currentState, raisedEvent, raisedSelections);
-        actions.push(...raisedStep.actions);
-        raisedEvents.push(...raisedStep.raisedEvents);
-        emittedEvents.push(...raisedStep.emittedEvents);
-        microsteps.push(raisedStep);
-        currentState = raisedStep.next;
-        shouldRunAlways = true;
-    }
-    const result = {
-        next: currentState,
-        actions,
-        emittedEvents,
-        microsteps
-    };
-    return completedTerminal
-        ? { ...result, done: true, output: finalOutput }
-        : { ...result, done: false, output: undefined };
-});
-const macrostep = Effect.fnUntraced(function* (machine, state, event) {
-    const configuration = yield* normalizeConfigurationEffect(machine, state);
-    const snapshot = snapshotFromConfiguration(machine, configuration);
-    const decodedEvent = yield* decodeEvent(machine, event);
-    if (isActiveFinalConfiguration(machine, configuration)) {
-        const completed = yield* completeConfigurationEffect(machine, configuration, decodedEvent);
-        const root = getRootPath(machine, completed.configuration);
-        if (!completed.configuration.outputs.has(root)) {
-            return yield* Effect.die(new Error("Machine reached a terminal configuration without a completed root output"));
-        }
-        return {
-            next: snapshotFromConfiguration(machine, completed.configuration),
-            actions: [],
-            emittedEvents: [],
-            microsteps: [],
-            done: true,
-            output: completed.configuration.outputs.get(root)
-        };
-    }
-    const selections = selectEventTransitions(machine, configuration, decodedEvent);
-    if (selections.length === 0) {
-        return {
-            next: snapshot,
-            actions: [],
-            emittedEvents: [],
-            microsteps: [],
-            done: false,
-            output: undefined
-        };
-    }
-    const step = yield* microstep(machine, configuration, decodedEvent, selections);
-    const actions = [...step.actions];
-    const raisedEvents = [...step.raisedEvents];
-    const emittedEvents = [...step.emittedEvents];
-    const microsteps = [step];
-    const settled = yield* settle(machine, step.next, decodedEvent, actions, raisedEvents, emittedEvents, microsteps);
-    const planned = {
-        next: snapshotFromConfiguration(machine, settled.next),
-        actions: settled.actions,
-        emittedEvents: settled.emittedEvents,
-        microsteps: settled.microsteps.map((step) => ({
-            next: snapshotFromConfiguration(machine, step.next),
-            event: step.event,
-            actions: step.actions,
-            raisedEvents: step.raisedEvents,
-            emittedEvents: step.emittedEvents,
-            exitPaths: step.exitPaths,
-            entryPaths: step.entryPaths,
-            changed: step.changed
-        }))
-    };
-    return settled.done
-        ? { ...planned, done: true, output: settled.output }
-        : { ...planned, done: false, output: undefined };
-});
-export const plan = macrostep;
-const actionUnsafe = Effect.fnUntraced(function* (effect) {
-    const actions = yield* DeferredActions;
-    yield* actions.add(effect);
-});
-/**
- * Defers an effectful action until the current machine step is planned.
- *
- * @category combinators
- * @since 4.0.0
- */
-export const action = (effect) => actionUnsafe(effect);
-/**
- * Returns the typed runtime capability for the current machine.
- *
- * @category combinators
- * @since 4.0.0
- */
-export const runtime = () => RuntimeContext;
-//# sourceMappingURL=machinePlanner.js.map