@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/node-transactions.js

@@ -0,0 +1,223 @@
+import { requireAutomationResultCapacity } from "./result-capacity.js";
+import { settleTerminalUndispatchedAdmission } from "./terminal-admission-receipt.js";
+function requireExecution(state, runId) {
+    const execution = state.executions.find((item) => item.id === runId);
+    if (!execution)
+        throw new Error("automation_run_not_found");
+    return execution;
+}
+function requireNode(execution, nodeId) {
+    const node = execution.nodes.find((item) => item.nodeId === nodeId);
+    if (!node)
+        throw new Error("automation_node_not_found");
+    return node;
+}
+function replaceExecution(state, current, patch) {
+    const next = { ...current, ...patch, revision: current.revision + 1 };
+    const index = state.executions.findIndex((item) => item.id === current.id);
+    state.executions[index] = next;
+    return next;
+}
+function replaceNode(execution, nodeId, patch) {
+    return execution.nodes.map((node) => node.nodeId === nodeId ? { ...node, ...patch } : node);
+}
+export function createAutomationNodeTransactions(options) {
+    const now = options.now ?? Date.now;
+    async function begin(input) {
+        return options.persistence.update((state) => {
+            const claimed = state.executions.find((item) => item.id === input.runId);
+            if (claimed && (claimed.automationId !== input.automationId ||
+                claimed.definitionRevision !== input.definitionRevision ||
+                claimed.stopRequestedAt || claimed.reportRef || claimed.nodes.length > 0 ||
+                claimed.inputIds.length !== input.inputIds.length ||
+                claimed.inputIds.some((id, index) => id !== input.inputIds[index])))
+                throw new Error("automation_run_already_started");
+            const execution = {
+                id: input.runId,
+                automationId: input.automationId,
+                definitionRevision: input.definitionRevision,
+                revision: claimed ? claimed.revision + 1 : 1,
+                inputIds: [...input.inputIds],
+                nodes: input.graph.steps.map((step) => ({ nodeId: step.id, status: "pending" })),
+            };
+            if (claimed) {
+                state.executions[state.executions.indexOf(claimed)] = execution;
+            }
+            else {
+                state.executions.push(execution);
+            }
+            return execution;
+        });
+    }
+    async function startNode(runId, nodeId) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, runId);
+            const node = requireNode(execution, nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "pending")
+                throw new Error("automation_run_locked");
+            replaceExecution(state, execution, {
+                nodes: replaceNode(execution, nodeId, { status: "running" }),
+            });
+        });
+    }
+    async function recordAttempt(input) {
+        return options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            const node = requireNode(execution, input.nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "running" || node.attemptId)
+                throw new Error("automation_run_locked");
+            if (state.attempts.some((item) => item.invocationId === input.invocationId))
+                throw new Error("automation_attempt_duplicate");
+            if (input.maxToolCalls !== undefined &&
+                state.attempts.filter((item) => item.runId === input.runId).length >= input.maxToolCalls)
+                throw new Error("automation_tool_call_limit_reached");
+            const attempt = {
+                id: input.invocationId,
+                runId: input.runId,
+                nodeId: input.nodeId,
+                invocationId: input.invocationId,
+                fingerprint: input.fingerprint,
+                state: "started",
+                startedAt: new Date(now()).toISOString(),
+            };
+            state.attempts.push(attempt);
+            replaceExecution(state, execution, {
+                nodes: replaceNode(execution, input.nodeId, { attemptId: attempt.id }),
+            });
+            return attempt;
+        });
+    }
+    async function recordAgentAttempt(input) {
+        return options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            const node = requireNode(execution, input.nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "running")
+                throw new Error("automation_run_locked");
+            if (state.attempts.some((item) => item.invocationId === input.invocationId))
+                throw new Error("automation_attempt_duplicate");
+            if (state.attempts.filter((item) => item.runId === input.runId).length >= input.maxToolCalls)
+                throw new Error("automation_tool_call_limit_reached");
+            const attempt = {
+                id: input.invocationId,
+                runId: input.runId,
+                nodeId: input.nodeId,
+                invocationId: input.invocationId,
+                fingerprint: input.fingerprint,
+                state: "started",
+                startedAt: new Date(now()).toISOString(),
+            };
+            state.attempts.push(attempt);
+            replaceExecution(state, execution, {});
+            return attempt;
+        });
+    }
+    async function recordModelCall(runId, nodeId, maxModelCalls) {
+        return options.persistence.update((state) => {
+            const execution = requireExecution(state, runId);
+            const node = requireNode(execution, nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "running")
+                throw new Error("automation_run_locked");
+            const count = execution.modelCalls ?? 0;
+            if (count >= maxModelCalls)
+                throw new Error("automation_model_call_limit_reached");
+            replaceExecution(state, execution, { modelCalls: count + 1 });
+            return count + 1;
+        });
+    }
+    async function settleAgentAttempt(input) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            requireNode(execution, input.nodeId);
+            const isTerminalUndispatchedAdmission = Boolean(execution.reportRef) && input.notDispatched === true;
+            if (isTerminalUndispatchedAdmission)
+                return settleTerminalUndispatchedAdmission({
+                    ...input, state, execution, resultKind: "effect_receipt", now: now(),
+                });
+            const index = state.attempts.findIndex((item) => item.id === input.invocationId && item.runId === input.runId && item.nodeId === input.nodeId);
+            if (index < 0 || state.attempts[index].state !== "started")
+                throw new Error("automation_attempt_mismatch");
+            if (input.result.runId !== input.runId || input.result.nodeId !== input.nodeId ||
+                input.result.kind !== "effect_receipt")
+                throw new Error("automation_result_ref_invalid");
+            const used = state.results.filter((item) => item.runId === input.runId)
+                .reduce((total, item) => total + item.sizeBytes, input.result.sizeBytes);
+            if (used > input.maxStoredArtifactBytes)
+                throw new Error("automation_artifact_budget_exhausted");
+            requireAutomationResultCapacity(state, input.result.sizeBytes);
+            state.results.push(input.result);
+            state.attempts[index] = {
+                ...state.attempts[index],
+                state: input.uncertain ? "uncertain" : "settled",
+                settledAt: new Date(now()).toISOString(),
+                settlementRef: input.result.id,
+            };
+            replaceExecution(state, execution, {});
+        });
+    }
+    async function hasUnsettledEffect(runId, nodeId) {
+        const state = await options.persistence.read();
+        return state.attempts.some((item) => item.runId === runId && item.nodeId === nodeId &&
+            (item.state === "started" || item.state === "uncertain"));
+    }
+    async function settleNode(input) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            const node = requireNode(execution, input.nodeId);
+            const isTerminalUndispatchedAdmission = Boolean(execution.reportRef) && input.notDispatched === true;
+            if (isTerminalUndispatchedAdmission)
+                return settleTerminalUndispatchedAdmission({
+                    ...input, state, execution, invocationId: input.attemptId, result: input.result,
+                    maxStoredArtifactBytes: input.maxStoredArtifactBytes, resultKind: "node_output", now: now(),
+                });
+            if (execution.reportRef)
+                throw new Error("automation_run_locked");
+            if (node.status !== "running" && node.status !== "pending")
+                throw new Error("automation_node_already_settled");
+            if (node.attemptId !== input.attemptId)
+                throw new Error("automation_attempt_mismatch");
+            if (input.result) {
+                if (input.result.runId !== input.runId || input.result.nodeId !== input.nodeId)
+                    throw new Error("automation_result_ref_invalid");
+                if (input.maxStoredArtifactBytes !== undefined &&
+                    state.results.filter((item) => item.runId === input.runId)
+                        .reduce((total, item) => total + item.sizeBytes, input.result.sizeBytes) >
+                        input.maxStoredArtifactBytes)
+                    throw new Error("automation_artifact_budget_exhausted");
+                requireAutomationResultCapacity(state, input.result.sizeBytes);
+                state.results.push(input.result);
+            }
+            if (input.attemptId) {
+                const index = state.attempts.findIndex((item) => item.id === input.attemptId);
+                if (index < 0 || state.attempts[index].state !== "started")
+                    throw new Error("automation_attempt_mismatch");
+                state.attempts[index] = {
+                    ...state.attempts[index],
+                    state: input.uncertain ? "uncertain" : "settled",
+                    settledAt: new Date(now()).toISOString(),
+                    ...(input.result ? { settlementRef: input.result.id } : {}),
+                };
+            }
+            replaceExecution(state, execution, {
+                nodes: replaceNode(execution, input.nodeId, {
+                    status: input.status,
+                    ...(input.result ? { resultRef: input.result.id } : {}),
+                    ...(input.errorCode ? { errorCode: input.errorCode } : {}),
+                }),
+            });
+        });
+    }
+    async function requestStop(runId) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, runId);
+            if (execution.stopRequestedAt)
+                return;
+            replaceExecution(state, execution, { stopRequestedAt: new Date(now()).toISOString() });
+        });
+    }
+    async function get(runId) {
+        const state = await options.persistence.read();
+        return state.executions.find((item) => item.id === runId) ?? null;
+    }
+    return { begin, startNode, recordAttempt, recordAgentAttempt,
+        recordModelCall, settleAgentAttempt, hasUnsettledEffect, settleNode, requestStop, get };
+}

package/dist/src/runtime/automations/occurrence-preparation.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { RuntimeConfig } from "../ports.js";
+import type { SchedulerAutomationExecutor } from "../scheduler/contracts.js";
+import { type AutomationSnapshotStaging } from "./snapshot-staging.js";
+import type { AutomationPersistence } from "./persistence.js";
+export declare function createAutomationOccurrencePreparer(options: {
+    config: RuntimeConfig;
+    persistence: AutomationPersistence;
+    attachments: RuntimeAttachmentStore;
+    snapshots?: AutomationSnapshotStaging;
+    now?: () => number;
+}): SchedulerAutomationExecutor["prepare"];

package/dist/src/runtime/automations/occurrence-preparation.js

@@ -0,0 +1,257 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { selectAutomationInputBatch } from "./input-batch-selection.js";
+import { createAutomationSnapshotStaging } from "./snapshot-staging.js";
+import { baselineFileRecord, cachedContentVersion, commitInputObservation, eligibleFileRecord, findSourceVersion, hasSourceBaseline, isReusableSourceInput, MAX_INPUT_SNAPSHOT_BYTES, recordsForSource, sourceBaselineMarker, } from "./input-ledger.js";
+import { captureSourceFile, discoverSourceFiles, } from "./source-discovery.js";
+function sourceFailure(error) {
+    if (error instanceof Error && error.message === "automation_source_changed")
+        return "automation_source_changed";
+    if (error instanceof Error && error.message === "automation_source_capacity_exceeded")
+        return "automation_source_capacity_exceeded";
+    return "automation_source_unavailable";
+}
+function failedForJob(job, error, terminalAt) {
+    return {
+        kind: "failed",
+        error,
+        commit: (state, runId) => {
+            state.executions.push({
+                id: runId,
+                automationId: job.target.automationId,
+                definitionRevision: job.target.definitionRevision,
+                revision: 1,
+                inputIds: [],
+                nodes: [],
+                reportRef: `derived:${runId}`,
+                terminalAt,
+            });
+        },
+    };
+}
+function sourceFree(job) {
+    return {
+        kind: "ready",
+        inputIds: [],
+        commit: (state, runId) => {
+            state.executions.push({
+                id: runId,
+                automationId: job.target.automationId,
+                definitionRevision: job.target.definitionRevision,
+                revision: 1,
+                inputIds: [],
+                nodes: [],
+            });
+        },
+    };
+}
+async function planSource(input) {
+    const discovered = await discoverSourceFiles({
+        source: input.source,
+        paths: input.config.paths,
+        now: input.now,
+    });
+    const records = recordsForSource(input.state, input.definition.automationId, input.source.sourceId);
+    const firstScan = !hasSourceBaseline(records, discovered.root);
+    if (firstScan && !input.source.includeExisting && discovered.unstableCount > 0)
+        return "unstable_baseline";
+    const establishExcludingBaseline = firstScan && !input.source.includeExisting;
+    const excludedInputIds = [];
+    const baselineFiles = [];
+    const candidates = [];
+    const refresh = [];
+    for (const file of discovered.files) {
+        const cached = cachedContentVersion(file, records);
+        const captured = cached ? undefined : await captureSourceFile(file);
+        const version = cached ?? captured.contentVersion;
+        const existing = findSourceVersion(records, file.canonicalPath, version);
+        const existingVersionNeedsBaseline = existing && establishExcludingBaseline;
+        if (existingVersionNeedsBaseline) {
+            excludedInputIds.push(existing.id);
+            continue;
+        }
+        if (existing) {
+            if (!cached)
+                refresh.push({
+                    recordId: existing.id, file, observedAt: input.observedAt,
+                });
+            if (isReusableSourceInput(existing, records, discovered.root))
+                candidates.push({ file, existing });
+            continue;
+        }
+        if (establishExcludingBaseline) {
+            baselineFiles.push(baselineFileRecord({
+                automationId: input.definition.automationId,
+                sourceId: input.source.sourceId,
+                file: captured,
+                observedAt: input.observedAt,
+            }));
+            continue;
+        }
+        candidates.push({ file, contentVersion: version });
+    }
+    const marker = firstScan ? sourceBaselineMarker({
+        automationId: input.definition.automationId,
+        sourceId: input.source.sourceId,
+        root: discovered.root,
+        observedAt: input.observedAt,
+        excludedInputIds,
+    }) : undefined;
+    return { marker, baselineFiles, candidates, refresh };
+}
+function selectedCandidates(definition, source, candidates) {
+    const threshold = definition.trigger.kind === "folder"
+        ? definition.trigger.minimumEligibleFiles : 1;
+    const maxFiles = source.mode === "per_file" ? 1 : source.maxBatchFiles;
+    return selectAutomationInputBatch(candidates, threshold, maxFiles);
+}
+function verifyPlanFits(state, plan, newFiles, existingIds, runId) {
+    const preview = structuredClone(state);
+    commitInputObservation({
+        state: preview,
+        marker: plan.marker,
+        baselineFiles: plan.baselineFiles,
+        newFiles,
+        selectedExistingIds: existingIds,
+        refresh: plan.refresh,
+        runId,
+    });
+}
+export function createAutomationOccurrencePreparer(options) {
+    const snapshots = options.snapshots ?? createAutomationSnapshotStaging({
+        runtimeDir: options.config.paths.runtimeDir, persistence: options.persistence,
+        attachments: options.attachments,
+    });
+    return async (job, candidateRunId) => {
+        const now = options.now?.() ?? Date.now();
+        const observedAt = new Date(now).toISOString();
+        const state = await options.persistence.read();
+        const definition = state.definitions.find((item) => item.automationId === job.target.automationId &&
+            item.revision === job.target.definitionRevision)?.definition;
+        if (!definition)
+            return failedForJob(job, "automation_definition_not_found", observedAt);
+        if (!definition.source) {
+            return definition.trigger.kind === "folder"
+                ? failedForJob(job, "automation_source_unavailable", observedAt)
+                : sourceFree(job);
+        }
+        let plan;
+        try {
+            await snapshots.reconcile();
+            plan = await planSource({
+                definition,
+                source: definition.source,
+                state,
+                config: options.config,
+                observedAt,
+                now,
+            });
+        }
+        catch (error) {
+            const code = sourceFailure(error);
+            return code === "automation_source_changed"
+                ? { kind: "no_input" }
+                : failedForJob(job, code, observedAt);
+        }
+        if (plan === "unstable_baseline")
+            return { kind: "no_input" };
+        let selected;
+        try {
+            selected = selectedCandidates(definition, definition.source, plan.candidates);
+        }
+        catch (error) {
+            return failedForJob(job, sourceFailure(error), observedAt);
+        }
+        if (selected.length === 0) {
+            try {
+                verifyPlanFits(state, plan, [], []);
+            }
+            catch (error) {
+                return failedForJob(job, sourceFailure(error), observedAt);
+            }
+            return {
+                kind: "no_input",
+                commit: plan.marker || plan.baselineFiles.length || plan.refresh.length
+                    ? (current) => commitInputObservation({
+                        state: current,
+                        marker: plan.marker,
+                        baselineFiles: plan.baselineFiles,
+                        refresh: plan.refresh,
+                    })
+                    : undefined,
+            };
+        }
+        const retainedBytes = state.inputs.reduce((bytes, record) => bytes + (record.snapshot?.sizeBytes ?? 0), 0);
+        const newBytes = selected.reduce((bytes, candidate) => bytes + (candidate.existing ? 0 : candidate.file.sizeBytes), 0);
+        if (retainedBytes + newBytes > MAX_INPUT_SNAPSHOT_BYTES)
+            return failedForJob(job, "automation_source_capacity_exceeded", observedAt);
+        const newFiles = [];
+        const existingIds = [];
+        try {
+            const needsNewSnapshots = selected.some((candidate) => !candidate.existing);
+            if (needsNewSnapshots)
+                await snapshots.begin(candidateRunId);
+            for (const candidate of selected) {
+                if (candidate.existing) {
+                    existingIds.push(candidate.existing.id);
+                    continue;
+                }
+                const captured = await captureSourceFile(candidate.file);
+                if (captured.contentVersion !== candidate.contentVersion)
+                    throw new Error("automation_source_changed");
+                const id = randomUUID();
+                const attachment = await options.attachments.saveAttachment({
+                    sessionId: candidateRunId,
+                    requestId: id,
+                    kind: captured.kind,
+                    mimeType: captured.mimeType,
+                    bytes: captured.bytes,
+                    name: basename(captured.canonicalPath),
+                });
+                newFiles.push(eligibleFileRecord({
+                    id,
+                    automationId: definition.automationId,
+                    sourceId: definition.source.sourceId,
+                    file: captured,
+                    observedAt,
+                    attachment,
+                }));
+            }
+            verifyPlanFits(state, plan, newFiles, existingIds, candidateRunId);
+        }
+        catch (error) {
+            await snapshots.discard(candidateRunId);
+            const code = sourceFailure(error);
+            return code === "automation_source_changed"
+                ? { kind: "no_input" }
+                : failedForJob(job, code, observedAt);
+        }
+        const inputIds = [...existingIds, ...newFiles.map((record) => record.id)];
+        return {
+            kind: "ready",
+            inputIds,
+            commit: (current, runId) => {
+                commitInputObservation({
+                    state: current,
+                    marker: plan.marker,
+                    baselineFiles: plan.baselineFiles,
+                    newFiles,
+                    selectedExistingIds: existingIds,
+                    refresh: plan.refresh,
+                    runId,
+                });
+                current.executions.push({
+                    id: runId,
+                    automationId: job.target.automationId,
+                    definitionRevision: job.target.definitionRevision,
+                    revision: 1,
+                    inputIds,
+                    nodes: [],
+                });
+            },
+            discard: newFiles.length > 0
+                ? () => snapshots.discard(candidateRunId)
+                : undefined,
+        };
+    };
+}

package/dist/src/runtime/automations/permission-grants.d.ts

@@ -0,0 +1,27 @@
+import type { SchedulerToolPermissionMode } from "../scheduler/tool-permission-mode.js";
+import type { OperationRef } from "./definition-contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationGrantRecord } from "./storage-records.js";
+export declare function sameOperation(left: OperationRef, right: OperationRef): boolean;
+export type GrantableAutomationOperation = Readonly<{
+    operation: OperationRef;
+    requiredMode: SchedulerToolPermissionMode;
+}>;
+export declare function currentAutomationGrant(records: readonly AutomationGrantRecord[], environmentId: string, automationId: string): AutomationGrantRecord | null;
+export declare function permitsAutomationOperation(grant: AutomationGrantRecord | null, environmentId: string, automationId: string, selected: OperationRef, requiredMode: SchedulerToolPermissionMode): boolean;
+export declare function createAutomationGrantManager(options: {
+    persistence: AutomationPersistence;
+    environmentId: string;
+    availableOperations: () => Promise<readonly GrantableAutomationOperation[]>;
+    now?: () => number;
+}): {
+    get: (automationId: string) => Promise<AutomationGrantRecord | null>;
+    replace: (input: {
+        automationId: string;
+        expectedGrantRevision: number;
+        mode: SchedulerToolPermissionMode;
+        operations: readonly OperationRef[];
+        actionId: string;
+    }) => Promise<AutomationGrantRecord>;
+};
+export type AutomationGrantManager = ReturnType<typeof createAutomationGrantManager>;

package/dist/src/runtime/automations/permission-grants.js

@@ -0,0 +1,72 @@
+import { randomUUID } from "node:crypto";
+import { requireUnarchivedAutomation } from "./archive-management.js";
+export function sameOperation(left, right) {
+    return left.toolName === right.toolName &&
+        left.operationId === right.operationId &&
+        left.contractVersion === right.contractVersion;
+}
+function operationKey(ref) {
+    return `${ref.toolName}\u0000${ref.operationId}\u0000${ref.contractVersion}`;
+}
+export function currentAutomationGrant(records, environmentId, automationId) {
+    return records
+        .filter((item) => item.environmentId === environmentId && item.automationId === automationId)
+        .reduce((latest, item) => !latest || item.grantRevision > latest.grantRevision ? item : latest, null);
+}
+export function permitsAutomationOperation(grant, environmentId, automationId, selected, requiredMode) {
+    if (!grant || grant.environmentId !== environmentId || grant.automationId !== automationId)
+        return false;
+    if (requiredMode === "full_plus" && grant.mode !== "full_plus")
+        return false;
+    return grant.operations.some((operation) => sameOperation(operation, selected));
+}
+export function createAutomationGrantManager(options) {
+    const now = options.now ?? Date.now;
+    async function get(automationId) {
+        const state = await options.persistence.read();
+        return currentAutomationGrant(state.grants, options.environmentId, automationId);
+    }
+    async function replace(input) {
+        if (!Number.isSafeInteger(input.expectedGrantRevision) || input.expectedGrantRevision < 0)
+            throw new Error("automation_grant_revision_conflict");
+        if (input.mode !== "full_access" && input.mode !== "full_plus")
+            throw new Error("automation_grant_invalid");
+        if (!input.actionId || input.actionId.length > 128 || input.operations.length > 64)
+            throw new Error("automation_grant_invalid");
+        const available = await options.availableOperations();
+        const keys = new Set();
+        for (const operation of input.operations) {
+            const key = operationKey(operation);
+            const current = available.find((candidate) => sameOperation(candidate.operation, operation));
+            if (keys.has(key) || !current)
+                throw new Error("automation_operation_unavailable");
+            if (current.requiredMode === "full_plus" && input.mode !== "full_plus")
+                throw new Error("automation_grant_invalid");
+            keys.add(key);
+        }
+        return options.persistence.update((state) => {
+            if (!state.drafts.some((item) => item.automationId === input.automationId))
+                throw new Error("automation_not_found");
+            requireUnarchivedAutomation(state, input.automationId);
+            const previous = currentAutomationGrant(state.grants, options.environmentId, input.automationId);
+            if ((previous?.grantRevision ?? 0) !== input.expectedGrantRevision)
+                throw new Error("automation_grant_revision_conflict");
+            const grant = {
+                id: randomUUID(),
+                automationId: input.automationId,
+                environmentId: options.environmentId,
+                grantRevision: input.expectedGrantRevision + 1,
+                mode: input.mode,
+                operations: structuredClone(input.operations),
+                evidence: {
+                    kind: "authenticated_user_action",
+                    actionId: input.actionId,
+                    at: new Date(now()).toISOString(),
+                },
+            };
+            state.grants.push(grant);
+            return grant;
+        });
+    }
+    return { get, replace };
+}

package/dist/src/runtime/automations/persistence.d.ts

@@ -0,0 +1,9 @@
+import type { SchedulerSnapshot, SchedulerStore } from "../scheduler/contracts.js";
+import type { AutomationJournalState } from "./storage-records.js";
+/** One durable owner: this facade delegates to the scheduler journal and lease. */
+export declare function createAutomationPersistence(store: SchedulerStore): {
+    read: () => Promise<AutomationJournalState>;
+    update: <T>(mutate: (state: AutomationJournalState) => T) => Promise<T>;
+    updateWithScheduler: <T>(mutate: (scheduler: SchedulerSnapshot, automations: AutomationJournalState) => T) => Promise<T>;
+};
+export type AutomationPersistence = ReturnType<typeof createAutomationPersistence>;

package/dist/src/runtime/automations/persistence.js

@@ -0,0 +1,13 @@
+/** One durable owner: this facade delegates to the scheduler journal and lease. */
+export function createAutomationPersistence(store) {
+    const read = store.readAutomations?.bind(store);
+    const update = store.updateAutomations?.bind(store);
+    const updateWithScheduler = store.updateWithAutomations?.bind(store);
+    if (!read || !update || !updateWithScheduler)
+        throw new Error("automation_store_unavailable");
+    return {
+        read: () => read(),
+        update: (mutate) => update(mutate),
+        updateWithScheduler: (mutate) => updateWithScheduler(mutate),
+    };
+}

package/dist/src/runtime/automations/publication-validation.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeConfig } from "../ports.js";
+import type { AutomationRevision } from "./definition-contracts.js";
+import { type AutomationGraphIssue } from "./graph-validation.js";
+import type { AutomationCatalogOperation } from "./catalog.js";
+import { type AutomationScheduleTiming } from "../scheduler/automation-schedule.js";
+export declare function validateAutomationPublication(input: {
+    definition: AutomationRevision;
+    config: RuntimeConfig;
+    operations: readonly AutomationCatalogOperation[];
+    grantMode: "full_access" | "full_plus";
+    now?: number;
+    timeZone?: string;
+    /** Replaying a frozen run does not create a new scheduled occurrence. */
+    checkScheduleReadiness?: boolean;
+    existingSchedule?: AutomationScheduleTiming;
+}): readonly AutomationGraphIssue[];