@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/dist/internal/run-store.js

@@ -1,7 +1,21 @@
 // src/internal/run-store.ts
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
 import { constants } from "node:fs";
-import { access, chmod as chmod2, lstat, mkdir as mkdir2, mkdtemp, readFile, readdir, readlink, rename as rename2, rm as rm2, symlink, utimes, writeFile as writeFile2 } from "node:fs/promises";
+import {
+  access,
+  chmod as chmod2,
+  lstat,
+  mkdir as mkdir2,
+  mkdtemp,
+  readFile,
+  readdir,
+  readlink,
+  rename as rename2,
+  rm as rm2,
+  symlink,
+  utimes,
+  writeFile as writeFile2
+} from "node:fs/promises";
 import { dirname as dirname2, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { gunzip, gzip } from "node:zlib";
@@ -76,7 +90,10 @@ var NornRunStore = class _NornRunStore {
   }
   async snapshotCurrent(message) {
     const previous = await this.readCheckpointHistory();
-    const checkpoint = this.createCheckpoint(message, previous.checkpoints.length + 1);
+    const checkpoint = this.createCheckpoint(
+      message,
+      previous.checkpoints.length + 1
+    );
     const checkpoints = [...previous.checkpoints, checkpoint];
     await this.createSnapshot(checkpoint, checkpoints);
     await writeJsonAtomically(this.checkpointsPath, checkpoints);
@@ -84,19 +101,28 @@ var NornRunStore = class _NornRunStore {
       await writeTextAtomically(this.currentRefPath, `${checkpoint.id}
 `);
     } catch (error) {
-      if (previous.content === void 0) await rm2(this.checkpointsPath, { force: true });
+      if (previous.content === void 0)
+        await rm2(this.checkpointsPath, { force: true });
       else await writeTextAtomically(this.checkpointsPath, previous.content);
       throw error;
     }
     return checkpoint;
   }
   async restoreSnapshot(ref, prepare) {
-    const checkpoint = (await this.listCheckpoints()).find((entry) => entry.id === ref);
+    const checkpoint = (await this.listCheckpoints()).find(
+      (entry) => entry.id === ref
+    );
     if (!checkpoint) throw new Error(`Unknown active run checkpoint: ${ref}`);
-    await this.restoreSnapshotManifest(await this.readSnapshot(checkpoint.id), prepare);
+    await this.restoreSnapshotManifest(
+      await this.readSnapshot(checkpoint.id),
+      prepare
+    );
   }
   async restoreCurrentSnapshot() {
-    await this.restoreSnapshotManifest(await this.readSnapshot(await this.currentSnapshotRef()), void 0);
+    await this.restoreSnapshotManifest(
+      await this.readSnapshot(await this.currentSnapshotRef()),
+      void 0
+    );
   }
   async listCheckpoints() {
     return (await this.readCheckpointHistory()).checkpoints;
@@ -105,10 +131,12 @@ var NornRunStore = class _NornRunStore {
     try {
       const content = await readFile(this.checkpointsPath, "utf8");
       const checkpoints = parseNornRunCheckpoints(JSON.parse(content));
-      for (const checkpoint of checkpoints) this.assertCheckpointPathMatchesId(checkpoint);
+      for (const checkpoint of checkpoints)
+        this.assertCheckpointPathMatchesId(checkpoint);
       return { checkpoints, content };
     } catch (error) {
-      if (isNodeError(error) && error.code === "ENOENT") return { checkpoints: [] };
+      if (isNodeError(error) && error.code === "ENOENT")
+        return { checkpoints: [] };
       throw error;
     }
   }
@@ -131,15 +159,33 @@ var NornRunStore = class _NornRunStore {
   }
   createCheckpoint(message, index) {
     const id = `cp_${randomUUID2().replaceAll("-", "")}`;
-    return { id, path: this.snapshotRelativePath(id), index, message, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    return {
+      id,
+      path: this.snapshotRelativePath(id),
+      index,
+      message,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
   async createSnapshot(checkpoint, checkpoints) {
-    const entries = (await this.snapshotEntries(this.currentRoot)).filter((entry) => entry.path !== CHECKPOINTS_FILE_NAME);
-    const historyBytes = Buffer.from(`${JSON.stringify(checkpoints, null, 2)}
-`);
+    const entries = (await this.snapshotEntries(this.currentRoot)).filter(
+      (entry) => entry.path !== CHECKPOINTS_FILE_NAME
+    );
+    const historyBytes = Buffer.from(
+      `${JSON.stringify(checkpoints, null, 2)}
+`
+    );
     const historyHash = hashBuffer(historyBytes);
     await this.storeObject(historyHash, historyBytes);
-    entries.push({ path: CHECKPOINTS_FILE_NAME, type: "file", sha256: historyHash, size: historyBytes.length, mode: 384, mtimeMs: Date.now(), compression: "gzip" });
+    entries.push({
+      path: CHECKPOINTS_FILE_NAME,
+      type: "file",
+      sha256: historyHash,
+      size: historyBytes.length,
+      mode: 384,
+      mtimeMs: Date.now(),
+      compression: "gzip"
+    });
     entries.sort((left, right) => left.path.localeCompare(right.path));
     const snapshot = {
       version: SNAPSHOT_VERSION,
@@ -161,22 +207,45 @@ var NornRunStore = class _NornRunStore {
   async collectSnapshotEntries(absolutePath, snapshotPath, entries) {
     const stat2 = await lstat(absolutePath);
     if (stat2.isDirectory()) {
-      if (snapshotPath.length > 0) entries.push({ path: snapshotPath, type: "directory", mode: stat2.mode });
+      if (snapshotPath.length > 0)
+        entries.push({
+          path: snapshotPath,
+          type: "directory",
+          mode: stat2.mode
+        });
       const children = await readdir(absolutePath, { withFileTypes: true });
-      for (const child of children.sort((left, right) => left.name.localeCompare(right.name))) {
-        await this.collectSnapshotEntries(join(absolutePath, child.name), joinSnapshotPath(snapshotPath, child.name), entries);
+      for (const child of children.sort(
+        (left, right) => left.name.localeCompare(right.name)
+      )) {
+        await this.collectSnapshotEntries(
+          join(absolutePath, child.name),
+          joinSnapshotPath(snapshotPath, child.name),
+          entries
+        );
       }
       return;
     }
     if (stat2.isSymbolicLink()) {
-      entries.push({ path: snapshotPath, type: "symlink", target: await readlink(absolutePath) });
+      entries.push({
+        path: snapshotPath,
+        type: "symlink",
+        target: await readlink(absolutePath)
+      });
       return;
     }
     if (!stat2.isFile()) return;
     const bytes = await readFile(absolutePath);
     const sha256 = hashBuffer(bytes);
     await this.storeObject(sha256, bytes);
-    entries.push({ path: snapshotPath, type: "file", sha256, size: stat2.size, mode: stat2.mode, mtimeMs: stat2.mtimeMs, compression: "gzip" });
+    entries.push({
+      path: snapshotPath,
+      type: "file",
+      sha256,
+      size: stat2.size,
+      mode: stat2.mode,
+      mtimeMs: stat2.mtimeMs,
+      compression: "gzip"
+    });
   }
   async storeObject(sha256, bytes) {
     const path = this.objectPath(sha256);
@@ -214,25 +283,34 @@ var NornRunStore = class _NornRunStore {
         await rename2(previousCurrent, this.currentRoot);
         throw error;
       }
-      await rm2(previousCurrent, { recursive: true, force: true }).catch(() => void 0);
+      await rm2(previousCurrent, { recursive: true, force: true }).catch(
+        () => void 0
+      );
     } finally {
-      await rm2(stagedRunRoot, { recursive: true, force: true }).catch(() => void 0);
+      await rm2(stagedRunRoot, { recursive: true, force: true }).catch(
+        () => void 0
+      );
     }
   }
   async materializeSnapshot(snapshot, destination) {
     const entriesByPath = /* @__PURE__ */ new Map();
     for (const entry of snapshot.entries) {
       this.materializedPath(destination, entry.path);
-      if (entriesByPath.has(entry.path)) throw new Error(`Duplicate snapshot path: ${entry.path}`);
+      if (entriesByPath.has(entry.path))
+        throw new Error(`Duplicate snapshot path: ${entry.path}`);
       entriesByPath.set(entry.path, entry);
     }
     for (const entry of snapshot.entries) {
       let parent = dirname2(entry.path);
       while (parent !== ".") {
-        if (entriesByPath.get(parent)?.type !== "directory") throw new Error(`Snapshot parent is not a directory: ${parent}`);
+        if (entriesByPath.get(parent)?.type !== "directory")
+          throw new Error(`Snapshot parent is not a directory: ${parent}`);
         parent = dirname2(parent);
       }
-      if (entry.type === "directory") await mkdir2(this.materializedPath(destination, entry.path), { recursive: true });
+      if (entry.type === "directory")
+        await mkdir2(this.materializedPath(destination, entry.path), {
+          recursive: true
+        });
     }
     for (const entry of snapshot.entries) {
       if (entry.type === "directory") continue;
@@ -241,26 +319,36 @@ var NornRunStore = class _NornRunStore {
         await symlink(entry.target, path);
         continue;
       }
-      const bytes = await gunzipBuffer(await readFile(this.objectPath(entry.sha256)));
+      const bytes = await gunzipBuffer(
+        await readFile(this.objectPath(entry.sha256))
+      );
       const actualSha256 = hashBuffer(bytes);
-      if (actualSha256 !== entry.sha256) throw new Error(`CAS object checksum mismatch: ${entry.sha256}`);
+      if (actualSha256 !== entry.sha256)
+        throw new Error(`CAS object checksum mismatch: ${entry.sha256}`);
       await writeFile2(path, bytes);
       await chmod2(path, entry.mode);
       await utimes(path, new Date(entry.mtimeMs), new Date(entry.mtimeMs));
     }
     for (const entry of [...snapshot.entries].reverse()) {
-      if (entry.type === "directory") await chmod2(this.materializedPath(destination, entry.path), entry.mode);
+      if (entry.type === "directory")
+        await chmod2(this.materializedPath(destination, entry.path), entry.mode);
     }
   }
   materializedPath(destination, snapshotPath) {
-    if (snapshotPath.length === 0 || isAbsolute(snapshotPath) || snapshotPath.split(/[\\/]/).some((part) => part === ".." || part === "." || part === "")) throw new Error(`Invalid snapshot path: ${snapshotPath}`);
+    if (snapshotPath.length === 0 || isAbsolute(snapshotPath) || snapshotPath.split(/[\\/]/).some((part) => part === ".." || part === "." || part === ""))
+      throw new Error(`Invalid snapshot path: ${snapshotPath}`);
     const path = resolve(destination, ...snapshotPath.split("/"));
     const pathFromCurrent = relative(destination, path);
-    if (pathFromCurrent === ".." || pathFromCurrent.startsWith(`..${sep}`)) throw new Error(`Snapshot path escapes current checkout: ${snapshotPath}`);
+    if (pathFromCurrent === ".." || pathFromCurrent.startsWith(`..${sep}`))
+      throw new Error(
+        `Snapshot path escapes current checkout: ${snapshotPath}`
+      );
     return path;
   }
   async readSnapshot(id) {
-    return parseRunSnapshotManifest(JSON.parse(await readFile(this.snapshotPath(id), "utf8")));
+    return parseRunSnapshotManifest(
+      JSON.parse(await readFile(this.snapshotPath(id), "utf8"))
+    );
   }
   snapshotPath(id) {
     return join(this.snapshotsRoot, `${id}.json`);
@@ -270,10 +358,18 @@ var NornRunStore = class _NornRunStore {
   }
   assertCheckpointPathMatchesId(checkpoint) {
     const expectedPath = this.snapshotRelativePath(checkpoint.id);
-    if (checkpoint.path !== expectedPath) throw new Error(`Run checkpoint path does not match id: ${checkpoint.id}`);
+    if (checkpoint.path !== expectedPath)
+      throw new Error(
+        `Run checkpoint path does not match id: ${checkpoint.id}`
+      );
   }
   objectPath(sha256) {
-    return join(this.objectsRoot, sha256.slice(0, 2), sha256.slice(2, 4), `${sha256}.gz`);
+    return join(
+      this.objectsRoot,
+      sha256.slice(0, 2),
+      sha256.slice(2, 4),
+      `${sha256}.gz`
+    );
   }
 };
 function hashBuffer(bytes) {
@@ -283,14 +379,23 @@ function joinSnapshotPath(parent, child) {
   return parent.length === 0 ? child : `${parent}/${child}`;
 }
 function parseRunSnapshotManifest(value) {
-  if (!value || typeof value !== "object") throw new Error("Invalid run snapshot manifest");
+  if (!value || typeof value !== "object")
+    throw new Error("Invalid run snapshot manifest");
   const snapshot = value;
-  if (snapshot.version !== SNAPSHOT_VERSION) throw new Error(`Unsupported run snapshot version: ${String(snapshot.version)}`);
-  if (typeof snapshot.id !== "string" || snapshot.id.length === 0) throw new Error("Invalid run snapshot id");
-  if (typeof snapshot.index !== "number" || !Number.isInteger(snapshot.index) || snapshot.index < 1) throw new Error("Invalid run snapshot index");
-  if (typeof snapshot.message !== "string") throw new Error("Invalid run snapshot message");
-  if (typeof snapshot.createdAt !== "string") throw new Error("Invalid run snapshot timestamp");
-  if (!Array.isArray(snapshot.entries)) throw new Error("Invalid run snapshot entries");
+  if (snapshot.version !== SNAPSHOT_VERSION)
+    throw new Error(
+      `Unsupported run snapshot version: ${String(snapshot.version)}`
+    );
+  if (typeof snapshot.id !== "string" || snapshot.id.length === 0)
+    throw new Error("Invalid run snapshot id");
+  if (typeof snapshot.index !== "number" || !Number.isInteger(snapshot.index) || snapshot.index < 1)
+    throw new Error("Invalid run snapshot index");
+  if (typeof snapshot.message !== "string")
+    throw new Error("Invalid run snapshot message");
+  if (typeof snapshot.createdAt !== "string")
+    throw new Error("Invalid run snapshot timestamp");
+  if (!Array.isArray(snapshot.entries))
+    throw new Error("Invalid run snapshot entries");
   return snapshot;
 }
 function parseNornRunCheckpoints(value) {
@@ -298,14 +403,21 @@ function parseNornRunCheckpoints(value) {
   return value.map(parseNornRunCheckpoint);
 }
 function parseNornRunCheckpoint(value) {
-  if (!value || typeof value !== "object") throw new Error("Invalid run checkpoint");
+  if (!value || typeof value !== "object")
+    throw new Error("Invalid run checkpoint");
   const checkpoint = value;
-  if (typeof checkpoint.id !== "string" || checkpoint.id.length === 0) throw new Error("Invalid run checkpoint id");
-  if (typeof checkpoint.path !== "string" || checkpoint.path.length === 0) throw new Error("Invalid run checkpoint path");
-  if (checkpoint.path.split(/[\\/]/).includes("..") || resolve(checkpoint.path) === checkpoint.path) throw new Error(`Invalid run checkpoint path: ${checkpoint.path}`);
-  if (typeof checkpoint.index !== "number" || !Number.isInteger(checkpoint.index) || checkpoint.index < 1) throw new Error("Invalid run checkpoint index");
-  if (typeof checkpoint.message !== "string") throw new Error("Invalid run checkpoint message");
-  if (typeof checkpoint.createdAt !== "string") throw new Error("Invalid run checkpoint timestamp");
+  if (typeof checkpoint.id !== "string" || checkpoint.id.length === 0)
+    throw new Error("Invalid run checkpoint id");
+  if (typeof checkpoint.path !== "string" || checkpoint.path.length === 0)
+    throw new Error("Invalid run checkpoint path");
+  if (checkpoint.path.split(/[\\/]/).includes("..") || resolve(checkpoint.path) === checkpoint.path)
+    throw new Error(`Invalid run checkpoint path: ${checkpoint.path}`);
+  if (typeof checkpoint.index !== "number" || !Number.isInteger(checkpoint.index) || checkpoint.index < 1)
+    throw new Error("Invalid run checkpoint index");
+  if (typeof checkpoint.message !== "string")
+    throw new Error("Invalid run checkpoint message");
+  if (typeof checkpoint.createdAt !== "string")
+    throw new Error("Invalid run checkpoint timestamp");
   return checkpoint;
 }
 export {

package/dist/internal/worker-directory.js

@@ -16,8 +16,12 @@ async function prepareRunWorkerDirectory(runRoot) {
     if (!isNodeError(error) || error.code !== "EEXIST") throw error;
   }
   const metadata = await lstat(directory);
-  if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error(`Run worker cwd must be a directory, not a symlink: ${directory}`);
-  if ((await readdir(directory)).length !== 0) throw new Error(`Run worker cwd must be empty: ${directory}`);
+  if (!metadata.isDirectory() || metadata.isSymbolicLink())
+    throw new Error(
+      `Run worker cwd must be a directory, not a symlink: ${directory}`
+    );
+  if ((await readdir(directory)).length !== 0)
+    throw new Error(`Run worker cwd must be empty: ${directory}`);
   await chmod(directory, 365);
   return directory;
 }

package/dist/internal/workflow-registry.js

@@ -1,25 +1,60 @@
 // src/internal/workflow-registry.ts
-import { isWorkflowComplete, isWorkflowDeclaration, isWorkflowFail, isWorkflowNext } from "@vimhead.dev/norn";
-import { assertWorkflowMetadata, inspectSchema, isPlainObject, schemaShape, schemaType, unwrapSchema } from "@vimhead.dev/norn/schema";
+import {
+  isWorkflowComplete,
+  isWorkflowDeclaration,
+  isWorkflowFail,
+  isWorkflowNext
+} from "@vimhead.dev/norn";
+import {
+  assertWorkflowMetadata,
+  inspectSchema,
+  isPlainObject,
+  schemaShape,
+  schemaType,
+  unwrapSchema
+} from "@vimhead.dev/norn/schema";
 import { Value } from "typebox/value";
 function decodeConfiguration(input) {
   if (!input.schema) {
-    if (input.value !== void 0) throw new Error(`Norn config provided without config schema: ${input.key}`);
-    return { key: input.key, schema: void 0, input: void 0, value: void 0 };
+    if (input.value !== void 0)
+      throw new Error(
+        `Norn config provided without config schema: ${input.key}`
+      );
+    return {
+      key: input.key,
+      schema: void 0,
+      input: void 0,
+      value: void 0
+    };
   }
   const value = input.value === void 0 && schemaType(unwrapSchema(input.schema)) === "object" ? {} : input.value;
-  return { key: input.key, schema: input.schema, input: value, value: Value.Decode(input.schema, value) };
+  return {
+    key: input.key,
+    schema: input.schema,
+    input: value,
+    value: Value.Decode(input.schema, value)
+  };
 }
 function assertCompatibleConfigurationOwners(workflows) {
   const owners = /* @__PURE__ */ new Map();
   for (const workflow of workflows) {
     for (const owner of [
       { key: workflow.id, kind: "workflow", definition: workflow },
-      ...workflow.scope ? [{ key: workflow.scope.id, kind: "scope", definition: workflow.scope }] : []
+      ...workflow.scope ? [
+        {
+          key: workflow.scope.id,
+          kind: "scope",
+          definition: workflow.scope
+        }
+      ] : []
     ]) {
       const previous = owners.get(owner.key);
-      if (previous && previous.kind !== owner.kind) throw new Error(`Ambiguous configuration key: ${owner.key}`);
-      if (previous && owner.kind === "scope" && previous.definition !== owner.definition) throw new Error(`Duplicate workflow scope id: ${owner.key}; import one shared scope definition`);
+      if (previous && previous.kind !== owner.kind)
+        throw new Error(`Ambiguous configuration key: ${owner.key}`);
+      if (previous && owner.kind === "scope" && previous.definition !== owner.definition)
+        throw new Error(
+          `Duplicate workflow scope id: ${owner.key}; import one shared scope definition`
+        );
       owners.set(owner.key, owner);
     }
   }
@@ -30,25 +65,40 @@ var NornWorkflowRegistry = class {
   register(input) {
     const { workflow, config, source } = input;
     assertWorkflowDefinition(workflow);
-    if (this.entries.has(workflow.id)) throw new Error(`Workflow already registered: ${workflow.id}`);
-    assertCompatibleConfigurationOwners([...this.sortedEntries().map((entry2) => entry2.workflow), workflow]);
+    if (this.entries.has(workflow.id))
+      throw new Error(`Workflow already registered: ${workflow.id}`);
+    assertCompatibleConfigurationOwners([
+      ...this.sortedEntries().map((entry2) => entry2.workflow),
+      workflow
+    ]);
     const entry = {
       workflow,
       source,
       scopeId: workflow.scope?.id,
-      configuration: decodeConfiguration({ key: workflow.id, schema: workflow.config, value: configurationInput(config, workflow.id) })
+      configuration: decodeConfiguration({
+        key: workflow.id,
+        schema: workflow.config,
+        value: configurationInput(config, workflow.id)
+      })
     };
     if (workflow.scope && !this.scopes.has(workflow.scope.id)) {
       this.scopes.set(workflow.scope.id, {
         definition: workflow.scope,
-        configuration: decodeConfiguration({ key: workflow.scope.id, schema: workflow.scope.config, value: configurationInput(config, workflow.scope.id) })
+        configuration: decodeConfiguration({
+          key: workflow.scope.id,
+          schema: workflow.scope.config,
+          value: configurationInput(config, workflow.scope.id)
+        })
       });
     }
     this.entries.set(workflow.id, entry);
     return () => {
       if (this.entries.get(workflow.id) !== entry) return;
       this.entries.delete(workflow.id);
-      if (entry.scopeId && ![...this.entries.values()].some((other) => other.scopeId === entry.scopeId)) this.scopes.delete(entry.scopeId);
+      if (entry.scopeId && ![...this.entries.values()].some(
+        (other) => other.scopeId === entry.scopeId
+      ))
+        this.scopes.delete(entry.scopeId);
     };
   }
   list(options = {}) {
@@ -71,12 +121,25 @@ var NornWorkflowRegistry = class {
   }
   configurationInfos() {
     return [
-      ...this.sortedEntries().map((entry) => ({ configuration: entry.configuration, scopeId: null })),
-      ...[...this.scopes.values()].map((scope) => ({ configuration: scope.configuration, scopeId: scope.definition.id }))
-    ].map(({ configuration, scopeId }) => ({ key: configuration.key, scopeId, configSchema: configuration.schema ? inspectSchema(configuration.schema) : null, config: configuration.value }));
+      ...this.sortedEntries().map((entry) => ({
+        configuration: entry.configuration,
+        scopeId: null
+      })),
+      ...[...this.scopes.values()].map((scope) => ({
+        configuration: scope.configuration,
+        scopeId: scope.definition.id
+      }))
+    ].map(({ configuration, scopeId }) => ({
+      key: configuration.key,
+      scopeId,
+      configSchema: configuration.schema ? inspectSchema(configuration.schema) : null,
+      config: configuration.value
+    }));
   }
   launchableEntries() {
-    return this.sortedEntries().filter(({ workflow }) => workflow.entrypoint !== false);
+    return this.sortedEntries().filter(
+      ({ workflow }) => workflow.entrypoint !== false
+    );
   }
   workflowById(workflowId) {
     return this.entries.get(workflowId)?.workflow;
@@ -84,19 +147,27 @@ var NornWorkflowRegistry = class {
   async describeGate(input) {
     const { workflow } = input;
     const entry = this.requireEntry(workflow.id);
-    if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
+    if (!workflow.gate)
+      throw new Error(`Workflow is not gated: ${workflow.id}`);
     const context = this.createExecutionContext({ ...input, entry });
     const description = await entry.workflow.gate?.describe?.(context) ?? workflow.id;
-    if (typeof description !== "string" || description.trim().length === 0) throw new Error(`Workflow gate description must not be empty: ${workflow.id}`);
+    if (typeof description !== "string" || description.trim().length === 0)
+      throw new Error(
+        `Workflow gate description must not be empty: ${workflow.id}`
+      );
     return description.trim();
   }
   async execute(input) {
     const { workflow } = input;
     const entry = this.requireEntry(workflow.id);
-    const result = await entry.workflow.execute(this.createExecutionContext({ ...input, entry }));
+    const result = await entry.workflow.execute(
+      this.createExecutionContext({ ...input, entry })
+    );
     if (isWorkflowNext(result)) return result;
-    if (isWorkflowComplete(result)) return { type: "complete", workflow, metadata: result.metadata };
-    if (isWorkflowFail(result)) return { type: "fail", workflow, metadata: result.metadata };
+    if (isWorkflowComplete(result))
+      return { type: "complete", workflow, metadata: result.metadata };
+    if (isWorkflowFail(result))
+      return { type: "fail", workflow, metadata: result.metadata };
     throw new Error(`Workflow returned invalid control result: ${workflow.id}`);
   }
   createExecutionContext(input) {
@@ -105,7 +176,12 @@ var NornWorkflowRegistry = class {
     return {
       args: Value.Decode(entry.workflow.args, input.args),
       config: parseExecutionConfig(entry.configuration, configOverride),
-      ...scope ? { scope: { id: scope.definition.id, config: parseExecutionConfig(scope.configuration, configOverride) } } : {},
+      ...scope ? {
+        scope: {
+          id: scope.definition.id,
+          config: parseExecutionConfig(scope.configuration, configOverride)
+        }
+      } : {},
       paths,
       run: execution.run,
       agents: execution.agents,
@@ -119,39 +195,54 @@ var NornWorkflowRegistry = class {
     return entry;
   }
   sortedEntries() {
-    return [...this.entries.values()].sort((left, right) => left.workflow.id.localeCompare(right.workflow.id));
+    return [...this.entries.values()].sort(
+      (left, right) => left.workflow.id.localeCompare(right.workflow.id)
+    );
   }
 };
 function configurationInput(config, key) {
   return Object.hasOwn(config, key) ? config[key] : void 0;
 }
 function parseExecutionConfig(configuration, overrides) {
-  if (overrides !== void 0 && !isPlainObject(overrides)) throw new Error("Run config override must be an object keyed by workflow or scope id");
+  if (overrides !== void 0 && !isPlainObject(overrides))
+    throw new Error(
+      "Run config override must be an object keyed by workflow or scope id"
+    );
   const override = overrides ? configurationInput(overrides, configuration.key) : void 0;
   if (override === void 0) return configuration.value;
-  if (!configuration.schema) throw new Error(`Run config override provided without config schema: ${configuration.key}`);
+  if (!configuration.schema)
+    throw new Error(
+      `Run config override provided without config schema: ${configuration.key}`
+    );
   const input = isPlainObject(configuration.input) && isPlainObject(override) ? deepMerge(configuration.input, override) : override;
   return Value.Decode(configuration.schema, input);
 }
 function deepMerge(base, override) {
   const result = { ...base };
-  for (const [key, value] of Object.entries(override)) result[key] = isPlainObject(result[key]) && isPlainObject(value) ? deepMerge(result[key], value) : value;
+  for (const [key, value] of Object.entries(override))
+    result[key] = isPlainObject(result[key]) && isPlainObject(value) ? deepMerge(result[key], value) : value;
   return result;
 }
 function assertWorkflowDefinition(workflow) {
   assertWorkflowMetadata(workflow);
-  if (!isWorkflowDeclaration(workflow)) throw new Error("Invalid workflow definition");
+  if (!isWorkflowDeclaration(workflow))
+    throw new Error("Invalid workflow definition");
   assertGateWorkflow(workflow);
 }
 function assertGateWorkflow(workflow) {
   if (!workflow.gate) return;
-  if (workflow.gate.enabled !== true) throw new Error(`Workflow gate must be enabled with true: ${workflow.id}`);
-  if (workflow.gate.describe !== void 0 && typeof workflow.gate.describe !== "function") throw new Error(`Invalid gate description callback: ${workflow.id}`);
+  if (workflow.gate.enabled !== true)
+    throw new Error(`Workflow gate must be enabled with true: ${workflow.id}`);
+  if (workflow.gate.describe !== void 0 && typeof workflow.gate.describe !== "function")
+    throw new Error(`Invalid gate description callback: ${workflow.id}`);
   if (!workflow.gate.fields) return;
   const argsSchema = unwrapSchema(workflow.args);
-  if (schemaType(argsSchema) !== "object") throw new Error(`Workflow gate fields require object args: ${workflow.id}`);
+  if (schemaType(argsSchema) !== "object")
+    throw new Error(`Workflow gate fields require object args: ${workflow.id}`);
   const shape = schemaShape(argsSchema);
-  for (const field of workflow.gate.fields) if (!Object.hasOwn(shape, field)) throw new Error(`Unknown workflow gate field ${field}: ${workflow.id}`);
+  for (const field of workflow.gate.fields)
+    if (!Object.hasOwn(shape, field))
+      throw new Error(`Unknown workflow gate field ${field}: ${workflow.id}`);
 }
 function workflowInfo(entry) {
   return {

package/dist/internal/working-directory.js

@@ -1,7 +1,8 @@
 // src/internal/working-directory.ts
 import { isAbsolute, resolve } from "node:path";
 function requireAbsoluteWorkingDirectory(cwd) {
-  if (typeof cwd !== "string" || !isAbsolute(cwd)) throw new Error("Working directory (cwd) must be an absolute path");
+  if (typeof cwd !== "string" || !isAbsolute(cwd))
+    throw new Error("Working directory (cwd) must be an absolute path");
   return resolve(cwd);
 }
 export {