@pmelab/gtd 63.0.0 → 64.0.0

package/src/workflow/load.ts

@@ -1,12 +1,6 @@
-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 { Context, Effect, Layer, Path } from "effect"
+import { GtdError, Narrator, NodeRuntime, nodeSyncIo } from "../platform/index.js"
 import { accessShapeFault, replay, type TreeView } from "../replay/index.js"
 // The published facade: what a config's `@pmelab/gtd/flows` import is served.
 import * as flows from "../flows/index.js"
@@ -129,22 +123,23 @@ const configModule: Effect.Effect<WorkflowModule, Error, Host | ConfigDiscovery>
 export const load: Effect.Effect<
   ConfigOperations,
   Error,
-  Narrator | Workspace | Host | ConfigDiscovery
+  Narrator | Workspace | Host | Path.Path | ConfigDiscovery
 > = Effect.gen(function* () {
   const host = yield* Host
+  const paths = yield* Path.Path
   yield* refuseLegacyRc
   const pinned = pinnedWorkflow()
   const module: WorkflowModule =
     pinned === undefined
       ? yield* configModule
-      : { filepath: resolvePath(host.root, pinned.origin), source: "" }
+      : { filepath: paths.resolve(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,
+          try: () => shippedModules(paths),
           catch: (e) => new GtdError(`gtd: ${e instanceof Error ? e.message : String(e)}`),
         })
       : undefined
@@ -153,8 +148,8 @@ export const load: Effect.Effect<
       loadWorkflows(
         module.filepath,
         shipped === undefined
-          ? runPinned(pinned!, module.filepath, host.root)
-          : await evaluate(module, shipped),
+          ? runPinned(paths, pinned!, module.filepath, host.root)
+          : await evaluate(paths, module, shipped),
       ),
     catch: (e) =>
       new GtdError(
@@ -205,14 +200,22 @@ export const load: Effect.Effect<
     warnings: diagnostics.filter((d) => d.severity === "warning"),
     fingerprint:
       pinned?.fingerprint ??
-      configFingerprint(loaded.file.dependencyFiles, host.root, module.read ?? readFromDisk),
+      configFingerprint(
+        nodeSyncIo,
+        paths,
+        loaded.file.dependencyFiles,
+        host.root,
+        module.read ?? readFromDisk,
+      ),
     drift:
       pinned === undefined
         ? []
         : changedConfigFiles(
             pinned.fingerprint,
             configFingerprint(
-              Object.keys(pinned.fingerprint).map((file) => resolvePath(host.root, file)),
+              nodeSyncIo,
+              paths,
+              Object.keys(pinned.fingerprint).map((file) => paths.resolve(host.root, file)),
               host.root,
               readFromDisk,
             ),
@@ -220,9 +223,11 @@ export const load: Effect.Effect<
   }
 })
 
+// Loading reads the real disk in every tier, as rolldown does: gtd's own
+// package and the config's node_modules exist nowhere else.
 const readFromDisk = (path: string): string | undefined => {
   try {
-    return readFileSync(path, "utf8")
+    return nodeSyncIo.readText(path)
   } catch {
     return undefined
   }
@@ -275,15 +280,17 @@ 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.
-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")
-    if (existsSync(file)) {
-      const pkg = JSON.parse(readFileSync(file, "utf8")) as PackageJson
+export const ownPackage = (
+  paths: Path.Path,
+): { readonly root: string; readonly pkg: PackageJson } => {
+  const start = paths.dirname(Effect.runSync(paths.fromFileUrl(new URL(import.meta.url))))
+  for (let dir = start; ; dir = paths.dirname(dir)) {
+    const source = readFromDisk(paths.join(dir, "package.json"))
+    if (source !== undefined) {
+      const pkg = JSON.parse(source) as PackageJson
       if (pkg.name === PACKAGE) return { root: dir, pkg }
     }
-    if (dirname(dir) === dir) throw new Error(`no ${PACKAGE} package.json above ${start}`)
+    if (paths.dirname(dir) === dir) throw new Error(`no ${PACKAGE} package.json above ${start}`)
   }
 }
 
@@ -302,10 +309,10 @@ interface ShippedModules {
 // config — or a workflow as it runs — requires it, so a command loads only the
 // subpaths its config uses; elsewhere, and from source, all of them up front.
 let shippedMemo: Promise<ShippedModules> | undefined
-const shippedModules = (): Promise<ShippedModules> =>
+const shippedModules = (paths: Path.Path): Promise<ShippedModules> =>
   (shippedMemo ??= (async () => {
     const fromSource = import.meta.url.endsWith(".ts")
-    const files = subpathFiles(fromSource ? "source" : "default")
+    const files = subpathFiles(paths, fromSource ? "source" : "default")
     const modules: Record<string, unknown> = { [FLOWS]: flows }
     const missing: Record<string, string> = {}
     if (process.features.require_module && !fromSource) {
@@ -313,7 +320,7 @@ const shippedModules = (): Promise<ShippedModules> =>
     }
     for (const [id, path] of files) {
       try {
-        modules[id] = await import(pathToFileURL(path).href)
+        modules[id] = await import(fileUrl(paths, path))
       } catch {
         missing[id] = path
       }
@@ -322,14 +329,14 @@ const shippedModules = (): Promise<ShippedModules> =>
   })())
 
 /** The file each subpath a config may import serves: all but `flows`, the engine's own, and the testkit's. */
-const subpathFiles = (condition: string): ReadonlyMap<string, string> => {
-  const { root, pkg } = ownPackage()
+const subpathFiles = (paths: Path.Path, condition: string): ReadonlyMap<string, string> => {
+  const { root, pkg } = ownPackage(paths)
   const files = new Map<string, string>()
   for (const [subpath, target] of Object.entries(pkg.exports)) {
     const file = typeof target === "string" ? target : target[condition]
     // A config runs no tests, and the gherkin steps import the consumer's test runner.
     if (subpath === "./flows" || subpath.startsWith("./testkit") || file === undefined) continue
-    files.set(`${PACKAGE}/${subpath.replace(/^\.\//, "")}`, join(root, file))
+    files.set(`${PACKAGE}/${subpath.replace(/^\.\//, "")}`, paths.join(root, file))
   }
   return files
 }
@@ -338,7 +345,7 @@ const requiredOnUse = (
   modules: Record<string, unknown>,
   files: ReadonlyMap<string, string>,
 ): Record<string, unknown> => {
-  const require = createRequire(import.meta.url)
+  const require = NodeRuntime.createRequire(import.meta.url)
   return new Proxy(modules, {
     has: (loaded, id) => id in loaded || (typeof id === "string" && files.has(id)),
     get: (loaded, id) =>
@@ -619,12 +626,12 @@ const shadowingDoors = (
 
 // 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[] => [
+const moduleCandidates = (paths: Path.Path, path: string): readonly string[] => [
   path,
   path.replace(/\.js$/, ".ts"),
   path.replace(/\.mjs$/, ".mts"),
   `${path}.ts`,
-  join(path, "index.ts"),
+  paths.join(path, "index.ts"),
 ]
 
 interface Evaluated {
@@ -641,9 +648,14 @@ type Chunk = (
   __dirname: string,
 ) => void
 
-const execute = (chunk: Chunk, filepath: string, require: (id: string) => unknown): unknown => {
+const execute = (
+  paths: Path.Path,
+  chunk: Chunk,
+  filepath: string,
+  require: (id: string) => unknown,
+): unknown => {
   const cjs = { exports: {} as unknown }
-  chunk(cjs.exports, require, cjs, filepath, dirname(filepath))
+  chunk(cjs.exports, require, cjs, filepath, paths.dirname(filepath))
   return cjs.exports
 }
 
@@ -656,9 +668,13 @@ const execute = (chunk: Chunk, filepath: string, require: (id: string) => unknow
  * it, as Node would. `@pmelab/gtd/*` is the running gtd's own copy, and
  * `files` leaves out every package file.
  */
-const evaluate = async (module: WorkflowModule, shipped: ShippedModules): Promise<Evaluated> => {
-  const { code, files } = await bundleConfig(module, { kind: "evaluate", shipped })
-  const fromConfig = createRequire(module.filepath)
+const evaluate = async (
+  paths: Path.Path,
+  module: WorkflowModule,
+  shipped: ShippedModules,
+): Promise<Evaluated> => {
+  const { code, files } = await bundleConfig(paths, module, { kind: "evaluate", shipped })
+  const fromConfig = NodeRuntime.createRequire(module.filepath)
   const require = Object.assign(
     (id: string): unknown =>
       id in shipped.modules
@@ -666,11 +682,11 @@ const evaluate = async (module: WorkflowModule, shipped: ShippedModules): Promis
         : fromConfig(id in shipped.missing ? shipped.missing[id]! : id),
     { resolve: fromConfig.resolve },
   )
-  const chunk = runInThisContext(
+  const chunk = NodeRuntime.compileScript(
     `(function (exports, require, module, __filename, __dirname) {${code}\n})`,
-    { filename: module.filepath },
+    module.filepath,
   ) as Chunk
-  return { exports: execute(chunk, module.filepath, require), files }
+  return { exports: execute(paths, chunk, module.filepath, require), files }
 }
 
 /**
@@ -688,12 +704,17 @@ interface PinnedWorkflow {
 const pinnedWorkflow = (): PinnedWorkflow | undefined =>
   (globalThis as { [PIN_KEY]?: PinnedWorkflow })[PIN_KEY]
 
-const runPinned = (pinned: PinnedWorkflow, filepath: string, root: string): Evaluated => ({
+const runPinned = (
+  paths: Path.Path,
+  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),
+  exports: execute(paths, pinned.run, filepath, (id) =>
+    id === FLOWS ? flows : NodeRuntime.createRequire(import.meta.url)(id),
   ),
-  files: Object.keys(pinned.fingerprint).map((file) => resolvePath(root, file)),
+  files: Object.keys(pinned.fingerprint).map((file) => paths.resolve(root, file)),
 })
 
 /**
@@ -702,22 +723,25 @@ const runPinned = (pinned: PinnedWorkflow, filepath: string, root: string): Eval
  * one function, so the engine runs it without a config, a package or rolldown.
  */
 export const pinnedWorkflowSource = async (
+  paths: Path.Path,
   module: WorkflowModule,
   root: string,
   version: string,
 ): Promise<string> => {
-  const gtd = realpathSync(ownPackage().root) + sep
-  const { code, files } = await bundleConfig(module, {
+  const gtd = nodeSyncIo.realPath(ownPackage(paths).root) + paths.sep
+  const { code, files } = await bundleConfig(paths, module, {
     kind: "pin",
-    shipped: subpathFiles(import.meta.url.endsWith(".ts") ? "source" : "default"),
+    shipped: subpathFiles(paths, 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),
+    origin: paths.relative(root, module.filepath),
     fingerprint: configFingerprint(
+      nodeSyncIo,
+      paths,
       files.filter((file) => !own(file)),
       root,
       module.read ?? readFromDisk,
@@ -743,13 +767,14 @@ const shippedImport = (
 }
 
 const bundleConfig = async (
+  paths: Path.Path,
   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)
+    const hit = moduleCandidates(paths, path).find((candidate) => read?.(candidate) !== undefined)
     if (hit === undefined) return null
     served.add(hit)
     return hit
@@ -760,13 +785,15 @@ const bundleConfig = async (
       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
+      if (/^\.\.?(\/|$)/.test(source)) return fromRead(paths.join(paths.dirname(importer), source))
+      if (!isPackage(paths, source)) return null
       const resolved = await this.resolve(source, importer, { skipSelf: true })
-      return mode.kind === "pin" ? resolved : packageImport(source, resolved)
+      return mode.kind === "pin" ? resolved : packageImport(paths, source, resolved)
     },
     load(id) {
-      if (mode.kind === "pin" && isNativeAddon(id)) throw new Error(nativeAddon(id))
+      if (mode.kind === "pin" && isNativeAddon(paths, id)) {
+        throw new Error(nativeAddon(paths, id))
+      }
       if (id === module.filepath) return module.source
       return served.has(id) ? read!(id) : null
     },
@@ -774,7 +801,7 @@ const bundleConfig = async (
     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),
+          key === "url" ? fileUrl(paths, id) : key === "filename" ? id : paths.dirname(id),
         ),
       )
     },
@@ -783,7 +810,7 @@ const bundleConfig = async (
     input: module.filepath,
     platform: "node",
     plugins: [plugin],
-    external: (id) => isBuiltin(id),
+    external: (id) => NodeRuntime.isBuiltin(id),
     resolve: { extensionAlias: { ".js": [".js", ".ts"], ".mjs": [".mjs", ".mts"] } },
     // Every statement runs, as it would unbundled.
     treeshake: false,
@@ -814,17 +841,23 @@ const bundleConfig = async (
 
 // 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 => {
+const isNativeAddon = (paths: Path.Path, id: string): boolean => {
   if (id.endsWith(".node")) return true
+  const { sep } = paths
   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"))
+  try {
+    return nodeSyncIo.stat(paths.join(root, "binding.gyp")) !== undefined
+  } catch {
+    return false
+  }
 }
 
-const nativeAddon = (path: string): string => {
+const nativeAddon = (paths: Path.Path, path: string): string => {
+  const { sep } = paths
   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]
@@ -834,28 +867,32 @@ const nativeAddon = (path: string): string => {
 // 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 = (
+  paths: Path.Path,
   source: string,
   resolved: { readonly id: string } | null,
 ): string | { readonly id: string; readonly external: true } =>
-  resolved !== null && isEsModule(resolved.id)
+  resolved !== null && isEsModule(paths, resolved.id)
     ? resolved.id
     : { id: resolved?.id ?? source, external: true }
 
-const isEsModule = (path: string): boolean => {
+const isEsModule = (paths: Path.Path, 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"
-    }
+  for (let dir = paths.dirname(path); paths.dirname(dir) !== dir; dir = paths.dirname(dir)) {
+    const source = readFromDisk(paths.join(dir, "package.json"))
+    if (source !== undefined) return (JSON.parse(source) 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)
+const isPackage = (paths: Path.Path, specifier: string): boolean =>
+  !paths.isAbsolute(specifier) && !NodeRuntime.isBuiltin(specifier)
+
+// `toFileUrl` fails only where `pathToFileURL` throws.
+const fileUrl = (paths: Path.Path, path: string): string =>
+  Effect.runSync(paths.toFileUrl(path)).href
 
 // rolldown reports each error with a colored code frame; a diagnostic takes
 // its headline and location.
@@ -863,7 +900,7 @@ 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 plain = NodeRuntime.stripVTControlCharacters(message)
     const at = /\[ (.+:\d+:\d+) \]/.exec(plain)?.[1]
     const headline = plain.split("\n")[0]!
     return at === undefined ? headline : `${headline} (${at})`
@@ -874,7 +911,8 @@ const bundleError = (e: unknown): unknown => {
 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 requireRolldown = (): Rolldown =>
+  NodeRuntime.createRequire(import.meta.url)("rolldown") as Rolldown
 
 const isWorkflow = (value: unknown): boolean =>
   markedOptions(value) !== undefined || isFactoryWorkflow(value)
@@ -1119,7 +1157,7 @@ interface ConfigServiceOperations {
   readonly load: Effect.Effect<
     ConfigOperations,
     Error,
-    Narrator | Workspace | Host | ConfigDiscovery
+    Narrator | Workspace | Host | Path.Path | ConfigDiscovery
   >
 }
 

package/src/workflow/pin.test.ts

@@ -2,10 +2,11 @@ import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "nod
 import { isBuiltin } from "node:module"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { Effect, Exit } from "effect"
+import { Effect, Exit, Layer } from "effect"
 import { parseAst } from "rolldown/parseAst"
 import { afterEach, describe, expect, it } from "vitest"
 import { PIN_KEY } from "../install/index.js"
+import { NodeServices } from "../platform/index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
 import { ConfigDiscovery, ConfigService } from "./index.js"
 import { EngineCore, pin, readPin } from "./pin.js"
@@ -16,7 +17,7 @@ afterEach(() => {
 
 // A pin must run with nothing installed: the engine imports Node and nothing else.
 describe.each([
-  ["live", EngineCore.Live],
+  ["live", EngineCore.Live.pipe(Layer.provide(NodeServices.layer))],
   ["in memory", testLayers(new InMemRepo())],
 ])("EngineCore (%s)", (_, layer) => {
   const source = () =>

package/src/workflow/pin.ts

@@ -1,8 +1,5 @@
-import { readFileSync } from "node:fs"
-import { join } from "node:path"
-import { gunzipSync, gzipSync } from "node:zlib"
-import { Context, Effect, Layer } from "effect"
-import { GtdError } from "../platform/index.js"
+import { Context, Effect, Layer, Path } from "effect"
+import { GtdError, NodeRuntime, nodeSyncIo } from "../platform/index.js"
 import { ownPackage, pinnedWorkflowSource } from "./load.js"
 import type { WorkflowModule } from "./discovery.js"
 
@@ -22,12 +19,20 @@ export class EngineCore extends Context.Service<
       source: Effect.suspend(() => {
         const file = path()
         return Effect.try({
-          try: () => readFileSync(file, "utf8"),
+          try: () => {
+            const source = nodeSyncIo.readText(file)
+            if (source === undefined) throw new Error("absent")
+            return source
+          },
           catch: () => new GtdError(`gtd bundle: no engine at ${file} — build gtd first`),
         })
       }),
     })
-  static Live = EngineCore.layer(() => join(ownPackage().root, "dist", "gtd.core.mjs"))
+  static Live = Layer.unwrap(
+    Effect.map(Path.Path, (path) =>
+      EngineCore.layer(() => path.join(ownPackage(path).root, "dist", "gtd.core.mjs")),
+    ),
+  )
 }
 
 /**
@@ -39,11 +44,12 @@ export const pin = (
   module: WorkflowModule,
   root: string,
   version: string,
-): Effect.Effect<Uint8Array, Error, EngineCore> =>
+): Effect.Effect<Uint8Array, Error, EngineCore | Path.Path> =>
   Effect.gen(function* () {
     const core = yield* (yield* EngineCore).source
+    const path = yield* Path.Path
     const workflow = yield* Effect.tryPromise({
-      try: () => pinnedWorkflowSource(module, root, version),
+      try: () => pinnedWorkflowSource(path, module, root, version),
       catch: (e) =>
         new GtdError(
           `gtd bundle: ${module.filepath}: ${e instanceof Error ? e.message : String(e)}`,
@@ -53,7 +59,7 @@ export const pin = (
     const source = workflow + core.replace(/^#!.*\n/, "")
     return Buffer.concat([
       Buffer.from(`gtdpin ${PIN_FORMAT} gtd ${version}\n`),
-      gzipSync(source, { level: 9 }),
+      NodeRuntime.gzip(source),
     ])
   })
 
@@ -75,6 +81,6 @@ export const readPin = (
   if (header === undefined) throw new Error("not a gtd pin")
   return {
     ...header,
-    source: gunzipSync(bytes.subarray(bytes.indexOf(0x0a) + 1)).toString("utf8"),
+    source: NodeRuntime.gunzip(bytes.subarray(bytes.indexOf(0x0a) + 1)),
   }
 }