@typeonce/effect-machine 0.11.0 → 0.13.0

package/src/internal/machine/inspectionRuntime.ts

@@ -0,0 +1,102 @@
+/**
+ * Root-scoped live inspection publication and evidence projection.
+ *
+ * @since 0.13.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as PubSub from "effect/PubSub"
+import * as Stream from "effect/Stream"
+import type { Inspection } from "../../Machine.js"
+
+export type Draft<Event extends Inspection.Event = Inspection.Event> = Event extends Inspection.Event
+  ? Omit<Event, "sequence" | "rootSessionId">
+  : never
+
+export interface Runtime {
+  readonly rootSessionId: string
+  readonly stream: Stream.Stream<Inspection.Event>
+  readonly isActive: () => boolean
+  readonly nextDeliveryId: () => number
+  readonly nextMacrostepId: () => number
+  readonly publishUnsafe: (event: Draft) => void
+  readonly close: Effect.Effect<void>
+}
+
+export const make = (rootSessionId: string): Effect.Effect<Runtime> =>
+  Effect.gen(function*() {
+    const pubsub = yield* PubSub.unbounded<Inspection.Event>()
+    let subscribers = 0
+    let sequence = 0
+    let deliveryId = 0
+    let macrostepId = 0
+    return {
+      rootSessionId,
+      stream: Stream.fromPubSub(pubsub).pipe(
+        Stream.onStart(Effect.sync(() => {
+          subscribers += 1
+        })),
+        Stream.ensuring(Effect.sync(() => {
+          subscribers -= 1
+        }))
+      ),
+      isActive: () => subscribers > 0,
+      nextDeliveryId: () => deliveryId++,
+      nextMacrostepId: () => macrostepId++,
+      publishUnsafe: (event) => {
+        if (subscribers === 0) return
+        PubSub.publishUnsafe(pubsub, {
+          ...event,
+          sequence: sequence++,
+          rootSessionId
+        } as Inspection.Event)
+      },
+      close: PubSub.shutdown(pubsub)
+    }
+  })
+
+export const endpoint = (
+  target: { readonly id: string; readonly sessionId: string }
+): Inspection.Endpoint => ({
+  id: target.id,
+  sessionId: target.sessionId
+})
+
+const commands = (values: ReadonlyArray<unknown>): ReadonlyArray<Inspection.Command> =>
+  values.flatMap((command): ReadonlyArray<Inspection.Command> => {
+    if (typeof command !== "object" || command === null || !("_tag" in command)) return []
+    if (command._tag === "SendTo" && "target" in command && "event" in command) {
+      const target = command.target
+      return typeof target === "object" && target !== null && "id" in target
+        ? [{
+          _tag: "SendTo",
+          target: "sessionId" in target ? endpoint(target as any) : { id: String(target.id) },
+          event: command.event
+        }]
+        : []
+    }
+    if (command._tag === "Stop" && "child" in command) {
+      const child = command.child
+      if (typeof child === "string") return [{ _tag: "Stop", target: { id: child } }]
+      return typeof child === "object" && child !== null && "id" in child
+        ? [{ _tag: "Stop", target: "sessionId" in child ? endpoint(child as any) : { id: String(child.id) } }]
+        : []
+    }
+    return []
+  })
+
+export const microsteps = (plan: unknown): ReadonlyArray<Inspection.Microstep> => {
+  if (typeof plan !== "object" || plan === null || !("microsteps" in plan) || !Array.isArray(plan.microsteps)) {
+    return []
+  }
+  return plan.microsteps.map((step: any) => ({
+    event: step.event,
+    transitions: Array.isArray(step.transitions) ? step.transitions : [],
+    raisedEvents: Array.isArray(step.raisedEvents) ? step.raisedEvents : [],
+    emittedEvents: Array.isArray(step.emittedEvents) ? step.emittedEvents : [],
+    commands: commands(Array.isArray(step.commands) ? step.commands : []),
+    exitPaths: Array.isArray(step.exitPaths) ? step.exitPaths : [],
+    entryPaths: Array.isArray(step.entryPaths) ? step.entryPaths : [],
+    changed: step.changed === true
+  }))
+}

package/src/internal/machine/invocation.ts

@@ -6,7 +6,7 @@
 
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
-import type { ChildMachine, Logic, Machine } from "../../Machine.js"
+import type { ChildMachine, Inspection, Logic, Machine } from "../../Machine.js"
 import * as Configuration from "./configuration.js"
 import { InfiniteTransitionError, MachineSchemaDecodeError, StoppedError } from "./errors.js"
 import * as InvocationEvent from "./invocationEvent.js"
@@ -23,6 +23,7 @@ export interface AnyConfig {
   readonly onDone?: unknown
   readonly onFailure?: unknown
   readonly onSnapshot?: unknown
+  readonly activityKind?: Inspection.Activity["kind"]
 }
 
 /** @internal */
@@ -47,7 +48,7 @@ const resolveOne = (
     return {
       id: String(raw.id),
       src: () =>
-        oneShot(resolveValue(raw.effect, context) as Effect.Effect<any, any, any>) as unknown as Runtime.ProcessLogic<
+        oneShot(raw.effect(context) as Effect.Effect<any, any, any>) as unknown as Runtime.ProcessLogic<
           any,
           any,
           any,
@@ -57,7 +58,8 @@ const resolveOne = (
         >,
       onDone: raw.onDone,
       onFailure: raw.onFailure,
-      onSnapshot: raw.onSnapshot
+      onSnapshot: raw.onSnapshot,
+      activityKind: "Effect"
     }
   }
   if ("after" in raw) {
@@ -72,7 +74,8 @@ const resolveOne = (
           any,
           any
         >,
-      onDone: raw.onDone
+      onDone: raw.onDone,
+      activityKind: "Timer"
     }
   }
   if ("logic" in raw) {
@@ -115,8 +118,18 @@ const runSequentialDiscard = <E, R>(
 
 const sendLifecycle = (
   scope: Runtime.ProcessScope<any>,
-  event: InvocationEvent.InvocationEvent
-): Effect.Effect<void> => scope.self.send(event).pipe(Effect.catchTag("StoppedError", () => Effect.void))
+  event: InvocationEvent.InvocationEvent,
+  activitySessionId?: string
+): Effect.Effect<void> =>
+  (activitySessionId === undefined
+    ? scope.self.send(event)
+    : scope.self.sendInspected === undefined
+    ? scope.self.send(event)
+    : scope.self.sendInspected(
+      event,
+      scope.self.inspectionSubject,
+      { _tag: "Activity", activitySessionId }
+    )).pipe(Effect.catchTag("StoppedError", () => Effect.void))
 
 const isFrameworkFailure = (error: unknown): boolean =>
   error instanceof InfiniteTransitionError || error instanceof MachineSchemaDecodeError || error instanceof StoppedError
@@ -131,7 +144,8 @@ const startResolved = (
   src: () => Runtime.ProcessLogic<any, any, any, any, any, any>,
   onDone: unknown,
   onFailure: unknown,
-  onSnapshot: unknown
+  onSnapshot: unknown,
+  activityKind?: Inspection.Activity["kind"]
 ): Effect.Effect<void, any, any> =>
   Effect.suspend(() => {
     const key = makeKey(path, invokeId)
@@ -141,8 +155,9 @@ const startResolved = (
       id: childId,
       duplicateId: invokeId,
       ...(descriptor === undefined ? undefined : { descriptor }),
+      ...(activityKind === undefined ? undefined : { activityKind }),
       sendParent: (isCurrent, event) => isCurrent() ? scope.self.send(event) : Effect.void,
-      onOutcome: (isCurrent, outcome) => {
+      onOutcome: (isCurrent, outcome, activitySessionId) => {
         if (outcome._tag === "Stopped" || !isCurrent()) return Effect.void
         if (outcome._tag === "Done") {
           if (onDone === undefined) {
@@ -152,14 +167,22 @@ const startResolved = (
               )
             ))
           }
-          return sendLifecycle(scope, InvocationEvent.done(path, invokeId, outcome.output))
+          return sendLifecycle(
+            scope,
+            InvocationEvent.done(path, invokeId, outcome.output),
+            activityKind === undefined ? undefined : activitySessionId
+          )
         }
         if (
           outcome._tag === "Failure" &&
           onFailure !== undefined &&
           (descriptor === undefined || !isFrameworkFailure(outcome.error))
         ) {
-          return sendLifecycle(scope, InvocationEvent.failure(path, invokeId, outcome.error))
+          return sendLifecycle(
+            scope,
+            InvocationEvent.failure(path, invokeId, outcome.error),
+            activityKind === undefined ? undefined : activitySessionId
+          )
         }
         return scope.failCause(outcome.cause)
       },
@@ -189,7 +212,8 @@ const start = (
     config.src,
     config.onDone,
     config.onFailure,
-    config.onSnapshot
+    config.onSnapshot,
+    config.activityKind
   )
 }
 
@@ -213,7 +237,8 @@ const startStaticChild = (
     descriptor[ChildMachineLogicTypeId],
     raw.onDone,
     raw.onFailure,
-    raw.onSnapshot
+    raw.onSnapshot,
+    undefined
   )
 }
 
@@ -235,7 +260,7 @@ export const startAll = (
     .filter((path) => configuration.active.has(path))
     .flatMap((path) => {
       const context = {
-        ...(Configuration.getActorScope(configuration) ?? { self: scope.self, parent: scope.parent }),
+        ...(Configuration.getMachineReferences(configuration) ?? { self: scope.self, parent: scope.parent }),
         state: configuration.values.get(path),
         containingState: Configuration.getParentValue(machine, configuration, path),
         ancestors: Configuration.getParentValues(machine, configuration, path),

package/src/internal/machine/machine.ts

@@ -33,7 +33,7 @@ import type { EnsureExecutable } from "./readiness.js"
 import * as internalRuntime from "./runtime.js"
 import * as Serialization from "./serialization.js"
 import * as StateDefinition from "./stateDefinition.js"
-import { ChildMachineLogicTypeId } from "./symbols.js"
+import { ChildMachineLogicTypeId, SnapshotBuilderStateTypeId } from "./symbols.js"
 import * as Topology from "./topology.js"
 
 export {
@@ -45,10 +45,9 @@ export {
   StartupError,
   StoppedError
 } from "./errors.js"
-export { ChildMachineLogicTypeId, InitialEventTypeId } from "./symbols.js"
+export { ChildMachineLogicTypeId, InitialEventTypeId, SnapshotBuilderStateTypeId } from "./symbols.js"
 
 const TypeId = "~effect/Machine"
-export const SnapshotBuilderStateTypeId: unique symbol = Symbol("effect/Machine/SnapshotBuilderState")
 export const InvokeTypeId: unique symbol = Symbol.for("effect/Machine/Invoke")
 const ChildMachineTypeId = "~effect/Machine/ChildMachine"
 type IsAny<A> = 0 extends 1 & A ? true : false
@@ -300,6 +299,24 @@ const withFrom = <Method extends (value: unknown, ...args: ReadonlyArray<any>) =
   return method as 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: initial,
+    enumerable: false
+  })
+  return builder
+}
+
 const makeSnapshotBuilder = (
   states: Machine.StateTree,
   options: SnapshotBuilderOptions
@@ -317,12 +334,15 @@ const makeSnapshotBuilder = (
       continue
     }
     const node = Topology.getStateNodeDefinition(path, definition)
-    builder[key] = withFrom(
+    const method = withFrom(
       (value: unknown, selector?: (builder: unknown) => unknown) =>
         makeSnapshotForNode(definition, key, value, selector, options),
       node.states === undefined ? "leaf" : "nested",
       node.schema !== undefined
     )
+    builder[key] = node.states === undefined || options.mode !== "full" || options.prefix !== ""
+      ? method
+      : withInitial(method, path, node.schema !== undefined)
   }
   return builder
 }
@@ -348,7 +368,7 @@ const makeParallelSnapshotBuilder = (
     }
     const path = options.prefix === "" ? key : `${options.prefix}.${key}`
     const node = Topology.getStateNodeDefinition(path, definition)
-    builder[key] = withFrom(
+    const method = withFrom(
       (value: unknown, selector?: (builder: unknown) => unknown) => {
         const nextRegions: Record<string, unknown> = {}
         for (const regionKey of Object.keys(regions)) {
@@ -360,6 +380,7 @@ const makeParallelSnapshotBuilder = (
       node.states === undefined ? "leaf" : "nested",
       node.schema !== undefined
     )
+    builder[key] = method
   }
   return builder
 }
@@ -538,7 +559,7 @@ const makeLocalTargetChildBuilder = (
       builder[child.key] = () => Topology.makeChoiceTarget(child.path, parent.path, values)
       continue
     }
-    builder[child.key] = withFrom(
+    const method = withFrom(
       (value: unknown, selector?: (builder: unknown) => unknown) => {
         if (child.type === "atomic" || child.type === "final") {
           return makeTargetWithValues(child.path, value, values)
@@ -572,6 +593,9 @@ const makeLocalTargetChildBuilder = (
       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
 }
@@ -677,6 +701,7 @@ const makeBranchTargetNodeBuilder = (
     "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 || source.startsWith(`${node.path}.`)) {
     addBranchTargetChildren(builder, states, stateNodes, node.path, values, source)
   }