cloving 0.3.20 → 1.1.0

package/dist/src/cli/render.js

@@ -0,0 +1,254 @@
+import { priceText, usageText, totalsSuffix } from "./usage-render.js";
+import { record } from "../protocol.js";
+function show(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function escaped(character) {
+    return `\\u${(character.codePointAt(0) ?? 0).toString(16).padStart(4, "0")}`;
+}
+const hiddenRanges = [
+    [0x00, 0x1f],
+    [0x7f, 0x9f],
+    [0x061c, 0x061c],
+    [0x200b, 0x200f],
+    [0x2028, 0x202e],
+    [0x2060, 0x2069],
+    [0xfeff, 0xfeff],
+];
+function hidden(character) {
+    const code = character.codePointAt(0) ?? 0;
+    return hiddenRanges.some(([first, last]) => code >= first && code <= last);
+}
+function visible(value) {
+    return show(value)
+        .split("\n")
+        .map((line) => Array.from(line, (character) => hidden(character) ? escaped(character) : character).join(""))
+        .join("\n    ");
+}
+export function errorText(error) {
+    const { candidates } = error;
+    const lines = [`${visible(error["code"])}: ${visible(error["detail"])}`];
+    if (Array.isArray(candidates))
+        lines.push(`Candidates: ${candidates.map(visible).join(", ")}`);
+    return lines.map((line) => `${line}\n`).join("");
+}
+function part(value, name) {
+    return record(value)?.[name];
+}
+function listing(value) {
+    const items = Array.isArray(value) ? value.map(show) : [];
+    return items.length === 0 ? "none" : items.join(", ");
+}
+function receiptLines(result) {
+    const receipt = result["receipt"];
+    return [
+        `Command ID: ${show(result["commandId"])}`,
+        `Receipt: sequence ${show(part(receipt, "sequence"))}, recorded at ${show(part(receipt, "recordedAt"))}`,
+        ...(result["replayed"] === true
+            ? ["This is the receipt of the earlier equal command."]
+            : []),
+    ];
+}
+function admitted(result) {
+    return [
+        `Run ${show(result["runId"])} is admitted.`,
+        ...receiptLines(result),
+        "The run is queued. Admission is not completed work.",
+    ];
+}
+function runLine(run) {
+    return `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}`;
+}
+function ended(run) {
+    return ["completed", "failed", "cancelled"].includes(show(run["state"]));
+}
+function newest(first, second) {
+    return show(second["latestAt"] ?? "").localeCompare(show(first["latestAt"] ?? ""));
+}
+export function runOverview(result) {
+    const listed = result["runs"];
+    const runs = Array.isArray(listed)
+        ? listed.map(record).filter((run) => run !== undefined)
+        : [];
+    const active = runs.filter((run) => !ended(run)).toSorted(newest);
+    const finished = runs.filter(ended).toSorted(newest);
+    return {
+        ...result,
+        runs: [...active, ...finished.slice(0, 20)],
+        hiddenRuns: Math.max(0, finished.length - 20),
+    };
+}
+function runList(result) {
+    const runs = result["runs"];
+    const lines = Array.isArray(runs) ? runs.map(runLine) : [];
+    const hiddenRuns = result["hiddenRuns"];
+    return [
+        `Workflows: ${visible(listing(result["workflows"]))}`,
+        "Runs:",
+        ...(lines.length === 0 ? ["  none"] : lines),
+        ...(typeof hiddenRuns === "number" && hiddenRuns > 0
+            ? [
+                `${String(hiddenRuns)} older runs: use --limit and --after to see them`,
+            ]
+            : []),
+    ];
+}
+function observation(value) {
+    if (record(value) === undefined)
+        return "none";
+    return `${show(part(value, "at"))} (sequence ${show(part(value, "sequence"))}, ${show(part(value, "source"))})`;
+}
+function feedbackLines(value) {
+    return (Array.isArray(value) ? value : []).map((item) => `Feedback of ${show(part(item, "decisionId"))}: ${visible(part(item, "text"))}`);
+}
+function outcome(value) {
+    if (record(value) === undefined)
+        return "none";
+    const reason = part(value, "reason");
+    const kind = visible(part(value, "kind"));
+    return typeof reason === "string" ? `${kind}: ${visible(reason)}` : kind;
+}
+function workerLines(value) {
+    return (Array.isArray(value) ? value : []).flatMap((turn) => [
+        `Worker turn ${visible(part(turn, "operationId"))}: ${priceText(part(turn, "costUsd"), part(turn, "estimatedCostUsd"))}`,
+        `  ${usageText(part(turn, "usage"))}`,
+    ]);
+}
+export function statusJson(result) {
+    const run = record(result["run"]);
+    if (result["kind"] !== "run-status" || run === undefined)
+        return result;
+    const turns = run["workerTurns"];
+    return {
+        ...result,
+        run: {
+            ...run,
+            costDisplay: priceText(run["claudeCostUsd"], run["estimatedCostUsd"]),
+            ...(Array.isArray(turns)
+                ? {
+                    workerTurns: turns.map((turn) => {
+                        const fields = record(turn);
+                        if (fields === undefined)
+                            return turn;
+                        return {
+                            ...fields,
+                            costDisplay: priceText(fields["costUsd"], fields["estimatedCostUsd"]),
+                        };
+                    }),
+                }
+                : {}),
+        },
+    };
+}
+export function runStatus(result) {
+    const run = result["run"];
+    const reason = part(run, "reason");
+    const recovery = part(run, "recovery");
+    const at = part(run, "nextActionAt") ?? null;
+    const suffix = totalsSuffix(part(run, "state"));
+    return [
+        `Run ${show(part(run, "runId"))} (${show(part(run, "workflowId"))})`,
+        `Title: ${visible(part(run, "title") ?? "none")}`,
+        `State: ${show(part(run, "state"))}`,
+        `Outcome: ${outcome(part(run, "outcome"))}`,
+        ...(typeof part(part(run, "outcome"), "ticketStatus") === "string"
+            ? [
+                `Ticket status: ${visible(part(part(run, "outcome"), "ticketStatus"))}`,
+            ]
+            : []),
+        ...(part(part(run, "outcome"), "issueUpdate") === "failed"
+            ? ["Issue status update failed; check the GitHub operation."]
+            : []),
+        `Condition: ${show(part(run, "condition"))}`,
+        `Reason: ${show(part(reason, "code"))}: ${show(part(reason, "detail"))}`,
+        `Revision: ${show(part(run, "revision"))}, latest sequence ${show(part(run, "latestSequence"))}`,
+        `Latest at: ${show(part(run, "latestAt") ?? "none")}`,
+        `Pending decisions: ${listing(part(run, "pendingDecisions"))}`,
+        `Evidence: ${listing(part(run, "evidence"))}`,
+        `Last confirmed observation: ${observation(part(run, "lastConfirmedObservation"))}`,
+        `Recovery: ${show(part(recovery, "attempts"))} of ${show(part(recovery, "limit") ?? "no limit")}`,
+        `Cost${suffix}: ${priceText(part(run, "claudeCostUsd"), part(run, "estimatedCostUsd"))}`,
+        `Token usage${suffix}: ${usageText(part(run, "usage"))}`,
+        ...workerLines(part(run, "workerTurns")),
+        `Next action: ${show(part(run, "nextAction") ?? "none")}${at === null ? "" : ` at ${show(at)}`}`,
+        `Human input can help: ${part(run, "humanInputCanHelp") === true ? "yes" : "no"}`,
+        ...feedbackLines(part(run, "feedback")),
+    ];
+}
+function binding(decision) {
+    return `--expected-revision ${show(part(decision, "revision"))} --generation ${show(part(decision, "generation"))} --subject-digest ${show(part(decision, "subjectDigest"))}`;
+}
+function suggestion(decision, command) {
+    const reference = part(decision, "label") ?? part(decision, "decisionId");
+    const head = `  cloving ${show(command)} ${show(reference)}`;
+    const tail = binding(decision);
+    if (command === "answer")
+        return `${head} --text <answer> ${tail}`;
+    if (command === "deny")
+        return `${head} --text "<feedback>" ${tail}`;
+    return `${head} ${tail}`;
+}
+export function decisionLines(decision) {
+    const allowed = part(decision, "allowed");
+    const label = part(decision, "label");
+    return [
+        `${label === null ? "" : `${show(label)} `}${show(part(decision, "type"))} ${show(part(decision, "decisionId"))}`,
+        `  Prompt: ${visible(part(decision, "prompt"))}`,
+        ...feedbackLines(part(decision, "feedback")).map((line) => `  ${line}`),
+        ...(Array.isArray(allowed) ? allowed : []).map((command) => suggestion(decision, command)),
+    ];
+}
+export function decisionList(result) {
+    const decisions = result["decisions"];
+    const lines = Array.isArray(decisions)
+        ? decisions.flatMap(decisionLines)
+        : [];
+    return lines.length === 0 ? ["No decision waits."] : lines;
+}
+function decisionRecorded(result) {
+    const run = result["run"];
+    return [
+        `Decision ${show(result["decisionId"])} is recorded as ${show(result["decision"])}.`,
+        ...receiptLines(result),
+        `Run state: ${show(part(run, "state"))}, revision ${show(part(run, "revision"))}`,
+        `Continuation: ${show(result["continuation"])}`,
+    ];
+}
+function runCommand(result) {
+    const committed = result["committed"];
+    const observed = result["observed"];
+    return [
+        `Run ${show(result["runId"])}: ${show(result["command"])} is committed. State ${show(part(committed, "state"))}, revision ${show(part(committed, "revision"))}.`,
+        ...receiptLines(result),
+        `Revoked intents: ${show(part(committed, "revokedIntents"))}`,
+        `Observed: ${show(part(observed, "condition"))}`,
+        `Unresolved effects: ${listing(part(observed, "unresolvedEffects"))}`,
+    ];
+}
+export function eventText(event) {
+    return `${show(event["sequence"])}  ${show(event["recordedAt"])}  ${show(event["type"])}  ${show(event["runId"])}  ${JSON.stringify(event["payload"])}`;
+}
+function eventPage(result) {
+    const events = result["events"];
+    return (Array.isArray(events) ? events : []).map((event) => eventText(record(event) ?? {}));
+}
+const renderers = new Map([
+    ["run-admitted", admitted],
+    ["run-list", runList],
+    ["run-status", runStatus],
+    ["decision-list", decisionList],
+    ["decision-recorded", decisionRecorded],
+    ["run-command", runCommand],
+    ["event-page", eventPage],
+]);
+export function rendered(result) {
+    const lines = renderers.get(show(result["kind"]))?.(result) ?? [];
+    return lines.map((line) => `${line}\n`).join("");
+}
+export function pendingSummary(result) {
+    const decisions = result["decisions"];
+    const lines = (Array.isArray(decisions) ? decisions : []).map((decision) => `  ${show(part(decision, "label") ?? part(decision, "type"))} ${show(part(decision, "decisionId"))}: ${visible(part(decision, "prompt"))}`);
+    return ["Pending decisions:", ...(lines.length === 0 ? ["  none"] : lines)]
+        .map((line) => `${line}\n`)
+        .join("");
+}

package/dist/src/cli/runtime-arguments.d.ts

@@ -0,0 +1,73 @@
+export type RunSource = {
+    readonly kind: "prompt";
+    readonly text: string;
+} | {
+    readonly kind: "ticket";
+    readonly id: string;
+} | {
+    readonly kind: "input";
+    readonly file: string;
+};
+type DecisionCommand = "answer" | "approve" | "deny";
+type RunCommand = "pause" | "resume" | "drop";
+export type RuntimeInvocation = {
+    readonly kind: "command-help";
+    readonly command: string;
+} | {
+    readonly kind: "run";
+    readonly workflowId: string;
+    readonly source: RunSource;
+    readonly commandId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "status";
+    readonly runId: string | null;
+    readonly limit: number | null;
+    readonly after: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "questions";
+    readonly runId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "decision";
+    readonly command: DecisionCommand;
+    readonly reference: string;
+    readonly text: string | null;
+    readonly expectedRevision: number;
+    readonly generation: number;
+    readonly subjectDigest: string;
+    readonly commandId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "run-command";
+    readonly command: RunCommand;
+    readonly runId: string;
+    readonly expectedRevision: number;
+    readonly commandId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "events";
+    readonly runId: string | null;
+    readonly after: number;
+    readonly limit: number | null;
+    readonly follow: boolean;
+    readonly json: boolean;
+} | {
+    readonly kind: "watch";
+    readonly port: number | null;
+    readonly json: boolean;
+};
+export interface GivenOption {
+    readonly name: string;
+    readonly value: string | undefined;
+}
+export interface RuntimeRequest {
+    readonly command: string;
+    readonly positionals: readonly string[];
+    readonly options: readonly GivenOption[];
+}
+type Outcome = RuntimeInvocation | string;
+export declare function isRuntimeCommand(command: string): boolean;
+export declare function runtimeInvocation(request: RuntimeRequest): Outcome;
+export {};

package/dist/src/cli/runtime-arguments.js

@@ -0,0 +1,248 @@
+import { isRecordKey } from "../authority/commands.js";
+const identifier = /^[A-Za-z0-9._:/-]{1,128}$/;
+const decisionReference = /^[A-Za-z0-9._:/-]{1,256}$/;
+const sha256Digest = /^sha256:[0-9a-f]{64}$/;
+const wholeNumber = /^(?:0|[1-9][0-9]*)$/;
+const invalid = Symbol("invalid");
+const revisions = { minimum: 1, maximum: Number.MAX_SAFE_INTEGER };
+const sequences = { minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
+const bindingOptions = ["expected-revision", "generation", "subject-digest"];
+const mutationOptions = ["command-id", "json"];
+const shapes = new Map([
+    [
+        "run",
+        {
+            subject: "required",
+            required: [],
+            allowed: () => ["prompt", "input", "ticket", "next", ...mutationOptions],
+            build: run,
+        },
+    ],
+    [
+        "status",
+        {
+            subject: "optional",
+            required: [],
+            allowed: statusOptions,
+            build: status,
+        },
+    ],
+    [
+        "questions",
+        {
+            subject: "optional",
+            required: [],
+            allowed: () => ["json"],
+            build: questions,
+        },
+    ],
+    ["answer", decisionShape("answer")],
+    ["approve", decisionShape("approve")],
+    ["deny", decisionShape("deny")],
+    ["pause", runCommandShape("pause")],
+    ["resume", runCommandShape("resume")],
+    ["drop", runCommandShape("drop")],
+    [
+        "events",
+        {
+            subject: "optional",
+            required: [],
+            allowed: eventOptions,
+            build: events,
+        },
+    ],
+    [
+        "watch",
+        {
+            subject: "none",
+            required: [],
+            allowed: () => ["port"],
+            build: watch,
+        },
+    ],
+]);
+export function isRuntimeCommand(command) {
+    return shapes.has(command);
+}
+export function runtimeInvocation(request) {
+    const shape = shapes.get(request.command);
+    if (shape === undefined)
+        return "unknown-command";
+    const names = request.options.map((option) => option.name);
+    if (new Set(names).size !== names.length)
+        return "repeated-option";
+    if (names.includes("help"))
+        return { kind: "command-help", command: request.command };
+    return shapeFailure(shape, request) ?? shape.build(request);
+}
+function shapeFailure(shape, request) {
+    const names = request.options.map((option) => option.name);
+    const allowed = shape.allowed(request);
+    const count = request.positionals.length;
+    if (names.some((name) => !allowed.includes(name)))
+        return "unexpected-option";
+    if (shape.subject === "required" && count === 0)
+        return "missing-argument";
+    if (count > (shape.subject === "none" ? 0 : 1))
+        return "unexpected-argument";
+    if (shape.required.some((name) => !names.includes(name)))
+        return "missing-option";
+    return undefined;
+}
+function decisionShape(command) {
+    const required = command === "answer" ? [...bindingOptions, "text"] : bindingOptions;
+    const optional = command === "deny" ? ["text"] : [];
+    return {
+        subject: "required",
+        required,
+        allowed: () => [...required, ...optional, ...mutationOptions],
+        build: (request) => decision(command, request),
+    };
+}
+function runCommandShape(command) {
+    return {
+        subject: "required",
+        required: ["expected-revision"],
+        allowed: () => ["expected-revision", ...mutationOptions],
+        build: (request) => runCommand(command, request),
+    };
+}
+function statusOptions(request) {
+    return request.positionals.length === 0
+        ? ["limit", "after", "json"]
+        : ["json"];
+}
+function eventOptions(request) {
+    return given(request, "follow")
+        ? ["after", "follow", "json"]
+        : ["after", "limit", "follow", "json"];
+}
+function given(request, name) {
+    return request.options.some((option) => option.name === name);
+}
+function valueOf(request, name) {
+    return request.options.find((option) => option.name === name)?.value;
+}
+function blank(value) {
+    return value?.trim() === "";
+}
+function matching(value, pattern) {
+    if (value === undefined)
+        return null;
+    return pattern.test(value) ? value : invalid;
+}
+function key(value) {
+    if (value === undefined)
+        return null;
+    return isRecordKey(value) ? value : invalid;
+}
+function whole(value, range) {
+    if (value === undefined)
+        return null;
+    if (!wholeNumber.test(value))
+        return invalid;
+    const number = Number(value);
+    return number >= range.minimum && number <= range.maximum ? number : invalid;
+}
+function inputSource(request) {
+    const prompt = valueOf(request, "prompt");
+    const input = valueOf(request, "input");
+    const ticket = valueOf(request, "ticket");
+    const next = given(request, "next");
+    const sources = [prompt, input, ticket].filter((value) => value !== undefined);
+    if (sources.length + Number(next) > 1)
+        return "conflicting-input-sources";
+    if (prompt !== undefined)
+        return { kind: "prompt", text: prompt };
+    if (input !== undefined)
+        return { kind: "input", file: input };
+    if (ticket !== undefined)
+        return { kind: "ticket", id: ticket };
+    if (next)
+        return { kind: "ticket", id: "next" };
+    return "missing-input-source";
+}
+function run(request) {
+    const source = inputSource(request);
+    if (typeof source === "string")
+        return source;
+    if (blank(valueOf(request, "prompt")))
+        return "empty-prompt";
+    const workflowId = matching(request.positionals[0], identifier);
+    const commandId = key(valueOf(request, "command-id"));
+    const unusable = typeof workflowId !== "string" ||
+        key(valueOf(request, "ticket")) === invalid;
+    if (unusable || commandId === invalid)
+        return "invalid-option-value";
+    const json = given(request, "json");
+    return { kind: "run", workflowId, source, commandId, json };
+}
+function status(request) {
+    const runId = key(request.positionals[0]);
+    const limit = whole(valueOf(request, "limit"), { minimum: 1, maximum: 500 });
+    const after = matching(valueOf(request, "after"), identifier);
+    if (runId === invalid || limit === invalid || after === invalid)
+        return "invalid-option-value";
+    const json = given(request, "json");
+    return { kind: "status", runId, limit, after, json };
+}
+function watch(request) {
+    const port = whole(valueOf(request, "port"), { minimum: 0, maximum: 65535 });
+    if (port === invalid)
+        return "invalid-option-value";
+    return { kind: "watch", port, json: false };
+}
+function questions(request) {
+    const runId = key(request.positionals[0]);
+    if (runId === invalid)
+        return "invalid-option-value";
+    return { kind: "questions", runId, json: given(request, "json") };
+}
+function decision(command, request) {
+    const answer = valueOf(request, "text");
+    if (blank(answer))
+        return "empty-prompt";
+    const reference = matching(request.positionals[0], decisionReference);
+    const expectedRevision = whole(valueOf(request, "expected-revision"), revisions);
+    const generation = whole(valueOf(request, "generation"), revisions);
+    const subjectDigest = matching(valueOf(request, "subject-digest"), sha256Digest);
+    const commandId = key(valueOf(request, "command-id"));
+    if (typeof reference !== "string" ||
+        typeof expectedRevision !== "number" ||
+        typeof generation !== "number" ||
+        typeof subjectDigest !== "string" ||
+        commandId === invalid)
+        return "invalid-option-value";
+    const subject = { command, reference, text: answer ?? null };
+    const binding = { expectedRevision, generation, subjectDigest };
+    const json = given(request, "json");
+    return { kind: "decision", ...subject, ...binding, commandId, json };
+}
+function runCommand(command, request) {
+    const runId = key(request.positionals[0]);
+    const expectedRevision = whole(valueOf(request, "expected-revision"), revisions);
+    const commandId = key(valueOf(request, "command-id"));
+    if (typeof runId !== "string" ||
+        typeof expectedRevision !== "number" ||
+        commandId === invalid)
+        return "invalid-option-value";
+    const json = given(request, "json");
+    return {
+        kind: "run-command",
+        command,
+        runId,
+        expectedRevision,
+        commandId,
+        json,
+    };
+}
+function events(request) {
+    const runId = key(request.positionals[0]);
+    const after = whole(valueOf(request, "after"), sequences);
+    const limit = whole(valueOf(request, "limit"), { minimum: 1, maximum: 1000 });
+    if (runId === invalid || after === invalid || limit === invalid)
+        return "invalid-option-value";
+    const follow = given(request, "follow");
+    const json = given(request, "json");
+    return { kind: "events", runId, after: after ?? 0, limit, follow, json };
+}

package/dist/src/cli/runtime-directory.d.ts

@@ -0,0 +1,4 @@
+type Environment = Readonly<Record<string, string | undefined>>;
+export declare function clientCommand(environment: Environment): string;
+export declare function runtimeDirectory(environment: Environment): string | undefined;
+export {};

package/dist/src/cli/runtime-directory.js

@@ -0,0 +1,25 @@
+import { join } from "node:path";
+function given(value) {
+    return value !== undefined && value.length > 0;
+}
+export function clientCommand(environment) {
+    const explicit = environment["CLOVING_RUNTIME_DIR"];
+    return given(explicit)
+        ? `CLOVING_RUNTIME_DIR=${explicit} cloving`
+        : "cloving";
+}
+export function runtimeDirectory(environment) {
+    const explicit = environment["CLOVING_RUNTIME_DIR"];
+    if (given(explicit))
+        return explicit;
+    const runtime = environment["XDG_RUNTIME_DIR"];
+    if (given(runtime))
+        return join(runtime, "cloving");
+    const state = environment["XDG_STATE_HOME"];
+    if (given(state))
+        return join(state, "cloving", "run");
+    const home = environment["HOME"];
+    return given(home)
+        ? join(home, ".local", "state", "cloving", "run")
+        : undefined;
+}

package/dist/src/cli/toolchain.d.ts

@@ -0,0 +1,3 @@
+import type { ToolchainIdentity } from "../workflow-admission.ts";
+export declare function observedToolchain(start: string): Promise<ToolchainIdentity>;
+export declare function qualifiedToolchain(observed: ToolchainIdentity, start: string): Promise<ToolchainIdentity>;

package/dist/src/cli/toolchain.js

@@ -0,0 +1,74 @@
+import { findPackageJSON } from "node:module";
+import { createHash } from "node:crypto";
+import { access, readFile, realpath } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import packageMetadata from "#package" with { type: "json" };
+const qualifiedNode = "v26.9.0";
+export async function observedToolchain(start) {
+    const root = await projectRoot(start);
+    const sdk = await packageDirectory(start, "workflow");
+    const core = sdk === undefined
+        ? undefined
+        : await packageDirectory(sdk, "@workflow/core");
+    const lock = await readFile(join(root, "package-lock.json")).catch(() => null);
+    return {
+        sdk: `workflow@${await installedVersion(start, "workflow")}`,
+        world: `@workflow/world-local@${await installedVersion(core ?? start, "@workflow/world-local")}`,
+        builder: `@workflow/builders@${await installedVersion(start, "@workflow/builders")}`,
+        node: process.version,
+        dependencies: lock === null
+            ? "missing"
+            : createHash("sha256").update(lock).digest("hex"),
+    };
+}
+export async function qualifiedToolchain(observed, start) {
+    const sdk = await packageDirectory(start, "workflow");
+    const core = await packageFields(sdk ?? start, "@workflow/core");
+    const declared = fields(core["dependencies"])["@workflow/world-local"];
+    return {
+        sdk: `workflow@${packageMetadata.dependencies.workflow}`,
+        world: `@workflow/world-local@${typeof declared === "string" ? declared : "undeclared"}`,
+        builder: `@workflow/builders@${packageMetadata.dependencies["@workflow/builders"]}`,
+        node: qualifiedNode,
+        dependencies: observed.dependencies,
+    };
+}
+async function projectRoot(start) {
+    let directory = start;
+    for (;;) {
+        const found = await access(join(directory, "package-lock.json")).then(() => true, () => false);
+        const parent = dirname(directory);
+        if (found || parent === directory)
+            return directory;
+        directory = parent;
+    }
+}
+async function installedVersion(root, name) {
+    const version = (await packageFields(root, name))["version"];
+    return typeof version === "string" ? version : "missing";
+}
+async function packageFields(root, name) {
+    const directory = await packageDirectory(root, name);
+    if (directory === undefined)
+        return {};
+    const text = await readFile(join(directory, "package.json"), "utf8").catch(() => "{}");
+    return fields(JSON.parse(text));
+}
+function fields(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value));
+}
+async function packageDirectory(start, name) {
+    try {
+        const file = findPackageJSON(name, join(start, "package.json"));
+        return file === undefined ? undefined : dirname(await realpath(file));
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ERR_MODULE_NOT_FOUND")
+            return undefined;
+        throw error;
+    }
+}