@pmelab/gtd 60.0.0 → 60.1.0

package/src/workflow/load.ts

@@ -1,7 +1,10 @@
-import { existsSync, readFileSync } from "node:fs"
-import { createRequire } from "node:module"
-import { dirname, join } from "node:path"
+import { existsSync, readFileSync, realpathSync } from "node:fs"
+import { createRequire, isBuiltin } from "node:module"
+import { dirname, isAbsolute, join, relative, resolve as resolvePath, sep } from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
+import { stripVTControlCharacters } from "node:util"
+import { runInThisContext } from "node:vm"
+import type { Plugin as RolldownPlugin } from "rolldown"
 import { Context, Effect, Layer } from "effect"
 import { GtdError, Narrator } from "../platform/index.js"
 import { accessShapeFault, replay, type TreeView } from "../replay/index.js"
@@ -15,6 +18,7 @@ import { compileConfig, type CompiledConfig } from "./compile.js"
 import { SETTING_NAME_RULE, isSettingName } from "./vars.js"
 import { ConfigDiscovery, WORKFLOW_MODULE, type WorkflowModule } from "./discovery.js"
 import { configFingerprint, type ConfigFingerprint } from "./fingerprint.js"
+import { PIN_KEY } from "../install/index.js"
 import {
   dedupeDiagnostics,
   formatDiagnostic,
@@ -100,9 +104,25 @@ export const refuseLegacyRc: Effect.Effect<void, GtdError, Host | ConfigDiscover
     )
   })
 
+const configModule: Effect.Effect<WorkflowModule, Error, Host | ConfigDiscovery> = Effect.gen(
+  function* () {
+    const host = yield* Host
+    const module = yield* (yield* ConfigDiscovery).workflowModule(host.root, host.home)
+    if (module !== undefined) return module
+    const missing: Diagnostic = {
+      severity: "error",
+      path: [],
+      message: `no workflows configured: no ${WORKFLOW_MODULE} here or above — gtd ships no workflow; \`gtd guide\` says where to get one`,
+      origin: host.root,
+    }
+    return yield* Effect.fail(configError([missing]))
+  },
+)
+
 /**
- * Find and evaluate `gtd.config.ts`, then check what it exports. Every finding
- * is collected into ONE sorted report rather than failing on the first.
+ * Find and evaluate `gtd.config.ts` — or, inside a pin, the workflow bundled
+ * into it — then check what it exports. Every finding is collected into ONE
+ * sorted report rather than failing on the first.
  */
 export const load: Effect.Effect<
   ConfigOperations,
@@ -110,25 +130,30 @@ export const load: Effect.Effect<
   Narrator | Workspace | Host | ConfigDiscovery
 > = Effect.gen(function* () {
   const host = yield* Host
-  const discovery = yield* ConfigDiscovery
   yield* refuseLegacyRc
-  const module = yield* discovery.workflowModule(host.root, host.home)
-  if (module === undefined) {
-    const missing: Diagnostic = {
-      severity: "error",
-      path: [],
-      message: `no workflows configured: no ${WORKFLOW_MODULE} here or above — gtd ships no workflow; \`gtd guide\` says where to get one`,
-      origin: host.root,
-    }
-    return yield* Effect.fail(configError([missing]))
-  }
-  yield* (yield* Narrator).narrate(`config: module ${module.filepath}`)
-  const shipped = yield* Effect.tryPromise({
-    try: shippedModules,
-    catch: (e) => new GtdError(`gtd: ${e instanceof Error ? e.message : String(e)}`),
-  })
-  const loaded = yield* Effect.try({
-    try: () => loadWorkflows(module, shipped),
+  const pinned = pinnedWorkflow()
+  const module: WorkflowModule =
+    pinned === undefined
+      ? yield* configModule
+      : { filepath: resolvePath(host.root, pinned.origin), source: "" }
+  yield* (yield* Narrator).narrate(
+    `config: ${pinned === undefined ? "module" : "pinned module"} ${module.filepath}`,
+  )
+  const shipped =
+    pinned === undefined
+      ? yield* Effect.tryPromise({
+          try: shippedModules,
+          catch: (e) => new GtdError(`gtd: ${e instanceof Error ? e.message : String(e)}`),
+        })
+      : undefined
+  const loaded = yield* Effect.tryPromise({
+    try: async () =>
+      loadWorkflows(
+        module.filepath,
+        shipped === undefined
+          ? runPinned(pinned!, module.filepath, host.root)
+          : await evaluate(module, shipped),
+      ),
     catch: (e) =>
       new GtdError(
         `gtd: config:\n  - ${module.filepath}: ${e instanceof Error ? e.message : String(e)}`,
@@ -176,11 +201,9 @@ export const load: Effect.Effect<
     },
     ...(compiled.ui !== undefined ? { ui: compiled.ui } : {}),
     warnings: diagnostics.filter((d) => d.severity === "warning"),
-    fingerprint: configFingerprint(
-      loaded.file.dependencyFiles,
-      host.root,
-      module.read ?? readFromDisk,
-    ),
+    fingerprint:
+      pinned?.fingerprint ??
+      configFingerprint(loaded.file.dependencyFiles, host.root, module.read ?? readFromDisk),
   }
 })
 
@@ -200,13 +223,11 @@ interface Settings {
 interface LoadedFile {
   readonly origin: string
   /**
-   * Every real file this module's evaluation touched — `origin` itself plus
-   * any relative import it (transitively) resolved on disk, in NO particular
-   * order. A caller that
-   * needs to know when a workflow's DEFINITION might have changed (the LSP's
-   * steering-map memo) must watch this whole set, not just `origin`: a
-   * `gtd.config.ts` re-exporting a sibling module is a documented pattern,
-   * and jiti resolves that import off disk same as any other require.
+   * Every file bundled evaluating this module — `origin` itself plus every
+   * local module it (transitively) imports, in NO particular order. A caller
+   * that needs to know when a workflow's DEFINITION might have changed (the
+   * LSP's steering-map memo) must watch this whole set, not just `origin`: a
+   * `gtd.config.ts` re-exporting a sibling module is a documented pattern.
    */
   readonly dependencyFiles: readonly string[]
 }
@@ -231,76 +252,8 @@ interface Loaded {
   readonly diagnostics: readonly Diagnostic[]
 }
 
-type JitiInstance = {
-  evalModule: (
-    source: string,
-    options: { filename: string; async?: false; cache?: Record<string, unknown> },
-  ) => unknown
-}
-type JitiModule = {
-  createJiti: (id: string, options: Record<string, unknown>) => JitiInstance
-}
-
-type Transform = (options: { readonly source: string }) => { code: string; error?: unknown }
-
-// Transpiling is most of a load's cost, and a load re-transpiles
-// gtd.config.ts and every shipped module it imports. The same options (the
-// source included) always transpile to the same code, so an in-process memo
-// is safe; evaluation stays fresh on every load.
-const TRANSFORM_MEMO_SIZE = 512
-const memoized = (transform: Transform): Transform => {
-  const memo = new Map<string, ReturnType<Transform>>()
-  return (options) => {
-    const key = JSON.stringify(options)
-    const hit = memo.get(key)
-    if (hit !== undefined) return hit
-    const result = transform(options)
-    if (result.error !== undefined) return result
-    if (memo.size >= TRANSFORM_MEMO_SIZE) memo.delete(memo.keys().next().value!)
-    memo.set(key, result)
-    return result
-  }
-}
-
-let jitiModule: JitiModule | undefined
-let transform: Transform | undefined
-/** Relative specifiers a module imports, served from somewhere other than the disk. */
-interface LocalModules {
-  /** The path a specifier names, or nothing when it names no module. */
-  readonly resolve: (specifier: string) => string | undefined
-  readonly load: (path: string) => unknown
-}
-
-const jiti = (shipped: ShippedModules, local?: LocalModules): JitiInstance => {
-  const require = createRequire(import.meta.url)
-  jitiModule ??= require("jiti") as JitiModule
-  // jiti's own Babel transform, which its package exports don't name.
-  transform ??= memoized(
-    require(join(dirname(require.resolve("jiti/package.json")), "dist", "babel.cjs")) as Transform,
-  )
-  return jitiModule.createJiti(import.meta.url, {
-    // Consulted when a module is required, so a local module is evaluated
-    // only once an import actually runs.
-    virtualModules: new Proxy(shipped.modules, {
-      has: (modules, id) =>
-        id in modules || (typeof id === "string" && local?.resolve(id) !== undefined),
-      get: (modules, id) => {
-        const path = typeof id === "string" ? local?.resolve(id) : undefined
-        return path === undefined ? modules[id as string] : local!.load(path)
-      },
-    }),
-    alias: shipped.missing,
-    // No transpile cache on disk, and a fresh module every load — nothing a
-    // later command could read back instead of the source.
-    fsCache: false,
-    moduleCache: false,
-    transform,
-    // The whole module, not just its default: the named exports are read too.
-    interopDefault: false,
-  })
-}
-
 const PACKAGE = "@pmelab/gtd"
+const FLOWS = `${PACKAGE}/flows`
 
 interface PackageJson {
   readonly name?: string
@@ -309,7 +262,7 @@ interface PackageJson {
 
 // Only gtd's own package.json: whatever other one sits nearest (a vendored
 // bundle inside a project) must never get its exports executed.
-const ownPackage = (): { readonly root: string; readonly pkg: PackageJson } => {
+export const ownPackage = (): { readonly root: string; readonly pkg: PackageJson } => {
   const start = dirname(fileURLToPath(import.meta.url))
   for (let dir = start; ; dir = dirname(dir)) {
     const file = join(dir, "package.json")
@@ -340,7 +293,7 @@ const shippedModules = (): Promise<ShippedModules> =>
   (shippedMemo ??= (async () => {
     const fromSource = import.meta.url.endsWith(".ts")
     const files = subpathFiles(fromSource ? "source" : "default")
-    const modules: Record<string, unknown> = { [`${PACKAGE}/flows`]: flows }
+    const modules: Record<string, unknown> = { [FLOWS]: flows }
     const missing: Record<string, string> = {}
     if (process.features.require_module && !fromSource) {
       return { modules: requiredOnUse(modules, files), missing }
@@ -582,18 +535,11 @@ const namespaceOf = (exported: unknown): Record<string, unknown> =>
 /**
  * Evaluate `gtd.config.ts`. Every export but the reserved names that went
  * through `workflow()` or is a factory workflow is a workflow named by its
- * export. `cache` is jiti's OWN per-call module cache (unrelated to the
- * instance's `moduleCache: false`) — passing an empty object in has the side
- * effect of collecting every real file jiti resolved evaluating this module,
- * module AND every relative import it pulled in, transitively.
+ * export.
  */
-const loadWorkflows = (module: WorkflowModule, shipped: ShippedModules): Loaded => {
-  const { exports: evaluated, files } =
-    module.read === undefined
-      ? evaluateFromDisk(module, shipped)
-      : evaluateRead(module, module.read, shipped)
-  const exports = namespaceOf(evaluated)
-  const file: LoadedFile = { origin: module.filepath, dependencyFiles: files }
+const loadWorkflows = (origin: string, evaluated: Evaluated): Loaded => {
+  const exports = namespaceOf(evaluated.exports)
+  const file: LoadedFile = { origin, dependencyFiles: evaluated.files }
   const exported = Object.entries(exports).filter(
     ([name, value]) => !RESERVED_EXPORTS.has(name) && isWorkflow(value),
   )
@@ -625,7 +571,7 @@ const loadWorkflows = (module: WorkflowModule, shipped: ShippedModules): Loaded
     catalogue,
     doors,
     default: defaultWorkflow && { ...defaultWorkflow, name: defaultName },
-    config: compileConfig(exports["config"], module.filepath),
+    config: compileConfig(exports["config"], origin),
     diagnostics: [
       ...retiredExports(exports, file.origin),
       ...nameRejections(rejections),
@@ -658,17 +604,8 @@ const shadowingDoors = (
       origin,
     }))
 
-const evaluateFromDisk = (
-  module: WorkflowModule,
-  shipped: ShippedModules,
-): { readonly exports: unknown; readonly files: readonly string[] } => {
-  const cache: Record<string, unknown> = {}
-  const exports = jiti(shipped).evalModule(module.source, { filename: module.filepath, cache })
-  return { exports, files: Object.keys(cache) }
-}
-
-// How jiti finds a TypeScript module behind a specifier: as written, its
-// `.js` spelling as `.ts`, with `.ts` appended, or as a directory index.
+// How a TypeScript module is found behind a relative specifier: as written,
+// its `.js` spelling as `.ts`, with `.ts` appended, or as a directory index.
 const moduleCandidates = (path: string): readonly string[] => [
   path,
   path.replace(/\.js$/, ".ts"),
@@ -677,41 +614,255 @@ const moduleCandidates = (path: string): readonly string[] => [
   join(path, "index.ts"),
 ]
 
+interface Evaluated {
+  readonly exports: unknown
+  readonly files: readonly string[]
+}
+
+/** A bundle's one chunk: CommonJS, so it runs as a plain function. */
+type Chunk = (
+  exports: unknown,
+  require: (id: string) => unknown,
+  module: { exports: unknown },
+  __filename: string,
+  __dirname: string,
+) => void
+
+const execute = (chunk: Chunk, filepath: string, require: (id: string) => unknown): unknown => {
+  const cjs = { exports: {} as unknown }
+  chunk(cjs.exports, require, cjs, filepath, dirname(filepath))
+  return cjs.exports
+}
+
 /**
- * Evaluates the config with every local module it imports taken from `read`
- * instead of the disk. jiti matches a virtual module on the specifier as
- * written, so each module gets its own instance resolving against its own
- * directory. A specifier `read` cannot serve falls through to the disk, and
- * fails the way a missing file does.
+ * Bundles the config and every local module it imports in memory, then
+ * evaluates the bundle. With `read`, a relative import `read` can serve is
+ * taken from it instead of the disk; one it cannot falls through to the disk,
+ * and fails the way a missing file does. An ES module or TypeScript package is
+ * bundled too; a CommonJS one is required from where its importer resolved
+ * it, as Node would. `@pmelab/gtd/*` is the running gtd's own copy, and
+ * `files` leaves out every package file.
  */
-const evaluateRead = (
+const evaluate = async (module: WorkflowModule, shipped: ShippedModules): Promise<Evaluated> => {
+  const { code, files } = await bundleConfig(module, { kind: "evaluate", shipped })
+  const fromConfig = createRequire(module.filepath)
+  const require = Object.assign(
+    (id: string): unknown =>
+      id in shipped.modules
+        ? shipped.modules[id]
+        : fromConfig(id in shipped.missing ? shipped.missing[id]! : id),
+    { resolve: fromConfig.resolve },
+  )
+  const chunk = runInThisContext(
+    `(function (exports, require, module, __filename, __dirname) {${code}\n})`,
+    { filename: module.filepath },
+  ) as Chunk
+  return { exports: execute(chunk, module.filepath, require), files }
+}
+
+/**
+ * What a pin registers: its workflow bundled, its origin relative to the
+ * repository root, and the fingerprint of the files it was bundled from — the
+ * content it runs, whatever the disk holds now.
+ */
+interface PinnedWorkflow {
+  readonly version: string
+  readonly origin: string
+  readonly fingerprint: ConfigFingerprint
+  readonly run: Chunk
+}
+
+const pinnedWorkflow = (): PinnedWorkflow | undefined =>
+  (globalThis as { [PIN_KEY]?: PinnedWorkflow })[PIN_KEY]
+
+const runPinned = (pinned: PinnedWorkflow, filepath: string, root: string): Evaluated => ({
+  // Everything but the engine's own flows and Node's builtins is in the bundle.
+  exports: execute(pinned.run, filepath, (id) =>
+    id === FLOWS ? flows : createRequire(import.meta.url)(id),
+  ),
+  files: Object.keys(pinned.fingerprint).map((file) => resolvePath(root, file)),
+})
+
+/**
+ * The statement that registers `module`'s workflow for a pin: the config and
+ * everything it imports — npm packages and gtd's own subpaths included — in
+ * one function, so the engine runs it without a config, a package or rolldown.
+ */
+export const pinnedWorkflowSource = async (
   module: WorkflowModule,
-  read: (path: string) => string | undefined,
-  shipped: ShippedModules,
-): { readonly exports: unknown; readonly files: readonly string[] } => {
-  const files = [module.filepath]
-  const evaluated = new Map<string, unknown>()
-  const evaluate = (filepath: string, source: string): unknown =>
-    jiti(shipped, {
-      resolve: (specifier) =>
-        /^\.\.?\//.test(specifier)
-          ? moduleCandidates(join(dirname(filepath), specifier)).find(
-              (candidate) => read(candidate) !== undefined,
-            )
-          : undefined,
-      load: (path) => {
-        if (!evaluated.has(path)) {
-          // A placeholder first, so an import cycle ends here.
-          evaluated.set(path, {})
-          files.push(path)
-          evaluated.set(path, evaluate(path, read(path)!))
-        }
-        return evaluated.get(path)
-      },
-    }).evalModule(source, { filename: filepath })
-  return { exports: evaluate(module.filepath, module.source), files }
+  root: string,
+  version: string,
+): Promise<string> => {
+  const gtd = realpathSync(ownPackage().root) + sep
+  const { code, files } = await bundleConfig(module, {
+    kind: "pin",
+    shipped: subpathFiles(import.meta.url.endsWith(".ts") ? "source" : "default"),
+  })
+  // gtd's own subpaths are bundled from its package, which only a config
+  // living in gtd's own repository may count among its files.
+  const own = (file: string) => file.startsWith(gtd) && !module.filepath.startsWith(gtd)
+  const registered = {
+    version,
+    origin: relative(root, module.filepath),
+    fingerprint: configFingerprint(
+      files.filter((file) => !own(file)),
+      root,
+      module.read ?? readFromDisk,
+    ),
+  }
+  return `globalThis[Symbol.for(${JSON.stringify(PIN_KEY.description)})] = { ...${JSON.stringify(registered)}, run: function (exports, require, module, __filename, __dirname) {\n${code}\n} };\n`
+}
+
+type BundleMode =
+  | { readonly kind: "evaluate"; readonly shipped: ShippedModules }
+  // Every import goes into the bundle but flows, the engine's own.
+  | { readonly kind: "pin"; readonly shipped: ReadonlyMap<string, string> }
+
+const shippedImport = (
+  source: string,
+  mode: BundleMode,
+): string | { readonly id: string; readonly external: true } | undefined => {
+  if (mode.kind === "pin")
+    return source === FLOWS ? { id: source, external: true } : mode.shipped.get(source)
+  return source in mode.shipped.modules || source in mode.shipped.missing
+    ? { id: source, external: true }
+    : undefined
 }
 
+const bundleConfig = async (
+  module: WorkflowModule,
+  mode: BundleMode,
+): Promise<{ readonly code: string; readonly files: readonly string[] }> => {
+  const { read } = module
+  const served = new Set<string>()
+  const fromRead = (path: string): string | null => {
+    const hit = moduleCandidates(path).find((candidate) => read?.(candidate) !== undefined)
+    if (hit === undefined) return null
+    served.add(hit)
+    return hit
+  }
+  const plugin: RolldownPlugin = {
+    name: "gtd-config",
+    async resolveId(source, importer) {
+      if (importer === undefined) return source === module.filepath ? source : null
+      const shipped = shippedImport(source, mode)
+      if (shipped !== undefined) return shipped
+      if (/^\.\.?(\/|$)/.test(source)) return fromRead(join(dirname(importer), source))
+      if (!isPackage(source)) return null
+      const resolved = await this.resolve(source, importer, { skipSelf: true })
+      return mode.kind === "pin" ? resolved : packageImport(source, resolved)
+    },
+    load(id) {
+      if (mode.kind === "pin" && isNativeAddon(id)) throw new Error(nativeAddon(id))
+      if (id === module.filepath) return module.source
+      return served.has(id) ? read!(id) : null
+    },
+    // One bundle has one file; each module keeps its own location.
+    transform(code, id) {
+      return code.replace(/\bimport\.meta\.(url|filename|dirname)\b/g, (_, key: string) =>
+        JSON.stringify(
+          key === "url" ? pathToFileURL(id).href : key === "filename" ? id : dirname(id),
+        ),
+      )
+    },
+  }
+  const bundle = await (rolldownModule ??= requireRolldown()).rolldown({
+    input: module.filepath,
+    platform: "node",
+    plugins: [plugin],
+    external: (id) => isBuiltin(id),
+    resolve: { extensionAlias: { ".js": [".js", ".ts"], ".mjs": [".mjs", ".mts"] } },
+    // Every statement runs, as it would unbundled.
+    treeshake: false,
+    tsconfig: false,
+    logLevel: "silent",
+  })
+  try {
+    const { output } = await bundle
+      // One chunk, and no `import()` left: the bundle runs as a plain function.
+      .generate({
+        format: "cjs",
+        exports: "named",
+        codeSplitting: false,
+        dynamicImportInCjs: false,
+      })
+      .catch((e) => {
+        throw bundleError(e)
+      })
+    const chunk = output[0]
+    return {
+      code: chunk.code,
+      files: chunk.moduleIds.filter((id) => !id.startsWith("\0") && !inPackage(id)),
+    }
+  } finally {
+    await bundle.close()
+  }
+}
+
+// A pin is plain JavaScript: a compiled addon stays a file on one machine.
+// A package node-gyp builds loads its addon by a path no bundler sees.
+const isNativeAddon = (id: string): boolean => {
+  if (id.endsWith(".node")) return true
+  const at = id.lastIndexOf(`node_modules${sep}`)
+  if (at < 0) return false
+  const rest = id.slice(at + `node_modules${sep}`.length).split(sep)
+  const root =
+    id.slice(0, at) + ["node_modules", ...rest.slice(0, rest[0]!.startsWith("@") ? 2 : 1)].join(sep)
+  return existsSync(join(root, "binding.gyp"))
+}
+
+const nativeAddon = (path: string): string => {
+  const at = path.lastIndexOf(`node_modules${sep}`)
+  const rest = at < 0 ? [] : path.slice(at + `node_modules${sep}`.length).split(sep)
+  const name = rest[0]?.startsWith("@") ? rest.slice(0, 2).join("/") : rest[0]
+  return `${name === undefined ? path : `package "${name}"`} loads a native addon (${path}), which a pin cannot carry`
+}
+
+// Bundled, an ES module gets the shipped `@pmelab/gtd/*` like the config
+// does. CommonJS stays Node's: it may read `__dirname`, which a bundle loses.
+const packageImport = (
+  source: string,
+  resolved: { readonly id: string } | null,
+): string | { readonly id: string; readonly external: true } =>
+  resolved !== null && isEsModule(resolved.id)
+    ? resolved.id
+    : { id: resolved?.id ?? source, external: true }
+
+const isEsModule = (path: string): boolean => {
+  if (/\.(mjs|[cm]?tsx?)$/.test(path)) return true
+  if (!/\.jsx?$/.test(path)) return false
+  for (let dir = dirname(path); dirname(dir) !== dir; dir = dirname(dir)) {
+    const file = join(dir, "package.json")
+    if (existsSync(file)) {
+      return (JSON.parse(readFileSync(file, "utf8")) as { type?: string }).type === "module"
+    }
+  }
+  return false
+}
+
+const inPackage = (path: string): boolean => /[\\/]node_modules[\\/]/.test(path)
+
+const isPackage = (specifier: string): boolean => !isAbsolute(specifier) && !isBuiltin(specifier)
+
+// rolldown reports each error with a colored code frame; a diagnostic takes
+// its headline and location.
+const bundleError = (e: unknown): unknown => {
+  const errors = (e as { errors?: readonly { message: string }[] } | null)?.errors
+  if (errors === undefined) return e
+  const lines = errors.map(({ message }) => {
+    const plain = stripVTControlCharacters(message)
+    const at = /\[ (.+:\d+:\d+) \]/.exec(plain)?.[1]
+    const headline = plain.split("\n")[0]!
+    return at === undefined ? headline : `${headline} (${at})`
+  })
+  return new Error(lines.join("\n"))
+}
+
+type Rolldown = typeof import("rolldown")
+let rolldownModule: Rolldown | undefined
+// Required at run time, never bundled: rolldown ships a native binding.
+const requireRolldown = (): Rolldown => createRequire(import.meta.url)("rolldown") as Rolldown
+
 const isWorkflow = (value: unknown): boolean =>
   markedOptions(value) !== undefined || isFactoryWorkflow(value)
 
@@ -928,7 +1079,7 @@ const firstStep = (
     const empty = watchedEmptyTree()
     const vars = watchedEmptySettings()
     const env = watchedEmptySettings()
-    const outcome = yield* Effect.either(
+    const outcome = yield* Effect.result(
       replayToFirstStep(loaded, vars.settings, env.settings, empty.tree),
     )
     const reads = [...settingReads("process", vars), ...settingReads("environment", env)]
@@ -939,8 +1090,8 @@ const firstStep = (
         ),
       )
     }
-    if (outcome._tag === "Left") return yield* Effect.fail(outcome.left)
-    const name = outcome.right
+    if (outcome._tag === "Failure") return yield* Effect.fail(outcome.failure)
+    const name = outcome.success
     if (!empty.read()) return name
     const atHead = yield* replayToFirstStep(loaded, vars.settings, env.settings, head)
     if (atHead === name) return name
@@ -959,9 +1110,8 @@ interface ConfigServiceOperations {
   >
 }
 
-export class ConfigService extends Context.Tag("ConfigService")<
-  ConfigService,
-  ConfigServiceOperations
->() {
+export class ConfigService extends Context.Service<ConfigService, ConfigServiceOperations>()(
+  "ConfigService",
+) {
   static Live = Layer.succeed(ConfigService, { load })
 }