@typeonce/effect-machine 0.6.1 → 0.8.0

package/dist/Machine.d.ts

@@ -383,48 +383,38 @@ type UnknownPseudoAnnotationProperty<Node> = Node extends {
 type ValidatePseudoStateAnnotations<Node, Path extends PropertyKey> = [UnknownPseudoAnnotationProperty<Node>] extends [
     never
 ] ? unknown : StateDefinitionError<"Pseudo-state annotations contain unknown properties", Path, Extract<UnknownPseudoAnnotationProperty<Node>, PropertyKey>>;
-type ValidateStateNode<Node, AllowHistory extends boolean, Path extends PropertyKey> = Node extends Machine.TaggedSchema ? unknown : Node extends Machine.HistoryStateNodeConfig ? ValidateExactStateNodeProperties<Node, "history", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state", Path>) : Node extends Machine.ChoiceStateNodeConfig ? ValidateExactStateNodeProperties<Node, "choice", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateChoiceStateNode<Node> : StateDefinitionError<"Choice states must be declared below an active parent state", Path>) : Node extends {
-    readonly schema: Machine.TaggedSchema;
-} ? ValidateStateNodeConfig<Node, Path> : StateDefinitionError<"State nodes must be tagged schemas or state node configs", Path>;
+type ValidateStateNode<Node, AllowHistory extends boolean, Path extends PropertyKey> = Node extends Machine.TaggedSchema ? unknown : Node extends Machine.HistoryStateNodeConfig ? ValidateExactStateNodeProperties<Node, "history", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state", Path>) : Node extends Machine.ChoiceStateNodeConfig ? ValidateExactStateNodeProperties<Node, "choice", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateChoiceStateNode<Node> : StateDefinitionError<"Choice states must be declared below an active parent state", Path>) : Node extends Machine.StateNodeConfig ? ValidateStateNodeConfig<Node, Path> : StateDefinitionError<"State nodes must be tagged schemas or state node configs", Path>;
 type ValidateHistoryStateNode<Node extends Machine.HistoryStateNodeConfig> = [
     Extract<keyof Node, "schema" | "states" | "initial" | "output" | "choice">
 ] extends [never] ? unknown : StateDefinitionError<"History states cannot declare schemas, children, initial states, or output">;
 type ValidateChoiceStateNode<Node extends Machine.ChoiceStateNodeConfig> = [
     Extract<keyof Node, "schema" | "states" | "initial" | "output" | "history">
 ] extends [never] ? unknown : StateDefinitionError<"Choice states cannot declare schemas, children, initial states, output, or history">;
-type ValidateStateNodeConfig<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}, Path extends PropertyKey> = Node extends {
+type ValidateStateNodeConfig<Node extends Machine.StateNodeConfig, Path extends PropertyKey> = Node extends {
     readonly type: "parallel";
 } ? ValidateExactStateNodeProperties<Node, "parallel", Path> & ValidateStateNodeWithChildren<Node, Node extends {
     readonly states: infer Children;
-} ? Children : never, Path> : Node extends {
+} ? Children : never, Path> & ValidatePseudoStateAnnotations<Node, Path> : Node extends {
     readonly type: "final";
-} ? ValidateExactStateNodeProperties<Node, "final", Path> & ValidateStateNodeWithoutChildren<Node> : Node extends {
+} ? ValidateExactStateNodeProperties<Node, "final", Path> & ValidateStateNodeWithoutChildren<Node> & ValidatePseudoStateAnnotations<Node, Path> : Node extends {
     readonly states: infer Children;
-} ? ValidateExactStateNodeProperties<Node, "compound", Path> & ValidateStateNodeWithChildren<Node, Children, Path> : ValidateExactStateNodeProperties<Node, "atomic", Path> & ValidateStateNodeWithoutChildren<Node>;
+} ? ValidateExactStateNodeProperties<Node, "compound", Path> & ValidateStateNodeWithChildren<Node, Children, Path> & ValidatePseudoStateAnnotations<Node, Path> : ValidateExactStateNodeProperties<Node, "atomic", Path> & ValidateStateNodeWithoutChildren<Node> & ValidatePseudoStateAnnotations<Node, Path>;
 type ValidateOutputSchema<Node> = "output" extends keyof Node ? Node extends {
     readonly output: Schema.Top;
 } ? unknown : StateDefinitionError<"State output must be a schema"> : unknown;
-type ValidateStateNodeWithChildren<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}, Children, Path extends PropertyKey> = Children extends Machine.StateSchemas ? Node extends {
+type ValidateStateNodeWithChildren<Node extends Machine.StateNodeConfig, Children, Path extends PropertyKey> = Children extends Machine.StateSchemas ? Node extends {
     readonly type: "final";
 } ? StateDefinitionError<"Final states cannot declare child states"> : Node extends {
     readonly type: "parallel";
 } ? "initial" extends keyof Node ? StateDefinitionError<"Parallel states cannot declare an initial child"> : {
     readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
 } & ValidateOutputSchema<Node> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children, Path> : StateDefinitionError<"Child states must be a state tree">;
-type ValidateCompoundStateNode<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
+type ValidateCompoundStateNode<Node extends Machine.StateNodeConfig, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
     readonly initial: infer Initial;
 } ? Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
     readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
 } : StateDefinitionError<"Compound initial must be one of its direct child keys"> : StateDefinitionError<"Compound states must declare an initial child">;
-type ValidateStateNodeWithoutChildren<Node extends {
-    readonly schema: Machine.TaggedSchema;
-}> = "initial" extends keyof Node ? StateDefinitionError<"Atomic states cannot declare an initial child"> : Node extends {
+type ValidateStateNodeWithoutChildren<Node extends Machine.StateNodeConfig> = "initial" extends keyof Node ? StateDefinitionError<"Atomic states cannot declare an initial child"> : Node extends {
     readonly type: infer Type;
 } ? Type extends "final" ? ValidateOutputSchema<Node> : Type extends "active" | undefined ? "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown : StateDefinitionError<"State node type must be active, final, or parallel"> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown;
 type DefineStateTreeInput<States extends Machine.StateSchemas> = {
@@ -483,6 +473,24 @@ type FromMethod<Arguments extends ReadonlyArray<unknown>, Result> = {
 };
 type ConstructionResult<Result> = Result | Machine.StateConstruction<Result>;
 type UnwrapConstruction<Result> = Result extends Machine.StateConstruction<infer Value> ? Value : Result;
+type NodeValue<Node> = [Machine.NodeSchema<Node>] extends [never] ? undefined : Machine.NodeSchema<Node>["Type"];
+type NodeMakeInput<Node> = [Machine.NodeSchema<Node>] extends [never] ? never : Machine.NodeSchema<Node>["~type.make.in"];
+type WithNodeValue<Node, Rest extends ReadonlyArray<unknown>> = Machine.NodeSchema<Node> extends never ? Rest : readonly [value: NodeValue<Node>, ...Rest];
+type WithNodeInput<Node, Rest extends ReadonlyArray<unknown>> = Machine.NodeSchema<Node> extends never ? Rest : readonly [input: NodeMakeInput<Node>, ...Rest];
+type NodeBuilderMethod<Node, Arguments extends ReadonlyArray<unknown>, Result, FromArguments extends ReadonlyArray<unknown>, FromResult> = Machine.NodeSchema<Node> extends never ? {
+    readonly from: FromCallable<FromArguments, FromResult>;
+} : ((...args: Arguments) => Result) & {
+    readonly from: FromCallable<FromArguments, FromResult>;
+};
+type NodeMethod<Node, Arguments extends ReadonlyArray<unknown>, Result, FromArguments extends ReadonlyArray<unknown>> = Machine.NodeSchema<Node> extends never ? FromMethod<FromArguments, Result> : ((...args: Arguments) => Result) & FromMethod<FromArguments, Result>;
+type NodeConstructionSelectorFromCallable<Node, Builder, Result> = Machine.NodeSchema<Node> extends never ? {
+    <Selected extends ConstructionResult<Result>>(state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
+} : ConstructionSelectorFromCallable<NodeMakeInput<Node>, Builder, Result>;
+type NestedTargetMethod<Node, Builder, Result> = Machine.NodeSchema<Node> extends never ? {
+    readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result>;
+} : (<Selected extends ConstructionResult<Result>>(value: NodeValue<Node>, state: (builder: Builder) => Selected) => Selected) & {
+    readonly from: NodeConstructionSelectorFromCallable<Node, Builder, Result>;
+};
 type ConstructionSelectorFromCallable<Input, Builder, Result> = {} extends Input ? {
     <Selected extends ConstructionResult<Result>>(state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
     <Selected extends ConstructionResult<Result>>(input: Input, state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
@@ -492,127 +500,111 @@ type InitialSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefi
 } & {
     readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
 };
-type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>) & FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>>;
+type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>> : ((...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>) & FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>>;
 type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     states: (builder: InitialParallelBuilder<Children, Path>) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
     readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => InitialSelectableResult<Children, Initial, Path>
-] : never : [value: Machine.NodeSchema<Node>["Type"]] : never;
+]> : never : WithNodeValue<Node, []> : never;
 type InitialSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     states: (builder: InitialParallelBuilder<Children, Path>) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>, boolean>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
     readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => ConstructionResult<InitialSelectableResult<Children, Initial, Path>>
-] : never : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
+]> : never : WithNodeInput<Node, []> : never;
 type InitialSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSnapshotRegionsWithPrefix<Children, Path>> : Node extends {
+} ? Machine.ParallelSnapshot<Path, NodeValue<Node>, InitialSnapshotRegionsWithPrefix<Children, Path>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
     readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
-} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSelectableResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, Machine.NodeSchema<Node>["Type"]> : never;
+} ? Machine.CompoundSnapshot<Path, NodeValue<Node>, InitialSelectableResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, NodeValue<Node>> : never;
 type InitialSelectableResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States> | ChoiceStateKey<States>, Prefix extends string> = StateId extends ChoiceStateKey<States> ? Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, StateId>> : StateId extends ActiveStateKey<States> ? InitialSnapshotResult<States, StateId, Prefix> : never;
 type InitialSnapshotRegionsWithPrefix<States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: InitialSnapshotResult<States, Key, Prefix>;
 };
 type InitialParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
-    readonly [Key in Remaining]: ((...args: InitialSnapshotArguments<States, Key, Prefix>) => InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: NodeBuilderMethod<States[Key], InitialSnapshotArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
-    }, Constructed>) & {
-        readonly from: FromCallable<InitialSnapshotFromArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
-        }, true>>;
-    };
+    }, Constructed>, InitialSnapshotFromArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
+    }, true>>;
 };
 type FullSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefix extends string = ""> = {
     readonly [Key in ActiveStateKey<States>]: FullSnapshotMethod<States, Key, Prefix>;
 } & {
     readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
 };
-type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>) & FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>>;
+type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>> : ((...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>) & FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>>;
 type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => Machine.SnapshotWithPrefix<Children, Path> | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>
-] : [value: Machine.NodeSchema<Node>["Type"]] : never;
+]> : WithNodeValue<Node, []> : never;
 type FullSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => ConstructionResult<Machine.SnapshotWithPrefix<Children, Path> | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>>
-] : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
+]> : WithNodeInput<Node, []> : never;
 type FullSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Machine.SnapshotByIdentifierWithPath<States, StateId, Path>;
 type FullParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
-    readonly [Key in Remaining]: ((...args: FullSnapshotArguments<States, Key, Prefix>) => FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: NodeBuilderMethod<States[Key], FullSnapshotArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-    }, Constructed>) & {
-        readonly from: FromCallable<FullSnapshotFromArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-        }, true>>;
-    };
+    }, Constructed>, FullSnapshotFromArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+    }, true>>;
 };
 type HistorySnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotArguments<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     states: (builder: HistoryParallelBuilder<Children, Path, Owner>) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    value: Machine.NodeSchema<Node>["Type"],
+} ? WithNodeValue<Node, [
     state: (builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
-] : never : never;
+]> : never : never;
 type HistorySnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotFromArguments<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     states: (builder: HistoryParallelBuilder<Children, Path, Owner>) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>, boolean>
-] : Node extends {
+]> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? [
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? WithNodeInput<Node, [
     state: (builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
-] : never : never;
+]> : never : never;
 type HistorySnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotResult<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], HistorySnapshotRegions<Children, Path, Owner>> : Node extends {
+} ? Machine.ParallelSnapshot<Path, NodeValue<Node>, HistorySnapshotRegions<Children, Path, Owner>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], HistorySnapshotWithPrefix<Children, Owner, Path>> : never : never;
-type HistorySnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string> = ((...args: HistorySnapshotArguments<States, StateId, Prefix, Owner>) => HistorySnapshotResult<States, StateId, Prefix, Owner>) & FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>>;
+} ? Machine.CompoundSnapshot<Path, NodeValue<Node>, HistorySnapshotWithPrefix<Children, Owner, Path>> : never : never;
+type HistorySnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>> : ((...args: HistorySnapshotArguments<States, StateId, Prefix, Owner>) => HistorySnapshotResult<States, StateId, Prefix, Owner>) & FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>>;
 type HistorySnapshotWithPrefix<States extends Machine.StateSchemas, Owner extends string, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? HistorySnapshotResult<States, Key, Prefix, Owner> : never;
 }[ActiveStateKey<States>];
@@ -623,19 +615,15 @@ type HistorySnapshotRegions<States extends Machine.StateSchemas, Prefix extends
     readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? HistorySnapshotResult<States, Key, Prefix, Owner> : FullSnapshotResult<States, Key, Prefix>;
 };
 type HistoryParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Owner extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
-    readonly [Key in Remaining]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? ((...args: HistorySnapshotArguments<States, Key, Prefix, Owner>) => HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? NodeBuilderMethod<States[Key], HistorySnapshotArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
+    }, Constructed>, HistorySnapshotFromArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
-    }, Constructed>) & {
-        readonly from: FromCallable<HistorySnapshotFromArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
-        }, true>>;
-    } : ((...args: FullSnapshotArguments<States, Key, Prefix>) => HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+    }, true>> : NodeBuilderMethod<States[Key], FullSnapshotArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-    }, Constructed>) & {
-        readonly from: FromCallable<FullSnapshotFromArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
-            readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-        }, true>>;
-    };
+    }, Constructed>, FullSnapshotFromArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+    }, true>>;
 };
 type ParentPath<Path extends string> = Path extends `${infer Parent}.${infer Child}` ? Child extends `${string}.${string}` ? `${Parent}.${ParentPath<Child>}` : Parent : never;
 type IsCompoundNode<Node> = Node extends {
@@ -664,19 +652,14 @@ type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States
 type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>>;
-} : ((value: Machine.NodeSchema<Node>["Type"], states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? Source extends Path | `${Path}.${string}` ? NestedTargetMethod<Node, LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>> : NodeMethod<Node, WithNodeValue<Node, [
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
+]>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : Node extends {
+]>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>>;
-} : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"]
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
-type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateNodeIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & {
+} ? NestedTargetMethod<Node, LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>> : NodeMethod<Node, WithNodeValue<Node, []>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, []>> : never;
+type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateNodeIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & (Scope extends Machine.ValuedStateIdentifier<States> ? {
     /**
      * Updates the value of the state containing the local group and moves to
      * one of the states inside it. Values in other active branches are kept.
@@ -686,7 +669,7 @@ type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope exten
     readonly with: (<Result extends ConstructionResult<LocalTargetResultWithPrefix<States, Children, Scope>>>(value: Machine.StateByIdentifier<States, Scope>, state: (builder: LocalTargetBuilderWithPrefix<States, Children, Scope, Source>) => Result) => Result) & {
         readonly from: ConstructionSelectorFromCallable<Machine.SchemaByIdentifier<States, Scope>["~type.make.in"], LocalTargetBuilderWithPrefix<States, Children, Scope, Source>, LocalTargetResultWithPrefix<States, Children, Scope>>;
     };
-} : {};
+} : {}) : {};
 type BranchTargetResult<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? States[StateId] extends {
@@ -703,18 +686,13 @@ type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, State
 type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>>;
-} & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"], states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"],
+} ? Source extends Path | `${Path}.${string}` ? NestedTargetMethod<Node, BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>> & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : NodeMethod<Node, WithNodeValue<Node, [
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
+]>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : Node extends {
+]>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
-    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>>;
-} & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
-    input: Machine.NodeSchema<Node>["~type.make.in"]
-], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
+} ? NestedTargetMethod<Node, BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>> & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : NodeMethod<Node, WithNodeValue<Node, []>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, []>> : never;
 type BranchTargetBuilderForRoot<States extends Machine.StateSchemas, Root extends ActiveStateKey<States>, Source extends Machine.StateNodeIdentifier<States>> = {
     readonly [Key in Root]: BranchTargetMethod<States, States, Key, "", Source>;
 };
@@ -735,13 +713,16 @@ type HasDirectShallowHistory<States extends Machine.StateSchemas> = {
         readonly history: "deep";
     } ? never : Key;
 }[HistoryStateKey<States>] extends never ? false : true;
+type HasValuedActiveChild<States extends Machine.StateSchemas> = {
+    readonly [Key in ActiveStateKey<States>]: Machine.NodeSchema<States[Key]> extends never ? never : Key;
+}[ActiveStateKey<States>] extends never ? false : true;
 type InitializerClosureForNode<AllStates extends Machine.StateSchemas, Node, Path extends string> = Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? Extract<Path, Machine.StateIdentifier<AllStates>> | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
+} ? (HasValuedActiveChild<Children> extends true ? Extract<Path, Machine.StateIdentifier<AllStates>> : never) | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
     readonly initial: infer Initial;
-} ? Extract<Path, Machine.StateIdentifier<AllStates>> | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : never) : never;
+} ? (Initial extends ActiveStateKey<Children> ? Machine.NodeSchema<Children[Initial]> extends never ? never : Extract<Path, Machine.StateIdentifier<AllStates>> : never) | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : never) : never;
 type InitializerClosuresForChildren<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: InitializerClosureForNode<AllStates, States[Key], Machine.JoinPath<Prefix, Key>>;
 }[ActiveStateKey<States>];
@@ -1280,8 +1261,9 @@ export declare namespace Machine {
      * Descriptive annotations exposed for compiled state nodes.
      *
      * Schema-backed states resolve their complete Effect Schema annotation map.
-     * Pseudo-states accept only the descriptive fields below. Annotations never
-     * affect state identity, targeting, or runtime behavior.
+     * Schema-less active states and pseudo-states accept only the descriptive
+     * fields below. Annotations never affect state identity, targeting, or
+     * runtime behavior.
      *
      * @category models
      * @since 0.4.0
@@ -1291,10 +1273,13 @@ export declare namespace Machine {
         readonly description?: string | undefined;
         readonly documentation?: string | undefined;
     }
-    /** Descriptive annotations accepted by schema-less pseudo-states. */
-    type PseudoStateAnnotations = Pick<StateNodeAnnotations, "title" | "description" | "documentation">;
+    /** Descriptive annotations accepted by schema-less active and pseudo-states. */
+    type SchemaLessStateAnnotations = Pick<StateNodeAnnotations, "title" | "description" | "documentation">;
+    /** @deprecated Use {@link SchemaLessStateAnnotations}. */
+    type PseudoStateAnnotations = SchemaLessStateAnnotations;
     /**
-     * Configuration accepted for an atomic object state node.
+     * Configuration accepted for an atomic object state node. Omit `schema` when
+     * the state owns no value; a schema-less final may still declare `output`.
      *
      * @category models
      * @since 0.4.0
@@ -1303,35 +1288,63 @@ export declare namespace Machine {
         readonly schema: TaggedSchema;
         readonly type?: "active";
         readonly output?: never;
+        readonly annotations?: never;
     } | {
         readonly schema: TaggedSchema;
         readonly type: "final";
         readonly output?: Schema.Top;
+        readonly annotations?: never;
+    } | {
+        readonly schema?: never;
+        readonly type?: "active";
+        readonly output?: never;
+        readonly annotations?: SchemaLessStateAnnotations;
+    } | {
+        readonly schema?: never;
+        readonly type: "final";
+        readonly output?: Schema.Top;
+        readonly annotations?: SchemaLessStateAnnotations;
     };
     /**
-     * Configuration accepted for a compound object state node.
+     * Configuration accepted for a compound object state node. Omit `schema`
+     * when the compound state exists only to own control topology.
      *
      * @category models
      * @since 0.4.0
      */
-    interface CompoundStateNodeConfig {
+    type CompoundStateNodeConfig = {
         readonly schema: TaggedSchema;
         readonly type?: "active";
         readonly initial: string;
         readonly states: StateTree;
-    }
+        readonly annotations?: never;
+    } | {
+        readonly schema?: never;
+        readonly type?: "active";
+        readonly initial: string;
+        readonly states: StateTree;
+        readonly annotations?: SchemaLessStateAnnotations;
+    };
     /**
-     * Configuration accepted for a parallel object state node.
+     * Configuration accepted for a parallel object state node. Omit `schema`
+     * when the parallel state exists only to own its regions.
      *
      * @category models
      * @since 0.4.0
      */
-    interface ParallelStateNodeConfig {
+    type ParallelStateNodeConfig = {
         readonly schema: TaggedSchema;
         readonly type: "parallel";
         readonly output?: Schema.Top;
         readonly states: StateTree;
-    }
+        readonly annotations?: never;
+    } | {
+        readonly schema?: never;
+        readonly type: "parallel";
+        readonly output?: Schema.Top;
+        readonly states: StateTree;
+        readonly annotations?: SchemaLessStateAnnotations;
+    };
     /**
      * Pseudo-state that restores the last active configuration of its parent.
      *
@@ -1348,7 +1361,7 @@ export declare namespace Machine {
         readonly type: "history";
         /** Defaults to shallow history. */
         readonly history?: "shallow" | "deep";
-        readonly annotations?: PseudoStateAnnotations;
+        readonly annotations?: SchemaLessStateAnnotations;
     }
     /**
      * Transient decision pseudo-state resolved immediately when targeted.
@@ -1362,7 +1375,7 @@ export declare namespace Machine {
      */
     interface ChoiceStateNodeConfig {
         readonly type: "choice";
-        readonly annotations?: PseudoStateAnnotations;
+        readonly annotations?: SchemaLessStateAnnotations;
     }
     /**
      * Configuration accepted for an object state node.
@@ -1423,11 +1436,17 @@ export declare namespace Machine {
         /** Type-safe builders for constructing valid initial snapshots. */
         readonly initial: InitialBuilder<States>;
         /**
-         * Returns the decoded value for an active state path.
+         * Returns the decoded value for an active state path. The supplied
+         * snapshot may be a complete root snapshot or a snapshot previously
+         * extracted from this definition. Extracted snapshots accept only their
+         * own absolute path and descendant paths.
          *
          * @since 0.4.0
          */
-        readonly get: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateByIdentifier<States, Path>>;
+        readonly get: {
+            <Path extends ValuedStateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): Option.Option<StateByIdentifier<States, Path>>;
+            <const From extends StateIdentifier<States>, const Path extends ValuedStateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): Option.Option<StateByIdentifier<States, Path>>;
+        };
         /**
          * Returns the decoded value for an active state path together with all of
          * its active parent values.
@@ -1438,19 +1457,31 @@ export declare namespace Machine {
          *
          * @since 0.4.0
          */
-        readonly getWithParents: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateWithParents<States, Path>>;
+        readonly getWithParents: <Path extends ValuedStateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateWithParents<States, Path>>;
         /**
-         * Returns the snapshot for an active state path.
+         * Returns the snapshot for an active state path. The supplied snapshot may
+         * be a complete root snapshot or a snapshot previously extracted from this
+         * definition. Extracted snapshots accept only their own absolute path and
+         * descendant paths.
          *
          * @since 0.4.0
          */
-        readonly getSnapshot: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<SnapshotByIdentifier<States, Path>>;
+        readonly getSnapshot: {
+            <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): Option.Option<SnapshotByIdentifier<States, Path>>;
+            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): Option.Option<SnapshotByIdentifier<States, Path>>;
+        };
         /**
-         * Returns whether a state path is active in the snapshot.
+         * Returns whether a state path is active in the snapshot. The supplied
+         * snapshot may be a complete root snapshot or a snapshot previously
+         * extracted from this definition. Extracted snapshots accept only their
+         * own absolute path and descendant paths.
          *
          * @since 0.4.0
          */
-        readonly matches: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => boolean;
+        readonly matches: {
+            <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): boolean;
+            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): boolean;
+        };
     }
     /**
      * Validates the nested shape of state schema definitions.
@@ -1463,14 +1494,14 @@ export declare namespace Machine {
     interface StateNodeBase<Path extends string = string> {
         readonly path: Path;
         readonly key: string;
-        /** Resolved Effect Schema annotations, or descriptive pseudo-state annotations. */
+        /** Resolved schema annotations, or descriptive schema-less-state annotations. */
         readonly annotations: Readonly<StateNodeAnnotations> | undefined;
         readonly order: number;
     }
     /** Runtime metadata for a compiled atomic state. */
     interface AtomicStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
         readonly type: "atomic";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1480,7 +1511,7 @@ export declare namespace Machine {
     /** Runtime metadata for a compiled compound state. */
     interface CompoundStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath, ChoicePath extends string = ActivePath> extends StateNodeBase<OwnPath> {
         readonly type: "compound";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1491,7 +1522,7 @@ export declare namespace Machine {
     /** Runtime metadata for a compiled parallel state. */
     interface ParallelStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
         readonly type: "parallel";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: Schema.Top | undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1502,7 +1533,7 @@ export declare namespace Machine {
     /** Runtime metadata for a compiled final state. */
     interface FinalStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
         readonly type: "final";
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: Schema.Top | undefined;
         readonly history: undefined;
         readonly parent: ActivePath | undefined;
@@ -1662,6 +1693,10 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type StateIdentifier<States extends StateSchemas> = StateIdentifierWithPrefix<States>;
+    /** Extracts active state paths whose definitions declare a state value schema. */
+    type ValuedStateIdentifier<States extends StateSchemas> = StateIdentifier<States> extends infer StateId ? StateId extends StateIdentifier<States> ? NodeSchema<NodeByIdentifier<States, StateId>> extends never ? never : StateId : never : never;
+    /** Extracts active state paths whose definitions intentionally omit a state value schema. */
+    type StructuralStateIdentifier<States extends StateSchemas> = Exclude<StateIdentifier<States>, ValuedStateIdentifier<States>>;
     /**
      * Extracts the state path values represented by a state definition under a
      * parent path prefix.
@@ -1789,7 +1824,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type StateByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = Extract<StateOf<States>, SchemaByIdentifier<States, StateId>["Type"]>;
+    type StateByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends ValuedStateIdentifier<States> ? SchemaByIdentifier<States, StateId>["Type"] : undefined;
     /**
      * Extracts every parent state path from a state identifier.
      *
@@ -1811,7 +1846,7 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type ParentStateValues<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? {
-        readonly [Parent in Extract<ParentStateIdentifier<StateId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
+        readonly [Parent in Extract<ParentStateIdentifier<StateId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
     } : never;
     /**
      * Extracts the nearest parent value, or `undefined` for a root state.
@@ -1819,7 +1854,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type ParentStateValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent ? [Parent] extends [never] ? undefined : Parent extends StateIdentifier<States> ? StateByIdentifier<States, Parent> : undefined : undefined : never;
+    type ParentStateValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent ? [Parent] extends [never] ? undefined : Parent extends ValuedStateIdentifier<States> ? StateByIdentifier<States, Parent> : undefined : undefined : never;
     /**
      * Represents a decoded state value together with all of its parent values.
      *
@@ -1936,7 +1971,7 @@ export declare namespace Machine {
      */
     interface EncodedSnapshotState {
         readonly path: string;
-        readonly value: unknown;
+        readonly value?: unknown;
     }
     /**
      * Encoded output for one completed state path in a normalized machine
@@ -2085,9 +2120,9 @@ export declare namespace Machine {
     type SnapshotByIdentifierWithPath<States extends StateSchemas, StateId extends ActiveStateKey<States>, Path extends string> = States[StateId] extends {
         readonly type: "parallel";
         readonly states: infer Children;
-    } ? Children extends StateSchemas ? ParallelSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotRegionsWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : States[StateId] extends {
+    } ? Children extends StateSchemas ? ParallelSnapshot<Path, NodeValue<States[StateId]>, SnapshotRegionsWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeValue<States[StateId]>> : States[StateId] extends {
         readonly states: infer Children;
-    } ? Children extends StateSchemas ? CompoundSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]>;
+    } ? Children extends StateSchemas ? CompoundSnapshot<Path, NodeValue<States[StateId]>, SnapshotWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeValue<States[StateId]>> : AtomicSnapshot<Path, NodeValue<States[StateId]>>;
     /**
      * Extracts a complete root snapshot whose selected configuration contains a
      * particular active state.
@@ -2172,7 +2207,7 @@ export declare namespace Machine {
         readonly path: StateId;
         readonly value: StateByIdentifier<States, StateId>;
         readonly values?: Partial<{
-            readonly [AncestorStateId in StateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>;
+            readonly [AncestorStateId in ValuedStateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>;
         }>;
     }
     /**
@@ -2413,7 +2448,7 @@ export declare namespace Machine {
     interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>> {
         readonly parent: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
         readonly parents: {
-            readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
+            readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
         };
         readonly event: LifecycleEvent<Events>;
         readonly target: TargetBuilder<States, ChoiceId>;
@@ -2801,11 +2836,11 @@ export declare namespace Machine {
         readonly type: "parallel";
         readonly states: infer Children extends StateSchemas;
     } ? {
-        readonly [Key in ActiveStateKey<Children>]: NodeSchema<Children[Key]>["Type"];
+        readonly [Key in ActiveStateKey<Children> as NodeSchema<Children[Key]> extends never ? never : Key]: NodeValue<Children[Key]>;
     } : Node extends {
         readonly states: infer Children extends StateSchemas;
         readonly initial: infer Initial;
-    } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]>["Type"] : never : never : never;
+    } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]> extends never ? never : NodeValue<Children[Initial]> : never : never : never;
     /** Context passed to an implicit child-state initializer. */
     type StateInitialContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = StateActionContext<States, Events, Emits, StateId>;
     /** Initial child value implementation for a compound or parallel state. */
@@ -3115,7 +3150,9 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * The returned `states` property is the same object passed to `defineStates`.
  * The returned `initial` builder creates snapshots without user-authored path
- * strings and enforces compound and parallel initial-state rules.
+ * strings and enforces compound and parallel initial-state rules. Active nodes
+ * may omit `schema` when they own no value; those builders expose `.from(...)`
+ * and still participate fully in targeting, matching, and snapshots.
  *
  * **Example** (Atomic initial snapshot)
  *