@sparkwing/sdk 0.0.0-stage → 0.68.2

package/dist/plan.js

@@ -0,0 +1,811 @@
+import { jsonValue } from "./protocol.js";
+import { argument } from "./describe.js";
+import { posix } from "node:path";
+import { failure, SDKError } from "./errors.js";
+function identifier(kind, value) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${kind} identifier must not be empty`);
+}
+function integer(name, value, min = 0) {
+    if (!Number.isSafeInteger(value) || value < min)
+        throw new Error(`${name} must be a ${min === 0 ? "nonnegative" : "positive"} integer`);
+    return value;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function names(kind, values) {
+    for (const value of values)
+        identifier(kind, value);
+    return unique(values);
+}
+function optionalField(target, key, value) {
+    if (value === undefined)
+        delete target[key];
+    else
+        target[key] = value;
+}
+function dependencyIDs(deps) {
+    return unique(deps.flatMap((dep) => (typeof dep === "string" ? [dep] : "members" in dep ? dep.members.map((job) => job.id) : [dep.id])));
+}
+function stepIDs(deps) {
+    return unique(deps.flatMap((dep) => (typeof dep === "string" ? [dep] : "members" in dep ? dep.members.map((step) => step.id) : [dep.id])));
+}
+export class ConcurrencyGroup {
+    name;
+    limit;
+    constructor(name, limit = {}) {
+        identifier("concurrency group", name);
+        if (limit.capacity !== undefined)
+            integer("concurrency capacity", limit.capacity, 1);
+        if (limit.queueTimeoutMs !== undefined)
+            integer("concurrency queue timeout", limit.queueTimeoutMs);
+        if (limit.scope !== undefined && !["global", "run", "box"].includes(limit.scope))
+            throw new Error("invalid concurrency scope");
+        if (limit.onLimit !== undefined && !["queue", "fail", "skip", "cancel_others"].includes(limit.onLimit))
+            throw new Error("invalid concurrency onLimit");
+        this.name = name;
+        this.limit = Object.freeze({ ...limit });
+    }
+    toString() {
+        return this.name;
+    }
+}
+function concurrency(group, cost) {
+    const limit = group.limit;
+    if (cost !== undefined)
+        integer("concurrency cost", cost, 1);
+    if (cost !== undefined && limit.capacity !== undefined && cost > limit.capacity)
+        throw new Error(`cost ${cost} exceeds group capacity ${limit.capacity}`);
+    const spec = { group: group.name };
+    if (limit.scope !== undefined)
+        spec.scope = limit.scope;
+    if (limit.capacity !== undefined)
+        spec.capacity = limit.capacity;
+    if (cost !== undefined)
+        spec.cost = cost;
+    if (limit.onLimit !== undefined)
+        spec.on_limit = limit.onLimit;
+    if (limit.queueTimeoutMs !== undefined)
+        spec.queue_timeout_ms = limit.queueTimeoutMs;
+    return spec;
+}
+function addConcurrency(spec, group, cost) {
+    const entry = concurrency(group, cost);
+    const entries = (spec.concurrency ??= []);
+    const i = entries.findIndex((other) => other.group === entry.group && other.scope === entry.scope);
+    if (i < 0)
+        entries.push(entry);
+    else
+        entries[i] = entry;
+}
+export function startup() {
+    return { phase: "startup" };
+}
+export function goModules() {
+    return Object.freeze({ kind: "go_modules" });
+}
+export function npm() {
+    return Object.freeze({ kind: "npm" });
+}
+export function dir(path, ...keyFiles) {
+    identifier("cache path", path);
+    if (!keyFiles.length)
+        throw new Error("directory cache needs at least one key file");
+    return Object.freeze({ kind: "dir", path, keyFiles: Object.freeze(names("cache key file", keyFiles)) });
+}
+function collect(closures) {
+    if (!closures.length)
+        return undefined;
+    const spec = {};
+    for (const closure of closures) {
+        if (closure.kind === "verify" || closure.kind === "memo_key")
+            spec[closure.kind] = closure.id;
+        else
+            (spec[closure.kind] ??= []).push(closure.id);
+    }
+    return spec;
+}
+export class Step {
+    id;
+    body;
+    owner;
+    #spec;
+    #skip = [];
+    #dryRun;
+    #result = false;
+    constructor(owner, id, body) {
+        identifier("step", id);
+        this.owner = owner;
+        this.id = id;
+        this.body = body;
+        this.#spec = { id };
+    }
+    needs(...steps) {
+        this.assertMutable();
+        this.#spec.needs = unique([...(this.#spec.needs ?? []), ...stepIDs(steps)]);
+        return this;
+    }
+    result() {
+        this.assertMutable();
+        this.#result = true;
+        return this;
+    }
+    skipIf(fn) {
+        this.assertMutable();
+        this.#skip.push(fn);
+        return this;
+    }
+    finally() {
+        this.assertMutable();
+        this.#spec.finally = true;
+        return this;
+    }
+    continueOnError() {
+        this.assertMutable();
+        this.#spec.continue_on_error = true;
+        return this;
+    }
+    optional() {
+        this.assertMutable();
+        this.#spec.optional = true;
+        return this.continueOnError();
+    }
+    dryRun(body) {
+        this.assertMutable();
+        this.#dryRun = body;
+        this.#spec.has_dry_run = true;
+        return this;
+    }
+    safeWithoutDryRun() {
+        this.assertMutable();
+        this.#spec.safe_without_dry_run = true;
+        return this;
+    }
+    risk(...labels) {
+        this.assertMutable();
+        this.#spec.risks = names("risk", [...(this.#spec.risks ?? []), ...labels]);
+        return this;
+    }
+    addGroup(id) {
+        this.assertMutable();
+        this.#spec.groups = unique([...(this.#spec.groups ?? []), id]);
+    }
+    assertMutable() {
+        this.owner.assertMutable();
+    }
+    get isResult() {
+        return this.#result;
+    }
+    get dryRunBody() {
+        return this.#dryRun;
+    }
+    closures() {
+        return this.#skip.map((fn, i) => ({
+            id: `${encodeURIComponent(this.owner.id)}/step/${encodeURIComponent(this.id)}/skip_if/${i}`,
+            kind: "skip_if",
+            fn,
+            job: this.owner,
+            step: this,
+        }));
+    }
+    toSpec() {
+        const spec = structuredClone(this.#spec);
+        optionalField(spec, "closures", collect(this.closures()));
+        return spec;
+    }
+}
+class StepGroup {
+    id;
+    members;
+    constructor(id, members) {
+        this.id = id;
+        this.members = Object.freeze([...members]);
+    }
+    needs(...steps) {
+        for (const member of this.members)
+            member.needs(...steps);
+        return this;
+    }
+    skipIf(fn) {
+        for (const member of this.members)
+            member.skipIf(fn);
+        return this;
+    }
+}
+export class Declaration {
+    id;
+    owner;
+    spec;
+    callbacks = [];
+    constructor(owner, id) {
+        identifier("job", id);
+        this.owner = owner;
+        this.id = id;
+        this.spec = { id };
+    }
+    needs(...jobs) {
+        this.assertMutable();
+        this.spec.deps = unique([...(this.spec.deps ?? []), ...dependencyIDs(jobs)]);
+        return this;
+    }
+    needsIfPresent(...jobs) {
+        this.assertMutable();
+        this.spec.deps_if_present = unique([...(this.spec.deps_if_present ?? []), ...dependencyIDs(jobs)]);
+        return this;
+    }
+    needsGenerated(...generators) {
+        this.assertMutable();
+        this.spec.needs_generated = unique([...(this.spec.needs_generated ?? []), ...generators.map((g) => g.id)]);
+        return this;
+    }
+    skipIf(fn, options = {}) {
+        this.assertMutable();
+        this.callbacks.push({ id: this.closureID("skip_if"), kind: "skip_if", fn, job: this });
+        if (options.budgetMs !== undefined)
+            this.spec.skip_if_budget_ms = integer("skip budget", options.budgetMs);
+        return this;
+    }
+    optional() {
+        this.assertMutable();
+        this.spec.optional = true;
+        return this.continueOnError();
+    }
+    continueOnError() {
+        this.assertMutable();
+        this.spec.continue_on_error = true;
+        return this;
+    }
+    onFailure(id, body) {
+        this.assertMutable();
+        if (this.owner.jobs().some((job) => job.spec.on_failure_of === this.id))
+            throw new Error("job already has a recovery");
+        const recovery = this.owner.job(id, body);
+        recovery.spec.on_failure_of = this.id;
+        return recovery;
+    }
+    addGroup(id) {
+        this.assertMutable();
+        this.spec.groups = unique([...(this.spec.groups ?? []), id]);
+    }
+    assertMutable() {
+        this.owner.assertMutable();
+    }
+    closureID(kind) {
+        return `${encodeURIComponent(this.id)}/${kind}/${this.callbacks.filter((c) => c.kind === kind).length}`;
+    }
+    steps() {
+        return [];
+    }
+    findStep(id) {
+        return this.steps().find((step) => step.id === id);
+    }
+    argSpecs() {
+        return [];
+    }
+    closures() {
+        return [...this.callbacks, ...this.steps().flatMap((step) => step.closures())];
+    }
+    toSpec() {
+        const spec = structuredClone(this.spec);
+        if (this.argSpecs().length)
+            spec.arguments = this.argSpecs().map((arg) => argument(arg, this.id));
+        optionalField(spec, "closures", collect(this.callbacks));
+        const steps = this.steps();
+        if (steps.length) {
+            spec.steps = steps.map((step) => step.toSpec());
+            const results = steps.filter((step) => step.isResult);
+            if (results.length > 1)
+                throw new Error("job has more than one result step");
+            if (results[0])
+                spec.result_step = results[0].id;
+        }
+        return spec;
+    }
+}
+class Approval extends Declaration {
+    constructor(owner, id, options) {
+        super(owner, id);
+        this.spec.approval = {};
+        if (options.message !== undefined)
+            this.spec.approval.message = options.message;
+        if (options.timeoutMs !== undefined)
+            this.spec.approval.timeout_ms = integer("approval timeout", options.timeoutMs);
+        if (options.onTimeout !== undefined) {
+            if (!["fail", "deny", "approve"].includes(options.onTimeout))
+                throw new Error("invalid approval onTimeout");
+            this.spec.approval.on_timeout = options.onTimeout;
+        }
+    }
+}
+const knownTools = new Set([
+    "aws",
+    "buildx",
+    "crane",
+    "docker",
+    "git",
+    "go",
+    "golangci-lint",
+    "helm",
+    "kubectl",
+    "node",
+    "npm",
+    "shellcheck",
+    "terraform",
+]);
+export class Job extends Declaration {
+    #steps = [];
+    #args = [];
+    #tools = [];
+    #requires = [];
+    #hasBody;
+    #stepGroups = new Set();
+    constructor(owner, id, body) {
+        super(owner, id);
+        this.#hasBody = body !== undefined;
+        if (body)
+            this.#steps.push(new Step(this, "run", body).result());
+    }
+    steps() {
+        return this.#steps;
+    }
+    argSpecs() {
+        return structuredClone(this.#args);
+    }
+    withArgs(...args) {
+        this.assertMutable();
+        const all = [...this.#args, ...args];
+        this.#args = structuredClone(all);
+        return this;
+    }
+    startsChildren(...pipelines) {
+        return this.startsChildrenIn("", ...pipelines);
+    }
+    startsChildrenIn(repository, ...pipelines) {
+        this.assertMutable();
+        (this.spec.children ??= []).push(...pipelines.map((pipeline) => ({ pipeline, ...(repository ? { repository } : {}) })));
+        return this;
+    }
+    references(...refs) {
+        this.assertMutable();
+        const entries = (this.spec.pipeline_refs ??= []);
+        for (const ref of refs)
+            if (!entries.some((entry) => entry.pipeline === ref.pipeline && entry.job === ref.jobId))
+                entries.push({ pipeline: ref.pipeline, job: ref.jobId });
+        return this;
+    }
+    step(id, body) {
+        this.assertMutable();
+        if (this.#hasBody)
+            throw new Error("a job with a body cannot also have steps");
+        if (this.findStep(id))
+            throw new Error(`duplicate step ${id}`);
+        const step = new Step(this, id, body);
+        this.#steps.push(step);
+        return step;
+    }
+    groupSteps(id, ...steps) {
+        this.assertMutable();
+        identifier("step group", id);
+        if (this.#stepGroups.has(id))
+            throw new Error(`duplicate step group ${id}`);
+        const members = steps.map((step) => {
+            if (!(step instanceof Step) || step.owner !== this)
+                throw new Error("step group member belongs to another job");
+            return step;
+        });
+        for (const member of members)
+            member.addGroup(id);
+        this.#stepGroups.add(id);
+        return new StepGroup(id, members);
+    }
+    failurePolicy(value) {
+        this.assertMutable();
+        if (!["fail_fast", "collect_all"].includes(value))
+            throw new Error("invalid failure policy");
+        this.spec.failure_policy = value;
+        return this;
+    }
+    retry(attempts, options = {}) {
+        this.assertMutable();
+        const retry = { attempts: integer("retry attempts", attempts) };
+        if (options.backoffMs !== undefined)
+            retry.backoff_ms = integer("retry backoff", options.backoffMs);
+        this.spec.retry = retry;
+        return this;
+    }
+    timeout(ms) {
+        this.assertMutable();
+        this.spec.timeout_ms = integer("timeout", ms);
+        return this;
+    }
+    noProgressTimeout(ms) {
+        this.assertMutable();
+        this.spec.no_progress_timeout_ms = integer("no-progress timeout", ms);
+        return this;
+    }
+    beforeRun(fn) {
+        this.assertMutable();
+        this.callbacks.push({ id: this.closureID("before_run"), kind: "before_run", fn, job: this });
+        return this;
+    }
+    afterRun(fn) {
+        this.assertMutable();
+        this.callbacks.push({ id: this.closureID("after_run"), kind: "after_run", fn, job: this });
+        return this;
+    }
+    verify(fn) {
+        this.assertMutable();
+        this.callbacks = this.callbacks.filter((c) => c.kind !== "verify");
+        this.callbacks.push({ id: this.closureID("verify"), kind: "verify", fn, job: this });
+        return this;
+    }
+    memo(fn, options = {}) {
+        this.assertMutable();
+        const memo = {};
+        if (options.ttlMs !== undefined)
+            memo.ttl_ms = integer("memo TTL", options.ttlMs);
+        this.spec.memo = memo;
+        this.callbacks = this.callbacks.filter((c) => c.kind !== "memo_key");
+        if (typeof fn === "function")
+            this.callbacks.push({ id: this.closureID("memo_key"), kind: "memo_key", fn, job: this });
+        else
+            memo.input = jsonValue(fn, true);
+        return this;
+    }
+    cache(...caches) {
+        this.assertMutable();
+        const entries = caches.map((cache) => {
+            if (cache.kind === "go_modules")
+                return { name: "go-modules", resolver: "go-modules", key_files: ["go.sum"] };
+            if (cache.kind === "npm")
+                return { name: "npm", resolver: "npm", key_files: ["package-lock.json"] };
+            if (cache.kind !== "dir" || !cache.path || !cache.keyFiles?.length)
+                throw new Error("directory cache needs a path and at least one key file");
+            const clean = posix.normalize(cache.path).replace(/(.)\/+$/, "$1");
+            return { name: posix.basename(clean), path: cache.path, key_scope: clean, key_files: names("cache key file", cache.keyFiles) };
+        });
+        (this.spec.caches ??= []).push(...entries);
+        return this;
+    }
+    artifacts(...globs) {
+        this.assertMutable();
+        this.spec.artifacts = names("artifact glob", [...(this.spec.artifacts ?? []), ...globs]);
+        return this;
+    }
+    consumes(producer, options = {}) {
+        this.assertMutable();
+        const ids = dependencyIDs([producer]);
+        (this.spec.consumes ??= []).push(...ids.map((id) => (options.into === undefined ? { producer: id } : { producer: id, into: options.into })));
+        return this.needs(...ids);
+    }
+    concurrency(group, cost) {
+        this.assertMutable();
+        addConcurrency(this.spec, group, cost);
+        return this;
+    }
+    needsTools(...values) {
+        this.assertMutable();
+        for (const name of values)
+            if (!knownTools.has(name))
+                throw new Error(`not a known tool: ${name}`);
+        this.#tools = unique([...this.#tools, ...values.map((name) => `tool:${name}`)]);
+        return this;
+    }
+    requires(...labels) {
+        this.assertMutable();
+        this.#requires = [...labels];
+        return this;
+    }
+    prefers(...labels) {
+        this.assertMutable();
+        this.spec.prefers = [...labels];
+        return this;
+    }
+    inline() {
+        this.assertMutable();
+        this.spec.inline = true;
+        return this;
+    }
+    env(name, value, option) {
+        this.assertMutable();
+        if (!name || name.includes("=") || name.includes("\0") || value.includes("\0"))
+            throw new Error("invalid environment variable");
+        (this.spec.env ??= Object.create(null))[name] =
+            option?.phase === "startup" ? { value, startup: true } : { value };
+        return this;
+    }
+    generate(fn) {
+        this.assertMutable();
+        const generator = new Generator(this.closureID("generate"), this);
+        this.callbacks.push({
+            id: generator.id,
+            kind: "generate",
+            fn: fn,
+            generator: generator,
+            job: this,
+        });
+        return generator;
+    }
+    toSpec() {
+        const spec = super.toSpec();
+        const requires = [...this.#requires, ...this.#tools];
+        if (requires.length)
+            spec.requires = requires;
+        return spec;
+    }
+}
+export class Generator {
+    id;
+    source;
+    constructor(id, source) {
+        this.id = id;
+        this.source = source;
+    }
+}
+class JobGroup {
+    id;
+    members;
+    constructor(id, members) {
+        this.id = id;
+        this.members = Object.freeze([...members]);
+    }
+    apply(fn) {
+        for (const member of this.members)
+            fn(member);
+        return this;
+    }
+    needs(...jobs) {
+        return this.apply((job) => job.needs(...jobs));
+    }
+    needsIfPresent(...jobs) {
+        return this.apply((job) => job.needsIfPresent(...jobs));
+    }
+    needsGenerated(...generators) {
+        return this.apply((job) => job.needsGenerated(...generators));
+    }
+    retry(attempts, options) {
+        return this.apply((job) => job.retry(attempts, options));
+    }
+    timeout(ms) {
+        return this.apply((job) => job.timeout(ms));
+    }
+    noProgressTimeout(ms) {
+        return this.apply((job) => job.noProgressTimeout(ms));
+    }
+    skipIf(fn, options) {
+        return this.apply((job) => job.skipIf(fn, options));
+    }
+    beforeRun(fn) {
+        return this.apply((job) => job.beforeRun(fn));
+    }
+    verify(fn) {
+        return this.apply((job) => job.verify(fn));
+    }
+    afterRun(fn) {
+        return this.apply((job) => job.afterRun(fn));
+    }
+    memo(fn, options) {
+        return this.apply((job) => job.memo(fn, options));
+    }
+    cache(...caches) {
+        return this.apply((job) => job.cache(...caches));
+    }
+    artifacts(...globs) {
+        return this.apply((job) => job.artifacts(...globs));
+    }
+    consumes(producer, options) {
+        return this.apply((job) => job.consumes(producer, options));
+    }
+    concurrency(group, cost) {
+        return this.apply((job) => job.concurrency(group, cost));
+    }
+    needsTools(...names) {
+        return this.apply((job) => job.needsTools(...names));
+    }
+    requires(...labels) {
+        return this.apply((job) => job.requires(...labels));
+    }
+    prefers(...labels) {
+        return this.apply((job) => job.prefers(...labels));
+    }
+    inline() {
+        return this.apply((job) => job.inline());
+    }
+    optional() {
+        return this.apply((job) => job.optional());
+    }
+    continueOnError() {
+        return this.apply((job) => job.continueOnError());
+    }
+    env(name, value, option) {
+        return this.apply((job) => job.env(name, value, option));
+    }
+}
+export class Plan {
+    declarations = [];
+    settings = {};
+    #groups = new Set();
+    #sealed = false;
+    assertMutable() {
+        if (this.#sealed)
+            throw failure("plan_drift", "declarations cannot change after planning");
+    }
+    seal() {
+        this.#sealed = true;
+    }
+    job(id, body) {
+        this.assertMutable();
+        return this.add(new Job(this, id, body));
+    }
+    approval(id, options = {}) {
+        this.assertMutable();
+        return this.add(new Approval(this, id, options));
+    }
+    add(job) {
+        this.assertMutable();
+        if (this.findJob(job.id))
+            throw new Error(`duplicate job ${job.id}`);
+        this.declarations.push(job);
+        return job;
+    }
+    groupJobs(id, ...jobs) {
+        this.assertMutable();
+        identifier("job group", id);
+        if (this.#groups.has(id))
+            throw new Error(`duplicate job group ${id}`);
+        const members = jobs.map((job) => {
+            if (!(job instanceof Job) || job.owner !== this)
+                throw new Error("job group member belongs to another plan");
+            return job;
+        });
+        for (const member of members)
+            member.addGroup(id);
+        this.#groups.add(id);
+        return new JobGroup(id, members);
+    }
+    concurrency(group, cost) {
+        this.assertMutable();
+        addConcurrency(this.settings, group, cost);
+        return this;
+    }
+    priority(value) {
+        this.assertMutable();
+        if (!Number.isSafeInteger(value))
+            throw new Error("priority must be an integer");
+        this.settings.priority = value;
+        return this;
+    }
+    claimWait(ms) {
+        this.assertMutable();
+        this.settings.claim_wait_ms = integer("claim wait", ms);
+        return this;
+    }
+    admissionClass(value) {
+        this.assertMutable();
+        identifier("admission class", value);
+        this.settings.admission_class = value;
+        return this;
+    }
+    checkout(options) {
+        this.assertMutable();
+        const source = {};
+        if (options.depth !== undefined)
+            source.depth = integer("checkout depth", options.depth);
+        if (options.fullHistory !== undefined)
+            source.full_history = options.fullHistory;
+        if (options.tags !== undefined)
+            source.tags = options.tags;
+        if (options.submodules !== undefined)
+            source.submodules = options.submodules;
+        if (options.lfs !== undefined)
+            source.lfs = options.lfs;
+        this.settings.source = source;
+        return this;
+    }
+    jobs() {
+        return this.declarations;
+    }
+    findJob(id) {
+        return this.declarations.find((job) => job.id === id);
+    }
+    findClosure(id) {
+        return this.declarations.flatMap((job) => job.closures()).find((closure) => closure.id === id);
+    }
+    toDoc() {
+        const jobs = this.declarations.map((job) => job.toSpec());
+        return { jobs, ...structuredClone(this.settings) };
+    }
+    insert(generated) {
+        if (generated.parent !== this)
+            throw new Error("generated jobs belong to another plan");
+        const jobs = generated.toDoc().jobs;
+        generated.seal();
+        this.declarations.push(...generated.jobs());
+        return jobs;
+    }
+}
+export class Generated extends Plan {
+    parent;
+    source;
+    generatorID;
+    constructor(source, generatorID, parent) {
+        super();
+        this.parent = parent;
+        this.source = source;
+        this.generatorID = generatorID;
+        const closure = parent.findClosure(generatorID);
+        if (closure?.kind !== "generate" || closure.job !== source)
+            throw new Error("generator does not belong to source");
+    }
+    add(job) {
+        job.needs(this.source).addGroup(this.generatorID);
+        for (const group of this.source.toSpec().groups ?? [])
+            job.addGroup(group);
+        return super.add(job);
+    }
+    toDoc() {
+        if (Object.keys(this.settings).length)
+            throw new Error("generated jobs cannot change plan settings");
+        const jobs = this.declarations.map((job) => job.toSpec());
+        return { jobs };
+    }
+}
+export function refTo(job) {
+    return {
+        jobId: job.id,
+        async get(ctx) {
+            const value = await ctx.output(job);
+            if (value === undefined)
+                throw failure("not_found", "job output not found");
+            return value;
+        },
+        async tryGet(ctx) {
+            return tryReference(() => ctx.output(job));
+        },
+    };
+}
+export function refToLastRun(pipeline, jobId, options = {}) {
+    identifier("pipeline", pipeline);
+    identifier("job", jobId);
+    const ref = {
+        pipeline,
+        jobId,
+        get(ctx) {
+            return ctx.latest(ref);
+        },
+        tryGet(ctx) {
+            return tryReference(() => ctx.latest(ref));
+        },
+        ...(options.maxAgeMs === undefined ? {} : { maxAgeMs: integer("reference max age", options.maxAgeMs) }),
+    };
+    return Object.freeze(ref);
+}
+async function tryReference(read) {
+    try {
+        return await read();
+    }
+    catch (error) {
+        if (error instanceof SDKError && error.code === "not_found")
+            return undefined;
+        throw error;
+    }
+}
+const registry = new Map();
+export function definePipeline(definition) {
+    identifier("pipeline", definition.name);
+    if (registry.has(definition.name))
+        throw new Error(`pipeline ${definition.name} is already defined`);
+    registry.set(definition.name, definition);
+    return definition;
+}
+export function pipelines() {
+    return [...registry.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function lookupPipeline(name) {
+    return registry.get(name);
+}
+export function resetPipelines() {
+    registry.clear();
+}
+//# sourceMappingURL=plan.js.map