cloving 1.1.0 → 1.2.0

package/dist/src/workflow-contracts.js

@@ -1,6 +1,9 @@
 import { isTicketStatus } from "./ticket-status.js";
 const identifier = /^[A-Za-z0-9._:-]{1,128}$/;
 const reason = /^\S[\s\S]{0,255}$/;
+export function isPromotionId(value) {
+    return typeof value === "string" && identifier.test(value);
+}
 export function isBlockedReason(value) {
     return typeof value === "string" && reason.test(value);
 }
@@ -40,7 +43,7 @@ const outcomes = {
     },
     handoff_requested: {
         keys: ["cycleId", "kind", "promotionId"],
-        optional: ["ticketStatus", "issueUpdate"],
+        optional: ["ticketStatus", "issueUpdate", "reason"],
         parse: (fields) => {
             const cycleId = textField(fields, {
                 key: "cycleId",
@@ -54,16 +57,18 @@ const outcomes = {
                 return null;
             const ticketStatus = fields["ticketStatus"];
             const issueUpdate = fields["issueUpdate"];
+            const reason = fields["reason"];
             if (issueUpdate !== undefined && issueUpdate !== "failed")
                 return null;
             if (ticketStatus !== undefined && !isTicketStatus(ticketStatus))
                 return null;
+            if (reason !== undefined && !isBlockedReason(reason))
+                return null;
             return {
                 kind: "handoff_requested",
                 cycleId,
                 promotionId,
-                ...(issueUpdate === "failed" ? { issueUpdate } : {}),
-                ...(ticketStatus === undefined ? {} : { ticketStatus }),
+                ...Object.fromEntries(Object.entries({ issueUpdate, ticketStatus, reason }).filter(([, value]) => value !== undefined)),
             };
         },
     },

package/dist/src/workflow-declaration.d.ts

@@ -1,11 +1,22 @@
 import type { SubmissionContract } from "./submission.ts";
+export interface WorkflowStage {
+    readonly name: string;
+    readonly label: string;
+    readonly operations?: readonly string[];
+    readonly gateKinds?: readonly ("approval" | "question")[];
+}
+export type WorkflowStages = Readonly<Record<string, readonly WorkflowStage[]>>;
 export interface WorkflowDeclaration {
     readonly workflowId: string;
     readonly effectLimit: number;
     readonly capabilities: readonly ("claude" | "github" | "chats")[];
     readonly input: SubmissionContract;
+    readonly stages?: readonly WorkflowStage[];
+    readonly handoffs?: readonly string[];
 }
 export interface DeclaredWorkflow extends WorkflowDeclaration {
     readonly functionName: string;
 }
+export declare function isWorkflowStages(value: unknown): value is readonly WorkflowStage[];
+export declare function isWorkflowHandoffs(value: unknown): value is readonly string[];
 export declare function isWorkflowDeclaration(value: unknown): value is WorkflowDeclaration;

package/dist/src/workflow-declaration.js

@@ -1,6 +1,7 @@
 import { record } from "./protocol.js";
 function keys(fields, allowed) {
-    return Object.keys(fields).every((key) => allowed.includes(key));
+    return (fields !== undefined &&
+        Object.keys(fields).every((key) => allowed.includes(key)));
 }
 function integer(value, bounds) {
     return (typeof value === "number" &&
@@ -20,8 +21,7 @@ function integerBounds(fields) {
 }
 function isField(value) {
     const fields = record(value);
-    if (fields === undefined ||
-        !keys(fields, ["type", "optional", "minimum", "maximum"]))
+    if (!keys(fields, ["type", "optional", "minimum", "maximum"]))
         return false;
     if (fields["optional"] !== undefined &&
         typeof fields["optional"] !== "boolean")
@@ -34,26 +34,82 @@ function isField(value) {
 }
 function isInput(value) {
     const input = record(value);
-    if (input === undefined || !keys(input, ["maximumBytes", "fields"]))
+    if (!keys(input, ["maximumBytes", "fields"]))
         return false;
     const fields = record(input["fields"]);
     return (integer(input["maximumBytes"], { minimum: 1, maximum: 1_048_576 }) &&
         fields !== undefined &&
         Object.values(fields).every(isField));
 }
+function matches(value, pattern) {
+    return typeof value === "string" && pattern.test(value);
+}
+function selectors(value, pattern) {
+    return (Array.isArray(value) &&
+        Array.from(value).every((item) => matches(item, pattern)));
+}
+function isStageLabel(label) {
+    return (typeof label === "string" &&
+        /^[^\p{C}\p{Zl}\p{Zp}]{1,40}$/u.test(label) &&
+        label.trim() === label &&
+        !["Other", "Done", "Stopped"].includes(label));
+}
+function isStage(value) {
+    const stage = record(value);
+    if (!keys(stage, ["name", "label", "operations", "gateKinds"]))
+        return false;
+    const { name, label } = stage;
+    const operations = Object.hasOwn(stage, "operations")
+        ? stage["operations"]
+        : [];
+    const gateKinds = Object.hasOwn(stage, "gateKinds") ? stage["gateKinds"] : [];
+    return (matches(name, /^[A-Za-z0-9-]{1,64}$/) &&
+        isStageLabel(label) &&
+        selectors(operations, /^[A-Za-z0-9._:/-]{1,128}$/) &&
+        selectors(gateKinds, /^(approval|question)$/) &&
+        operations.length + gateKinds.length > 0);
+}
+function unique(values) {
+    return new Set(values).size === values.length;
+}
+export function isWorkflowStages(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 12)
+        return false;
+    const stages = Array.from(value);
+    if (!stages.every(isStage))
+        return false;
+    return (unique(stages.map((stage) => stage.name)) &&
+        unique(stages.map((stage) => stage.label)) &&
+        unique(stages.flatMap((stage) => stage.operations ?? [])) &&
+        unique(stages.flatMap((stage) => stage.gateKinds ?? [])));
+}
+function isCapabilities(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((capability) => capability === "claude" ||
+            capability === "github" ||
+            capability === "chats"));
+}
+export function isWorkflowHandoffs(value) {
+    return selectors(value, /^[A-Za-z0-9-]{1,64}$/) && unique(value);
+}
 export function isWorkflowDeclaration(value) {
     const declaration = record(value);
-    if (declaration === undefined ||
-        !keys(declaration, ["workflowId", "effectLimit", "capabilities", "input"]))
+    if (!keys(declaration, [
+        "workflowId",
+        "effectLimit",
+        "capabilities",
+        "input",
+        "stages",
+        "handoffs",
+    ]))
         return false;
-    const { workflowId, effectLimit, capabilities, input } = declaration;
-    return (typeof workflowId === "string" &&
-        /^[A-Za-z0-9-]{1,64}$/.test(workflowId) &&
+    const { workflowId, effectLimit, capabilities, input, handoffs } = declaration;
+    return (matches(workflowId, /^[A-Za-z0-9-]{1,64}$/) &&
         integer(effectLimit, { minimum: 1, maximum: 100 }) &&
-        Array.isArray(capabilities) &&
-        capabilities.length > 0 &&
-        capabilities.every((capability) => capability === "claude" ||
-            capability === "github" ||
-            capability === "chats") &&
-        isInput(input));
+        isCapabilities(capabilities) &&
+        isInput(input) &&
+        (!Object.hasOwn(declaration, "stages") ||
+            isWorkflowStages(declaration["stages"])) &&
+        (!Object.hasOwn(declaration, "handoffs") || isWorkflowHandoffs(handoffs)));
 }

package/dist/src/workflow-discovery.d.ts

@@ -0,0 +1,18 @@
+export interface WorkflowReservation {
+    readonly baseName?: string;
+    readonly workflowId?: string;
+    readonly functionName?: string;
+}
+export interface WorkflowDiscoveryIdentity {
+    readonly baseName: string;
+    readonly workflowId: string | undefined;
+    readonly functionNames: readonly string[];
+}
+export type WorkflowConflictCode = "workflow-conflict" | "bundled-name-reserved";
+export declare function workflowConflicts(candidates: readonly WorkflowDiscoveryIdentity[], bundled: readonly WorkflowReservation[]): readonly (readonly WorkflowConflictCode[])[];
+export declare const bundledWorkflowIds: {
+    readonly ticket: "develop-ticket";
+    readonly issue: "develop-issue";
+    readonly prompt: "develop-prompt";
+    readonly prd: "develop-prd";
+};

package/dist/src/workflow-discovery.js

@@ -0,0 +1,33 @@
+function identityKeys(identity) {
+    return [
+        ...(identity.baseName === undefined ? [] : [`base:${identity.baseName}`]),
+        ...(identity.workflowId === undefined ? [] : [`id:${identity.workflowId}`]),
+        ...identity.functionNames.map((name) => `function:${name}`),
+    ];
+}
+export function workflowConflicts(candidates, bundled) {
+    const keys = candidates.map(identityKeys);
+    const counts = new Map();
+    for (const names of keys) {
+        for (const name of new Set(names))
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const reserved = new Set(bundled.flatMap((entry) => identityKeys({
+        ...entry,
+        functionNames: entry.functionName === undefined ? [] : [entry.functionName],
+    })));
+    return keys.map((names) => {
+        const codes = [];
+        if (names.some((name) => reserved.has(name)))
+            codes.push("bundled-name-reserved");
+        if (names.some((name) => (counts.get(name) ?? 0) > 1))
+            codes.push("workflow-conflict");
+        return codes;
+    });
+}
+export const bundledWorkflowIds = {
+    ticket: "develop-ticket",
+    issue: "develop-issue",
+    prompt: "develop-prompt",
+    prd: "develop-prd",
+};

package/dist/src/workflow-refusals.d.ts

@@ -0,0 +1,6 @@
+export interface WorkflowRefusal {
+    readonly scope: "project" | "user";
+    readonly label: string;
+    readonly codes: readonly string[];
+}
+export declare function workflowRefusals(value: unknown): readonly WorkflowRefusal[];

package/dist/src/workflow-refusals.js

@@ -0,0 +1,39 @@
+import { record } from "./protocol.js";
+const refusalCodes = new Set([
+    "invalid-declaration",
+    "forbidden-import",
+    "missing-export",
+    "unsupported-source",
+    "dynamic-effect",
+    "undeclared-effect",
+    "effect-limit",
+    "direct-effect",
+    "workflow-conflict",
+    "bundled-name-reserved",
+    "unsafe-workflow-path",
+    "workflow-read-failed",
+    "workflow-source-changed",
+    "compile-failed",
+]);
+function refusal(value) {
+    const { scope, label, codes } = record(value) ?? {};
+    if ((scope !== "project" && scope !== "user") ||
+        typeof label !== "string" ||
+        /^(?:[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.ts|file-[a-f0-9]{16}|workflows\/)$/u.exec(label)?.[0] !== label ||
+        !Array.isArray(codes) ||
+        codes.length === 0)
+        return [];
+    const known = codes.filter((code) => typeof code === "string" && refusalCodes.has(code));
+    if (known.length !== codes.length)
+        return [];
+    return [{ scope, label, codes: [...new Set(known)].sort() }];
+}
+export function workflowRefusals(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap(refusal).sort((left, right) => {
+        const a = `${left.scope}\0${left.label}`;
+        const b = `${right.scope}\0${right.label}`;
+        return a < b ? -1 : Number(a > b);
+    });
+}

package/dist/src/workflows.d.ts

@@ -1,6 +1,7 @@
 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 { handoff } from "./steps/handoff.ts";
+export type { GateRequest, GateResult, HandoffRequest, HandoffValue, 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,5 @@
 export { loadCycle } from "./steps/load-cycle.js";
 export { protectedEffect } from "./steps/protected-effect.js";
 export { decisionGate } from "./steps/decision-gate.js";
+export { handoff } from "./steps/handoff.js";
 export { ticketStatus } from "./ticket-status.js";

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

@@ -0,0 +1,13 @@
+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;
+}, installed?: CandidatePackageOptions): Promise<WorkflowCandidateAdmission>;

package/dist/tools/admit-workflow.js

@@ -0,0 +1,94 @@
+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, } 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;
+    if (Buffer.from(source, "utf8").toString("utf8") !== source)
+        return { kind: "refused", codes: ["unsupported-source"] };
+    try {
+        const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
+        const facts = analyzeWorkflowCandidate(source, { packageRoot });
+        const codes = checkWorkflowCandidate({ declaration, ...facts });
+        if (codes.length > 0)
+            return { kind: "refused", codes };
+        return await compiledCandidate(source, packageRoot);
+    }
+    catch {
+        return { kind: "refused", codes: ["compile-failed"] };
+    }
+}
+async function compiledCandidate(source, packageRoot) {
+    const directory = await realpath(await mkdtemp(join(tmpdir(), "cloving-candidate-")));
+    try {
+        await prepareCandidateProject(directory, { source, packageRoot });
+        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 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");
+}
+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/self-host-project.d.ts

@@ -0,0 +1,17 @@
+import { type DeclaredWorkflow } from "../src/workflow-declaration.ts";
+import type { WorkflowRefusal } from "../src/workflow-refusals.ts";
+interface ProjectSettings {
+    readonly product: string;
+    readonly project: string;
+    readonly repository: string;
+    readonly home: string;
+    readonly xdgConfigHome?: string | undefined;
+}
+export interface RegisteredWorkflows {
+    readonly repository: 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,177 @@
+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 });
+    for (const name of Object.keys(packageMetadata.dependencies)) {
+        const location = findPackageJSON(name, join(product, "package.json"));
+        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,
+        ]))
+            .digest("hex");
+        const file = join(directory, `${name}.ts`);
+        await writeFile(file, candidate.source);
+        await writeFile(join(directory, `${name}.declaration.json`), candidate.declaration);
+        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);
+}
+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 = {};
+    for (const [functionName, manifest] of Object.entries(workflowManifests(compiled, combined))) {
+        const path = join(project, `${manifest.name}.workflow.json`);
+        await writeFile(path, JSON.stringify(manifest));
+        Object.defineProperty(manifests, functionName, {
+            value: path,
+            enumerable: true,
+        });
+    }
+    await writeFile(join(project, "declarations.json"), JSON.stringify(combined));
+    await writeFile(join(project, "dependencies.json"), await workflowBundleDependencies({
+        product,
+        packages: Object.keys(packageMetadata.dependencies),
+    }));
+    await retainWorkflowBundle({
+        project,
+        repository: folders.repository,
+        directory: join(dirname(project), "workflow-bundles"),
+    });
+    return {
+        repository: folders.repository,
+        manifests,
+        declarations: combined,
+        workflowRefusals: folders.refusals,
+    };
+}