akm-cli 0.9.2-alpha.4 → 0.9.2

package/dist/workflows/ir/source-freeze-v4.js

@@ -1,506 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { prepareCommandInvocation } from "../../commands/command/command-execution.js";
-import { loadAdapterExecutionSource } from "../../commands/command/execution-source-loader.js";
-import { makeBundleRef, parseBundleRef } from "../../core/asset/asset-ref.js";
-import { parseEnvRef } from "../../core/env-secret-ref.js";
-import { ConfigError, UsageError } from "../../core/errors.js";
-import { captureFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
-import { freezeExecutableIdentity } from "../../execution/executable-identity.js";
-import { canonicalResolvedExecutionRequest, decodeResolvedExecutionRequest, } from "../../execution/resolved-request.js";
-import { deriveInstallations } from "../../indexer/installations.js";
-import { resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
-import { requireAuthorizedExecutionPlan } from "../../integrations/agent/execution-cascade.js";
-import { lowerResolvedExecutionRequest } from "../../integrations/agent/execution-lowering.js";
-import { prepareInlineExecution } from "../../integrations/agent/inline-execution.js";
-import { resolveAssetPath } from "../../sources/resolve.js";
-import { prepareTaskV3Execution, } from "../../tasks/runtime-v3.js";
-import { parseTaskV3Yaml } from "../../tasks/source-v3.js";
-import { defaultLlmEngineConcurrency } from "../concurrency-policy.js";
-import { DEFAULT_EXEC_TIMEOUT_MS } from "../resource-limits.js";
-import { compileWorkflowSource } from "../source-ir/compile.js";
-import { sourceStepProgramUnit, sourceStepRef, workflowShellCommand } from "../source-ir/program.js";
-import { classifyWorkflowStepUses } from "../source-ir/semantics.js";
-import { freezeWorkflowEnvironment } from "./environment-v4.js";
-/** Resolve every authored target through the shared command/task authorities before v4 publication. */
-export async function resolveWorkflowSourceV4(asset, workflowSource, config, collector) {
-    const compiled = compileWorkflowSource(workflowSource.content, { path: asset.path, workspaceRoot: asset.sourcePath });
-    if (!compiled.ok) {
-        throw new UsageError(`Workflow source cannot be frozen: ${compiled.errors.map((error) => error.message).join("; ")}`, "INVALID_FLAG_VALUE");
-    }
-    if (compiled.ir.jobs.length !== 1) {
-        throw new UsageError("Multi-job workflow cannot execute until job boundaries and needs have a durable runtime representation.", "INVALID_FLAG_VALUE");
-    }
-    const context = { asset, config, collector, sourceIr: compiled.ir };
-    const units = new Map();
-    const judges = new Map();
-    let engineAnnouncement;
-    const sourceSteps = compiled.ir.jobs[0]?.steps ?? [];
-    for (const sourceStep of sourceSteps) {
-        if (!sourceStep.route) {
-            const resolved = await resolveStep(sourceStep, context);
-            units.set(sourceStep.id, Object.freeze(resolved));
-            engineAnnouncement ??= resolved.engineAnnouncement;
-        }
-        if (sourceStep.gate?.rubric?.trim()) {
-            const judge = resolveJudge(sourceStep, context);
-            if (judge.target.kind !== "command")
-                throw new Error(`workflow judge ${sourceStep.id} did not resolve to a command target`);
-            judges.set(sourceStep.id, judge.target);
-            engineAnnouncement ??= judge.engineAnnouncement;
-        }
-    }
-    return Object.freeze({
-        sourceIr: compiled.ir,
-        units,
-        judges,
-        ...(engineAnnouncement ? { engineAnnouncement } : {}),
-    });
-}
-async function resolveStep(source, context) {
-    const baseUnit = sourceStepProgramUnit(source);
-    if (source.exec || source.run !== undefined)
-        return directShell(source, baseUnit, context);
-    if (!source.uses)
-        return inlineDispatch(source, baseUnit, context);
-    const target = classifyWorkflowStepUses(source.uses);
-    if (target.kind === "task")
-        return taskDispatch(source, baseUnit, target.ref, context);
-    if (target.kind === "script")
-        return directScript(source, baseUnit, target.ref, context);
-    if (target.kind === "command" || target.kind === "builtin-command") {
-        const action = target.kind === "builtin-command"
-            ? source.with
-            : { ref: qualifyRef(target.ref, "commands", context.asset, context.config) };
-        return commandDispatch(source, baseUnit, action, context);
-    }
-    throw new UsageError(`Workflow target ${source.uses} is not executable in 0.9.2.`, "INVALID_FLAG_VALUE");
-}
-async function commandDispatch(source, baseUnit, action, context) {
-    const prepared = await prepareCommandInvocation({
-        action,
-        config: context.config,
-        invocationKind: "workflow",
-        ...(context.sourceIr.defaults
-            ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
-            : {}),
-        ...(source.commandMode === "literal" ? { inlineContentMode: "literal" } : {}),
-        current: executionValues(source, context.asset.sourcePath),
-        sourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
-    });
-    return commandResult(source, baseUnit, prepared, context);
-}
-function inlineDispatch(source, baseUnit, context) {
-    const content = source.instructions ?? `Execute workflow step ${source.id}.`;
-    const prepared = prepareInlineExecution({
-        content,
-        config: context.config,
-        invocationKind: "workflow",
-        ...(context.sourceIr.defaults
-            ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
-            : {}),
-        current: executionValues(source, context.asset.sourcePath),
-    });
-    return commandResult(source, baseUnit, prepared, context);
-}
-function resolveJudge(source, context) {
-    const engine = context.config.workflow?.judgeEngine;
-    if (!engine) {
-        throw new ConfigError("This workflow declares completion criteria but no verification engine is configured. Set workflow.judgeEngine to a named LLM or agent engine.", "INVALID_CONFIG_FILE");
-    }
-    const content = source.gate?.rubric?.trim() ?? "Judge workflow completion.";
-    const prepared = prepareInlineExecution({
-        content,
-        config: context.config,
-        invocationKind: "workflow",
-        current: { engine },
-    });
-    return commandResult(source, { onError: "fail", source: sourceStepRef(source) }, prepared, context);
-}
-async function taskDispatch(source, baseUnit, refInput, context) {
-    const owned = await resolveOwnedAsset(refInput, "task", context);
-    const retained = captureOwned(owned, context.collector);
-    const task = parseTaskV3Yaml({ yaml: retained.content, filePath: owned.file, workspaceRoot: owned.root });
-    if (task.target.kind === "uses" && task.target.uses.kind === "workflow") {
-        throw new UsageError("A workflow task step cannot compose a nested workflow target.", "INVALID_FLAG_VALUE");
-    }
-    const prepared = await prepareTaskV3Execution(task, {
-        taskId: parseBundleRef(owned.ref).conceptId.slice("tasks/".length),
-        taskRef: owned.ref,
-        bundleName: owned.bundle,
-        bundleRoot: owned.root,
-        config: context.config,
-        commandSourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
-        resolveAsset: async ({ ref, type }) => {
-            const target = await resolveOwnedAsset(ref, type, context);
-            captureOwned(target, context.collector);
-            return { file: target.file, bundleRoot: target.root };
-        },
-        readFile: (file, root = owned.root) => context.collector.readBytes(file, root),
-    });
-    if (prepared.kind === "workflow") {
-        throw new UsageError("A workflow task step cannot compose a nested workflow target.", "INVALID_FLAG_VALUE");
-    }
-    const taskLiterals = Object.entries(prepared.environment).map(([name, value]) => Object.freeze({ kind: "literal", name, value }));
-    if (prepared.kind === "command") {
-        return commandResult(source, baseUnit, prepared.invocation, context, taskLiterals);
-    }
-    if (prepared.kind === "shell") {
-        const authoredExec = {
-            command: workflowShellCommand(prepared.shell, prepared.command),
-            ...(prepared.cwdIdentity.realCwd !== prepared.cwdIdentity.realRoot
-                ? { cwd: path.relative(prepared.cwdIdentity.realRoot, prepared.cwdIdentity.realCwd) }
-                : {}),
-        };
-        const exec = freezeExecSpec(source, authoredExec, context);
-        const environment = Object.freeze([...taskLiterals, ...freezeEnvironment(source, authoredExec, context)]);
-        const executable = freezeExecutableIdentity(exec.command[0], { cwd: prepared.cwdIdentity.realCwd });
-        const target = Object.freeze({
-            kind: "shell",
-            contentHash: "",
-            exec,
-            cwdIdentity: prepared.cwdIdentity,
-            executable,
-            ...gitIdentity(baseUnit, prepared.cwdIdentity.realRoot),
-        });
-        return {
-            target,
-            environment,
-            unit: { ...baseUnit, exec: authoredExec },
-            instructions: source.instructions ?? `Run task ${owned.ref}.`,
-        };
-    }
-    return scriptResult(source, baseUnit, prepared, context, taskLiterals);
-}
-async function directScript(source, baseUnit, refInput, context) {
-    const owned = await resolveOwnedAsset(refInput, "script", context);
-    captureOwned(owned, context.collector);
-    const synthetic = parseTaskV3Yaml({
-        yaml: `version: 3\nuses: ${owned.ref}\nakm:\n  schedule: "@daily"\n`,
-        filePath: `${context.asset.path}#${source.id}`,
-        workspaceRoot: context.asset.sourcePath,
-    });
-    const prepared = await prepareTaskV3Execution(synthetic, {
-        taskId: source.id,
-        taskRef: `${context.asset.ref}#${source.id}`,
-        bundleName: parseBundleRef(context.asset.ref).bundle ?? owned.bundle,
-        bundleRoot: context.asset.sourcePath,
-        config: context.config,
-        resolveAsset: async () => ({ file: owned.file, bundleRoot: owned.root }),
-        readFile: () => context.collector.readBytes(owned.file, owned.root),
-    });
-    if (prepared.kind !== "script")
-        throw new Error("direct script did not project as a script");
-    return scriptResult(source, baseUnit, prepared, context, []);
-}
-function scriptResult(source, baseUnit, prepared, context, literals) {
-    const requestedExecutable = scriptExecutable(prepared.interpreter);
-    const executable = freezeExecutableIdentity(requestedExecutable, { cwd: prepared.cwdIdentity.realCwd });
-    const authoredExec = { command: [executable.absolutePath, "<frozen-script>"] };
-    const exec = freezeExecSpec(source, authoredExec, context);
-    const environment = Object.freeze([...literals, ...freezeEnvironment(source, authoredExec, context)]);
-    const target = Object.freeze({
-        kind: "script",
-        ref: prepared.sourceRef,
-        contentHash: prepared.sha256,
-        exec,
-        interpreter: prepared.interpreter,
-        extension: prepared.extension,
-        bytesBase64: prepared.bytesBase64,
-        byteLength: prepared.byteLength,
-        cwdIdentity: prepared.cwdIdentity,
-        materialization: "ephemeral-0700-delete",
-        executable,
-        ...gitIdentity(baseUnit, prepared.cwdIdentity.realRoot),
-    });
-    return {
-        target,
-        environment,
-        unit: { ...baseUnit, exec: authoredExec },
-        instructions: source.instructions ?? `Run script ${prepared.sourceRef}.`,
-    };
-}
-function directShell(source, baseUnit, context) {
-    const authoredExec = baseUnit.exec;
-    if (!authoredExec)
-        throw new Error(`workflow shell step ${source.id} lost its source-IR execution spec`);
-    const exec = freezeExecSpec(source, authoredExec, context);
-    const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath, authoredExec.cwd);
-    const executable = freezeExecutableIdentity(authoredExec.command[0], { cwd: cwdIdentity.realCwd });
-    const environment = Object.freeze(freezeEnvironment(source, authoredExec, context));
-    const target = Object.freeze({
-        kind: "shell",
-        contentHash: "",
-        exec,
-        cwdIdentity,
-        executable,
-        ...gitIdentity(baseUnit, cwdIdentity.realRoot),
-    });
-    return {
-        target,
-        environment,
-        unit: { ...baseUnit, exec },
-        instructions: source.instructions ?? `Run ${source.run ?? authoredExec.command.join(" ")}.`,
-    };
-}
-function commandResult(source, baseUnit, prepared, context, literals = []) {
-    const request = durableRequest(requireAuthorizedExecutionPlan(prepared.plan));
-    const lowered = lowerResolvedExecutionRequest(request, prepared.config);
-    const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath);
-    let runner = lowered.runner;
-    let executable;
-    if (runner.kind === "agent") {
-        executable = freezeExecutableIdentity(runner.profile.bin, { cwd: cwdIdentity.realCwd });
-        runner = Object.freeze({ ...runner, profile: Object.freeze({ ...runner.profile, bin: executable.absolutePath }) });
-    }
-    const unit = {
-        ...baseUnit,
-        engine: request.engine.name,
-        ...(request.model ? { model: request.model.resolved } : {}),
-        ...(Object.hasOwn(request.runtime, "timeoutMs") ? { timeoutMs: request.runtime.timeoutMs } : {}),
-        ...(request.inference ? { llm: request.inference } : {}),
-        ...(request.outputSchema ? { output: request.outputSchema } : {}),
-    };
-    const environment = Object.freeze([...literals, ...freezeEnvironment(source, undefined, context)]);
-    const target = Object.freeze({
-        kind: "command",
-        ref: request.command.source?.ref ?? null,
-        contentHash: createHash("sha256").update(request.command.content).digest("hex"),
-        request: JSON.parse(canonicalResolvedExecutionRequest(request)),
-        runner,
-        ...(targetConcurrency(runner, context.config) ? { concurrency: targetConcurrency(runner, context.config) } : {}),
-        cwdIdentity,
-        ...(executable ? { executable } : {}),
-        ...gitIdentity(baseUnit, cwdIdentity.realRoot),
-    });
-    const engineAnnouncement = fallbackAnnouncement(prepared.fallbackEngineName, request.engine.name);
-    return {
-        target,
-        environment,
-        unit,
-        instructions: request.command.content,
-        ...(engineAnnouncement ? { engineAnnouncement } : {}),
-    };
-}
-function freezeExecSpec(source, exec, context) {
-    const declared = Object.hasOwn(source.unit ?? {}, "timeoutMs")
-        ? source.unit?.timeoutMs
-        : context.sourceIr.defaults && Object.hasOwn(context.sourceIr.defaults, "timeoutMs")
-            ? context.sourceIr.defaults.timeoutMs
-            : undefined;
-    return {
-        ...exec,
-        command: exec.command,
-        timeoutMs: declared === undefined ? DEFAULT_EXEC_TIMEOUT_MS : declared,
-    };
-}
-function targetConcurrency(runner, config) {
-    if (runner.kind === "llm") {
-        const configured = typeof runner.engine === "string" ? config.engines?.[runner.engine] : undefined;
-        return defaultLlmEngineConcurrency(runner.connection.endpoint, configured?.kind === "llm" ? configured.concurrency : undefined);
-    }
-    if (runner.kind !== "sdk" || !runner.fallbackConnection)
-        return undefined;
-    const selected = typeof runner.engine === "string" ? config.engines?.[runner.engine] : undefined;
-    const fallbackName = selected?.kind === "agent" ? (selected.llmEngine ?? config.defaults?.llmEngine) : undefined;
-    const fallback = fallbackName ? config.engines?.[fallbackName] : undefined;
-    return defaultLlmEngineConcurrency(runner.fallbackConnection.endpoint, fallback?.kind === "llm" ? fallback.concurrency : undefined);
-}
-function durableRequest(request) {
-    const wire = JSON.parse(canonicalResolvedExecutionRequest(request));
-    const runtime = { ...wire.runtime };
-    delete runtime.environment;
-    wire.runtime = runtime;
-    return decodeResolvedExecutionRequest(wire);
-}
-function executionValues(source, workspace) {
-    return executionUnitValues(source.unit, workspace);
-}
-function executionUnitValues(unit, workspace) {
-    return Object.freeze({
-        ...(unit && Object.hasOwn(unit, "engine") ? { engine: unit.engine } : {}),
-        ...(unit && Object.hasOwn(unit, "model") ? { model: unit.model } : {}),
-        ...(unit && Object.hasOwn(unit, "llm") ? { inference: unit.llm } : {}),
-        ...(unit && Object.hasOwn(unit, "timeoutMs") ? { timeout: unit.timeoutMs } : {}),
-        ...(unit && "output" in unit && Object.hasOwn(unit, "output") ? { outputSchema: unit.output } : {}),
-        workspace,
-    });
-}
-function freezeEnvironment(source, exec, context) {
-    const literals = Object.entries(source.env ?? {}).map(([name, value]) => Object.freeze({ kind: "literal", name, value: String(value) }));
-    const passThrough = (exec?.passEnv ?? []).map((name) => Object.freeze({ kind: "pass-through", name }));
-    const refs = source.unit?.env ?? [];
-    const envRefs = freezeWorkflowEnvironment(refs, {
-        collector: context.collector,
-        resolveRef: (ref) => {
-            const parsedEnv = parseEnvRef(ref);
-            if (parsedEnv.type !== "env")
-                throw new UsageError(`Expected an env ref; got ${ref}.`, "INVALID_FLAG_VALUE");
-            const owned = resolveOwnedAssetSync(ref, "env", context);
-            return { ref: owned.ref, bundle: owned.bundle, adapter: owned.adapter, root: owned.root, path: owned.file };
-        },
-    });
-    return [...literals, ...passThrough, ...envRefs];
-}
-async function guardedExecutionSource(ref, kind, context) {
-    const owned = await resolveOwnedAsset(ref, kind === "command" ? "command" : "agent", context);
-    captureOwned(owned, context.collector);
-    const options = {
-        config: context.config,
-        fileContext: () => context.collector.fileContext(owned.root, owned.file),
-    };
-    const rendered = kind === "command"
-        ? await loadAdapterExecutionSource(owned.ref, "command", options)
-        : await loadAdapterExecutionSource(owned.ref, "persona", options);
-    context.collector.bindIdentity(owned.file, owned.root, rendered.identity);
-    return rendered;
-}
-async function resolveOwnedAsset(ref, type, context) {
-    return resolveOwnedAssetCore(ref, type, context, false);
-}
-function resolveOwnedAssetSync(ref, type, context) {
-    return resolveOwnedAssetCore(ref, type, context, true);
-}
-function resolveOwnedAssetCore(refInput, type, context, sync) {
-    const parsed = parseBundleRef(refInput);
-    const plural = type === "env" ? "env" : `${type}s`;
-    const conceptId = parsed.conceptId.startsWith(`${plural}/`) ? parsed.conceptId : `${plural}/${parsed.conceptId}`;
-    const name = conceptId.slice(plural.length + 1);
-    const direct = parsed.bundle ? configuredOwner(parsed.bundle, context.config) : undefined;
-    const sources = resolveSourceEntries(undefined, context.config);
-    const installations = deriveInstallations(sources);
-    const candidates = direct
-        ? [direct]
-        : sources.flatMap((source, index) => {
-            const installation = installations[index];
-            if (!installation || (parsed.bundle && installation.id !== parsed.bundle))
-                return [];
-            return [
-                {
-                    bundle: installation.id,
-                    root: source.path,
-                    adapter: source.adapterId ?? installation.components[0]?.adapter ?? "akm",
-                },
-            ];
-        });
-    const findSync = () => {
-        for (const candidate of candidates) {
-            const directory = path.join(candidate.root, plural);
-            for (const extension of assetExtensions(type)) {
-                const file = path.resolve(directory, `${name}${extension}`);
-                if (fs.existsSync(file) && fs.statSync(file).isFile()) {
-                    return { ...candidate, ref: makeBundleRef(candidate.bundle, conceptId), file };
-                }
-            }
-        }
-        throw new UsageError(`Workflow source target ${refInput} was not found.`, "INVALID_FLAG_VALUE");
-    };
-    if (sync)
-        return findSync();
-    return (async () => {
-        for (const candidate of candidates) {
-            try {
-                const file = await resolveAssetPath(candidate.root, type, name);
-                return { ...candidate, ref: makeBundleRef(candidate.bundle, conceptId), file };
-            }
-            catch {
-                // Continue in installation priority order.
-            }
-        }
-        return findSync();
-    })();
-}
-function configuredOwner(bundle, config) {
-    const entry = config.bundles?.[bundle];
-    if (!entry || typeof entry.path !== "string")
-        return undefined;
-    const components = entry.components ? Object.values(entry.components) : [];
-    const component = components[0];
-    return {
-        bundle,
-        root: path.resolve(entry.path, component?.root ?? "."),
-        adapter: component?.adapter ?? "akm",
-    };
-}
-function assetExtensions(type) {
-    if (type === "script")
-        return [
-            "",
-            ".sh",
-            ".ts",
-            ".js",
-            ".py",
-            ".rb",
-            ".go",
-            ".pl",
-            ".php",
-            ".lua",
-            ".r",
-            ".swift",
-            ".kt",
-            ".kts",
-            ".ps1",
-            ".cmd",
-            ".bat",
-        ];
-    if (type === "env")
-        return ["", ".env"];
-    return ["", ".md", ".yml"];
-}
-function captureOwned(owned, collector) {
-    trackAncestry(collector, owned.root, owned.file);
-    const retained = collector.capture(owned.file, owned.root, { authored: true });
-    return collector.bindIdentity(owned.file, owned.root, {
-        ref: owned.ref,
-        bundle: owned.bundle,
-        adapter: owned.adapter,
-        file: retained.relativePath,
-        hash: retained.sha256,
-    });
-}
-function trackAncestry(collector, rootInput, file) {
-    const root = path.resolve(rootInput);
-    collector.trackDirectory(root, root);
-    const relative = path.relative(root, path.dirname(file));
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new UsageError(`${file} resolves outside its owning root.`, "PATH_ESCAPE_VIOLATION");
-    }
-    let current = root;
-    for (const segment of relative === "" ? [] : relative.split(path.sep)) {
-        current = path.join(current, segment);
-        collector.trackDirectory(current, root);
-    }
-}
-function qualifyRef(ref, plural, asset, config) {
-    const parsed = parseBundleRef(ref);
-    if (parsed.bundle)
-        return ref;
-    const bundle = parseBundleRef(asset.ref).bundle ?? config.defaultBundle;
-    if (!bundle)
-        throw new UsageError(`Workflow ref ${ref} has no owning bundle.`, "INVALID_FLAG_VALUE");
-    const concept = parsed.conceptId.startsWith(`${plural}/`) ? parsed.conceptId : `${plural}/${parsed.conceptId}`;
-    return makeBundleRef(bundle, concept);
-}
-function scriptExecutable(interpreter) {
-    if (interpreter === "bun" || interpreter === "bun-standalone")
-        return process.execPath;
-    if (interpreter === "kotlin")
-        return "kotlin";
-    return interpreter;
-}
-function gitIdentity(unit, root) {
-    if (unit.isolation !== "worktree")
-        return {};
-    const result = spawnSync("git", ["-C", root, "rev-parse", "HEAD"], { encoding: "utf8" });
-    const oid = result.status === 0 ? result.stdout.trim() : "";
-    if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(oid)) {
-        throw new UsageError(`Worktree-isolated workflow root ${root} has no immutable Git HEAD OID.`, "INVALID_FLAG_VALUE");
-    }
-    return { gitCommitOid: oid };
-}

package/dist/workflows/source-ir/ordering.js

@@ -1,38 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/** The one canonical job ordering: emit one lexical ready job, then recompute readiness. */
-export function canonicalTopologicalJobs(jobs) {
-    const byId = new Map(jobs.map((job) => [job.id, job]));
-    for (const job of jobs) {
-        for (const dependency of job.needs) {
-            if (!byId.has(dependency)) {
-                return { ok: false, kind: "missing", job, dependency };
-            }
-        }
-    }
-    const ordered = [];
-    const emitted = new Set();
-    while (ordered.length < jobs.length) {
-        const ready = jobs
-            .filter((job) => !emitted.has(job.id) && job.needs.every((need) => emitted.has(need)))
-            .sort((left, right) => compareCodePoints(left.id, right.id))[0];
-        if (!ready) {
-            const cyclic = jobs
-                .filter((job) => !emitted.has(job.id))
-                .sort((left, right) => compareCodePoints(left.id, right.id))[0];
-            if (!cyclic)
-                throw new Error("Dependency ordering stalled without a remaining job.");
-            return { ok: false, kind: "cycle", job: cyclic };
-        }
-        ordered.push(ready);
-        emitted.add(ready.id);
-    }
-    return { ok: true, jobs: ordered };
-}
-export function compareWorkflowSourceCodePoints(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function compareCodePoints(left, right) {
-    return compareWorkflowSourceCodePoints(left, right);
-}