opencode-oncall 0.1.0

package/dist/wechat/broker-launcher.d.ts

@@ -0,0 +1,37 @@
+import { createDefaultBrokerEndpoint } from "./broker-endpoint.js";
+type BrokerMetadata = {
+    pid: number;
+    endpoint: string;
+    startedAt: number;
+    version: string;
+};
+type LaunchLockContent = {
+    pid: number;
+    acquiredAt: number;
+    lockId: string;
+};
+type LaunchOptions = {
+    stateRoot?: string;
+    brokerJsonPath?: string;
+    launchLockPath?: string;
+    backoffMs?: number;
+    maxAttempts?: number;
+    expectedVersion?: string;
+    endpointFactory?: () => string;
+    spawnImpl?: (endpoint: string, stateRoot: string) => {
+        pid?: number | undefined;
+        unref?: (() => void) | undefined;
+    };
+    retireBrokerImpl?: (metadata: BrokerMetadata) => Promise<void> | void;
+    pingImpl?: (endpoint: string) => Promise<boolean>;
+    isProcessAliveImpl?: (pid: number) => boolean;
+    onLockAcquired?: (lock: LaunchLockContent) => void;
+};
+type ResolveBrokerSpawnCommandOptions = {
+    execPath?: string;
+};
+type ResolveBrokerSpawnEnv = NodeJS.ProcessEnv;
+export declare function resolveBrokerSpawnEnv(env?: ResolveBrokerSpawnEnv): NodeJS.ProcessEnv;
+export { createDefaultBrokerEndpoint };
+export declare function resolveBrokerSpawnCommand(options?: ResolveBrokerSpawnCommandOptions): string;
+export declare function connectOrSpawnBroker(options?: LaunchOptions): Promise<BrokerMetadata>;

package/dist/wechat/broker-launcher.js

@@ -0,0 +1,418 @@
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, open, readFile, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createBrokerSocket, createDefaultBrokerEndpoint } from "./broker-endpoint.js";
+import { WECHAT_FILE_MODE, wechatBrokerDiagnosticsPath, wechatStateRoot } from "./state-paths.js";
+import { parseEnvelopeLine, serializeEnvelope } from "./protocol.js";
+const DEFAULT_BACKOFF_MS = 250;
+const DEFAULT_MAX_ATTEMPTS = 20;
+const DEFAULT_BOOTING_BROKER_WAIT_STEP_MS = 100;
+const DEFAULT_BOOTING_BROKER_WAIT_STEPS = 20;
+async function appendBrokerLauncherDiagnostic(stateRoot, event) {
+    try {
+        await mkdir(stateRoot, { recursive: true, mode: 0o700 });
+        await appendFile(wechatBrokerDiagnosticsPath(stateRoot), `${JSON.stringify({ at: Date.now(), ...event })}\n`, { encoding: "utf8", mode: WECHAT_FILE_MODE });
+    }
+    catch {
+    }
+}
+export function resolveBrokerSpawnEnv(env = process.env) {
+    return {
+        ...env,
+        BUN_BE_BUN: "1",
+    };
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function parseBrokerVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version.trim());
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+    };
+}
+function isBrokerVersionCompatible(candidateVersion, expectedVersion) {
+    const candidate = parseBrokerVersion(candidateVersion);
+    const expected = parseBrokerVersion(expectedVersion);
+    if (!candidate || !expected) {
+        return candidateVersion === expectedVersion;
+    }
+    if (candidate.major !== expected.major || candidate.minor !== expected.minor) {
+        return false;
+    }
+    return candidate.patch >= expected.patch;
+}
+function shouldRetireBrokerForVersion(candidateVersion, expectedVersion) {
+    const candidate = parseBrokerVersion(candidateVersion);
+    const expected = parseBrokerVersion(expectedVersion);
+    if (!candidate || !expected) {
+        return candidateVersion !== expectedVersion;
+    }
+    if (candidate.major !== expected.major || candidate.minor !== expected.minor) {
+        return true;
+    }
+    return candidate.patch < expected.patch;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export { createDefaultBrokerEndpoint };
+export function resolveBrokerSpawnCommand(options = {}) {
+    const execPath = options.execPath ?? process.execPath;
+    return execPath;
+}
+async function readCurrentPackageVersion() {
+    try {
+        const packageJsonPath = new URL("../../package.json", import.meta.url);
+        const raw = await readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return isNonEmptyString(parsed.version) ? parsed.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readBrokerMetadata(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isFiniteNumber(parsed.pid) || !isNonEmptyString(parsed.endpoint) || !isFiniteNumber(parsed.startedAt)) {
+            return null;
+        }
+        return {
+            pid: parsed.pid,
+            endpoint: parsed.endpoint,
+            startedAt: parsed.startedAt,
+            version: isNonEmptyString(parsed.version) ? parsed.version : "unknown",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultPingImpl(endpoint) {
+    return new Promise((resolve) => {
+        const socket = createBrokerSocket(endpoint);
+        let buffer = "";
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 500);
+        socket.once("error", () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+        socket.once("connect", () => {
+            socket.write(serializeEnvelope({ id: `launcher-ping-${Date.now()}`, type: "ping", payload: {} }));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString("utf8");
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            clearTimeout(timer);
+            socket.end();
+            try {
+                const response = parseEnvelopeLine(buffer.slice(0, newlineIndex + 1));
+                resolve(response.type === "pong");
+            }
+            catch {
+                resolve(false);
+            }
+        });
+    });
+}
+async function readLaunchLock(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isFiniteNumber(parsed.pid) || !isFiniteNumber(parsed.acquiredAt) || !isNonEmptyString(parsed.lockId)) {
+            return null;
+        }
+        return {
+            pid: parsed.pid,
+            acquiredAt: parsed.acquiredAt,
+            lockId: parsed.lockId,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function acquireLaunchLock(filePath, isProcessAliveImpl) {
+    const lock = {
+        pid: process.pid,
+        acquiredAt: Date.now(),
+        lockId: randomUUID(),
+    };
+    try {
+        const handle = await open(filePath, "wx", 0o600);
+        await handle.writeFile(JSON.stringify(lock, null, 2), "utf8");
+        await handle.close();
+        return { lock };
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            throw error;
+        }
+        const existing = await readLaunchLock(filePath);
+        if (existing && isProcessAliveImpl(existing.pid)) {
+            return { lock: null };
+        }
+        await rm(filePath, { force: true });
+        return {
+            lock: null,
+            ...(existing ? { recoveredStaleLock: { pid: existing.pid } } : {}),
+        };
+    }
+}
+function getBrokerIdentity(metadata) {
+    return `${metadata.pid}:${metadata.startedAt}:${metadata.version}:${metadata.endpoint}`;
+}
+async function readCompatibleBrokerState(brokerFilePath, pingImpl, isProcessAliveImpl, expectedVersion) {
+    const metadata = await readBrokerMetadata(brokerFilePath);
+    if (!metadata) {
+        return { status: "unavailable" };
+    }
+    if (isNonEmptyString(expectedVersion) && !isBrokerVersionCompatible(metadata.version, expectedVersion)) {
+        return { status: "unavailable" };
+    }
+    if (!isProcessAliveImpl(metadata.pid)) {
+        return { status: "unavailable" };
+    }
+    const ok = await pingImpl(metadata.endpoint);
+    if (ok) {
+        return {
+            status: "ready",
+            metadata,
+        };
+    }
+    return {
+        status: "booting",
+        metadata,
+    };
+}
+async function isBrokerAlive(brokerFilePath, pingImpl, isProcessAliveImpl, expectedVersion) {
+    const state = await readCompatibleBrokerState(brokerFilePath, pingImpl, isProcessAliveImpl, expectedVersion);
+    if (state.status !== "ready") {
+        return null;
+    }
+    return state.metadata;
+}
+async function readBootingCompatibleBroker(brokerFilePath, pingImpl, isProcessAliveImpl, expectedVersion) {
+    const state = await readCompatibleBrokerState(brokerFilePath, pingImpl, isProcessAliveImpl, expectedVersion);
+    if (state.status !== "booting") {
+        return null;
+    }
+    return state.metadata;
+}
+async function readVersionMismatchedBroker(brokerFilePath, expectedVersion) {
+    const metadata = await readBrokerMetadata(brokerFilePath);
+    if (!metadata) {
+        return null;
+    }
+    if (!isNonEmptyString(expectedVersion) || !shouldRetireBrokerForVersion(metadata.version, expectedVersion)) {
+        return null;
+    }
+    return metadata;
+}
+async function defaultRetireBrokerImpl(metadata, pingImpl) {
+    if (metadata.pid === process.pid) {
+        return;
+    }
+    const reachable = await pingImpl(metadata.endpoint);
+    if (!reachable) {
+        return;
+    }
+    if (!isProcessAlive(metadata.pid)) {
+        return;
+    }
+    try {
+        process.kill(metadata.pid, "SIGTERM");
+    }
+    catch {
+        return;
+    }
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 5000) {
+        if (!isProcessAlive(metadata.pid)) {
+            return;
+        }
+        await delay(50);
+    }
+    try {
+        process.kill(metadata.pid, "SIGKILL");
+    }
+    catch {
+        // process already exited
+    }
+}
+function defaultSpawnImpl(endpoint, stateRoot) {
+    const entry = fileURLToPath(new URL("./broker-entry.js", import.meta.url));
+    const child = spawn(resolveBrokerSpawnCommand(), [entry, `--endpoint=${endpoint}`, `--state-root=${stateRoot}`], {
+        cwd: path.resolve(fileURLToPath(new URL("../..", import.meta.url))),
+        detached: true,
+        env: resolveBrokerSpawnEnv(process.env),
+        stdio: "ignore",
+    });
+    child.unref();
+    return child;
+}
+async function waitForBootingBrokerToBecomeReady(input) {
+    let lastBootingBroker = null;
+    for (let step = 0; step < input.maxWaitSteps; step += 1) {
+        const state = await readCompatibleBrokerState(input.brokerFilePath, input.pingImpl, input.isProcessAliveImpl, input.expectedVersion);
+        if (state.status === "ready") {
+            return {
+                status: "ready",
+                metadata: state.metadata,
+            };
+        }
+        if (state.status !== "booting") {
+            return lastBootingBroker
+                ? {
+                    status: "failed",
+                    metadata: lastBootingBroker,
+                }
+                : null;
+        }
+        if (getBrokerIdentity(state.metadata) !== input.bootingBrokerIdentity) {
+            return {
+                status: "replaced",
+                metadata: state.metadata,
+            };
+        }
+        lastBootingBroker = state.metadata;
+        if (step < input.maxWaitSteps - 1) {
+            await delay(input.waitStepMs);
+        }
+    }
+    return lastBootingBroker
+        ? {
+            status: "failed",
+            metadata: lastBootingBroker,
+        }
+        : null;
+}
+export async function connectOrSpawnBroker(options = {}) {
+    const stateRoot = options.stateRoot ?? wechatStateRoot();
+    const brokerJsonFile = options.brokerJsonPath ?? path.join(stateRoot, "broker.json");
+    const launchLockFile = options.launchLockPath ?? path.join(stateRoot, "launch.lock");
+    const backoffMs = options.backoffMs ?? DEFAULT_BACKOFF_MS;
+    const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    const expectedVersion = options.expectedVersion ?? await readCurrentPackageVersion();
+    const pingImpl = options.pingImpl ?? defaultPingImpl;
+    const isProcessAliveImpl = options.isProcessAliveImpl ?? isProcessAlive;
+    const spawnImpl = options.spawnImpl ?? defaultSpawnImpl;
+    const retireBrokerImpl = options.retireBrokerImpl ?? ((metadata) => defaultRetireBrokerImpl(metadata, pingImpl));
+    const endpointFactory = options.endpointFactory ?? (() => createDefaultBrokerEndpoint({ stateRoot }));
+    const bootingBrokerWaitStepMs = Math.min(Math.max(backoffMs, 10), DEFAULT_BOOTING_BROKER_WAIT_STEP_MS);
+    const bootingBrokerWaitSteps = DEFAULT_BOOTING_BROKER_WAIT_STEPS;
+    await mkdir(stateRoot, { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        const running = await isBrokerAlive(brokerJsonFile, pingImpl, isProcessAliveImpl, expectedVersion);
+        if (running) {
+            return running;
+        }
+        let failedBootingBrokerIdentity = null;
+        const bootingCompatibleBroker = await readBootingCompatibleBroker(brokerJsonFile, pingImpl, isProcessAliveImpl, expectedVersion);
+        if (bootingCompatibleBroker) {
+            let bootingBrokerToWaitFor = bootingCompatibleBroker;
+            for (let transition = 0; transition < maxAttempts && bootingBrokerToWaitFor; transition += 1) {
+                const waitResult = await waitForBootingBrokerToBecomeReady({
+                    brokerFilePath: brokerJsonFile,
+                    bootingBrokerIdentity: getBrokerIdentity(bootingBrokerToWaitFor),
+                    pingImpl,
+                    isProcessAliveImpl,
+                    expectedVersion,
+                    waitStepMs: bootingBrokerWaitStepMs,
+                    maxWaitSteps: bootingBrokerWaitSteps,
+                });
+                if (waitResult?.status === "ready") {
+                    return waitResult.metadata;
+                }
+                if (waitResult?.status === "replaced") {
+                    bootingBrokerToWaitFor = waitResult.metadata;
+                    continue;
+                }
+                failedBootingBrokerIdentity = waitResult ? getBrokerIdentity(waitResult.metadata) : null;
+                bootingBrokerToWaitFor = null;
+            }
+            if (bootingBrokerToWaitFor) {
+                continue;
+            }
+        }
+        const lockAttempt = await acquireLaunchLock(launchLockFile, isProcessAliveImpl);
+        if (lockAttempt.recoveredStaleLock) {
+            await appendBrokerLauncherDiagnostic(stateRoot, {
+                type: "brokerTakeover",
+                code: "brokerTakeover",
+                reason: "staleLock",
+                previousPid: lockAttempt.recoveredStaleLock.pid,
+            });
+        }
+        const lock = lockAttempt.lock;
+        if (!lock) {
+            await delay(backoffMs);
+            continue;
+        }
+        options.onLockAcquired?.(lock);
+        try {
+            const lockWindowBrokerState = await readCompatibleBrokerState(brokerJsonFile, pingImpl, isProcessAliveImpl, expectedVersion);
+            if (lockWindowBrokerState.status === "ready") {
+                return lockWindowBrokerState.metadata;
+            }
+            if (lockWindowBrokerState.status === "booting" &&
+                getBrokerIdentity(lockWindowBrokerState.metadata) !== failedBootingBrokerIdentity) {
+                continue;
+            }
+            const versionMismatchedBroker = await readVersionMismatchedBroker(brokerJsonFile, expectedVersion);
+            if (versionMismatchedBroker) {
+                await appendBrokerLauncherDiagnostic(stateRoot, {
+                    type: "brokerTakeover",
+                    code: "brokerTakeover",
+                    reason: "versionMismatch",
+                    previousVersion: versionMismatchedBroker.version,
+                    nextVersion: expectedVersion,
+                    previousPid: versionMismatchedBroker.pid,
+                });
+                await retireBrokerImpl(versionMismatchedBroker);
+            }
+            const endpoint = endpointFactory();
+            const child = spawnImpl(endpoint, stateRoot);
+            void child?.unref?.();
+            for (let n = 0; n < 20; n += 1) {
+                await delay(100);
+                const spawned = await isBrokerAlive(brokerJsonFile, pingImpl, isProcessAliveImpl, expectedVersion);
+                if (spawned) {
+                    return spawned;
+                }
+            }
+            throw new Error("spawned broker did not become available");
+        }
+        finally {
+            await rm(launchLockFile, { force: true });
+        }
+    }
+    throw new Error("broker unavailable");
+}

package/dist/wechat/broker-mutation-queue.d.ts

@@ -0,0 +1,93 @@
+import { SHOW_FALLBACK_TOAST_DELIVERY_FAILED_REASON, type ShowFallbackToastPayload } from "./protocol.js";
+import type { WechatDeadLetterRecord } from "./dead-letter-store.js";
+import type { NotificationRecord } from "./notification-types.js";
+import type { PreparedRecoveryRequestReopen, RequestRecord } from "./request-store.js";
+type DestroyableSocket = {
+    destroyed: boolean;
+};
+export type LiveRegistration<TSocket extends DestroyableSocket = DestroyableSocket> = {
+    socket: TSocket;
+    sessionToken: string;
+    registrationEpoch: string;
+};
+export type FallbackToastMutation = {
+    type: "fallbackToastMutation";
+    instanceID: string;
+    wechatAccountId: string;
+    userId: string;
+    message: string;
+    reason: typeof SHOW_FALLBACK_TOAST_DELIVERY_FAILED_REASON;
+    registrationEpoch?: string;
+};
+export type BrokerMutationDiagnosticEvent = {
+    type: "showFallbackToast" | "fallbackToastDropped";
+    code: "showFallbackToast" | "fallbackToastDropped";
+    instanceID: string;
+    reason?: typeof SHOW_FALLBACK_TOAST_DELIVERY_FAILED_REASON;
+    registrationEpoch?: string;
+    liveRegistrationEpoch?: string;
+};
+export type RecoveryMutation = {
+    type: "recoveryMutation";
+    requestedHandle: string;
+    deadLetter: WechatDeadLetterRecord;
+    originalRequest: RequestRecord;
+    pendingNotifications: NotificationRecord[];
+    recoveryChainHandles: string[];
+};
+export type RecoveryMutationFailure = {
+    recoveryErrorCode: string;
+    recoveryErrorMessage: string;
+};
+export type RecoveryMutationResult = {
+    ok: true;
+    recovered: RequestRecord;
+} | {
+    ok: false;
+    message: string;
+};
+type ExecuteRecoveryMutationDeps = {
+    revalidate: (mutation: RecoveryMutation) => Promise<RecoveryMutationResult | undefined>;
+    prepareFreshRecovery: (mutation: RecoveryMutation, recoveredAt: number) => Promise<PreparedRecoveryRequestReopen>;
+    suppressPendingNotifications: (mutation: RecoveryMutation) => Promise<void>;
+    commitPreparedRecovery: (prepared: PreparedRecoveryRequestReopen, mutation: RecoveryMutation) => Promise<RequestRecord>;
+    rollbackPreparedRecovery: (prepared: PreparedRecoveryRequestReopen, mutation: RecoveryMutation) => Promise<void>;
+    markRecovered: (input: {
+        kind: WechatDeadLetterRecord["kind"];
+        routeKey: string;
+        recoveredAt: number;
+    }) => Promise<void>;
+    markFailed: (input: {
+        kind: WechatDeadLetterRecord["kind"];
+        routeKey: string;
+        failure: RecoveryMutationFailure;
+    }) => Promise<void>;
+    mapFailure: (error: unknown) => RecoveryMutationFailure;
+    appendDiagnostic?: (event: BrokerMutationDiagnosticEvent) => Promise<void>;
+    now?: () => number;
+    testHooks?: {
+        afterReopenRequest?: (mutation: RecoveryMutation) => Promise<void> | void;
+    };
+};
+type ExecuteFallbackToastMutationDeps<TSocket extends DestroyableSocket = DestroyableSocket> = {
+    markTokenStale: (input: {
+        wechatAccountId: string;
+        userId: string;
+        staleReason: string;
+    }) => Promise<unknown>;
+    appendDiagnostic: (event: BrokerMutationDiagnosticEvent) => Promise<void>;
+    getLiveRegistration: (instanceID: string) => LiveRegistration<TSocket> | undefined;
+    deliverFallbackToast: (input: {
+        instanceID: string;
+        registration: LiveRegistration<TSocket>;
+        payload: ShowFallbackToastPayload;
+    }) => Promise<void> | void;
+};
+export type BrokerMutationQueue = {
+    enqueue: <T>(mutationType: string, task: () => Promise<T>) => Promise<T>;
+    drain: () => Promise<void>;
+};
+export declare function createBrokerMutationQueue(): BrokerMutationQueue;
+export declare function executeFallbackToastMutation<TSocket extends DestroyableSocket = DestroyableSocket>(mutation: FallbackToastMutation, deps: ExecuteFallbackToastMutationDeps<TSocket>): Promise<void>;
+export declare function executeRecoveryMutation(mutation: RecoveryMutation, deps: ExecuteRecoveryMutationDeps): Promise<RecoveryMutationResult>;
+export {};

package/dist/wechat/broker-mutation-queue.js

@@ -0,0 +1,126 @@
+import { NOTIFICATION_DELIVERY_FAILED_STALE_REASON } from "./token-store.js";
+function toError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    return new Error(String(value));
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+export function createBrokerMutationQueue() {
+    let chain = Promise.resolve();
+    return {
+        enqueue(_mutationType, task) {
+            const next = chain.then(task);
+            chain = next.then(() => undefined, () => undefined);
+            return next;
+        },
+        drain() {
+            return chain;
+        },
+    };
+}
+export async function executeFallbackToastMutation(mutation, deps) {
+    await Promise.resolve(deps.markTokenStale({
+        wechatAccountId: mutation.wechatAccountId,
+        userId: mutation.userId,
+        staleReason: NOTIFICATION_DELIVERY_FAILED_STALE_REASON,
+    })).catch(() => { });
+    const liveRegistration = deps.getLiveRegistration(mutation.instanceID);
+    const registrationEpoch = mutation.registrationEpoch;
+    const canDeliver = liveRegistration
+        && liveRegistration.socket.destroyed !== true
+        && isNonEmptyString(registrationEpoch)
+        && liveRegistration.registrationEpoch === registrationEpoch;
+    if (!canDeliver) {
+        await deps.appendDiagnostic({
+            type: "fallbackToastDropped",
+            code: "fallbackToastDropped",
+            instanceID: mutation.instanceID,
+            reason: mutation.reason,
+            ...(isNonEmptyString(registrationEpoch) ? { registrationEpoch } : {}),
+            ...(liveRegistration ? { liveRegistrationEpoch: liveRegistration.registrationEpoch } : {}),
+        });
+        return;
+    }
+    const payload = {
+        wechatAccountId: mutation.wechatAccountId,
+        userId: mutation.userId,
+        message: mutation.message,
+        reason: mutation.reason,
+        registrationEpoch,
+    };
+    await deps.appendDiagnostic({
+        type: "showFallbackToast",
+        code: "showFallbackToast",
+        instanceID: mutation.instanceID,
+        reason: mutation.reason,
+        registrationEpoch,
+        liveRegistrationEpoch: liveRegistration.registrationEpoch,
+    });
+    await Promise.resolve(deps.deliverFallbackToast({
+        instanceID: mutation.instanceID,
+        registration: liveRegistration,
+        payload,
+    }));
+}
+export async function executeRecoveryMutation(mutation, deps) {
+    const revalidated = await deps.revalidate(mutation);
+    if (revalidated) {
+        return revalidated;
+    }
+    const recoveredAt = deps.now?.() ?? Date.now();
+    let preparedRecovery;
+    try {
+        preparedRecovery = await deps.prepareFreshRecovery(mutation, recoveredAt);
+        await deps.suppressPendingNotifications(mutation);
+        const recovered = await deps.commitPreparedRecovery(preparedRecovery, mutation);
+        await deps.testHooks?.afterReopenRequest?.(mutation);
+        await deps.markRecovered({
+            kind: mutation.deadLetter.kind,
+            routeKey: mutation.deadLetter.routeKey,
+            recoveredAt,
+        });
+        return {
+            ok: true,
+            recovered,
+        };
+    }
+    catch (error) {
+        const failure = deps.mapFailure(error);
+        let rollbackError;
+        let markFailedError;
+        if (preparedRecovery) {
+            try {
+                await deps.rollbackPreparedRecovery(preparedRecovery, mutation);
+            }
+            catch (rollbackFailure) {
+                rollbackError = toError(rollbackFailure);
+            }
+        }
+        try {
+            await deps.markFailed({
+                kind: mutation.deadLetter.kind,
+                routeKey: mutation.deadLetter.routeKey,
+                failure,
+            });
+        }
+        catch (persistFailure) {
+            markFailedError = toError(persistFailure);
+        }
+        if (rollbackError && markFailedError) {
+            throw new Error(`recovery rollback failed: ${rollbackError.message}; recovery failed metadata persistence failed: ${markFailedError.message}`);
+        }
+        if (rollbackError) {
+            throw rollbackError;
+        }
+        if (markFailedError) {
+            throw markFailedError;
+        }
+        return {
+            ok: false,
+            message: failure.recoveryErrorMessage,
+        };
+    }
+}