@typeonce/effect-machine-devtools 0.24.0 → 0.26.0

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 })))
+    }
+  }
+})

package/src/internal/browser/planner-example.ts

@@ -1,5 +1,6 @@
 import { Machine } from "@typeonce/effect-machine"
 import { Schema } from "effect"
+import * as Effect from "effect/Effect"
 
 class Idle extends Schema.TaggedClass<Idle>("PlannerIdle")("Idle", { owner: Schema.String }) {}
 class Working extends Schema.TaggedClass<Working>("PlannerWorking")("Working", {
@@ -128,6 +129,7 @@ export const plannerMachine = Machine.make({
     }
   },
   Working: {
+    invoke: (from) => from.effect("monitor-job", () => Effect.never),
     on: {
       AutoFinish: (to) =>
         to.full.Finished().resolve(({ state, target }) => target.decoded(new Finished({ job: state.job }))),

package/src/internal/browser/protocol-events-example.ts

@@ -0,0 +1,200 @@
+import { Machine } from "@typeonce/effect-machine"
+import { Schema } from "effect"
+
+class ChildProgress extends Schema.TaggedClass<ChildProgress>("ProtocolChildProgress")("ChildProgress", {
+  percent: Schema.Number
+}) {}
+class ChildFinished extends Schema.TaggedClass<ChildFinished>("ProtocolChildFinished")("ChildFinished", {
+  result: Schema.String
+}) {}
+class ChildProblem extends Schema.TaggedClass<ChildProblem>("ProtocolChildProblem")("ChildProblem", {
+  message: Schema.String
+}) {}
+
+const ParentEvents = Machine.events(ChildProgress, ChildFinished, ChildProblem)
+
+class ChildIdle extends Schema.TaggedClass<ChildIdle>("ProtocolChildIdle")("Idle", {}) {}
+class ChildWorking extends Schema.TaggedClass<ChildWorking>("ProtocolChildWorking")("Working", {
+  job: Schema.String,
+  progress: Schema.Number
+}) {}
+class ChildDone extends Schema.TaggedClass<ChildDone>("ProtocolChildDone")("Done", {
+  result: Schema.String
+}) {}
+class ChildCancelled extends Schema.TaggedClass<ChildCancelled>("ProtocolChildCancelled")("Cancelled", {
+  reason: Schema.String
+}) {}
+
+class BeginChildWork extends Schema.TaggedClass<BeginChildWork>("ProtocolBeginChildWork")("BeginChildWork", {
+  job: Schema.String
+}) {}
+class CancelChildWork extends Schema.TaggedClass<CancelChildWork>("ProtocolCancelChildWork")(
+  "CancelChildWork",
+  { reason: Schema.String }
+) {}
+class Heartbeat extends Schema.TaggedClass<Heartbeat>("ProtocolHeartbeat")("Heartbeat", {
+  percent: Schema.Number
+}) {}
+class CommitChildWork extends Schema.TaggedClass<CommitChildWork>("ProtocolCommitChildWork")(
+  "CommitChildWork",
+  {}
+) {}
+class ChildTrace extends Schema.TaggedClass<ChildTrace>("ProtocolChildTrace")("ChildTrace", {
+  message: Schema.String
+}) {}
+
+const ChildEvents = Machine.events(BeginChildWork, CancelChildWork)
+const ChildInternalEvents = Machine.internalEvents(Heartbeat, CommitChildWork)
+const ChildEmissions = Machine.emittedEvents(ChildTrace)
+const ChildStates = Machine.states({
+  Idle: ChildIdle,
+  Working: ChildWorking,
+  Done: { schema: ChildDone, type: "final", output: Schema.String },
+  Cancelled: { schema: ChildCancelled, type: "final", output: Schema.String }
+})
+
+export const requiredParentChildMachine = Machine.make({
+  id: "required-parent-child",
+  states: ChildStates.states,
+  events: ChildEvents,
+  internalEvents: ChildInternalEvents,
+  emittedEvents: ChildEmissions,
+  parent: Machine.parent(ParentEvents),
+  initial: (to) => to.Idle().resolve(({ target }) => target.decoded(new ChildIdle({})))
+}).handle({
+  Idle: {
+    on: {
+      BeginChildWork: (to) =>
+        to.full.Working().resolve(({ event, target }, enqueue) => {
+          enqueue.raise(ChildInternalEvents.Heartbeat({ percent: 25 }))
+          enqueue.emit(ChildEmissions.ChildTrace({ message: `started ${event.job}` }))
+          return target.decoded(new ChildWorking({ job: event.job, progress: 0 }))
+        })
+    }
+  },
+  Working: {
+    invoke: (from) =>
+      from.effect(
+        "report-progress-to-parent",
+        ({ parent, state }) => parent.send(ParentEvents.ChildProgress({ percent: state.progress }))
+      ).onDone((to) => to.none).onFailure((to) =>
+        to.full.Cancelled().resolve(({ error, target }) =>
+          target.decoded(new ChildCancelled({ reason: String(error) }))
+        )
+      ),
+    on: {
+      Heartbeat: (to) =>
+        to.full.Working().resolve(({ event, state, target }, enqueue) => {
+          enqueue.raise(ChildInternalEvents.CommitChildWork())
+          return target.decoded(new ChildWorking({ job: state.job, progress: event.percent }))
+        }),
+      CommitChildWork: (to) =>
+        to.full.Done().resolve(({ state, target }) =>
+          target.decoded(new ChildDone({ result: `${state.job}:complete` }))
+        ),
+      CancelChildWork: (to) =>
+        to.full.Cancelled().resolve(({ event, target }) => target.decoded(new ChildCancelled({ reason: event.reason })))
+    }
+  },
+  Done: {
+    output: ({ state }) => state.result
+  },
+  Cancelled: {
+    output: ({ state }) => state.reason
+  }
+})
+
+const ProtocolChild = Machine.child("protocol-child", requiredParentChildMachine)
+
+class ParentIdle extends Schema.TaggedClass<ParentIdle>("ProtocolParentIdle")("Idle", {}) {}
+class Supervising extends Schema.TaggedClass<Supervising>("ProtocolSupervising")("Supervising", {
+  latestProgress: Schema.Number
+}) {}
+class ParentComplete extends Schema.TaggedClass<ParentComplete>("ProtocolParentComplete")("Complete", {
+  result: Schema.String
+}) {}
+class ParentFailed extends Schema.TaggedClass<ParentFailed>("ProtocolParentFailed")("Failed", {
+  message: Schema.String
+}) {}
+class LaunchChild extends Schema.TaggedClass<LaunchChild>("ProtocolLaunchChild")("LaunchChild", {}) {}
+class ResetParent extends Schema.TaggedClass<ResetParent>("ProtocolResetParent")("ResetParent", {}) {}
+
+const ParentStates = Machine.states({
+  Idle: ParentIdle,
+  Supervising,
+  Complete: { schema: ParentComplete, type: "final", output: Schema.String },
+  Failed: ParentFailed
+})
+
+export const parentProtocolMachine = Machine.make({
+  id: "parent-child-protocol",
+  states: ParentStates.states,
+  events: Machine.events(LaunchChild, ResetParent, ParentEvents),
+  initial: (to) => to.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+}).handle({
+  Idle: {
+    on: {
+      LaunchChild: (to) =>
+        to.full.Supervising().resolve(({ target }) => target.decoded(new Supervising({ latestProgress: 0 })))
+    }
+  },
+  Supervising: {
+    invoke: (from) =>
+      from.child(ProtocolChild).onDone((to) =>
+        to.full.Complete().resolve(({ output, target }) => target.decoded(new ParentComplete({ result: output })))
+      ).onFailure((to) =>
+        to.full.Failed().resolve(({ error, target }) => target.decoded(new ParentFailed({ message: String(error) })))
+      ),
+    on: {
+      ChildProgress: (to) =>
+        to.full.Supervising().resolve(({ event, target }) =>
+          target.decoded(new Supervising({ latestProgress: event.percent }))
+        ),
+      ChildFinished: (to) =>
+        to.full.Complete().resolve(({ event, target }) => target.decoded(new ParentComplete({ result: event.result }))),
+      ChildProblem: (to) =>
+        to.full.Failed().resolve(({ event, target }) => target.decoded(new ParentFailed({ message: event.message }))),
+      ResetParent: (to) => to.full.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+    }
+  },
+  Complete: {
+    output: ({ state }) => state.result
+  },
+  Failed: {
+    on: {
+      ResetParent: (to) => to.full.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+    }
+  }
+})
+
+class Detached extends Schema.TaggedClass<Detached>("OptionalParentDetached")("Detached", {}) {}
+class Published extends Schema.TaggedClass<Published>("OptionalParentPublished")("Published", {
+  deliveredToParent: Schema.Boolean
+}) {}
+class PublishOutside extends Schema.TaggedClass<PublishOutside>("OptionalParentPublishOutside")(
+  "PublishOutside",
+  { result: Schema.String }
+) {}
+
+const OptionalParentStates = Machine.states({ Detached, Published })
+
+export const optionalParentMachine = Machine.make({
+  id: "optional-parent-protocol",
+  states: OptionalParentStates.states,
+  events: Machine.events(PublishOutside),
+  parent: Machine.optionalParent(ParentEvents),
+  initial: (to) => to.Detached().resolve(({ target }) => target.decoded(new Detached({})))
+}).handle({
+  Detached: {
+    on: {
+      PublishOutside: (to) =>
+        to.full.Published().resolve(({ event, parent, target }, enqueue) => {
+          if (parent !== undefined) {
+            enqueue.sendTo(parent, ParentEvents.ChildFinished({ result: event.result }))
+          }
+          return target.decoded(new Published({ deliveredToParent: parent !== undefined }))
+        })
+    }
+  },
+  Published: {}
+})