cloving 1.1.0 → 1.3.0

package/dist/src/workflow-schedule.js

@@ -0,0 +1,53 @@
+import { record } from "./protocol.js";
+import { checkSubmission } from "./submission.js";
+export function parseSchedulesSetting(value) {
+    try {
+        return JSON.parse(value ?? "{}");
+    }
+    catch {
+        throw new Error("invalid-schedules");
+    }
+}
+export function configuredSchedules(declarations, overrides) {
+    const settings = record(overrides);
+    if (settings === undefined)
+        throw new Error("invalid-schedules");
+    if (Object.keys(settings).some((id) => !declarations.some((entry) => entry.workflowId === id)))
+        throw new Error("unknown-schedule-workflow");
+    const schedules = [];
+    for (const declaration of declarations) {
+        const { workflowId } = declaration;
+        const selected = Object.hasOwn(settings, workflowId)
+            ? settings[workflowId]
+            : declaration.schedule;
+        if (selected === undefined && !Object.hasOwn(settings, workflowId))
+            continue;
+        const checked = checkWorkflowSchedule(declaration.input, selected);
+        if (checked.kind === "rejected")
+            throw new Error(checked.code);
+        schedules.push([workflowId, checked.schedule]);
+    }
+    return Object.fromEntries(schedules);
+}
+export function checkWorkflowSchedule(contract, value) {
+    const fields = record(value);
+    const seconds = fields?.["everySeconds"];
+    if (fields === undefined ||
+        Object.keys(fields).some((key) => !["everySeconds", "input"].includes(key)) ||
+        typeof seconds !== "number" ||
+        !Number.isInteger(seconds) ||
+        seconds < 60 ||
+        seconds > 86400)
+        return { kind: "rejected", code: "invalid-schedule-interval" };
+    const checked = checkSubmission(contract, {
+        workflowId: "schedule",
+        source: "declared",
+        submission: fields["input"],
+    });
+    if (checked.kind === "rejected")
+        return { kind: "rejected", code: "invalid-schedule-input" };
+    return {
+        kind: "valid",
+        schedule: { everySeconds: seconds, input: checked.submission },
+    };
+}

package/dist/src/workflows.d.ts

@@ -1,6 +1,17 @@
 export { loadCycle, type CycleLoad } from "./steps/load-cycle.ts";
 export { protectedEffect } from "./steps/protected-effect.ts";
 export { decisionGate } from "./steps/decision-gate.ts";
-export type { GateRequest, GateResult, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
+export { waitForDecision } from "./steps/wait-for-decision.ts";
+export { reviewByPerson } from "./steps/review-by-person.ts";
+export { reviewByAgent } from "./steps/review-by-agent.ts";
+export { mergeByPerson } from "./steps/merge-by-person.ts";
+export { mergeWhenGreen } from "./steps/merge-when-green.ts";
+export type { ReviewSubject, CommitReviewSubject, DraftReviewSubject, ReviewResult, Reviewer, } from "./review-subject.ts";
+export type { MergeCheckName, MergeReason, MergeRequest, MergeResult, PullRequest, } from "./merge-request.ts";
+export { handoff } from "./steps/handoff.ts";
+export { waitForRun } from "./steps/wait-for-run.ts";
+export { runCommand } from "./steps/run-command.ts";
+export { sleep } from "./steps/sleep.ts";
+export type { CommandRequest, GateRequest, GateResult, DecisionResult, HandoffRequest, HandoffValue, RunWaitRequest, RunWaitOutcome, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
 export type { CycleOutcome, DevelopmentInput } from "./workflow-contracts.ts";
 export { ticketStatus, type TicketStatus } from "./ticket-status.ts";

package/dist/src/workflows.js

@@ -1,4 +1,13 @@
 export { loadCycle } from "./steps/load-cycle.js";
 export { protectedEffect } from "./steps/protected-effect.js";
 export { decisionGate } from "./steps/decision-gate.js";
+export { waitForDecision } from "./steps/wait-for-decision.js";
+export { reviewByPerson } from "./steps/review-by-person.js";
+export { reviewByAgent } from "./steps/review-by-agent.js";
+export { mergeByPerson } from "./steps/merge-by-person.js";
+export { mergeWhenGreen } from "./steps/merge-when-green.js";
+export { handoff } from "./steps/handoff.js";
+export { waitForRun } from "./steps/wait-for-run.js";
+export { runCommand } from "./steps/run-command.js";
+export { sleep } from "./steps/sleep.js";
 export { ticketStatus } from "./ticket-status.js";

package/dist/tools/admit-workflow.d.ts

@@ -0,0 +1,14 @@
+import { type WorkflowCandidateCode } from "../src/workflow-candidate.ts";
+import { type CandidatePackageOptions } from "./workflow-candidate-program.ts";
+export type WorkflowCandidateAdmission = {
+    readonly kind: "admitted";
+    readonly artifactDigest: string;
+} | {
+    readonly kind: "refused";
+    readonly codes: readonly (WorkflowCandidateCode | "compile-failed")[];
+};
+export declare function admitWorkflowCandidate(input: {
+    readonly source: string;
+    readonly declaration: unknown;
+    readonly helpers?: Readonly<Record<string, string>>;
+}, installed?: CandidatePackageOptions): Promise<WorkflowCandidateAdmission>;

package/dist/tools/admit-workflow.js

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readFile, realpath, rm, symlink, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { findPackageJSON } from "node:module";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkWorkflowCandidate, candidateDeclarationRefusals, workflowHelperPath, } from "../src/workflow-candidate.js";
+import { candidatePackageRoot, } from "./workflow-candidate-program.js";
+import { analyzeWorkflowCandidate } from "./workflow-candidate-source.js";
+import { isWorkflowManifest } from "./workflow-manifest.js";
+export async function admitWorkflowCandidate(input, installed = {}) {
+    const { source, declaration } = input;
+    const refusal = candidateDeclarationRefusals(declaration);
+    if (refusal.length > 0)
+        return { kind: "refused", codes: refusal };
+    if (Buffer.from(source, "utf8").toString("utf8") !== source)
+        return { kind: "refused", codes: ["unsupported-source"] };
+    try {
+        const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
+        const helpers = input.helpers ?? {};
+        const facts = analyzeWorkflowCandidate(source, { packageRoot, helpers });
+        const codes = checkWorkflowCandidate({ declaration, ...facts });
+        if (codes.length > 0)
+            return { kind: "refused", codes };
+        return await compiledCandidate({ source, helpers, packageRoot });
+    }
+    catch {
+        return { kind: "refused", codes: ["compile-failed"] };
+    }
+}
+async function compiledCandidate(input) {
+    const directory = await realpath(await mkdtemp(join(tmpdir(), "cloving-candidate-")));
+    try {
+        await prepareCandidateProject(directory, input);
+        if (!(await compile(directory)))
+            return { kind: "refused", codes: ["compile-failed"] };
+        const artifactDirectory = join(directory, "artifacts");
+        const manifest = JSON.parse(await readFile(join(artifactDirectory, "manifest.json"), "utf8"));
+        if (!isWorkflowManifest(manifest) ||
+            Object.values(manifest.workflows ?? {}).flatMap((entries) => Object.values(entries)).length !== 1)
+            return { kind: "refused", codes: ["compile-failed"] };
+        const digest = createHash("sha256");
+        for (const [name, content] of Object.entries(input.helpers).sort(([left], [right]) => (left < right ? -1 : Number(left > right))))
+            digest.update(JSON.stringify([name, content]));
+        for (const name of [
+            "manifest.json",
+            "flow.mjs",
+            "steps.mjs",
+            "client.mjs",
+        ]) {
+            const bytes = await readFile(join(artifactDirectory, name));
+            digest.update(JSON.stringify([name, bytes.length]));
+            digest.update(bytes);
+        }
+        return { kind: "admitted", artifactDigest: digest.digest("hex") };
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+async function prepareCandidateProject(directory, input) {
+    const { source, packageRoot } = input;
+    await mkdir(join(directory, "workflows"));
+    await mkdir(join(directory, "node_modules"));
+    await symlink(packageRoot, join(directory, "node_modules/cloving"));
+    const runtime = findPackageJSON("workflow", import.meta.url);
+    if (!runtime)
+        throw new Error("candidate-runtime-unavailable");
+    await symlink(dirname(runtime), join(directory, "node_modules/workflow"));
+    await writeFile(join(directory, "package.json"), '{"name":"candidate-project","private":true,"type":"module"}');
+    await writeFile(join(directory, "tsconfig.json"), JSON.stringify({
+        compilerOptions: {
+            target: "ES2024",
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            types: [],
+        },
+        include: ["workflows/candidate.ts"],
+    }));
+    await writeFile(join(directory, "workflows/candidate.ts"), source, "utf8");
+    for (const [name, content] of Object.entries(input.helpers)) {
+        if (workflowHelperPath("candidate.ts", `./${name}`) !== name)
+            throw new Error("invalid-workflow-helper");
+        const path = join(directory, "workflows", name);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, "utf8");
+    }
+}
+function compile(directory) {
+    const extension = extname(fileURLToPath(import.meta.url));
+    const executable = fileURLToPath(new URL(`./compile-workflows${extension}`, import.meta.url));
+    return new Promise((settle) => {
+        const child = spawn(process.execPath, [executable, "workflows", "artifacts"], {
+            cwd: directory,
+            env: { PATH: dirname(process.execPath), TMPDIR: tmpdir() },
+            stdio: "ignore",
+            timeout: 30000,
+        });
+        child.once("error", () => {
+            settle(false);
+        });
+        child.once("close", (code) => {
+            settle(code === 0);
+        });
+    });
+}

package/dist/tools/doctor-adoption.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/doctor-adoption.js

@@ -0,0 +1,11 @@
+import { selectRuntimeDirectory } from "./self-host-runtime.js";
+const [runtime, repository, legacyRuntime, adoptionRecord] = process.argv.slice(2);
+if (runtime === undefined || repository === undefined)
+    process.exitCode = 1;
+else
+    process.stdout.write(JSON.stringify(await selectRuntimeDirectory({
+        runtime,
+        repository,
+        legacyRuntime,
+        adoptionRecord,
+    })) + "\n");

package/dist/tools/project-configuration.d.ts

@@ -0,0 +1,4 @@
+import { resolveSettings } from "../src/project-settings.ts";
+export declare function topLevel(given: string): string;
+export declare function projectRoot(given: string): Promise<string>;
+export declare function projectConfiguration(repository: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<ReturnType<typeof resolveSettings>>;

package/dist/tools/project-configuration.js

@@ -0,0 +1,47 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { configurationRoot, resolveSettings } from "../src/project-settings.js";
+import { repositoryFileName } from "../src/repository-identity.js";
+async function settingsFile(file) {
+    try {
+        return await readFile(file.path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw new Error(`unreadable-config-file: ${file.scope}`, { cause: error });
+    }
+}
+export function topLevel(given) {
+    try {
+        return execFileSync("git", ["-C", given, "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return given;
+    }
+}
+export function projectRoot(given) {
+    return realpath(topLevel(resolve(given)));
+}
+export async function projectConfiguration(repository, environment) {
+    const projectName = repositoryFileName({
+        name: basename(repository),
+        sha256: createHash("sha256").update(repository).digest("hex"),
+    });
+    return resolveSettings(environment, {
+        project: await settingsFile({
+            path: join(repository, ".cloving/config.json"),
+            scope: "project",
+        }),
+        private: await settingsFile({
+            path: join(configurationRoot(environment, homedir()), "cloving/projects", `${projectName}.json`),
+            scope: "private",
+        }),
+    });
+}

package/dist/tools/self-host-processes.d.ts

@@ -5,6 +5,7 @@ export interface HostProcesses {
     readonly directory: string;
     readonly repository: string;
     readonly watchPort: string;
+    readonly phoneRelay: string;
     readonly updateMilliseconds: number | undefined;
 }
 export declare function hostedPrograms(settings: HostProcesses): Promise<number>;

package/dist/tools/self-host-processes.js

@@ -1,5 +1,6 @@
 import { execFile, spawn } from "node:child_process";
 import { addAbortListener } from "node:events";
+import { rm } from "node:fs/promises";
 import { extname, join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
@@ -21,7 +22,8 @@ function launched(argumentsList, settings) {
 }
 async function stopped(programs) {
     for (const program of programs)
-        program.child.kill("SIGTERM");
+        if (!program.child.killed)
+            program.child.kill("SIGTERM");
     await Promise.all(programs.map((program) => program.ended));
 }
 function updatingGit(settings, stopping) {
@@ -51,8 +53,10 @@ function updatingGit(settings, stopping) {
     };
 }
 async function polled(settings, lifecycle) {
-    if (settings.updateMilliseconds === undefined)
+    if (settings.updateMilliseconds === undefined) {
+        await rm(join(settings.directory, "pending-self-update"), { force: true });
         return;
+    }
     const cancelled = () => lifecycle.stopping.aborted;
     const updater = selfUpdater({
         directory: settings.directory,
@@ -87,33 +91,40 @@ async function polled(settings, lifecycle) {
     }
     return undefined;
 }
+function productChild(settings, argumentsList) {
+    const [program, ...rest] = argumentsList;
+    return launched([
+        join(settings.product, `src/${program}${extname(import.meta.filename)}`),
+        ...rest,
+    ], {
+        directory: settings.product,
+        environment: {
+            ...process.env,
+            CLOVING_RUNTIME_DIR: settings.runtime,
+            CLOVING_WATCH_REPOSITORY: settings.repository,
+        },
+    });
+}
 function hostedChildren(settings) {
     const daemon = launched([join(settings.project, "start.mjs")], {
         directory: settings.project,
         environment: process.env,
     });
-    if (settings.watchPort === "off")
-        return [daemon];
-    return [
-        daemon,
-        launched([
-            join(settings.product, `src/cli${extname(import.meta.filename)}`),
-            "watch",
-            "--port",
-            settings.watchPort,
-        ], {
-            directory: settings.product,
-            environment: {
-                ...process.env,
-                CLOVING_RUNTIME_DIR: settings.runtime,
-                CLOVING_WATCH_REPOSITORY: settings.repository,
-            },
-        }),
-    ];
+    const watch = settings.watchPort === "off"
+        ? []
+        : [
+            productChild(settings, [
+                "cli",
+                "watch",
+                "--port",
+                settings.watchPort,
+            ]),
+        ];
+    const relay = settings.phoneRelay === "off" ? [] : [productChild(settings, ["relay"])];
+    return { daemon, programs: [daemon, ...watch, ...relay] };
 }
 export async function hostedPrograms(settings) {
-    const programs = hostedChildren(settings);
-    const daemon = programs[0];
+    const { daemon, programs } = hostedChildren(settings);
     const stopping = new AbortController();
     let updating = false;
     const interrupt = () => {

package/dist/tools/self-host-project.d.ts

@@ -0,0 +1,21 @@
+import { type DeclaredWorkflow } from "../src/workflow-declaration.ts";
+import type { WorkflowRefusal } from "../src/workflow-refusals.ts";
+import { type WorkflowListing } from "./workflow-folders.ts";
+interface ProjectSettings {
+    readonly product: string;
+    readonly project: string;
+    readonly repository: string;
+    readonly home: string;
+    readonly xdgConfigHome?: string | undefined;
+    readonly userFolder?: string | undefined;
+}
+export interface RegisteredWorkflows {
+    readonly workflows: readonly WorkflowListing[];
+    readonly repository: string;
+    readonly bundleDigest: string;
+    readonly manifests: Readonly<Record<string, string>>;
+    readonly declarations: readonly DeclaredWorkflow[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+}
+export declare function preparedProject(settings: ProjectSettings): Promise<RegisteredWorkflows>;
+export {};

package/dist/tools/self-host-project.js

@@ -0,0 +1,224 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readFile, rm, symlink, writeFile, } from "node:fs/promises";
+import { findPackageJSON } from "node:module";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import packageMetadata from "#package" with { type: "json" };
+import { record } from "../src/protocol.js";
+import { isWorkflowDeclaration, } from "../src/workflow-declaration.js";
+import { bundledWorkflowIds, } from "../src/workflow-discovery.js";
+import { workflowDeclarations, workflowFiles, workflowManifests, } from "./self-host-workflows.js";
+import { loadWorkflowFolders, } from "./workflow-folders.js";
+import { isWorkflowManifest } from "./workflow-manifest.js";
+import { retainWorkflowBundle } from "./workflow-bundles.js";
+import { workflowBundleDependencies, workflowPackageRoot, } from "./workflow-bundle-dependencies.js";
+async function initializeProject(settings) {
+    const { project, product } = settings;
+    await rm(project, { recursive: true, force: true });
+    await mkdir(join(project, "workflows"), { recursive: true, mode: 0o700 });
+    await writeFile(join(project, "package.json"), '{"name":"cloving-self-host","private":true,"type":"module"}');
+    const files = await workflowFiles(join(product, "workflows"));
+    for (const file of files)
+        await copyWorkflow(settings, file);
+    const modules = join(project, "node_modules");
+    await mkdir(join(modules, "cloving"), { recursive: true });
+    const dependencies = new Map(Object.keys(packageMetadata.dependencies).map((name) => [name, join(product, "package.json")]));
+    const sdk = findPackageJSON("workflow", join(product, "package.json"));
+    if (sdk === undefined)
+        throw new Error("missing-runtime-dependency: workflow");
+    dependencies.set("@workflow/core", sdk);
+    for (const [name, from] of dependencies) {
+        const location = findPackageJSON(name, from);
+        if (location === undefined)
+            throw new Error(`missing-runtime-dependency: ${name}`);
+        await mkdir(dirname(join(modules, name)), { recursive: true });
+        await symlink(dirname(location), join(modules, name));
+    }
+    await symlink(join(product, "src"), join(modules, "cloving", "src"));
+    await writeFile(join(modules, "cloving", "package.json"), JSON.stringify({
+        name: packageMetadata.name,
+        version: packageMetadata.version,
+        type: "module",
+        exports: Object.fromEntries(Object.keys(packageMetadata.exports)
+            .filter((subpath) => subpath.startsWith("./workflows"))
+            .map((subpath) => [
+            subpath,
+            `./src/${subpath.slice("./workflows/".length) || "workflows"}${extname(import.meta.filename)}`,
+        ])),
+    }));
+    return files;
+}
+async function compile(settings) {
+    const { product, project } = settings;
+    await rm(join(project, "artifacts"), { recursive: true, force: true });
+    await new Promise((settle, reject) => {
+        const child = spawn(process.execPath, [
+            join(product, `tools/compile-workflows${extname(import.meta.filename)}`),
+            "workflows",
+            "artifacts",
+        ], { cwd: project, env: process.env, stdio: "ignore", timeout: 30000 });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code === 0)
+                settle();
+            else
+                reject(new Error("The workflows did not compile."));
+        });
+    });
+    const compiled = JSON.parse(await readFile(join(project, "artifacts/manifest.json"), "utf8"));
+    if (!isWorkflowManifest(compiled))
+        throw new Error("The compiled workflow manifest is invalid.");
+    return compiled;
+}
+function reservations(input) {
+    const { files, manifests, declarations } = input;
+    return [
+        ...files.map((file) => ({
+            baseName: basename(file, extname(file)),
+        })),
+        ...Object.entries(manifests).map(([functionName, manifest]) => ({
+            baseName: manifest.name,
+            workflowId: manifest.workflowId,
+            functionName,
+        })),
+        ...[
+            ...Object.values(bundledWorkflowIds),
+            ...declarations.map((item) => item.workflowId),
+        ].map((workflowId) => ({ workflowId })),
+    ];
+}
+async function stageCandidates(project, candidates) {
+    if (candidates.length === 0)
+        return [];
+    const directory = join(project, "workflows", "operators");
+    await mkdir(directory, { mode: 0o700 });
+    const staged = [];
+    for (const candidate of candidates) {
+        const name = createHash("sha256")
+            .update(JSON.stringify([
+            candidate.scope,
+            candidate.baseName,
+            candidate.source,
+            candidate.declaration,
+            Object.entries(candidate.helpers).sort(([left], [right]) => left < right ? -1 : Number(left > right)),
+        ]))
+            .digest("hex");
+        const root = Object.keys(candidate.helpers).length > 0
+            ? join(directory, name)
+            : directory;
+        await mkdir(root, { recursive: true, mode: 0o700 });
+        const file = join(root, `${name}.ts`);
+        await writeFile(file, candidate.source);
+        await writeFile(join(root, `${name}.declaration.json`), candidate.declaration);
+        for (const [path, source] of Object.entries(candidate.helpers)) {
+            const destination = join(root, path);
+            await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
+            await writeFile(destination, source);
+        }
+        staged.push({ candidate, file });
+    }
+    return staged;
+}
+function operatorDeclaration(staged, compiled) {
+    const { candidate, project } = staged;
+    const declaration = record(JSON.parse(candidate.declaration))?.["workflow"];
+    const entries = Object.entries(compiled.workflows ?? {}).filter(([file]) => resolve(project, file) === staged.file);
+    const functions = entries.flatMap(([, functions]) => Object.values(functions));
+    const [workflow] = functions;
+    if (!isWorkflowDeclaration(declaration) ||
+        functions.length !== 1 ||
+        workflow === undefined)
+        throw new Error("The admitted workflow is missing from the compiled bundle.");
+    return {
+        ...declaration,
+        capabilities: [...new Set(declaration.capabilities)],
+        functionName: workflow.workflowId.slice(workflow.workflowId.lastIndexOf("//") + 2),
+    };
+}
+async function copyWorkflow(settings, file) {
+    const { product, project } = settings;
+    await copyFile(join(product, "workflows", file), join(project, "workflows", file));
+    const sidecar = `${basename(file, extname(file))}.declaration.json`;
+    const declaration = await readFile(join(product, "workflows", sidecar)).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (declaration !== undefined)
+        await writeFile(join(project, "workflows", sidecar), declaration);
+}
+function bundledListings(input) {
+    const { product, files, manifests, declarations } = input;
+    const byFunction = new Map(declarations.map(({ functionName, ...declaration }) => [
+        functionName,
+        declaration,
+    ]));
+    return Object.entries(manifests).map(([functionName, manifest]) => {
+        const declaration = byFunction.get(functionName);
+        const file = files.find((file) => basename(file, extname(file)) === manifest.name);
+        return {
+            scope: "bundled",
+            workflowId: declaration?.workflowId ?? manifest.name,
+            file: join(product, "workflows", file ?? manifest.name),
+            admitted: true,
+            codes: [],
+            ...(declaration === undefined ? {} : { declaration }),
+        };
+    });
+}
+async function writeManifests(project, compiled) {
+    const manifests = {};
+    for (const [functionName, manifest] of Object.entries(compiled)) {
+        const path = join(project, `${manifest.name}.workflow.json`);
+        await writeFile(path, JSON.stringify(manifest));
+        Object.defineProperty(manifests, functionName, {
+            value: path,
+            enumerable: true,
+        });
+    }
+    return manifests;
+}
+export async function preparedProject(settings) {
+    const { product, project } = settings;
+    const files = await initializeProject(settings);
+    let compiled = await compile(settings);
+    const bundled = workflowManifests(compiled);
+    const declarations = await workflowDeclarations(join(project, "workflows"), bundled);
+    const folders = await loadWorkflowFolders({
+        ...settings,
+        bundled: reservations({ files, manifests: bundled, declarations }),
+    }, { packageRoot: await workflowPackageRoot(product) });
+    const staged = await stageCandidates(project, folders.candidates);
+    if (staged.length > 0)
+        compiled = await compile(settings);
+    const combined = [
+        ...declarations,
+        ...staged.map((candidate) => operatorDeclaration({ ...candidate, project }, compiled)),
+    ];
+    const manifests = await writeManifests(project, workflowManifests(compiled, combined));
+    await writeFile(join(project, "declarations.json"), JSON.stringify(combined));
+    await writeFile(join(project, "dependencies.json"), await workflowBundleDependencies({
+        product,
+        packages: Object.keys(packageMetadata.dependencies),
+    }));
+    const bundleDigest = await retainWorkflowBundle({
+        project,
+        repository: folders.repository,
+        directory: join(dirname(project), "workflow-bundles"),
+    });
+    const workflows = bundledListings({
+        product,
+        files,
+        manifests: bundled,
+        declarations,
+    });
+    workflows.push(...folders.workflows);
+    return {
+        workflows,
+        repository: folders.repository,
+        bundleDigest,
+        manifests,
+        declarations: combined,
+        workflowRefusals: folders.refusals,
+    };
+}

package/dist/tools/self-host-runtime.d.ts

@@ -0,0 +1,16 @@
+interface RuntimeSelection {
+    readonly runtime: string;
+    readonly repository: string;
+    readonly legacyRuntime: string | undefined;
+    readonly adoptionRecord: string | undefined;
+}
+export declare function selectRuntimeDirectory(input: RuntimeSelection): Promise<{
+    readonly runtime: string;
+    readonly note: string;
+    readonly adoptionRecord?: string;
+}>;
+export declare function adoptRuntimeDirectory(input: RuntimeSelection): Promise<{
+    readonly runtime: string;
+    readonly note: string;
+}>;
+export {};