@olivervea/pipelines 2.0.0-beta.2 → 2.0.0-beta.20

package/manifest.schema.json

@@ -47,6 +47,42 @@
           "const": "2.0",
           "type": "string"
         },
+        "config": {
+          "description": "Config entries used by steps, sorted by name (omitted when none). Fields of kind secretRef ({secret: NAME}) name a secret.",
+          "items": {
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "type": "string"
+              },
+              "name": {
+                "description": "Config entry name; a key of the pipeline's config document.",
+                "pattern": "^[a-z][a-zA-Z0-9]*$",
+                "type": "string"
+              },
+              "required": {
+                "description": "False when the schema accepts a missing value (optional, or a default).",
+                "type": "boolean"
+              },
+              "schema": {
+                "additionalProperties": {},
+                "description": "z.input view: validates the config document's value for this entry (defaults listed).",
+                "propertyNames": {
+                  "type": "string"
+                },
+                "type": "object"
+              }
+            },
+            "required": [
+              "name",
+              "description",
+              "required",
+              "schema"
+            ],
+            "type": "object"
+          },
+          "type": "array"
+        },
         "description": {
           "type": "string"
         },
@@ -92,7 +128,7 @@
               "type": "string"
             },
             "sdk": {
-              "description": "@olve/pipelines package version.",
+              "description": "@olivervea/pipelines package version.",
               "type": "string"
             },
             "sdkHash": {
@@ -129,6 +165,28 @@
           "minLength": 1,
           "type": "string"
         },
+        "retention": {
+          "additionalProperties": false,
+          "description": "Retention overrides for this pipeline (omitted when none). Each field replaces the instance setting of the same meaning.",
+          "properties": {
+            "buildGraceDays": {
+              "maximum": 9007199254740991,
+              "minimum": 0,
+              "type": "integer"
+            },
+            "keepLatestRuns": {
+              "maximum": 9007199254740991,
+              "minimum": 0,
+              "type": "integer"
+            },
+            "minRunAgeDays": {
+              "maximum": 9007199254740991,
+              "minimum": 0,
+              "type": "integer"
+            }
+          },
+          "type": "object"
+        },
         "secrets": {
           "description": "All declared secrets (steps + poll triggers), sorted by name.",
           "items": {
@@ -297,28 +355,173 @@
             "stages"
           ],
           "type": "object"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "cases": {
+              "additionalProperties": {
+                "items": {
+                  "$ref": "#/$defs/Stage"
+                },
+                "type": "array"
+              },
+              "description": "Discriminator value → stages. Exactly one case runs; a step name may repeat across cases, nowhere else.",
+              "propertyNames": {
+                "type": "string"
+              },
+              "type": "object"
+            },
+            "discriminator": {
+              "description": "The union's literal field whose value names the case.",
+              "minLength": 1,
+              "type": "string"
+            },
+            "select": {
+              "description": "Config reference (`<entry>.<field>…`) to a discriminated union; the run's config snapshot picks the case.",
+              "minLength": 1,
+              "type": "string"
+            }
+          },
+          "required": [
+            "select",
+            "discriminator",
+            "cases"
+          ],
+          "type": "object"
         }
       ]
     },
     "Step": {
       "additionalProperties": false,
       "properties": {
+        "clusterAccess": {
+          "const": true,
+          "description": "The step pod gets the instance's step ServiceAccount token (Kubernetes:StepServiceAccount), if the instance grants one. Omitted = no token.",
+          "type": "boolean"
+        },
         "config": {
           "additionalProperties": {
             "$ref": "#/$defs/Json"
           },
-          "description": "Library-step configuration (display only; already covered by handlerHash).",
+          "description": "The step's settings (display only; already covered by handlerHash). A config reference is recorded as {\"$config\": \"<entry>.<field>…\"}; the entry is in configEntries.",
           "propertyNames": {
             "type": "string"
           },
           "type": "object"
         },
+        "configEntries": {
+          "description": "Config entries the step receives (sorted; omitted when none). The service delivers them in input.json under '$config'.",
+          "items": {
+            "description": "Config entry name; a key of the pipeline's config document.",
+            "pattern": "^[a-z][a-zA-Z0-9]*$",
+            "type": "string"
+          },
+          "type": "array"
+        },
         "description": {
           "description": "What the step does, shown in the UI (may be empty).",
           "type": "string"
         },
+        "externalInputs": {
+          "additionalProperties": {
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "type": "string"
+              },
+              "from": {
+                "description": "Who or what may answer.",
+                "items": {
+                  "oneOf": [
+                    {
+                      "additionalProperties": false,
+                      "properties": {
+                        "kind": {
+                          "const": "person",
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "kind"
+                      ],
+                      "type": "object"
+                    },
+                    {
+                      "additionalProperties": false,
+                      "properties": {
+                        "kind": {
+                          "const": "callback",
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "kind"
+                      ],
+                      "type": "object"
+                    },
+                    {
+                      "additionalProperties": false,
+                      "properties": {
+                        "intervalSeconds": {
+                          "maximum": 9007199254740991,
+                          "minimum": 10,
+                          "type": "integer"
+                        },
+                        "kind": {
+                          "const": "poll",
+                          "type": "string"
+                        },
+                        "url": {
+                          "description": "GET while waiting; {run.id} and {run.number} are filled in.",
+                          "type": "string"
+                        },
+                        "valuePath": {
+                          "description": "Dot path to the value; '.' is the whole body.",
+                          "minLength": 1,
+                          "type": "string"
+                        }
+                      },
+                      "required": [
+                        "kind",
+                        "url",
+                        "valuePath",
+                        "intervalSeconds"
+                      ],
+                      "type": "object"
+                    }
+                  ]
+                },
+                "minItems": 1,
+                "type": "array"
+              },
+              "model": {
+                "description": "The value is validated against this model's input view.",
+                "pattern": "^[A-Za-z][A-Za-z0-9_]*$",
+                "type": "string"
+              },
+              "title": {
+                "description": "What is asked, shown to whoever answers.",
+                "minLength": 1,
+                "type": "string"
+              }
+            },
+            "required": [
+              "model",
+              "title",
+              "description",
+              "from"
+            ],
+            "type": "object"
+          },
+          "description": "Inputs answered from outside the run (omitted when none): the step waits until every one has a value, which the service writes into input.json under its key.",
+          "propertyNames": {
+            "type": "string"
+          },
+          "type": "object"
+        },
         "handlerHash": {
-          "description": "Implementation identity: handler bundle (contract files excluded) + harness (bun + sdkHash); for library steps kind + config + harness.",
+          "description": "Implementation identity: handler bundle (contract files excluded) + harness (bun + sdkHash); for a step that carries its implementation kind + config + harness + the hash of the code of its kind.",
           "pattern": "^sha256:[0-9a-f]{64}$",
           "type": "string"
         },
@@ -348,14 +551,8 @@
           "type": "object"
         },
         "kind": {
-          "description": "'custom' = handlers/<name>.ts; others are SDK library steps.",
-          "enum": [
-            "custom",
-            "script",
-            "gitHubSource",
-            "imageBuild",
-            "helmDeployOverSsh"
-          ],
+          "description": "'custom' = the handler is a handlers/*.ts file; any other kind is a step that carries its implementation (an SDK or package step). A label: the service accepts any kind.",
+          "minLength": 1,
           "type": "string"
         },
         "name": {

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@olivervea/pipelines",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.20",
   "description": "Olve.Pipelines v2 SDK: typed pipeline authoring, the step harness, and the build tool.",
   "type": "module",
   "license": "MIT",
   "author": "Oliver Vea",
-  "homepage": "https://github.com/OliverVea/Olve.Pipelines/tree/v2/sdk#readme",
+  "homepage": "https://github.com/OliverVea/Olve.Pipelines/tree/main/sdk#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OliverVea/Olve.Pipelines.git",
-    "directory": "sdk"
+    "directory": "src/sdk"
   },
   "bugs": {
     "url": "https://github.com/OliverVea/Olve.Pipelines/issues"
@@ -50,13 +50,15 @@
     "test": "bun test",
     "check-compile-fail": "bun scripts/check-compile-fail.ts",
     "gen-schema": "bun scripts/gen-manifest-schema.ts",
-    "check": "tsc --noEmit -p . && bun scripts/check-compile-fail.ts && bun test"
+    "check": "prettier --check . && tsc --noEmit -p . && bun scripts/check-compile-fail.ts && bun test",
+    "format": "prettier --write ."
   },
   "dependencies": {
     "zod": "4.6.7"
   },
   "devDependencies": {
     "@types/bun": "1.4.3",
+    "prettier": "^3.5.0",
     "typescript": "7.0.2"
   }
 }

package/src/assets.d.ts

@@ -1,10 +1,10 @@
 // `import script from "./scripts/x.sh" with { type: "file" }` yields a path string
 // (inside the compiled binary it points into the embedded /$bunfs filesystem).
-declare module "*.sh" {
+declare module '*.sh' {
   const path: string;
   export default path;
 }
-declare module "*.bash" {
+declare module '*.bash' {
   const path: string;
   export default path;
 }

package/src/build/build.ts

@@ -1,21 +1,35 @@
-// olve-build: pipeline dir → single executable + step.tar.gz + manifest.json.
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { canonicalJson } from "../util/canonical.ts";
-import { sha256File } from "../util/hash.ts";
-import type { HarnessInfo } from "../util/handler-hash.ts";
-import { writeTarGz } from "../util/tar.ts";
-import { MANIFEST_BEGIN, MANIFEST_END, uploadFile } from "../harness/result.ts";
-import { GLIBC_INTERP, MUSL_INTERP, readInterpreter } from "./elf.ts";
-import { handlerHashes, type HandlerHash } from "./hashes.ts";
-import { harnessInfo, loadProject, relPosix, type Project } from "./project.ts";
+// olve-build: pipeline dir → single executable + step.tar.zst + manifest.json.
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { canonicalJson } from '../util/canonical.ts';
+import { sha256File } from '../util/hash.ts';
+import type { HarnessInfo } from '../util/handler-hash.ts';
+import { writeTarZst } from '../util/tar.ts';
+import { MANIFEST_BEGIN, MANIFEST_END, uploadFile } from '../harness/result.ts';
+import { GLIBC_INTERP, MUSL_INTERP, readInterpreter } from './elf.ts';
+import { handlerHashes, kindHashes, type HandlerHash } from './hashes.ts';
+import {
+  harnessInfo,
+  loadPipeline,
+  loadProject,
+  relPosix,
+  type Project,
+} from './project.ts';
 
-export const BUILD_FLAGS = ["--no-compile-autoload-dotenv", "--no-compile-autoload-bunfig", "--bytecode", "--format=esm"] as const;
-export type Target = "bun-linux-x64" | "bun-linux-x64-musl";
+export const BUILD_FLAGS = [
+  '--no-compile-autoload-dotenv',
+  '--no-compile-autoload-bunfig',
+  '--bytecode',
+  '--format=esm',
+] as const;
+export type Target = 'bun-linux-x64' | 'bun-linux-x64-musl';
 
 export class BuildError extends Error {
-  override name = "BuildError";
-  constructor(message: string, readonly exitCode = 1) {
+  override name = 'BuildError';
+  constructor(
+    message: string,
+    readonly exitCode = 1,
+  ) {
     super(message);
   }
 }
@@ -23,7 +37,7 @@ export class BuildError extends Error {
 export interface BuildOptions {
   out: string;
   target?: Target;
-  /** Pre-signed PUT for step.tar.gz. */
+  /** Pre-signed PUT for the step archive. */
   uploadUrl?: string;
   /** Print the manifest between sentinels on stdout (for the build Job's pod log). */
   sentinels?: boolean;
@@ -41,84 +55,140 @@ export interface BuildResult {
 }
 
 /** Writes `<dir>/.olve/gen/{handlers,entry}.ts`: the literal-import handler registry + binary entry. */
-export function generateEntry(project: Project, hashes: Record<string, string>, harness: HarnessInfo): string {
-  const gen = join(project.dir, ".olve", "gen");
+export function generateEntry(
+  project: Project,
+  hashes: Record<string, string>,
+  harness: HarnessInfo,
+  kinds: Record<string, string> = {},
+): 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");
+  const registry = project.handlers
+    .map(
+      ([name, file]) =>
+        `  ${JSON.stringify(name)}: () => import(${JSON.stringify(relPosix(gen, file))}),`,
+    )
+    .join('\n');
   writeFileSync(
-    join(gen, "handlers.ts"),
+    join(gen, 'handlers.ts'),
     `// GENERATED by olve-build — do not edit.\n` +
-      `import type { HandlerRegistry, HarnessInfo } from "@olve/pipelines/harness";\n\n` +
+      `import type { HandlerRegistry, HarnessInfo } from "@olivervea/pipelines/harness";\n\n` +
       `export const handlers: HandlerRegistry = {\n${registry}\n};\n\n` +
       `export const handlerHashes: Record<string, string> = ${JSON.stringify(hashes, null, 2)};\n\n` +
+      `export const kindHashes: Record<string, string> = ${JSON.stringify(kinds, null, 2)};\n\n` +
       `export const harness: HarnessInfo = ${JSON.stringify(harness, null, 2)};\n`,
   );
-  const entry = join(gen, "entry.ts");
+  const entry = join(gen, 'entry.ts');
   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 "@olve/pipelines/harness";\n` +
-      `import { handlers, handlerHashes, harness } from "./handlers.ts";\n\n` +
-      `process.exit(await runHarness({ pipeline, handlers, handlerHashes, harness }, process.argv.slice(2)));\n`,
+      `import { runHarness } from "@olivervea/pipelines/harness";\n` +
+      `import { handlers, handlerHashes, kindHashes, harness } from "./handlers.ts";\n\n` +
+      `process.exit(await runHarness({ pipeline, handlers, handlerHashes, kindHashes, harness }, process.argv.slice(2)));\n`,
   );
   return entry;
 }
 
 export async function build(dir: string, opts: BuildOptions): Promise<BuildResult> {
-  const log = opts.log ?? ((l: string) => process.stderr.write(l + "\n"));
-  const stdout = opts.stdout ?? (async (t: string) => void (await Bun.write(Bun.stdout, t)));
-  const target = opts.target ?? "bun-linux-x64";
-  const project = loadProject(dir);
+  const log = opts.log ?? ((l: string) => process.stderr.write(l + '\n'));
+  const stdout =
+    opts.stdout ?? (async (t: string) => void (await Bun.write(Bun.stdout, t)));
+  const target = opts.target ?? 'bun-linux-x64';
+  const project = await loadProject(dir);
   const out = resolve(opts.out);
   mkdirSync(out, { recursive: true });
   const harness = harnessInfo();
 
   const t0 = performance.now();
   const hashes = await handlerHashes(project, harness);
-  const entry = generateEntry(project, Object.fromEntries(Object.entries(hashes).map(([k, v]) => [k, v.handlerHash])), harness);
-  log(`olve-build: ${project.handlers.length} handler(s) hashed in ${((performance.now() - t0) / 1000).toFixed(2)}s`);
+  const kinds = await kindHashes(project, await loadPipeline(project));
+  const entry = generateEntry(
+    project,
+    Object.fromEntries(Object.entries(hashes).map(([k, v]) => [k, v.handlerHash])),
+    harness,
+    kinds,
+  );
+  log(
+    `olve-build: ${project.handlers.length} handler(s) hashed in ${((performance.now() - t0) / 1000).toFixed(2)}s`,
+  );
 
   // 1. compile
-  const binary = join(out, "step");
+  const binary = join(out, 'step');
   rmSync(binary, { force: true });
   const t1 = performance.now();
-  const p = Bun.spawnSync([process.execPath, "build", "--compile", `--target=${target}`, ...BUILD_FLAGS, entry, `--outfile=${binary}`], {
-    cwd: project.dir,
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, NO_COLOR: "1" },
-  });
+  const p = Bun.spawnSync(
+    [
+      process.execPath,
+      'build',
+      '--compile',
+      `--target=${target}`,
+      ...BUILD_FLAGS,
+      entry,
+      `--outfile=${binary}`,
+    ],
+    {
+      cwd: project.dir,
+      stdout: 'pipe',
+      stderr: 'pipe',
+      env: { ...process.env, NO_COLOR: '1' },
+    },
+  );
   if (p.exitCode !== 0 || !existsSync(binary))
-    throw new BuildError(`bun build --compile failed (exit ${p.exitCode}):\n${p.stdout.toString()}${p.stderr.toString()}`);
-  log(`olve-build: compiled ${target} in ${((performance.now() - t1) / 1000).toFixed(2)}s`);
+    throw new BuildError(
+      `bun build --compile failed (exit ${p.exitCode}):\n${p.stdout.toString()}${p.stderr.toString()}`,
+    );
+  log(
+    `olve-build: compiled ${target} in ${((performance.now() - t1) / 1000).toFixed(2)}s`,
+  );
 
   // 2. loader check: the harness launches the binary through /olve/lib/<loader>; a musl binary
   //    (e.g. compiled on alpine, where bun-linux-x64 silently yields musl) would not start.
-  const expected = target === "bun-linux-x64" ? GLIBC_INTERP : MUSL_INTERP;
+  const expected = target === 'bun-linux-x64' ? GLIBC_INTERP : MUSL_INTERP;
   const interp = readInterpreter(binary);
   if (interp !== expected)
-    throw new BuildError(`compiled binary has PT_INTERP ${interp ?? "(none)"}, expected ${expected} — compile on a glibc Bun image (oven/bun:<version>-slim), not alpine`);
+    throw new BuildError(
+      `compiled binary has PT_INTERP ${interp ?? '(none)'}, expected ${expected} — compile on a glibc Bun image (oven/bun:<version>-slim), not alpine`,
+    );
 
   // 3. describe (runs the real binary: the manifest is exactly what the step pods will see)
-  const d = Bun.spawnSync([binary, "describe"], { cwd: out, stdout: "pipe", stderr: "pipe", env: { PATH: process.env.PATH ?? "/usr/bin:/bin" } });
-  if (d.exitCode !== 0) throw new BuildError(`describe failed (exit ${d.exitCode}):\n${d.stderr.toString()}`, d.exitCode ?? 1);
+  const d = Bun.spawnSync([binary, 'describe'], {
+    cwd: out,
+    stdout: 'pipe',
+    stderr: 'pipe',
+    env: { PATH: process.env.PATH ?? '/usr/bin:/bin' },
+  });
+  if (d.exitCode !== 0)
+    throw new BuildError(
+      `describe failed (exit ${d.exitCode}):\n${d.stderr.toString()}`,
+      d.exitCode ?? 1,
+    );
   const manifest = d.stdout.toString();
-  const manifestFile = join(out, "manifest.json");
+  const manifestFile = join(out, 'manifest.json');
   writeFileSync(manifestFile, manifest);
 
-  // 4. step.tar.gz (deterministic: `step` at the root, 0755, mtime 0)
-  const archive = join(out, "step.tar.gz");
-  await writeTarGz(archive, [{ path: "step", type: "file", mode: 0o755, source: binary }]);
+  // 4. step.tar.zst (deterministic: `step` at the root, 0755, mtime 0)
+  const archive = join(out, 'step.tar.zst');
+  await writeTarZst(archive, [
+    { path: 'step', type: 'file', mode: 0o755, source: binary },
+  ]);
   writeFileSync(
-    join(out, "build.json"),
-    canonicalJson({ target, flags: BUILD_FLAGS, harness, handlers: hashes, binarySha256: sha256File(binary), archiveSha256: sha256File(archive) }),
+    join(out, 'build.json'),
+    canonicalJson({
+      target,
+      flags: BUILD_FLAGS,
+      harness,
+      handlers: hashes,
+      kinds,
+      binarySha256: sha256File(binary),
+      archiveSha256: sha256File(archive),
+    }),
   );
   log(`olve-build: wrote ${archive}`);
 
   if (opts.uploadUrl) {
     await uploadFile(opts.uploadUrl, archive, log);
-    log("olve-build: uploaded step.tar.gz");
+    log('olve-build: uploaded step.tar.zst');
   }
   if (opts.sentinels) await stdout(`${MANIFEST_BEGIN}\n${manifest}${MANIFEST_END}\n`);
   return { binary, archive, manifestFile, manifest, hashes, harness };

package/src/build/cli.ts

@@ -1,12 +1,13 @@
 #!/usr/bin/env bun
 // olve-build <pipelineDir> --out <dir> [--target bun-linux-x64|bun-linux-x64-musl] [--upload-url <url>] [--sentinels] [--hash-only]
-import { parseArgs } from "node:util";
-import { canonicalJson } from "../util/canonical.ts";
-import { build, BuildError, type Target } from "./build.ts";
-import { handlerHashes } from "./hashes.ts";
-import { harnessInfo, loadProject, ProjectError } from "./project.ts";
+import { parseArgs } from 'node:util';
+import { canonicalJson } from '../util/canonical.ts';
+import { build, BuildError, type Target } from './build.ts';
+import { handlerHashes } from './hashes.ts';
+import { harnessInfo, loadProject, ProjectError } from './project.ts';
 
-const USAGE = "usage: olve-build <pipelineDir> --out <dir> [--target bun-linux-x64|bun-linux-x64-musl] [--upload-url <url>] [--sentinels]\n       olve-build <pipelineDir> --hash-only";
+const USAGE =
+  'usage: olve-build <pipelineDir> --out <dir> [--target bun-linux-x64|bun-linux-x64-musl] [--upload-url <url>] [--sentinels]\n       olve-build <pipelineDir> --hash-only';
 
 async function main(): Promise<number> {
   let parsed;
@@ -14,12 +15,12 @@ async function main(): Promise<number> {
     parsed = parseArgs({
       allowPositionals: true,
       options: {
-        out: { type: "string" },
-        target: { type: "string" },
-        "upload-url": { type: "string" },
-        sentinels: { type: "boolean", default: false },
-        "hash-only": { type: "boolean", default: false },
-        help: { type: "boolean", short: "h", default: false },
+        out: { type: 'string' },
+        target: { type: 'string' },
+        'upload-url': { type: 'string' },
+        sentinels: { type: 'boolean', default: false },
+        'hash-only': { type: 'boolean', default: false },
+        help: { type: 'boolean', short: 'h', default: false },
       },
     });
   } catch (e) {
@@ -27,23 +28,29 @@ async function main(): Promise<number> {
     return 64;
   }
   const { values, positionals } = parsed;
-  if (values.help) return console.log(USAGE), 0;
-  if (positionals.length !== 1) return console.error(USAGE), 64;
+  if (values.help) return (console.log(USAGE), 0);
+  if (positionals.length !== 1) return (console.error(USAGE), 64);
   const dir = positionals[0]!;
   try {
-    if (values["hash-only"]) {
-      const h = await handlerHashes(loadProject(dir), harnessInfo());
+    if (values['hash-only']) {
+      const h = await handlerHashes(await loadProject(dir), harnessInfo());
       await Bun.write(Bun.stdout, canonicalJson({ harness: harnessInfo(), handlers: h }));
       return 0;
     }
-    if (!values.out) return console.error(`--out is required\n${USAGE}`), 64;
-    const target = (values.target ?? "bun-linux-x64") as Target;
-    if (target !== "bun-linux-x64" && target !== "bun-linux-x64-musl") return console.error(`unsupported target ${target}`), 64;
-    await build(dir, { out: values.out, target, uploadUrl: values["upload-url"], sentinels: values.sentinels });
+    if (!values.out) return (console.error(`--out is required\n${USAGE}`), 64);
+    const target = (values.target ?? 'bun-linux-x64') as Target;
+    if (target !== 'bun-linux-x64' && target !== 'bun-linux-x64-musl')
+      return (console.error(`unsupported target ${target}`), 64);
+    await build(dir, {
+      out: values.out,
+      target,
+      uploadUrl: values['upload-url'],
+      sentinels: values.sentinels,
+    });
     return 0;
   } catch (e) {
-    if (e instanceof BuildError) return console.error(e.message), e.exitCode;
-    if (e instanceof ProjectError) return console.error(e.message), 78;
+    if (e instanceof BuildError) return (console.error(e.message), e.exitCode);
+    if (e instanceof ProjectError) return (console.error(e.message), 78);
     console.error((e as Error)?.stack ?? String(e));
     return 1;
   }