@typeonce/effect-machine 0.31.2 → 0.33.0

package/dist/internal/machine/machine.js

@@ -3,15 +3,18 @@ import * as Inspectable from "effect/Inspectable";
 import * as Option from "effect/Option";
 import { Prototype as PipeablePrototype } from "effect/Pipeable";
 import { hasProperty } from "effect/Predicate";
+import * as Schema from "effect/Schema";
 import * as Activities from "./activities.js";
 import * as Configuration from "./configuration.js";
+import * as InvocationDefinition from "./invocationDefinition.js";
 import * as internalPlanner from "./planner.js";
 import * as internalProcess from "./process.js";
 import * as Protocol from "./protocol.js";
 import * as internalRuntime from "./runtime.js";
 import * as Serialization from "./serialization.js";
 import * as StateDefinition from "./stateDefinition.js";
-import { ChildMachineLogicTypeId, SnapshotBuilderStateTypeId } from "./symbols.js";
+import { ChildMachineLogicTypeId } from "./symbols.js";
+import { getLocalTargetScope, getTargetBuilderNode, makeSnapshotBuilder, makeTargetBuilder, withFrom } from "./targetBuilder.js";
 import * as Topology from "./topology.js";
 export { ChildAlreadyExistsError, InfiniteTransitionError, MachineSchemaDecodeError, MachineSchemaEncodeError, ProcessLocalError, StartupError, StoppedError } from "./errors.js";
 export { ChildMachineLogicTypeId, InitialEventTypeId, SnapshotBuilderStateTypeId } from "./symbols.js";
@@ -34,6 +37,7 @@ const Proto = {
 const makeWithHandlers = (self, handlers) => {
     const machine = Object.create(Proto);
     machine.states = self.states;
+    machine.root = self.root;
     machine.events = self.events;
     machine.internalEvents = self.internalEvents;
     machine.emittedEvents = self.emittedEvents;
@@ -57,26 +61,50 @@ const transitionOptions = (options) => {
     const configuration = typeof options === "object" && options !== null
         ? options
         : {};
-    return {
-        reenter: configuration.reenter === true,
-        declinable: configuration.declinable === true
-    };
+    if (hasProperty(configuration, "reenter")) {
+        throw new Error("Use .reenter() before construction instead of the resolver reenter option");
+    }
+    return { declinable: configuration.declinable === true };
 };
-const makeDirectTransitionDescriptor = (selection, resolve, options) => {
+const makeDirectTransitionDescriptor = (selection, resolve, options, reenterSource = false) => {
     const shared = {
         [TransitionBuilderDescriptorTypeId]: TransitionBuilderDescriptorTypeId,
         type: "direct",
         selection: plainTargetSelection(selection),
+        reenterSource,
         ...transitionOptions(options)
     };
     return resolve === undefined
         ? Object.freeze(shared)
-        : Object.freeze({ ...shared, resolve });
+        : Object.freeze({ ...shared, resolver: resolve });
+};
+// The authored callback crosses an erased schema boundary here. Each builder
+// retains its construction mode, and planning validates both resulting values.
+const constructSelectionValue = (selection, context, method, value) => {
+    if (selection.kind === "update")
+        return context.owner[method](value);
+    if (selection.updatePath === undefined)
+        return context.target[method](value);
+    const values = value;
+    return context.target[method](values.target).update(context.owner[method](values.update));
+};
+const guardedSelection = (selection, predicate, reenterSource) => {
+    const wrap = (resolve, options) => makeDirectTransitionDescriptor(selection, (context, enqueue) => predicate(context) ? resolve(context, enqueue) : Topology.makeDeclined(), { ...transitionOptions(options), declinable: true }, reenterSource);
+    return Object.freeze({
+        ...wrap((context) => selection.kind === "none" ? undefined : constructSelectedTarget(context.target)),
+        from: (value) => wrap((context) => constructSelectionValue(selection, context, "from", value(context))),
+        decoded: (value) => wrap((context) => constructSelectionValue(selection, context, "decoded", value(context))),
+        resolve: wrap
+    });
 };
-const decorateTransitionSelection = (selection) => Object.freeze({
+const decorateTransitionSelection = (selection, reenterSource = false) => Object.freeze({
     ...selection,
-    resolve: (resolve, options) => makeDirectTransitionDescriptor(selection, resolve, options),
-    reenter: () => makeDirectTransitionDescriptor(selection, undefined, { reenter: true }),
+    ...(reenterSource ? makeDirectTransitionDescriptor(selection, undefined, undefined, true) : {}),
+    guard: (predicate) => guardedSelection(selection, predicate, reenterSource),
+    from: (value) => makeDirectTransitionDescriptor(selection, (context) => constructSelectionValue(selection, context, "from", value(context)), undefined, reenterSource),
+    decoded: (value) => makeDirectTransitionDescriptor(selection, (context) => constructSelectionValue(selection, context, "decoded", value(context)), undefined, reenterSource),
+    resolve: (resolve, options) => makeDirectTransitionDescriptor(selection, resolve, options, reenterSource),
+    reenter: () => decorateTransitionSelection(selection, true),
     updating: (owner) => {
         if (typeof owner !== "function") {
             throw new Error("Machine updating owner must be a state selector");
@@ -86,14 +114,9 @@ const decorateTransitionSelection = (selection) => Object.freeze({
             ownerSelection.scope !== "branch") {
             throw new Error("Machine updating owner must be addressed by one branch state selector");
         }
-        return decorateTransitionSelection(Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, ownerSelection.path));
+        return decorateTransitionSelection(Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, ownerSelection.path), reenterSource);
     }
 });
-const decorateStateUpdateSelection = (selection) => {
-    const update = (resolve, options) => makeDirectTransitionDescriptor(selection, resolve, options);
-    Object.assign(update, selection);
-    return Object.freeze(update);
-};
 const noneTransitionSelection = decorateTransitionSelection(Topology.noneTargetSelection);
 const makeInitialBuilderDescriptor = (selection, resolve) => Object.freeze({
     [InitialBuilderDescriptorTypeId]: InitialBuilderDescriptorTypeId,
@@ -102,6 +125,8 @@ const makeInitialBuilderDescriptor = (selection, resolve) => Object.freeze({
 });
 const decorateInitialSelection = (selection) => Object.freeze({
     ...selection,
+    from: (value) => makeInitialBuilderDescriptor(selection, (context) => context.target.from(value(context))),
+    decoded: (value) => makeInitialBuilderDescriptor(selection, (context) => context.target.decoded(value(context))),
     resolve: (resolve) => makeInitialBuilderDescriptor(selection, resolve)
 });
 const decorateInitialSelectorNode = (node) => {
@@ -125,8 +150,12 @@ const decorateInitialSelectorNode = (node) => {
 };
 const decorateTransitionSelectorNode = (node) => {
     if (Topology.isTargetSelection(node)) {
-        if (node.kind === "update")
-            return decorateStateUpdateSelection(node);
+        if (node.kind === "state" && node.scope === "full" && hasProperty(node, "initial")) {
+            return Object.freeze({
+                ...decorateTransitionSelection(node),
+                initial: decorateTransitionSelection(node.initial)
+            });
+        }
         return node === Topology.noneTargetSelection ? noneTransitionSelection : decorateTransitionSelection(node);
     }
     if (typeof node === "function") {
@@ -145,24 +174,24 @@ const decorateTransitionSelectorNode = (node) => {
     }
     return node;
 };
-const makeTransitionSelector = (stateNodes, source) => {
-    const selector = {
-        ...decorateTransitionSelectorNode(makeTargetSelector(stateNodes, source))
-    };
-    selector.branches = (declarations) => Object.freeze({
-        resolve: (resolve, options) => Object.freeze({
-            [TransitionBuilderDescriptorTypeId]: TransitionBuilderDescriptorTypeId,
-            type: "branches",
-            declarations,
-            resolve,
-            ...transitionOptions(options)
-        })
-    });
-    return Object.freeze(selector);
-};
+const decorateBranches = (declarations, reenterSource = false) => Object.freeze({
+    reenter: () => decorateBranches(declarations, true),
+    resolve: (resolve, options) => Object.freeze({
+        [TransitionBuilderDescriptorTypeId]: TransitionBuilderDescriptorTypeId,
+        type: "branches",
+        declarations,
+        resolve,
+        reenterSource,
+        ...transitionOptions(options)
+    })
+});
+const makeTransitionSelector = (stateNodes, source) => Object.freeze({
+    ...decorateTransitionSelectorNode(makeTargetSelector(stateNodes, source)),
+    branches: (declarations) => decorateBranches(declarations)
+});
 const normalizeTransitionBuilder = (transition, stateNodes, path) => {
     const result = transition(makeTransitionSelector(stateNodes, path));
-    if (Topology.isTargetSelection(result)) {
+    if (Topology.isTargetSelection(result) && !hasProperty(result, TransitionBuilderDescriptorTypeId)) {
         const selection = plainTargetSelection(result);
         return { target: () => selection };
     }
@@ -173,14 +202,14 @@ const normalizeTransitionBuilder = (transition, stateNodes, path) => {
         return {
             branches: () => descriptor.declarations,
             resolve: descriptor.resolve,
-            reenter: descriptor.reenter,
+            reenter: descriptor.reenterSource,
             declinable: descriptor.declinable
         };
     }
     return {
         target: () => descriptor.selection,
-        resolve: descriptor.resolve,
-        reenter: descriptor.reenter,
+        resolve: descriptor.resolver,
+        reenter: descriptor.reenterSource,
         declinable: descriptor.declinable
     };
 };
@@ -215,7 +244,7 @@ const makeSelectionNode = (stateNodes, path, scope, source) => {
             addSelectionChildren(method, stateNodes, path, scope, source);
         }
         if (scope === "branch" && source !== undefined && node.schema !== undefined &&
-            (source === path || source.startsWith(`${path}.`)) &&
+            (source === path || Configuration.isDescendantOf(source, path)) &&
             getTargetBuilderNode(stateNodes, source).type !== "choice") {
             Object.defineProperty(method, "update", {
                 value: makeStateUpdateSelection(path, "branch"),
@@ -223,6 +252,9 @@ const makeSelectionNode = (stateNodes, path, scope, source) => {
             });
         }
     }
+    if (node.type === "atomic" && scope === "branch" && source === path && node.schema !== undefined) {
+        Object.defineProperty(method, "update", { value: makeStateUpdateSelection(path, "branch"), enumerable: true });
+    }
     return method;
 };
 const makeHistorySelectionTree = (stateNodes, parent) => {
@@ -242,15 +274,12 @@ const makeHistorySelectionTree = (stateNodes, parent) => {
     return builder;
 };
 const makeTargetSelector = (stateNodes, source) => {
-    const full = {};
-    for (const node of stateNodes.byPath.values()) {
-        if (node.parent === undefined && node.type !== "history" && node.type !== "choice") {
-            full[node.key] = makeSelectionNode(stateNodes, node.path, "full");
-        }
-    }
+    const full = Object.assign({}, makeSelectionValue("state", "", "full"), {
+        initial: makeSelectionValue("initial", "", "full")
+    });
     const branch = {};
-    const root = getTargetBuilderNode(stateNodes, source.split(".")[0]);
-    branch[root.key] = makeSelectionNode(stateNodes, root.path, "branch", source);
+    const root = getTargetBuilderNode(stateNodes, stateNodes.roots[0]);
+    addSelectionChildren(branch, stateNodes, root.path, "branch", source);
     const local = {};
     const localScope = getLocalTargetScope(stateNodes, source);
     if (localScope !== undefined) {
@@ -265,10 +294,15 @@ const makeTargetSelector = (stateNodes, source) => {
     }
     return {
         none: Topology.noneTargetSelection,
+        self: getTargetBuilderNode(stateNodes, source).schema === undefined ||
+            getTargetBuilderNode(stateNodes, source).type === "final"
+            ? {}
+            : { update: makeStateUpdateSelection(source, "branch") },
+        root: makeSelectionNode(stateNodes, root.path, "branch", source),
         local,
         branch,
         full,
-        history: makeHistorySelectionTree(stateNodes, undefined)
+        history: makeHistorySelectionTree(stateNodes, "")
     };
 };
 const captureDefinitionBranch = (branch, selector, stateNodes, path, trigger) => {
@@ -327,6 +361,8 @@ const getSelectionBuilder = (target, selection, stateNodes, source) => {
     let parts = selection.path.split(".");
     if (selection.kind === "history") {
         builder = target.history;
+        if (selection.path !== "")
+            parts.unshift("");
     }
     else if (selection.scope === "local") {
         builder = target.local;
@@ -337,12 +373,14 @@ const getSelectionBuilder = (target, selection, stateNodes, source) => {
                 parts = [];
             }
             else {
-                parts = selection.path.slice(scope.length + 1).split(".");
+                parts = (scope === "" ? selection.path : selection.path.slice(scope.length + 1)).split(".");
             }
         }
     }
     else if (selection.scope === "branch") {
         builder = target.branch;
+        if (selection.path !== "")
+            parts.unshift("");
     }
     else {
         builder = target.full;
@@ -390,7 +428,7 @@ const validateResolvedSelection = (result, selection, stateNodes) => {
     const acceptsDescendant = (selection.scope === "local" || selection.scope === "branch") &&
         (selectedNode?.type === "compound" || selectedNode?.type === "parallel");
     if (resultPath === undefined ||
-        (resultPath !== selection.path && !(acceptsDescendant && resultPath.startsWith(`${selection.path}.`)))) {
+        (resultPath !== selection.path && !(acceptsDescendant && Configuration.isDescendantOf(resultPath, selection.path)))) {
         throw new Error(`Machine transition resolver selected "${selection.path}" but constructed "${resultPath ?? "<invalid>"}"`);
     }
 };
@@ -457,6 +495,9 @@ const captureNamedBranches = (declarations, path, trigger) => {
         if (target.updatePath !== undefined) {
             throw new Error(`Machine transition branch "${key}" cannot declare an updating target`);
         }
+        if (hasProperty(target, TransitionBuilderDescriptorTypeId)) {
+            throw new Error(`Machine transition branch "${key}" requires a topology selection; apply .reenter() to .branches(...)`);
+        }
         if (title !== undefined && (typeof title !== "string" || title.length === 0)) {
             throw new Error(`Machine transition branch "${key}" title must be a non-empty string`);
         }
@@ -654,10 +695,10 @@ const captureInvokeDefinition = (invoke, stateNodes, path) => {
                 captured[key] = captureTransition(captured[key], stateNodes, path, key);
             }
         }
-        return captured;
+        return InvocationDefinition.capture(captured, path);
     });
     if (Array.isArray(authored))
-        return capturedDefinitions;
+        return Object.freeze(capturedDefinitions);
     return capturedDefinitions[0];
 };
 const flattenHandlers = (handlers, stateNodes, states, prefix, config) => {
@@ -671,6 +712,12 @@ const flattenHandlers = (handlers, stateNodes, states, prefix, config) => {
             throw new Error(`Machine expected state "${path}" handler to be an object`);
         }
         const { states: childConfig, ...stateConfig } = nodeConfig;
+        if (typeof stateConfig.history === "object" && stateConfig.history !== null) {
+            stateConfig.history = Object.freeze(Object.fromEntries(Object.entries(stateConfig.history).map(([key, entry]) => [
+                key,
+                typeof entry === "object" && entry !== null ? Object.freeze({ ...entry }) : entry
+            ])));
+        }
         const on = stateConfig.on;
         if (typeof on === "object" && on !== null) {
             const capturedOn = captureEventHandlers(on, stateNodes, path);
@@ -712,340 +759,11 @@ const flattenHandlers = (handlers, stateNodes, states, prefix, config) => {
 };
 const makeHandle = (self) => ((config) => {
     const handlers = Object.create(null);
-    flattenHandlers(handlers, self.stateNodes, self.states, "", config);
+    flattenHandlers(handlers, self.stateNodes, self.states, "", { "": config });
     return makeWithHandlers(self, handlers);
 });
 export const isMachine = (u) => hasProperty(u, TypeId) && u[TypeId] === TypeId;
 export const isFinal = (machine, state) => internalPlanner.isFinal(machine, state);
-const withFrom = (method, kind, valued) => {
-    const builder = {};
-    if (valued) {
-        Object.defineProperty(builder, "decoded", {
-            value: method,
-            enumerable: false
-        });
-    }
-    Object.defineProperty(builder, "from", {
-        value: (...args) => {
-            if (!valued) {
-                return method(undefined, ...args);
-            }
-            const omitted = args.length === 0 || (kind === "nested" && args.length === 1 && typeof args[0] === "function");
-            const input = omitted ? {} : args[0];
-            const rest = omitted ? args : args.slice(1);
-            return method(Topology.makeStateInput(input), ...rest);
-        },
-        enumerable: false
-    });
-    return builder;
-};
-const withInitial = (builder, path, valued, values) => {
-    const initial = withFrom((value) => Topology.makeInitialTarget(path, value, values), "leaf", valued);
-    Object.defineProperty(builder, "initial", {
-        value: initial,
-        enumerable: false
-    });
-    return builder;
-};
-const makeSnapshotBuilder = (states, options) => {
-    const builder = {};
-    for (const key of Object.keys(states)) {
-        const definition = states[key];
-        const pseudoType = definition.type;
-        if (pseudoType === "history") {
-            continue;
-        }
-        const path = options.prefix === "" ? key : `${options.prefix}.${key}`;
-        if (pseudoType === "choice") {
-            builder[key] = () => Topology.makeChoiceTarget(path, getParentPathRuntime(path));
-            continue;
-        }
-        const node = Topology.getStateNodeDefinition(path, definition);
-        const method = withFrom((value, selector) => makeSnapshotForNode(definition, key, value, selector, options), node.states === undefined ? "leaf" : "nested", node.schema !== undefined);
-        builder[key] = node.states === undefined || options.mode !== "full" || options.prefix !== ""
-            ? method
-            : withInitial(method, path, node.schema !== undefined);
-    }
-    return builder;
-};
-const makeParallelSnapshotBuilder = (states, options, regions) => {
-    const builder = {};
-    Object.defineProperty(builder, SnapshotBuilderStateTypeId, {
-        value: regions,
-        enumerable: false
-    });
-    for (const key of Object.keys(states)) {
-        const definition = states[key];
-        const pseudoType = definition.type;
-        if (pseudoType === "history" || pseudoType === "choice") {
-            continue;
-        }
-        if (hasProperty(regions, key)) {
-            continue;
-        }
-        const path = options.prefix === "" ? key : `${options.prefix}.${key}`;
-        const node = Topology.getStateNodeDefinition(path, definition);
-        const method = withFrom((value, selector) => {
-            const nextRegions = {};
-            for (const regionKey of Object.keys(regions)) {
-                nextRegions[regionKey] = regions[regionKey];
-            }
-            nextRegions[key] = makeSnapshotForNode(definition, key, value, selector, options);
-            return makeParallelSnapshotBuilder(states, options, nextRegions);
-        }, node.states === undefined ? "leaf" : "nested", node.schema !== undefined);
-        builder[key] = method;
-    }
-    return builder;
-};
-const getParallelSnapshotBuilderRegions = (path, states, builder) => {
-    if (typeof builder !== "object" || builder === null || !hasProperty(builder, SnapshotBuilderStateTypeId)) {
-        throw new Error(`Machine expected parallel state "${path}" builder callback to return a builder`);
-    }
-    const regions = builder[SnapshotBuilderStateTypeId];
-    for (const key of Object.keys(states)) {
-        const pseudoType = states[key].type;
-        if (pseudoType === "history" || pseudoType === "choice") {
-            continue;
-        }
-        if (!hasProperty(regions, key)) {
-            throw new Error(`Machine expected parallel state "${path}" builder callback to provide region "${key}"`);
-        }
-    }
-    return regions;
-};
-const makeSnapshotForNode = (definition, key, value, selector, options) => {
-    const path = options.prefix === "" ? key : `${options.prefix}.${key}`;
-    const node = Topology.getStateNodeDefinition(path, definition);
-    const snapshot = {
-        path,
-        value
-    };
-    if (node.states === undefined) {
-        return snapshot;
-    }
-    if (selector === undefined) {
-        throw new Error(`Machine expected state "${path}" builder to provide active child states`);
-    }
-    if (node.type === "parallel") {
-        const builder = makeParallelSnapshotBuilder(node.states, { ...options, prefix: path }, {});
-        const selected = selector(builder);
-        snapshot.states = getParallelSnapshotBuilderRegions(path, node.states, selected);
-        return snapshot;
-    }
-    const childStates = options.mode === "initial" && node.initial !== undefined
-        ? { [node.initial]: node.states[node.initial] }
-        : node.states;
-    const selected = selector(makeSnapshotBuilder(childStates, { ...options, prefix: path }));
-    snapshot.state = selected;
-    return snapshot;
-};
-const getTargetBuilderNode = (stateNodes, path) => {
-    const node = stateNodes.byPath.get(path);
-    if (node === undefined) {
-        throw new Error(`Machine expected state path "${path}" to exist`);
-    }
-    return node;
-};
-const getLocalTargetScope = (stateNodes, source) => {
-    let current = source;
-    while (current !== undefined) {
-        const node = stateNodes.byPath.get(current);
-        if (node === undefined) {
-            return undefined;
-        }
-        if (node.type === "compound") {
-            return node.path;
-        }
-        current = node.parent;
-    }
-    return undefined;
-};
-const hasTargetValues = (values) => values !== undefined && Object.keys(values).length > 0;
-const makeTargetWithValues = (path, value, values) => hasTargetValues(values)
-    ? Topology.makeTarget(path, value, { values: values })
-    : Topology.makeTarget(path, value);
-const getTargetBuilderDefinition = (states, targetPath) => {
-    let children = states;
-    let path = "";
-    let definition;
-    for (const key of targetPath.split(".")) {
-        if (!hasProperty(children, key)) {
-            throw new Error(`Machine expected state path "${targetPath}" to exist`);
-        }
-        definition = children[key];
-        path = path === "" ? key : `${path}.${key}`;
-        const node = Topology.getStateNodeDefinition(path, definition);
-        children = node.states ?? {};
-    }
-    return definition;
-};
-const makeParallelTarget = (states, node, value, selector, values) => {
-    if (selector === undefined) {
-        throw new Error(`Machine expected parallel target "${node.path}" builder to provide every active region`);
-    }
-    const snapshot = makeSnapshotForNode(getTargetBuilderDefinition(states, node.path), node.key, value, selector, { mode: "full", prefix: node.parent ?? "" });
-    return Topology.makeTarget(node.path, value, {
-        snapshot: snapshot,
-        values: values
-    });
-};
-const extendTargetValues = (values, path, value) => {
-    const next = {};
-    if (values !== undefined) {
-        for (const key of Object.keys(values)) {
-            next[key] = values[key];
-        }
-    }
-    next[path] = value;
-    return next;
-};
-const makeLocalTargetChildBuilder = (states, stateNodes, parentPath, values, source) => {
-    const parent = getTargetBuilderNode(stateNodes, parentPath);
-    const builder = {};
-    for (const childPath of Array.from(stateNodes.byPath.values())
-        .filter((node) => node.parent === parent.path && node.type !== "history")
-        .map((node) => node.path)) {
-        const child = getTargetBuilderNode(stateNodes, childPath);
-        if (child.type === "choice") {
-            builder[child.key] = () => Topology.makeChoiceTarget(child.path, parent.path, values);
-            continue;
-        }
-        const method = withFrom((value, selector) => {
-            if (child.type === "atomic" || child.type === "final") {
-                return makeTargetWithValues(child.path, value, values);
-            }
-            if (child.type === "parallel") {
-                if (source !== child.path && !source.startsWith(`${child.path}.`)) {
-                    return makeParallelTarget(states, child, value, selector, values);
-                }
-                if (selector === undefined) {
-                    throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`);
-                }
-                return selector(makeLocalTargetChildBuilder(states, stateNodes, child.path, child.schema === undefined ? values : extendTargetValues(values, child.path, value), source));
-            }
-            if (selector === undefined) {
-                throw new Error(`Machine expected target "${child.path}" builder to provide an active child state`);
-            }
-            return selector(makeLocalTargetChildBuilder(states, stateNodes, child.path, child.schema === undefined ? values : extendTargetValues(values, child.path, value), source));
-        }, child.type === "atomic" || child.type === "final" ? "leaf" : "nested", child.schema !== undefined);
-        builder[child.key] = child.type === "atomic" || child.type === "final"
-            ? method
-            : withInitial(method, child.path, child.schema !== undefined, values);
-    }
-    return builder;
-};
-const makeLocalTargetBuilder = (states, stateNodes, source) => {
-    const scope = getLocalTargetScope(stateNodes, source);
-    if (scope === undefined) {
-        return {};
-    }
-    const builder = makeLocalTargetChildBuilder(states, stateNodes, scope, undefined, source);
-    const scopeNode = getTargetBuilderNode(stateNodes, scope);
-    if (scopeNode.schema !== undefined) {
-        builder.with = withFrom((value, selector) => {
-            if (selector === undefined) {
-                throw new Error(`Machine expected target "${scope}" builder to provide an active child state`);
-            }
-            return selector(makeLocalTargetChildBuilder(states, stateNodes, scope, { [scope]: value }, source));
-        }, "nested", true);
-    }
-    return builder;
-};
-const addBranchTargetChildren = (builder, states, stateNodes, parentPath, values, source) => {
-    const parent = getTargetBuilderNode(stateNodes, parentPath);
-    for (const childPath of Array.from(stateNodes.byPath.values())
-        .filter((node) => node.parent === parent.path && node.type !== "history")
-        .map((node) => node.path)) {
-        const child = getTargetBuilderNode(stateNodes, childPath);
-        if (child.type === "choice") {
-            builder[child.key] = () => Topology.makeChoiceTarget(child.path, parent.path, values);
-            continue;
-        }
-        builder[child.key] = makeBranchTargetNodeBuilder(states, stateNodes, child.path, values, source);
-    }
-};
-const makeBranchTargetNodeBuilder = (states, stateNodes, path, values, source) => {
-    const node = getTargetBuilderNode(stateNodes, path);
-    if (node.type === "atomic" || node.type === "final") {
-        return withFrom((value) => makeTargetWithValues(node.path, value, values), "leaf", node.schema !== undefined);
-    }
-    const builder = withFrom((value, selector) => {
-        if (node.type === "parallel") {
-            if (source !== node.path && !source.startsWith(`${node.path}.`)) {
-                return makeParallelTarget(states, node, value, selector, values);
-            }
-            if (selector === undefined) {
-                throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`);
-            }
-            const nextBuilder = {};
-            addBranchTargetChildren(nextBuilder, states, stateNodes, node.path, node.schema === undefined ? values : extendTargetValues(values, node.path, value), source);
-            return selector(nextBuilder);
-        }
-        if (selector === undefined) {
-            throw new Error(`Machine expected target "${node.path}" builder to provide an active child state`);
-        }
-        const nextBuilder = {};
-        addBranchTargetChildren(nextBuilder, states, stateNodes, node.path, node.schema === undefined ? values : extendTargetValues(values, node.path, value), source);
-        return selector(nextBuilder);
-    }, "nested", node.schema !== undefined);
-    withInitial(builder, node.path, node.schema !== undefined, values);
-    if (node.type !== "parallel" || source === node.path || source.startsWith(`${node.path}.`)) {
-        addBranchTargetChildren(builder, states, stateNodes, node.path, values, source);
-    }
-    return builder;
-};
-const makeBranchTargetBuilder = (states, stateNodes, source) => {
-    const rootPath = source.split(".")[0];
-    const root = getTargetBuilderNode(stateNodes, rootPath);
-    return {
-        [root.key]: makeBranchTargetNodeBuilder(states, stateNodes, root.path, undefined, source)
-    };
-};
-const makeHistoryTargetBuilder = (states, prefix) => {
-    const builder = {};
-    for (const key of Object.keys(states)) {
-        const path = prefix === "" ? key : `${prefix}.${key}`;
-        const definition = Topology.getStateNodeDefinition(path, states[key]);
-        if (definition.type === "history") {
-            const parent = getParentPathRuntime(path);
-            builder[key] = () => Topology.makeHistoryTarget(path, parent);
-            continue;
-        }
-        if (definition.states !== undefined) {
-            builder[key] = makeHistoryTargetBuilder(definition.states, path);
-        }
-    }
-    return builder;
-};
-const getParentPathRuntime = (path) => {
-    const separator = path.lastIndexOf(".");
-    if (separator < 0) {
-        throw new Error(`Machine expected history state "${path}" to have an active parent`);
-    }
-    return path.slice(0, separator);
-};
-const makeTargetBuilder = (states, stateNodes) => {
-    const full = makeSnapshotBuilder(states, { mode: "full", prefix: "" });
-    const history = makeHistoryTargetBuilder(states, "");
-    return (source) => ({
-        none: Topology.makeNoTarget,
-        local: makeLocalTargetBuilder(states, stateNodes, source),
-        branch: makeBranchTargetBuilder(states, stateNodes, source),
-        full,
-        history
-    });
-};
-const makeInitialSelector = (stateNodes) => {
-    const selector = {};
-    for (const node of stateNodes.byPath.values()) {
-        if (node.parent === undefined && node.type !== "history" && node.type !== "choice") {
-            selector[node.key] = node.type === "atomic" || node.type === "final"
-                ? makeSelectionMethod("state", node.path, "initial")
-                : Object.freeze({ initial: makeSelectionValue("initial", node.path, "initial") });
-        }
-    }
-    return Object.freeze(selector);
-};
 const getInitialSelectionBuilder = (initialBuilder, selection) => {
     const path = selection.path;
     if (path === undefined || path.includes(".")) {
@@ -1057,11 +775,12 @@ const getInitialSelectionBuilder = (initialBuilder, selection) => {
     }
     return builder;
 };
-const captureInitialBranch = (definition, stateNodes, initialBuilder) => {
-    if (typeof definition !== "function") {
+const captureInitialBranch = (definition, initialBuilder, configuration) => {
+    if (definition !== undefined && typeof definition !== "function") {
         throw new Error("Machine initial definition must be a target-first callback");
     }
-    const result = definition(decorateInitialSelectorNode(makeInitialSelector(stateNodes)));
+    const selector = decorateInitialSelection(makeSelectionValue(configuration ? "state" : "initial", "", "initial"));
+    const result = definition === undefined ? selector : definition(selector);
     let selection;
     let resolve;
     if (Topology.isTargetSelection(result)) {
@@ -1092,9 +811,12 @@ const validateInitialSelection = (result, selection) => {
         throw new Error(`Machine initial resolver selected "${selection.path}" but constructed "${resultPath}"`);
     }
 };
-const compileInitial = (definition, states, stateNodes) => {
-    const initialBuilder = makeSnapshotBuilder(states, { mode: "initial", prefix: "" });
-    const branch = captureInitialBranch(definition, stateNodes, initialBuilder);
+const compileInitial = (definition, states, stateNodes, configuration = false) => {
+    const rootNode = getTargetBuilderNode(stateNodes, "");
+    const initialBuilder = configuration ?
+        makeSnapshotBuilder(states, { mode: "full", prefix: "" })
+        : { "": withFrom((value) => Topology.makeInitialTarget("", value), "leaf", rootNode.schema !== undefined) };
+    const branch = captureInitialBranch(definition, initialBuilder, configuration);
     return {
         initial: (input) => {
             const result = branch.resolve === undefined
@@ -1109,15 +831,13 @@ const compileInitial = (definition, states, stateNodes) => {
         })
     };
 };
-export const state = ((node) => {
-    StateDefinition.validateStateDefinitions({ state: node }, "Machine.state");
-    return StateDefinition.captureStateDefinitions({ state: node }).state;
-});
-export const states = ((states) => {
-    StateDefinition.validateStateDefinitions(states, "Machine.states");
-    const captured = StateDefinition.captureStateDefinitions(states);
+export const state = (node) => {
+    const captured = StateDefinition.captureRoot(node);
+    const access = makeStateHelpers();
+    return Object.freeze({ ...access, "~effect/Machine/State": "~effect/Machine/State", node: captured });
+};
+const makeStateHelpers = () => {
     return {
-        states: captured,
         path: ((path) => path),
         get: ((snapshot, path) => Topology.getSnapshotByPath(snapshot, path).pipe(Option.map((snapshot) => snapshot.value))),
         getWithParents: ((snapshot, path) => {
@@ -1127,31 +847,42 @@ export const states = ((states) => {
         getSnapshot: Topology.getSnapshotByPath,
         matches: ((snapshot, path) => Option.isSome(Topology.getSnapshotByPath(snapshot, path)))
     };
-});
-export const make = ((config) => {
-    StateDefinition.validateStateDefinitions(config.states, "Machine.make");
+};
+export const make = (config) => {
+    const states = Object.freeze({ "": config.root.node });
     const self = Object.create(Proto);
-    self.states = config.states;
+    self.states = states;
+    self.root = config.root;
     self.events = config.events;
     self.internalEvents = config.internalEvents ?? Protocol.makeEventProtocol("internal", []);
     self.emittedEvents = config.emittedEvents ?? Protocol.makeEventProtocol("emitted", []);
     self.parent = config.parent;
     self.input = config.input;
     self.id = config.id;
-    self.stateNodes = Topology.compileStateNodes(config.states);
-    const compiledInitial = compileInitial(config.initial, config.states, self.stateNodes);
+    self.stateNodes = Topology.compileStateNodes(states);
+    const compiledInitial = compileInitial(config.initialConfiguration ?? config.initial, states, self.stateNodes, config.initialConfiguration !== undefined);
     self.initial = compiledInitial.initial;
     self.initialDefinition = compiledInitial.definition;
-    self.makeTargetBuilder = makeTargetBuilder(config.states, self.stateNodes);
+    self.makeTargetBuilder = makeTargetBuilder(states, self.stateNodes);
     self.handlers = Object.create(null);
     self.handle = makeHandle(self);
     Protocol.setProtocol(self);
     return self;
-});
+};
 const flattenEventProtocolInputs = (kind, inputs) => inputs.flatMap((input) => Protocol.isEventProtocol(input, kind)
     ? Protocol.eventProtocolSchemas(input)
     : [input]);
 export const events = (...inputs) => Protocol.makeEventProtocol("public", flattenEventProtocolInputs("public", inputs));
+const eventFieldSchemas = (cases) => {
+    for (const [tag, fields] of Object.entries(cases)) {
+        if (Object.hasOwn(fields, "_tag"))
+            throw new Error(`Machine event "${tag}" fields cannot declare _tag`);
+    }
+    return Object.keys(cases).length === 0 ? [] : [Schema.TaggedUnion(cases)];
+};
+export const eventsFromFields = (cases) => Protocol.makeEventProtocol("public", eventFieldSchemas(cases));
+export const internalEventsFromFields = (cases) => Protocol.makeEventProtocol("internal", eventFieldSchemas(cases));
+export const emittedEventsFromFields = (cases) => Protocol.makeEventProtocol("emitted", eventFieldSchemas(cases));
 const makeParent = (mode, events) => {
     if (!Protocol.isEventProtocol(events, "public")) {
         throw new Error("Machine parent declarations require a protocol created with Machine.events");