@olivervea/pipelines 0.0.0-stage → 2.0.0-beta.1

package/src/builder/refs.ts

@@ -0,0 +1,26 @@
+import type { RefBrand } from "../core/brands.ts";
+import type { AnyStep, InferEntry } from "../core/steps.ts";
+import type { Primitive } from "../core/types.ts";
+
+/**
+ * A typed reference into the run pool — what mappers see. `symbol &` makes template strings, `+`
+ * and `===` against values compile errors (TS2731 / TS2469 / TS2367); only property access and
+ * literals remain. Fields of a maybe-undefined ref are themselves maybe-undefined.
+ */
+export type Ref<T> = symbol & { readonly [RefBrand]: T } & RefFields<T>;
+type RefFields<T> = [NonNullable<T>] extends [Primitive]
+  ? {}
+  : NonNullable<T> extends readonly unknown[]
+    ? {}
+    : { readonly [K in keyof NonNullable<T> & string]-?: Ref<NonNullable<T>[K] | (undefined extends T ? undefined : never)> };
+
+/** What a mapper may put where a T is expected: a Ref<T>, a literal, or an object of those. */
+export type Mappable<T> =
+  | Ref<T>
+  | (T extends Primitive
+      ? T
+      : T extends readonly unknown[]
+        ? never
+        : { [K in keyof T]: Mappable<T[K]> } & { readonly [RefBrand]?: never }); // a Ref of another model can't sneak in structurally
+
+export type MapperResult<S extends AnyStep> = { [K in keyof S["input"]]: Mappable<InferEntry<S["input"][K]>> };

package/src/core/brands.ts

@@ -0,0 +1,13 @@
+// Runtime markers. `Symbol.for` (not `Symbol()`) so that two copies of the SDK in one process — e.g.
+// a dev runner and the user's installed package — still recognise each other's objects.
+export const STEP = Symbol.for("olve.pipelines.step");
+export const IMPLEMENTATION = Symbol.for("olve.pipelines.implementation");
+export const SKIPPED = Symbol.for("olve.pipelines.skipped");
+export const PIPELINE = Symbol.for("olve.pipelines.pipeline");
+export const REF_PATH = Symbol.for("olve.pipelines.refPath");
+
+// Type-only brands (never exist at runtime).
+export declare const ModelBrand: unique symbol;
+export declare const RefBrand: unique symbol;
+export declare const StepBrand: unique symbol;
+export declare const SkippedBrand: unique symbol;

package/src/core/handlers.ts

@@ -0,0 +1,44 @@
+import { IMPLEMENTATION, SKIPPED, type SkippedBrand } from "./brands.ts";
+import type { Ctx } from "../ctx/types.ts";
+import type { AnyStep, LibraryStep, OutputValue, SecretsOf, StepInput } from "./steps.ts";
+import type { Awaitable } from "./types.ts";
+
+/** Returned by `ctx.skip(reason)`: the step produced no output on purpose. */
+export interface Skipped {
+  readonly [SkippedBrand]: true;
+  readonly reason: string;
+}
+export function skipped(reason: string): Skipped {
+  return Object.freeze({ [SKIPPED]: true, reason }) as unknown as Skipped;
+}
+export function isSkipped(v: unknown): v is Skipped {
+  return typeof v === "object" && v !== null && (v as Record<symbol, unknown>)[SKIPPED] === true;
+}
+
+export type HandlerResult<S extends AnyStep> = OutputValue<S> | Skipped;
+export type Handler<S extends AnyStep> = (input: StepInput<S["input"]>, ctx: Ctx<SecretsOf<S>>) => Awaitable<HandlerResult<S>>;
+
+export interface Implementation<S extends AnyStep = AnyStep> {
+  readonly step: S;
+  readonly handler: Handler<S>;
+}
+
+/** Block-bodied/async returns get no excess-property check; this restores it for handler outputs. */
+type NoExtraFields<R, T> = R extends Skipped | void
+  ? unknown
+  : { [K in Exclude<keyof R, keyof T>]: `❌ '${K & string}' is not a field of the output model` };
+
+/**
+ * Implement a custom step. Input, ctx and return types come from the step definition alone.
+ * Default-export the result from `handlers/<step-name>.ts`.
+ */
+export function implement<S extends AnyStep, R extends HandlerResult<S>>(
+  step: S & (S extends LibraryStep ? "❌ library steps already carry their implementation" : unknown),
+  handler: (input: StepInput<S["input"]>, ctx: Ctx<SecretsOf<S>>) => Awaitable<R & NoExtraFields<R, OutputValue<S>>>,
+): Implementation<S> {
+  return Object.freeze({ [IMPLEMENTATION]: true, step, handler: handler as unknown as Handler<S> }) as Implementation<S>;
+}
+
+export function isImplementation(v: unknown): v is Implementation {
+  return typeof v === "object" && v !== null && (v as Record<symbol, unknown>)[IMPLEMENTATION] === true;
+}

package/src/core/models.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import type { ModelBrand } from "./brands.ts";
+
+/** A named, nominal zod schema. The name is its identity in the manifest (one schema per name). */
+export interface Model<N extends string = string, S extends z.ZodType = z.ZodType> {
+  readonly kind: "model";
+  readonly name: N;
+  readonly schema: S;
+}
+export type AnyModel = Model<string, z.ZodType>;
+
+/** Output view of a model (`z.output`), nominally branded with the model name. The brand is optional, so plain literals still assign. */
+export type Infer<M extends AnyModel> = z.output<M["schema"]> & { readonly [ModelBrand]?: M["name"] };
+/** Input view of a model (`z.input`: fields with defaults are optional). What trigger mappers produce. */
+export type InferInput<M extends AnyModel> = z.input<M["schema"]>;
+/** Output view without the nominal brand. */
+export type Plain<M extends AnyModel> = z.output<M["schema"]>;
+
+/** Model names: identifier-like, so they are safe as JSON keys, C# names and URL segments. */
+export const MODEL_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
+
+export function model<const N extends string, S extends z.ZodType>(name: N, schema: S): Model<N, S> {
+  return Object.freeze({ kind: "model" as const, name, schema });
+}
+
+export function isModel(v: unknown): v is AnyModel {
+  return typeof v === "object" && v !== null && (v as { kind?: unknown }).kind === "model" && (v as { schema?: unknown }).schema instanceof z.ZodType;
+}
+
+// ─── File references ─────────────────────────────────────────────────────────────────────────
+
+/**
+ * One path segment: no `/`, `\` or NUL, and not `.` / `..`. A path is segments joined by `/`;
+ * a trailing `/` marks a directory reference (stored as a tar archive, see README).
+ */
+const SEGMENT = String.raw`(?!\.\.?(?:/|$))[^/\\\x00]+`;
+export const FILE_PATH_PATTERN = `^(?:${SEGMENT}/)*${SEGMENT}/?$`;
+export const FILE_PATH = new RegExp(FILE_PATH_PATTERN);
+
+const FileRefSchema = z
+  .object({
+    run: z.number().int().nonnegative(),
+    step: z.string().min(1),
+    attempt: z.number().int().positive(),
+    path: z.string().regex(FILE_PATH),
+    sha256: z.string().regex(/^[0-9a-f]{64}$/),
+  })
+  .brand<"FileRef">()
+  .meta({ "x-olve-kind": "fileRef" });
+
+/** A file or directory in some step attempt's output (`runs/<p>/<run>/<step>/<attempt>/files/<path>`). Branded: only `ctx.output.*` or a mapper ref produce one. */
+export type FileRef = z.output<typeof FileRefSchema>;
+/** Schema for a file reference field inside a model. Marked `"x-olve-kind": "fileRef"` in JSON Schema. */
+export const fileRef = () => FileRefSchema;
+export const fileRefSchema = FileRefSchema;
+
+// ─── optional() ──────────────────────────────────────────────────────────────────────────────
+
+/** A step input that may be missing because its producer was *maybe skipped* (inside a `when`). There must still be a producer. */
+export interface Optional<M extends AnyModel = AnyModel> {
+  readonly kind: "optional";
+  readonly model: M;
+}
+export function optional<M extends AnyModel>(model: M): Optional<M> {
+  return Object.freeze({ kind: "optional" as const, model });
+}
+export function isOptional(v: unknown): v is Optional {
+  return typeof v === "object" && v !== null && (v as { kind?: unknown }).kind === "optional" && isModel((v as { model?: unknown }).model);
+}

package/src/core/secrets.ts

@@ -0,0 +1,13 @@
+/** A named pipeline secret. Steps (and poll triggers) declare the secrets they use; only those are mounted. */
+export interface Secret<N extends string = string> {
+  readonly kind: "secret";
+  readonly name: N;
+  readonly description: string;
+}
+/** Secret names double as environment variable names in the step container. */
+export const SECRET_NAME = /^[A-Z_][A-Z0-9_]*$/;
+
+export function secret<const N extends string>(name: N, description: string): Secret<N> {
+  return Object.freeze({ kind: "secret" as const, name, description });
+}
+export type DeclaredSecrets<N extends string> = { readonly [K in N]: string };

package/src/core/steps.ts

@@ -0,0 +1,107 @@
+import type { z } from "zod";
+import { STEP, type StepBrand } from "./brands.ts";
+import type { AnyModel, Infer, Optional } from "./models.ts";
+import type { Secret } from "./secrets.ts";
+import type { Simplify } from "./types.ts";
+
+/** A step input entry: a model (matchable by model), `optional(model)`, or a plain zod schema (mapper required). */
+export type InputEntry = AnyModel | Optional | z.ZodType;
+export type InputSpec = { readonly [key: string]: InputEntry };
+
+export type InferEntry<E> =
+  E extends Optional<infer M> ? Infer<M> | undefined
+  : E extends AnyModel ? Infer<E>
+  : E extends z.ZodType ? z.output<E>
+  : never;
+/** What a handler receives: the output view of every input entry. */
+export type StepInput<I> = Simplify<{ -readonly [K in keyof I]: InferEntry<I[K]> }>;
+
+/** `custom` steps have a handler file; the others are library steps implemented by the SDK. */
+export type StepKind = "custom" | "script" | "gitHubSource" | "imageBuild" | "helmDeployOverSsh";
+
+export interface Step<
+  N extends string = string,
+  I extends InputSpec = InputSpec,
+  O extends AnyModel | null = AnyModel | null,
+  Sec extends string = string,
+> {
+  readonly [StepBrand]: true;
+  readonly kind: StepKind;
+  readonly name: N;
+  readonly description: string;
+  readonly image: string;
+  readonly input: I;
+  readonly output: O;
+  readonly secrets: readonly Secret<Sec>[];
+  readonly timeoutSeconds?: number;
+  readonly retries?: number;
+  /** Library steps carry their own implementation and config. */
+  readonly builtin?: LibraryImplementation;
+}
+/** Runtime part of a library step (not part of the public contract). */
+export interface LibraryImplementation {
+  /** Config as emitted in the manifest (JSON only; must not contain paths). */
+  readonly manifestConfig: () => Record<string, unknown>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  readonly run: (input: any, ctx: any) => Promise<unknown>;
+}
+export type LibraryStep = { readonly builtin: LibraryImplementation };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyStep = Step<string, any, AnyModel | null, any>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type SecretsOf<S> = S extends Step<any, any, any, infer Sec> ? Sec : never;
+export type OutputValue<S extends AnyStep> = S["output"] extends AnyModel ? Infer<S["output"]> : void;
+
+/** Step names must be literals (identity, duplicate detection and mapper keys depend on it). */
+export type LiteralName<N extends string> = N & (string extends N ? "❌ step name must be a string literal" : unknown);
+
+/** Step names: lower-case kebab, ≤ 63 chars (usable as K8s label values and URL segments). */
+export const STEP_NAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/** Names that cannot be steps: `input` is the pipeline input's root in mappings. */
+export const RESERVED_STEP_NAMES: readonly string[] = ["input"];
+
+export interface StepDef<N extends string, I extends InputSpec, O extends AnyModel | null, Sec extends readonly Secret[]> {
+  name: LiteralName<N>;
+  /** What the step does, shown in the UI. Required; may be empty. */
+  description: string;
+  /** Any image: the harness brings its own runtime. */
+  image: string;
+  input?: I;
+  output?: O;
+  secrets?: Sec;
+  timeoutSeconds?: number;
+  /** Automatic retries (an idempotency claim). Default 0. */
+  retries?: number;
+}
+
+export function makeStep(kind: StepKind, def: Record<string, unknown>, builtin?: LibraryImplementation): AnyStep {
+  const s = {
+    [STEP]: true,
+    kind,
+    name: def.name,
+    description: def.description,
+    image: def.image,
+    input: Object.freeze({ ...((def.input as object | undefined) ?? {}) }),
+    output: def.output ?? null,
+    secrets: Object.freeze([...((def.secrets as readonly Secret[] | undefined) ?? [])]),
+    ...(def.timeoutSeconds !== undefined ? { timeoutSeconds: def.timeoutSeconds } : {}),
+    ...(def.retries !== undefined ? { retries: def.retries } : {}),
+    ...(builtin ? { builtin } : {}),
+  };
+  return Object.freeze(s) as unknown as AnyStep;
+}
+
+export function isStep(v: unknown): v is AnyStep {
+  return typeof v === "object" && v !== null && (v as Record<symbol, unknown>)[STEP] === true;
+}
+
+/** Define a custom step: a contract (name, image, inputs, output, secrets). Its handler lives in `handlers/<name>.ts`. */
+export function step<
+  const N extends string,
+  const I extends InputSpec = {},
+  O extends AnyModel | null = null,
+  const Sec extends readonly Secret[] = [],
+>(def: StepDef<N, I, O, Sec>): Step<N, I, O, Sec[number]["name"]> {
+  return makeStep("custom", def as never) as never;
+}

package/src/core/types.ts

@@ -0,0 +1,6 @@
+export type Primitive = string | number | boolean | bigint | null | undefined;
+export type Simplify<T> = { [K in keyof T]: T[K] } & {};
+export type Awaitable<T> = T | Promise<T>;
+export type IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;
+/** `Ok` when there is no error, else the error (a readable string-literal type). */
+export type OrError<Err, Ok> = [Err] extends [never] ? Ok : Err;

package/src/ctx/files.ts

@@ -0,0 +1,161 @@
+// File references: producing them (`ctx.output.*`) and fetching them (`ctx.files.fetch`).
+//
+// Storage rule (shared with the service): a ref's *object path* is `path` for files and
+// `path` minus the trailing "/" plus ".tar" for directories (a deterministic tar). The step writes
+// objects to `$OLVE_DIR/work/files/<object path>`; the service stores them under
+// `runs/<p>/<run>/<step>/<attempt>/files/<object path>`.
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileRefSchema, FILE_PATH, type FileRef } from "../core/models.ts";
+import { ENV } from "../harness/env.ts";
+import { sha256File } from "../util/hash.ts";
+import { dirEntries, extractTar, writeTar } from "../util/tar.ts";
+import type { OutputFileOptions, RunInfo } from "./types.ts";
+
+export const objectPath = (refPath: string): string => (refPath.endsWith("/") ? refPath.slice(0, -1) + ".tar" : refPath);
+export const fileKey = (ref: Pick<FileRef, "run" | "step" | "attempt" | "path">): string => `${ref.run}/${ref.step}/${ref.attempt}/${ref.path}`;
+
+/** Strips everything from `?` on (pre-signed credentials). */
+export const redactUrl = (url: string): string => url.replace(/[?#].*$/, "?…");
+
+export interface FilesDeps {
+  run: RunInfo;
+  workFiles: string;
+  tmpDir: string;
+  root: string;
+  signal: AbortSignal;
+  log: (message: string, fields?: Record<string, unknown>) => void;
+}
+
+function checkName(name: string, what: string): void {
+  if (!FILE_PATH.test(name) || name.endsWith("/")) throw new Error(`${what}: '${name}' is not a valid relative file name (no leading '/', no '..', no trailing '/')`);
+}
+
+export function createOutput(deps: FilesDeps) {
+  const used = new Set<string>();
+  const claim = (obj: string) => {
+    if (used.has(obj) || existsSync(join(deps.workFiles, obj))) throw new Error(`output file '${obj}' already exists`);
+    used.add(obj);
+    const dest = join(deps.workFiles, obj);
+    mkdirSync(dirname(dest), { recursive: true });
+    return dest;
+  };
+  const ref = (path: string, dest: string): FileRef =>
+    ({ run: deps.run.number, step: deps.run.step, attempt: deps.run.attempt, path, sha256: sha256File(dest) }) as FileRef;
+
+  return {
+    async file(path: string, opts: OutputFileOptions = {}): Promise<FileRef> {
+      const src = resolve(path);
+      if (!statSync(src).isFile()) throw new Error(`ctx.output.file: '${path}' is not a file`);
+      const name = opts.name ?? basename(src);
+      checkName(name, "ctx.output.file");
+      const dest = claim(name);
+      copyFileSync(src, dest);
+      return ref(name, dest);
+    },
+    async dir(path: string, opts: OutputFileOptions = {}): Promise<FileRef> {
+      const src = resolve(path);
+      if (!statSync(src).isDirectory()) throw new Error(`ctx.output.dir: '${path}' is not a directory`);
+      const name = opts.name ?? basename(src);
+      checkName(name, "ctx.output.dir");
+      const dest = claim(objectPath(name + "/"));
+      writeTar(dest, dirEntries(src));
+      return ref(name + "/", dest);
+    },
+    async write(name: string, content: string | Uint8Array): Promise<FileRef> {
+      checkName(name, "ctx.output.write");
+      const dest = claim(name);
+      writeFileSync(dest, content);
+      return ref(name, dest);
+    },
+  };
+}
+
+function urlMap(root: string): Record<string, string> {
+  const raw = process.env[ENV.fileUrls] ?? (existsSync(join(root, "files.json")) ? readFileSync(join(root, "files.json"), "utf8") : undefined);
+  if (!raw) return {};
+  try {
+    const m = JSON.parse(raw) as unknown;
+    if (typeof m !== "object" || m === null || Array.isArray(m)) throw new Error("not an object");
+    return m as Record<string, string>;
+  } catch (e) {
+    throw new Error(`${ENV.fileUrls} / files.json is not a JSON object of file key → URL (${(e as Error).message})`);
+  }
+}
+
+const TRANSIENT = (status: number) => status >= 500 || status === 408 || status === 429;
+
+async function download(url: string, dest: string, headers: Record<string, string>, signal: AbortSignal, log: FilesDeps["log"]): Promise<void> {
+  const attempts = 4;
+  for (let i = 1; ; i++) {
+    let status = 0;
+    try {
+      const res = await fetch(url, { headers, signal });
+      status = res.status;
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      await Bun.write(dest + ".partial", res);
+      renameSync(dest + ".partial", dest);
+      return;
+    } catch (e) {
+      rmSync(dest + ".partial", { force: true });
+      const transient = status === 0 || TRANSIENT(status);
+      if (signal.aborted || !transient || i >= attempts) throw new Error(`download of ${redactUrl(url)} failed: ${(e as Error).message}`);
+      log("download failed, retrying", { url: redactUrl(url), attempt: i, error: (e as Error).message });
+      await Bun.sleep(1000 * 2 ** (i - 1));
+    }
+  }
+}
+
+export function createFetch(deps: FilesDeps) {
+  const cache = new Map<string, string>();
+  return async (input: FileRef): Promise<string> => {
+    const parsed = fileRefSchema.safeParse(input);
+    if (!parsed.success) throw new Error(`ctx.files.fetch: not a valid file reference: ${JSON.stringify(input)}`);
+    const ref = parsed.data;
+    const key = fileKey(ref);
+    const hit = cache.get(key);
+    if (hit) return hit;
+
+    const obj = objectPath(ref.path);
+    const base = join(deps.tmpDir, "files", String(ref.run), ref.step, String(ref.attempt));
+    const objFile = join(base, ".objects", obj);
+    mkdirSync(dirname(objFile), { recursive: true });
+
+    const own = ref.run === deps.run.number && ref.step === deps.run.step && ref.attempt === deps.run.attempt;
+    const urls = urlMap(deps.root);
+    const localDir = process.env[ENV.filesDir];
+    const baseUrl = process.env[ENV.filesBaseUrl];
+    if (own && existsSync(join(deps.workFiles, obj))) copyFileSync(join(deps.workFiles, obj), objFile);
+    else if (urls[key]) await download(urls[key], objFile, {}, deps.signal, deps.log);
+    else if (localDir && existsSync(join(localDir, String(ref.run), ref.step, String(ref.attempt), "files", obj)))
+      copyFileSync(join(localDir, String(ref.run), ref.step, String(ref.attempt), "files", obj), objFile);
+    else if (baseUrl) {
+      const token = process.env[ENV.filesToken];
+      const url = `${baseUrl.replace(/\/+$/, "")}/${ref.run}/${encodeURIComponent(ref.step)}/${ref.attempt}/${obj.split("/").map(encodeURIComponent).join("/")}`;
+      await download(url, objFile, token ? { authorization: `Bearer ${token}` } : {}, deps.signal, deps.log);
+    } else {
+      throw new Error(
+        `ctx.files.fetch: no source for ${key} (set ${ENV.fileUrls} / $OLVE_DIR/files.json, ${ENV.filesBaseUrl} or ${ENV.filesDir})`,
+      );
+    }
+
+    const actual = sha256File(objFile);
+    if (actual !== ref.sha256) {
+      rmSync(objFile, { force: true });
+      throw new Error(`ctx.files.fetch: ${key} has sha256 ${actual}, expected ${ref.sha256}`);
+    }
+    let result = objFile;
+    if (ref.path.endsWith("/")) {
+      result = join(base, ref.path.slice(0, -1));
+      rmSync(result, { recursive: true, force: true });
+      mkdirSync(result, { recursive: true });
+      await extractTar(objFile, result);
+    } else {
+      result = join(base, ref.path);
+      mkdirSync(dirname(result), { recursive: true });
+      renameSync(objFile, result);
+    }
+    cache.set(key, result);
+    return result;
+  };
+}

package/src/ctx/index.ts

@@ -0,0 +1,119 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { skipped } from "../core/handlers.ts";
+import type { Secret } from "../core/secrets.ts";
+import { createFetch, createOutput, redactUrl } from "./files.ts";
+import { createSh } from "./sh.ts";
+import type { Ctx, Http, RetryOptions, RunInfo } from "./types.ts";
+
+export interface CtxOptions {
+  run: RunInfo;
+  /** Declared secrets of the step. */
+  secrets: readonly Secret[];
+  /** Secret values that take precedence over the environment (tests). */
+  secretValues?: Readonly<Record<string, string>>;
+  paths: { root: string; workFiles: string; tmp: string };
+  signal: AbortSignal;
+  /** Where log lines go (default stderr). */
+  logSink?: (line: string) => void;
+}
+
+export function formatLog(message: string, fields?: Record<string, unknown>): string {
+  const parts = Object.entries(fields ?? {}).map(([k, v]) => `${k}=${typeof v === "string" && !/\s|"/.test(v) ? v : JSON.stringify(v)}`);
+  return parts.length ? `${message} ${parts.join(" ")}` : message;
+}
+
+export function createSecrets(declared: readonly Secret[], values?: Readonly<Record<string, string>>): Record<string, string> {
+  const obj: Record<string, string> = {};
+  for (const s of declared) {
+    Object.defineProperty(obj, s.name, {
+      enumerable: true,
+      get() {
+        const v = values?.[s.name] ?? process.env[s.name];
+        if (v === undefined) throw new Error(`secret ${s.name} is not set (the harness reads it from the environment variable ${s.name})`);
+        return v;
+      },
+    });
+  }
+  return Object.freeze(obj);
+}
+
+async function httpError(res: Response, url: string): Promise<Error> {
+  let body = "";
+  try {
+    body = (await res.text()).slice(0, 500);
+  } catch {
+    /* ignore */
+  }
+  return new Error(`HTTP ${res.status} ${res.statusText} from ${redactUrl(url)}${body ? `: ${body}` : ""}`);
+}
+
+export function createHttp(signal: AbortSignal): Http {
+  const f = (url: string, init?: RequestInit) => fetch(url, { ...init, signal: init?.signal ?? signal });
+  return {
+    fetch: f,
+    async getJson<T>(url: string, init?: { headers?: Record<string, string> }): Promise<T> {
+      const res = await f(url, { headers: { accept: "application/json", ...init?.headers } });
+      if (!res.ok) throw await httpError(res, url);
+      return (await res.json()) as T;
+    },
+    async expectOk(url: string, init?: { headers?: Record<string, string>; method?: string }): Promise<Response> {
+      const res = await f(url, { method: init?.method ?? "GET", headers: init?.headers });
+      if (!res.ok) throw await httpError(res, url);
+      return res;
+    },
+  };
+}
+
+export function createRetry(signal: AbortSignal, log: (m: string, f?: Record<string, unknown>) => void) {
+  return async <T>(opts: RetryOptions, fn: (attempt: number) => Promise<T>): Promise<T> => {
+    if (!(Number.isInteger(opts.attempts) && opts.attempts >= 1)) throw new Error("retry: attempts must be a positive integer");
+    let delay = Math.max(0, opts.delaySeconds) * 1000;
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await fn(attempt);
+      } catch (e) {
+        if (attempt >= opts.attempts || signal.aborted) throw e;
+        log("retrying", { attempt, of: opts.attempts, error: (e as Error)?.message ?? String(e) });
+        await new Promise<void>((res, rej) => {
+          const t = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            res();
+          }, delay);
+          const onAbort = () => {
+            clearTimeout(t);
+            rej(new Error("retry cancelled: the step was cancelled"));
+          };
+          signal.addEventListener("abort", onAbort, { once: true });
+        });
+        delay *= opts.backoff ?? 1;
+      }
+    }
+  };
+}
+
+/** The real ctx handed to handlers by the harness (and by testHandler). */
+export function createCtx(o: CtxOptions): Ctx {
+  mkdirSync(o.paths.tmp, { recursive: true });
+  mkdirSync(o.paths.workFiles, { recursive: true });
+  const sink = o.logSink ?? ((line: string) => process.stderr.write(line + "\n"));
+  const log = (message: string, fields?: Record<string, unknown>) => sink(formatLog(message, fields));
+  const { sh, exec } = createSh({ tmpDir: o.paths.tmp, signal: o.signal });
+  const filesDeps = { run: o.run, workFiles: o.paths.workFiles, tmpDir: o.paths.tmp, root: o.paths.root, signal: o.signal, log };
+  return {
+    secrets: createSecrets(o.secrets, o.secretValues) as Ctx["secrets"],
+    sh,
+    exec,
+    readText: async (p) => readFileSync(resolve(p), "utf8"),
+    readJson: async <T>(p: string) => JSON.parse(readFileSync(resolve(p), "utf8")) as T,
+    files: { fetch: createFetch(filesDeps) },
+    output: createOutput(filesDeps),
+    http: createHttp(o.signal),
+    retry: createRetry(o.signal, log),
+    log,
+    signal: o.signal,
+    run: Object.freeze({ ...o.run }),
+    tmpDir: o.paths.tmp,
+    skip: skipped,
+  };
+}