@typeonce/effect-machine-devtools 0.23.0 → 0.25.0

package/src/internal/browser/input-form.ts

@@ -0,0 +1,252 @@
+import type { InputSchema } from "../../MachineDocument.js"
+
+type JsonPrimitive = string | number | boolean | null
+
+export type InputField =
+  | {
+    readonly _tag: "String"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly defaultValue: string | undefined
+    readonly format: string | undefined
+    readonly minLength: number | undefined
+    readonly maxLength: number | undefined
+    readonly pattern: string | undefined
+  }
+  | {
+    readonly _tag: "Number"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly defaultValue: number | undefined
+    readonly integer: boolean
+    readonly minimum: number | undefined
+    readonly maximum: number | undefined
+  }
+  | {
+    readonly _tag: "Boolean"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly defaultValue: boolean | undefined
+  }
+  | {
+    readonly _tag: "Enum"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly values: ReadonlyArray<JsonPrimitive>
+    readonly defaultValue: JsonPrimitive | undefined
+  }
+  | {
+    readonly _tag: "Literal"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly value: JsonPrimitive
+  }
+  | {
+    readonly _tag: "Object"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly fields: ReadonlyArray<{
+      readonly key: string
+      readonly required: boolean
+      readonly field: InputField
+    }>
+  }
+  | {
+    readonly _tag: "Array"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly item: InputField
+    readonly minItems: number
+    readonly maxItems: number | undefined
+  }
+  | {
+    readonly _tag: "Union"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly alternatives: ReadonlyArray<InputField>
+  }
+  | {
+    readonly _tag: "Unsupported"
+    readonly title: string | undefined
+    readonly description: string | undefined
+    readonly reason: string
+  }
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const stringValue = (value: unknown): string | undefined => typeof value === "string" ? value : undefined
+
+const numberValue = (value: unknown): number | undefined =>
+  typeof value === "number" && Number.isFinite(value) ? value : undefined
+
+const primitiveValue = (value: unknown): JsonPrimitive | undefined =>
+  value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+    ? value
+    : undefined
+
+const resolveReference = (
+  value: unknown,
+  definitions: Readonly<Record<string, unknown>>,
+  seen: ReadonlySet<string> = new Set()
+): unknown => {
+  if (!isRecord(value) || typeof value.$ref !== "string" || !value.$ref.startsWith("#/$defs/")) return value
+  const name = decodeURIComponent(value.$ref.slice("#/$defs/".length))
+  if (seen.has(name)) return undefined
+  const next = definitions[name]
+  return resolveReference(next, definitions, new Set([...seen, name]))
+}
+
+const annotations = (schema: Record<string, unknown>) => ({
+  title: stringValue(schema.title),
+  description: stringValue(schema.description)
+})
+
+const mergeAllOf = (
+  schema: Record<string, unknown>,
+  definitions: Readonly<Record<string, unknown>>
+): Record<string, unknown> => {
+  if (!Array.isArray(schema.allOf)) return schema
+  const { allOf, ...base } = schema
+  return Object.assign(
+    base,
+    ...allOf
+      .map((part) => resolveReference(part, definitions))
+      .filter(isRecord)
+      .map((part) => mergeAllOf(part, definitions))
+  )
+}
+
+const effectNumberAlternative = (
+  alternatives: ReadonlyArray<unknown>,
+  definitions: Readonly<Record<string, unknown>>
+): Record<string, unknown> | undefined => {
+  if (alternatives.length !== 2) return undefined
+  const resolved = alternatives.map((alternative) => resolveReference(alternative, definitions))
+  const number = resolved.find((alternative) => isRecord(alternative) && alternative.type === "number")
+  const encodedNonFinite = resolved.find((alternative) => {
+    if (!isRecord(alternative) || alternative.type !== "string" || !Array.isArray(alternative.enum)) return false
+    const enumValues: ReadonlyArray<unknown> = alternative.enum
+    return enumValues.length === 3 &&
+      ["Infinity", "-Infinity", "NaN"].every((value) => enumValues.includes(value))
+  })
+  return isRecord(number) && encodedNonFinite !== undefined ? number : undefined
+}
+
+const project = (
+  value: unknown,
+  definitions: Readonly<Record<string, unknown>>
+): InputField => {
+  const referenced = resolveReference(value, definitions)
+  if (!isRecord(referenced)) {
+    return {
+      _tag: "Unsupported",
+      title: undefined,
+      description: undefined,
+      reason: "This input schema cannot be represented as fields."
+    }
+  }
+  const resolved = mergeAllOf(referenced, definitions)
+  const common = annotations(resolved)
+  const alternatives = Array.isArray(resolved.oneOf)
+    ? resolved.oneOf
+    : Array.isArray(resolved.anyOf)
+    ? resolved.anyOf
+    : undefined
+  if (alternatives !== undefined) {
+    const effectNumber = effectNumberAlternative(alternatives, definitions)
+    if (effectNumber !== undefined) {
+      return {
+        _tag: "Number",
+        ...common,
+        defaultValue: numberValue(resolved.default ?? effectNumber.default),
+        integer: false,
+        minimum: numberValue(resolved.minimum ?? effectNumber.minimum),
+        maximum: numberValue(resolved.maximum ?? effectNumber.maximum)
+      }
+    }
+    return {
+      _tag: "Union",
+      ...common,
+      alternatives: alternatives.map((alternative) => project(alternative, definitions))
+    }
+  }
+  const constant = primitiveValue(resolved.const)
+  if (constant !== undefined || resolved.const === null) {
+    return { _tag: "Literal", ...common, value: constant ?? null }
+  }
+  if (Array.isArray(resolved.enum)) {
+    const values = resolved.enum.map(primitiveValue).filter((item): item is JsonPrimitive => item !== undefined)
+    if (values.length > 0) {
+      return {
+        _tag: "Enum",
+        ...common,
+        values,
+        defaultValue: primitiveValue(resolved.default)
+      }
+    }
+  }
+  switch (resolved.type) {
+    case "string":
+      return {
+        _tag: "String",
+        ...common,
+        defaultValue: stringValue(resolved.default),
+        format: stringValue(resolved.format),
+        minLength: numberValue(resolved.minLength),
+        maxLength: numberValue(resolved.maxLength),
+        pattern: stringValue(resolved.pattern)
+      }
+    case "integer":
+    case "number":
+      return {
+        _tag: "Number",
+        ...common,
+        defaultValue: numberValue(resolved.default),
+        integer: resolved.type === "integer",
+        minimum: numberValue(resolved.minimum),
+        maximum: numberValue(resolved.maximum)
+      }
+    case "boolean":
+      return {
+        _tag: "Boolean",
+        ...common,
+        defaultValue: typeof resolved.default === "boolean" ? resolved.default : undefined
+      }
+    case "null":
+      return { _tag: "Literal", ...common, value: null }
+    case "object": {
+      if (!isRecord(resolved.properties)) return { _tag: "Object", ...common, fields: [] }
+      const required = new Set(
+        Array.isArray(resolved.required)
+          ? resolved.required.filter((item): item is string => typeof item === "string")
+          : []
+      )
+      return {
+        _tag: "Object",
+        ...common,
+        fields: Object.entries(resolved.properties).map(([key, child]) => ({
+          key,
+          required: required.has(key),
+          field: project(child, definitions)
+        }))
+      }
+    }
+    case "array":
+      return {
+        _tag: "Array",
+        ...common,
+        item: project(resolved.items, definitions),
+        minItems: numberValue(resolved.minItems) ?? 0,
+        maxItems: numberValue(resolved.maxItems)
+      }
+    default:
+      return {
+        _tag: "Unsupported",
+        ...common,
+        reason: "This input schema has no concrete JSON shape to render."
+      }
+  }
+}
+
+export const projectInputSchema = (document: InputSchema): InputField => project(document.schema, document.definitions)

package/src/internal/browser/invoke-outcomes-example.ts

@@ -0,0 +1,231 @@
+import { Machine } from "@typeonce/effect-machine"
+import { Effect, Schema, Stream } from "effect"
+
+class ChildWorking extends Schema.TaggedClass<ChildWorking>("InvokeGalleryChildWorking")("Working", {
+  task: Schema.String
+}) {}
+class ChildDone extends Schema.TaggedClass<ChildDone>("InvokeGalleryChildDone")("Done", {
+  result: Schema.String
+}) {}
+class FinishChild extends Schema.TaggedClass<FinishChild>("InvokeGalleryFinishChild")("FinishChild", {}) {}
+
+const ChildStates = Machine.states({
+  Working: ChildWorking,
+  Done: { schema: ChildDone, type: "final", output: Schema.String }
+})
+
+export const invokeGalleryChildMachine = Machine.make({
+  id: "invoke-gallery-child",
+  states: ChildStates.states,
+  events: Machine.events(FinishChild),
+  initial: (to) => to.Working().resolve(({ target }) => target.decoded(new ChildWorking({ task: "render-preview" })))
+}).handle({
+  Working: {
+    on: {
+      FinishChild: (to) =>
+        to.full.Done().resolve(({ state, target }) =>
+          target.decoded(new ChildDone({ result: `${state.task}:complete` }))
+        )
+    }
+  },
+  Done: {
+    output: ({ state }) => state.result
+  }
+})
+
+const InvokedChild = Machine.child("preview-worker", invokeGalleryChildMachine)
+
+class Gallery extends Schema.TaggedClass<Gallery>("InvokeGallery")("Gallery", {
+  selectedDemo: Schema.NullOr(Schema.String)
+}) {}
+class Choose extends Schema.TaggedClass<Choose>("InvokeGalleryChoose")("Choose", {}) {}
+class LoadingDocument extends Schema.TaggedClass<LoadingDocument>("InvokeGalleryLoadingDocument")(
+  "LoadingDocument",
+  { request: Schema.String }
+) {}
+class StreamingUpdates extends Schema.TaggedClass<StreamingUpdates>("InvokeGalleryStreamingUpdates")(
+  "StreamingUpdates",
+  { values: Schema.Array(Schema.Number) }
+) {}
+class WaitingForTimeout extends Schema.TaggedClass<WaitingForTimeout>("InvokeGalleryWaitingForTimeout")(
+  "WaitingForTimeout",
+  { delay: Schema.Literal("2 seconds") }
+) {}
+class WatchingProcess extends Schema.TaggedClass<WatchingProcess>("InvokeGalleryWatchingProcess")(
+  "WatchingProcess",
+  { revision: Schema.Number }
+) {}
+class RunningChild extends Schema.TaggedClass<RunningChild>("InvokeGalleryRunningChild")("RunningChild", {}) {}
+class Completed extends Schema.TaggedClass<Completed>("InvokeGalleryCompleted")("Completed", {
+  source: Schema.String,
+  result: Schema.String
+}) {}
+class Failed extends Schema.TaggedClass<Failed>("InvokeGalleryFailed")("Failed", {
+  source: Schema.String,
+  message: Schema.String
+}) {}
+
+class RunEffect extends Schema.TaggedClass<RunEffect>("InvokeGalleryRunEffect")("RunEffect", {
+  request: Schema.String
+}) {}
+class RunStream extends Schema.TaggedClass<RunStream>("InvokeGalleryRunStream")("RunStream", {}) {}
+class RunTimer extends Schema.TaggedClass<RunTimer>("InvokeGalleryRunTimer")("RunTimer", {}) {}
+class RunProcess extends Schema.TaggedClass<RunProcess>("InvokeGalleryRunProcess")("RunProcess", {}) {}
+class RunChild extends Schema.TaggedClass<RunChild>("InvokeGalleryRunChild")("RunChild", {}) {}
+class Reset extends Schema.TaggedClass<Reset>("InvokeGalleryReset")("Reset", {}) {}
+class StreamValue extends Schema.TaggedClass<StreamValue>("InvokeGalleryStreamValue")("StreamValue", {
+  value: Schema.Number
+}) {}
+
+const GalleryEvents = Machine.events(RunEffect, RunStream, RunTimer, RunProcess, RunChild, Reset)
+const GalleryInternalEvents = Machine.internalEvents(StreamValue)
+const processLogic = Machine.logic({
+  initial: "starting" as "starting" | "ready",
+  run: () => Effect.fail("process stopped")
+})
+
+const GalleryStates = Machine.states({
+  Gallery: {
+    schema: Gallery,
+    initial: "Choose",
+    states: {
+      Choose,
+      LoadingDocument,
+      StreamingUpdates,
+      WaitingForTimeout,
+      WatchingProcess,
+      RunningChild
+    }
+  },
+  Completed,
+  Failed
+})
+
+export const invokeOutcomesMachine = Machine.make({
+  id: "invoke-outcomes",
+  states: GalleryStates.states,
+  events: GalleryEvents,
+  internalEvents: GalleryInternalEvents,
+  initial: (to) =>
+    to.Gallery.initial.resolve(({ target }) =>
+      target.decoded(
+        new Gallery({ selectedDemo: null }),
+        (gallery) => gallery.Choose.decoded(new Choose({}))
+      )
+    )
+}).handle({
+  Gallery: {
+    initialize: ({ builder }) => builder.decoded(new Choose({})),
+    on: {
+      Reset: (to) => to.local.Choose().resolve(({ target }) => target.decoded(new Choose({})))
+    },
+    states: {
+      Choose: {
+        on: {
+          RunEffect: (to) =>
+            to.local.LoadingDocument().resolve(({ event, target }) =>
+              target.decoded(new LoadingDocument({ request: event.request }))
+            ),
+          RunStream: (to) =>
+            to.local.StreamingUpdates().resolve(({ target }) => target.decoded(new StreamingUpdates({ values: [] }))),
+          RunTimer: (to) =>
+            to.local.WaitingForTimeout().resolve(({ target }) =>
+              target.decoded(new WaitingForTimeout({ delay: "2 seconds" }))
+            ),
+          RunProcess: (to) =>
+            to.local.WatchingProcess().resolve(({ target }) => target.decoded(new WatchingProcess({ revision: 1 }))),
+          RunChild: (to) => to.local.RunningChild().resolve(({ target }) => target.decoded(new RunningChild({})))
+        }
+      },
+      LoadingDocument: {
+        invoke: (from) =>
+          from.effect(
+            "load-document",
+            ({ state }) =>
+              state.request === "fail" ? Effect.fail("document unavailable") : Effect.succeed("document loaded")
+          ).onDone((to) =>
+            to.full.Completed().resolve(({ output, target }) =>
+              target.decoded(new Completed({ source: "effect", result: output }))
+            )
+          ).onFailure((to) =>
+            to.full.Failed().resolve(({ error, target }) =>
+              target.decoded(new Failed({ source: "effect", message: error }))
+            )
+          )
+      },
+      StreamingUpdates: {
+        invoke: (from) =>
+          from.stream(
+            "document-updates",
+            () => Stream.fromIterable([1, 2, 3]).pipe(Stream.concat(Stream.fail("stream disconnected")))
+          ).onElement((to) =>
+            to.none.resolve(({ element }, enqueue) => {
+              enqueue.raise(GalleryInternalEvents.StreamValue({ value: element }))
+            })
+          ).onDone((to) =>
+            to.full.Completed().resolve(({ state, target }) =>
+              target.decoded(new Completed({ source: "stream", result: state.values.join(", ") }))
+            )
+          ).onFailure((to) =>
+            to.full.Failed().resolve(({ error, target }) =>
+              target.decoded(new Failed({ source: "stream", message: error }))
+            )
+          ),
+        on: {
+          StreamValue: (to) =>
+            to.local.StreamingUpdates().resolve(({ event, state, target }) =>
+              target.decoded(new StreamingUpdates({ values: [...state.values, event.value] }))
+            )
+        }
+      },
+      WaitingForTimeout: {
+        invoke: (from) =>
+          from.timer("request-timeout", "2 seconds").onDone((to) =>
+            to.full.Completed().resolve(({ target }) =>
+              target.decoded(new Completed({ source: "timer", result: "timeout elapsed" }))
+            )
+          )
+      },
+      WatchingProcess: {
+        invoke: (from) =>
+          from.logic("status-worker", {
+            address: Machine.childAddress("status-worker"),
+            logic: processLogic
+          }).onFailure((to) =>
+            to.full.Failed().resolve(({ error, target }) =>
+              target.decoded(new Failed({ source: "process", message: String(error) }))
+            )
+          ).onSnapshot((to) =>
+            to.branches({
+              ready: { title: "Worker reports ready", target: to.full.Completed() },
+              waiting: { title: "Worker is still starting", target: to.none }
+            }).resolve(({ select, snapshot }) =>
+              snapshot.state === "ready"
+                ? select.ready.decoded(new Completed({ source: "process", result: "ready" }))
+                : select.waiting()
+            )
+          )
+      },
+      RunningChild: {
+        invoke: (from) =>
+          from.child(InvokedChild).onDone((to) =>
+            to.full.Completed().resolve(({ output, target }) =>
+              target.decoded(new Completed({ source: "child machine", result: output }))
+            )
+          )
+      }
+    }
+  },
+  Completed: {
+    on: {
+      Reset: (to) =>
+        to.full.Gallery.initial.resolve(({ target }) => target.decoded(new Gallery({ selectedDemo: null })))
+    }
+  },
+  Failed: {
+    on: {
+      Reset: (to) =>
+        to.full.Gallery.initial.resolve(({ target }) => target.decoded(new Gallery({ selectedDemo: null })))
+    }
+  }
+})

package/src/internal/browser/parallel-completion-example.ts

@@ -0,0 +1,199 @@
+import { Machine } from "@typeonce/effect-machine"
+import { Schema } from "effect"
+
+class Cart extends Schema.TaggedClass<Cart>("ParallelCart")("Cart", {
+  items: Schema.Number
+}) {}
+class Order extends Schema.TaggedClass<Order>("ParallelOrder")("Order", {
+  orderId: Schema.String,
+  total: Schema.Number
+}) {}
+class Payment extends Schema.TaggedClass<Payment>("ParallelPayment")("Payment", {
+  attempts: Schema.Number
+}) {}
+class AwaitingAuthorization extends Schema.TaggedClass<AwaitingAuthorization>("ParallelAwaitingAuthorization")(
+  "AwaitingAuthorization",
+  {}
+) {}
+class Authorized extends Schema.TaggedClass<Authorized>("ParallelAuthorized")("Authorized", {
+  authorizationId: Schema.String
+}) {}
+class Fulfillment extends Schema.TaggedClass<Fulfillment>("ParallelFulfillment")("Fulfillment", {
+  warehouse: Schema.String
+}) {}
+class WaitingForPayment extends Schema.TaggedClass<WaitingForPayment>("ParallelWaitingForPayment")(
+  "WaitingForPayment",
+  {}
+) {}
+class Packing extends Schema.TaggedClass<Packing>("ParallelPacking")("Packing", {
+  packageCount: Schema.Number
+}) {}
+class Shipped extends Schema.TaggedClass<Shipped>("ParallelShipped")("Shipped", {
+  trackingCode: Schema.String
+}) {}
+class OrderComplete extends Schema.TaggedClass<OrderComplete>("ParallelOrderComplete")("OrderComplete", {
+  orderId: Schema.String
+}) {}
+class OrderCancelled extends Schema.TaggedClass<OrderCancelled>("ParallelOrderCancelled")(
+  "OrderCancelled",
+  { reason: Schema.String }
+) {}
+
+class Checkout extends Schema.TaggedClass<Checkout>("ParallelCheckout")("Checkout", {
+  orderId: Schema.String,
+  total: Schema.Number
+}) {}
+class Authorize extends Schema.TaggedClass<Authorize>("ParallelAuthorize")("Authorize", {
+  authorizationId: Schema.String
+}) {}
+class DeclinePayment extends Schema.TaggedClass<DeclinePayment>("ParallelDeclinePayment")(
+  "DeclinePayment",
+  { reason: Schema.String }
+) {}
+class Pack extends Schema.TaggedClass<Pack>("ParallelPack")("Pack", { packages: Schema.Number }) {}
+class Ship extends Schema.TaggedClass<Ship>("ParallelShip")("Ship", { trackingCode: Schema.String }) {}
+class CompleteAll extends Schema.TaggedClass<CompleteAll>("ParallelCompleteAll")("CompleteAll", {
+  authorizationId: Schema.String,
+  trackingCode: Schema.String
+}) {}
+class CancelOrder extends Schema.TaggedClass<CancelOrder>("ParallelCancelOrder")("CancelOrder", {
+  reason: Schema.String
+}) {}
+class RetryOrder extends Schema.TaggedClass<RetryOrder>("ParallelRetryOrder")("RetryOrder", {}) {}
+class AutoShip extends Schema.TaggedClass<AutoShip>("ParallelAutoShip")("AutoShip", {}) {}
+
+const ParallelInternalEvents = Machine.internalEvents(AutoShip)
+const ParallelStates = Machine.states({
+  Cart,
+  Order: {
+    schema: Order,
+    type: "parallel",
+    states: {
+      payment: {
+        schema: Payment,
+        initial: "AwaitingAuthorization",
+        states: {
+          AwaitingAuthorization,
+          Authorized: { schema: Authorized, type: "final" }
+        }
+      },
+      fulfillment: {
+        schema: Fulfillment,
+        initial: "WaitingForPayment",
+        states: {
+          WaitingForPayment,
+          Packing,
+          Shipped: { schema: Shipped, type: "final" }
+        }
+      }
+    }
+  },
+  Complete: { schema: OrderComplete, type: "final", output: Schema.String },
+  Cancelled: OrderCancelled
+})
+
+export const parallelCompletionMachine = Machine.make({
+  id: "parallel-completion",
+  states: ParallelStates.states,
+  events: Machine.events(
+    Checkout,
+    Authorize,
+    DeclinePayment,
+    Pack,
+    Ship,
+    CompleteAll,
+    CancelOrder,
+    RetryOrder
+  ),
+  internalEvents: ParallelInternalEvents,
+  initial: (to) => to.Cart().resolve(({ target }) => target.decoded(new Cart({ items: 2 })))
+}).handle({
+  Cart: {
+    on: {
+      Checkout: (to) =>
+        to.full.Order.initial.resolve(({ event, target }) =>
+          target.decoded(new Order({ orderId: event.orderId, total: event.total }))
+        )
+    }
+  },
+  Order: {
+    initialize: ({ builder }) => builder.payment.from({ attempts: 0 }).fulfillment.from({ warehouse: "north" }),
+    on: {
+      CancelOrder: (to) =>
+        to.full.Cancelled().resolve(({ event, target }) => target.decoded(new OrderCancelled({ reason: event.reason })))
+    },
+    onDone: (to) =>
+      to.full.Complete().resolve(({ target }) => target.decoded(new OrderComplete({ orderId: "completed-order" }))),
+    states: {
+      payment: {
+        initialize: ({ builder }) => builder.from(),
+        states: {
+          AwaitingAuthorization: {
+            on: {
+              Authorize: (to) =>
+                to.local.Authorized().resolve(({ event, target }) =>
+                  target.decoded(new Authorized({ authorizationId: event.authorizationId }))
+                ),
+              CompleteAll: (to) =>
+                to.local.Authorized().resolve(({ event, target }) =>
+                  target.decoded(new Authorized({ authorizationId: event.authorizationId }))
+                ),
+              DeclinePayment: (to) =>
+                to.full.Cancelled().resolve(({ event, target }) =>
+                  target.decoded(new OrderCancelled({ reason: event.reason }))
+                )
+            }
+          }
+        }
+      },
+      fulfillment: {
+        initialize: ({ builder }) => builder.from(),
+        states: {
+          WaitingForPayment: {
+            on: {
+              Authorize: (to) =>
+                to.local.Packing().resolve(({ target }) => target.decoded(new Packing({ packageCount: 1 }))),
+              Pack: (to) =>
+                to.local.Packing().resolve(({ event, target }) =>
+                  target.decoded(new Packing({ packageCount: event.packages }))
+                ),
+              CompleteAll: (to) =>
+                to.local.Shipped().resolve(({ event, target }) =>
+                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                )
+            }
+          },
+          Packing: {
+            invoke: (from) =>
+              from.timer("packing-sla", "5 seconds").onDone((to) =>
+                to.none.resolve((_, enqueue) => {
+                  enqueue.raise(ParallelInternalEvents.AutoShip())
+                })
+              ),
+            on: {
+              AutoShip: (to) =>
+                to.local.Shipped().resolve(({ target }) => target.decoded(new Shipped({ trackingCode: "automatic" }))),
+              Ship: (to) =>
+                to.local.Shipped().resolve(({ event, target }) =>
+                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                ),
+              CompleteAll: (to) =>
+                to.local.Shipped().resolve(({ event, target }) =>
+                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                )
+            }
+          }
+        }
+      }
+    }
+  },
+  Complete: {
+    output: ({ state }) => state.orderId
+  },
+  Cancelled: {
+    on: {
+      RetryOrder: (to) =>
+        to.full.Order.initial.resolve(({ target }) => target.decoded(new Order({ orderId: "retry", total: 0 })))
+    }
+  }
+})