@olivervea/pipelines 2.0.0-beta.21 → 2.0.0-beta.23

package/README.md

@@ -59,7 +59,7 @@ skips when the version exists, or when the pipeline secret `NPM_TOKEN` is unset.
 
 ## Authoring
 
-A pipeline directory (the binding path, `.pipelines/` by default) is an ordinary Bun package. `main` in `package.json` names the entry point, which default-exports the pipeline (`pipeline.ts` when there is no `main`); every other name is yours. A step that carries its implementation, `implement(step({ … }), fn)`, is imported and staged like any value. A plain `step()` needs a top-level `handlers/*.ts` default-exporting `implement(step, fn)`, paired by the step, not the file name; shared code goes in a subfolder.
+A pipeline directory (the binding path, `.pipelines/` by default) is an ordinary Bun package. `main` in `package.json` is required and names the entry point, which default-exports the pipeline; every other name is yours. A step carries its implementation, `implement(step({ … }), fn)`, and is imported and staged like any value.
 
 Describe evaluates the entry point and everything it imports, so top-level code must be deterministic: no env, time or network. Scripts are embedded with `import s from "./x.sh" with { type: "file" }`.
 
@@ -89,6 +89,7 @@ export const deployBeta = step({
 
 Rules:
 
+- `step()` is the contract. A pipeline stages `implement(step, fn)`; a staged step without an implementation is a describe error.
 - Models are **nominal**: two models with the same shape are not interchangeable.
 - There is **one schema per model name**. Two different schemas registered under the same name is a describe error.
 - **Outputs are validated strictly**: unknown keys are rejected at any depth, not stripped.
@@ -165,16 +166,16 @@ Library steps carry their own implementation and image; they take typed settings
 | `httpHealthCheck(ctx, url, { attempts?, delaySeconds?, headers? })` | GETs `url` until it returns 2xx (redirects followed), retrying network errors and non-2xx statuses; defaults 5 attempts, 5 s apart. Throws the last error when the attempts run out. Runs in the harness, so the image needs no curl. `helmDeployOverSsh`'s `healthUrl` uses it. |
 | `serviceUrl(release)` | `http://<release>.<namespace>.svc.cluster.local` for a `HelmRelease` (charts that name the Service after the release). |
 | `checkSpa(ctx, url)` | `GET <url>/` must reference an `/assets/*.js` bundle (Vite's layout) and the bundle must be served as JavaScript; returns `{ html, bundle }` for app-specific checks. |
-| `sshSession(ctx, { host, key })` | Installs openssh-client when the image has no ssh (apk or apt-get), writes the key to `<tmpDir>/ssh/id` (trailing newline, mode 600; host key not verified) and returns `{ run(remote), text(remote), copy(local, remote), shell(remote) }`; `shell` is the quoted ssh command for pipes (`ctx.sh(`printf '%s' "$V" \| ${s.shell("kubectl apply -f -")}`)`). `helmDeployOverSsh` uses it. |
+| `sshSession(ctx, { host, key })` | Installs openssh-client when the image has no ssh (apk or apt-get), writes the key to `<tmpDir>/ssh/id` (trailing newline, mode 600; host key not verified) and returns `{ run(remote, { tty? }), text(remote), copy(local, remote), shell(remote) }`; `shell` is the quoted ssh command for pipes (`ctx.sh(`printf '%s' "$V" \| ${s.shell("kubectl apply -f -")}`)`). `helmDeployOverSsh` uses it. |
 
 ```ts
-import { httpHealthCheck, implement } from "@olivervea/pipelines";
-export default implement(smoke, async (_, ctx) => { await httpHealthCheck(ctx, "http://app.ns.svc.cluster.local/api/health", { attempts: 10 }); });
+import { httpHealthCheck, implement, step } from "@olivervea/pipelines";
+export const smoke = implement(step({ name: "smoke", description: "", image: "alpine:3.22" }), async (_, ctx) => { await httpHealthCheck(ctx, "http://app.ns.svc.cluster.local/api/health", { attempts: 10 }); });
 ```
 
 ### Reusable steps
 
-A step several pipelines use is a function returning `implement(step(…), handler)`, staged directly: it carries its handler, so it has no `handlers/` file. The library steps are written this way, so a module in a repo or a package of its own works the same.
+A step several pipelines use is a function returning `implement(step(…), handler)`, staged directly. The library steps are written this way, so a module in a repo or a package of its own works the same.
 
 ```ts
 import { implement, resolveConfigRefs, serviceUrl, step, HelmRelease, type Configurable, type LiteralName } from "@olivervea/pipelines";
@@ -189,17 +190,15 @@ export function smokeTest<const N extends string>(def: { name: LiteralName<N>; d
 
 - **`kind`**: a label, `custom` unless the step names one. Prefix a package's kinds (`acme/smokeTest`).
 - **`settings`**: what the step was set up with, recorded as the step's manifest `config` (so part of its version). JSON values and config references; the step receives every entry its settings reference.
-- `implement` refuses a step that already carries an implementation; a `handlers/*.ts` file for such a step is a describe error.
+- `implement` refuses a step that already carries an implementation.
 
 ### Handlers
 
 ```ts
-// handlers/deploy-beta.ts
-import { implement } from "@olivervea/pipelines";
-import { deployBeta } from "../pipeline";
-import deployScript from "../scripts/deploy.sh" with { type: "file" };
+import { implement, step } from "@olivervea/pipelines";
+import deployScript from "./scripts/deploy.sh" with { type: "file" };
 
-export default implement(deployBeta, async ({ artifact }, ctx) => {
+export const deployBeta = implement(step({ name: "deploy-beta", /* … */ }), async ({ artifact }, ctx) => {
   await ctx.sh(deployScript, { env: { IMAGE_TAR: await ctx.files.fetch(artifact.image), CHART_DIR: await ctx.files.fetch(artifact.chart) } });
   await ctx.retry({ attempts: 5, delaySeconds: 5 }, () => ctx.http.expectOk("https://pipelines-beta.ovea.pro/api/health"));
   return { release: "olve-pipelines", version: artifact.version, url: "https://pipelines-beta.ovea.pro" };   // or ctx.skip("reason")
@@ -251,13 +250,13 @@ export default pipeline({ name: "Olve.Pipelines", description: "…", input: M.D
 
 ```ts
 import { testHandler, testFileRef } from "@olivervea/pipelines/testing";
-import deployBeta from "../handlers/deploy-beta";
+import { deployBeta } from "../steps/deploy-beta";
 
 const r = await testHandler(deployBeta, { artifact }, { secrets: { SSH_PRIVATE_KEY: "k" }, config: { target: { host: "h" } }, ctx: { http: fakeHttp }, run: { number: 412 } });
 expect(r).toMatchObject({ status: "succeeded", output: { release: "olve-pipelines" } });   // r.filesDir, r.logs, r.exitCode
 ```
 
-`testHandler` uses the same validation path as a real run. Invalid input gives `status: "failed"` with `kind: "input"`; an invalid return value gives `kind: "output"`. Any part of `ctx` can be replaced; whatever you don't replace is the real implementation. `testHandler` takes any implementation: a handler module's default export, a library step or a reusable step.
+`testHandler` uses the same validation path as a real run. Invalid input gives `status: "failed"` with `kind: "input"`; an invalid return value gives `kind: "output"`. Any part of `ctx` can be replaced; whatever you don't replace is the real implementation. `testHandler` takes any implementation: a custom step, a library step or a reusable step.
 
 ## Harness contract (service ⇄ step binary)
 
@@ -337,7 +336,7 @@ For `map-trigger`, `output` is the pipeline input after it has been parsed by th
 | 65 | `input.json` missing, not JSON, or invalid for the step (or event), including its `$config` | failed / `input` |
 | 66 | the return value failed strict validation, or an own file ref is missing or changed | failed / `output` |
 | 74 | the `result.tar.gz` upload failed after retries. Used only when the step itself succeeded; otherwise the step's own code wins. | yes (printed) |
-| 78 | the pipeline is invalid (describe problems, or a missing or wrong handler module) | none |
+| 78 | the pipeline is invalid (describe problems, or a step without an implementation) | none |
 | 130 / 143 | the handler failed after SIGINT / SIGTERM (cancellation, `activeDeadlineSeconds`) | failed / `handler` |
 
 ### Result upload (`OLVE_RESULT_URL`)
@@ -368,7 +367,7 @@ Exact format: [`manifest.schema.json`](manifest.schema.json) (JSON Schema 2020-1
 - **`apiVersion`** is `"2.0"`.
 - **`harness`** is `{ bun, sdk, sdkHash }`.
 - **`models[name]`** is `{ output, input? }`.
-- **Step `kind`** is `custom` (a handler file) or the kind of a step that carries its implementation (`imageBuild`, `composeDeploy`, a package's `acme/…`). To the service it is a label: any non-empty kind is accepted, so a new library or package step needs no service change.
+- **Step `kind`** is `custom` by default, or what a reusable step names (`imageBuild`, `composeDeploy`, a package's `acme/…`). To the service it is a label: any non-empty kind is accepted, so a new library or package step needs no service change.
   - `output` is the `z.output` view, with `additionalProperties: false` on every object. It validates outputs, the pool and trigger results.
   - `input` is the `z.input` view (defaults optional). Use it for trigger forms and manual input. It is emitted only when it differs from `output` beyond `additionalProperties`.
 - **Step `input`** maps each input key to a mapping:
@@ -379,7 +378,7 @@ Exact format: [`manifest.schema.json`](manifest.schema.json) (JSON Schema 2020-1
   An object whose only key is `ref` (with a string value) or `const` is a tag. Describe never emits a nested object with exactly that key set. Model-matched inputs are emitted already resolved (`{"ref": "build"}`).
 - **Step `externalInputs`** (when present) maps each external input key to `{model, title, description, from}`, `from` being `{kind: "person"}`, `{kind: "callback"}` or `{kind: "poll", url, valuePath, intervalSeconds}`. Those keys are not in `input` or `inputTypes`; the service merges the answers into `input.json`.
 - **`inputTypes`** declares each input key: `{model, optional}`, or `{schema: {output, input?}}` for a plain schema.
-- **`codeHash`** is the build's identity: `sha256(canonical {bundle, harness})`. `bundle` hashes the entry point and any `handlers/*.ts` bundled together, with `@olivervea/pipelines` external. It is tree-shaken and includes embedded scripts and dependencies, so any change to code in use changes it, and with it the manifest, which makes a new pipeline version. A step version covers what the step declares: image, `inputTypes`/model versions, `output` model version, `secrets`, `configEntries` (and those entries' schemas), `input` mappings and `config`.
+- **`codeHash`** is the build's identity: `sha256(canonical {bundle, harness})`. `bundle` hashes the entry point bundled with everything it imports, with `@olivervea/pipelines` external. It is tree-shaken and includes embedded scripts and dependencies, so any change to code in use changes it, and with it the manifest, which makes a new pipeline version. A step version covers what the step declares: image, `inputTypes`/model versions, `output` model version, `secrets`, `configEntries` (and those entries' schemas), `input` mappings and `config`.
 - **`stages`** is an array whose items are either `{steps: [Step…]}` (parallel, with a barrier) or `{when: {field: [values]}, stages: [...]}`.
 - **`triggers`**:
   - `{kind: "push", name: "push"}`;
@@ -395,7 +394,7 @@ Describe runs these checks; reconcile should re-run the manifest-level ones:
 
 - step name format and reserved names (`input`, `failure`), and duplicate step names;
 - one schema per model name, and JSON-representable models;
-- missing handler file, a handler file without a step (or for a step that carries its implementation), and a step that carries its implementation without a kind;
+- a staged step without an implementation, and an empty step kind;
 - availability, ambiguity, maybe-available as required, `optional` without a producer, plain schema without a mapper;
 - mapper source analysis and recording, unknown fields in refs, mapper keys that are missing or extra;
 - `when` on an unknown or non-literal field, or with an invalid value;
@@ -411,8 +410,8 @@ olve-build <pipelineDir> --out <dir> [--target bun-linux-x64|bun-linux-x64-musl]
 olve-build <pipelineDir> --hash-only          # print the code hash (diagnostics)
 ```
 
-1. Pair each `handlers/*.ts` with the step its `implement(step, …)` names, and hash the build (see `codeHash`).
-2. Generate `<pipelineDir>/.olve/gen/handlers.ts` (a registry of literal `import()` paths, plus the code hash and harness info) and `entry.ts`. Add `.olve/` to `.gitignore`.
+1. Read the entry point from `main` in `package.json` (a missing `main`, or a `main` whose file is missing, is an error) and hash the build (see `codeHash`).
+2. Generate `<pipelineDir>/.olve/gen/entry.ts`, which imports the pipeline and calls `runHarness` with it, the code hash and the harness info. Add `.olve/` to `.gitignore`.
 3. Run `bun build --compile --target=bun-linux-x64 --no-compile-autoload-dotenv --no-compile-autoload-bunfig --bytecode --format=esm` → `<out>/step`. The output is never minified, because mapper source analysis needs real source.
 4. Check that `PT_INTERP` is `/lib64/ld-linux-x86-64.so.2`. On alpine, Bun silently produces a musl binary; the check fails it.
 5. Run `<out>/step describe` → `<out>/manifest.json`. A describe problem is a build failure with exit 78. **A step with no implementation is an error.**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olivervea/pipelines",
-  "version": "2.0.0-beta.21",
+  "version": "2.0.0-beta.23",
   "description": "Olve.Pipelines v2 SDK: typed pipeline authoring, the step harness, and the build tool.",
   "type": "module",
   "license": "MIT",

package/src/build/build.ts

@@ -48,7 +48,7 @@ export interface BuildResult {
   harness: HarnessInfo;
 }
 
-/** Writes `<dir>/.olve/gen/{handlers,entry}.ts`: the literal-import handler registry + binary entry. */
+/** Writes `<dir>/.olve/gen/entry.ts`, the entry point of the step binary. */
 export function generateEntry(
   project: Project,
   code: string,
@@ -56,28 +56,14 @@ export function generateEntry(
 ): string {
   const gen = join(project.dir, '.olve', 'gen');
   mkdirSync(gen, { recursive: true });
-  const registry = project.handlers
-    .map(
-      ([name, file]) =>
-        `  ${JSON.stringify(name)}: () => import(${JSON.stringify(relPosix(gen, file))}),`,
-    )
-    .join('\n');
-  writeFileSync(
-    join(gen, 'handlers.ts'),
-    `// GENERATED by olve-build — do not edit.\n` +
-      `import type { HandlerRegistry, HarnessInfo } from "@olivervea/pipelines/harness";\n\n` +
-      `export const handlers: HandlerRegistry = {\n${registry}\n};\n\n` +
-      `export const codeHash = ${JSON.stringify(code)};\n\n` +
-      `export const harness: HarnessInfo = ${JSON.stringify(harness, null, 2)};\n`,
-  );
   const entry = join(gen, 'entry.ts');
+  const config = `{ pipeline, codeHash: ${JSON.stringify(code)}, harness: ${JSON.stringify(harness)} }`;
   writeFileSync(
     entry,
     `// GENERATED by olve-build — do not edit. Entry point of the step binary.\n` +
       `import pipeline from ${JSON.stringify(relPosix(gen, project.pipelineFile))};\n` +
-      `import { runHarness } from "@olivervea/pipelines/harness";\n` +
-      `import { handlers, codeHash, harness } from "./handlers.ts";\n\n` +
-      `process.exit(await runHarness({ pipeline, handlers, codeHash, harness }, process.argv.slice(2)));\n`,
+      `import { runHarness } from "@olivervea/pipelines/harness";\n\n` +
+      `process.exit(await runHarness(${config}, process.argv.slice(2)));\n`,
   );
   return entry;
 }

package/src/build/hashes.ts

@@ -1,11 +1,9 @@
 // The build's code hash: everything the pipeline runs, bundled once with the SDK external (the
 // harness identity stands for it).
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
 import type { BunPlugin } from 'bun';
 import { sha256Hex } from '../util/hash.ts';
 import { composeCodeHash, type HarnessInfo } from '../util/code-hash.ts';
-import { relPosix, type Project } from './project.ts';
+import type { Project } from './project.ts';
 
 const sdkExternal: BunPlugin = {
   name: 'olve-code-hash-external',
@@ -17,7 +15,8 @@ const sdkExternal: BunPlugin = {
   },
 };
 
-async function bundleHash(project: Project, entry: string): Promise<string> {
+async function bundleHash(project: Project): Promise<string> {
+  const entry = project.pipelineFile;
   const r = await Bun.build({
     entrypoints: [entry],
     target: 'bun',
@@ -53,18 +52,5 @@ async function bundleHash(project: Project, entry: string): Promise<string> {
 }
 
 export async function codeHash(project: Project, harness: HarnessInfo): Promise<string> {
-  const gen = join(project.dir, '.olve', 'gen');
-  mkdirSync(gen, { recursive: true });
-  const entry = join(gen, 'code.ts');
-  const files = [project.pipelineFile, ...project.handlers.map(([, file]) => file)];
-  writeFileSync(
-    entry,
-    files
-      .map(
-        (f, i) =>
-          `export { default as m${i} } from ${JSON.stringify(relPosix(gen, f))};\n`,
-      )
-      .join(''),
-  );
-  return composeCodeHash(await bundleHash(project, entry), harness);
+  return composeCodeHash(await bundleHash(project), harness);
 }

package/src/build/project.ts

@@ -1,7 +1,6 @@
 // Layout of a pipeline directory and the identity of the SDK building it.
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
-import { isImplementation } from '../core/handlers.ts';
 import { sha256Hex } from '../util/hash.ts';
 import type { HarnessInfo } from '../util/code-hash.ts';
 
@@ -10,8 +9,6 @@ export const SDK_ROOT = resolve(import.meta.dir, '../..');
 export interface Project {
   dir: string;
   pipelineFile: string;
-  /** step name → absolute handler file, sorted by step name. The step is the one the file's `implement(step, …)` names. */
-  handlers: [string, string][];
 }
 
 export class ProjectError extends Error {
@@ -22,36 +19,23 @@ export async function loadProject(dirArg: string): Promise<Project> {
   const dir = resolve(dirArg);
   if (!existsSync(dir) || !statSync(dir).isDirectory())
     throw new ProjectError(`${dirArg} is not a directory`);
-  const pipelineFile = entryOf(dirArg, dir);
-  const hdir = join(dir, 'handlers');
-  const files = existsSync(hdir)
-    ? readdirSync(hdir)
-        .filter(
-          (f) =>
-            f.endsWith('.ts') &&
-            !f.endsWith('.test.ts') &&
-            !f.endsWith('.d.ts') &&
-            statSync(join(hdir, f)).isFile(),
-        )
-        .sort()
-    : [];
-  return {
-    dir,
-    pipelineFile,
-    handlers: await resolveHandlers(hdir, files),
-  };
+  return { dir, pipelineFile: entryOf(dirArg, dir) };
 }
 
-/** The package's `main`, or `pipeline.ts` in a package that doesn't name one. */
+/** The file `main` in the package's package.json names. */
 function entryOf(dirArg: string, dir: string): string {
   const pkg = join(dir, 'package.json');
   const main = existsSync(pkg)
     ? (JSON.parse(readFileSync(pkg, 'utf8')) as { main?: string }).main
     : undefined;
-  const entry = join(dir, main ?? 'pipeline.ts');
+  if (!main)
+    throw new ProjectError(
+      `${join(dirArg, 'package.json')} must name the entry point in \`main\` (a file that default-exports pipeline({...}))`,
+    );
+  const entry = join(dir, main);
   if (!existsSync(entry))
     throw new ProjectError(
-      `${join(dirArg, main ?? 'pipeline.ts')} not found (it must default-export pipeline({...}))`,
+      `${join(dirArg, main)} not found (it must default-export pipeline({...}))`,
     );
   return entry;
 }
@@ -66,37 +50,6 @@ export async function loadPipeline(project: Project): Promise<unknown> {
   return mod.default;
 }
 
-/** Pairs each handler file with the step its default export implements (file names don't matter). */
-async function resolveHandlers(
-  hdir: string,
-  files: string[],
-): Promise<[string, string][]> {
-  const byStep = new Map<string, string>();
-  for (const f of files) {
-    const file = join(hdir, f);
-    let impl: unknown;
-    try {
-      impl = ((await import(file)) as { default?: unknown }).default;
-    } catch (e) {
-      throw new ProjectError(
-        `handlers/${f} failed to load: ${(e as Error)?.message ?? String(e)}`,
-      );
-    }
-    if (!isImplementation(impl))
-      throw new ProjectError(
-        `handlers/${f} must default-export implement(<step>, …); put shared code in a subfolder such as handlers/lib/`,
-      );
-    const step = (impl.step as { name: string }).name;
-    const other = byStep.get(step);
-    if (other)
-      throw new ProjectError(
-        `handlers/${other.slice(hdir.length + 1)} and handlers/${f} both implement step '${step}'`,
-      );
-    byStep.set(step, file);
-  }
-  return [...byStep].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-}
-
 function listFiles(dir: string): string[] {
   const out: string[] = [];
   for (const e of readdirSync(dir, { withFileTypes: true })) {

package/src/builder/pipeline.ts

@@ -314,7 +314,7 @@ export function pipelineData(p: unknown): PipelineData {
       : undefined;
   if (!d)
     throw new TypeError(
-      'not a pipeline (pipeline.ts must default-export pipeline({...})...)',
+      'not a pipeline (the entry point must default-export pipeline({...})...)',
     );
   return d as PipelineData;
 }
@@ -553,7 +553,7 @@ export class Pipeline<In extends AnyModel, A extends AvailMap> {
   }
 }
 
-/** Start a pipeline definition. `pipeline.ts` must default-export the result. */
+/** Start a pipeline definition. The entry point must default-export the result. */
 export function pipeline<In extends AnyModel>(
   def: PipelineDef<In>,
 ): Pipeline<In, InitialAvail<In>> {

package/src/core/handlers.ts

@@ -30,7 +30,7 @@ export type Handler<S extends AnyStep> = (
   ctx: Ctx<SecretsOf<S>, ConfigOf<S>>,
 ) => Awaitable<HandlerResult<S>>;
 
-/** A step with its handler. It is itself a step: stage it directly, or default-export it from `handlers/*.ts`. */
+/** A step with its handler. It is itself a step: stage it like any value. */
 export type Implementation<S extends AnyStep = AnyStep> = S & {
   readonly [ImplementationBrand]: true;
   /** The step as defined. */
@@ -48,8 +48,8 @@ type NoExtraFields<R, T> = R extends Skipped | void
     };
 
 /**
- * Implement a step. Input, ctx and return types come from the step definition alone. Default-export
- * the result from a `handlers/*.ts` file, or stage it directly (a reusable step: give it a `kind`).
+ * Implement a step. Input, ctx and return types come from the step definition alone. Stage the
+ * result directly; a reusable step gives itself a `kind`.
  */
 export function implement<S extends AnyStep, R extends HandlerResult<S>>(
   step: S &

package/src/core/steps.ts

@@ -28,8 +28,7 @@ export type InferEntry<E> =
 export type StepInput<I> = Simplify<{ -readonly [K in keyof I]: InferEntry<I[K]> }>;
 
 /**
- * A label for what a step is, shown in the UI. `custom` (the default) is a step whose handler is in
- * `handlers/`; a step that carries its implementation (`implement(step, …)` staged directly) names its
+ * A label for what a step is, shown in the UI. `custom` is the default; a reusable step names its
  * kind, e.g. `gitHubSource`. Packages prefix theirs (`acme/deploy`).
  */
 export type StepKind = string;
@@ -142,8 +141,8 @@ export function isStep(v: unknown): v is AnyStep {
 }
 
 /**
- * Define a step: a contract (name, image, inputs, output, secrets). Its handler is a `handlers/*.ts`
- * default-exporting `implement(step, …)`, or, for a reusable step, `implement(step, …)` staged directly.
+ * Define a step: a contract (name, image, inputs, output, secrets). `implement(step, fn)` gives it
+ * its handler; that is what a pipeline stages.
  */
 export function step<
   const N extends string,

package/src/describe/describe.ts

@@ -40,8 +40,6 @@ export class DescribeError extends Error {
 }
 
 export interface DescribeOptions {
-  /** Step names that have a handler (a `handlers/*.ts` default-exporting `implement(step, …)`). */
-  handlerNames: Iterable<string>;
   /** Hash of the build (from the build; includes the harness identity). */
   codeHash?: string;
   harness: HarnessInfo;
@@ -126,7 +124,6 @@ function literalValues(field: JsonSchema | undefined): unknown[] | undefined {
 export function describePipeline(pipeline: unknown, opts: DescribeOptions): ManifestT {
   const data = pipelineData(pipeline);
   const problems: string[] = [...data.problems];
-  const handlerNames = new Set(opts.handlerNames);
 
   // ── models ──
   const models = new Map<string, { schemas: ModelSchemasT; key: string }>();
@@ -229,20 +226,10 @@ export function describePipeline(pipeline: unknown, opts: DescribeOptions): Mani
     const prev = placements.get(s.name) ?? [];
     if (prev.some((p) => !exclusive(p.cases, cases)))
       problems.push(`duplicate step name '${s.name}'`);
-    else if (prev.length) {
-      if (
-        prev.some(
-          (p) => p.step !== s && !isImplementation(p.step) && !isImplementation(s),
-        )
-      )
-        problems.push(
-          `step '${s.name}': two different steps with handler files share the name across select cases; handlers pair by name, so use one step or different names`,
-        );
-      if (prev.some((p) => (p.step.output?.name ?? null) !== (s.output?.name ?? null)))
-        problems.push(
-          `step '${s.name}': its select cases must give it the same output model`,
-        );
-    }
+    else if (prev.some((p) => (p.step.output?.name ?? null) !== (s.output?.name ?? null)))
+      problems.push(
+        `step '${s.name}': its select cases must give it the same output model`,
+      );
     placements.set(s.name, [...prev, { step: s, cases }]);
     if (!steps.has(s.name)) steps.set(s.name, s);
   };
@@ -455,10 +442,8 @@ export function describePipeline(pipeline: unknown, opts: DescribeOptions): Mani
           `${at}: config reference '${ref}': config '${entry}' has no field '${path.join('.')}'`,
         );
     }
-    if (!carried && !handlerNames.has(s.name))
-      problems.push(
-        `${at} has no implementation (implement(${camel(s.name)}, …) and stage that, or add a handlers/*.ts default-exporting it)`,
-      );
+    if (!carried)
+      problems.push(`${at} has no implementation (stage implement(step({...}), fn))`);
     if (typeof s.description !== 'string')
       problems.push(`${at}: description must be a string (it may be empty)`);
     if (
@@ -718,17 +703,6 @@ export function describePipeline(pipeline: unknown, opts: DescribeOptions): Mani
     })
     .filter((x) => x !== undefined);
 
-  // ── handlers without a step ──
-  for (const h of handlerNames) {
-    const s = steps.get(h);
-    if (!s)
-      problems.push(`a handler implements step '${h}', which is not in the pipeline`);
-    else if (isImplementation(s))
-      problems.push(
-        `a handler implements '${h}', a ${s.kind} step that carries its own implementation`,
-      );
-  }
-
   // ── triggers ──
   const triggerNames = new Set<string>();
   const triggers: TriggerT[] = data.triggers.map((t) => {
@@ -930,7 +904,3 @@ interface CaseOf {
   value: string;
   cond: string;
 }
-
-function camel(name: string): string {
-  return name.replace(/-([a-z0-9])/g, (_, c: string) => c.toUpperCase());
-}

package/src/dev/cli.ts

@@ -36,12 +36,6 @@ export async function devConfig(
   const harness = harnessInfo();
   return {
     pipeline,
-    handlers: Object.fromEntries(
-      project.handlers.map(([name, file]) => [
-        name,
-        () => import(file) as Promise<{ default: unknown }>,
-      ]),
-    ),
     ...(withHashes ? { codeHash: await codeHash(project, harness) } : {}),
     harness,
   };

package/src/harness/exit.ts

@@ -11,7 +11,7 @@ export const EXIT = {
   outputInvalid: 66,
   /** Uploading result.tar.gz to OLVE_RESULT_URL failed (after retries). The envelope was still printed. */
   uploadFailed: 74,
-  /** The pipeline is invalid: describe problems, missing/invalid handler module. */
+  /** The pipeline is invalid: describe problems, a step without an implementation. */
   configInvalid: 78,
   /** Cancelled by SIGINT / SIGTERM (128 + signal). */
   sigint: 130,

package/src/harness/index.ts

@@ -5,7 +5,6 @@ export {
   allSteps,
   resolveStepFunction,
   type HarnessConfig,
-  type HandlerRegistry,
   type HarnessIO,
 } from './main.ts';
 export { EXIT } from './exit.ts';

package/src/harness/main.ts

@@ -31,15 +31,9 @@ import {
 } 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 interface HarnessConfig {
   /** Default export of the entry point. */
   pipeline: unknown;
-  handlers: HandlerRegistry;
   /** Hash of the build (from the build; includes the harness identity). */
   codeHash?: string;
   harness: HarnessInfo;
@@ -129,26 +123,10 @@ export function cancellation(): { signal: AbortSignal; dispose(): void } {
   };
 }
 
-/** 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> {
+/** The function `step` carries, or what is wrong. */
+export function resolveStepFunction(step: AnyStep): 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`;
-  let mod: { default: unknown };
-  try {
-    mod = await load();
-  } catch (e) {
-    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 (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;
+  return `step '${step.name}' has no implementation (stage implement(step({...}), fn))`;
 }
 
 /** Writes output.json, prints the sentinel block and uploads result.tar.gz when OLVE_RESULT_URL is set. */
@@ -189,7 +167,6 @@ async function describeMode(
   try {
     const text = manifestText(
       describePipeline(cfg.pipeline, {
-        handlerNames: Object.keys(cfg.handlers),
         codeHash: cfg.codeHash,
         harness: cfg.harness,
       }),
@@ -214,7 +191,7 @@ async function runMode(
   const data = pipelineData(cfg.pipeline);
   const step = findStep(data, name, selectedCases());
   if (typeof step === 'string') return (io.stderr(step), EXIT.usage);
-  const fn = await resolveStepFunction(step, cfg.handlers);
+  const fn = resolveStepFunction(step);
   if (typeof fn === 'string') return (io.stderr(fn), EXIT.configInvalid);
 
   const p = paths();

package/src/library/ssh.ts

@@ -16,8 +16,11 @@ export const SSH_CLIENT_INSTALL =
 
 export interface SshSession {
   readonly host: string;
-  /** Runs a remote command; a non-zero exit throws. */
-  run(remote: string): Promise<void>;
+  /**
+   * Runs a remote command; a non-zero exit throws. With `tty`, the command gets a terminal, so a client that
+   * dies (a cancelled step) hangs it up: without one, the command gets no signal and carries on.
+   */
+  run(remote: string, options?: { tty?: boolean }): Promise<void>;
   /** Runs a remote command and returns its stdout. */
   text(remote: string): Promise<string>;
   /** `scp -r` a local file or directory to a remote path. */
@@ -58,7 +61,8 @@ export async function sshSession(
   const argv = (remote: string) => ['ssh', ...sshOpts, opts.host, remote];
   return {
     host: opts.host,
-    run: (remote) => ctx.exec(argv(remote)),
+    run: (remote, options) =>
+      ctx.exec(options?.tty ? ['ssh', '-tt', ...argv(remote).slice(1)] : argv(remote)),
     text: (remote) => ctx.sh.text(argv(remote).map(shq).join(' ')),
     copy: (local, remote) =>
       ctx.exec(['scp', ...sshOpts, '-r', local, `${opts.host}:${remote}`]),

package/src/testing/index.ts

@@ -46,7 +46,7 @@ export type TestResult<S extends AnyStep> = {
 );
 
 /**
- * Runs an implementation (a handler module's default export, or a step that carries its own) with `input`.
+ * Runs a step that carries its implementation with `input`.
  * Input is validated like `input.json`, the result like a real run: an invalid output gives
  * `{ status: "failed", error: { kind: "output" } }`, a throwing handler `kind: "handler"`.
  */
@@ -57,7 +57,7 @@ export async function testHandler<S extends AnyStep>(
 ): Promise<TestResult<S>> {
   if (!isImplementation(target))
     throw new TypeError(
-      "testHandler expects implement(…): a handler module's default export or a step that carries its implementation",
+      'testHandler expects implement(…): a step that carries its implementation',
     );
   const step: AnyStep = target.step;
   const fn = target.handler as unknown as StepFunction;