@typeonce/effect-machine 0.31.2 → 0.33.0

package/src/internal/machine/targetBuilder.ts

@@ -0,0 +1,525 @@
+/** Constructs decoded snapshots and transition targets from a captured state tree. */
+import { hasProperty } from "effect/Predicate"
+import type { Machine } from "../../Machine.js"
+import { SnapshotBuilderStateTypeId } from "./symbols.js"
+import * as Topology from "./topology.js"
+
+type SnapshotBuilderOptions = {
+  readonly mode: "initial" | "full"
+  readonly prefix: string
+}
+
+type FromMethodKind = "leaf" | "nested"
+
+export const withFrom = <Method extends (value: unknown, ...args: ReadonlyArray<any>) => unknown>(
+  method: Method,
+  kind: FromMethodKind,
+  valued: boolean
+): {
+  readonly decoded?: Method
+  readonly from: (...args: ReadonlyArray<any>) => unknown
+} => {
+  const builder: Record<string, unknown> = {}
+  if (valued) {
+    Object.defineProperty(builder, "decoded", {
+      value: method,
+      enumerable: false
+    })
+  }
+  Object.defineProperty(builder, "from", {
+    value: (...args: ReadonlyArray<any>) => {
+      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 as {
+    readonly decoded?: Method
+    readonly from: (...args: ReadonlyArray<any>) => unknown
+  }
+}
+
+const withInitial = <Builder extends object>(
+  builder: Builder,
+  path: string,
+  valued: boolean,
+  values?: Readonly<Record<string, unknown>>
+): Builder => {
+  const initial = withFrom(
+    (value: unknown) => Topology.makeInitialTarget(path, value, values),
+    "leaf",
+    valued
+  )
+  Object.defineProperty(builder, "initial", {
+    value: Object.freeze(initial),
+    enumerable: false
+  })
+  return builder
+}
+
+export const makeSnapshotBuilder = (
+  states: Machine.StateTree,
+  options: SnapshotBuilderOptions
+): unknown => {
+  const builder: Record<string, unknown> = {}
+  for (const key of Object.keys(states)) {
+    const definition = states[key]!
+    const pseudoType = (definition as { readonly type?: unknown }).type
+    if (pseudoType === "history") {
+      continue
+    }
+    const path = options.prefix === "" ? key : `${options.prefix}.${key}`
+    if (pseudoType === "choice") {
+      builder[key] = Object.freeze(() => Topology.makeChoiceTarget(path, getParentPathRuntime(path)))
+      continue
+    }
+    const node = Topology.getStateNodeDefinition(path, definition)
+    const method = withFrom(
+      makeSnapshotFactory(definition, key, options),
+      node.states === undefined ? "leaf" : "nested",
+      node.schema !== undefined
+    )
+    builder[key] = Object.freeze(
+      node.states === undefined || options.mode !== "full" || options.prefix !== ""
+        ? method
+        : withInitial(method, path, node.schema !== undefined)
+    )
+  }
+  return Object.freeze(builder)
+}
+
+const makeParallelSnapshotBuilder = (
+  states: Machine.StateTree,
+  options: SnapshotBuilderOptions,
+  regions: Readonly<Record<string, unknown>>
+): unknown => {
+  const builder: Record<string, unknown> = {}
+  Object.defineProperty(builder, SnapshotBuilderStateTypeId, {
+    value: regions,
+    enumerable: false
+  })
+  for (const key of Object.keys(states)) {
+    const definition = states[key]!
+    const pseudoType = (definition as { readonly type?: unknown }).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: unknown, selector?: (builder: unknown) => unknown) => {
+        const nextRegions: Record<string, unknown> = {}
+        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: string,
+  states: Machine.StateTree,
+  builder: unknown
+): Readonly<Record<string, unknown>> => {
+  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 as { readonly [SnapshotBuilderStateTypeId]: Readonly<Record<string, unknown>> })[
+    SnapshotBuilderStateTypeId
+  ]
+  for (const key of Object.keys(states)) {
+    const pseudoType = (states[key] as { readonly type?: unknown }).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
+}
+
+/**
+ * A factory owns its lazily compiled child builder. The builder captures only
+ * immutable topology; every call constructs fresh values and configurations.
+ * Parallel builders remain per-call because they accumulate selected regions.
+ */
+const makeSnapshotFactory = (
+  definition: Machine.TaggedSchema | Machine.StateNodeConfig,
+  key: string,
+  options: SnapshotBuilderOptions
+): (value: unknown, selector?: (builder: unknown) => unknown) => Record<string, unknown> => {
+  const path = options.prefix === "" ? key : `${options.prefix}.${key}`
+  const mode = options.mode
+  const node = Topology.getStateNodeDefinition(path, definition)
+  let childBuilder: unknown
+  return (value, selector) => {
+    const snapshot: Record<string, unknown> = { 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, { mode, prefix: path }, {})
+      snapshot.states = getParallelSnapshotBuilderRegions(path, node.states, selector(builder))
+      return snapshot
+    }
+    if (childBuilder === undefined) {
+      const childStates = mode === "initial" && node.initial !== undefined
+        ? { [node.initial]: node.states[node.initial]! }
+        : node.states
+      childBuilder = makeSnapshotBuilder(childStates, { mode, prefix: path })
+    }
+    snapshot.state = selector(childBuilder)
+    return snapshot
+  }
+}
+
+const makeSnapshotForNode = (
+  definition: Machine.TaggedSchema | Machine.StateNodeConfig,
+  key: string,
+  value: unknown,
+  selector: ((builder: unknown) => unknown) | undefined,
+  options: SnapshotBuilderOptions
+): Record<string, unknown> => makeSnapshotFactory(definition, key, options)(value, selector)
+
+export const getTargetBuilderNode = (
+  stateNodes: Machine.StateNodes,
+  path: string
+): Machine.StateNode => {
+  const node = stateNodes.byPath.get(path)
+  if (node === undefined) {
+    throw new Error(`Machine expected state path "${path}" to exist`)
+  }
+  return node
+}
+
+export const getLocalTargetScope = (
+  stateNodes: Machine.StateNodes,
+  source: string
+): string | undefined => {
+  let current: string | undefined = 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: Readonly<Record<string, unknown>> | undefined
+): values is Readonly<Record<string, unknown>> => values !== undefined && Object.keys(values).length > 0
+
+const makeTargetWithValues = (
+  path: string,
+  value: unknown,
+  values: Readonly<Record<string, unknown>> | undefined
+): Machine.Target<any, any> =>
+  hasTargetValues(values)
+    ? Topology.makeTarget(path as any, value as any, { values: values as any })
+    : Topology.makeTarget(path as any, value as any)
+
+const getTargetBuilderDefinition = (
+  states: Machine.StateTree,
+  targetPath: string
+): Machine.TaggedSchema | Machine.StateNodeConfig => {
+  let children = states
+  let path = ""
+  let definition: Machine.TaggedSchema | Machine.StateNodeConfig | undefined
+  const segments = Object.hasOwn(states, "") && targetPath !== ""
+    ? ["", ...targetPath.split(".")]
+    : targetPath.split(".")
+  for (const key of segments) {
+    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: Machine.StateTree,
+  node: Machine.StateNode,
+  value: unknown,
+  selector: ((builder: unknown) => unknown) | undefined,
+  values: Readonly<Record<string, unknown>> | undefined
+): Machine.Target<any, any> => {
+  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 as any, value as any, {
+    snapshot: snapshot as any,
+    values: values as any
+  })
+}
+
+const extendTargetValues = (
+  values: Readonly<Record<string, unknown>> | undefined,
+  path: string,
+  value: unknown
+): Readonly<Record<string, unknown>> => {
+  const next: Record<string, unknown> = {}
+  if (values !== undefined) {
+    for (const key of Object.keys(values)) {
+      next[key] = values[key]
+    }
+  }
+  next[path] = value
+  return next
+}
+
+const makeLocalTargetChildBuilder = (
+  states: Machine.StateTree,
+  stateNodes: Machine.StateNodes,
+  parentPath: string,
+  values: Readonly<Record<string, unknown>> | undefined,
+  source: string
+): unknown => {
+  const parent = getTargetBuilderNode(stateNodes, parentPath)
+  const builder: Record<string, unknown> = {}
+  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: unknown, selector?: (builder: unknown) => unknown) => {
+        if (child.type === "atomic" || child.type === "final") {
+          return makeTargetWithValues(child.path, value, values)
+        }
+        if (child.type === "parallel") {
+          if (source !== child.path && !(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: Machine.StateTree,
+  stateNodes: Machine.StateNodes,
+  source: string
+): unknown => {
+  const scope = getLocalTargetScope(stateNodes, source)
+  if (scope === undefined) {
+    return {}
+  }
+  const builder = makeLocalTargetChildBuilder(states, stateNodes, scope, undefined, source) as Record<string, unknown>
+  const scopeNode = getTargetBuilderNode(stateNodes, scope)
+  if (scopeNode.schema !== undefined) {
+    builder.with = withFrom(
+      (value: unknown, selector?: (builder: unknown) => unknown) => {
+        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: Record<string, unknown>,
+  states: Machine.StateTree,
+  stateNodes: Machine.StateNodes,
+  parentPath: string,
+  values: Readonly<Record<string, unknown>> | undefined,
+  source: string
+): void => {
+  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: Machine.StateTree,
+  stateNodes: Machine.StateNodes,
+  path: string,
+  values: Readonly<Record<string, unknown>> | undefined,
+  source: string
+): unknown => {
+  const node = getTargetBuilderNode(stateNodes, path)
+  if (node.type === "atomic" || node.type === "final") {
+    return withFrom(
+      (value: unknown) => makeTargetWithValues(node.path, value, values),
+      "leaf",
+      node.schema !== undefined
+    )
+  }
+  const builder = withFrom(
+    (value: unknown, selector?: (builder: unknown) => unknown) => {
+      if (node.type === "parallel") {
+        if (source !== node.path && !(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: Record<string, unknown> = {}
+        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: Record<string, unknown> = {}
+      addBranchTargetChildren(
+        nextBuilder,
+        states,
+        stateNodes,
+        node.path,
+        node.schema === undefined ? values : extendTargetValues(values, node.path, value),
+        source
+      )
+      return selector(nextBuilder)
+    },
+    "nested",
+    node.schema !== undefined
+  ) as unknown as Record<string, unknown>
+  withInitial(builder, node.path, node.schema !== undefined, values)
+  if (node.type !== "parallel" || source === node.path || node.path === "" || source.startsWith(`${node.path}.`)) {
+    addBranchTargetChildren(builder, states, stateNodes, node.path, values, source)
+  }
+  return builder
+}
+
+const makeBranchTargetBuilder = (
+  states: Machine.StateTree,
+  stateNodes: Machine.StateNodes,
+  source: string
+): unknown => {
+  const rootPath = stateNodes.roots[0]!
+  const root = getTargetBuilderNode(stateNodes, rootPath)
+  return {
+    [root.key]: makeBranchTargetNodeBuilder(states, stateNodes, root.path, undefined, source)
+  }
+}
+
+const makeHistoryTargetBuilder = (
+  states: Machine.StateTree,
+  prefix: string
+): unknown => {
+  const builder: Record<string, unknown> = {}
+  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: string): string => {
+  const separator = path.lastIndexOf(".")
+  if (separator < 0) {
+    return ""
+  }
+  return path.slice(0, separator)
+}
+
+export const makeTargetBuilder = <const States extends Machine.StateSchemas>(
+  states: States,
+  stateNodes: Machine.StateNodes
+) => {
+  const full = makeSnapshotBuilder(states, { mode: "full", prefix: "" }) as Machine.FullTargetBuilder<States>
+  const history = makeHistoryTargetBuilder(states, "") as Machine.HistoryTargetBuilder<States>
+  return <Source extends Machine.StateNodeIdentifier<States>>(source: Source): Machine.TargetBuilder<States, Source> =>
+    ({
+      none: Topology.makeNoTarget,
+      local: makeLocalTargetBuilder(states, stateNodes, source),
+      branch: makeBranchTargetBuilder(states, stateNodes, source),
+      full,
+      history
+    }) as Machine.TargetBuilder<States, Source>
+}

package/src/internal/machine/topology.ts

@@ -374,7 +374,7 @@ export const compileStateNodes = (states: Machine.StateSchemas): Machine.StateNo
       if (key.includes(".")) {
         throw new Error(`Machine state keys cannot contain ".": "${key}"`)
       }
-      const path = parent === undefined ? key : `${parent}.${key}`
+      const path = parent === undefined || parent === "" ? key : `${parent}.${key}`
       const definition = getStateNodeDefinition(path, tree[key]!)
       let node: Machine.StateNode
       let childStates: Machine.StateTree | undefined
@@ -401,7 +401,7 @@ export const compileStateNodes = (states: Machine.StateSchemas): Machine.StateNo
             history: undefined,
             parent,
             children: [],
-            initial: `${path}.${definition.initial}`
+            initial: path === "" ? definition.initial : `${path}.${definition.initial}`
           }
           childStates = definition.states
           break
@@ -627,7 +627,7 @@ export const getSnapshotByPath = (
   if (snapshot.path === path) {
     return Option.some(snapshot)
   }
-  if (!path.startsWith(`${snapshot.path}.`)) {
+  if (snapshot.path !== "" && !path.startsWith(`${snapshot.path}.`)) {
     return Option.none()
   }
   if (parents !== undefined) {

package/src/internal/machine/transition.ts

@@ -0,0 +1,26 @@
+import type { Enqueue, Machine } from "../../Machine.js"
+
+/** Captured callbacks shared by definition construction and both planners. */
+export type TransitionHandler<States extends Machine.StateSchemas, E, R, Context> = (
+  context: Context,
+  enqueue: Enqueue<any, any>
+) => Machine.HandlerResult<States, E, R> | Machine.Declined
+
+export type TransitionEvaluator<States extends Machine.StateSchemas, E, R, Context> = (
+  context: Context,
+  enqueue: Enqueue<any, any>
+) => {
+  readonly result: Machine.HandlerResult<States, E, R> | Machine.Declined
+  readonly branchIndex: number
+  readonly branchKey: string | undefined
+}
+
+export type EventTransition<States extends Machine.StateSchemas, E, R, Context> =
+  | TransitionHandler<States, E, R, Context>
+  | {
+    readonly reenter?: boolean
+    readonly declinable?: boolean
+    readonly targets?: ReadonlyArray<string>
+    readonly transition: TransitionHandler<States, E, R, Context>
+    readonly evaluate?: TransitionEvaluator<States, E, R, Context>
+  }

package/src/internal/testing/machine/finiteModel.ts

@@ -1352,7 +1352,7 @@ const selectDefinitionTarget = (
   const sourceRoot = byPath.get(source)!.root
   if (selected.root !== sourceRoot) {
     const root = target.split(".")[0]!
-    return selector.full[root]()
+    return selector.branch[root]()
   }
   const selectable = selectableDefinitionTarget(source, target, byPath)
   let current = selector.branch
@@ -1442,7 +1442,7 @@ const makeHandlers = (
           ? () => undefined
           : ({ target }: { readonly target: any }) =>
             resolveDefinitionTarget(target, path, transition.target!, byPath, transition.targetValue)
-        return selected.resolve(resolve, "reenter" in transition ? { reenter: transition.reenter } : undefined)
+        return ("reenter" in transition && transition.reenter ? selected.reenter() : selected).resolve(resolve)
       }
       if (transition.trigger.type === "event") on[transition.trigger.event] = config
       else if (transition.trigger.type === "always") always = config
@@ -1452,17 +1452,18 @@ const makeHandlers = (
       ? Object.fromEntries(node.states.flatMap((child) => {
         if (child._tag !== "History") return []
         return [[child.key, {
-          default: ({ target }: { readonly target: Record<string, any> }) => {
-            const fallback = byPath.get(child.fallback)!
-            const parts = child.fallback.split(".")
-            const completeRoot = selectSnapshot(target, fallback.root, byPath, parts, 0)
-            if (findSnapshot(completeRoot, path) === undefined) {
-              throw new Error(
-                `MachineTest.compileModel could not construct history fallback for "${path}.${child.key}"`
-              )
-            }
-            return completeRoot
-          }
+          default: ({ target: root }: { readonly target: any }) =>
+            root.from((target: Record<string, any>) => {
+              const fallback = byPath.get(child.fallback)!
+              const parts = child.fallback.split(".")
+              const completeRoot = selectSnapshot(target, fallback.root, byPath, parts, 0)
+              if (findSnapshot(completeRoot, path) === undefined) {
+                throw new Error(
+                  `MachineTest.compileModel could not construct history fallback for "${path}.${child.key}"`
+                )
+              }
+              return completeRoot
+            })
         }]]
       }))
       : {}
@@ -1511,23 +1512,21 @@ export const compileModel = (model: FiniteModel): Machine.Machine.Any => {
   const flattened = validateModel(model)
   const byPath = new Map(flattened.map((state) => [state.path, state]))
   const stateTree = makeStateTree(model.roots, undefined)
-  const defined = Machine.states(stateTree as any)
+  const defined = Machine.state({ initial: model.initial, states: stateTree } as any)
   const eventSchemas = model.events.map((event) => Schema.TaggedStruct(event, {}))
   const initial = byPath.get(model.initial)!
   const machine = Machine.make({
-    states: defined.states as any,
-    events: Machine.events(...eventSchemas) as any,
-    initial: (to: Record<string, any>) => {
-      const selected = to[initial.path]
-      const selection = typeof selected === "function" ? selected() : selected.initial
-      return selection.resolve(({ target }: { readonly target: any }) =>
-        selectSnapshot({ [initial.path]: target }, initial.path, byPath, [initial.path], 0) as any
-      )
-    }
+    root: defined,
+    events: Machine.eventsFromSchemas(...eventSchemas) as any
   } as any)
   const transitions = new Map(model.transitions.map((transition) => [
     `${transition.source}\u0000${triggerKey(transition.trigger)}`,
     transition
   ]))
-  return machine.handle(makeHandlers(model.roots, undefined, byPath, transitions) as any) as Machine.Machine.Any
+  return machine.handle(
+    {
+      initialize: ({ builder }: any) => builder.decoded(stateValue(initial)),
+      states: makeHandlers(model.roots, undefined, byPath, transitions)
+    } as any
+  ) as Machine.Machine.Any
 }