@norskvideo/ctl-test-harness 0.1.17 → 0.1.19

package/daemon.d.ts

@@ -6,6 +6,15 @@ export { makeStoreDir, makeTempDir, pollUntil, TEST_TMP_BASE };
 export declare function requireLicenseFile(opts?: {
     missing?: "exit" | "throw";
 }): string;
+/** What a caller sees when the CLI itself cannot be started: in a product
+ *  repo outside its nix shell nothing resolves (cli-command.ts), and spawn's
+ *  ENOENT must read as one line, not an uncaught 'error' event. */
+export declare function cliUnavailableMessage(command: readonly string[], cause: string): string;
+export declare function runCliWith(command: readonly string[], storeDir: string, ...args: string[]): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
 export declare function runCli(storeDir: string, ...args: string[]): Promise<{
     stdout: string;
     stderr: string;

package/daemon.js

@@ -50,17 +50,30 @@ export function requireLicenseFile(opts = {}) {
     }
     return licenseFile;
 }
-export async function runCli(storeDir, ...args) {
+/** What a caller sees when the CLI itself cannot be started: in a product
+ *  repo outside its nix shell nothing resolves (cli-command.ts), and spawn's
+ *  ENOENT must read as one line, not an uncaught 'error' event. */
+export function cliUnavailableMessage(command, cause) {
+    return `could not run ${command.join(" ")}: ${cause} — set NORSK_CTL_BINARY to a norsk-ctl binary, or run inside the product's \`nix develop .#dev\` shell, which puts the pinned release on PATH`;
+}
+export async function runCliWith(command, storeDir, ...args) {
     return new Promise((res) => {
-        const [cmd, ...cmdArgs] = cliCommand;
+        const [cmd, ...cmdArgs] = command;
         const proc = spawn(cmd, [...cmdArgs, ...args], {
             env: { ...process.env, NORSK_CTL_STORE_DIR: storeDir },
         });
         const stdout = [];
         const stderr = [];
+        let failed = false;
         proc.stdout.on("data", (d) => stdout.push(d));
         proc.stderr.on("data", (d) => stderr.push(d));
+        proc.on("error", (e) => {
+            failed = true;
+            res({ stdout: "", stderr: cliUnavailableMessage(command, e.message), exitCode: 127 });
+        });
         proc.on("close", (code) => {
+            if (failed)
+                return;
             res({
                 stdout: Buffer.concat(stdout).toString(),
                 stderr: Buffer.concat(stderr).toString(),
@@ -69,6 +82,9 @@ export async function runCli(storeDir, ...args) {
         });
     });
 }
+export async function runCli(storeDir, ...args) {
+    return runCliWith(cliCommand, storeDir, ...args);
+}
 export function isPortFree(port) {
     return new Promise((resolve) => {
         const srv = createServer();
@@ -127,14 +143,20 @@ export function startDaemon(storeDir, options) {
         detached: options?.detached === true,
         env: { ...process.env, NORSK_CTL_STORE_DIR: storeDir, NORSK_CTL_PORT: String(port), ...options?.env },
     });
-    const ready = pollUntil(async () => {
-        const res = await fetch(`http://localhost:${port}/api/ready`, { signal: AbortSignal.timeout(1000) });
-        return res.ok;
-    }, {
-        timeoutMs: options?.readyTimeoutMs ?? DAEMON_READY_TIMEOUT_MS,
-        intervalMs: 500,
-        label: "Daemon did not become ready",
+    const spawnFailed = new Promise((_, reject) => {
+        proc.once("error", (e) => reject(new Error(cliUnavailableMessage(cliCommand, e.message))));
     });
+    const ready = Promise.race([
+        spawnFailed,
+        pollUntil(async () => {
+            const res = await fetch(`http://localhost:${port}/api/ready`, { signal: AbortSignal.timeout(1000) });
+            return res.ok;
+        }, {
+            timeoutMs: options?.readyTimeoutMs ?? DAEMON_READY_TIMEOUT_MS,
+            intervalMs: 500,
+            label: "Daemon did not become ready",
+        }),
+    ]);
     return { daemon: daemonHandle(proc), ready };
 }
 function runningContainers(names) {

package/demo/cli.d.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env bun
+import { type DemoRunOptions, type DemoRunResult, demoPorts } from "./run.js";
+import type { DemoSpec } from "./spec.js";
+export interface DemoArgs {
+    action: "up" | "check" | "down" | "spec";
+    mode: "dev" | "standalone";
+    exportOnly: boolean;
+    json: boolean;
+    spec: string;
+}
+export declare function parseDemoArgs(argv: string[]): DemoArgs;
+export interface ResolvedSpecView {
+    product: string;
+    slug: string;
+    instanceId: string;
+    mode: string;
+    ports: ReturnType<typeof demoPorts>;
+    dev: DemoSpec["dev"];
+    image?: string;
+    template: {
+        name: string;
+    } | {
+        build: {
+            name: string;
+            input: string | Record<string, unknown>;
+        };
+    };
+    launch?: DemoSpec["launch"];
+    prerequisites?: DemoSpec["prerequisites"];
+    sources: Array<{
+        name: string;
+        asset: NonNullable<DemoSpec["sources"]>[number]["asset"];
+        ingest: unknown;
+        streamId?: string;
+    }>;
+    ready: Array<{
+        http: string;
+        status: number;
+        bodyIncludes?: string;
+    } | {
+        custom: string;
+    }>;
+    after: boolean;
+    open: Array<{
+        name: string;
+        url: string;
+        pick?: string;
+    }>;
+    standalone?: DemoSpec["standalone"];
+}
+/** `demo spec --json`: what will run, resolved as far as it can be without a
+ *  daemon. Ingest ports are shown by their reference — they are the instance's
+ *  to give, at launch. JSON-safe (hooks become their labels). */
+export declare function resolvedSpecView(spec: DemoSpec, opts: {
+    mode: string;
+    slug?: string;
+}): ResolvedSpecView;
+/** Everything `demoMain` touches, injectable so the dispatch is unit-tested. */
+export interface DemoCliIo {
+    cwd: string;
+    loadSpec(path: string): Promise<DemoSpec>;
+    runDemo(spec: DemoSpec, opts: DemoRunOptions): Promise<DemoRunResult>;
+    runExportCheck(spec: DemoSpec, opts: {
+        cwd: string;
+    }): Promise<{
+        exportDir: string;
+    }>;
+    demoDown(product: string): Promise<void>;
+    stdout(line: string): void;
+    stderr(line: string): void;
+    abort?: AbortSignal;
+}
+export declare function demoMain(argv: string[], io: DemoCliIo): Promise<number>;
+export declare function defaultDemoCliIo(): DemoCliIo;

package/demo/cli.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env bun
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// `ctl-demo`, the bin behind every product's `bun run demo` (05-demo s4):
+//
+//   demo up      [--mode dev]                       launch, print the URLs, hold; Ctrl-C tears down
+//   demo check   [--mode dev]                       the same, then tear down and exit 0/1 (what CI runs)
+//   demo check   --mode standalone --export-only    build + export-workdir + every symlink resolves
+//   demo down                                       tear down what `up` recorded, from any shell
+//   demo spec    [--json]                           the resolved spec: ports, template, sources, URLs
+//
+// The spec is `tests/demo.spec.ts` in the cwd (`--spec <path>` otherwise), a
+// TypeScript module whose default export is `defineDemo({...})`. This runs
+// under bun only: the spec is TypeScript and so is every product's dev shell.
+import { resolve } from "node:path";
+import { demoDown, demoPorts, demoSlug, runDemo, runExportCheck, } from "./run.js";
+const USAGE = `usage: demo <up|check|down|spec> [--mode dev|standalone] [--export-only] [--json] [--spec <path>]
+
+  up                                  launch on a private daemon, print the URLs, hold (Ctrl-C tears down)
+  check                               up, then tear down and exit 0/1 — what CI runs
+  check --mode standalone --export-only
+                                      build the template, export the standalone workdir, assert every symlink resolves
+  down                                tear down what \`up\` recorded
+  spec [--json]                       print the resolved spec without launching anything
+
+  --spec <path>                       the demo spec (default tests/demo.spec.ts)`;
+const DEFAULT_SPEC = "tests/demo.spec.ts";
+export function parseDemoArgs(argv) {
+    const [action, ...rest] = argv;
+    if (action !== "up" && action !== "check" && action !== "down" && action !== "spec") {
+        throw new Error(action ? `unknown action '${action}'\n${USAGE}` : USAGE);
+    }
+    const args = { action, mode: "dev", exportOnly: false, json: false, spec: DEFAULT_SPEC };
+    for (let i = 0; i < rest.length; i++) {
+        const flag = rest[i];
+        const value = () => {
+            const v = rest[++i];
+            if (v === undefined)
+                throw new Error(`${flag} needs a value\n${USAGE}`);
+            return v;
+        };
+        switch (flag) {
+            case "--mode": {
+                const m = value();
+                if (m === "image")
+                    throw new Error("--mode image is not yet implemented (05-demo s7 step 2); use --mode dev");
+                if (m !== "dev" && m !== "standalone")
+                    throw new Error(`unknown mode '${m}'\n${USAGE}`);
+                args.mode = m;
+                break;
+            }
+            case "--export-only":
+                args.exportOnly = true;
+                break;
+            case "--json":
+                args.json = true;
+                break;
+            case "--spec":
+                args.spec = value();
+                break;
+            default:
+                throw new Error(`unknown flag '${flag}'\n${USAGE}`);
+        }
+    }
+    if (args.mode === "standalone" && !args.exportOnly && (args.action === "up" || args.action === "check")) {
+        throw new Error("the full standalone tier (engine + Studio panes) is not yet implemented (05-demo s7 step 3); this slice has `check --mode standalone --export-only`");
+    }
+    if (args.exportOnly && args.mode !== "standalone") {
+        throw new Error("--export-only belongs to --mode standalone");
+    }
+    return args;
+}
+/** `demo spec --json`: what will run, resolved as far as it can be without a
+ *  daemon. Ingest ports are shown by their reference — they are the instance's
+ *  to give, at launch. JSON-safe (hooks become their labels). */
+export function resolvedSpecView(spec, opts) {
+    const slug = opts.slug ?? demoSlug(spec.product);
+    const instanceId = `demo-${slug}`;
+    const ports = demoPorts(slug);
+    const pinned = spec.launch?.params?.STUDIO_HOST_PORT;
+    const studioHostPort = pinned !== undefined ? Number(pinned) : ports.studioHostPort;
+    const url = (ref) => {
+        if ("url" in ref)
+            return ref.url;
+        if ("control" in ref)
+            return `http://localhost:${ports.backendPort}${ref.control}`;
+        if ("proxy" in ref)
+            return `http://localhost:${ports.proxyPort}${ref.proxy.replaceAll("{id}", instanceId)}`;
+        return `http://localhost:${studioHostPort}${ref.studio}`;
+    };
+    const t = spec.template;
+    const template = t && "build" in t
+        ? { build: { name: t.build.name ?? `${spec.product}-demo`, input: t.build.input } }
+        : { name: t?.name ?? "<the product's first default template>" };
+    return {
+        product: spec.product,
+        slug,
+        instanceId,
+        mode: opts.mode,
+        ports,
+        dev: spec.dev,
+        ...(spec.image !== undefined ? { image: spec.image } : {}),
+        template,
+        ...(spec.launch !== undefined ? { launch: spec.launch } : {}),
+        ...(spec.prerequisites !== undefined ? { prerequisites: spec.prerequisites } : {}),
+        sources: (spec.sources ?? []).map((s) => ({
+            name: s.name,
+            asset: s.asset ?? { preset: "camera1" },
+            ingest: s.ingest,
+            ...(s.streamId !== undefined ? { streamId: s.streamId } : {}),
+        })),
+        ready: (spec.ready ?? []).map((g) => "custom" in g
+            ? { custom: g.label ?? "custom gate" }
+            : {
+                http: url(g.http),
+                status: g.status ?? 200,
+                ...(g.bodyIncludes !== undefined ? { bodyIncludes: g.bodyIncludes } : {}),
+            }),
+        after: spec.after !== undefined,
+        open: (spec.open ?? []).map((o) => ({
+            name: o.name,
+            url: url(o.url),
+            ...(o.pick !== undefined ? { pick: o.pick } : {}),
+        })),
+        ...(spec.standalone !== undefined ? { standalone: spec.standalone } : {}),
+    };
+}
+function isModuleNotFound(e) {
+    const code = e?.code;
+    return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || /cannot find module/i.test(String(e));
+}
+export async function demoMain(argv, io) {
+    let args;
+    try {
+        args = parseDemoArgs(argv);
+    }
+    catch (e) {
+        io.stderr(e instanceof Error ? e.message : String(e));
+        return 2;
+    }
+    const specPath = resolve(io.cwd, args.spec);
+    let spec;
+    try {
+        spec = await io.loadSpec(specPath);
+    }
+    catch (e) {
+        if (isModuleNotFound(e)) {
+            io.stderr(`no demo spec at ${specPath}\n  write ${args.spec}: \`export default defineDemo({ product, dev, ... })\` from @norskvideo/ctl-test-harness/demo`);
+        }
+        else {
+            io.stderr(`could not load ${specPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return 1;
+    }
+    try {
+        switch (args.action) {
+            case "spec": {
+                const view = resolvedSpecView(spec, { mode: args.mode });
+                io.stdout(args.json ? JSON.stringify(view, null, 2) : renderView(view));
+                return 0;
+            }
+            case "down":
+                await io.demoDown(spec.product);
+                return 0;
+            case "up":
+            case "check": {
+                if (args.exportOnly) {
+                    await io.runExportCheck(spec, { cwd: io.cwd });
+                    return 0;
+                }
+                await io.runDemo(spec, {
+                    action: args.action,
+                    mode: "dev",
+                    cwd: io.cwd,
+                    ...(io.abort ? { abort: io.abort } : {}),
+                });
+                return 0;
+            }
+        }
+    }
+    catch (e) {
+        io.stderr(`demo ${args.action} failed: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+}
+function renderView(v) {
+    const lines = [
+        `${v.product} (${v.mode}) -> instance ${v.instanceId}`,
+        `  daemon :${v.ports.daemonPort}  dev backend :${v.ports.backendPort}  proxy :${v.ports.proxyPort}  studio :${v.ports.studioHostPort}`,
+        `  template ${"name" in v.template ? v.template.name : `build ${v.template.build.name}`}`,
+    ];
+    for (const s of v.sources)
+        lines.push(`  source ${s.name}: ${JSON.stringify(s.asset)} -> ingest ${JSON.stringify(s.ingest)}`);
+    for (const g of v.ready)
+        lines.push(`  ready  ${"custom" in g ? g.custom : `${g.http} -> ${g.status}`}`);
+    for (const o of v.open)
+        lines.push(`  open   ${o.name}: ${o.url}${o.pick ? ` (pick /${o.pick}/)` : ""}`);
+    return lines.join("\n");
+}
+async function loadSpecModule(path) {
+    const mod = (await import(__rewriteRelativeImportExtension(path)));
+    const spec = mod.default;
+    if (!spec || typeof spec !== "object" || typeof spec.product !== "string") {
+        throw new Error(`${path} must default-export defineDemo({...})`);
+    }
+    return spec;
+}
+export function defaultDemoCliIo() {
+    const controller = new AbortController();
+    const release = () => controller.abort();
+    process.once("SIGINT", release);
+    process.once("SIGTERM", release);
+    return {
+        cwd: process.cwd(),
+        loadSpec: loadSpecModule,
+        runDemo: (spec, opts) => runDemo(spec, opts),
+        runExportCheck: (spec, opts) => runExportCheck(spec, opts),
+        demoDown: (product) => demoDown(product),
+        stdout: (line) => console.log(line),
+        stderr: (line) => console.error(line),
+        abort: controller.signal,
+    };
+}
+if (import.meta.main) {
+    process.exit(await demoMain(process.argv.slice(2), defaultDemoCliIo()));
+}

package/demo/index.d.ts

@@ -0,0 +1,6 @@
+export type { DemoArgs, DemoCliIo, ResolvedSpecView } from "./cli.js";
+export { defaultDemoCliIo, demoMain, parseDemoArgs, resolvedSpecView } from "./cli.js";
+export type { CliResult, DemoDeps, DemoPorts, DemoRunOptions, DemoRunResult, DemoState, DemoStateStore, DemoTimeouts, ExportCheckOptions, IngestPortRow, ProcessHandle, TemplateParams, } from "./run.js";
+export { defaultDemoDeps, demoDown, demoPorts, demoSlug, expandHome, fileStateStore, findBrokenSymlinks, killGroup, resolveIngestPort, runDemo, runExportCheck, } from "./run.js";
+export type { DemoContext, DemoIngest, DemoOpen, DemoReady, DemoSource, DemoSpec, DemoTemplate, DemoUrl, } from "./spec.js";
+export { DemoSpecSchema, defineDemo, formatSpecIssues } from "./spec.js";

package/demo/index.js

@@ -0,0 +1,3 @@
+export { defaultDemoCliIo, demoMain, parseDemoArgs, resolvedSpecView } from "./cli.js";
+export { defaultDemoDeps, demoDown, demoPorts, demoSlug, expandHome, fileStateStore, findBrokenSymlinks, killGroup, resolveIngestPort, runDemo, runExportCheck, } from "./run.js";
+export { DemoSpecSchema, defineDemo, formatSpecIssues } from "./spec.js";

package/demo/run.d.ts

@@ -0,0 +1,160 @@
+import { ensureRunnerOnNetwork } from "../container-net.js";
+import { type DaemonProcess, type StartDaemonOptions } from "../daemon.js";
+import { type BaseHarnessPorts } from "../harness-config.js";
+import { type SourceHandle, type SrtPumpTarget } from "../source-pump.js";
+import type { DemoIngest, DemoSpec } from "./spec.js";
+export interface CliResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface ProcessHandle {
+    pid: number | undefined;
+    kill(): void;
+    exited: Promise<number | null>;
+}
+/** What `up` records so `down` (or a refused second `up`) can find the run. */
+export interface DemoState {
+    product: string;
+    storeDir: string;
+    daemonPort: number;
+    instanceId?: string;
+    devPid?: number;
+}
+export interface DemoStateStore {
+    read(product: string): DemoState | null;
+    write(state: DemoState): void;
+    remove(product: string): void;
+}
+export interface DemoDeps {
+    licenseFile(): string;
+    storeDir(slug: string): string;
+    writeFile(path: string, contents: string): void;
+    fileExists(path: string): boolean;
+    startDaemon(storeDir: string, options: StartDaemonOptions): {
+        daemon: DaemonProcess;
+        ready: Promise<void>;
+    };
+    /** Does a daemon answer /api/ready on this port? (A stale state file otherwise.) */
+    daemonAnswers(port: number): Promise<boolean>;
+    cli(storeDir: string, argv: string[]): Promise<CliResult>;
+    startProcess(command: string[], opts: {
+        cwd: string;
+        env: Record<string, string>;
+    }): ProcessHandle;
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    startSources(opts: {
+        daemonPort: number;
+        instanceId: string;
+        targets: readonly SrtPumpTarget[];
+        timeoutMs?: number;
+    }): Promise<SourceHandle[]>;
+    stopSources(handles: SourceHandle[]): Promise<void>;
+    cleanup(opts: {
+        deleteInstance: (id: string) => Promise<unknown>;
+        stopDaemon: () => Promise<unknown>;
+        instances: string[];
+        daemon: DaemonProcess | null;
+        storeDir: string;
+        containers: string[];
+    }): Promise<void>;
+    /** Docker leaves root-owned bind-mount targets under the store (smoke.ts). */
+    nukeStoreAsRoot(storeDir: string): void;
+    storeExists(storeDir: string): boolean;
+    ensureNetwork(): ReturnType<typeof ensureRunnerOnNetwork>;
+    supportsNoPublish(): Promise<boolean>;
+    containerUser(): string | undefined;
+    /** Symlinks under an exported workdir whose target does not exist, as
+     *  `<link> -> <target>` lines. */
+    brokenSymlinks(dir: string): string[];
+    state: DemoStateStore;
+    /** `up`: block until released (Ctrl-C, or the abort signal). */
+    hold(abort?: AbortSignal): Promise<void>;
+    killPid?(pid: number): void;
+    log(line: string): void;
+}
+export interface DemoTimeouts {
+    /** The dev backend answering its readyPath. */
+    devReadyMs?: number;
+    /** The instance reporting running. */
+    healthyMs?: number;
+    /** Each `ready` gate, unless the gate says otherwise. */
+    readyMs?: number;
+}
+export interface DemoRunOptions {
+    action: "up" | "check";
+    mode: "dev";
+    /** The product repo root: dev command cwd, relative inputs and links. */
+    cwd: string;
+    /** Default: the product name without its `norsk-` prefix. */
+    slug?: string;
+    /** Releases an `up` hold. */
+    abort?: AbortSignal;
+    timeouts?: DemoTimeouts;
+}
+export interface DemoRunResult {
+    instanceId: string;
+    daemonPort: number;
+    storeDir: string;
+    /** The `open` block as printed: name and resolved value. */
+    open: Array<{
+        name: string;
+        value: string;
+    }>;
+}
+export interface DemoPorts extends BaseHarnessPorts {
+    proxyPort: number;
+}
+/** Per-slug port band above the smoke tier's (33000-34000), so a demo and a
+ *  smoke run of the same product never meet. */
+export declare function demoPorts(slug: string, overrides?: Partial<DemoPorts>): DemoPorts;
+export declare function demoSlug(product: string): string;
+export declare function expandHome(path: string): string;
+/** The daemon's `ingestPorts` row (ProductInstance.ingestPorts in the contract). */
+export interface IngestPortRow {
+    port: number;
+    proto: "tcp" | "udp";
+    service: string;
+    hostPort?: number;
+    param?: string;
+    label?: string;
+    origin: "allocated" | "operator" | "default";
+}
+/** The template's declared parameters (name -> stringified default) and the
+ *  spec's overrides: together, a parameter's effective value at launch. */
+export interface TemplateParams {
+    declared: Map<string, string | undefined>;
+    overrides: Record<string, string | number>;
+}
+/** Ports come from the instance and its template, not the spec (05-demo s4).
+ *  A `param` is first an allocated port the instance reports, else an
+ *  ordinary template parameter whose effective value (the spec's override,
+ *  else the template default) is the container port — the `${P}:${P}/udp`
+ *  idiom every product's SRT ingest uses. A bare number is accepted only when
+ *  no parameter carries it and the instance offers it as the conventional
+ *  default, so the demo follows the template when the template moves. */
+export declare function resolveIngestPort(ingest: DemoIngest, rows: IngestPortRow[], t?: TemplateParams): number;
+export declare function findBrokenSymlinks(dir: string): string[];
+/** `<cwd>/test-temp/demo/<product>.json` — beside the store dirs, inside the
+ *  consumer's repo, where `down` from another shell can find it. */
+export declare function fileStateStore(cwd: string): DemoStateStore;
+/** SIGTERM a process group (a pid startProcess spawned detached leads its
+ *  own), falling back to the pid alone if it is not a group leader. */
+export declare function killGroup(pid: number): void;
+export declare function defaultDemoDeps(cwd: string): DemoDeps;
+export declare function runDemo(spec: DemoSpec, opts: DemoRunOptions, deps?: DemoDeps): Promise<DemoRunResult>;
+export interface ExportCheckOptions {
+    cwd: string;
+    slug?: string;
+    timeouts?: DemoTimeouts;
+}
+/** `demo check --mode standalone --export-only` (05-demo s4): build the
+ *  template, export the standalone workdir with the spec's live-source links,
+ *  assert every symlink resolves. No instance, no licence — the daemon's own
+ *  preflight still wants a Docker socket, but nothing is launched. This is the
+ *  path that rotted (05-demo s1) and it is cheap enough to gate every push. */
+export declare function runExportCheck(spec: DemoSpec, opts: ExportCheckOptions, deps?: DemoDeps): Promise<{
+    exportDir: string;
+}>;
+/** `demo down`: tear down the run `up` recorded, from any shell. */
+export declare function demoDown(product: string, deps?: DemoDeps): Promise<void>;