@typeonce/effect-machine 0.2.0 → 0.4.0

package/dist/internal/machineModel.js

@@ -1,766 +0,0 @@
-/**
- * Internal machine representation helpers.
- *
- * @since 4.0.0
- */
-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 getStateNodeDefinition = (path, definition) => {
-    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}`,
-                order
-            };
-            byPath.set(path, node);
-            paths.push(path);
-            order += 1;
-            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,
-    path,
-    value,
-    values: options?.values
-});
-export const isTarget = (u) => hasProperty(u, TargetTypeId);
-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) => decodeBoundary(machine, node.schema, 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 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) => {
-    const paths = [];
-    let current = path;
-    while (current !== undefined) {
-        paths.unshift(current);
-        current = getNode(machine, current).parent;
-    }
-    return paths;
-};
-export const pathDepth = (machine, path) => getPathToRoot(machine, path).length;
-export const compareDocumentOrder = (machine, left, right) => getNode(machine, left).order - getNode(machine, right).order;
-export const hasActiveChild = (machine, configuration, path) => getNode(machine, path).children.some((child) => configuration.active.has(child));
-export const getActiveLeafPaths = (machine, configuration) => {
-    const leaves = Array.from(configuration.active)
-        .filter((path) => !hasActiveChild(machine, configuration, path))
-        .sort((left, right) => compareDocumentOrder(machine, left, right));
-    if (leaves.length === 0) {
-        throw new Error("Machine expected an active leaf state");
-    }
-    return leaves;
-};
-export const getLeafPath = (machine, configuration) => getActiveLeafPaths(machine, configuration)[0];
-export const getActiveLeafPathFrom = (machine, configuration, path) => {
-    const leaves = getActiveLeafPaths(machine, configuration)
-        .filter((leaf) => isPathInSubtree(leaf, path));
-    if (leaves.length === 0) {
-        throw new Error(`Machine expected state "${path}" to have an active leaf state`);
-    }
-    return leaves[0];
-};
-export const getRootPath = (machine, configuration) => {
-    for (const path of configuration.active) {
-        if (getNode(machine, path).parent === undefined) {
-            return path;
-        }
-    }
-    throw new Error("Machine expected an active root state");
-};
-export const getActiveValue = (configuration, path) => {
-    if (!configuration.values.has(path)) {
-        throw new Error(`Machine expected active state "${path}" to have a value`);
-    }
-    return configuration.values.get(path);
-};
-export const getParentValues = (machine, configuration, path) => {
-    const parents = {};
-    const paths = getPathToRoot(machine, path);
-    for (let index = 0; index < paths.length - 1; index++) {
-        const parent = paths[index];
-        parents[parent] = getActiveValue(configuration, parent);
-    }
-    return parents;
-};
-export const getParentValue = (machine, configuration, path) => {
-    const parent = getNode(machine, path).parent;
-    return parent === undefined ? undefined : getActiveValue(configuration, parent);
-};
-export const getInitialEntryPaths = (machine, configuration) => {
-    const visit = (path) => {
-        if (!configuration.active.has(path)) {
-            return [];
-        }
-        const node = getNode(machine, path);
-        return [
-            path,
-            ...node.children.flatMap(visit)
-        ];
-    };
-    return machine.stateNodes.roots.flatMap(visit);
-};
-export const snapshotFromPath = (machine, configuration, path) => {
-    const node = getNode(machine, path);
-    const snapshot = {
-        path,
-        value: getActiveValue(configuration, path)
-    };
-    if (node.type === "compound") {
-        const child = node.children.find((child) => configuration.active.has(child));
-        if (child === undefined) {
-            throw new Error(`Machine expected compound state "${path}" to have an active child`);
-        }
-        snapshot.state = snapshotFromPath(machine, configuration, child);
-    }
-    if (node.type === "parallel") {
-        const states = {};
-        for (const child of node.children) {
-            if (!configuration.active.has(child)) {
-                throw new Error(`Machine expected parallel state "${path}" to have active child region "${child}"`);
-            }
-            const childNode = getNode(machine, child);
-            states[childNode.key] = snapshotFromPath(machine, configuration, child);
-        }
-        snapshot.states = states;
-    }
-    return snapshot;
-};
-export const snapshotFromConfiguration = (machine, configuration) => {
-    const snapshot = snapshotFromPath(machine, configuration, getRootPath(machine, configuration));
-    const completed = Array.from(configuration.outputs)
-        .map(([path, output]) => ({ path, output }));
-    if (completed.length > 0) {
-        ;
-        snapshot.completed = completed;
-    }
-    return snapshot;
-};
-export const configurationFromSnapshot = (machine, snapshot) => {
-    const active = new Set();
-    const values = new Map();
-    const snapshotOutputs = snapshot.completed;
-    const visit = (current) => {
-        const node = getNode(machine, String(current.path));
-        if (!Schema.is(node.schema)(current.value)) {
-            throw new Error(`Machine expected snapshot for "${node.path}" to match its schema`);
-        }
-        active.add(node.path);
-        values.set(node.path, current.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`);
-            }
-            const child = getNode(machine, String(current.state.path));
-            if (child.parent !== node.path) {
-                throw new Error(`Machine expected snapshot "${child.path}" to be a child of "${node.path}"`);
-            }
-            visit(current.state);
-        }
-        if (node.type === "parallel") {
-            if (!hasProperty(current, "states") || typeof current.states !== "object" || current.states === null) {
-                throw new Error(`Machine expected parallel snapshot "${node.path}" to include active child regions`);
-            }
-            const states = current.states;
-            for (const childPath of node.children) {
-                const child = getNode(machine, childPath);
-                const childSnapshot = states[child.key];
-                if (!hasOwn(states, child.key) || !isSnapshot(childSnapshot)) {
-                    throw new Error(`Machine expected parallel snapshot "${node.path}" to include region "${child.key}"`);
-                }
-                const snapshotChild = getNode(machine, String(childSnapshot.path));
-                if (snapshotChild.path !== child.path) {
-                    throw new Error(`Machine expected snapshot "${snapshotChild.path}" to be region "${child.path}"`);
-                }
-                visit(childSnapshot);
-            }
-        }
-    };
-    visit(snapshot);
-    const outputs = new Map();
-    if (snapshotOutputs !== undefined) {
-        for (const { output, path } of snapshotOutputs) {
-            if (active.has(path)) {
-                outputs.set(path, output);
-            }
-        }
-    }
-    return { active, values, outputs };
-};
-export const normalizeConfiguration = (machine, state) => configurationFromSnapshot(machine, state);
-export const configurationFromSnapshotEffect = Effect.fnUntraced(function* (machine, snapshot) {
-    const active = new Set();
-    const values = new Map();
-    const snapshotOutputs = snapshot.completed;
-    const visit = Effect.fnUntraced(function* (current) {
-        const node = getNode(machine, String(current.path));
-        const value = yield* decodeStateValue(machine, node, current.value);
-        active.add(node.path);
-        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`);
-            }
-            const child = getNode(machine, String(current.state.path));
-            if (child.parent !== node.path) {
-                throw new Error(`Machine expected snapshot "${child.path}" to be a child of "${node.path}"`);
-            }
-            yield* visit(current.state);
-        }
-        if (node.type === "parallel") {
-            if (!hasProperty(current, "states") || typeof current.states !== "object" || current.states === null) {
-                throw new Error(`Machine expected parallel snapshot "${node.path}" to include active child regions`);
-            }
-            const states = current.states;
-            for (const childPath of node.children) {
-                const child = getNode(machine, childPath);
-                const childSnapshot = states[child.key];
-                if (!hasOwn(states, child.key) || !isSnapshot(childSnapshot)) {
-                    throw new Error(`Machine expected parallel snapshot "${node.path}" to include region "${child.key}"`);
-                }
-                const snapshotChild = getNode(machine, String(childSnapshot.path));
-                if (snapshotChild.path !== child.path) {
-                    throw new Error(`Machine expected snapshot "${snapshotChild.path}" to be region "${child.path}"`);
-                }
-                yield* visit(childSnapshot);
-            }
-        }
-    });
-    yield* visit(snapshot);
-    const outputs = new Map();
-    if (snapshotOutputs !== undefined) {
-        for (const { output, path } of snapshotOutputs) {
-            if (active.has(path)) {
-                outputs.set(path, output);
-            }
-        }
-    }
-    return { active, values, outputs };
-});
-export const normalizeConfigurationEffect = (machine, state) => configurationFromSnapshotEffect(machine, state).pipe(Effect.catchCause((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 validateInitialConfiguration = (machine, configuration) => {
-    for (const path of configuration.active) {
-        const node = getNode(machine, path);
-        if (node.type === "compound") {
-            const child = node.children.find((child) => configuration.active.has(child));
-            if (child !== node.initial) {
-                throw new Error(`Machine initial state "${node.path}" must enter initial child "${node.initial}"`);
-            }
-        }
-        if (node.type === "parallel") {
-            for (const child of node.children) {
-                if (!configuration.active.has(child)) {
-                    throw new Error(`Machine initial state "${node.path}" must enter child region "${child}"`);
-                }
-            }
-        }
-    }
-};
-export const configurationFromTargetPathEffect = Effect.fnUntraced(function* (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, yield* decodeStateValue(machine, currentNode, value));
-        }
-        else if (providedValues !== undefined && hasOwn(providedValues, currentPath)) {
-            values.set(currentPath, yield* decodeStateValue(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") {
-            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)) {
-                        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 };
-});
-export const normalizeTargetConfigurationEffect = (machine, current, target) => {
-    if (isTarget(target)) {
-        return configurationFromTargetPathEffect(machine, current, target.path, target.value, target.values);
-    }
-    if (isSnapshot(target)) {
-        return normalizeConfigurationEffect(machine, target);
-    }
-    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";
-export const hasCompletionHandler = (machine, path) => getStateConfigByPath(machine, path)?.onDone !== undefined;
-export const isActiveFinalNode = (machine, configuration, path) => {
-    if (!configuration.active.has(path)) {
-        return false;
-    }
-    const node = getNode(machine, path);
-    if (node.type === "compound") {
-        const child = getActiveChildPath(machine, configuration, path);
-        return child !== undefined && isDirectFinalPath(machine, child);
-    }
-    if (node.type === "parallel") {
-        for (const child of node.children) {
-            if (!isActiveFinalNode(machine, configuration, child)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return isDirectFinalPath(machine, path);
-};
-export const isActiveFinalConfiguration = (machine, configuration) => {
-    const root = getRootPath(machine, configuration);
-    return isActiveFinalNode(machine, configuration, root) && !hasCompletionHandler(machine, root);
-};
-export const setCompletedOutput = (outputs, path, output) => {
-    if (outputs.has(path)) {
-        return {
-            path,
-            output: outputs.get(path),
-            isNew: false
-        };
-    }
-    outputs.set(path, output);
-    return {
-        path,
-        output,
-        isNew: true
-    };
-};
-export const resolveFinalOutputEffect = Effect.fnUntraced(function* (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 yield* decodeOutputValue(machine, node, output);
-});
-export const completeActiveFinalNodeEffect = Effect.fnUntraced(function* (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 || !isDirectFinalPath(machine, child)) {
-            return undefined;
-        }
-        const childCompletion = yield* completeActiveFinalNodeEffect(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;
-    }
-    if (node.type === "parallel") {
-        const regionOutputs = {};
-        let completed = true;
-        for (const child of node.children) {
-            const childCompletion = yield* completeActiveFinalNodeEffect(machine, configuration, child, event, outputs, completions);
-            if (childCompletion === undefined) {
-                completed = false;
-            }
-            else {
-                regionOutputs[getNode(machine, child).key] = childCompletion.output;
-            }
-        }
-        if (!completed) {
-            return undefined;
-        }
-        const completion = setCompletedOutput(outputs, path, yield* resolveFinalOutputEffect(machine, configuration, path, event, regionOutputs));
-        if (completion.isNew) {
-            completions.push(completion);
-        }
-        return completion;
-    }
-    if (!isDirectFinalPath(machine, path)) {
-        return undefined;
-    }
-    const completion = setCompletedOutput(outputs, path, yield* resolveFinalOutputEffect(machine, configuration, path, event));
-    if (completion.isNew) {
-        completions.push(completion);
-    }
-    return completion;
-});
-export const completeConfigurationEffect = Effect.fnUntraced(function* (machine, configuration, event) {
-    const outputs = new Map(configuration.outputs);
-    const completions = [];
-    const completed = {
-        active: configuration.active,
-        values: configuration.values,
-        outputs
-    };
-    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;
-    })) {
-        yield* completeActiveFinalNodeEffect(machine, completed, path, event, outputs, completions);
-    }
-    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)
-    })))
-});
-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 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" ? "state" : "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, node.schema, 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 })
-        });
-    }
-    return {
-        _tag: "MachineSnapshot",
-        active,
-        ...(completed.length === 0 ? {} : { completed })
-    };
-}).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, node.schema, entry.value, {
-            boundary: "state",
-            state: entry.path
-        }));
-    }
-    const configuration = {
-        active,
-        values,
-        outputs: new Map()
-    };
-    const snapshot = validateEncodedConfiguration(machine, configuration);
-    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;
-    }
-    return snapshot;
-}).pipe(Effect.catchCause((cause) => failDecodeCause(machine, cause)));
-//# sourceMappingURL=machineModel.js.map