@xopcai/xopc 0.0.332 → 0.0.333

package/dist/src/automations/capabilities/write.js

@@ -1,4 +1,4 @@
-import { AutomationCancelOutputSchema, AutomationDeleteInputSchema, AutomationDeleteOutputSchema, AutomationMutationOutputSchema, AutomationReadAllInputSchema, AutomationReadAllOutputSchema, AutomationReadOutputSchema, AutomationRunMutationOutputSchema, AutomationSetEnabledInputSchema, CapabilityResourceInputSchema } from "../../../packages/gateway-contract/src/capabilities.js";
+import { AutomationCancelOutputSchema, AutomationDeleteInputSchema, AutomationDeleteOutputSchema, AutomationMutationOutputSchema, AutomationReadAllInputSchema, AutomationReadAllOutputSchema, AutomationReadOutputSchema, AutomationRecoveryOutputSchema, AutomationReplayEventInputSchema, AutomationRetryDeliveryInputSchema, AutomationRunMutationOutputSchema, AutomationSetEnabledInputSchema, CapabilityResourceInputSchema } from "../../../packages/gateway-contract/src/capabilities.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
@@ -6,6 +6,8 @@ import { CreateAutomationSchema, UpdateAutomationSchema } from "../domain/valida
 import { getAutomation } from "../storage/automation-repository.js";
 import { getAutomationRun, markAllAutomationRunsRead, markAutomationRunRead } from "../storage/automation-run-repository.js";
 import "../storage/index.js";
+import { getAutomationEventForRun } from "../events/event-repository.js";
+import "../events/index.js";
 import { AutomationAlreadyExistsError, AutomationAlreadyRunningError } from "../service/automation-service.js";
 import { z } from "zod";
 //#region src/automations/capabilities/write.ts
@@ -44,6 +46,36 @@ function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 	const requireProject = (id) => {
 		if (id && !projects?.get(id)) throw new CapabilityError("NOT_FOUND", "Project not found");
 	};
+	dispatcher.register(defineAtomicCapability({
+		...policy,
+		id: "xopc.automations.replay_event",
+		description: "Replay dead-letter projection and run-delivery work for one immutable event.",
+		input: AutomationReplayEventInputSchema,
+		output: AutomationRecoveryOutputSchema,
+		execute({ id }) {
+			if (!service.replayEventAtomically(id)) throw new CapabilityError("NOT_FOUND", "Dead-letter event work not found");
+			return {
+				ok: true,
+				accepted: true
+			};
+		},
+		afterCommit: () => service.dispatchRecoveryWork()
+	}));
+	dispatcher.register(defineAtomicCapability({
+		...policy,
+		id: "xopc.automations.retry_delivery",
+		description: "Retry one dead-letter result destination using its stable delivery identity.",
+		input: AutomationRetryDeliveryInputSchema,
+		output: AutomationRecoveryOutputSchema,
+		execute({ runId, destinationKey }) {
+			if (!service.retryResultDeliveryAtomically(runId, destinationKey)) throw new CapabilityError("NOT_FOUND", "Dead-letter result delivery not found");
+			return {
+				ok: true,
+				accepted: true
+			};
+		},
+		afterCommit: () => service.dispatchRecoveryWork()
+	}));
 	dispatcher.register(defineAtomicCapability({
 		...policy,
 		id: "xopc.automations.cancel",
@@ -91,13 +123,30 @@ function registerAutomationWriteCapabilities(dispatcher, service, projects) {
 		description: command === "run" ? "Queue a manual run with the currently accepted execution configuration." : "Queue a rerun with current configuration and the original trigger event.",
 		input: CapabilityResourceInputSchema,
 		output: AutomationRunMutationOutputSchema,
-		execute({ id }) {
+		execute({ id }, context) {
 			const automationId = command === "run" ? id : getAutomationRun(id)?.automationId;
 			const automation = automationId ? getAutomation(automationId) : null;
 			if (!automation) throw new CapabilityError("NOT_FOUND", "Automation or source run not found");
 			assertManagedOperation(automation, "run");
 			try {
-				const run = command === "run" ? service.queueRunAtomically(id) : service.queueRerunAtomically(id);
+				const request = {
+					id: `${command}:${context.operationId}`,
+					type: command === "run" ? "automation.manual.requested" : "automation.rerun.requested",
+					source: "user",
+					trust: "user",
+					subject: {
+						kind: "automation",
+						id: automation.id
+					},
+					correlationId: context.operationId,
+					dedupeKey: context.idempotencyKey,
+					payload: command === "run" ? { automationId: automation.id } : {
+						automationId: automation.id,
+						previousRunId: id
+					}
+				};
+				const executionEvent = command === "rerun" ? getAutomationEventForRun(id) ?? request : request;
+				const run = service.queueTriggerAtomically(automation.id, request, executionEvent);
 				return {
 					ok: true,
 					automation: { ...automation },

package/dist/src/automations/delivery/delivery-router.d.ts

@@ -0,0 +1,50 @@
+import type { Automation, AutomationArtifact, AutomationResultDeliveryRecord, AutomationResultEnvelope, AutomationRun, AutomationRunDeliveryContext } from '../domain/types.js';
+type AutomationDeliveryHandler = (input: {
+    deliveryId: string;
+    attempt: number;
+    run: AutomationRun;
+    result: AutomationResultEnvelope;
+    config: Record<string, unknown>;
+    signal: AbortSignal;
+}) => void | Promise<void>;
+export declare function listAutomationResultDeliveries(input?: {
+    runId?: string;
+    status?: AutomationResultDeliveryRecord['status'];
+    limit?: number;
+}): AutomationResultDeliveryRecord[];
+export declare function retryAutomationResultDelivery(runId: string, destinationKey: string): boolean;
+export declare function getAutomationResultDeliveryMetrics(): {
+    pending: number;
+    deadLetters: number;
+    activeLeases: number;
+};
+export declare class AutomationDeliveryRouter {
+    private readonly options;
+    private active?;
+    private timer?;
+    private readonly handlers;
+    private readonly owner;
+    private readonly abortController;
+    constructor(options?: {
+        deliverGatewayEvent?: (run: AutomationRun, context: AutomationRunDeliveryContext) => void | Promise<void>;
+        onDeadLetter?: (input: {
+            phase: 'result_delivery';
+            runId: string;
+            destinationKey: string;
+            error: string;
+        }) => void;
+        fetch?: typeof fetch;
+    });
+    register(kind: string, handler: AutomationDeliveryHandler): void;
+    validateArtifacts(artifacts: AutomationArtifact[]): void;
+    enqueue(run: AutomationRun, automation: Automation, suppliedArtifacts?: AutomationArtifact[]): void;
+    start(): void;
+    stop(): Promise<void>;
+    dispatch(): Promise<number>;
+    private claim;
+    private runDispatch;
+    private release;
+    private fail;
+    private postWebhook;
+}
+export {};

package/dist/src/automations/delivery/delivery-router.js

@@ -0,0 +1,318 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getAutomationRun } from "../storage/automation-run-repository.js";
+import "../storage/index.js";
+import { getAutomationEventForRun } from "../events/event-repository.js";
+import { assertUrlSafe } from "../../agent/tools/url-safety.js";
+import "../events/index.js";
+import { resolveAutomationWebhookSecret } from "../webhook-secrets.js";
+import { createHmac, randomUUID } from "node:crypto";
+//#region src/automations/delivery/delivery-router.ts
+init_transaction();
+init_logger();
+const log = createLogger("AutomationDeliveryRouter");
+const MAX_ATTEMPTS = 5;
+const LEASE_MS = 45e3;
+const MAX_INLINE_ARTIFACT_BYTES = 64 * 1024;
+function listAutomationResultDeliveries(input = {}) {
+	const clauses = [];
+	const params = [];
+	if (input.runId) {
+		clauses.push("run_id = ?");
+		params.push(input.runId);
+	}
+	if (input.status) {
+		clauses.push("status = ?");
+		params.push(input.status);
+	}
+	params.push(Math.max(1, Math.min(200, Math.floor(input.limit ?? 50))));
+	return getSqliteDatabase().prepare(`SELECT delivery_id, run_id, destination_key, kind, status, config_json,
+    attempts, next_attempt_at_ms, last_error, created_at_ms, updated_at_ms
+    FROM automation_result_deliveries ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""}
+    ORDER BY created_at_ms DESC, run_id DESC, destination_key LIMIT ?`).all(...params).map((row) => ({
+		runId: row.run_id,
+		destinationKey: row.destination_key,
+		kind: row.kind,
+		status: row.status,
+		attempts: row.attempts,
+		nextAttemptAtMs: row.next_attempt_at_ms,
+		...row.last_error ? { lastError: row.last_error } : {},
+		createdAtMs: row.created_at_ms,
+		updatedAtMs: row.updated_at_ms
+	}));
+}
+function retryAutomationResultDelivery(runId, destinationKey) {
+	const now = Date.now();
+	return getSqliteDatabase().prepare(`UPDATE automation_result_deliveries
+    SET status = 'retrying', attempts = 0, next_attempt_at_ms = ?, last_error = NULL,
+        lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+    WHERE run_id = ? AND destination_key = ? AND status = 'dead_letter'`).run(now, now, runId, destinationKey).changes === 1;
+}
+function getAutomationResultDeliveryMetrics() {
+	const now = Date.now();
+	const row = getSqliteDatabase().prepare(`SELECT
+    SUM(CASE WHEN status IN ('pending', 'retrying', 'delivering') THEN 1 ELSE 0 END) AS pending,
+    SUM(CASE WHEN status = 'dead_letter' THEN 1 ELSE 0 END) AS dead_letters,
+    SUM(CASE WHEN status = 'delivering' AND lease_until_ms > ? THEN 1 ELSE 0 END) AS active_leases
+    FROM automation_result_deliveries`).get(now);
+	return {
+		pending: row.pending ?? 0,
+		deadLetters: row.dead_letters ?? 0,
+		activeLeases: row.active_leases ?? 0
+	};
+}
+function assertArtifacts(artifacts) {
+	for (const artifact of artifacts) {
+		if (artifact.kind === "file") {
+			let uri;
+			try {
+				uri = new URL(artifact.uri);
+			} catch {
+				throw new Error(`Automation file artifact must use an authorized URI: ${artifact.id}`);
+			}
+			if (uri.protocol !== "xopc:" && uri.protocol !== "https:") throw new Error(`Automation file artifact URI is not allowed: ${artifact.id}`);
+			continue;
+		}
+		if (artifact.kind === "reference") continue;
+		if (Buffer.byteLength(JSON.stringify(artifact)) > MAX_INLINE_ARTIFACT_BYTES) throw new Error(`Automation artifact exceeds ${MAX_INLINE_ARTIFACT_BYTES} bytes: ${artifact.id}`);
+	}
+}
+function toResult(run, artifacts) {
+	if (run.endedAtMs === void 0 || ![
+		"succeeded",
+		"failed",
+		"cancelled",
+		"timeout"
+	].includes(run.status)) throw new Error("Cannot deliver an unfinished automation run");
+	assertArtifacts(artifacts);
+	const event = getAutomationEventForRun(run.id);
+	return {
+		schemaVersion: 1,
+		resultId: `result:${run.id}`,
+		runId: run.id,
+		automationId: run.automationId,
+		status: run.status,
+		...run.summary ? { summary: run.summary } : {},
+		...run.error ? { error: {
+			code: `AUTOMATION_${run.status.toUpperCase()}`,
+			message: run.error,
+			retryable: false
+		} } : {},
+		artifacts,
+		correlationId: event?.correlationId ?? run.id,
+		rootEventId: event?.rootEventId ?? run.id,
+		createdAtMs: run.createdAtMs,
+		completedAtMs: run.endedAtMs
+	};
+}
+var AutomationDeliveryRouter = class {
+	active;
+	timer;
+	handlers = /* @__PURE__ */ new Map();
+	owner = `automation-delivery:${process.pid}:${randomUUID()}`;
+	abortController = new AbortController();
+	constructor(options = {}) {
+		this.options = options;
+		this.register("gateway_event", ({ run, config }) => this.options.deliverGatewayEvent?.(run, {
+			notificationPolicy: config.notificationPolicy,
+			requiresAttention: config.requiresAttention === true,
+			...typeof config.projectId === "string" ? { projectId: config.projectId } : {}
+		}));
+		this.register("webhook", (input) => this.postWebhook(input));
+	}
+	register(kind, handler) {
+		if (this.handlers.has(kind)) throw new Error(`Automation delivery handler already registered: ${kind}`);
+		this.handlers.set(kind, handler);
+	}
+	validateArtifacts(artifacts) {
+		assertArtifacts(artifacts);
+	}
+	enqueue(run, automation, suppliedArtifacts = []) {
+		const now = Date.now();
+		const result = toResult(run, suppliedArtifacts.length > 0 ? suppliedArtifacts : run.summary ? [{
+			id: `summary:${run.id}`,
+			kind: "text",
+			text: run.summary,
+			mediaType: "text/plain"
+		}] : []);
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO automation_results (run_id, result_id, result_json, created_at_ms)
+        VALUES (?, ?, ?, ?)`).run(run.id, result.resultId, JSON.stringify(result), now);
+			const insert = db.prepare(`INSERT INTO automation_result_deliveries (
+        delivery_id, run_id, destination_key, kind, status, config_json, attempts,
+        next_attempt_at_ms, created_at_ms, updated_at_ms
+      ) VALUES (?, ?, ?, ?, 'pending', ?, 0, ?, ?, ?)`);
+			for (const destination of automation.delivery.destinations) {
+				const config = destination.kind === "gateway_event" ? {
+					...destination,
+					notificationPolicy: automation.delivery.notificationPolicy,
+					requiresAttention: run.status !== "succeeded" || (automation.safety?.mode ?? "auto_apply") !== "auto_apply",
+					...automation.projectId ? { projectId: automation.projectId } : {}
+				} : destination;
+				insert.run(randomUUID(), run.id, destination.key, destination.kind, JSON.stringify(config), now, now, now);
+			}
+		});
+	}
+	start() {
+		if (this.timer) return;
+		this.dispatch();
+		this.timer = setInterval(() => void this.dispatch(), 1e3);
+		this.timer.unref?.();
+	}
+	async stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		this.abortController.abort(/* @__PURE__ */ new Error("Automation delivery router stopped"));
+		await this.active?.catch(() => void 0);
+	}
+	dispatch() {
+		this.active ??= this.runDispatch().finally(() => {
+			this.active = void 0;
+		});
+		return this.active;
+	}
+	claim(limit) {
+		const now = Date.now();
+		return runSqliteWriteTransaction((db) => {
+			const expiredCandidates = db.prepare(`SELECT delivery_id, run_id, destination_key
+        FROM automation_result_deliveries
+        WHERE status = 'delivering' AND lease_until_ms <= ? AND attempts >= ?`).all(now, MAX_ATTEMPTS);
+			const expire = db.prepare(`UPDATE automation_result_deliveries
+        SET status = 'dead_letter', last_error = 'Delivery lease expired after maximum attempts',
+            lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+        WHERE delivery_id = ? AND status = 'delivering' AND lease_until_ms <= ? AND attempts >= ?`);
+			const expired = [];
+			for (const candidate of expiredCandidates) if (expire.run(now, candidate.delivery_id, now, MAX_ATTEMPTS).changes === 1) expired.push({
+				runId: candidate.run_id,
+				destinationKey: candidate.destination_key,
+				error: "Delivery lease expired after maximum attempts"
+			});
+			const candidates = db.prepare(`SELECT delivery_id, run_id, destination_key, kind, config_json, attempts
+        FROM automation_result_deliveries
+        WHERE attempts < ? AND (
+          (status IN ('pending', 'retrying') AND next_attempt_at_ms <= ?)
+          OR (status = 'delivering' AND lease_until_ms <= ?)
+        )
+        ORDER BY created_at_ms, run_id, destination_key LIMIT ?`).all(MAX_ATTEMPTS, now, now, limit);
+			const claimed = [];
+			const statement = db.prepare(`UPDATE automation_result_deliveries
+        SET status = 'delivering', attempts = attempts + 1, lease_owner = ?, lease_until_ms = ?, updated_at_ms = ?
+        WHERE delivery_id = ? AND attempts = ? AND (
+          (status IN ('pending', 'retrying') AND next_attempt_at_ms <= ?)
+          OR (status = 'delivering' AND lease_until_ms <= ?)
+        )`);
+			for (const candidate of candidates) if (statement.run(this.owner, now + LEASE_MS, now, candidate.delivery_id, candidate.attempts, now, now).changes === 1) claimed.push(candidate);
+			return {
+				rows: claimed,
+				expired
+			};
+		});
+	}
+	async runDispatch() {
+		const { rows, expired } = this.claim(100);
+		for (const item of expired) {
+			this.options.onDeadLetter?.({
+				phase: "result_delivery",
+				...item
+			});
+			log.warn(item, "Automation result delivery moved to dead letter after lease expiry");
+		}
+		let delivered = 0;
+		for (const [index, row] of rows.entries()) {
+			if (this.abortController.signal.aborted) {
+				for (const remaining of rows.slice(index)) this.release(remaining);
+				break;
+			}
+			const run = getAutomationRun(row.run_id);
+			const resultRow = getSqliteDatabase().prepare("SELECT result_json FROM automation_results WHERE run_id = ?").get(row.run_id);
+			if (!run || !resultRow) {
+				this.fail(row, /* @__PURE__ */ new Error("Automation result is unavailable"), true);
+				continue;
+			}
+			try {
+				const handler = this.handlers.get(row.kind);
+				if (!handler) throw new Error(`Automation delivery handler is unavailable: ${row.kind}`);
+				await handler({
+					deliveryId: row.delivery_id,
+					attempt: row.attempts + 1,
+					run,
+					result: JSON.parse(resultRow.result_json),
+					config: JSON.parse(row.config_json),
+					signal: this.abortController.signal
+				});
+				if (getSqliteDatabase().prepare(`UPDATE automation_result_deliveries
+          SET status = 'delivered', last_error = NULL, lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+          WHERE delivery_id = ? AND status = 'delivering' AND lease_owner = ?`).run(Date.now(), row.delivery_id, this.owner).changes === 1) delivered += 1;
+			} catch (error) {
+				if (this.abortController.signal.aborted) this.release(row);
+				else this.fail(row, error, false);
+			}
+		}
+		return delivered;
+	}
+	release(row) {
+		getSqliteDatabase().prepare(`UPDATE automation_result_deliveries
+      SET status = 'retrying', attempts = MAX(0, attempts - 1), next_attempt_at_ms = ?,
+          lease_owner = NULL, lease_until_ms = NULL, updated_at_ms = ?
+      WHERE delivery_id = ? AND status = 'delivering' AND lease_owner = ?`).run(Date.now(), Date.now(), row.delivery_id, this.owner);
+	}
+	fail(row, error, permanent) {
+		const attempts = row.attempts + 1;
+		const terminal = permanent || attempts >= MAX_ATTEMPTS;
+		const delayMs = Math.min(10 * 6e4, 1e3 * 5 ** Math.max(0, attempts - 1));
+		if (getSqliteDatabase().prepare(`UPDATE automation_result_deliveries
+      SET status = ?, next_attempt_at_ms = ?, last_error = ?, lease_owner = NULL,
+          lease_until_ms = NULL, updated_at_ms = ?
+      WHERE delivery_id = ? AND status = 'delivering' AND lease_owner = ?`).run(terminal ? "dead_letter" : "retrying", Date.now() + delayMs, error instanceof Error ? error.message : String(error), Date.now(), row.delivery_id, this.owner).changes !== 1) return;
+		if (terminal) this.options.onDeadLetter?.({
+			phase: "result_delivery",
+			runId: row.run_id,
+			destinationKey: row.destination_key,
+			error: error instanceof Error ? error.message : String(error)
+		});
+		log.warn({
+			err: error,
+			runId: row.run_id,
+			deliveryKind: row.kind,
+			attempt: attempts
+		}, terminal ? "Automation result delivery moved to dead letter" : "Automation result delivery will retry");
+	}
+	async postWebhook(input) {
+		const endpoint = String(input.config.endpoint ?? "");
+		const secretId = String(input.config.secretId ?? "");
+		assertUrlSafe(endpoint);
+		const secret = resolveAutomationWebhookSecret(secretId);
+		if (!secret) throw new Error(`Automation webhook secret is unavailable: ${secretId}`);
+		const timestamp = String(Date.now());
+		const body = JSON.stringify(input.result);
+		const signature = createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("hex");
+		const controller = new AbortController();
+		const onAbort = () => controller.abort(input.signal.reason);
+		input.signal.addEventListener("abort", onAbort, { once: true });
+		if (input.signal.aborted) onAbort();
+		const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("Automation delivery timed out")), 3e4);
+		try {
+			const response = await (this.options.fetch ?? fetch)(endpoint, {
+				method: "POST",
+				redirect: "manual",
+				headers: {
+					"content-type": "application/json",
+					"idempotency-key": `${input.result.runId}:${String(input.config.key)}`,
+					"x-xopc-delivery-id": input.deliveryId,
+					"x-xopc-delivery-attempt": String(input.attempt),
+					"x-xopc-timestamp": timestamp,
+					"x-xopc-signature": `sha256=${signature}`
+				},
+				body,
+				signal: controller.signal
+			});
+			if (!response.ok) throw new Error(`Automation delivery failed with HTTP ${response.status}`);
+		} finally {
+			clearTimeout(timer);
+			input.signal.removeEventListener("abort", onAbort);
+		}
+	}
+};
+//#endregion
+export { AutomationDeliveryRouter, getAutomationResultDeliveryMetrics, listAutomationResultDeliveries, retryAutomationResultDelivery };

package/dist/src/automations/delivery/index.d.ts

@@ -0,0 +1 @@
+export * from './delivery-router.js';

package/dist/src/automations/delivery/index.js

@@ -0,0 +1,2 @@
+import { AutomationDeliveryRouter, getAutomationResultDeliveryMetrics, listAutomationResultDeliveries, retryAutomationResultDelivery } from "./delivery-router.js";
+export { AutomationDeliveryRouter, getAutomationResultDeliveryMetrics, listAutomationResultDeliveries, retryAutomationResultDelivery };

package/dist/src/automations/domain/defaults.d.ts

@@ -4,5 +4,4 @@ export declare const DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS: number;
 export declare function defaultAutomationTimeoutSeconds(action: AutomationAction): number;
 export declare function resolveAutomationTimeoutSeconds(action: AutomationAction, reliability?: {
     executionTimeoutSeconds?: number;
-    timeoutSeconds?: number;
 }): number;

package/dist/src/automations/domain/defaults.js

@@ -5,7 +5,7 @@ function defaultAutomationTimeoutSeconds(action) {
 	return action.kind === "system" ? 60 : action.kind === "browser_automation" ? 600 : DEFAULT_AUTOMATION_TIMEOUT_SECONDS;
 }
 function resolveAutomationTimeoutSeconds(action, reliability) {
-	return reliability?.executionTimeoutSeconds ?? ("timeoutSeconds" in action ? action.timeoutSeconds : void 0) ?? reliability?.timeoutSeconds ?? defaultAutomationTimeoutSeconds(action);
+	return reliability?.executionTimeoutSeconds ?? ("timeoutSeconds" in action ? action.timeoutSeconds : void 0) ?? defaultAutomationTimeoutSeconds(action);
 }
 //#endregion
 export { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds };

package/dist/src/automations/domain/index.js

@@ -1,4 +1,4 @@
-import { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./validation.js";
+import { AutomationActionSchema, AutomationDeliveryPolicySchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, UpdateAutomationSchema } from "./validation.js";
 import { computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, timerDelayUntil } from "./schedule.js";
 import { DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds } from "./defaults.js";
-export { AutomationActionSchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds, timerDelayUntil };
+export { AutomationActionSchema, AutomationDeliveryPolicySchema, AutomationManagementSchema, AutomationReliabilitySchema, AutomationSafetyPolicySchema, AutomationScheduleSchema, AutomationSchema, AutomationStateSchema, AutomationTriggerSchema, CreateAutomationSchema, DEFAULT_AUTOMATION_TIMEOUT_SECONDS, DEFAULT_BROWSER_AUTOMATION_TIMEOUT_SECONDS, UpdateAutomationSchema, computeNextAutomationRunAtMs, computeNextScheduleRunAtMs, defaultAutomationTimeoutSeconds, resolveAutomationTimeoutSeconds, timerDelayUntil };