@typeonce/effect-machine 0.1.0 → 0.3.0

package/dist/Machine.js

@@ -104,6 +104,7 @@ const ActionRequirementTypeId = "~effect/Machine/ActionRequirement";
 const RuntimeCompatibilityErrorTypeId = "~effect/Machine/RuntimeCompatibilityError";
 const InvokeTypeId = Symbol.for("effect/Machine/Invoke");
 const SnapshotBuilderStateTypeId = Symbol("effect/Machine/SnapshotBuilderState");
+const SnapshotBuilderConstructionTypeId = Symbol("effect/Machine/SnapshotBuilderConstruction");
 const ChildAddressTypeId = "~effect/Machine/ChildAddress";
 const ChildAddressCompatibilityErrorTypeId = "~effect/Machine/ChildAddressCompatibilityError";
 const ChildMachineTypeId = "~effect/Machine/ChildMachine";
@@ -121,6 +122,7 @@ const cloneWithHandlers = (self, handlers) => {
     const machine = Object.create(Proto);
     machine.states = self.states;
     machine.events = self.events;
+    machine.internalEvents = self.internalEvents;
     machine.emits = self.emits;
     machine.input = self.input;
     machine.id = self.id;
@@ -129,6 +131,7 @@ const cloneWithHandlers = (self, handlers) => {
     machine.makeTargetBuilder = self.makeTargetBuilder;
     machine.handlers = handlers;
     machine.handle = makeHandle(machine);
+    Model.copyProtocol(self, machine);
     return machine;
 };
 const flattenHandlers = (handlers, states, prefix, config) => {
@@ -174,10 +177,27 @@ export const isMachine = (u) => hasProperty(u, TypeId);
  * @since 4.0.0
  */
 export const isFinal = (machine, state) => internalPlanner.isFinal(machine, state);
+const withFrom = (method, kind) => {
+    Object.defineProperty(method, "from", {
+        value: (...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 Model.markStateConstruction(method(Model.makeStateInput(input), ...rest));
+        },
+        enumerable: false
+    });
+    return method;
+};
 const makeSnapshotBuilder = (states, options) => {
     const builder = {};
     for (const key of Object.keys(states)) {
-        builder[key] = (value, selector) => makeSnapshotForNode(states[key], key, value, selector, options);
+        if (states[key].type === "history") {
+            continue;
+        }
+        const path = options.prefix === "" ? key : `${options.prefix}.${key}`;
+        const node = Model.getStateNodeDefinition(path, states[key]);
+        builder[key] = withFrom((value, selector) => makeSnapshotForNode(states[key], key, value, selector, options), node.states === undefined ? "leaf" : "nested");
     }
     return builder;
 };
@@ -187,18 +207,28 @@ const makeParallelSnapshotBuilder = (states, options, regions) => {
         value: regions,
         enumerable: false
     });
+    Object.defineProperty(builder, SnapshotBuilderConstructionTypeId, {
+        value: Model.isStateConstruction(builder),
+        enumerable: false
+    });
     for (const key of Object.keys(states)) {
+        if (states[key].type === "history") {
+            continue;
+        }
         if (hasProperty(regions, key)) {
             continue;
         }
-        builder[key] = (value, selector) => {
+        const path = options.prefix === "" ? key : `${options.prefix}.${key}`;
+        const node = Model.getStateNodeDefinition(path, states[key]);
+        builder[key] = withFrom((value, selector) => {
             const nextRegions = {};
             for (const regionKey of Object.keys(regions)) {
                 nextRegions[regionKey] = regions[regionKey];
             }
             nextRegions[key] = makeSnapshotForNode(states[key], key, value, selector, options);
-            return makeParallelSnapshotBuilder(states, options, nextRegions);
-        };
+            const next = makeParallelSnapshotBuilder(states, options, nextRegions);
+            return Model.isStateConstruction(builder) ? Model.markStateConstruction(next) : next;
+        }, node.states === undefined ? "leaf" : "nested");
     }
     return builder;
 };
@@ -208,6 +238,9 @@ const getParallelSnapshotBuilderRegions = (path, states, builder) => {
     }
     const regions = builder[SnapshotBuilderStateTypeId];
     for (const key of Object.keys(states)) {
+        if (states[key].type === "history") {
+            continue;
+        }
         if (!hasProperty(regions, key)) {
             throw new Error(`Machine expected parallel state "${path}" builder callback to provide region "${key}"`);
         }
@@ -229,14 +262,16 @@ const makeSnapshotForNode = (definition, key, value, selector, options) => {
     }
     if (node.type === "parallel") {
         const builder = makeParallelSnapshotBuilder(node.states, { ...options, prefix: path }, {});
-        snapshot.states = getParallelSnapshotBuilderRegions(path, node.states, selector(builder));
-        return snapshot;
+        const selected = selector(builder);
+        snapshot.states = getParallelSnapshotBuilderRegions(path, node.states, selected);
+        return Model.isStateConstruction(selected) ? Model.markStateConstruction(snapshot) : snapshot;
     }
     const childStates = options.mode === "initial" && node.initial !== undefined
         ? { [node.initial]: node.states[node.initial] }
         : node.states;
-    snapshot.state = selector(makeSnapshotBuilder(childStates, { ...options, prefix: path }));
-    return snapshot;
+    const selected = selector(makeSnapshotBuilder(childStates, { ...options, prefix: path }));
+    snapshot.state = selected;
+    return Model.isStateConstruction(selected) ? Model.markStateConstruction(snapshot) : snapshot;
 };
 const getTargetBuilderNode = (stateNodes, path) => {
     const node = stateNodes.byPath.get(path);
@@ -263,6 +298,31 @@ const hasTargetValues = (values) => values !== undefined && Object.keys(values).
 const makeTargetWithValues = (path, value, values) => hasTargetValues(values)
     ? Model.makeTarget(path, value, { values: values })
     : Model.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 = Model.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 Model.makeTarget(node.path, value, {
+        snapshot: snapshot,
+        values: values
+    });
+};
 const extendTargetValues = (values, path, value) => {
     const next = {};
     if (values !== undefined) {
@@ -273,100 +333,122 @@ const extendTargetValues = (values, path, value) => {
     next[path] = value;
     return next;
 };
-const makeLocalTargetChildBuilder = (stateNodes, parentPath, values) => {
+const makeLocalTargetChildBuilder = (states, stateNodes, parentPath, values, source) => {
     const parent = getTargetBuilderNode(stateNodes, parentPath);
     const builder = {};
     for (const childPath of parent.children) {
         const child = getTargetBuilderNode(stateNodes, childPath);
-        builder[child.key] = (value, selector) => {
+        builder[child.key] = 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, 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(stateNodes, child.path, extendTargetValues(values, child.path, value)));
-        };
+            return selector(makeLocalTargetChildBuilder(states, stateNodes, child.path, extendTargetValues(values, child.path, value), source));
+        }, child.type === "atomic" || child.type === "final" ? "leaf" : "nested");
     }
     return builder;
 };
-const makeLocalTargetBuilder = (stateNodes, source) => {
+const makeLocalTargetBuilder = (states, stateNodes, source) => {
     const scope = getLocalTargetScope(stateNodes, source);
     if (scope === undefined) {
         return {};
     }
-    const builder = makeLocalTargetChildBuilder(stateNodes, scope, undefined);
-    builder.with = (value, selector) => {
+    const builder = makeLocalTargetChildBuilder(states, stateNodes, scope, undefined, source);
+    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(stateNodes, scope, { [scope]: value }));
-    };
+        return selector(makeLocalTargetChildBuilder(states, stateNodes, scope, { [scope]: value }, source));
+    }, "nested");
     return builder;
 };
-const addBranchTargetChildren = (builder, stateNodes, parentPath, values) => {
+const addBranchTargetChildren = (builder, states, stateNodes, parentPath, values, source) => {
     const parent = getTargetBuilderNode(stateNodes, parentPath);
     for (const childPath of parent.children) {
         const child = getTargetBuilderNode(stateNodes, childPath);
-        builder[child.key] = makeBranchTargetNodeBuilder(stateNodes, child.path, values);
+        builder[child.key] = makeBranchTargetNodeBuilder(states, stateNodes, child.path, values, source);
     }
 };
-const makeBranchTargetNodeBuilder = (stateNodes, path, values) => {
+const makeBranchTargetNodeBuilder = (states, stateNodes, path, values, source) => {
     const node = getTargetBuilderNode(stateNodes, path);
     if (node.type === "atomic" || node.type === "final") {
-        return (value) => makeTargetWithValues(node.path, value, values);
+        return withFrom((value) => makeTargetWithValues(node.path, value, values), "leaf");
     }
-    const builder = ((value, selector) => {
+    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, 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, stateNodes, node.path, extendTargetValues(values, node.path, value));
+        addBranchTargetChildren(nextBuilder, states, stateNodes, node.path, extendTargetValues(values, node.path, value), source);
         return selector(nextBuilder);
-    });
-    addBranchTargetChildren(builder, stateNodes, node.path, values);
+    }, "nested");
+    if (node.type !== "parallel" || source === node.path || source.startsWith(`${node.path}.`)) {
+        addBranchTargetChildren(builder, states, stateNodes, node.path, values, source);
+    }
     return builder;
 };
-const makeBranchTargetBuilder = (stateNodes, source) => {
+const makeBranchTargetBuilder = (states, stateNodes, source) => {
     const rootPath = source.split(".")[0];
     const root = getTargetBuilderNode(stateNodes, rootPath);
     return {
-        [root.key]: makeBranchTargetNodeBuilder(stateNodes, root.path, undefined)
+        [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 = states[key];
+        if (definition.type === "history") {
+            const parent = getParentPathRuntime(path);
+            builder[key] = () => Model.makeHistoryTarget(path, parent);
+            continue;
+        }
+        if (typeof definition === "object" && definition !== null && hasProperty(definition, "states")) {
+            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) => ({
-        local: makeLocalTargetBuilder(stateNodes, source),
-        branch: makeBranchTargetBuilder(stateNodes, source),
-        full
+        local: makeLocalTargetBuilder(states, stateNodes, source),
+        branch: makeBranchTargetBuilder(states, stateNodes, source),
+        full,
+        history
     });
 };
-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") && Model.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 (Model.isSnapshot(child)) {
-                const result = getSnapshotByPath(child, path, parents);
-                if (Option.isSome(result)) {
-                    return result;
-                }
-            }
-        }
-    }
-    return Option.none();
-};
 /**
  * Defines a state tree while preserving literal state paths.
  *
@@ -385,7 +467,7 @@ const getSnapshotByPath = (snapshot, path, parents) => {
  *
  * ```ts
  * import { Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
  *
@@ -394,24 +476,24 @@ const getSnapshotByPath = (snapshot, path, parents) => {
  * Machine.make({
  *   states: States.states,
  *   events: [],
- *   initial: () => States.initial.idle(new Idle({}))
+ *   initial: () => States.initial.idle.from()
  * })
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export const defineStates = (states, ..._validation) => ({
+export const defineStates = ((states) => ({
     states: states,
     initial: makeSnapshotBuilder(states, { mode: "initial", prefix: "" }),
-    get: ((snapshot, path) => getSnapshotByPath(snapshot, path).pipe(Option.map((snapshot) => snapshot.value))),
+    get: ((snapshot, path) => Model.getSnapshotByPath(snapshot, path).pipe(Option.map((snapshot) => snapshot.value))),
     getWithParents: ((snapshot, path) => {
         const parents = {};
-        return getSnapshotByPath(snapshot, path, parents).pipe(Option.map((snapshot) => ({ value: snapshot.value, parents })));
+        return Model.getSnapshotByPath(snapshot, path, parents).pipe(Option.map((snapshot) => ({ value: snapshot.value, parents })));
     }),
-    getSnapshot: getSnapshotByPath,
-    matches: (snapshot, path) => Option.isSome(getSnapshotByPath(snapshot, path))
-});
+    getSnapshot: Model.getSnapshotByPath,
+    matches: (snapshot, path) => Option.isSome(Model.getSnapshotByPath(snapshot, path))
+}));
 /**
  * Creates a schema-first machine definition.
  *
@@ -423,11 +505,16 @@ export const defineStates = (states, ..._validation) => ({
  * `defineStates` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
+ * Schemas in `events` define the public input protocol. Schemas in
+ * `internalEvents` are added to the complete handler protocol for invoke
+ * results, child emissions, and other machine-local deliveries. Their tags
+ * must be disjoint.
+ *
  * **Example** (Typed counter machine)
  *
  * ```ts
  * import { Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Count extends Schema.TaggedClass<Count>("Count")("Count", {
  *   value: Schema.Number
@@ -457,10 +544,11 @@ export const defineStates = (states, ..._validation) => ({
  * @category constructors
  * @since 4.0.0
  */
-export const make = (config, ..._validation) => {
+export const make = ((config) => {
     const self = Object.create(Proto);
     self.states = config.states;
     self.events = config.events;
+    self.internalEvents = config.internalEvents ?? [];
     self.emits = config.emits ?? [];
     self.input = config.input;
     self.id = config.id;
@@ -469,8 +557,9 @@ export const make = (config, ..._validation) => {
     self.makeTargetBuilder = makeTargetBuilder(config.states, self.stateNodes);
     self.handlers = Object.create(null);
     self.handle = makeHandle(self);
+    Model.setProtocol(self);
     return self;
-};
+});
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -538,6 +627,8 @@ export const decodeSnapshot = Model.decodeSnapshot;
  * Invoked child processes run while their owning state is active and are
  * stopped before the state exits. An unrecovered child failure fails the owning
  * machine; recover inside the child Effect when failure should become an event.
+ * The `id` is a state-local lifecycle key, not a communication address. To
+ * send events to the invocation, pass a typed `childAddress` as `address`.
  * The `src` callback is intentionally independent from its parent state. When
  * construction depends on the typed state, lifecycle event, or runtime, use
  * the state config factory form `invoke: (context) => Machine.invoke(...)` and
@@ -547,7 +638,7 @@ export const decodeSnapshot = Model.decodeSnapshot;
  *
  * ```ts
  * import { Effect, Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
  *   value: Schema.String
@@ -565,6 +656,64 @@ export const decodeSnapshot = Model.decodeSnapshot;
  * @since 4.0.0
  */
 export const invoke = (config) => ({ ...config, [InvokeTypeId]: undefined });
+/**
+ * Invokes one Effect and maps its typed outcome into machine-local events.
+ *
+ * **Details**
+ *
+ * This is the high-level one-shot counterpart to `invoke`. Success and typed
+ * failure values are mapped independently, so callers do not need to recover
+ * an Effect into a common event union by hand. Defects and interruption remain
+ * failures of the owning machine.
+ *
+ * Declare mapped outcomes in `internalEvents` unless they are also legitimate
+ * public commands.
+ *
+ * @see {@link invoke} for arbitrary child process logic.
+ * @see {@link after} for a state-scoped delayed event.
+ * @category constructors
+ * @since 4.0.0
+ */
+export const invokeEffect = (config) => ((config) => invoke({
+    id: config.id,
+    src: () => effect(config.onFailure === undefined
+        ? Effect.map(config.effect, config.onSuccess)
+        : Effect.matchEffect(config.effect, {
+            onFailure: (error) => Effect.succeed(config.onFailure(error)),
+            onSuccess: (value) => Effect.succeed(config.onSuccess(value))
+        }))
+}))(config);
+/**
+ * Creates a cancellable state-scoped delayed event.
+ *
+ * The timer starts when its owning state is entered and is interrupted when
+ * that state exits. The delayed value should normally be declared in
+ * `internalEvents`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const after = (duration, event, options) => invoke({
+    id: options?.id ?? `Machine.after:${String(event._tag)}`,
+    src: () => effect(Effect.as(Effect.sleep(duration), event))
+});
+/**
+ * Constructs another tagged case from compatible source fields.
+ *
+ * The target must be one tagged struct or tagged class whose discriminator is
+ * supplied by its constructor. Union wrappers are rejected because their
+ * `make` operation cannot select a member after the source discriminator has
+ * been discarded. Missing or incompatible required target fields must be
+ * supplied by the patch, and the target schema's normal `make` validation
+ * remains authoritative at runtime.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const retag = (target, source, ...args) => {
+    const { _tag: _, ...fields } = source;
+    return target.make({ ...fields, ...(args[0] ?? {}) });
+};
 /**
  * Creates an invoked child process from a complete statechart machine.
  *
@@ -594,7 +743,8 @@ export const invokeMachine = ((config) => {
     const machine = config.child.machine;
     return {
         id: config.child.id,
-        addressable: true,
+        address: config.child.id,
+        descriptor: config.child,
         src: () => machine.input === undefined
             ? internalProcess.toProcessLogic(machine)
             : internalProcess.toProcessLogic(machine, config.input),
@@ -664,13 +814,14 @@ export const plan = internalPlanner.plan;
  * The action's error and service requirements are retained in the machine
  * type without becoming requirements of `plan` or `planInitial`. The managed
  * runtime executes staged actions sequentially before publishing the planned
- * state.
+ * state. Pass a second argument when the planning Effect should return that
+ * value after staging.
  *
  * **Example** (Typed staged action)
  *
  * ```ts
  * import { Context, Effect } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Audit extends Context.Service<Audit, {
  *   readonly write: Effect.Effect<void, "AuditError">
@@ -685,7 +836,10 @@ export const plan = internalPlanner.plan;
  * @category combinators
  * @since 4.0.0
  */
-export const action = (effect) => internalPlanner.action(effect);
+export const action = ((effect, ...next) => {
+    const staged = internalPlanner.action(effect);
+    return next.length === 0 ? staged : Effect.as(staged, next[0]);
+});
 const processLocal = (operation) => Effect.die(new ProcessLocalErrorValue({ operation }));
 const standaloneProcessRuntime = internalRuntime.MachineRuntime.of({
     self: {
@@ -756,7 +910,7 @@ export const runtime = () => internalPlanner.runtime();
  *
  * ```ts
  * import { Effect, Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class LoadFailed extends Schema.TaggedClass<LoadFailed>("LoadFailed")("LoadFailed", {
  *   reason: Schema.String
@@ -835,20 +989,29 @@ export const transition = (initial, transition) => logic({
     run: ({ receive, updateState }) => receive.pipe(Effect.flatMap((event) => updateState((state) => transition(state, event))), Effect.forever)
 });
 /**
- * Creates a typed parent-local child address or complete machine descriptor.
+ * Creates a typed descriptor for a complete child machine.
  *
- * **When to use**
+ * Descriptors identify a child by id and machine identity, so independently
+ * constructed descriptors for the same pair address the same invoked child.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const child = (id, machine) => ({
+    [ChildMachineTypeId]: ChildMachineTypeId,
+    id,
+    machine
+});
+/**
+ * Creates a typed parent-local address for lower-level child process logic.
  *
- * Use with a complete machine to create the descriptor shared by
- * `invokeMachine`, `sendTo`, and child lookup APIs. The one-argument form
- * creates an event-only address for lower-level process logic.
+ * The default event protocol is `never`; provide an event type before using
+ * the address with `spawn`, `invoke`, or `sendTo`.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const child = ((id, machine) => machine === undefined
-    ? id
-    : { [ChildMachineTypeId]: ChildMachineTypeId, id, machine });
+export const childAddress = (id) => id;
 /**
  * Spawns a child process owned by the currently running machine.
  *
@@ -876,14 +1039,14 @@ export const spawn = ((logic, options) => Effect.flatMap(internalRuntime.Machine
  * @category runtime
  * @since 4.0.0
  */
-export const sendTo = ((child, event) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => runtime.sendTo(typeof child === "string" ? child : child.id, event)));
+export const sendTo = ((child, event) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => runtime.sendTo(child, event)));
 /**
  * Stops a named child process of the running machine.
  *
  * @category runtime
  * @since 4.0.0
  */
-export const stopChild = ((child) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => runtime.stopChild(typeof child === "string" ? child : child.id)));
+export const stopChild = ((child) => Effect.flatMap(internalRuntime.MachineRuntime, (runtime) => runtime.stopChild(child)));
 /**
  * Returns a stream of terminal lifecycle outcomes for a running machine.
  *