@typeonce/effect-machine 0.31.2 → 0.32.0

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

@@ -0,0 +1,120 @@
+import type { Machine } from "../../../Machine.js"
+import type { InitialTrace, Microstep, RunFailure, Trace, TraceStep } from "../../../testing/MachineTest.js"
+type AnyMachine = Machine.Any
+
+const canonicalize = (value: unknown, active: WeakSet<object>): unknown => {
+  if (typeof value === "number" && (!Number.isFinite(value) || Object.is(value, -0))) {
+    return { $number: Object.is(value, -0) ? "-0" : String(value) }
+  }
+  if (value === undefined) return { $undefined: true }
+  if (typeof value === "bigint") return { $bigint: String(value) }
+  if (typeof value === "symbol") return { $symbol: String(value) }
+  if (typeof value === "function") return { $function: value.name || "anonymous" }
+  if (typeof value !== "object" || value === null) return value
+  if (active.has(value)) return { $circular: true }
+  active.add(value)
+  let result: unknown
+  if (value instanceof Error) {
+    result = {
+      $error: value.name,
+      message: value.message,
+      ...Object.fromEntries(
+        Object.keys(value).sort().map((
+          key
+        ) => [key, canonicalize((value as unknown as Record<string, unknown>)[key], active)])
+      )
+    }
+  } else if (Array.isArray(value)) {
+    result = value.map((item) => canonicalize(item, active))
+  } else if (value instanceof RegExp) {
+    result = { $regexp: value.source, flags: value.flags, lastIndex: value.lastIndex }
+  } else if (value instanceof Date) {
+    result = { $date: Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString() }
+  } else if (value instanceof Map) {
+    result = {
+      $map: Array.from(value, ([key, item]) => [canonicalize(key, active), canonicalize(item, active)]).sort((a, b) =>
+        JSON.stringify(a).localeCompare(JSON.stringify(b))
+      )
+    }
+  } else if (value instanceof Set) {
+    result = {
+      $set: Array.from(value, (item) => canonicalize(item, active)).sort((a, b) =>
+        JSON.stringify(a).localeCompare(JSON.stringify(b))
+      )
+    }
+  } else {
+    result = Object.fromEntries(
+      Object.keys(value).sort().map((key) => [key, canonicalize((value as Record<string, unknown>)[key], active)])
+    )
+  }
+  active.delete(value)
+  return result
+}
+
+export const formatValue = (value: unknown): string => JSON.stringify(canonicalize(value, new WeakSet()))
+
+const formatConfiguration = (paths: ReadonlyArray<string>): string =>
+  `[${paths.map((path) => path === "" ? "(root)" : path).join(", ")}]`
+
+const formatMicrosteps = <M extends AnyMachine>(microsteps: ReadonlyArray<Microstep<M, any>>): Array<string> =>
+  microsteps.map((microstep, index) => {
+    const transitions = microstep.transitions.map((transition) => ({
+      source: transition.source,
+      trigger: transition.trigger,
+      reenter: transition.reenter,
+      branchIndex: transition.branchIndex,
+      target: transition.target,
+      resolvedTarget: transition.resolvedTarget
+    }))
+    return `  microstep ${index}: event=${formatValue(microstep.event)} changed=${String(microstep.changed)} ` +
+      `transitions=${formatValue(transitions)} exit=${formatConfiguration(microstep.exitPaths)} ` +
+      `entry=${formatConfiguration(microstep.entryPaths)} commands=${microstep.commands.length} ` +
+      `raised=${formatValue(microstep.raisedEvents)} emitted=${formatValue(microstep.emittedEvents)} ` +
+      `next=${formatValue(microstep.next)}`
+  })
+
+const formatInitial = <M extends AnyMachine>(initial: InitialTrace<M>): Array<string> => [
+  `initial: startingConfiguration=${formatConfiguration(initial.startingConfiguration)} ` +
+  `startingState=${formatValue(initial.startingState)} initialEntry=${
+    formatConfiguration(initial.initialEntryPaths)
+  } ` +
+  `configuration=${formatConfiguration(initial.configuration)} state=${formatValue(initial.plan.state)} ` +
+  `done=${String(initial.plan.done)} output=${formatValue(initial.plan.output)} ` +
+  `commands=${initial.plan.commands.length} emitted=${formatValue(initial.plan.emittedEvents)}`,
+  ...formatMicrosteps(initial.plan.microsteps)
+]
+
+const formatStep = <M extends AnyMachine>(step: TraceStep<M>): Array<string> => [
+  `step ${step.index}: event=${formatValue(step.event)} before=${formatConfiguration(step.beforeConfiguration)} ` +
+  `after=${formatConfiguration(step.afterConfiguration)} state=${formatValue(step.after)} ` +
+  `done=${String(step.plan.done)} output=${formatValue(step.plan.output)} ` +
+  `commands=${step.plan.commands.length} emitted=${formatValue(step.plan.emittedEvents)}`,
+  ...formatMicrosteps(step.plan.microsteps)
+]
+
+const isRunFailure = <M extends AnyMachine, Cause>(
+  trace: Trace<M> | RunFailure<Cause, M>
+): trace is RunFailure<Cause, M> => "_tag" in trace && trace._tag === "MachineTestRunFailure"
+
+export const formatTrace = <M extends AnyMachine, Cause>(trace: Trace<M> | RunFailure<Cause, M>): string => {
+  const lines = [`scenario: ${formatValue(trace.scenario)}`]
+  if (isRunFailure(trace)) {
+    if (trace.initial !== undefined) {
+      lines.push(...formatInitial(trace.initial))
+      for (const step of trace.steps) {
+        lines.push(...formatStep(step))
+      }
+    }
+    lines.push(
+      `failure: phase=${trace.phase} eventIndex=${formatValue(trace.eventIndex)} ` +
+        `event=${formatValue(trace.event)} cause=${formatValue(trace.cause)}`
+    )
+    return lines.join("\n")
+  }
+  lines.push(...formatInitial(trace.initial))
+  for (const step of trace.steps) {
+    lines.push(...formatStep(step))
+  }
+  lines.push(`final: configuration=${formatConfiguration(trace.finalConfiguration)} state=${formatValue(trace.final)}`)
+  return lines.join("\n")
+}

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

@@ -27,14 +27,14 @@ export const probe = <M extends AnyMachine, Error, Output>(
   machine: M,
   ref: Machine.MachineRef<
     Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-    Machine.Machine.InputEvent<M>,
+    Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
     Error,
     Output
   >
 ): Effect.Effect<Probe<M, Error, Output>, ProbeUnavailableError> => {
   const acknowledged = (ref as Runtime.MachineRef<
     Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-    Machine.Machine.InputEvent<M>,
+    Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
     Error,
     Output
   >)[Runtime.acknowledgedSend]
@@ -61,12 +61,12 @@ export const probe = <M extends AnyMachine, Error, Output>(
         ) => boolean
       ) => ({ _tag: "Until", predicate } as const)
     }),
-    sendAndAwait: (event: Machine.Machine.InputEvent<M>) =>
+    sendAndAwait: (event: Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>) =>
       acknowledged.call(ref, event).pipe(
         Effect.map(({ after, before, plan }) => {
           const eventPlan = plan as ProbePlan<M>
           return Object.freeze({
-            event,
+            event: eventPlan.event,
             before,
             plan: eventPlan,
             after,

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

@@ -573,10 +573,7 @@ const runtimeTargetPath = (index: ModelIndex, transition: FiniteTransition): str
   if (target.node._tag === "Choice") {
     return runtimeTargetPath(index, { ...transition, target: resolveChoicePath(index, target.path) })
   }
-  // A same-root branch builder identifies the concrete initialized leaf. A
-  // full builder replaces the root with a complete snapshot and identifies
-  // that snapshot's root even when it contains initialized descendants.
-  if (source.root !== target.root) return target.path
+  // Branch builders preserve the deepest concrete selection within their declared bound.
 
   const initial = (path: string): string => {
     const current = getState(index, path)
@@ -603,7 +600,7 @@ const runtimeTargetPath = (index: ModelIndex, transition: FiniteTransition): str
     const next = target.path.slice(current.path.length + 1).split(".")[0]!
     return inspect(`${current.path}.${next}`)
   }
-  return inspect(source.root)
+  return inspect(source.root === target.root ? source.root : target.root)
 }
 
 const entryChoicePath = (index: ModelIndex, path: string): string | undefined => {
@@ -916,8 +913,6 @@ const transitionRecord = (index: ModelIndex, transition: FiniteTransition): Refe
     ? transition.target
     : transition.target === undefined
     ? runtimeTargetPath(index, transition)
-    : getState(index, transition.source).root !== getState(index, transition.target).root
-    ? transition.target
     : entryChoicePath(index, transition.target) ?? runtimeTargetPath(index, transition),
   resolvedTarget: transition.target === undefined
     ? runtimeTargetPath(index, transition)
@@ -1269,7 +1264,7 @@ const projectState = (snapshot: unknown): ActualStateProjection => {
   const values: Record<string, unknown> = {}
   const visit = (current: unknown): void => {
     if (!isRecord(current)) return
-    if (typeof current.path === "string") {
+    if (typeof current.path === "string" && current.path !== "") {
       activePaths.push(current.path)
       values[current.path] = current.value
     }
@@ -1282,7 +1277,9 @@ const projectState = (snapshot: unknown): ActualStateProjection => {
   return {
     activePaths,
     values,
-    completions: isRecord(snapshot) && Array.isArray(snapshot.completed) ? snapshot.completed : [],
+    completions: isRecord(snapshot) && Array.isArray(snapshot.completed)
+      ? snapshot.completed.filter((completion) => !isRecord(completion) || completion.path !== "")
+      : [],
     history: isRecord(snapshot) && isRecord(snapshot.history) ? snapshot.history : {}
   }
 }
@@ -1402,7 +1399,13 @@ export const verifyModelTrace = (
     add(
       location,
       `${field}.history`,
-      historyOrderIndependent(expected.history),
+      historyOrderIndependent(
+        Object.fromEntries(
+          Object.entries(expected.history).map((
+            [path, record]
+          ) => [path, { ...record, active: ["", ...record.active] }])
+        )
+      ),
       historyOrderIndependent(projected.history)
     )
   }
@@ -1422,26 +1425,26 @@ export const verifyModelTrace = (
   add(
     initialLocation,
     "initial.startingConfiguration",
-    reference.initial.startingState.activePaths,
+    ["", ...reference.initial.startingState.activePaths],
     get(actualInitial, "startingConfiguration")
   )
   add(
     initialLocation,
     "initial.initialEntryPaths",
-    reference.initial.initialEntryPaths,
+    ["", ...reference.initial.initialEntryPaths],
     get(actualInitial, "initialEntryPaths")
   )
   add(
     initialLocation,
     "initial.plan.initialEntryPaths",
-    reference.initial.initialEntryPaths,
+    ["", ...reference.initial.initialEntryPaths],
     get(actualInitialPlan, "initialEntryPaths")
   )
   compareState(initialLocation, "initial.plan.state", reference.initial.state, get(actualInitialPlan, "state"))
   add(
     initialLocation,
     "initial.configuration",
-    reference.initial.state.activePaths,
+    ["", ...reference.initial.state.activePaths],
     get(actualInitial, "configuration")
   )
   add(
@@ -1463,7 +1466,7 @@ export const verifyModelTrace = (
     add(location, "step.index", expected.index, get(actual, "index"))
     add(location, "step.event", expected.event, eventTag(get(actual, "event")))
     compareState(location, "step.before", expected.before, get(actual, "before"))
-    add(location, "step.beforeConfiguration", expected.before.activePaths, get(actual, "beforeConfiguration"))
+    add(location, "step.beforeConfiguration", ["", ...expected.before.activePaths], get(actual, "beforeConfiguration"))
 
     const actualMicrosteps = array(get(actualPlan, "microsteps"))
     add(location, "step.plan.microsteps.length", expected.microsteps.length, actualMicrosteps.length)
@@ -1490,14 +1493,19 @@ export const verifyModelTrace = (
 
     compareState(location, "step.plan.next", expected.after, get(actualPlan, "next"))
     compareState(location, "step.after", expected.after, get(actual, "after"))
-    add(location, "step.afterConfiguration", expected.after.activePaths, get(actual, "afterConfiguration"))
+    add(location, "step.afterConfiguration", ["", ...expected.after.activePaths], get(actual, "afterConfiguration"))
     add(location, "step.plan.done", expected.done, get(actualPlan, "done"))
     add(location, "step.plan.output", expected.output, get(actualPlan, "output"))
   }
 
   const finalLocation: ModelVerificationLocation = { phase: "final" }
   compareState(finalLocation, "trace.final", reference.final, get(actualTrace, "final"))
-  add(finalLocation, "trace.finalConfiguration", reference.final.activePaths, get(actualTrace, "finalConfiguration"))
+  add(
+    finalLocation,
+    "trace.finalConfiguration",
+    ["", ...reference.final.activePaths],
+    get(actualTrace, "finalConfiguration")
+  )
 
   return mismatches.length === 0
     ? Effect.void

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

@@ -57,7 +57,7 @@ export const rawConfigurationPaths = <M extends AnyMachine>(
 export const appendTrace = <M extends AnyMachine>(
   machine: ReadyMachine<M>,
   trace: Trace<M>,
-  event: Machine.Machine.InputEvent<M>,
+  event: Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
   scenario: Scenario<M>
 ): Effect.Effect<Trace<M>, RunFailure<RunError<M>, M>, RunServices<M>> => {
   const index = trace.steps.length
@@ -83,13 +83,13 @@ export const appendTrace = <M extends AnyMachine>(
         index,
         before,
         beforeConfiguration,
-        event,
+        event: plan.event,
         plan,
         after: plan.next,
         afterConfiguration: rawConfigurationPaths(machine, plan.next)
       }
       return {
-        scenario,
+        scenario: { ...scenario, events: [...trace.steps.map((step) => step.event), plan.event] },
         initial: trace.initial,
         steps: [...trace.steps, step],
         final: plan.next,
@@ -135,7 +135,7 @@ export const run: <M extends AnyMachine>(
     configuration: rawConfigurationPaths(machine, initial.state)
   }
   let trace: Trace<M> = {
-    scenario,
+    scenario: { ...scenario, events: [] },
     initial: initialTrace,
     steps: [],
     final: initial.state,

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

@@ -0,0 +1,77 @@
+/**
+ * Compares decoded trace data without serializing it or invoking getters.
+ * Collection order and cycles must agree. Decoding may copy a shared value,
+ * so aliases outside the current comparison path do not require identity.
+ * Functions, symbols, and objects with opaque state retain identity semantics.
+ */
+export const sameValue = (left: unknown, right: unknown): boolean => {
+  const leftToRight = new WeakMap<object, object>()
+  const rightToLeft = new WeakMap<object, object>()
+  const compare = (a: unknown, b: unknown): boolean => {
+    if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+      return Object.is(a, b)
+    }
+    const knownRight = leftToRight.get(a)
+    const knownLeft = rightToLeft.get(b)
+    if (knownRight !== undefined || knownLeft !== undefined) return knownRight === b && knownLeft === a
+    leftToRight.set(a, b)
+    rightToLeft.set(b, a)
+    try {
+      if (a === b) return true
+      if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false
+
+      if (a instanceof Date && b instanceof Date && !Object.is(a.getTime(), b.getTime())) return false
+      if (a instanceof RegExp && b instanceof RegExp && (a.source !== b.source || a.flags !== b.flags)) return false
+      if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) {
+        if (!sameBytes(new Uint8Array(a), new Uint8Array(b))) return false
+      } else if (
+        typeof SharedArrayBuffer !== "undefined" && a instanceof SharedArrayBuffer && b instanceof SharedArrayBuffer
+      ) {
+        if (!sameBytes(new Uint8Array(a), new Uint8Array(b))) return false
+      } else if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        if (
+          !sameBytes(
+            new Uint8Array(a.buffer, a.byteOffset, a.byteLength),
+            new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
+          )
+        ) return false
+      } else if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size) return false
+        const entries = Array.from(b)
+        if (
+          !Array.from(a).every(([key, value], index) =>
+            compare(key, entries[index]![0]) && compare(value, entries[index]![1])
+          )
+        ) return false
+      } else if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size) return false
+        const values = Array.from(b)
+        if (!Array.from(a).every((value, index) => compare(value, values[index]))) return false
+      } else if (a instanceof WeakMap || a instanceof WeakSet || a instanceof Promise) {
+        return false
+      }
+
+      const keys = Reflect.ownKeys(a)
+      if (keys.length !== Reflect.ownKeys(b).length) return false
+      if (
+        keys.length === 0 && Object.getPrototypeOf(a) !== null && Object.getPrototypeOf(a) !== Object.prototype &&
+        !(a instanceof Date || a instanceof RegExp || a instanceof Map || a instanceof Set ||
+          a instanceof ArrayBuffer || ArrayBuffer.isView(a)) &&
+        !(typeof SharedArrayBuffer !== "undefined" && a instanceof SharedArrayBuffer)
+      ) return false
+      return keys.every((key) => {
+        const x = Object.getOwnPropertyDescriptor(a, key)!
+        const y = Object.getOwnPropertyDescriptor(b, key)
+        if (y === undefined || x.enumerable !== y.enumerable || ("value" in x) !== ("value" in y)) return false
+        return "value" in x ? compare(x.value, y.value) : x.get === y.get && x.set === y.set
+      })
+    } finally {
+      leftToRight.delete(a)
+      rightToLeft.delete(b)
+    }
+  }
+  return compare(left, right)
+}
+
+const sameBytes = (left: Uint8Array, right: Uint8Array): boolean =>
+  left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index])