cloving 1.4.0 → 1.5.0

package/dist/src/broker/actor/projection-memory.js

@@ -0,0 +1,207 @@
+import { eligibleIntents } from "../../authority/reducer.js";
+import { loadProjections, } from "../../storage/decision-snapshots.js";
+import { messageOutcomes, recordedTimes, runTimes, storedWorkflows, submittedWorkflows, } from "../../storage/projection-lookups.js";
+import { changedProjection, followingSequence, projectedChange, } from "../../storage/projection-changes.js";
+import { currentState, intentKind, } from "../authority-restore.js";
+const pendingLimit = 1_000;
+export function projectionMemory(options) {
+    const memory = {
+        held: undefined,
+        stale: null,
+        recorded: new Map(),
+        logger: options.logger,
+    };
+    return {
+        record: ({ messageId, change }) => {
+            memory.recorded.delete(messageId);
+            memory.recorded.set(messageId, projectedChange(change));
+            if (memory.recorded.size <= pendingLimit)
+                return;
+            memory.recorded.clear();
+            memory.held = undefined;
+        },
+        load: (database) => database.connection(async (connection) => {
+            memory.recorded.clear();
+            memory.held = await rebuilt(connection);
+        }),
+        read: (database) => database.connection(async (connection) => {
+            const held = await advanced(memory, connection);
+            return held.projection;
+        }),
+    };
+}
+async function advanced(memory, connection) {
+    const recorded = [...memory.recorded];
+    memory.recorded.clear();
+    try {
+        memory.held = await updated(memory, { recorded, connection });
+    }
+    catch (error) {
+        memory.held = undefined;
+        memory.stale = `update failed: ${String(Reflect.get(Object(error), "message"))}`;
+        throw error;
+    }
+    return memory.held;
+}
+async function updated(memory, update) {
+    const { recorded, connection } = update;
+    if (memory.held === undefined)
+        return rebuiltAfter(memory, connection);
+    if (recorded.length === 0)
+        return memory.held;
+    const outcomes = await messageOutcomes(connection, recorded.map(([messageId]) => messageId));
+    const committed = [];
+    let sequence = memory.held.snapshot.sequence;
+    for (const [messageId, change] of recorded) {
+        const outcome = outcomes.get(messageId) ?? "missing";
+        if (outcome === "rolled-back")
+            continue;
+        const reason = mismatch({ messageId, change, outcome, sequence });
+        if (reason !== null) {
+            memory.stale = reason;
+            return rebuiltAfter(memory, connection);
+        }
+        committed.push(change);
+        sequence = followingSequence(sequence, change);
+    }
+    return applied(memory.held, { changes: committed, connection });
+}
+async function rebuiltAfter(memory, connection) {
+    const held = await rebuilt(connection);
+    if (memory.stale !== null)
+        memory.logger.warn({
+            event: "authority-projection-rebuilt",
+            reason: memory.stale,
+        });
+    memory.stale = null;
+    return held;
+}
+function mismatch(recorded) {
+    const { messageId, change, outcome, sequence } = recorded;
+    if (outcome === "missing")
+        return `message ${messageId} is not stored`;
+    if (change.previous === sequence)
+        return null;
+    return `sequence ${String(change.previous)} does not follow ${String(sequence)}`;
+}
+async function rebuilt(connection) {
+    const snapshot = await loadProjections(connection);
+    return withProjection({
+        snapshot,
+        times: await runTimes(connection),
+        workflows: new Map([
+            ...snapshot.details.flatMap((row) => row.submission === null ? [] : [[row.submission, null]]),
+            ...(await submittedWorkflows(connection)),
+        ]),
+    });
+}
+async function applied(previous, input) {
+    const { changes } = input;
+    if (changes.length === 0)
+        return previous;
+    return withProjection({
+        snapshot: changedProjection(previous.snapshot, changes),
+        times: await changedTimes(previous.times, input),
+        workflows: await changedWorkflows(previous.workflows, input),
+    });
+}
+async function changedTimes(previous, input) {
+    const runs = new Map(input.changes.flatMap((change) => change.runs.map((row) => [row.runId, row.sequence])));
+    const carried = new Map(input.changes.flatMap((change) => change.events.map((event) => [event.sequence, event.recordedAt])));
+    const stored = await recordedTimes(input.connection, [
+        ...new Set([...runs.values()].filter((sequence) => !carried.has(sequence))),
+    ]);
+    const times = new Map(previous);
+    for (const [runId, sequence] of runs) {
+        const time = carried.get(sequence) ?? stored.get(sequence);
+        if (time === undefined)
+            times.delete(runId);
+        else
+            times.set(runId, time);
+    }
+    return times;
+}
+async function changedWorkflows(previous, input) {
+    const submissions = [
+        ...new Set(input.changes.flatMap((change) => change.details.flatMap((row) => row.submission === null || previous.has(row.submission)
+            ? []
+            : [row.submission]))),
+    ];
+    const stored = await storedWorkflows(input.connection, submissions);
+    return new Map([
+        ...previous,
+        ...submissions.map((submission) => [submission, stored.get(submission) ?? null]),
+    ]);
+}
+function withProjection(parts) {
+    return { ...parts, projection: projection(parts) };
+}
+function remembered(compute) {
+    let value;
+    return () => {
+        value ??= { current: compute() };
+        return value.current;
+    };
+}
+function projection(parts) {
+    const { snapshot, times, workflows } = parts;
+    const state = remembered(() => currentState(snapshot));
+    return {
+        snapshot,
+        state,
+        eligible: remembered(() => eligible({ snapshot, state: state() })),
+        operations: remembered(() => operationRecords(snapshot)),
+        sequences: remembered(() => sequences({ snapshot, times })),
+        workflowIds: (runIds) => workflowIds({ snapshot, workflows, runIds }),
+    };
+}
+function sequences(parts) {
+    const timed = parts.snapshot.runs.flatMap((row) => {
+        const time = parts.times.get(row.runId);
+        return time === undefined ? [] : [{ row, time }];
+    });
+    return {
+        latest: parts.snapshot.sequence,
+        runs: Object.fromEntries(timed.map(({ row }) => [row.runId, row.sequence])),
+        times: Object.fromEntries(timed.map(({ row, time }) => [row.runId, time])),
+    };
+}
+function workflowIds(parts) {
+    const wanted = parts.runIds === undefined ? null : new Set(parts.runIds);
+    return Object.fromEntries(parts.snapshot.details.flatMap((row) => {
+        const workflowId = row.submission === null ? null : parts.workflows.get(row.submission);
+        if (typeof workflowId !== "string")
+            return [];
+        return wanted === null || wanted.has(row.runId)
+            ? [[row.runId, workflowId]]
+            : [];
+    }));
+}
+export function operationRecords(snapshot) {
+    const deliveries = Map.groupBy(snapshot.deliveries, (row) => row.operationId);
+    return snapshot.outbox.map((row) => ({
+        operationId: row.operationId,
+        kind: intentKind(row.kind),
+        runId: row.runId,
+        createdSequence: row.createdSequence,
+        releasedSequence: row.releasedSequence,
+        deliveries: (deliveries.get(row.operationId) ?? []).map(({ effectId, outcome, receipt, purpose, epoch }) => ({
+            effectId,
+            outcome,
+            receipt,
+            purpose,
+            epoch,
+        })),
+    }));
+}
+function eligible(parts) {
+    return eligibleIntents({
+        ...parts.state,
+        effects: {
+            operations: Object.fromEntries(parts.snapshot.pending.map((operationId) => [
+                operationId,
+                { status: "dispatch-pending" },
+            ])),
+        },
+    });
+}

package/dist/src/broker/actor/runtime-parts.d.ts

@@ -1,4 +1,5 @@
 import { type ActorClass, type Database, type InstrumentationEvent, type SolidObjectsConfiguration, type SolidObjectsRuntime } from "solid-objects";
+import { type DomainChange } from "../../storage/domain-changes.ts";
 import { type AuthorityTiming } from "./authority-settings.ts";
 import type { StrandingWatchdog } from "./authority-watchdog.ts";
 export interface FailedDelivery {
@@ -20,4 +21,8 @@ export declare function registeredRuntime(registration: {
     readonly database: Database;
     readonly actor: ActorClass;
     readonly settings: Partial<SolidObjectsConfiguration>;
+    readonly record: (recorded: {
+        readonly messageId: string;
+        readonly change: DomainChange;
+    }) => void;
 }): SolidObjectsRuntime;

package/dist/src/broker/actor/runtime-parts.js

@@ -1,5 +1,5 @@
 import { createRuntime, } from "solid-objects";
-import { persistChange } from "../../storage/domain-changes.js";
+import { persistChange, } from "../../storage/domain-changes.js";
 import { persistAction } from "./authority-actor.js";
 import { brokerAuthorization } from "./authority-policy.js";
 import { librarySettings } from "./authority-settings.js";
@@ -26,9 +26,14 @@ export function runtimeSettings(parts) {
     };
 }
 export function registeredRuntime(registration) {
-    const { database, actor, settings } = registration;
+    const { database, actor, settings, record } = registration;
     const runtime = createRuntime({ database, ...settings });
     runtime.register(actor);
-    runtime.registerCommitAction(persistAction, (change, context) => persistChange(change, context.connection));
+    runtime.registerCommitAction(persistAction, async (change, context) => {
+        record({
+            messageId: context.messageId,
+            change: await persistChange(change, context.connection),
+        });
+    });
     return runtime;
 }

package/dist/src/broker/authority-restore.js

@@ -133,7 +133,7 @@ export function currentState(snapshot) {
     return {
         ...projectedState(snapshot),
         ...decisionState(snapshot),
-        ...commandWaitState(snapshot.waits ?? []),
+        ...commandWaitState(snapshot.waits),
     };
 }
 export function projectedState(snapshot) {

package/dist/src/broker/effect-upgrade.d.ts

@@ -3,3 +3,4 @@ import type { AuthorityState } from "../authority/reducer.ts";
 export declare function upgradeEffects(database: Database, state: AuthorityState): Promise<void>;
 export declare function upgradeSpendingIndexes(database: Database): Promise<void>;
 export declare function upgradeEventIndexes(database: Database): Promise<void>;
+export declare function upgradeRunIndexes(database: Database): Promise<void>;

package/dist/src/broker/effect-upgrade.js

@@ -1,4 +1,4 @@
-import { currentVersion, effectedVersion, spendingVersion, upgradeSchema, } from "../storage/domain-schema.js";
+import { currentVersion, effectedVersion, eventIndexVersion, spendingVersion, upgradeSchema, } from "../storage/domain-schema.js";
 import { persistEffects } from "../storage/effect-changes.js";
 import { effectRows } from "./effect-restore.js";
 export async function upgradeEffects(database, state) {
@@ -11,5 +11,8 @@ export async function upgradeSpendingIndexes(database) {
     await database.transaction((connection) => upgradeSchema(connection, spendingVersion));
 }
 export async function upgradeEventIndexes(database) {
+    await database.transaction((connection) => upgradeSchema(connection, eventIndexVersion));
+}
+export async function upgradeRunIndexes(database) {
     await database.transaction((connection) => upgradeSchema(connection, currentVersion));
 }

package/dist/src/cli/arguments.js

@@ -12,6 +12,7 @@ const options = {
     version: { type: "boolean", short: "v" },
     input: { type: "string" },
     json: { type: "boolean" },
+    active: { type: "boolean" },
     prompt: { type: "string" },
     ticket: { type: "string" },
     next: { type: "boolean" },

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

@@ -7,7 +7,9 @@ export interface ClientRequest extends ServiceRequest {
     readonly signal?: AbortSignal;
 }
 export declare function send(runtimeDirectory: string, input: ClientRequest): Promise<Reply>;
-export declare function listRuns(runtimeDirectory: string): Promise<Reply>;
+export declare function listRuns(runtimeDirectory: string, selection?: {
+    readonly active?: true;
+}): Promise<Reply>;
 export declare function mutate(runtimeDirectory: string, mutation: {
     readonly request: ServiceRequest;
     readonly signal: Promise<void>;

package/dist/src/cli/client.js

@@ -2,7 +2,7 @@ import net from "node:net";
 import { join } from "node:path";
 import { socketAddress } from "../broker/socket-address.js";
 import { parseReplyLine, record, requestLine, } from "../protocol.js";
-const mutations = ["run", "decision", "run-command"];
+const mutations = ["run", "decision", "run-command", "queue-command"];
 function unavailable(runtimeDirectory) {
     return {
         kind: "error",
@@ -101,10 +101,10 @@ function listedRuns(result) {
         ? runs.map(record).filter((run) => run !== undefined)
         : [];
 }
-export async function listRuns(runtimeDirectory) {
+export async function listRuns(runtimeDirectory, selection = {}) {
     const first = await send(runtimeDirectory, {
         operation: "status",
-        parameters: { limit: 500 },
+        parameters: { ...selection, limit: 500 },
     });
     if (first.kind === "error")
         return first;
@@ -123,7 +123,7 @@ export async function listRuns(runtimeDirectory) {
         after = next;
         const page = await send(runtimeDirectory, {
             operation: "status",
-            parameters: { limit: 500, after },
+            parameters: { ...selection, limit: 500, after },
         });
         if (page.kind === "error")
             return page;

package/dist/src/cli/command-requests.d.ts

@@ -1,12 +1,41 @@
 import { type Fields, type Reply, type ServiceError, type ServiceRequest } from "../protocol.ts";
 import { type ClientRequest } from "./client.ts";
+import type { DecisionCommand, RunCommand, RunSource } from "./runtime-arguments.ts";
 export interface ReadCommand {
-    readonly kind: "status" | "questions" | "events";
+    readonly kind: "status" | "questions" | "events" | "reload";
     readonly runId?: string | null;
     readonly limit?: number | null;
     readonly after?: string | number | null;
+    readonly active?: boolean;
     readonly follow?: boolean;
 }
+export type SubmittedSource = Exclude<RunSource, {
+    readonly kind: "input";
+}> | {
+    readonly kind: "input";
+    readonly submission: Fields;
+};
+export declare function runRequest(run: {
+    readonly workflowId: string;
+    readonly source: SubmittedSource;
+    readonly commandId: string;
+}): ServiceRequest;
+export interface DecisionRequest {
+    readonly command: DecisionCommand;
+    readonly reference: string;
+    readonly text: string | null;
+    readonly expectedRevision: number;
+    readonly generation: number;
+    readonly subjectDigest: string;
+    readonly commandId: string;
+}
+export declare function decisionRequest(decision: DecisionRequest): ServiceRequest;
+export declare function runCommandRequest(request: {
+    readonly command: RunCommand;
+    readonly runId: string;
+    readonly expectedRevision: number;
+    readonly commandId: string;
+}): ServiceRequest;
 export declare function readCommandRequest(command: ReadCommand): ServiceRequest;
 export declare function readCommandReply(runtimeDirectory: string, request: ClientRequest): Promise<Reply>;
 export declare function errorObject(error: ServiceError, format?: {

package/dist/src/cli/command-requests.js

@@ -2,11 +2,52 @@ import {} from "../protocol.js";
 import { send } from "./client.js";
 import { withCiReruns } from "./github-ci-progress.js";
 import { statusJson } from "./render.js";
+function submission(source) {
+    if (source.kind === "input")
+        return source.submission;
+    return source.kind === "prompt"
+        ? { prompt: source.text }
+        : { ticket: source.id };
+}
+export function runRequest(run) {
+    return {
+        operation: "run",
+        parameters: {
+            workflowId: run.workflowId,
+            source: run.source.kind,
+            submission: submission(run.source),
+            commandId: run.commandId,
+        },
+    };
+}
+export function decisionRequest(decision) {
+    return {
+        operation: "decision",
+        parameters: Object.fromEntries(Object.entries(decision).filter(([, value]) => value !== null)),
+    };
+}
+export function runCommandRequest(request) {
+    return {
+        operation: "run-command",
+        parameters: {
+            command: request.command,
+            runId: request.runId,
+            expectedRevision: request.expectedRevision,
+            commandId: request.commandId,
+        },
+    };
+}
 export function readCommandRequest(command) {
-    const { kind, runId, limit, after, follow } = command;
+    const { kind, runId, limit, after, active, follow } = command;
     const parameters = kind === "questions"
         ? { runId }
-        : { runId, limit, after, ...(follow === undefined ? {} : { follow }) };
+        : {
+            runId,
+            limit,
+            after,
+            ...(active === true ? { active } : {}),
+            ...(follow === undefined ? {} : { follow }),
+        };
     return {
         operation: kind,
         parameters: Object.fromEntries(Object.entries(parameters).filter(([, value]) => value !== null && value !== undefined)),

package/dist/src/cli/commands.js

@@ -1,6 +1,7 @@
-import { commandJson, errorObject, readCommandReply, readCommandRequest, } from "./command-requests.js";
+import { commandJson, decisionRequest, errorObject, readCommandReply, readCommandRequest, runCommandRequest, runRequest, } from "./command-requests.js";
 import { reportCommand } from "./report.js";
 import { scheduleServiceRequest } from "./schedule-arguments.js";
+import { queueServiceRequest } from "./queue-arguments.js";
 import { withCiReruns } from "./github-ci-progress.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -55,7 +56,8 @@ function identified(environment, invocation) {
         environment.terminal.error(`Command ID: ${commandId}\n`);
     return { json, commandId, announced: !json };
 }
-async function inputFile(environment, file) {
+async function inputFile(environment, input) {
+    const { file, commandId } = input;
     let text;
     try {
         text = await readFile(resolve(environment.workingDirectory, file), "utf8");
@@ -69,8 +71,9 @@ async function inputFile(environment, file) {
             },
         };
     }
+    let submission;
     try {
-        return { kind: "read", submission: JSON.parse(text) };
+        submission = record(JSON.parse(text));
     }
     catch {
         return {
@@ -81,37 +84,37 @@ async function inputFile(environment, file) {
             },
         };
     }
-}
-function typed(source) {
-    return source.kind === "prompt"
-        ? { prompt: source.text }
-        : { ticket: source.id };
+    if (submission === undefined)
+        return {
+            kind: "error",
+            error: {
+                commandId,
+                detail: "The submission is not an object.",
+                code: "invalid-submission",
+            },
+        };
+    return { kind: "read", source: { kind: "input", submission } };
 }
 async function run(environment, invocation) {
     const format = identified(environment, invocation);
-    const { commandId } = format;
     const { source } = invocation;
     const read = source.kind === "input"
-        ? await inputFile(environment, source.file)
-        : { kind: "read", submission: typed(source) };
+        ? await inputFile(environment, {
+            file: source.file,
+            commandId: format.commandId,
+        })
+        : { kind: "read", source };
     if (read.kind === "error")
         return failed(environment, { error: read.error, format });
     return mutated(environment, {
         format,
-        request: {
-            operation: "run",
-            parameters: {
-                workflowId: invocation.workflowId,
-                source: source.kind,
-                submission: read.submission,
-                commandId,
-            },
-        },
+        request: runRequest({
+            workflowId: invocation.workflowId,
+            source: read.source,
+            commandId: format.commandId,
+        }),
     });
 }
-function present(values) {
-    return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== null));
-}
 async function summarized(environment) {
     const pending = await send(environment.runtimeDirectory, {
         operation: "questions",
@@ -121,11 +124,11 @@ async function summarized(environment) {
         environment.terminal.out(pendingSummary(pending.result));
 }
 async function status(environment, invocation) {
-    const { runId, limit, after, json } = invocation;
+    const { runId, limit, after, active, json } = invocation;
     if (!json && runId === null)
         await summarized(environment);
     if (!json && runId === null && limit === null && after === null) {
-        const reply = await withCiReruns(environment.runtimeDirectory, await listRuns(environment.runtimeDirectory));
+        const reply = await withCiReruns(environment.runtimeDirectory, await listRuns(environment.runtimeDirectory, active ? { active } : {}));
         return presented(environment, {
             format: { json },
             reply: reply.kind === "result"
@@ -140,37 +143,29 @@ async function status(environment, invocation) {
 }
 function decision(environment, invocation) {
     const format = identified(environment, invocation);
-    const { commandId } = format;
     return mutated(environment, {
         format,
-        request: {
-            operation: "decision",
-            parameters: present({
-                command: invocation.command,
-                reference: invocation.reference,
-                text: invocation.text,
-                expectedRevision: invocation.expectedRevision,
-                generation: invocation.generation,
-                subjectDigest: invocation.subjectDigest,
-                commandId,
-            }),
-        },
+        request: decisionRequest({
+            command: invocation.command,
+            reference: invocation.reference,
+            text: invocation.text,
+            expectedRevision: invocation.expectedRevision,
+            generation: invocation.generation,
+            subjectDigest: invocation.subjectDigest,
+            commandId: format.commandId,
+        }),
     });
 }
 function runCommand(environment, invocation) {
     const format = identified(environment, invocation);
-    const { commandId } = format;
     return mutated(environment, {
         format,
-        request: {
-            operation: "run-command",
-            parameters: {
-                command: invocation.command,
-                runId: invocation.runId,
-                expectedRevision: invocation.expectedRevision,
-                commandId,
-            },
-        },
+        request: runCommandRequest({
+            command: invocation.command,
+            runId: invocation.runId,
+            expectedRevision: invocation.expectedRevision,
+            commandId: format.commandId,
+        }),
     });
 }
 async function events(environment, invocation) {
@@ -216,6 +211,8 @@ function located(invocation, environment) {
             format: { json: invocation.json },
             request: scheduleServiceRequest(invocation),
         });
+    if (invocation.kind === "queue")
+        return queue(environment, invocation);
     if (invocation.kind === "report")
         return reportCommand(invocation, environment);
     if (invocation.kind === "run")
@@ -235,6 +232,18 @@ function located(invocation, environment) {
         request: readCommandRequest(invocation),
     });
 }
+function queue(environment, invocation) {
+    if (invocation.action === "show")
+        return requested(environment, {
+            format: { json: invocation.json },
+            request: { operation: "queue", parameters: {} },
+        });
+    const format = identified(environment, invocation);
+    return mutated(environment, {
+        format,
+        request: queueServiceRequest(invocation, format.commandId),
+    });
+}
 function watch(environment, invocation) {
     return watchServer({
         actions: environment.watchActions ?? "on",

package/dist/src/cli/config-notice.js

@@ -1,6 +1,7 @@
 import net from "node:net";
 import { join } from "node:path";
 import { socketAddress } from "../broker/socket-address.js";
+import { reloadedSettingFields } from "../project-settings.js";
 import { runtimeDirectory } from "./runtime-directory.js";
 function serviceDirectory(repository) {
     try {
@@ -40,7 +41,9 @@ export async function configNotice(repository, input) {
     const source = input.entry?.source;
     const hidden = source === "environment" ||
         (input.scope === "project" && source === "private");
-    return hidden
-        ? `The ${source} source hides this file value. A restart keeps the value of that source.`
+    if (hidden)
+        return `The ${source} source hides this file value. A restart keeps the value of that source.`;
+    return reloadedSettingFields.includes(String(input.entry?.field))
+        ? "Run cloving reload to use the new value."
         : "Restart the service to use the new value.";
 }

package/dist/src/cli/doctor-retention.d.ts

@@ -0,0 +1,2 @@
+import type { DoctorObservation } from "../doctor-report.ts";
+export declare function retentionObservation(state: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<DoctorObservation>;