cloving 1.4.0 → 1.5.0

package/dist/src/daemon/workflow-generations.d.ts

@@ -8,16 +8,18 @@ export interface WorkflowGeneration {
     readonly handler: WorkflowHandler;
 }
 export type WorkflowBundleLoader = (directory: string) => Promise<WorkflowGeneration>;
-export declare function workflowGenerations(settings: {
-    readonly directory: string;
-    readonly repository: string;
+export interface CurrentGeneration {
     readonly registrations: readonly WorkflowRegistration[];
     readonly table: readonly {
         readonly workflowId: string;
         readonly functionName: string;
     }[];
-    readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
+    readonly workflows: Readonly<Record<string, unknown>>;
     readonly handler: WorkflowHandler;
+}
+export declare function workflowGenerations(settings: CurrentGeneration & {
+    readonly directory: string;
+    readonly repository: string;
     readonly loadBundle?: WorkflowBundleLoader;
 }): {
     resolve: (manifest: ExecutionManifest | undefined) => Promise<{
@@ -25,6 +27,7 @@ export declare function workflowGenerations(settings: {
         handler: WorkflowHandler;
     } | undefined>;
     available: (manifest: ExecutionManifest) => Promise<ExecutionManifest | undefined>;
+    replace: (source: CurrentGeneration) => void;
 };
 export declare function prepareWorkflowGenerations(ports: {
     readonly state: HostPorts["state"];

package/dist/src/daemon/workflow-generations.js

@@ -1,26 +1,31 @@
 import { join } from "node:path";
 import { workflowRegistry, } from "../service/registry.js";
 import { workflowPin } from "../broker/workflow-pin.js";
+function isWorkflowFunction(value) {
+    return typeof value === "function";
+}
 export function workflowGenerations(settings) {
-    const functions = Object.fromEntries(settings.table.map((row) => [
-        row.workflowId,
-        settings.workflows[row.functionName],
-    ]));
-    const registry = workflowRegistry(settings.registrations, {
-        workflowBundles: {
-            directory: join(settings.directory, "workflow-bundles"),
-            repository: settings.repository,
-        },
+    const workflowBundles = {
+        directory: join(settings.directory, "workflow-bundles"),
+        repository: settings.repository,
+    };
+    const generation = (source) => ({
+        functions: new Map(source.table.map((row) => [
+            row.workflowId,
+            source.workflows[row.functionName],
+        ])),
+        registry: workflowRegistry(source.registrations, { workflowBundles }),
+        handler: source.handler,
     });
+    let current = generation(settings);
     const resolve = async (manifest) => {
         if (manifest === undefined)
             return undefined;
+        const { functions, registry, handler } = current;
         const registered = registry.byPin(workflowPin(manifest));
         if (registered !== undefined) {
-            const workflow = functions[registered.workflowId];
-            return workflow === undefined
-                ? undefined
-                : { workflow, handler: settings.handler };
+            const workflow = functions.get(registered.workflowId);
+            return isWorkflowFunction(workflow) ? { workflow, handler } : undefined;
         }
         if (manifest.bundleDigest === undefined ||
             settings.loadBundle === undefined)
@@ -30,7 +35,7 @@ export function workflowGenerations(settings) {
             return undefined;
         try {
             const generation = await settings.loadBundle(directory);
-            const workflow = Object.values(generation.workflows).find((candidate) => typeof candidate === "function" &&
+            const workflow = Object.values(generation.workflows).find((candidate) => isWorkflowFunction(candidate) &&
                 Reflect.get(candidate, "workflowId") === manifest.workflowId);
             return workflow === undefined
                 ? undefined
@@ -43,6 +48,9 @@ export function workflowGenerations(settings) {
     return {
         resolve,
         available: async (manifest) => (await resolve(manifest)) === undefined ? undefined : manifest,
+        replace: (source) => {
+            current = generation(source);
+        },
     };
 }
 export async function prepareWorkflowGenerations(ports, generations) {

package/dist/src/daemon/workflow-reload.d.ts

@@ -0,0 +1,41 @@
+import type { WorkflowReloadPort } from "../service/workflow-reload.ts";
+import { type DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { DaemonSettings } from "./daemon-adapters.ts";
+import type { WorkflowBundleLoader, workflowGenerations } from "./workflow-generations.ts";
+import { type TurnSettingsSource } from "./settings-reload.ts";
+export declare function queueWorkflowId(settings: {
+    readonly declarations?: readonly DeclaredWorkflow[];
+}): string | undefined;
+export declare function daemonRegistrations(settings: DaemonSettings): Promise<{
+    table: readonly import("./ticket-registration.ts").TicketRegistration[];
+    admitted: {
+        readonly kind: "rejected";
+        readonly detail: string;
+    } | {
+        registrations: {
+            admission?: "when-idle" | number;
+            queue?: boolean;
+            workflowId: string;
+            manifest: import("../workflow-admission.ts").ExecutionManifest;
+            availability: "available" | "unavailable";
+            submission: import("../submission.ts").SubmissionContract;
+            resolver: import("../service/registry.ts").Resolver;
+            effectLimit?: number;
+            stages?: readonly import("../workflow-declaration.ts").WorkflowStage[];
+            handoffs?: readonly string[];
+            commands?: readonly string[];
+            commandWaits?: import("../workflow-declaration.ts").CommandWaits;
+        }[];
+        kind: "admitted";
+    };
+}>;
+type ReloadSettings = DaemonSettings & {
+    readonly reloadCommand: readonly string[];
+    readonly loadBundle: WorkflowBundleLoader;
+    readonly turnSettings: TurnSettingsSource;
+};
+type Generations = Pick<ReturnType<typeof workflowGenerations>, "replace">;
+export declare function workflowReload(settings: ReloadSettings & {
+    readonly generations: Generations;
+}): WorkflowReloadPort;
+export {};

package/dist/src/daemon/workflow-reload.js

@@ -0,0 +1,244 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { record } from "../protocol.js";
+import { serviceLimits } from "../service/service.js";
+import { isWorkflowDeclaration, } from "../workflow-declaration.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
+import { ticketRegistrations, ticketRegistrationTable, } from "./ticket-registration.js";
+import { scheduledDeclarations } from "./workflow-schedules.js";
+import { keptDigests, profileRefusal, reloadedSettings, settingChanges, } from "./settings-reload.js";
+const executed = promisify(execFile);
+function refused(code, detail) {
+    return { kind: "refused", code, detail };
+}
+export function queueWorkflowId(settings) {
+    return settings.declarations?.find((declaration) => declaration.queue === true)?.workflowId;
+}
+export async function daemonRegistrations(settings) {
+    const conflict = settings.workflowRefusals?.find((refusal) => refusal.codes.includes("queue-workflow-conflict"));
+    if (conflict !== undefined)
+        return {
+            table: [],
+            admitted: {
+                kind: "rejected",
+                detail: `queue-workflow-conflict: ${conflict.scope} ${conflict.label}`,
+            },
+        };
+    const table = ticketRegistrationTable({
+        repository: settings.repository,
+        command: settings.ticketCommand,
+        nextCommand: settings.nextCommand,
+        githubCommand: settings.githubCommand,
+    }, settings.declarations);
+    const admitted = await ticketRegistrations(settings.manifests, {
+        table,
+        commands: settings.commands ?? {},
+        ...(settings.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: settings.bundleDigest }),
+    });
+    return {
+        table,
+        admitted: admitted.kind === "rejected"
+            ? admitted
+            : {
+                ...admitted,
+                registrations: admitted.registrations.map((registration) => ({
+                    ...registration,
+                    ...(settings.queueMilliseconds !== undefined &&
+                        registration.workflowId === queueWorkflowId(settings)
+                        ? { admission: settings.queueLanes ?? 1, queue: true }
+                        : {}),
+                })),
+            },
+    };
+}
+function declaredWorkflows(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const declarations = [];
+    for (const entry of value) {
+        const { functionName, ...declaration } = record(entry) ?? {};
+        if (typeof functionName !== "string" || !isWorkflowDeclaration(declaration))
+            return undefined;
+        declarations.push({ ...declaration, functionName });
+    }
+    return declarations;
+}
+function manifestPaths(value) {
+    const fields = record(value);
+    if (fields === undefined)
+        return undefined;
+    const entries = Object.entries(fields);
+    const paths = entries.filter((entry) => typeof entry[1] === "string");
+    return paths.length === entries.length
+        ? Object.fromEntries(paths)
+        : undefined;
+}
+function parsedOutput(output) {
+    try {
+        return record(JSON.parse(output));
+    }
+    catch {
+        return undefined;
+    }
+}
+function outputRefusal(value) {
+    const error = value?.["error"];
+    if (typeof error === "string")
+        return refused("reload-failed", error);
+    const refusal = record(value?.["refusal"]);
+    const code = refusal?.["code"];
+    const detail = refusal?.["detail"];
+    return typeof code === "string" && typeof detail === "string"
+        ? refused(code, detail)
+        : undefined;
+}
+function preparedBundle(output) {
+    const value = parsedOutput(output);
+    const refusal = outputRefusal(value);
+    if (refusal !== undefined)
+        return refusal;
+    const bundleDigest = value?.["bundleDigest"];
+    const manifests = manifestPaths(value?.["manifests"]);
+    const declarations = declaredWorkflows(value?.["declarations"]);
+    const settings = reloadedSettings(value);
+    if (typeof bundleDigest !== "string" ||
+        manifests === undefined ||
+        declarations === undefined ||
+        settings === undefined)
+        return refused("reload-failed", "The reload command printed no workflow bundle.");
+    return {
+        kind: "prepared",
+        bundleDigest,
+        manifests,
+        declarations,
+        workflowRefusals: workflowRefusals(value?.["workflowRefusals"]),
+        ...settings,
+    };
+}
+async function prepared(command) {
+    const [executable = "", ...fixed] = command;
+    const output = await executed(executable, fixed, {
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+    }).then((result) => result.stdout, (error) => String(Reflect.get(Object(error), "stdout")));
+    return preparedBundle(output);
+}
+function restartFacts(declarations) {
+    const schedules = new Map(declarations
+        .filter((declaration) => declaration.schedule !== undefined)
+        .map((declaration) => [declaration.workflowId, declaration.schedule]));
+    return JSON.stringify({
+        queue: queueWorkflowId({ declarations }) ?? null,
+        schedules: [...schedules.keys()]
+            .sort()
+            .map((workflowId) => [workflowId, schedules.get(workflowId)]),
+    });
+}
+function refusalName(refusal) {
+    return `${refusal.scope} ${refusal.label}`;
+}
+function addedRefusals(current, next) {
+    const known = new Set(current.map(refusalName));
+    const added = next.filter((refusal) => !known.has(refusalName(refusal)));
+    if (added.length === 0)
+        return undefined;
+    const reasons = added.map((refusal) => `${refusalName(refusal)}: ${refusal.codes.join(", ")}`);
+    return refused("reload-failed", `The reload gives new workflow refusals: ${reasons.join("; ")}`);
+}
+async function reloaded(settings, bundle) {
+    const scheduled = scheduledDeclarations({ declarations: bundle.declarations, schedules: settings.schedules }, {
+        repository: settings.repository,
+        documentBytes: serviceLimits.documentBytes,
+    });
+    if (scheduled.kind === "refused")
+        return refused("reload-failed", `${scheduled.reason}: ${scheduled.detail}`);
+    if (restartFacts(scheduled.declarations) !==
+        restartFacts(settings.declarations ?? []))
+        return refused("reload-needs-restart", "The queue workflow or a schedule changed. Restart the service.");
+    let generation;
+    try {
+        generation = await settings.loadBundle(join(settings.directory, "workflow-bundles", bundle.bundleDigest));
+    }
+    catch (error) {
+        return refused("reload-failed", `The new bundle did not load: ${String(error)}`);
+    }
+    const { table, admitted } = await daemonRegistrations({
+        ...settings,
+        bundleDigest: bundle.bundleDigest,
+        manifests: bundle.manifests,
+        declarations: scheduled.declarations,
+        workflowRefusals: bundle.workflowRefusals,
+    });
+    if (admitted.kind === "rejected")
+        return refused("reload-failed", admitted.detail);
+    settings.generations.replace({
+        registrations: admitted.registrations,
+        table,
+        workflows: generation.workflows,
+        handler: generation.handler,
+    });
+    return {
+        kind: "reloaded",
+        bundleDigest: bundle.bundleDigest,
+        workflows: admitted.registrations,
+        workflowRefusals: bundle.workflowRefusals,
+    };
+}
+function reloadLine(outcome, digests) {
+    if (outcome.kind === "refused")
+        return `Workflow reload: refused ${outcome.code}: ${outcome.detail}\n`;
+    return `Workflow reload: ${outcome.kind} ${String(digests.previous)} -> ${String(digests.current)}\n`;
+}
+async function workflowPart(settings, prepared) {
+    const { state, bundle } = prepared;
+    const added = addedRefusals(state.workflowRefusals, bundle.workflowRefusals);
+    if (added !== undefined)
+        return added;
+    if (bundle.bundleDigest === state.bundleDigest)
+        return { kind: "unchanged", workflowRefusals: bundle.workflowRefusals };
+    return reloaded(settings, bundle);
+}
+async function reloadOutcome(settings, state) {
+    const kept = (outcome) => ({ outcome, state });
+    const bundle = await prepared(settings.reloadCommand);
+    if (bundle.kind === "refused")
+        return kept(bundle);
+    const profiles = profileRefusal(settings, bundle.turnSettings);
+    if (profiles !== undefined)
+        return kept(refused(profiles.code, profiles.detail));
+    const workflows = await workflowPart(settings, { state, bundle });
+    if (workflows.kind === "refused")
+        return kept(workflows);
+    const changes = settingChanges(state.settingDigests, bundle.settingDigests);
+    settings.turnSettings.replace(bundle.turnSettings);
+    return {
+        outcome: { ...workflows, ...changes },
+        state: {
+            bundleDigest: workflows.kind === "reloaded"
+                ? workflows.bundleDigest
+                : state.bundleDigest,
+            workflowRefusals: workflows.workflowRefusals,
+            settingDigests: keptDigests(state.settingDigests, {
+                digests: bundle.settingDigests,
+                reloadedFields: changes.reloadedFields,
+            }),
+        },
+    };
+}
+export function workflowReload(settings) {
+    let state = {
+        bundleDigest: settings.bundleDigest,
+        workflowRefusals: workflowRefusals(settings.workflowRefusals),
+        settingDigests: settings.settingDigests ?? {},
+    };
+    return async () => {
+        const previous = state.bundleDigest;
+        const step = await reloadOutcome(settings, state);
+        state = step.state;
+        process.stdout.write(reloadLine(step.outcome, { previous, current: state.bundleDigest }));
+        return step.outcome;
+    };
+}

package/dist/src/daemon/workflow-replay.d.ts

@@ -4,8 +4,9 @@ interface ReplayRun {
     readonly runId: string;
     readonly workflowId?: string;
 }
+type ReplayState = Pick<AuthorityState, "details" | "runs">;
 interface ReplayPorts {
-    readonly state: () => Promise<Pick<AuthorityState, "details">>;
+    readonly state: () => Promise<ReplayState>;
     readonly run: (receipt: string) => Promise<ReplayRun | undefined>;
     readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
     readonly submit: (command: Readonly<Record<string, unknown>>) => Promise<{

package/dist/src/daemon/workflow-replay.js

@@ -18,8 +18,8 @@ async function located(ports, receipt) {
     return undefined;
 }
 async function observedReplay(ports, replay) {
-    const { runId, receipt, available } = replay;
-    const observation = (await ports.state()).details[runId]?.observation;
+    const { state, runId, receipt, available } = replay;
+    const observation = state.details[runId]?.observation;
     const unavailable = observation?.reason === "pinned-workflow-unavailable";
     if (available !== unavailable)
         return true;
@@ -49,7 +49,11 @@ export function pinnedWorkflowHandler(handler, ports) {
         if (run === undefined)
             return new Response("unknown-world-run", { status: 503 });
         const available = await ports.available(run.runId, run.workflowId);
-        if (!(await observedReplay(ports, { runId: run.runId, receipt, available })))
+        const state = await ports.state();
+        if (state.runs[run.runId]?.status === "cancelled")
+            return Response.json({ ok: true });
+        const replay = { state, runId: run.runId, receipt, available };
+        if (!(await observedReplay(ports, replay)))
             return new Response("workflow-observation-unavailable", { status: 503 });
         if (available)
             return handler(request, run.runId);

package/dist/src/doctor-report.d.ts

@@ -1,8 +1,8 @@
 import { type SubmissionContract } from "./submission.ts";
-export declare const doctorCodes: readonly ["git-repository", "node-version", "harnesses", "default-harness", "gh-login", "github-origin", "greptile-review", "settings-files", "no-workflow", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts"];
+export declare const doctorCodes: readonly ["git-repository", "node-version", "harnesses", "default-harness", "gh-login", "github-origin", "greptile-review", "settings-files", "no-workflow", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts", "retention"];
 export type DoctorCode = (typeof doctorCodes)[number];
 export interface DoctorObservation {
-    readonly result: "ok" | "fail" | "skip";
+    readonly result: "ok" | "warn" | "fail" | "skip";
     readonly detail: string;
 }
 export interface DoctorCheck extends DoctorObservation {

package/dist/src/doctor-report.js

@@ -16,6 +16,7 @@ export const doctorCodes = [
     "check-command",
     "queue-interval",
     "private-texts",
+    "retention",
 ];
 export const doctorFixes = {
     "git-repository": "Change to the repository, or run: git init",
@@ -34,6 +35,7 @@ export const doctorFixes = {
     "check-command": "Set checks.beforeMerge to an executable list: ${EDITOR:-vi} .cloving/config.json",
     "queue-interval": "Set an interval from 10 to 3600: CLOVING_QUEUE_SECONDS=30 cloving doctor",
     "private-texts": `Set a nonblank private text: CLOVING_PRIVATE_TEXTS='["TEXT TO KEEP PRIVATE"]' cloving doctor`,
+    retention: "Set a retention period: cloving config set retention.days 30 --private",
 };
 export function doctorExitCode(checks) {
     return checks.some((check) => check.required && check.result !== "ok")

package/dist/src/private-config.schema.json

@@ -294,6 +294,37 @@
                 }
             },
             "additionalProperties": false
+        },
+        "retention": {
+            "type": "object",
+            "properties": {
+                "days": {
+                    "anyOf": [
+                        {
+                            "type": "integer",
+                            "minimum": 1
+                        },
+                        {
+                            "const": null
+                        }
+                    ]
+                },
+                "action": {
+                    "enum": ["archive", "delete"]
+                },
+                "archiveFolder": {
+                    "anyOf": [
+                        {
+                            "type": "string",
+                            "pattern": "^/"
+                        },
+                        {
+                            "const": null
+                        }
+                    ]
+                }
+            },
+            "additionalProperties": false
         }
     },
     "additionalProperties": false,

package/dist/src/project-settings.d.ts

@@ -2,7 +2,13 @@ import { type Configuration, type RedGreenSettings } from "./configuration-schem
 import type { TurnProfiles } from "./turn-profile.ts";
 import type { TokenPrices } from "./token-prices.ts";
 export type SettingSource = "environment" | "private" | "project";
-export type SettingValue = string | number | readonly string[] | TurnProfiles | TokenPrices | RedGreenSettings;
+export declare const reloadedSettingFields: readonly string[];
+export interface TurnSettings {
+    readonly profiles: TurnProfiles;
+    readonly fallbackModels: readonly string[];
+    readonly tokenPrices: TokenPrices;
+}
+export type SettingValue = null | string | number | readonly string[] | TurnProfiles | TokenPrices | RedGreenSettings;
 export declare const settingVariables: Readonly<Record<string, string>>;
 export declare function absoluteWorkflowFolder(folder: string | undefined): string | undefined;
 export declare function configurationRoot(environment: Readonly<NodeJS.ProcessEnv>, home: string): string;
@@ -16,4 +22,12 @@ export declare function resolveSettings(environment: Readonly<NodeJS.ProcessEnv>
     readonly profiles: TurnProfiles;
     readonly harness?: Configuration["harness"];
     readonly sources: Readonly<Record<string, SettingSource>>;
+    readonly values: Readonly<Record<string, SettingValue>>;
 };
+interface ResolvedFields {
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly values: Readonly<Record<string, SettingValue>>;
+    readonly profiles: TurnProfiles;
+}
+export declare function settingDigests(resolved: ResolvedFields, digest: (text: string) => string): Readonly<Record<string, string>>;
+export {};

package/dist/src/project-settings.js

@@ -1,4 +1,10 @@
-import { configuration, } from "./configuration-schema.js";
+import { configuration, settingFields, } from "./configuration-schema.js";
+export const reloadedSettingFields = [
+    "fallbackModels",
+    "profiles",
+    "tokenPrices",
+    "workflows.folder",
+];
 export const settingVariables = {
     "checks.beforeMerge": "CLOVING_CHECK_COMMAND",
     "checks.required": "CLOVING_REQUIRED_CHECKS",
@@ -18,6 +24,9 @@ export const settingVariables = {
     "selfUpdate.everySeconds": "CLOVING_SELF_UPDATE_SECONDS",
     "github.command": "CLOVING_GH_COMMAND",
     "workflows.folder": "CLOVING_WORKFLOW_FOLDER",
+    "retention.days": "CLOVING_RETENTION_DAYS",
+    "retention.action": "CLOVING_RETENTION_ACTION",
+    "retention.archiveFolder": "CLOVING_RETENTION_ARCHIVE_FOLDER",
 };
 const environmentOnly = [
     "CLOVING_RUNTIME_DIR",
@@ -65,6 +74,7 @@ export function configurationValues(values) {
         selfUpdate: values.selfUpdate,
         github: values.github,
         workflows: values.workflows,
+        retention: values.retention,
     };
     for (const [name, group] of Object.entries(groups)) {
         if (group === undefined)
@@ -126,8 +136,30 @@ export function resolveSettings(environment, files) {
         environment: resolved,
         profiles,
         sources,
+        values,
         ...(privateConfiguration.harness === undefined
             ? {}
             : { harness: privateConfiguration.harness }),
     };
 }
+function resolvedValue(resolved, field) {
+    if (field === "profiles")
+        return resolved.profiles;
+    const variable = resolved.variables[field];
+    return variable === undefined
+        ? resolved.values[field]
+        : resolved.environment[variable];
+}
+export function settingDigests(resolved, digest) {
+    const fields = {
+        ...resolved,
+        variables: {
+            ...settingVariables,
+            ...harnessCommandMapping(resolved.values["harness.name"]),
+        },
+    };
+    return Object.fromEntries(settingFields().map((field) => [
+        field,
+        digest(JSON.stringify(resolvedValue(fields, field) ?? null)),
+    ]));
+}

package/dist/src/queue-state.d.ts

@@ -0,0 +1,26 @@
+import type { Fields } from "./protocol.ts";
+export declare const queueFailureLimit = 3;
+export interface QueueDrain {
+    readonly startedAt: number;
+    readonly drainedAt: number | null;
+}
+export interface QueueControl {
+    readonly failedRunIds: readonly string[];
+    readonly drain: QueueDrain | undefined;
+    readonly error: string | undefined;
+}
+export type QueueCommand = "resume" | "drain";
+export type QueueChange = {
+    readonly kind: "changed" | "replayed" | "conflicting-command";
+} | {
+    readonly kind: "unavailable";
+    readonly detail: string;
+};
+export interface QueuePort {
+    readonly control: () => QueueControl | undefined;
+    readonly change: (request: {
+        readonly command: QueueCommand;
+        readonly commandId: string;
+    }) => Promise<QueueChange>;
+}
+export declare function queueStateFields(control: QueueControl, busy: number): Fields;

package/dist/src/queue-state.js

@@ -0,0 +1,34 @@
+export const queueFailureLimit = 3;
+function stopReason(control) {
+    if (control.error !== undefined)
+        return control.error;
+    if (control.failedRunIds.length >= queueFailureLimit)
+        return "failure-limit";
+    return undefined;
+}
+function drainState(drain, busy) {
+    return drain.drainedAt === null || busy > 0 ? "draining" : "drained";
+}
+function stateName(control, busy) {
+    if (control.error !== undefined)
+        return "stopped";
+    if (control.drain !== undefined)
+        return drainState(control.drain, busy);
+    if (stopReason(control) !== undefined)
+        return "stopped";
+    return "running";
+}
+export function queueStateFields(control, busy) {
+    const reason = stopReason(control);
+    return {
+        state: stateName(control, busy),
+        stop: reason === undefined ? null : { reason },
+        failedRunIds: [...control.failedRunIds],
+        drain: control.drain === undefined
+            ? null
+            : {
+                startedAt: control.drain.startedAt,
+                drainedAt: control.drain.drainedAt,
+            },
+    };
+}