@olivervea/pipelines 2.0.0-beta.18 → 2.0.0-beta.19

package/src/harness/main.ts

@@ -2,24 +2,39 @@
 //   describe [--sentinels]   → manifest (canonical JSON) on stdout
 //   run <step>               → $OLVE_DIR/input.json → handler → $OLVE_DIR/work/output.json (+ result upload)
 //   map-trigger <trigger>    → $OLVE_DIR/input.json (event) → pipeline input → $OLVE_DIR/work/output.json
-import { mkdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { isImplementation } from "../core/handlers.ts";
-import { configRefPath, isConfigRef, unionAt } from "../core/config.ts";
-import type { AnyStep } from "../core/steps.ts";
-import type { WebhookEvent } from "../core/webhooks.ts";
-import { pipelineData, type PipelineData, type StageNode } from "../builder/pipeline.ts";
-import { createCtx, formatLog } from "../ctx/index.ts";
-import { DescribeError, describePipeline, manifestText } from "../describe/describe.ts";
-import type { HarnessInfo } from "../util/handler-hash.ts";
-import { callbackUrlsFromEnv, ENV, paths, runInfoFromEnv } from "./env.ts";
-import { EXIT } from "./exit.ts";
-import { executeStep, type Envelope, type Execution, type StepFunction } from "./execute.ts";
-import { MANIFEST_BEGIN, MANIFEST_END, packResult, removeStale, sentinelBlock, uploadFile, writeEnvelope } from "./result.ts";
-import { formatIssues, parseStrict } from "./validate.ts";
+import { mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isImplementation } from '../core/handlers.ts';
+import { configRefPath, isConfigRef, unionAt } from '../core/config.ts';
+import type { AnyStep } from '../core/steps.ts';
+import type { WebhookEvent } from '../core/webhooks.ts';
+import { pipelineData, type PipelineData, type StageNode } from '../builder/pipeline.ts';
+import { createCtx, formatLog } from '../ctx/index.ts';
+import { DescribeError, describePipeline, manifestText } from '../describe/describe.ts';
+import type { HarnessInfo } from '../util/handler-hash.ts';
+import { callbackUrlsFromEnv, ENV, paths, runInfoFromEnv } from './env.ts';
+import { EXIT } from './exit.ts';
+import {
+  executeStep,
+  type Envelope,
+  type Execution,
+  type StepFunction,
+} from './execute.ts';
+import {
+  MANIFEST_BEGIN,
+  MANIFEST_END,
+  packResult,
+  removeStale,
+  sentinelBlock,
+  uploadFile,
+  writeEnvelope,
+} from './result.ts';
+import { formatIssues, parseStrict } from './validate.ts';
 
 /** step name → lazy import of `handlers/<name>.ts`. Literal import() paths so Bun bundles them. */
-export type HandlerRegistry = Readonly<Record<string, () => Promise<{ default: unknown }>>>;
+export type HandlerRegistry = Readonly<
+  Record<string, () => Promise<{ default: unknown }>>
+>;
 
 export interface HarnessConfig {
   /** Default export of pipeline.ts. */
@@ -41,11 +56,12 @@ export const defaultIO: HarnessIO = {
     await Bun.write(Bun.stdout, text);
   },
   stderr: (line) => {
-    process.stderr.write(line.endsWith("\n") ? line : line + "\n");
+    process.stderr.write(line.endsWith('\n') ? line : line + '\n');
   },
 };
 
-const USAGE = "usage: step describe [--sentinels] | step run <step> | step map-trigger <trigger>";
+const USAGE =
+  'usage: step describe [--sentinels] | step run <step> | step map-trigger <trigger>';
 
 export function allSteps(data: PipelineData): AnyStep[] {
   const out: AnyStep[] = [];
@@ -58,12 +74,17 @@ export function stepsWithCases(data: PipelineData): { step: AnyStep; cases: stri
   const out: { step: AnyStep; cases: string[] }[] = [];
   const walk = (nodes: readonly StageNode[], cases: string[]) => {
     for (const n of nodes) {
-      if (n.kind === "stage") out.push(...n.steps.map((s) => ({ step: s.step, cases })));
-      else if (n.kind === "when") walk(n.nodes, cases);
+      if (n.kind === 'stage') out.push(...n.steps.map((s) => ({ step: s.step, cases })));
+      else if (n.kind === 'when') walk(n.nodes, cases);
       else {
         const union = isConfigRef(n.on) ? unionAt(n.on) : undefined;
         for (const [value, inner] of Object.entries(n.cases))
-          walk(inner, union ? [...cases, `${configRefPath(n.on)}.${union.discriminator}=${value}`] : cases);
+          walk(
+            inner,
+            union
+              ? [...cases, `${configRefPath(n.on)}.${union.discriminator}=${value}`]
+              : cases,
+          );
       }
     }
   };
@@ -73,9 +94,15 @@ export function stepsWithCases(data: PipelineData): { step: AnyStep; cases: stri
 }
 
 /** The step `run <name>` executes: the only one so named, or the one in the cases the service selected (`OLVE_CASES`). */
-export function findStep(data: PipelineData, name: string, selected: readonly string[]): AnyStep | string {
+export function findStep(
+  data: PipelineData,
+  name: string,
+  selected: readonly string[],
+): AnyStep | string {
   const candidates = stepsWithCases(data).filter((c) => c.step.name === name);
-  const distinct = candidates.filter((c, i) => candidates.findIndex((d) => d.step === c.step) === i);
+  const distinct = candidates.filter(
+    (c, i) => candidates.findIndex((d) => d.step === c.step) === i,
+  );
   if (distinct.length === 0) return `unknown step '${name}'`;
   if (distinct.length === 1) return distinct[0]!.step;
   const chosen = distinct.filter((c) => c.cases.every((k) => selected.includes(k)));
@@ -84,26 +111,30 @@ export function findStep(data: PipelineData, name: string, selected: readonly st
 }
 
 /** The select case conditions of the step being run (JSON array), set by the service for steps inside a select. */
-export const ENV_CASES = "OLVE_CASES";
+export const ENV_CASES = 'OLVE_CASES';
 
 /** Installs SIGTERM/SIGINT handlers that abort the returned signal (PID 1 ignores signals without them). */
 export function cancellation(): { signal: AbortSignal; dispose(): void } {
   const ac = new AbortController();
-  const onTerm = () => ac.abort("SIGTERM");
-  const onInt = () => (ac.signal.aborted ? process.exit(EXIT.sigint) : ac.abort("SIGINT"));
-  process.on("SIGTERM", onTerm);
-  process.on("SIGINT", onInt);
+  const onTerm = () => ac.abort('SIGTERM');
+  const onInt = () =>
+    ac.signal.aborted ? process.exit(EXIT.sigint) : ac.abort('SIGINT');
+  process.on('SIGTERM', onTerm);
+  process.on('SIGINT', onInt);
   return {
     signal: ac.signal,
     dispose() {
-      process.off("SIGTERM", onTerm);
-      process.off("SIGINT", onInt);
+      process.off('SIGTERM', onTerm);
+      process.off('SIGINT', onInt);
     },
   };
 }
 
 /** Resolves the function that implements `step` (carried by the step, or a handler module). */
-export async function resolveStepFunction(step: AnyStep, handlers: HandlerRegistry): Promise<StepFunction | string> {
+export async function resolveStepFunction(
+  step: AnyStep,
+  handlers: HandlerRegistry,
+): Promise<StepFunction | string> {
   if (isImplementation(step)) return step.handler as unknown as StepFunction;
   const load = handlers[step.name];
   if (!load) return `step '${step.name}' has no handler`;
@@ -114,7 +145,8 @@ export async function resolveStepFunction(step: AnyStep, handlers: HandlerRegist
     return `the handler of step '${step.name}' failed to load: ${(e as Error)?.stack ?? String(e)}`;
   }
   const impl = mod.default;
-  if (!isImplementation(impl)) return `the handler of step '${step.name}' must default-export implement(<step '${step.name}'>, …)`;
+  if (!isImplementation(impl))
+    return `the handler of step '${step.name}' must default-export implement(<step '${step.name}'>, …)`;
   if (impl.step !== step)
     return `the handler of step '${step.name}' implements a different step object (it must be implement(<the '${step.name}' step from pipeline.ts>, …))`;
   return impl.handler as unknown as StepFunction;
@@ -129,7 +161,7 @@ export async function finish(exec: Execution, io: HarnessIO): Promise<number> {
   if (!url) return exec.exitCode;
   try {
     mkdirSync(p.tmp, { recursive: true });
-    const archive = join(p.tmp, "result.tar.gz");
+    const archive = join(p.tmp, 'result.tar.gz');
     await packResult(p.work, archive);
     await uploadFile(url, archive, io.stderr);
   } catch (e) {
@@ -139,18 +171,31 @@ export async function finish(exec: Execution, io: HarnessIO): Promise<number> {
   return exec.exitCode;
 }
 
-function readJson(path: string): { ok: true; value: unknown } | { ok: false; message: string } {
+function readJson(
+  path: string,
+): { ok: true; value: unknown } | { ok: false; message: string } {
   try {
-    return { ok: true, value: JSON.parse(readFileSync(path, "utf8")) };
+    return { ok: true, value: JSON.parse(readFileSync(path, 'utf8')) };
   } catch (e) {
     return { ok: false, message: `cannot read ${path}: ${(e as Error).message}` };
   }
 }
 
-async function describeMode(cfg: HarnessConfig, args: string[], io: HarnessIO): Promise<number> {
-  const sentinels = args.includes("--sentinels");
+async function describeMode(
+  cfg: HarnessConfig,
+  args: string[],
+  io: HarnessIO,
+): Promise<number> {
+  const sentinels = args.includes('--sentinels');
   try {
-    const text = manifestText(describePipeline(cfg.pipeline, { handlerNames: Object.keys(cfg.handlers), handlerHashes: cfg.handlerHashes, kindHashes: cfg.kindHashes, harness: cfg.harness }));
+    const text = manifestText(
+      describePipeline(cfg.pipeline, {
+        handlerNames: Object.keys(cfg.handlers),
+        handlerHashes: cfg.handlerHashes,
+        kindHashes: cfg.kindHashes,
+        harness: cfg.harness,
+      }),
+    );
     await io.stdout(sentinels ? `${MANIFEST_BEGIN}\n${text}${MANIFEST_END}\n` : text);
     return EXIT.ok;
   } catch (e) {
@@ -162,13 +207,17 @@ async function describeMode(cfg: HarnessConfig, args: string[], io: HarnessIO):
   }
 }
 
-async function runMode(cfg: HarnessConfig, name: string | undefined, io: HarnessIO): Promise<number> {
-  if (!name) return io.stderr(USAGE), EXIT.usage;
+async function runMode(
+  cfg: HarnessConfig,
+  name: string | undefined,
+  io: HarnessIO,
+): Promise<number> {
+  if (!name) return (io.stderr(USAGE), EXIT.usage);
   const data = pipelineData(cfg.pipeline);
   const step = findStep(data, name, selectedCases());
-  if (typeof step === "string") return io.stderr(step), EXIT.usage;
+  if (typeof step === 'string') return (io.stderr(step), EXIT.usage);
   const fn = await resolveStepFunction(step, cfg.handlers);
-  if (typeof fn === "string") return io.stderr(fn), EXIT.configInvalid;
+  if (typeof fn === 'string') return (io.stderr(fn), EXIT.configInvalid);
 
   const p = paths();
   removeStale(p.work);
@@ -180,11 +229,28 @@ async function runMode(cfg: HarnessConfig, name: string | undefined, io: Harness
     let exec: Execution;
     if (!raw.ok) {
       io.stderr(raw.message);
-      exec = { envelope: { status: "failed", error: { kind: "input", message: raw.message } }, exitCode: EXIT.inputInvalid };
+      exec = {
+        envelope: { status: 'failed', error: { kind: 'input', message: raw.message } },
+        exitCode: EXIT.inputInvalid,
+      };
     } else {
       const run = runInfoFromEnv(step.name);
-      const ctx = createCtx({ run, secrets: step.secrets, paths: { root: p.root, workFiles: p.files, tmp: p.tmp }, signal: cancel.signal, logSink: io.stderr, callbackUrls: callbackUrlsFromEnv() });
-      exec = await executeStep({ step, fn, rawInput: raw.value, ctx, workFiles: p.files, log: io.stderr });
+      const ctx = createCtx({
+        run,
+        secrets: step.secrets,
+        paths: { root: p.root, workFiles: p.files, tmp: p.tmp },
+        signal: cancel.signal,
+        logSink: io.stderr,
+        callbackUrls: callbackUrlsFromEnv(),
+      });
+      exec = await executeStep({
+        step,
+        fn,
+        rawInput: raw.value,
+        ctx,
+        workFiles: p.files,
+        log: io.stderr,
+      });
     }
     return await finish(exec, io);
   } finally {
@@ -193,64 +259,121 @@ async function runMode(cfg: HarnessConfig, name: string | undefined, io: Harness
 }
 
 function isWebhookEvent(v: unknown): boolean {
-  if (typeof v !== "object" || v === null || Array.isArray(v) || !("body" in v)) return false;
+  if (typeof v !== 'object' || v === null || Array.isArray(v) || !('body' in v))
+    return false;
   const headers = (v as { headers?: unknown }).headers;
-  return typeof headers === "object" && headers !== null && !Array.isArray(headers);
+  return typeof headers === 'object' && headers !== null && !Array.isArray(headers);
 }
 
-async function mapTriggerMode(cfg: HarnessConfig, name: string | undefined, io: HarnessIO): Promise<number> {
-  if (!name) return io.stderr(USAGE), EXIT.usage;
+async function mapTriggerMode(
+  cfg: HarnessConfig,
+  name: string | undefined,
+  io: HarnessIO,
+): Promise<number> {
+  if (!name) return (io.stderr(USAGE), EXIT.usage);
   const data = pipelineData(cfg.pipeline);
   const trigger = data.triggers.find((t) => t.name === name);
-  if (!trigger) return io.stderr(`unknown trigger '${name}' (known: ${data.triggers.map((t) => t.name).join(", ") || "none"})`), EXIT.usage;
+  if (!trigger)
+    return (
+      io.stderr(
+        `unknown trigger '${name}' (known: ${data.triggers.map((t) => t.name).join(', ') || 'none'})`,
+      ),
+      EXIT.usage
+    );
   const p = paths();
   removeStale(p.work);
   mkdirSync(p.work, { recursive: true });
   const raw = readJson(p.input);
-  const fail = (kind: "input" | "output" | "handler", message: string, exitCode: number): Execution => {
+  const fail = (
+    kind: 'input' | 'output' | 'handler',
+    message: string,
+    exitCode: number,
+  ): Execution => {
     io.stderr(message);
-    return { envelope: { status: "failed", error: { kind, message } }, exitCode };
+    return { envelope: { status: 'failed', error: { kind, message } }, exitCode };
   };
   let exec: Execution;
-  if (!raw.ok) exec = fail("input", raw.message, EXIT.inputInvalid);
-  else if (trigger.kind === "poll" && (typeof raw.value !== "object" || raw.value === null || typeof (raw.value as { value?: unknown }).value !== "string"))
-    exec = fail("input", `poll trigger '${name}': the event must be {"value": "<string>"}`, EXIT.inputInvalid);
-  else if (trigger.kind === "push" && (typeof raw.value !== "object" || raw.value === null || Array.isArray(raw.value)))
-    exec = fail("input", `push trigger: the event must be the webhook payload object`, EXIT.inputInvalid);
-  else if (trigger.kind === "webhook" && !isWebhookEvent(raw.value))
-    exec = fail("input", `webhook trigger '${name}': the event must be {"headers": {...}, "body": ...}`, EXIT.inputInvalid);
+  if (!raw.ok) exec = fail('input', raw.message, EXIT.inputInvalid);
+  else if (
+    trigger.kind === 'poll' &&
+    (typeof raw.value !== 'object' ||
+      raw.value === null ||
+      typeof (raw.value as { value?: unknown }).value !== 'string')
+  )
+    exec = fail(
+      'input',
+      `poll trigger '${name}': the event must be {"value": "<string>"}`,
+      EXIT.inputInvalid,
+    );
+  else if (
+    trigger.kind === 'push' &&
+    (typeof raw.value !== 'object' || raw.value === null || Array.isArray(raw.value))
+  )
+    exec = fail(
+      'input',
+      `push trigger: the event must be the webhook payload object`,
+      EXIT.inputInvalid,
+    );
+  else if (trigger.kind === 'webhook' && !isWebhookEvent(raw.value))
+    exec = fail(
+      'input',
+      `webhook trigger '${name}': the event must be {"headers": {...}, "body": ...}`,
+      EXIT.inputInvalid,
+    );
   else {
     let mapped: unknown;
     let threw: unknown = undefined;
     try {
       mapped =
-        trigger.kind === "poll" ? await trigger.map((raw.value as { value: string }).value)
-        : trigger.kind === "webhook" ? await trigger.map(raw.value as WebhookEvent)
-        : await trigger.map(raw.value);
+        trigger.kind === 'poll'
+          ? await trigger.map((raw.value as { value: string }).value)
+          : trigger.kind === 'webhook'
+            ? await trigger.map(raw.value as WebhookEvent)
+            : await trigger.map(raw.value);
     } catch (e) {
-      threw = e ?? new Error("undefined");
+      threw = e ?? new Error('undefined');
     }
-    if (threw !== undefined) exec = fail("handler", `trigger '${name}' mapper threw: ${(threw as Error)?.message ?? String(threw)}`, EXIT.handlerFailed);
-    else if (mapped === null && trigger.kind === "webhook") exec = { envelope: { status: "skipped", reason: `trigger '${name}' ignored the delivery` }, exitCode: EXIT.ok };
+    if (threw !== undefined)
+      exec = fail(
+        'handler',
+        `trigger '${name}' mapper threw: ${(threw as Error)?.message ?? String(threw)}`,
+        EXIT.handlerFailed,
+      );
+    else if (mapped === null && trigger.kind === 'webhook')
+      exec = {
+        envelope: { status: 'skipped', reason: `trigger '${name}' ignored the delivery` },
+        exitCode: EXIT.ok,
+      };
     else {
-      const r = parseStrict(data.input.schema, mapped, "input");
+      const r = parseStrict(data.input.schema, mapped, 'input');
       exec = r.ok
-        ? { envelope: { status: "succeeded", output: r.value } satisfies Envelope, exitCode: EXIT.ok }
-        : fail("output", `trigger '${name}': mapped input does not match ${data.input.name}:\n  ${r.issues.join("\n  ")}`, EXIT.outputInvalid);
+        ? {
+            envelope: { status: 'succeeded', output: r.value } satisfies Envelope,
+            exitCode: EXIT.ok,
+          }
+        : fail(
+            'output',
+            `trigger '${name}': mapped input does not match ${data.input.name}:\n  ${r.issues.join('\n  ')}`,
+            EXIT.outputInvalid,
+          );
     }
   }
   return finish(exec, io);
 }
 
 /** Entry point of the compiled binary (and the dev runner). Returns the exit code. */
-export async function runHarness(cfg: HarnessConfig, argv: readonly string[], io: HarnessIO = defaultIO): Promise<number> {
+export async function runHarness(
+  cfg: HarnessConfig,
+  argv: readonly string[],
+  io: HarnessIO = defaultIO,
+): Promise<number> {
   const [mode, ...rest] = argv;
   switch (mode) {
-    case "describe":
+    case 'describe':
       return describeMode(cfg, rest, io);
-    case "run":
+    case 'run':
       return runMode(cfg, rest[0], io);
-    case "map-trigger":
+    case 'map-trigger':
       return mapTriggerMode(cfg, rest[0], io);
     default:
       io.stderr(USAGE);
@@ -262,8 +385,8 @@ export { formatIssues, formatLog };
 
 function selectedCases(): string[] {
   try {
-    const v = JSON.parse(process.env[ENV_CASES] ?? "[]") as unknown;
-    return Array.isArray(v) ? v.filter((x): x is string => typeof x === "string") : [];
+    const v = JSON.parse(process.env[ENV_CASES] ?? '[]') as unknown;
+    return Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : [];
   } catch {
     return [];
   }

package/src/harness/result.ts

@@ -1,22 +1,29 @@
 // Writing, printing and uploading the result of `run` / `map-trigger`.
-import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { canonicalJson } from "../util/canonical.ts";
-import { dirEntries, writeTarGz, type TarEntry } from "../util/tar.ts";
-import { redactUrl } from "../ctx/files.ts";
-import type { Envelope } from "./execute.ts";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { canonicalJson } from '../util/canonical.ts';
+import { dirEntries, writeTarGz, type TarEntry } from '../util/tar.ts';
+import { redactUrl } from '../ctx/files.ts';
+import type { Envelope } from './execute.ts';
 
-export const RESULT_BEGIN = "---OLVE-RESULT-BEGIN---";
-export const RESULT_END = "---OLVE-RESULT-END---";
-export const MANIFEST_BEGIN = "---OLVE-MANIFEST-BEGIN---";
-export const MANIFEST_END = "---OLVE-MANIFEST-END---";
+export const RESULT_BEGIN = '---OLVE-RESULT-BEGIN---';
+export const RESULT_END = '---OLVE-RESULT-END---';
+export const MANIFEST_BEGIN = '---OLVE-MANIFEST-BEGIN---';
+export const MANIFEST_END = '---OLVE-MANIFEST-END---';
 
 /** Atomically writes the envelope to `<work>/output.json`. */
 export function writeEnvelope(work: string, envelope: Envelope): string {
   mkdirSync(work, { recursive: true });
-  const path = join(work, "output.json");
-  writeFileSync(path + ".partial", canonicalJson(envelope));
-  renameSync(path + ".partial", path);
+  const path = join(work, 'output.json');
+  writeFileSync(path + '.partial', canonicalJson(envelope));
+  renameSync(path + '.partial', path);
   return path;
 }
 
@@ -27,9 +34,15 @@ export function sentinelBlock(envelope: Envelope): string {
 
 /** Packs output.json + files/ into result.tar.gz (deterministic). */
 export async function packResult(work: string, out: string): Promise<void> {
-  const entries: TarEntry[] = [{ path: "output.json", type: "file", mode: 0o644, source: join(work, "output.json") }];
-  const files = join(work, "files");
-  if (existsSync(files)) entries.push({ path: "files", type: "dir", mode: 0o755 }, ...dirEntries(files, "files"));
+  const entries: TarEntry[] = [
+    { path: 'output.json', type: 'file', mode: 0o644, source: join(work, 'output.json') },
+  ];
+  const files = join(work, 'files');
+  if (existsSync(files))
+    entries.push(
+      { path: 'files', type: 'dir', mode: 0o755 },
+      ...dirEntries(files, 'files'),
+    );
   await writeTarGz(out, entries);
 }
 
@@ -48,7 +61,7 @@ export async function uploadFile(
     let status = 0;
     let detail: string;
     try {
-      const res = await fetch(url, { method: "PUT", body: Bun.file(file) });
+      const res = await fetch(url, { method: 'PUT', body: Bun.file(file) });
       status = res.status;
       if (res.ok) return;
       detail = `HTTP ${res.status} ${res.statusText}`;
@@ -57,7 +70,8 @@ export async function uploadFile(
       detail = (e as Error).message;
     }
     const transient = status === 0 || TRANSIENT(status);
-    if (!transient || i >= attempts) throw new Error(`upload to ${redactUrl(url)} failed: ${detail}`);
+    if (!transient || i >= attempts)
+      throw new Error(`upload to ${redactUrl(url)} failed: ${detail}`);
     log(`upload to ${redactUrl(url)} failed (${detail}); retry ${i}/${attempts - 1}`);
     await Bun.sleep(base * 2 ** (i - 1));
   }
@@ -68,8 +82,10 @@ export async function uploadFile(
  * *contents* of files/. The directories themselves are kept (olve-init creates them 1777).
  */
 export function removeStale(work: string): void {
-  rmSync(join(work, "output.json"), { force: true });
-  rmSync(join(work, "output.json.partial"), { force: true });
-  const files = join(work, "files");
-  if (existsSync(files)) for (const e of readdirSync(files)) rmSync(join(files, e), { recursive: true, force: true });
+  rmSync(join(work, 'output.json'), { force: true });
+  rmSync(join(work, 'output.json.partial'), { force: true });
+  const files = join(work, 'files');
+  if (existsSync(files))
+    for (const e of readdirSync(files))
+      rmSync(join(files, e), { recursive: true, force: true });
 }

package/src/harness/validate.ts

@@ -1,23 +1,30 @@
-import { z } from "zod";
-import { isModel, isOptional } from "../core/models.ts";
-import { isExternal } from "../core/external.ts";
-import type { AnyStep } from "../core/steps.ts";
+import { z } from 'zod';
+import { isModel, isOptional } from '../core/models.ts';
+import { isExternal } from '../core/external.ts';
+import type { AnyStep } from '../core/steps.ts';
 
 export type Validation<T> = { ok: true; value: T } | { ok: false; issues: string[] };
 
 export function formatIssues(err: z.ZodError, prefix: string): string[] {
-  return err.issues.map((i) => `${prefix}${i.path.length ? "." + i.path.map(String).join(".") : ""}: ${i.message}`);
+  return err.issues.map(
+    (i) =>
+      `${prefix}${i.path.length ? '.' + i.path.map(String).join('.') : ''}: ${i.message}`,
+  );
 }
 
 const isPlainObject = (v: unknown): v is Record<string, unknown> =>
-  typeof v === "object" && v !== null && !Array.isArray(v) && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+  typeof v === 'object' &&
+  v !== null &&
+  !Array.isArray(v) &&
+  (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
 
 /**
  * zod strips unknown keys silently (at every depth). Compares the raw value with the parsed one:
  * any key present in a raw object but absent from the parsed object at the same place was stripped.
  */
-export function strippedKeys(raw: unknown, parsed: unknown, path = ""): string[] {
-  if (Array.isArray(raw) && Array.isArray(parsed)) return raw.flatMap((x, i) => strippedKeys(x, parsed[i], `${path}[${i}]`));
+export function strippedKeys(raw: unknown, parsed: unknown, path = ''): string[] {
+  if (Array.isArray(raw) && Array.isArray(parsed))
+    return raw.flatMap((x, i) => strippedKeys(x, parsed[i], `${path}[${i}]`));
   if (isPlainObject(raw) && isPlainObject(parsed)) {
     const out: string[] = [];
     for (const k of Object.keys(raw)) {
@@ -31,11 +38,21 @@ export function strippedKeys(raw: unknown, parsed: unknown, path = ""): string[]
 }
 
 /** Strict parse: zod validation plus rejection of unknown keys at any depth. */
-export function parseStrict(schema: z.ZodType, value: unknown, prefix: string): Validation<unknown> {
+export function parseStrict(
+  schema: z.ZodType,
+  value: unknown,
+  prefix: string,
+): Validation<unknown> {
   const r = schema.safeParse(value);
   if (!r.success) return { ok: false, issues: formatIssues(r.error, prefix) };
   const extra = strippedKeys(value, r.data);
-  if (extra.length) return { ok: false, issues: extra.map((k) => `${prefix}.${k}: unknown field (outputs are validated strictly)`) };
+  if (extra.length)
+    return {
+      ok: false,
+      issues: extra.map(
+        (k) => `${prefix}.${k}: unknown field (outputs are validated strictly)`,
+      ),
+    };
   return { ok: true, value: r.data };
 }
 
@@ -46,30 +63,51 @@ function entrySchema(e: unknown): z.ZodType {
 }
 
 /** Reserved input.json key holding the step's config entries (written by the service). */
-export const CONFIG_KEY = "$config";
+export const CONFIG_KEY = '$config';
 
 /** Parses `$config` with each declared entry's schema (defaults applied). Undeclared entries are ignored. */
-export function validateConfig(step: AnyStep, raw: unknown): Validation<Record<string, unknown>> {
+export function validateConfig(
+  step: AnyStep,
+  raw: unknown,
+): Validation<Record<string, unknown>> {
   const given = isPlainObject(raw) ? raw[CONFIG_KEY] : undefined;
-  if (given !== undefined && !isPlainObject(given)) return { ok: false, issues: [`input.${CONFIG_KEY} must be an object keyed by config entry names`] };
+  if (given !== undefined && !isPlainObject(given))
+    return {
+      ok: false,
+      issues: [`input.${CONFIG_KEY} must be an object keyed by config entry names`],
+    };
   const issues: string[] = [];
   const out: Record<string, unknown> = {};
   for (const e of step.config ?? []) {
     const value = given?.[e.name];
     const r = e.schema.safeParse(value);
-    if (!r.success) issues.push(...formatIssues(r.error, `config.${e.name}`).map((i) => (value === undefined ? `${i} (config entry '${e.name}' is not set)` : i)));
+    if (!r.success)
+      issues.push(
+        ...formatIssues(r.error, `config.${e.name}`).map((i) =>
+          value === undefined ? `${i} (config entry '${e.name}' is not set)` : i,
+        ),
+      );
     else if (r.data !== undefined) out[e.name] = r.data;
   }
   return issues.length ? { ok: false, issues } : { ok: true, value: out };
 }
 
 /** Validates input.json against the step's input entries. Unknown top-level keys are rejected; nested values are parsed (unknown nested keys stripped). */
-export function validateInput(step: AnyStep, raw: unknown): Validation<Record<string, unknown>> {
-  if (!isPlainObject(raw)) return { ok: false, issues: ["input.json must be a JSON object keyed by the step's input names"] };
+export function validateInput(
+  step: AnyStep,
+  raw: unknown,
+): Validation<Record<string, unknown>> {
+  if (!isPlainObject(raw))
+    return {
+      ok: false,
+      issues: ["input.json must be a JSON object keyed by the step's input names"],
+    };
   const issues: string[] = [];
   const out: Record<string, unknown> = {};
   const declared = step.input as Record<string, unknown>;
-  for (const k of Object.keys(raw)) if (k !== CONFIG_KEY && !Object.hasOwn(declared, k)) issues.push(`input.${k}: not an input of step '${step.name}'`);
+  for (const k of Object.keys(raw))
+    if (k !== CONFIG_KEY && !Object.hasOwn(declared, k))
+      issues.push(`input.${k}: not an input of step '${step.name}'`);
   for (const [k, e] of Object.entries(declared)) {
     if (!Object.hasOwn(raw, k)) {
       if (isOptional(e)) continue;
@@ -87,7 +125,12 @@ export function validateInput(step: AnyStep, raw: unknown): Validation<Record<st
 export function validateOutput(step: AnyStep, value: unknown): Validation<unknown> {
   if (!step.output) {
     if (value === undefined || value === null) return { ok: true, value: null };
-    return { ok: false, issues: [`step '${step.name}' declares no output model but the handler returned a value`] };
+    return {
+      ok: false,
+      issues: [
+        `step '${step.name}' declares no output model but the handler returned a value`,
+      ],
+    };
   }
-  return parseStrict(step.output.schema, value, "output");
+  return parseStrict(step.output.schema, value, 'output');
 }