@typeonce/effect-machine 0.3.0 → 0.4.0

package/dist/internal/{machineModel.js → machine/configuration.js}

@@ -1,5 +1,5 @@
 /**
- * Internal machine representation helpers.
+ * Internal active-configuration, history, and completion helpers.
  *
  * @since 4.0.0
  */
@@ -7,14 +7,10 @@ import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { hasProperty } from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import { MachineSchemaDecodeError, MachineSchemaEncodeError } from "./machineErrors.js";
-export const TargetTypeId = "~effect/Machine/Target";
-export const TargetSnapshotTypeId = Symbol("effect/Machine/TargetSnapshot");
-export const StateInputTypeId = Symbol("effect/Machine/StateInput");
-export const StateConstructionTypeId = Symbol("effect/Machine/StateConstruction");
-export const HistoryTargetTypeId = Symbol("effect/Machine/HistoryTarget");
-const validateHistoryRecordControl = (machine, record) => {
+import { MachineSchemaDecodeError } from "./errors.js";
+import { decodeBoundary, decodeOutputValue, decodeOutputValueSync, decodeStateValue, decodeStateValueSync } from "./protocol.js";
+import { getNode, getStateNodeSchema, isSnapshot, isTarget, TargetSnapshotTypeId } from "./topology.js";
+export const validateHistoryRecordControl = (machine, record) => {
     const ancestry = new Set(getPathToRoot(machine, record.parent));
     const visit = (path) => {
         const node = getNode(machine, path);
@@ -62,14 +58,13 @@ const historyFromSnapshot = (machine, snapshot) => {
                 throw new Error(`Machine snapshot contains invalid remembered state "${activePath}"`);
             }
             const node = getNode(machine, activePath);
-            if (node.type === "history" ||
+            if (node.type === "history" || node.type === "choice" ||
                 !(isPathInSubtree(activePath, historyNode.parent) ||
-                    getPathToRoot(machine, historyNode.parent).includes(activePath)) ||
-                !Schema.is(getStateNodeSchema(node))(entry.values[activePath])) {
+                    getPathToRoot(machine, historyNode.parent).includes(activePath))) {
                 throw new Error(`Machine snapshot contains invalid remembered value for "${activePath}"`);
             }
             active.add(activePath);
-            values.set(activePath, entry.values[activePath]);
+            values.set(activePath, decodeStateValueSync(machine, node, entry.values[activePath]));
         }
         if (!active.has(historyNode.parent) || Object.keys(entry.values).length !== active.size) {
             throw new Error(`Machine snapshot contains incomplete history record "${path}"`);
@@ -101,7 +96,7 @@ const historyFromSnapshotEffect = Effect.fnUntraced(function* (machine, snapshot
         const values = new Map();
         for (const activePath of entry.active) {
             const node = machine.stateNodes.byPath.get(activePath);
-            if (active.has(activePath) || node === undefined || node.type === "history" ||
+            if (active.has(activePath) || node === undefined || node.type === "history" || node.type === "choice" ||
                 !Object.prototype.hasOwnProperty.call(entry.values, activePath) ||
                 !(isPathInSubtree(activePath, historyNode.parent) ||
                     getPathToRoot(machine, historyNode.parent).includes(activePath))) {
@@ -146,251 +141,39 @@ const historyFromSnapshotEffect = Effect.fnUntraced(function* (machine, snapshot
     }
     return history;
 });
-const historyToSnapshot = (history) => {
+const historyToSnapshot = (machine, history) => {
     const entries = {};
     for (const [path, record] of history) {
+        const active = Array.from(record.active).sort((left, right) => compareDocumentOrder(machine, left, right));
         entries[path] = {
             mode: record.mode,
-            active: Array.from(record.active),
-            values: Object.fromEntries(record.values)
+            active,
+            values: Object.fromEntries(active.map((path) => [path, record.values.get(path)]))
         };
     }
     return entries;
 };
-export const makeHistoryTarget = (path, parent) => ({
-    [HistoryTargetTypeId]: HistoryTargetTypeId,
-    path,
-    parent
-});
-export const isHistoryTarget = (u) => hasProperty(u, HistoryTargetTypeId);
-export const getStateNodeDefinition = (path, definition) => {
-    if (!Schema.isSchema(definition) && definition.type === "history") {
-        return {
-            schema: undefined,
-            output: undefined,
-            type: "history",
-            initial: undefined,
-            states: undefined
-        };
-    }
-    if (Schema.isSchema(definition)) {
-        return {
-            schema: definition,
-            output: undefined,
-            type: "atomic",
-            initial: undefined,
-            states: undefined
-        };
-    }
-    if (!hasProperty(definition, "schema") || !Schema.isSchema(definition.schema)) {
-        throw new Error(`Machine.make expected state "${path}" to be a tagged schema or state node config`);
-    }
-    if (definition.type === "parallel" && !hasProperty(definition, "states")) {
-        throw new Error(`Machine.make expected parallel state "${path}" to declare child regions`);
-    }
-    if (hasProperty(definition, "states")) {
-        if (definition.type === "final") {
-            throw new Error(`Machine.make expected compound state "${path}" to be active`);
-        }
-        if (definition.type === "parallel") {
-            return {
-                schema: definition.schema,
-                output: Schema.isSchema(definition.output) ? definition.output : undefined,
-                type: "parallel",
-                initial: undefined,
-                states: definition.states
-            };
-        }
-        if (typeof definition.initial !== "string") {
-            throw new Error(`Machine.make expected compound state "${path}" to declare an initial child`);
-        }
-        return {
-            schema: definition.schema,
-            output: undefined,
-            type: "compound",
-            initial: definition.initial,
-            states: definition.states
-        };
-    }
-    return {
-        schema: definition.schema,
-        output: Schema.isSchema(definition.output) ? definition.output : undefined,
-        type: definition.type === "final" ? "final" : "atomic",
-        initial: undefined,
-        states: undefined
-    };
-};
-export const compileStateNodes = (states) => {
-    const byPath = new Map();
-    let order = 0;
-    const compile = (tree, parent) => {
-        const paths = [];
-        for (const key of Object.keys(tree)) {
-            if (key.includes(".")) {
-                throw new Error(`Machine state keys cannot contain ".": "${key}"`);
-            }
-            const path = parent === undefined ? key : `${parent}.${key}`;
-            const definition = getStateNodeDefinition(path, tree[key]);
-            const node = {
-                path,
-                key,
-                schema: definition.schema,
-                output: definition.output,
-                type: definition.type,
-                parent,
-                children: [],
-                initial: definition.initial === undefined ? undefined : `${path}.${definition.initial}`,
-                history: definition.type === "history"
-                    ? (tree[key].history === "deep" ? "deep" : "shallow")
-                    : undefined,
-                order
-            };
-            byPath.set(path, node);
-            order += 1;
-            if (definition.type === "history") {
-                if (parent === undefined) {
-                    throw new Error(`Machine history state "${path}" must belong to a parent state`);
-                }
-                continue;
-            }
-            paths.push(path);
-            if (definition.states !== undefined) {
-                const children = compile(definition.states, path);
-                if (node.type === "compound" && (node.initial === undefined || !children.includes(node.initial))) {
-                    throw new Error(`Machine.make expected compound state "${path}" initial child to exist`);
-                }
-                ;
-                node.children = children;
-            }
-        }
-        return paths;
-    };
-    return {
-        byPath,
-        roots: compile(states, undefined)
-    };
-};
-export const makeTarget = (path, value, options) => ({
-    [TargetTypeId]: TargetTypeId,
-    [TargetSnapshotTypeId]: options?.snapshot,
-    path,
-    value,
-    values: options?.values
-});
-export const isTarget = (u) => hasProperty(u, TargetTypeId);
-export const makeStateInput = (input) => ({
-    [StateInputTypeId]: StateInputTypeId,
-    input
-});
-const isStateInput = (u) => hasProperty(u, StateInputTypeId);
-export const markStateConstruction = (value) => {
-    if ((typeof value === "object" && value !== null) || typeof value === "function") {
-        Object.defineProperty(value, StateConstructionTypeId, {
-            value: StateConstructionTypeId,
-            enumerable: false
-        });
-    }
-    return value;
-};
-export const isStateConstruction = (u) => hasProperty(u, StateConstructionTypeId);
-export const isSnapshot = (u) => hasProperty(u, "path") && hasProperty(u, "value");
-export const getSnapshotByPath = (snapshot, path, parents) => {
-    if (snapshot.path === path) {
-        return Option.some(snapshot);
-    }
-    if (!path.startsWith(`${snapshot.path}.`)) {
-        return Option.none();
-    }
-    if (parents !== undefined) {
-        parents[snapshot.path] = snapshot.value;
-    }
-    if (hasProperty(snapshot, "state") && isSnapshot(snapshot.state)) {
-        return getSnapshotByPath(snapshot.state, path, parents);
-    }
-    if (hasProperty(snapshot, "states") && typeof snapshot.states === "object" && snapshot.states !== null) {
-        for (const child of Object.values(snapshot.states)) {
-            if (isSnapshot(child)) {
-                const result = getSnapshotByPath(child, path, parents);
-                if (Option.isSome(result)) {
-                    return result;
-                }
-            }
-        }
-    }
-    return Option.none();
-};
-const MachineProtocolTypeId = Symbol.for("effect/Machine/protocol");
-const getProtocolSchemas = (machine) => {
-    const protocol = machine[MachineProtocolTypeId];
-    if (protocol === undefined) {
-        throw new Error("Machine protocol is unavailable");
-    }
-    return protocol;
-};
-const setProtocolSchemas = (machine, protocol) => {
-    Object.defineProperty(machine, MachineProtocolTypeId, {
-        value: protocol,
-        enumerable: false
-    });
-};
-export const setProtocol = (machine) => {
-    setProtocolSchemas(machine, {
-        event: Schema.Union([...machine.events, ...machine.internalEvents]),
-        emit: Schema.Union(machine.emits)
-    });
-};
-export const copyProtocol = (source, target) => setProtocolSchemas(target, getProtocolSchemas(source));
-export const getEventName = (event) => hasProperty(event, "_tag") ? String(event._tag) : undefined;
-export const decodeBoundary = (machine, schema, value, options) => Schema.decodeUnknownEffect(Schema.toType(schema))(value).pipe(Effect.mapError((cause) => new MachineSchemaDecodeError({
-    machineId: machine.id,
-    boundary: options.boundary,
-    cause,
-    ...(options.state === undefined ? {} : { state: options.state }),
-    ...(options.event === undefined ? {} : { event: options.event })
-})));
-export const decodeInput = (machine, schema, value) => decodeBoundary(machine, schema, value, { boundary: "input" });
-export const decodeEvent = (machine, event) => {
-    const eventName = getEventName(event);
-    return decodeBoundary(machine, getProtocolSchemas(machine).event, event, eventName === undefined ? { boundary: "event" } : { boundary: "event", event: eventName });
-};
-export const decodeEmit = (machine, event) => {
-    const eventName = getEventName(event);
-    return decodeBoundary(machine, getProtocolSchemas(machine).emit, event, eventName === undefined ? { boundary: "emit" } : { boundary: "emit", event: eventName });
-};
-export const decodeStateValue = (machine, node, value) => isStateInput(value)
-    ? getStateNodeSchema(node).makeEffect(value.input).pipe(Effect.mapError((cause) => new MachineSchemaDecodeError({
-        machineId: machine.id,
-        boundary: "state",
-        state: node.path,
-        cause
-    })))
-    : decodeBoundary(machine, getStateNodeSchema(node), value, { boundary: "state", state: node.path });
-export const decodeOutputValue = (machine, node, value) => node.output === undefined
-    ? Effect.succeed(value)
-    : decodeBoundary(machine, node.output, value, { boundary: "output", state: node.path });
-export const getNode = (machine, path) => {
-    const node = machine.stateNodes.byPath.get(path);
-    if (node === undefined) {
-        throw new Error(`Machine expected state path "${path}" to exist`);
-    }
-    return node;
-};
-export const getStateNodeSchema = (node) => {
-    if (node.schema === undefined || node.type === "history") {
-        throw new Error(`Machine history state "${node.path}" has no active value schema`);
-    }
-    return node.schema;
-};
+const pathToRootCache = new WeakMap();
 export const hasOwn = (u, key) => Object.prototype.hasOwnProperty.call(u, key);
 export const isDescendantOf = (path, ancestor) => path.startsWith(`${ancestor}.`);
 export const isPathInSubtree = (path, ancestor) => path === ancestor || isDescendantOf(path, ancestor);
 export const getPathToRoot = (machine, path) => {
+    let pathsByLeaf = pathToRootCache.get(machine.stateNodes);
+    if (pathsByLeaf === undefined) {
+        pathsByLeaf = new Map();
+        pathToRootCache.set(machine.stateNodes, pathsByLeaf);
+    }
+    const cached = pathsByLeaf.get(path);
+    if (cached !== undefined) {
+        return cached;
+    }
     const paths = [];
     let current = path;
     while (current !== undefined) {
         paths.unshift(current);
         current = getNode(machine, current).parent;
     }
+    pathsByLeaf.set(path, paths);
     return paths;
 };
 export const pathDepth = (machine, path) => getPathToRoot(machine, path).length;
@@ -489,7 +272,7 @@ export const snapshotFromConfiguration = (machine, configuration) => {
         snapshot.completed = completed;
     }
     if (configuration.history.size > 0) {
-        Object.assign(snapshot, { history: historyToSnapshot(configuration.history) });
+        Object.assign(snapshot, { history: historyToSnapshot(machine, configuration.history) });
     }
     return snapshot;
 };
@@ -499,7 +282,7 @@ export const snapshotFromConfiguration = (machine, configuration) => {
 export const snapshotFromConfigurationAtPath = (machine, configuration, path) => {
     const snapshot = snapshotFromPath(machine, configuration, path);
     if (configuration.history.size > 0) {
-        Object.assign(snapshot, { history: historyToSnapshot(configuration.history) });
+        Object.assign(snapshot, { history: historyToSnapshot(machine, configuration.history) });
     }
     return snapshot;
 };
@@ -509,11 +292,9 @@ export const configurationFromSnapshot = (machine, snapshot) => {
     const snapshotOutputs = snapshot.completed;
     const visit = (current) => {
         const node = getNode(machine, String(current.path));
-        if (!Schema.is(getStateNodeSchema(node))(current.value)) {
-            throw new Error(`Machine expected snapshot for "${node.path}" to match its schema`);
-        }
+        const value = decodeStateValueSync(machine, node, current.value);
         active.add(node.path);
-        values.set(node.path, current.value);
+        values.set(node.path, value);
         if (node.type === "compound") {
             if (!hasProperty(current, "state") || !isSnapshot(current.state)) {
                 throw new Error(`Machine expected compound snapshot "${node.path}" to include an active child state`);
@@ -555,6 +336,21 @@ export const configurationFromSnapshot = (machine, snapshot) => {
     return { active, values, outputs, history: historyFromSnapshot(machine, snapshot) };
 };
 export const normalizeConfiguration = (machine, state) => configurationFromSnapshot(machine, state);
+export const normalizeConfigurationSync = (machine, state) => {
+    try {
+        return configurationFromSnapshot(machine, state);
+    }
+    catch (cause) {
+        if (cause instanceof MachineSchemaDecodeError) {
+            throw cause;
+        }
+        throw new MachineSchemaDecodeError({
+            machineId: machine.id,
+            boundary: "configuration",
+            cause: Cause.die(cause)
+        });
+    }
+};
 export const configurationFromSnapshotEffect = Effect.fnUntraced(function* (machine, snapshot) {
     const active = new Set();
     const values = new Map();
@@ -624,7 +420,8 @@ export const validateInitialConfiguration = (machine, configuration) => {
         const node = getNode(machine, path);
         if (node.type === "compound") {
             const child = node.children.find((child) => configuration.active.has(child));
-            if (child !== node.initial) {
+            const initialNode = node.initial === undefined ? undefined : getNode(machine, node.initial);
+            if (initialNode?.type === "choice" ? child === undefined : child !== node.initial) {
                 throw new Error(`Machine initial state "${node.path}" must enter initial child "${node.initial}"`);
             }
         }
@@ -794,19 +591,30 @@ export const configurationFromTargetSnapshotEffect = Effect.fnUntraced(function*
         const ancestorNode = getNode(machine, ancestor);
         if (ancestorNode.type === "parallel") {
             for (const child of ancestorNode.children) {
-                if (pathSet.has(child) || !current.active.has(child)) {
+                if (pathSet.has(child))
                     continue;
-                }
-                for (const activePath of current.active) {
-                    if (isPathInSubtree(activePath, child)) {
-                        active.add(activePath);
-                        if (current.values.has(activePath)) {
-                            values.set(activePath, current.values.get(activePath));
-                        }
-                        if (current.outputs.has(activePath)) {
-                            outputs.set(activePath, current.outputs.get(activePath));
+                if (current.active.has(child)) {
+                    for (const activePath of current.active) {
+                        if (isPathInSubtree(activePath, child)) {
+                            active.add(activePath);
+                            if (current.values.has(activePath)) {
+                                values.set(activePath, current.values.get(activePath));
+                            }
+                            if (current.outputs.has(activePath)) {
+                                outputs.set(activePath, current.outputs.get(activePath));
+                            }
                         }
                     }
+                    continue;
+                }
+                if (providedValues !== undefined && hasOwn(providedValues, child)) {
+                    for (const [providedPath, providedValue] of Object.entries(providedValues)) {
+                        if (!isPathInSubtree(providedPath, child))
+                            continue;
+                        const providedNode = getNode(machine, providedPath);
+                        active.add(providedPath);
+                        values.set(providedPath, yield* decodeStateValue(machine, providedNode, providedValue));
+                    }
                 }
             }
         }
@@ -837,6 +645,126 @@ export const normalizeTargetConfigurationEffect = (machine, current, target) =>
     }
     throw new Error("Machine expected transition target to be a snapshot or target builder result");
 };
+const configurationFromTargetPathSync = (machine, current, path, value, providedValues) => {
+    const node = getNode(machine, path);
+    const active = new Set();
+    const values = new Map();
+    const outputs = new Map();
+    const paths = getPathToRoot(machine, node.path);
+    const pathSet = new Set(paths);
+    for (const currentPath of paths) {
+        const currentNode = getNode(machine, currentPath);
+        active.add(currentPath);
+        if (currentPath === node.path) {
+            values.set(currentPath, decodeStateValueSync(machine, currentNode, value));
+        }
+        else if (providedValues !== undefined && hasOwn(providedValues, currentPath)) {
+            values.set(currentPath, decodeStateValueSync(machine, currentNode, providedValues[currentPath]));
+        }
+        else if (current.values.has(currentPath)) {
+            values.set(currentPath, current.values.get(currentPath));
+        }
+        else {
+            throw new Error(`Machine target "${node.path}" requires a value for ancestor state "${currentPath}"`);
+        }
+    }
+    for (const ancestor of paths) {
+        const ancestorNode = getNode(machine, ancestor);
+        if (ancestorNode.type !== "parallel")
+            continue;
+        for (const child of ancestorNode.children) {
+            if (pathSet.has(child) || !current.active.has(child))
+                continue;
+            for (const activePath of current.active) {
+                if (!isPathInSubtree(activePath, child))
+                    continue;
+                active.add(activePath);
+                if (current.values.has(activePath))
+                    values.set(activePath, current.values.get(activePath));
+                if (current.outputs.has(activePath))
+                    outputs.set(activePath, current.outputs.get(activePath));
+            }
+        }
+    }
+    if (node.type === "compound" || node.type === "parallel") {
+        throw new Error(`Machine target "${node.path}" must include an active child state`);
+    }
+    return { active, values, outputs, history: current.history };
+};
+const configurationFromTargetSnapshotSync = (machine, current, snapshot, providedValues) => {
+    const subtree = configurationFromSnapshot(machine, snapshot);
+    const active = new Set(subtree.active);
+    const values = new Map(subtree.values);
+    const outputs = new Map(subtree.outputs);
+    const paths = getPathToRoot(machine, String(snapshot.path));
+    const pathSet = new Set(paths);
+    for (const ancestor of paths.slice(0, -1)) {
+        const node = getNode(machine, ancestor);
+        active.add(ancestor);
+        if (providedValues !== undefined && hasOwn(providedValues, ancestor)) {
+            values.set(ancestor, decodeStateValueSync(machine, node, providedValues[ancestor]));
+        }
+        else if (current.values.has(ancestor)) {
+            values.set(ancestor, current.values.get(ancestor));
+        }
+        else {
+            throw new Error(`Machine target "${snapshot.path}" requires a value for ancestor state "${ancestor}"`);
+        }
+    }
+    for (const ancestor of paths.slice(0, -1)) {
+        const ancestorNode = getNode(machine, ancestor);
+        if (ancestorNode.type !== "parallel")
+            continue;
+        for (const child of ancestorNode.children) {
+            if (pathSet.has(child))
+                continue;
+            if (current.active.has(child)) {
+                for (const activePath of current.active) {
+                    if (!isPathInSubtree(activePath, child))
+                        continue;
+                    active.add(activePath);
+                    if (current.values.has(activePath))
+                        values.set(activePath, current.values.get(activePath));
+                    if (current.outputs.has(activePath))
+                        outputs.set(activePath, current.outputs.get(activePath));
+                }
+                continue;
+            }
+            if (providedValues !== undefined && hasOwn(providedValues, child)) {
+                for (const [providedPath, providedValue] of Object.entries(providedValues)) {
+                    if (!isPathInSubtree(providedPath, child))
+                        continue;
+                    const providedNode = getNode(machine, providedPath);
+                    active.add(providedPath);
+                    values.set(providedPath, decodeStateValueSync(machine, providedNode, providedValue));
+                }
+            }
+        }
+    }
+    return {
+        active,
+        values,
+        outputs,
+        history: new Map([...current.history, ...subtree.history])
+    };
+};
+export const normalizeTargetConfigurationSync = (machine, current, target) => {
+    if (isTarget(target)) {
+        const snapshot = target[TargetSnapshotTypeId];
+        if (snapshot !== undefined) {
+            if (String(snapshot.path) !== String(target.path)) {
+                throw new Error(`Machine expected target snapshot path to be "${target.path}"`);
+            }
+            return configurationFromTargetSnapshotSync(machine, current, snapshot, target.values);
+        }
+        return configurationFromTargetPathSync(machine, current, target.path, target.value, target.values);
+    }
+    if (isSnapshot(target)) {
+        const configuration = normalizeConfigurationSync(machine, target);
+        return { ...configuration, history: new Map([...current.history, ...configuration.history]) };
+    }
+    throw new Error("Machine expected transition target to be a snapshot or target builder result");
+};
 export const getStateConfigByPath = (machine, path) => machine.handlers[path];
 export const getActiveChildPath = (machine, configuration, path) => getNode(machine, path).children.find((child) => configuration.active.has(child));
 export const isDirectFinalPath = (machine, path) => getNode(machine, path).type === "final";
@@ -964,297 +892,74 @@ export const completeConfigurationEffect = Effect.fnUntraced(function* (machine,
     }
     return { configuration: completed, completions };
 });
-const EncodedSnapshotSchema = Schema.Struct({
-    _tag: Schema.Literal("MachineSnapshot"),
-    active: Schema.Array(Schema.Struct({
-        path: Schema.String,
-        value: Schema.Unknown
-    })),
-    completed: Schema.optional(Schema.Array(Schema.Struct({
-        path: Schema.String,
-        output: Schema.optional(Schema.Unknown)
-    }))),
-    history: Schema.optional(Schema.Record(Schema.String, Schema.Struct({
-        mode: Schema.Literals(["shallow", "deep"]),
-        active: Schema.Array(Schema.String),
-        values: Schema.Record(Schema.String, Schema.Unknown)
-    })))
-});
-const encodeBoundary = (machine, schema, value, options) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new MachineSchemaEncodeError({
-    machineId: machine.id,
-    boundary: options.boundary,
-    state: options.state,
-    cause
-})));
-const decodeEncodedBoundary = (machine, schema, value, options) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((cause) => new MachineSchemaDecodeError({
-    machineId: machine.id,
-    boundary: options.boundary,
-    state: options.state,
-    cause
-})));
-const getCompletionSchema = (machine, configuration, path) => {
+const resolveFinalOutputSync = (machine, configuration, path, event, outputs) => {
+    const node = getNode(machine, path);
+    const output = getStateConfigByPath(machine, path)?.output?.({
+        state: getActiveValue(configuration, path),
+        parent: getParentValue(machine, configuration, path),
+        parents: getParentValues(machine, configuration, path),
+        event,
+        outputs
+    });
+    return decodeOutputValueSync(machine, node, output);
+};
+const completeActiveFinalNodeSync = (machine, configuration, path, event, outputs, completions) => {
+    if (!configuration.active.has(path))
+        return undefined;
+    if (outputs.has(path))
+        return { path, output: outputs.get(path), isNew: false };
     const node = getNode(machine, path);
     if (node.type === "compound") {
         const child = getActiveChildPath(machine, configuration, path);
-        if (child === undefined) {
-            throw new Error(`Machine expected completed state "${path}" to have an active child`);
-        }
-        return getCompletionSchema(machine, configuration, child);
-    }
-    return node.output ?? Schema.Void;
-};
-const validateEncodedConfiguration = (machine, configuration) => {
-    const snapshot = snapshotFromConfiguration(machine, configuration);
-    const normalized = configurationFromSnapshot(machine, snapshot);
-    if (normalized.active.size !== configuration.active.size ||
-        Array.from(configuration.active).some((path) => !normalized.active.has(path))) {
-        throw new Error("Machine encoded snapshot contains states outside its active configuration");
-    }
-    return snapshot;
-};
-const failEncodeCause = (machine, cause) => {
-    const error = Cause.findErrorOption(cause);
-    return Option.isSome(error) && error.value instanceof MachineSchemaEncodeError
-        ? Effect.fail(error.value)
-        : Effect.fail(new MachineSchemaEncodeError({
-            machineId: machine.id,
-            boundary: "configuration",
-            cause
-        }));
-};
-const failDecodeCause = (machine, cause) => {
-    const error = Cause.findErrorOption(cause);
-    return Option.isSome(error) && error.value instanceof MachineSchemaDecodeError
-        ? Effect.fail(error.value)
-        : Effect.fail(new MachineSchemaDecodeError({
-            machineId: machine.id,
-            boundary: "configuration",
-            cause
-        }));
-};
-export const encodeSnapshot = (machine, snapshot) => Effect.gen(function* () {
-    const configuration = yield* normalizeConfigurationEffect(machine, snapshot).pipe(Effect.mapError((error) => new MachineSchemaEncodeError({
-        machineId: machine.id,
-        boundary: error.boundary === "state" || error.boundary === "history" ? error.boundary : "configuration",
-        ...(error.state === undefined ? {} : { state: error.state }),
-        cause: error.cause
-    })));
-    const completionPaths = new Set();
-    for (const completion of snapshot.completed ?? []) {
-        if (completionPaths.has(completion.path)) {
-            throw new Error(`Machine snapshot contains duplicate completion "${completion.path}"`);
-        }
-        if (!configuration.active.has(completion.path) || !isActiveFinalNode(machine, configuration, completion.path)) {
-            throw new Error(`Machine snapshot contains invalid completion "${completion.path}"`);
-        }
-        completionPaths.add(completion.path);
-    }
-    const active = [];
-    for (const path of Array.from(configuration.active).sort((left, right) => compareDocumentOrder(machine, left, right))) {
-        const node = getNode(machine, path);
-        active.push({
-            path,
-            value: yield* encodeBoundary(machine, getStateNodeSchema(node), getActiveValue(configuration, path), {
-                boundary: "state",
-                state: path
-            })
-        });
-    }
-    const completed = [];
-    for (const [path, output] of Array.from(configuration.outputs).sort(([left], [right]) => compareDocumentOrder(machine, left, right))) {
-        if (!configuration.active.has(path) || !isActiveFinalNode(machine, configuration, path)) {
-            throw new Error(`Machine encoded snapshot contains invalid completion "${path}"`);
-        }
-        const encodedOutput = yield* encodeBoundary(machine, getCompletionSchema(machine, configuration, path), output, {
-            boundary: "output",
-            state: path
-        });
-        completed.push({
-            path,
-            ...(encodedOutput === undefined ? {} : { output: encodedOutput })
-        });
-    }
-    const history = {};
-    for (const [historyPath, record] of Array.from(configuration.history).sort(([left], [right]) => left.localeCompare(right))) {
-        const historyNode = machine.stateNodes.byPath.get(historyPath);
-        if (historyNode === undefined || historyNode.type !== "history" || historyNode.parent !== record.parent ||
-            historyNode.history !== record.mode) {
-            return yield* Effect.fail(new MachineSchemaEncodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(new Error(`Machine snapshot contains invalid history record "${historyPath}"`))
-            }));
-        }
-        try {
-            validateHistoryRecordControl(machine, record);
-        }
-        catch (cause) {
-            return yield* Effect.fail(new MachineSchemaEncodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(cause)
-            }));
-        }
-        const encodedValues = {};
-        for (const path of record.active) {
-            const stateNode = machine.stateNodes.byPath.get(path);
-            if (stateNode === undefined || stateNode.type === "history" || !record.values.has(path) ||
-                !(isPathInSubtree(path, record.parent) || getPathToRoot(machine, record.parent).includes(path))) {
-                return yield* Effect.fail(new MachineSchemaEncodeError({
-                    machineId: machine.id,
-                    boundary: "history",
-                    state: path,
-                    cause: Cause.die(new Error(`Machine snapshot contains invalid remembered state "${path}"`))
-                }));
-            }
-            encodedValues[path] = yield* encodeBoundary(machine, getStateNodeSchema(stateNode), record.values.get(path), { boundary: "history", state: path });
-        }
-        if (record.values.size !== record.active.size) {
-            return yield* Effect.fail(new MachineSchemaEncodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(new Error(`Machine history record "${historyPath}" contains values outside its paths`))
-            }));
-        }
-        history[historyPath] = {
-            mode: record.mode,
-            active: Array.from(record.active).sort((left, right) => compareDocumentOrder(machine, left, right)),
-            values: encodedValues
-        };
-    }
-    return {
-        _tag: "MachineSnapshot",
-        active,
-        ...(completed.length === 0 ? {} : { completed }),
-        ...(Object.keys(history).length === 0 ? {} : { history })
-    };
-}).pipe(Effect.catchCause((cause) => failEncodeCause(machine, cause)));
-export const decodeSnapshot = (machine, encoded) => Effect.gen(function* () {
-    const decoded = yield* Schema.decodeUnknownEffect(EncodedSnapshotSchema)(encoded).pipe(Effect.mapError((cause) => new MachineSchemaDecodeError({
-        machineId: machine.id,
-        boundary: "configuration",
-        cause
-    })));
-    const active = new Set();
-    const values = new Map();
-    for (const entry of decoded.active) {
-        if (active.has(entry.path)) {
-            throw new Error(`Machine encoded snapshot contains duplicate state "${entry.path}"`);
-        }
-        const node = getNode(machine, entry.path);
-        active.add(entry.path);
-        values.set(entry.path, yield* decodeEncodedBoundary(machine, getStateNodeSchema(node), entry.value, {
-            boundary: "state",
-            state: entry.path
-        }));
+        if (child === undefined || !isDirectFinalPath(machine, child))
+            return undefined;
+        const childCompletion = completeActiveFinalNodeSync(machine, configuration, child, event, outputs, completions);
+        if (childCompletion === undefined)
+            return undefined;
+        const completion = setCompletedOutput(outputs, path, childCompletion.output);
+        if (completion.isNew)
+            completions.push(completion);
+        return completion;
     }
-    const history = new Map();
-    for (const [historyPath, encodedRecord] of Object.entries(decoded.history ?? {})) {
-        const historyNode = machine.stateNodes.byPath.get(historyPath);
-        if (historyNode === undefined || historyNode.type !== "history" || historyNode.parent === undefined ||
-            historyNode.history !== encodedRecord.mode) {
-            return yield* Effect.fail(new MachineSchemaDecodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(new Error(`Machine encoded snapshot contains invalid history record "${historyPath}"`))
-            }));
-        }
-        const rememberedActive = new Set();
-        const rememberedValues = new Map();
-        for (const path of encodedRecord.active) {
-            if (rememberedActive.has(path)) {
-                return yield* Effect.fail(new MachineSchemaDecodeError({
-                    machineId: machine.id,
-                    boundary: "history",
-                    state: path,
-                    cause: Cause.die(new Error(`Machine encoded history contains duplicate state "${path}"`))
-                }));
-            }
-            const stateNode = machine.stateNodes.byPath.get(path);
-            if (stateNode === undefined || stateNode.type === "history" ||
-                !Object.prototype.hasOwnProperty.call(encodedRecord.values, path) ||
-                !(isPathInSubtree(path, historyNode.parent) || getPathToRoot(machine, historyNode.parent).includes(path))) {
-                return yield* Effect.fail(new MachineSchemaDecodeError({
-                    machineId: machine.id,
-                    boundary: "history",
-                    state: path,
-                    cause: Cause.die(new Error(`Machine encoded snapshot contains invalid remembered state "${path}"`))
-                }));
-            }
-            rememberedActive.add(path);
-            rememberedValues.set(path, yield* decodeEncodedBoundary(machine, getStateNodeSchema(stateNode), encodedRecord.values[path], {
-                boundary: "history",
-                state: path
-            }));
-        }
-        if (Object.keys(encodedRecord.values).length !== rememberedActive.size) {
-            return yield* Effect.fail(new MachineSchemaDecodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(new Error(`Machine encoded history "${historyPath}" contains values outside its paths`))
-            }));
-        }
-        if (!rememberedActive.has(historyNode.parent)) {
-            return yield* Effect.fail(new MachineSchemaDecodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(new Error(`Machine encoded history "${historyPath}" does not contain its parent state`))
-            }));
-        }
-        const record = {
-            mode: encodedRecord.mode,
-            parent: historyNode.parent,
-            active: rememberedActive,
-            values: rememberedValues
-        };
-        try {
-            validateHistoryRecordControl(machine, record);
-        }
-        catch (cause) {
-            return yield* Effect.fail(new MachineSchemaDecodeError({
-                machineId: machine.id,
-                boundary: "history",
-                state: historyPath,
-                cause: Cause.die(cause)
-            }));
+    if (node.type === "parallel") {
+        const regionOutputs = {};
+        let completed = true;
+        for (const child of node.children) {
+            const childCompletion = completeActiveFinalNodeSync(machine, configuration, child, event, outputs, completions);
+            if (childCompletion === undefined)
+                completed = false;
+            else
+                regionOutputs[getNode(machine, child).key] = childCompletion.output;
         }
-        history.set(historyPath, record);
+        if (!completed)
+            return undefined;
+        const completion = setCompletedOutput(outputs, path, resolveFinalOutputSync(machine, configuration, path, event, regionOutputs));
+        if (completion.isNew)
+            completions.push(completion);
+        return completion;
     }
-    const configuration = {
-        active,
-        values,
-        outputs: new Map(),
-        history
-    };
-    const snapshot = validateEncodedConfiguration(machine, configuration);
+    if (!isDirectFinalPath(machine, path))
+        return undefined;
+    const completion = setCompletedOutput(outputs, path, resolveFinalOutputSync(machine, configuration, path, event));
+    if (completion.isNew)
+        completions.push(completion);
+    return completion;
+};
+export const completeConfigurationSync = (machine, configuration, event) => {
+    const outputs = new Map(configuration.outputs);
     const completions = [];
-    const completionPaths = new Set();
-    for (const completion of decoded.completed ?? []) {
-        if (completionPaths.has(completion.path)) {
-            throw new Error(`Machine encoded snapshot contains duplicate completion "${completion.path}"`);
-        }
-        if (!active.has(completion.path) || !isActiveFinalNode(machine, configuration, completion.path)) {
-            throw new Error(`Machine encoded snapshot contains invalid completion "${completion.path}"`);
-        }
-        completionPaths.add(completion.path);
-        completions.push({
-            path: completion.path,
-            output: yield* decodeEncodedBoundary(machine, getCompletionSchema(machine, configuration, completion.path), completion.output, {
-                boundary: "output",
-                state: completion.path
-            })
-        });
-    }
-    if (completions.length > 0) {
-        ;
-        snapshot.completed = completions;
+    const completed = {
+        active: configuration.active,
+        values: configuration.values,
+        outputs,
+        history: configuration.history
+    };
+    for (const path of Array.from(completed.active).sort((left, right) => {
+        const depth = pathDepth(machine, right) - pathDepth(machine, left);
+        return depth === 0 ? compareDocumentOrder(machine, left, right) : depth;
+    })) {
+        completeActiveFinalNodeSync(machine, completed, path, event, outputs, completions);
     }
-    return snapshot;
-}).pipe(Effect.catchCause((cause) => failDecodeCause(machine, cause)));
-//# sourceMappingURL=machineModel.js.map
+    return { configuration: completed, completions };
+};
+//# sourceMappingURL=configuration.js.map