cloving 1.4.0 → 1.5.0

package/dist/src/record-retention.d.ts

@@ -0,0 +1,46 @@
+export interface StoredRun {
+    readonly status: string;
+    readonly endedAt: number | null;
+}
+export interface RecordFolder {
+    readonly started: unknown;
+    readonly changedAt: number;
+}
+export interface RetentionContext {
+    readonly runs: Readonly<Record<string, StoredRun>>;
+    readonly now: number;
+    readonly days: number;
+}
+export type RetentionVerdict = "due" | "kept" | "skipped" | "unreadable";
+export interface RetentionSettings {
+    readonly days: number | null;
+    readonly action: "archive" | "delete";
+    readonly archiveFolder: string | null;
+}
+export interface RunTurns {
+    readonly runId: string;
+    readonly operationIds: readonly string[];
+}
+export type TurnDetails = {
+    readonly state: "archived";
+    readonly folder: string;
+} | {
+    readonly state: "deleted";
+};
+export interface TurnFolders {
+    readonly turns: number;
+    readonly kept: number;
+    readonly archived: string | undefined;
+}
+export declare const sharedRecordFolders: readonly string[];
+export declare const defaultRetention: RetentionSettings;
+type Variables = Readonly<Record<string, string | undefined>>;
+export declare function folderRunId(started: unknown): string | undefined;
+export declare function retentionVerdict(folder: RecordFolder, context: RetentionContext): RetentionVerdict;
+export declare function turnDetails(found: TurnFolders, context: {
+    readonly run: StoredRun | undefined;
+    readonly retention: RetentionSettings;
+    readonly now: number;
+}): TurnDetails | undefined;
+export declare function retentionSettings(variables: Variables): RetentionSettings;
+export {};

package/dist/src/record-retention.js

@@ -0,0 +1,81 @@
+import { operationScope } from "./operation-identity.js";
+export const sharedRecordFolders = [
+    "journal/runs",
+    "journal/targets",
+];
+export const defaultRetention = {
+    days: 30,
+    action: "archive",
+    archiveFolder: null,
+};
+const dayMilliseconds = 86_400_000;
+const finished = ["completed", "failed", "cancelled"];
+export function folderRunId(started) {
+    if (typeof started !== "object" || started === null)
+        return undefined;
+    if ("runId" in started && typeof started.runId === "string")
+        return started.runId;
+    if (!("operationId" in started) || typeof started.operationId !== "string")
+        return undefined;
+    return operationScope(started.operationId)?.run;
+}
+export function retentionVerdict(folder, context) {
+    const runId = folderRunId(folder.started);
+    const run = runId !== undefined && Object.hasOwn(context.runs, runId)
+        ? context.runs[runId]
+        : undefined;
+    if (run === undefined)
+        return "unreadable";
+    if (!finished.includes(run.status))
+        return "skipped";
+    const limit = context.now - context.days * dayMilliseconds;
+    return endedBefore(run, limit) && folder.changedAt < limit ? "due" : "kept";
+}
+function endedBefore(run, limit) {
+    return finished.includes(run.status) && (run.endedAt ?? Number.NaN) < limit;
+}
+export function turnDetails(found, context) {
+    if (found.archived !== undefined)
+        return { state: "archived", folder: found.archived };
+    const { run, retention } = context;
+    if (found.turns === 0 || found.kept > 0 || run === undefined)
+        return undefined;
+    if (retention.action !== "delete" || retention.days === null)
+        return undefined;
+    const limit = context.now - retention.days * dayMilliseconds;
+    return endedBefore(run, limit) ? { state: "deleted" } : undefined;
+}
+function refused(variable, expected) {
+    throw new Error(`invalid-setting: ${variable} must be ${expected}`);
+}
+function retentionDays(value) {
+    if (value === undefined)
+        return defaultRetention.days;
+    if (value === "null")
+        return null;
+    const days = Number(value);
+    if (/^[1-9][0-9]*$/.test(value) && Number.isSafeInteger(days))
+        return days;
+    return refused("CLOVING_RETENTION_DAYS", "a whole number of at least 1 or null");
+}
+function retentionAction(value) {
+    if (value === undefined)
+        return defaultRetention.action;
+    if (value === "archive" || value === "delete")
+        return value;
+    return refused("CLOVING_RETENTION_ACTION", "archive or delete");
+}
+function archiveFolder(value) {
+    if (value === undefined || value === "null")
+        return null;
+    if (value.startsWith("/"))
+        return value;
+    return refused("CLOVING_RETENTION_ARCHIVE_FOLDER", "an absolute path or null");
+}
+export function retentionSettings(variables) {
+    return {
+        days: retentionDays(variables["CLOVING_RETENTION_DAYS"]),
+        action: retentionAction(variables["CLOVING_RETENTION_ACTION"]),
+        archiveFolder: archiveFolder(variables["CLOVING_RETENTION_ARCHIVE_FOLDER"]),
+    };
+}

package/dist/src/service/active-tickets.js

@@ -1,4 +1,5 @@
 import { record } from "../protocol.js";
+import { queueStateFields } from "../queue-state.js";
 import { queueRun, queueSpend } from "./queue-spend.js";
 export async function activeWorkflow(context, workflowId) {
     const workflows = await context.authority.queries.workflowIds();
@@ -22,6 +23,7 @@ export async function queueOverview(context) {
     if (workflow?.admission === undefined)
         return {};
     const active = await activeWorkflow(context, workflow.workflowId);
+    const control = context.queue?.control();
     return {
         queue: {
             workflowId: workflow.workflowId,
@@ -34,6 +36,9 @@ export async function queueOverview(context) {
                     : []),
                 ...(workflow.resolver.skippedTickets?.() ?? []),
             ],
+            ...(control === undefined
+                ? {}
+                : queueStateFields(control, active.length)),
         },
     };
 }

package/dist/src/service/dispatcher.d.ts

@@ -0,0 +1,4 @@
+import type { Reply, ServiceRequest } from "../protocol.ts";
+import { type Connection } from "./event-handler.ts";
+import { type ServiceContext } from "./replies.ts";
+export declare function dispatcher(context: ServiceContext): (request: ServiceRequest, connection: Connection) => Promise<Reply | undefined>;

package/dist/src/service/dispatcher.js

@@ -0,0 +1,33 @@
+import { decision, questions } from "./decision-handler.js";
+import { events } from "./event-handler.js";
+import { queueCommand, queueRead } from "./queue-handlers.js";
+import { failed, scheduleRequest } from "./replies.js";
+import { runCommand, status } from "./run-handlers.js";
+import { submissionHandler } from "./submission-handler.js";
+import { reloadUnavailable } from "./workflow-reload.js";
+export function dispatcher(context) {
+    const run = submissionHandler(context);
+    const operations = new Map([
+        ["run", (request) => run(request.parameters)],
+        ["schedule", (request) => scheduleRequest(context, request.parameters)],
+        ["queue", () => queueRead(context)],
+        ["queue-command", (request) => queueCommand(context, request.parameters)],
+        ["status", (request) => status(context, request.parameters)],
+        ["questions", (request) => questions(context, request.parameters)],
+        ["decision", (request) => decision(context, request.parameters)],
+        ["run-command", (request) => runCommand(context, request.parameters)],
+        ["reload", () => context.reload?.() ?? reloadUnavailable()],
+        [
+            "events",
+            (request, connection) => events(context, { parameters: request.parameters, connection }),
+        ],
+    ]);
+    return (request, connection) => {
+        const operation = operations.get(request.operation);
+        if (operation === undefined)
+            return Promise.resolve(failed("unknown-operation", {
+                detail: `The service has no operation ${request.operation}.`,
+            }));
+        return operation(request, connection);
+    };
+}

package/dist/src/service/queue-handlers.d.ts

@@ -0,0 +1,4 @@
+import type { Fields, Reply } from "../protocol.ts";
+import { type ServiceContext } from "./replies.ts";
+export declare function queueRead(context: ServiceContext): Promise<Reply>;
+export declare function queueCommand(context: ServiceContext, parameters: Fields): Promise<Reply>;

package/dist/src/service/queue-handlers.js

@@ -0,0 +1,32 @@
+import { queueOverview } from "./active-tickets.js";
+import { failed, invalidRequest, isIdentifier, result, } from "./replies.js";
+const noQueue = failed("queue-unavailable", {
+    detail: "The service has no queue workflow.",
+});
+export async function queueRead(context) {
+    const overview = await queueOverview(context);
+    if (overview["queue"] === undefined)
+        return noQueue;
+    return result("queue", overview);
+}
+export async function queueCommand(context, parameters) {
+    const { command, commandId } = parameters;
+    if ((command !== "resume" && command !== "drain") || !isIdentifier(commandId))
+        return invalidRequest("The queue command request is not valid.");
+    if (context.queue === undefined)
+        return noQueue;
+    const change = await context.queue.change({ command, commandId });
+    if (change.kind === "unavailable")
+        return failed("queue-unavailable", { commandId, detail: change.detail });
+    if (change.kind === "conflicting-command")
+        return failed("conflicting-command", {
+            commandId,
+            detail: "The command ID names another queue command.",
+        });
+    return result("queue-command", {
+        command,
+        commandId,
+        replayed: change.kind === "replayed",
+        ...(await queueOverview(context)),
+    });
+}

package/dist/src/service/registry.d.ts

@@ -2,6 +2,7 @@ import type { CommandWaits, WorkflowStage, WorkflowStages } from "../workflow-de
 import type { SubmissionContract } from "../submission.ts";
 import type { ExecutionManifest } from "../workflow-admission.ts";
 import type { AvailableManifest } from "../broker/actor/delivery-intents.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 export interface WorkflowBundleStore {
     readonly directory: string;
     readonly repository: string;
@@ -52,8 +53,33 @@ export interface Registry {
     readonly bundle: (pinned: ExecutionManifest) => Promise<string | undefined>;
     readonly available: AvailableManifest;
 }
-export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: {
+export interface RegistryOptions {
     readonly retainedWorkflows?: readonly WorkflowRegistration[];
     readonly workflowBundles?: WorkflowBundleStore;
     readonly retainedWorkflow?: AvailableManifest;
-}): Registry;
+}
+export interface ReplaceableRegistry extends Registry {
+    readonly replace: (workflows: readonly WorkflowRegistration[]) => void;
+}
+export declare function replaceableRegistry(workflows: readonly WorkflowRegistration[], options?: RegistryOptions): ReplaceableRegistry;
+export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: RegistryOptions): Registry;
+interface WorkflowInventory {
+    readonly bundleDigest?: string;
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+}
+export interface WorkflowCatalog {
+    readonly registry: Registry;
+    readonly inventory: () => WorkflowInventory;
+    readonly replace: (next: {
+        readonly bundleDigest: string;
+        readonly workflows: readonly WorkflowRegistration[];
+        readonly workflowRefusals: readonly WorkflowRefusal[];
+    }) => void;
+    readonly replaceRefusals: (refusals: readonly WorkflowRefusal[]) => void;
+}
+export declare function workflowCatalog(options: RegistryOptions & {
+    readonly workflows: readonly WorkflowRegistration[];
+    readonly bundleDigest?: string;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+}): WorkflowCatalog;
+export {};

package/dist/src/service/registry.js

@@ -1,6 +1,7 @@
 import { workflowPin } from "../broker/workflow-pin.js";
 import { declaredManifest } from "../execution-pin.js";
 import { readRetainedWorkflowBundle } from "../../tools/workflow-bundles.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 function registered(workflow) {
     const manifest = declaredManifest(workflow.manifest, workflow);
     return {
@@ -19,6 +20,30 @@ function availableVersions(workflow) {
     delete manifest.bundleDigest;
     return [workflow, { ...workflow, manifest, pin: workflowPin(manifest) }];
 }
+export function replaceableRegistry(workflows, options = {}) {
+    let earlier = [...workflows, ...(options.retainedWorkflows ?? [])];
+    let current = workflowRegistry(workflows, options);
+    return {
+        get workflowIds() {
+            return current.workflowIds;
+        },
+        get workflowStages() {
+            return current.workflowStages;
+        },
+        byId: (workflowId) => current.byId(workflowId),
+        byPin: (pin) => current.byPin(pin),
+        bundle: (pinned) => current.bundle(pinned),
+        available: (pinned) => current.available(pinned),
+        replace: (next) => {
+            const replacement = workflowRegistry(next, {
+                ...options,
+                retainedWorkflows: earlier,
+            });
+            earlier = [...next, ...earlier];
+            current = replacement;
+        },
+    };
+}
 export function workflowRegistry(workflows, options = {}) {
     const current = workflows.map(registered);
     const available = [
@@ -54,3 +79,26 @@ export function workflowRegistry(workflows, options = {}) {
         },
     };
 }
+export function workflowCatalog(options) {
+    const registry = replaceableRegistry(options.workflows, options);
+    let inventory = {
+        ...(options.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: options.bundleDigest }),
+        workflowRefusals: workflowRefusals(options.workflowRefusals),
+    };
+    return {
+        registry,
+        inventory: () => inventory,
+        replace: (next) => {
+            registry.replace(next.workflows);
+            inventory = {
+                bundleDigest: next.bundleDigest,
+                workflowRefusals: next.workflowRefusals,
+            };
+        },
+        replaceRefusals: (refusals) => {
+            inventory = { ...inventory, workflowRefusals: refusals };
+        },
+    };
+}

package/dist/src/service/replies.d.ts

@@ -1,19 +1,26 @@
 import type { SchedulePort } from "../schedule-progress.ts";
+import type { QueuePort } from "../queue-state.ts";
 import type { Authority, CommandRecord, StoreReceipt } from "../broker/actor/authority.ts";
 import type { Fields, Reply } from "../protocol.ts";
 import type { ChangeSignal } from "./changes.ts";
 import type { Gateway } from "./gateway.ts";
-import type { Registry } from "./registry.ts";
-import { type WorkflowRefusal } from "../workflow-refusals.ts";
+import type { Registry, WorkflowCatalog } from "./registry.ts";
 import type { CommandEffects } from "../command-settings.ts";
-export interface ServiceContext {
+import type { RunTurns, TurnDetails } from "../record-retention.ts";
+export interface ServiceReads {
+    readonly workerHarness?: (operationId: string) => Promise<string | undefined>;
+    readonly turnDetails?: (turns: RunTurns) => Promise<TurnDetails | undefined>;
+}
+export interface ServiceContext extends ServiceReads {
+    readonly version?: string;
     readonly schedule?: SchedulePort;
+    readonly queue?: QueuePort;
     readonly queueDailySpendLimitUsd?: number;
-    readonly workerHarness?: (operationId: string) => Promise<string | undefined>;
     readonly commandEffects?: CommandEffects;
     readonly authority: Authority;
     readonly registry: Registry;
-    readonly workflowRefusals?: readonly WorkflowRefusal[];
+    readonly workflowCatalog?: WorkflowCatalog;
+    readonly reload?: () => Promise<Reply>;
     readonly gateway: Gateway;
     readonly clock: () => string;
     readonly livenessMilliseconds: number;
@@ -24,13 +31,13 @@ export interface ServiceContext {
     readonly worldReports?: () => readonly unknown[];
     readonly changed?: ChangeSignal["next"];
 }
-export declare function queryMetadata(options: {
+export declare function queryMetadata(options: ServiceReads & {
+    readonly version?: string;
     readonly schedule?: SchedulePort;
+    readonly queue?: QueuePort;
     readonly queueDailySpendLimitUsd?: number;
-    readonly workerHarness?: ServiceContext["workerHarness"];
     readonly commandEffects?: CommandEffects;
-    readonly workflowRefusals?: readonly WorkflowRefusal[];
-}): Pick<ServiceContext, "schedule" | "workerHarness" | "commandEffects" | "workflowRefusals" | "queueDailySpendLimitUsd">;
+}): Pick<ServiceContext, "schedule" | "queue" | "workerHarness" | "turnDetails" | "commandEffects" | "queueDailySpendLimitUsd" | "version">;
 export declare function result(kind: string, fields: Fields): Reply;
 export declare function failed(code: string, extra: Fields): Reply;
 export declare function invalidRequest(detail: string): Reply;

package/dist/src/service/replies.js

@@ -1,18 +1,21 @@
 import { isRecordKey } from "../authority/commands.js";
-import { workflowRefusals, } from "../workflow-refusals.js";
 export function queryMetadata(options) {
     return {
+        ...(options.version === undefined ? {} : { version: options.version }),
         ...(options.schedule === undefined ? {} : { schedule: options.schedule }),
+        ...(options.queue === undefined ? {} : { queue: options.queue }),
         ...(options.queueDailySpendLimitUsd === undefined
             ? {}
             : { queueDailySpendLimitUsd: options.queueDailySpendLimitUsd }),
         ...(options.workerHarness === undefined
             ? {}
             : { workerHarness: options.workerHarness }),
+        ...(options.turnDetails === undefined
+            ? {}
+            : { turnDetails: options.turnDetails }),
         ...(options.commandEffects === undefined
             ? {}
             : { commandEffects: options.commandEffects }),
-        workflowRefusals: workflowRefusals(options.workflowRefusals),
     };
 }
 const codes = {

package/dist/src/service/run-handlers.js

@@ -1,14 +1,16 @@
 import { commandWaitDisplay } from "./command-waits.js";
 import { scheduleMetadata, scheduledMetadata, metadataOf, outcomeOf, ticketMetadataPage, workflowMetadata, } from "./run-metadata.js";
 import { linksOf } from "../authority/handoff-chain.js";
+import { terminal } from "../authority/transitions.js";
 import { runView, unresolvedEffects, } from "../authority/status.js";
 import { record } from "../protocol.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
-import { usageTotals } from "./worker-totals.js";
+import { turnDetailsOf, usageTotals } from "./worker-totals.js";
 import { commandFields } from "./command-effects.js";
 import { decidedOf, feedbackOf } from "./decision-handler.js";
 import { queueOverview } from "./active-tickets.js";
 import { queueRunStatuses } from "./queue-runs.js";
+import { workflowFields } from "./workflow-reload.js";
 async function snapshot(context) {
     const { authority } = context;
     const state = await authority.state();
@@ -150,7 +152,9 @@ async function submittedInput(context, digest) {
     return record(request?.["submission"]) ?? null;
 }
 async function listed(context, page) {
-    const identifiers = Object.keys(page.snapshot.state.runs)
+    const identifiers = Object.entries(page.snapshot.state.runs)
+        .filter(([, run]) => !page.active || !terminal.includes(run.status))
+        .map(([runId]) => runId)
         .sort()
         .filter((runId) => runId > page.after);
     const shown = identifiers.slice(0, page.limit);
@@ -159,15 +163,12 @@ async function listed(context, page) {
         views.push(await viewOf(context, { snapshot: page.snapshot, runId }));
     const runs = views.filter((view) => view !== undefined).map(summary);
     return result("run-list", {
+        ...(context.version === undefined
+            ? {}
+            : { serviceVersion: context.version }),
         ...(await queueOverview(context)),
         ...(await scheduleMetadata(context)),
-        workflows: context.registry.workflowIds,
-        workflowRefusals: context.workflowRefusals ?? [],
-        ...(Object.keys(context.registry.workflowStages).length === 0
-            ? {}
-            : {
-                workflowStages: context.registry.workflowStages,
-            }),
+        ...workflowFields(context),
         runs,
         next: identifiers.length > shown.length ? (shown.at(-1) ?? null) : null,
         worldReports: context.worldReports?.() ?? [],
@@ -176,9 +177,12 @@ async function listed(context, page) {
 function listParameters(parameters) {
     const after = parameters["after"] ?? "";
     const limit = parameters["limit"] ?? 50;
+    const active = parameters["active"] ?? false;
     if (typeof after !== "string" || !wholeNumber(limit, 1) || limit > 500)
         return undefined;
-    return { after, limit };
+    if (typeof active !== "boolean")
+        return undefined;
+    return { after, limit, active };
 }
 export async function status(context, parameters) {
     if (parameters["metadata"] === "workflows")
@@ -202,6 +206,7 @@ export async function status(context, parameters) {
     return result("run-status", {
         run: {
             ...full({ ...view, ...totals }),
+            ...(await turnDetailsOf(context, { runId: view.runId, totals })),
             ...(await commandFields(context, view.commandOperations)),
             outcome: await outcomeOf(context, view),
             decisions: await decidedOf(context, {

package/dist/src/service/service.d.ts

@@ -1,7 +1,8 @@
 import { type Authority, type AuthorityTiming, type Delivery, type EffectSettings, type Refusal } from "../broker/actor/authority.ts";
 import { type WorkflowRefusal } from "../workflow-refusals.ts";
 import { type Registry, type WorkflowRegistration, type WorkflowBundleStore } from "./registry.ts";
-import { type ServiceContext } from "./replies.ts";
+import { type WorkflowReloadPort } from "./workflow-reload.ts";
+import { type ServiceContext, type ServiceReads } from "./replies.ts";
 import { type WorkerPort } from "./worker-port.ts";
 import type { RunWaitTarget } from "../run-wait.ts";
 import type { CommandEffects } from "../command-settings.ts";
@@ -49,10 +50,11 @@ export interface HostPorts {
     readonly openGate: WorkerPort["openGate"];
     readonly registerWait: WorkerPort["registerWait"];
 }
-export interface ServiceOptions {
+export interface ServiceOptions extends ServiceReads {
+    readonly version?: string;
     readonly schedule?: NonNullable<ServiceContext["schedule"]>;
+    readonly queue?: NonNullable<ServiceContext["queue"]>;
     readonly queueDailySpendLimitUsd?: number;
-    readonly workerHarness?: ServiceContext["workerHarness"];
     readonly commandEffects?: CommandEffects;
     readonly stateDirectory: string;
     readonly runtimeDirectory: string;
@@ -61,6 +63,8 @@ export interface ServiceOptions {
     readonly workflowBundles?: WorkflowBundleStore;
     readonly retainedWorkflow?: Registry["available"];
     readonly workflowRefusals?: readonly WorkflowRefusal[];
+    readonly bundleDigest?: string;
+    readonly reload?: WorkflowReloadPort;
     readonly delivery: Delivery;
     readonly host?: (ports: HostPorts) => Promise<ServiceHost>;
     readonly timing?: ServiceTiming;

package/dist/src/service/service.js

@@ -4,14 +4,12 @@ import { authorityTiming, openAuthority, } from "../broker/actor/authority.js";
 import { socketAddress } from "../broker/socket-address.js";
 import {} from "../workflow-refusals.js";
 import { changeSignal } from "./changes.js";
-import { decision, questions } from "./decision-handler.js";
-import { events } from "./event-handler.js";
 import { expiryScan } from "./expiry.js";
 import { commandGateway, workerCommandBound } from "./gateway.js";
-import { workflowRegistry, } from "./registry.js";
-import { errorMessage, failed, queryMetadata, scheduleRequest, } from "./replies.js";
-import { runCommand, status } from "./run-handlers.js";
-import { submissionHandler } from "./submission-handler.js";
+import { workflowCatalog, } from "./registry.js";
+import { reloadOperation } from "./workflow-reload.js";
+import { errorMessage, queryMetadata, } from "./replies.js";
+import { dispatcher } from "./dispatcher.js";
 import { connectionLimits, listen, reachable } from "./transport.js";
 import { workerPort } from "./worker-port.js";
 import { runWaitTarget } from "./run-waits.js";
@@ -56,31 +54,17 @@ async function endpoint(directory) {
 function wallClock() {
     return new Date().toISOString();
 }
-function dispatcher(context) {
-    const run = submissionHandler(context);
-    const operations = new Map([
-        ["run", (request) => run(request.parameters)],
-        ["schedule", (request) => scheduleRequest(context, request.parameters)],
-        ["status", (request) => status(context, request.parameters)],
-        ["questions", (request) => questions(context, request.parameters)],
-        ["decision", (request) => decision(context, request.parameters)],
-        ["run-command", (request) => runCommand(context, request.parameters)],
-        [
-            "events",
-            (request, connection) => events(context, { parameters: request.parameters, connection }),
-        ],
-    ]);
-    return (request, connection) => {
-        const operation = operations.get(request.operation);
-        if (operation === undefined)
-            return Promise.resolve(failed("unknown-operation", {
-                detail: `The service has no operation ${request.operation}.`,
-            }));
-        return operation(request, connection);
+function catalogContext(options, catalog) {
+    return {
+        registry: catalog.registry,
+        workflowCatalog: catalog,
+        ...(options.reload === undefined
+            ? {}
+            : { reload: reloadOperation({ port: options.reload, catalog }) }),
     };
 }
 async function started(authority, setup) {
-    const { options, path, timing, registry, gateway, host } = setup;
+    const { options, path, timing, catalog, gateway, host } = setup;
     const clock = options.clock ?? wallClock;
     const { textBytes, documentBytes } = options.limits ?? serviceLimits;
     await rm(path, { force: true });
@@ -90,7 +74,7 @@ async function started(authority, setup) {
         limits: { idleMilliseconds: timing.idleMilliseconds },
         handle: dispatcher({
             authority,
-            registry,
+            ...catalogContext(options, catalog),
             ...queryMetadata(options),
             gateway,
             clock,
@@ -138,7 +122,8 @@ export async function startService(options) {
     if (typeof path !== "string")
         return path;
     const timing = options.timing ?? serviceTiming;
-    const registry = workflowRegistry(options.workflows, options);
+    const catalog = workflowCatalog(options);
+    const { registry } = catalog;
     const opening = await openAuthority(options.stateDirectory, {
         delivery: options.delivery,
         timing: timing.authority,
@@ -163,7 +148,7 @@ export async function startService(options) {
                 options,
                 path,
                 timing,
-                registry,
+                catalog,
                 gateway,
                 worker,
                 host: host.host,

package/dist/src/service/worker-totals.d.ts

@@ -3,3 +3,7 @@ import { type WorkerTotals } from "../worker-usage.ts";
 import type { ServiceContext } from "./replies.ts";
 export declare function reportFields(text: string | undefined): Fields;
 export declare function usageTotals(context: ServiceContext, runId: string): Promise<WorkerTotals>;
+export declare function turnDetailsOf(context: ServiceContext, run: {
+    readonly runId: string;
+    readonly totals: WorkerTotals;
+}): Promise<Fields>;

package/dist/src/service/worker-totals.js

@@ -35,3 +35,10 @@ export async function usageTotals(context, runId) {
     }
     return workerTotals(turns);
 }
+export async function turnDetailsOf(context, run) {
+    const details = await context.turnDetails?.({
+        runId: run.runId,
+        operationIds: run.totals.workerTurns.map((turn) => turn.operationId),
+    });
+    return details === undefined ? {} : { turnDetails: details };
+}

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

@@ -0,0 +1,35 @@
+import type { Fields, Reply } from "../protocol.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
+import type { Registry, WorkflowCatalog, WorkflowRegistration } from "./registry.ts";
+export interface SettingChanges {
+    readonly reloadedFields: readonly string[];
+    readonly restartFields: readonly string[];
+}
+export type WorkflowBundleReload = {
+    readonly kind: "reloaded";
+    readonly bundleDigest: string;
+    readonly workflows: readonly WorkflowRegistration[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+} | {
+    readonly kind: "unchanged";
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+} | {
+    readonly kind: "refused";
+    readonly code: string;
+    readonly detail: string;
+};
+export type WorkflowReload = (Exclude<WorkflowBundleReload, {
+    readonly kind: "refused";
+}> & SettingChanges) | Extract<WorkflowBundleReload, {
+    readonly kind: "refused";
+}>;
+export type WorkflowReloadPort = () => Promise<WorkflowReload>;
+export declare function workflowFields(context: {
+    readonly registry: Registry;
+    readonly workflowCatalog?: WorkflowCatalog;
+}): Fields;
+export declare function reloadOperation(parts: {
+    readonly port: WorkflowReloadPort;
+    readonly catalog: WorkflowCatalog;
+}): () => Promise<Reply>;
+export declare function reloadUnavailable(): Promise<Reply>;