@typeonce/effect-machine-devtools 0.31.2 → 0.32.0

package/src/internal/browser/transition-semantics-example.ts

@@ -74,46 +74,53 @@ class Archive extends Schema.TaggedClass<Archive>("TransitionArchive")("Archive"
   reason: Schema.String
 }) {}
 
-const TransitionStates = Machine.states({
-  Workspace: {
-    schema: Workspace,
-    initial: "Routing",
-    states: {
-      Routing: { type: "choice" },
-      Draft,
-      AutoSaving,
-      Review: {
-        schema: Review,
-        initial: "Checking",
-        states: {
-          Checking,
-          ChangesRequested,
-          Approved: { schema: Approved, type: "final" }
-        }
-      },
-      Finished: { schema: WorkspaceFinished, type: "final" },
-      recent: { type: "history" },
-      exact: { type: "history", history: "deep" }
-    }
-  },
-  Paused,
-  Disabled,
-  Published: { schema: Published, type: "final", output: Schema.String }
+const TransitionStates = Machine.state({
+  initial: "Paused",
+  states: {
+    Workspace: {
+      schema: Workspace,
+      initial: "Routing",
+      states: {
+        Routing: { type: "choice" },
+        Draft,
+        AutoSaving,
+        Review: {
+          schema: Review,
+          initial: "Checking",
+          states: {
+            Checking,
+            ChangesRequested,
+            Approved: { schema: Approved, type: "final" }
+          }
+        },
+        Finished: { schema: WorkspaceFinished, type: "final" },
+        recent: { type: "history" },
+        exact: { type: "history", history: "deep" }
+      }
+    },
+    Paused,
+    Disabled,
+    Published: { schema: Published, type: "final", output: Schema.String }
+  }
 })
 
 const defaultWorkspaceSnapshot = () => ({
-  path: "Workspace" as const,
-  value: new Workspace({ revision: 0, preferredRoute: "draft" as const }),
+  path: "" as const,
+  value: undefined,
   state: {
-    path: "Workspace.Draft" as const,
-    value: new Draft({ text: "Recovered draft", autosaves: 0 })
+    path: "Workspace" as const,
+    value: new Workspace({ revision: 0, preferredRoute: "draft" as const }),
+    state: {
+      path: "Workspace.Draft" as const,
+      value: new Draft({ text: "Recovered draft", autosaves: 0 })
+    }
   }
 })
 
 export const transitionSemanticsMachine = Machine.make({
   id: "transition-semantics",
-  states: TransitionStates.states,
-  events: Machine.events(
+  root: TransitionStates,
+  events: Machine.eventsFromSchemas(
     Create,
     Edit,
     Save,
@@ -131,115 +138,120 @@ export const transitionSemanticsMachine = Machine.make({
     BumpWorkspace,
     Archive
   ),
-  initial: (to) => to.Paused().resolve(({ target }) => target.decoded(new Paused({ reason: "not started" })))
+  initialConfiguration: (root) =>
+    root.resolve(({ target }) => target.from((to) => to.Paused.decoded(new Paused({ reason: "not started" }))))
 }).handle({
-  Workspace: {
-    history: {
-      recent: { default: defaultWorkspaceSnapshot },
-      exact: { default: defaultWorkspaceSnapshot }
-    },
-    on: {
-      Pause: (to) =>
-        to.full.Paused().resolve(({ event, target }) => target.decoded(new Paused({ reason: event.reason }))),
-      BumpWorkspace: (to) =>
-        to.branch.Workspace.update(({ current, owner }) =>
-          owner.decoded(
-            new Workspace({
-              revision: current.revision + 1,
-              preferredRoute: current.preferredRoute
-            })
-          )
-        )
-    },
-    onDone: (to) =>
-      to.full.Published().resolve(({ target }) => target.decoded(new Published({ result: "workspace published" }))),
-    states: {
-      Routing: {
-        choice: (to) =>
-          to.branches({
-            draft: { title: "Preferred route is draft", target: to.local.Draft() },
-            review: { title: "Preferred route is review", target: to.local.Review.initial }
-          }).resolve(({ containingState, select }) =>
-            containingState.preferredRoute === "review"
-              ? select.review.decoded(new Review({ requestedBy: "initial route" }))
-              : select.draft.decoded(new Draft({ text: "", autosaves: 0 }))
+  states: {
+    Workspace: {
+      history: {
+        recent: { default: defaultWorkspaceSnapshot },
+        exact: { default: defaultWorkspaceSnapshot }
+      },
+      on: {
+        Pause: (to) =>
+          to.branch.Paused().resolve(({ event, target }) => target.decoded(new Paused({ reason: event.reason }))),
+        BumpWorkspace: (to) =>
+          to.branch.Workspace.update.resolve(({ current, owner }) =>
+            owner.decoded(
+              new Workspace({
+                revision: current.revision + 1,
+                preferredRoute: current.preferredRoute
+              })
+            )
           )
       },
-      Draft: {
-        on: {
-          Edit: (to) =>
-            to.local.Draft().resolve(({ event, state, target }) =>
-              target.decoded(new Draft({ text: event.text, autosaves: state.autosaves }))
-            ),
-          Save: (to) => to.local.AutoSaving().resolve(({ target }) => target.decoded(new AutoSaving({}))),
-          Submit: (to) =>
+      onDone: (to) =>
+        to.branch.Published().resolve(({ target }) => target.decoded(new Published({ result: "workspace published" }))),
+      states: {
+        Routing: {
+          choice: (to) =>
             to.branches({
-              review: { title: "Enter the review flow", target: to.local.Review.initial },
-              publish: { title: "Publish without review", target: to.local.Finished() }
-            }).resolve(({ event, select }) =>
-              event.mode === "publish"
-                ? select.publish.decoded(new WorkspaceFinished({ result: "published directly" }))
-                : select.review.decoded(new Review({ requestedBy: event.requestedBy }))
+              draft: { title: "Preferred route is draft", target: to.local.Draft() },
+              review: { title: "Preferred route is review", target: to.local.Review.initial }
+            }).resolve(({ containingState, select }) =>
+              containingState.preferredRoute === "review"
+                ? select.review.decoded(new Review({ requestedBy: "initial route" }))
+                : select.draft.decoded(new Draft({ text: "", autosaves: 0 }))
+            )
+        },
+        Draft: {
+          on: {
+            Edit: (to) =>
+              to.local.Draft().resolve(({ event, state, target }) =>
+                target.decoded(new Draft({ text: event.text, autosaves: state.autosaves }))
+              ),
+            Save: (to) => to.local.AutoSaving().resolve(({ target }) => target.decoded(new AutoSaving({}))),
+            Submit: (to) =>
+              to.branches({
+                review: { title: "Enter the review flow", target: to.local.Review.initial },
+                publish: { title: "Publish without review", target: to.local.Finished() }
+              }).resolve(({ event, select }) =>
+                event.mode === "publish"
+                  ? select.publish.decoded(new WorkspaceFinished({ result: "published directly" }))
+                  : select.review.decoded(new Review({ requestedBy: event.requestedBy }))
+              ),
+            Refresh: (to) => to.none.resolve(() => undefined, { reenter: true }),
+            Ignore: (to) => to.none,
+            MaybeHandle: (to) =>
+              to.none.resolve(({ decline, event }) => event.accept ? undefined : decline(), {
+                declinable: true
+              })
+          }
+        },
+        AutoSaving: {
+          always: (to) =>
+            to.local.Draft().resolve(({ target }) =>
+              target.decoded(new Draft({ text: "Autosaved draft", autosaves: 1 }))
+            )
+        },
+        Review: {
+          initialize: ({ builder }) => builder.decoded(new Checking({ checks: ["types", "tests"] })),
+          onDone: (to) =>
+            to.branch.Workspace.Finished().resolve(({ target }) =>
+              target.decoded(new WorkspaceFinished({ result: "approved review" }))
             ),
-          Refresh: (to) => to.none.resolve(() => undefined, { reenter: true }),
-          Ignore: (to) => to.none,
-          MaybeHandle: (to) =>
-            to.none.resolve(({ decline, event }) => event.accept ? undefined : decline(), {
-              declinable: true
-            })
-        }
-      },
-      AutoSaving: {
-        always: (to) =>
-          to.local.Draft().resolve(({ target }) => target.decoded(new Draft({ text: "Autosaved draft", autosaves: 1 })))
-      },
-      Review: {
-        initialize: ({ builder }) => builder.decoded(new Checking({ checks: ["types", "tests"] })),
-        onDone: (to) =>
-          to.branch.Workspace.Finished().resolve(({ target }) =>
-            target.decoded(new WorkspaceFinished({ result: "approved review" }))
-          ),
-        states: {
-          Checking: {
-            on: {
-              Approve: (to) =>
-                to.local.Approved().resolve(({ event, target }) =>
-                  target.decoded(new Approved({ reviewer: event.reviewer }))
-                ),
-              Reject: (to) =>
-                to.local.ChangesRequested().resolve(({ event, target }) =>
-                  target.decoded(new ChangesRequested({ reason: event.reason }))
-                )
-            }
-          },
-          ChangesRequested: {
-            on: {
-              Revise: (to) =>
-                to.branch.Workspace.Draft().resolve(({ target }) =>
-                  target.decoded(new Draft({ text: "Revised draft", autosaves: 0 }))
-                )
+          states: {
+            Checking: {
+              on: {
+                Approve: (to) =>
+                  to.local.Approved().resolve(({ event, target }) =>
+                    target.decoded(new Approved({ reviewer: event.reviewer }))
+                  ),
+                Reject: (to) =>
+                  to.local.ChangesRequested().resolve(({ event, target }) =>
+                    target.decoded(new ChangesRequested({ reason: event.reason }))
+                  )
+              }
+            },
+            ChangesRequested: {
+              on: {
+                Revise: (to) =>
+                  to.branch.Workspace.Draft().resolve(({ target }) =>
+                    target.decoded(new Draft({ text: "Revised draft", autosaves: 0 }))
+                  )
+              }
             }
           }
         }
       }
+    },
+    Paused: {
+      on: {
+        Create: (to) =>
+          to.branch.Workspace.initial.resolve(({ event, target }) =>
+            target.decoded(new Workspace({ revision: 0, preferredRoute: event.route }))
+          ),
+        ResumeShallow: (to) => to.history.Workspace.recent.resolve(({ target }) => target()),
+        ResumeDeep: (to) => to.history.Workspace.exact.resolve(({ target }) => target()),
+        Restart: (to) =>
+          to.branch.Workspace.initial.resolve(({ target }) =>
+            target.decoded(new Workspace({ revision: 0, preferredRoute: "draft" }))
+          )
+      }
+    },
+    Disabled: {},
+    Published: {
+      output: ({ state }) => state.result
     }
-  },
-  Paused: {
-    on: {
-      Create: (to) =>
-        to.full.Workspace.initial.resolve(({ event, target }) =>
-          target.decoded(new Workspace({ revision: 0, preferredRoute: event.route }))
-        ),
-      ResumeShallow: (to) => to.history.Workspace.recent.resolve(({ target }) => target()),
-      ResumeDeep: (to) => to.history.Workspace.exact.resolve(({ target }) => target()),
-      Restart: (to) =>
-        to.full.Workspace.initial.resolve(({ target }) =>
-          target.decoded(new Workspace({ revision: 0, preferredRoute: "draft" }))
-        )
-    }
-  },
-  Disabled: {},
-  Published: {
-    output: ({ state }) => state.result
   }
 })

package/src/internal/browser/visualizer-model.ts

@@ -55,7 +55,7 @@ export interface VisualizerModel {
 }
 
 export const stateLabel = (state: VisualizationState): string =>
-  state.title === null ? state.key : `${state.title} (${state.key})`
+  state.title === null ? (state.path === "" ? "(root)" : state.key) : `${state.title} (${state.key})`
 
 export const triggerLabel = (transition: VisualizationTransition): string => {
   switch (transition.trigger.type) {
@@ -74,7 +74,7 @@ export const triggerLabel = (transition: VisualizationTransition): string => {
 
 const propertyAccess = (key: string): string => /^[$A-Z_a-z][$\w]*$/.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`
 
-const pathAccess = (path: string): string => path.split(".").map(propertyAccess).join("")
+const pathAccess = (path: string): string => path === "" ? "" : path.split(".").map(propertyAccess).join("")
 
 const nearestCompoundScope = (
   document: VisualizationDocument,
@@ -97,7 +97,7 @@ const localPathAccess = (
   const scope = nearestCompoundScope(document, source)
   if (scope === undefined) return undefined
   if (path === scope) return ""
-  const prefix = `${scope}.`
+  const prefix = scope === "" ? "" : `${scope}.`
   return path.startsWith(prefix) ? pathAccess(path.slice(prefix.length)) : undefined
 }
 
@@ -138,13 +138,13 @@ export const branchTargetApi = (
     switch (selection.kind) {
       case "state":
       case "choice":
-        api = `to.branch${pathAccess(path)}()`
+        api = path === "" ? "to.root()" : `to.branch${pathAccess(path)}()`
         break
       case "initial":
-        api = `to.branch${pathAccess(path)}.initial`
+        api = path === "" ? "to.root.initial" : `to.branch${pathAccess(path)}.initial`
         break
       case "update":
-        api = `to.branch${pathAccess(path)}.update`
+        api = path === "" ? "to.root.update" : `to.branch${pathAccess(path)}.update`
         break
       case "history":
         break
@@ -165,7 +165,7 @@ export const branchTargetApi = (
         break
     }
   } else if (selection.scope === "initial") {
-    if (selection.kind === "state") api = `to${pathAccess(path)}()`
+    if (selection.kind === "state") api = path === "" ? "to" : `to${pathAccess(path)}()`
     if (selection.kind === "initial") api = `to${pathAccess(path)}.initial`
   }
 

package/src/internal/devServer.ts

@@ -1,5 +1,6 @@
 import { type ChokidarOptions, type FSWatcher, watch } from "chokidar"
 import * as Effect from "effect/Effect"
+import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type { IncomingMessage, ServerResponse } from "node:http"
 import { isAbsolute, relative, resolve } from "node:path"
@@ -117,11 +118,12 @@ const acquire = (
       })
   })
 
-const acquireWatcher = (
+export const acquireWatcher = (
   options: DevServer.Options,
   registry: MachineRegistry.MachineRegistry["Service"]
-): Effect.Effect<FSWatcher> =>
-  Effect.sync(() => {
+): Effect.Effect<FSWatcher, never, Scope.Scope> =>
+  Effect.gen(function*() {
+    const scope = yield* Effect.scope
     let refreshTimer: ReturnType<typeof setTimeout> | undefined
     const watcher = watch(options.root, watcherOptions(options))
     watcher.on("all", (_event, file) => {
@@ -130,16 +132,20 @@ const acquireWatcher = (
       refreshTimer = setTimeout(() => {
         Effect.runFork(
           registry.refresh.pipe(
-            Effect.catch((cause) => Effect.logWarning("Machine reload failed", cause))
+            Effect.catch((cause) => Effect.logWarning("Machine reload failed", cause)),
+            Effect.forkIn(scope)
           )
         )
       }, options.debounce ?? 150)
     })
-    watcher.on("close", () => {
-      if (refreshTimer !== undefined) clearTimeout(refreshTimer)
-    })
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(async () => {
+        if (refreshTimer !== undefined) clearTimeout(refreshTimer)
+        await watcher.close()
+      })
+    )
     watcher.on("error", (cause) => {
-      Effect.runFork(Effect.logError("Machine file watcher failed", cause))
+      Effect.runFork(Effect.logError("Machine file watcher failed", cause).pipe(Effect.forkIn(scope)))
     })
     return watcher
   })
@@ -166,10 +172,7 @@ export const run = (
       acquire(ErrorType, options, registry),
       (server) => Effect.promise(() => server.close())
     )
-    yield* Effect.acquireRelease(
-      acquireWatcher(options, registry),
-      (watcher) => Effect.promise(() => watcher.close())
-    )
+    yield* acquireWatcher(options, registry)
     const address = server.resolvedUrls?.local[0] ?? `http://${options.host}:${options.port}/`
     yield* Effect.logInfo(`Effect Machine visualizer: ${address}`)
     return yield* Effect.never

package/src/internal/machineRegistry.ts

@@ -89,28 +89,28 @@ const make = (api: PublicApi, options: MachineRegistry.Options) =>
       results: []
     })
 
-    const refresh = SubscriptionRef.get(state).pipe(
-      Effect.flatMap((current) =>
-        inspector.inspect({
-          ...options,
-          revision: current.revision + 1,
-          retainedCandidates: retainedCandidates(current.results)
-        }).pipe(
-          Effect.map((results): MachineRegistry.Snapshot => ({
+    const refresh = SubscriptionRef.modifyEffect(state, (current) =>
+      inspector.inspect({
+        ...options,
+        revision: current.revision + 1,
+        retainedCandidates: retainedCandidates(current.results)
+      }).pipe(
+        Effect.map((results) => {
+          const next: MachineRegistry.Snapshot = {
             protocolVersion: DevToolsProtocol.protocolVersion,
             revision: current.revision + 1,
             results: reconcile(current.results, results)
-          }))
-        )
-      ),
-      Effect.tap((next) => SubscriptionRef.set(state, next)),
-      Effect.mapError((cause) =>
-        new api.RegistryError({
-          message: `Could not inspect Effect Machine definitions under ${options.root}`,
-          cause
+          }
+          return [next, next] as const
         })
+      )).pipe(
+        Effect.mapError((cause) =>
+          new api.RegistryError({
+            message: `Could not inspect Effect Machine definitions under ${options.root}`,
+            cause
+          })
+        )
       )
-    )
 
     yield* refresh