@pixelzx/genesis 2026.6.28 → 2026.6.29

package/dist/approval-native-runtime-rl6s6chH.js

@@ -1,729 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
-import { t as createSubsystemLogger } from "./subsystem-CNq69MoE.js";
-import { p as formatHumanList } from "./exec-approval-reply-BhbjoK1B.js";
-import { t as createOperatorApprovalsGatewayClient } from "./operator-approvals-client-D1R6aLFV.js";
-import { t as buildChannelApprovalNativeTargetKey } from "./approval-native-target-key-C1JhZ_Ty.js";
-//#region src/infra/approval-native-delivery.ts
-function dedupeTargets(targets) {
-	const seen = /* @__PURE__ */ new Set();
-	const deduped = [];
-	for (const target of targets) {
-		const key = buildChannelApprovalNativeTargetKey(target.target);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		deduped.push(target);
-	}
-	return deduped;
-}
-async function resolveChannelNativeApprovalDeliveryPlan(params) {
-	const adapter = params.adapter;
-	if (!adapter) return {
-		targets: [],
-		originTarget: null,
-		notifyOriginWhenDmOnly: false
-	};
-	const capabilities = adapter.describeDeliveryCapabilities({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		approvalKind: params.approvalKind,
-		request: params.request
-	});
-	if (!capabilities.enabled) return {
-		targets: [],
-		originTarget: null,
-		notifyOriginWhenDmOnly: false
-	};
-	const originTarget = capabilities.supportsOriginSurface && adapter.resolveOriginTarget ? await adapter.resolveOriginTarget({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		approvalKind: params.approvalKind,
-		request: params.request
-	}) ?? null : null;
-	const approverDmTargets = capabilities.supportsApproverDmSurface && adapter.resolveApproverDmTargets ? await adapter.resolveApproverDmTargets({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		approvalKind: params.approvalKind,
-		request: params.request
-	}) : [];
-	const plannedTargets = [];
-	const preferOrigin = capabilities.preferredSurface === "origin" || capabilities.preferredSurface === "both";
-	const preferApproverDm = capabilities.preferredSurface === "approver-dm" || capabilities.preferredSurface === "both";
-	if (preferOrigin && originTarget) plannedTargets.push({
-		surface: "origin",
-		target: originTarget,
-		reason: "preferred"
-	});
-	if (preferApproverDm) for (const target of approverDmTargets) plannedTargets.push({
-		surface: "approver-dm",
-		target,
-		reason: "preferred"
-	});
-	else if (!originTarget) for (const target of approverDmTargets) plannedTargets.push({
-		surface: "approver-dm",
-		target,
-		reason: "fallback"
-	});
-	return {
-		targets: dedupeTargets(plannedTargets),
-		originTarget,
-		notifyOriginWhenDmOnly: capabilities.preferredSurface === "approver-dm" && capabilities.notifyOriginWhenDmOnly === true && originTarget !== null
-	};
-}
-//#endregion
-//#region src/infra/approval-native-route-notice.ts
-function describeApprovalDeliveryDestination(params) {
-	const surfaces = new Set(params.deliveredTargets.map((target) => target.surface));
-	return surfaces.size === 1 && surfaces.has("approver-dm") ? `${params.channelLabel} DMs` : params.channelLabel;
-}
-function resolveApprovalRoutedElsewhereNoticeText(destinations) {
-	const uniqueDestinations = Array.from(new Set(destinations.map((value) => value.trim()))).filter(Boolean);
-	if (uniqueDestinations.length === 0) return null;
-	return `Approval required. I sent the approval request to ${formatHumanList(uniqueDestinations.toSorted((a, b) => a.localeCompare(b)))}, not this chat.`;
-}
-//#endregion
-//#region src/infra/approval-native-route-coordinator.ts
-const activeApprovalRouteRuntimes = /* @__PURE__ */ new Map();
-const pendingApprovalRouteNotices = /* @__PURE__ */ new Map();
-let approvalRouteRuntimeSeq = 0;
-const MAX_APPROVAL_ROUTE_NOTICE_TTL_MS = 5 * 6e4;
-function normalizeChannel(value) {
-	return normalizeLowercaseStringOrEmpty(value);
-}
-function clearPendingApprovalRouteNotice(approvalId) {
-	const entry = pendingApprovalRouteNotices.get(approvalId);
-	if (!entry) return;
-	pendingApprovalRouteNotices.delete(approvalId);
-	if (entry.cleanupTimeout) clearTimeout(entry.cleanupTimeout);
-}
-function createPendingApprovalRouteNotice(params) {
-	const timeoutMs = Math.min(Math.max(0, params.request.expiresAtMs - Date.now()), MAX_APPROVAL_ROUTE_NOTICE_TTL_MS);
-	const cleanupTimeout = setTimeout(() => {
-		clearPendingApprovalRouteNotice(params.request.id);
-	}, timeoutMs);
-	cleanupTimeout.unref?.();
-	return {
-		request: params.request,
-		approvalKind: params.approvalKind,
-		expectedRuntimeIds: new Set(params.expectedRuntimeIds ?? []),
-		reports: /* @__PURE__ */ new Map(),
-		cleanupTimeout,
-		finalized: false
-	};
-}
-function resolveRouteNoticeTargetFromRequest(request) {
-	const channel = request.request.turnSourceChannel?.trim();
-	const to = request.request.turnSourceTo?.trim();
-	if (!channel || !to) return null;
-	return {
-		channel,
-		to,
-		accountId: request.request.turnSourceAccountId ?? void 0,
-		threadId: request.request.turnSourceThreadId ?? void 0
-	};
-}
-function resolveFallbackRouteNoticeTarget(report) {
-	const channel = report.channel?.trim();
-	const to = report.deliveryPlan.originTarget?.to?.trim();
-	if (!channel || !to) return null;
-	return {
-		channel,
-		to,
-		accountId: report.accountId ?? void 0,
-		threadId: report.deliveryPlan.originTarget?.threadId ?? void 0
-	};
-}
-function didReportDeliverToOrigin(report, originAccountId) {
-	const originTarget = report.deliveryPlan.originTarget;
-	if (!originTarget) return false;
-	const reportAccountId = normalizeOptionalString(report.accountId);
-	if (originAccountId !== void 0 && reportAccountId !== void 0 && reportAccountId !== originAccountId) return false;
-	const originKey = buildChannelApprovalNativeTargetKey(originTarget);
-	return report.deliveredTargets.some((plannedTarget) => buildChannelApprovalNativeTargetKey(plannedTarget.target) === originKey);
-}
-function resolveApprovalRouteNotice(params) {
-	const explicitTarget = resolveRouteNoticeTargetFromRequest(params.request);
-	const originChannel = normalizeChannel(explicitTarget?.channel ?? params.request.request.turnSourceChannel);
-	const fallbackTarget = params.reports.filter((report) => normalizeChannel(report.channel) === originChannel || !originChannel).map(resolveFallbackRouteNoticeTarget).find((target) => target !== null) ?? null;
-	const target = explicitTarget ? {
-		...fallbackTarget,
-		...explicitTarget,
-		accountId: explicitTarget.accountId ?? fallbackTarget?.accountId,
-		threadId: explicitTarget.threadId ?? fallbackTarget?.threadId
-	} : fallbackTarget;
-	if (!target) return null;
-	const originAccountId = normalizeOptionalString(target.accountId);
-	if (params.reports.some((report) => {
-		if (originChannel && normalizeChannel(report.channel) !== originChannel) return false;
-		return didReportDeliverToOrigin(report, originAccountId);
-	})) return null;
-	const text = resolveApprovalRoutedElsewhereNoticeText(params.reports.flatMap((report) => {
-		if (!report.channelLabel || report.deliveredTargets.length === 0) return [];
-		const reportChannel = normalizeChannel(report.channel);
-		if (originChannel && reportChannel === originChannel && !report.deliveryPlan.notifyOriginWhenDmOnly) return [];
-		const reportAccountId = normalizeOptionalString(report.accountId);
-		if (originChannel && reportChannel === originChannel && originAccountId !== void 0 && reportAccountId !== void 0 && reportAccountId !== originAccountId) return [];
-		return [describeApprovalDeliveryDestination({
-			channelLabel: report.channelLabel,
-			deliveredTargets: report.deliveredTargets
-		})];
-	}));
-	if (!text) return null;
-	const requestGateway = params.reports.find((report) => activeApprovalRouteRuntimes.has(report.runtimeId))?.requestGateway ?? params.reports[0]?.requestGateway;
-	if (!requestGateway) return null;
-	return {
-		requestGateway,
-		target,
-		text
-	};
-}
-async function maybeFinalizeApprovalRouteNotice(approvalId) {
-	const entry = pendingApprovalRouteNotices.get(approvalId);
-	if (!entry || entry.finalized) return;
-	for (const runtimeId of entry.expectedRuntimeIds) if (!entry.reports.has(runtimeId)) return;
-	entry.finalized = true;
-	const reports = Array.from(entry.reports.values());
-	const notice = resolveApprovalRouteNotice({
-		request: entry.request,
-		reports
-	});
-	clearPendingApprovalRouteNotice(approvalId);
-	if (!notice) return;
-	try {
-		await notice.requestGateway("send", {
-			channel: notice.target.channel,
-			to: notice.target.to,
-			accountId: notice.target.accountId ?? void 0,
-			threadId: notice.target.threadId ?? void 0,
-			message: notice.text,
-			idempotencyKey: `approval-route-notice:${approvalId}`
-		});
-	} catch {}
-}
-function createApprovalNativeRouteReporter(params) {
-	const runtimeId = `native-approval-route:${++approvalRouteRuntimeSeq}`;
-	let registered = false;
-	const report = async (payload) => {
-		if (!registered || !params.handledKinds.has(payload.approvalKind)) return;
-		const entry = pendingApprovalRouteNotices.get(payload.request.id) ?? createPendingApprovalRouteNotice({
-			request: payload.request,
-			approvalKind: payload.approvalKind,
-			expectedRuntimeIds: [runtimeId]
-		});
-		entry.expectedRuntimeIds.add(runtimeId);
-		entry.reports.set(runtimeId, {
-			runtimeId,
-			request: payload.request,
-			channel: params.channel,
-			channelLabel: params.channelLabel,
-			accountId: params.accountId,
-			deliveryPlan: payload.deliveryPlan,
-			deliveredTargets: payload.deliveredTargets,
-			requestGateway: params.requestGateway
-		});
-		pendingApprovalRouteNotices.set(payload.request.id, entry);
-		await maybeFinalizeApprovalRouteNotice(payload.request.id);
-	};
-	return {
-		observeRequest(payload) {
-			if (!registered || !params.handledKinds.has(payload.approvalKind)) return;
-			const entry = pendingApprovalRouteNotices.get(payload.request.id) ?? createPendingApprovalRouteNotice({
-				request: payload.request,
-				approvalKind: payload.approvalKind,
-				expectedRuntimeIds: Array.from(activeApprovalRouteRuntimes.values()).filter((runtime) => runtime.handledKinds.has(payload.approvalKind)).map((runtime) => runtime.runtimeId)
-			});
-			entry.expectedRuntimeIds.add(runtimeId);
-			pendingApprovalRouteNotices.set(payload.request.id, entry);
-		},
-		start() {
-			if (registered) return;
-			activeApprovalRouteRuntimes.set(runtimeId, {
-				runtimeId,
-				handledKinds: params.handledKinds,
-				channel: params.channel,
-				channelLabel: params.channelLabel,
-				accountId: params.accountId,
-				requestGateway: params.requestGateway
-			});
-			registered = true;
-		},
-		async reportSkipped(params) {
-			await report({
-				approvalKind: params.approvalKind,
-				request: params.request,
-				deliveryPlan: {
-					targets: [],
-					originTarget: null,
-					notifyOriginWhenDmOnly: false
-				},
-				deliveredTargets: []
-			});
-		},
-		async reportDelivery(params) {
-			await report(params);
-		},
-		async stop() {
-			if (!registered) return;
-			registered = false;
-			activeApprovalRouteRuntimes.delete(runtimeId);
-			for (const entry of pendingApprovalRouteNotices.values()) {
-				entry.expectedRuntimeIds.delete(runtimeId);
-				if (entry.expectedRuntimeIds.size === 0) {
-					clearPendingApprovalRouteNotice(entry.request.id);
-					continue;
-				}
-				await maybeFinalizeApprovalRouteNotice(entry.request.id);
-			}
-		}
-	};
-}
-//#endregion
-//#region src/infra/exec-approval-channel-runtime.ts
-function resolveApprovalReplayMethods(eventKinds) {
-	const methods = [];
-	if (eventKinds.has("exec")) methods.push("exec.approval.list");
-	if (eventKinds.has("plugin")) methods.push("plugin.approval.list");
-	return methods;
-}
-function createExecApprovalChannelRuntime(adapter) {
-	const log = createSubsystemLogger(adapter.label);
-	const nowMs = adapter.nowMs ?? Date.now;
-	const eventKinds = new Set(adapter.eventKinds ?? ["exec"]);
-	const pending = /* @__PURE__ */ new Map();
-	let gatewayClient = null;
-	let started = false;
-	let shouldRun = false;
-	let startPromise = null;
-	let replayPromise = null;
-	const shouldKeepRunning = () => shouldRun;
-	const spawn = (label, promise) => {
-		promise.catch((err) => {
-			const message = formatErrorMessage(err);
-			log.error(`${label}: ${message}`);
-		});
-	};
-	const stopClientIfInactive = (client) => {
-		if (shouldKeepRunning()) return false;
-		gatewayClient = null;
-		client.stop();
-		return true;
-	};
-	const clearPendingEntry = (approvalId) => {
-		const entry = pending.get(approvalId);
-		if (!entry) return null;
-		pending.delete(approvalId);
-		if (entry.timeoutId) clearTimeout(entry.timeoutId);
-		return entry;
-	};
-	const handleExpired = async (approvalId) => {
-		const entry = clearPendingEntry(approvalId);
-		if (!entry) return;
-		log.debug(`expired ${approvalId}`);
-		await adapter.finalizeExpired?.({
-			request: entry.request,
-			entries: entry.entries
-		});
-	};
-	const handleRequested = async (request, opts) => {
-		if (opts?.ignoreIfInactive && !shouldKeepRunning()) return;
-		if (!adapter.shouldHandle(request)) return;
-		if (pending.has(request.id)) {
-			log.debug(`ignored duplicate request ${request.id}`);
-			return;
-		}
-		log.debug(`received request ${request.id}`);
-		const entry = {
-			request,
-			entries: [],
-			timeoutId: null,
-			delivering: true,
-			pendingResolution: null
-		};
-		pending.set(request.id, entry);
-		let entries;
-		try {
-			entries = await adapter.deliverRequested(request);
-		} catch (err) {
-			if (pending.get(request.id) === entry) clearPendingEntry(request.id);
-			throw err;
-		}
-		if (pending.get(request.id) !== entry) return;
-		if (!entries.length) {
-			pending.delete(request.id);
-			return;
-		}
-		entry.entries = entries;
-		entry.delivering = false;
-		if (entry.pendingResolution) {
-			pending.delete(request.id);
-			log.debug(`resolved ${entry.pendingResolution.id} with ${entry.pendingResolution.decision}`);
-			await adapter.finalizeResolved({
-				request: entry.request,
-				resolved: entry.pendingResolution,
-				entries: entry.entries
-			});
-			return;
-		}
-		const timeoutMs = Math.max(0, request.expiresAtMs - nowMs());
-		const timeoutId = setTimeout(() => {
-			spawn("error handling approval expiration", handleExpired(request.id));
-		}, timeoutMs);
-		timeoutId.unref?.();
-		entry.timeoutId = timeoutId;
-	};
-	const handleResolved = async (resolved) => {
-		const entry = pending.get(resolved.id);
-		if (!entry) return;
-		if (entry.delivering) {
-			entry.pendingResolution = resolved;
-			return;
-		}
-		const finalizedEntry = clearPendingEntry(resolved.id);
-		if (!finalizedEntry) return;
-		log.debug(`resolved ${resolved.id} with ${resolved.decision}`);
-		await adapter.finalizeResolved({
-			request: finalizedEntry.request,
-			resolved,
-			entries: finalizedEntry.entries
-		});
-	};
-	const handleGatewayEvent = (evt) => {
-		if (evt.event === "exec.approval.requested" && eventKinds.has("exec")) {
-			spawn("error handling approval request", handleRequested(evt.payload, { ignoreIfInactive: true }));
-			return;
-		}
-		if (evt.event === "plugin.approval.requested" && eventKinds.has("plugin")) {
-			spawn("error handling approval request", handleRequested(evt.payload, { ignoreIfInactive: true }));
-			return;
-		}
-		if (evt.event === "exec.approval.resolved" && eventKinds.has("exec")) {
-			spawn("error handling approval resolved", handleResolved(evt.payload));
-			return;
-		}
-		if (evt.event === "plugin.approval.resolved" && eventKinds.has("plugin")) spawn("error handling approval resolved", handleResolved(evt.payload));
-	};
-	const replayPendingApprovals = async (client) => {
-		try {
-			for (const method of resolveApprovalReplayMethods(eventKinds)) {
-				if (stopClientIfInactive(client)) return;
-				const pendingRequests = await client.request(method, {});
-				if (stopClientIfInactive(client)) return;
-				for (const request of pendingRequests) {
-					if (stopClientIfInactive(client)) return;
-					await handleRequested(request, { ignoreIfInactive: true });
-				}
-			}
-		} catch (error) {
-			if (!shouldKeepRunning()) return;
-			throw error;
-		}
-	};
-	const startPendingApprovalReplay = (client) => {
-		const promise = replayPendingApprovals(client).catch((err) => {
-			const message = formatErrorMessage(err);
-			log.error(`error replaying pending approvals: ${message}`);
-		}).finally(() => {
-			if (replayPromise === promise) replayPromise = null;
-		});
-		replayPromise = promise;
-	};
-	const waitForPendingApprovalReplay = async () => {
-		const replay = replayPromise;
-		if (!replay) return;
-		await replay.catch(() => {});
-	};
-	return {
-		async start() {
-			if (started) return;
-			if (startPromise) {
-				await startPromise;
-				return;
-			}
-			shouldRun = true;
-			startPromise = (async () => {
-				if (!adapter.isConfigured()) {
-					log.debug("disabled");
-					return;
-				}
-				let readySettled = false;
-				let resolveReady;
-				let rejectReady;
-				const ready = new Promise((resolve, reject) => {
-					resolveReady = resolve;
-					rejectReady = reject;
-				});
-				const settleReady = (fn) => {
-					if (readySettled) return;
-					readySettled = true;
-					fn();
-				};
-				const client = await createOperatorApprovalsGatewayClient({
-					config: adapter.cfg,
-					gatewayUrl: adapter.gatewayUrl,
-					clientDisplayName: adapter.clientDisplayName,
-					onEvent: handleGatewayEvent,
-					onHelloOk: () => {
-						log.debug("connected to gateway");
-						settleReady(resolveReady);
-					},
-					onConnectError: (err) => {
-						log.error(`connect error: ${err.message}`);
-						settleReady(() => rejectReady(err));
-					},
-					onClose: (code, reason) => {
-						log.debug(`gateway closed: ${code} ${reason}`);
-						settleReady(() => rejectReady(/* @__PURE__ */ new Error(`gateway closed: ${code} ${reason}`)));
-					}
-				});
-				if (!shouldRun) {
-					client.stop();
-					return;
-				}
-				await adapter.beforeGatewayClientStart?.();
-				gatewayClient = client;
-				try {
-					client.start();
-					await ready;
-					if (stopClientIfInactive(client)) return;
-					started = true;
-					startPendingApprovalReplay(client);
-				} catch (error) {
-					gatewayClient = null;
-					started = false;
-					client.stop();
-					throw error;
-				}
-			})().finally(() => {
-				startPromise = null;
-			});
-			await startPromise;
-		},
-		async stop() {
-			shouldRun = false;
-			if (startPromise) await startPromise.catch(() => {});
-			const wasActive = started || gatewayClient !== null || replayPromise !== null;
-			started = false;
-			gatewayClient?.stop();
-			gatewayClient = null;
-			await waitForPendingApprovalReplay();
-			if (!wasActive) {
-				await adapter.onStopped?.();
-				return;
-			}
-			for (const entry of pending.values()) if (entry.timeoutId) clearTimeout(entry.timeoutId);
-			pending.clear();
-			await adapter.onStopped?.();
-			log.debug("stopped");
-		},
-		handleRequested,
-		handleResolved,
-		handleExpired,
-		async request(method, params) {
-			if (!gatewayClient) throw new Error(`${adapter.label}: gateway client not connected`);
-			return await gatewayClient.request(method, params);
-		}
-	};
-}
-//#endregion
-//#region src/infra/approval-native-runtime.ts
-async function deliverApprovalRequestViaChannelNativePlan(params) {
-	const deliveryPlan = await resolveChannelNativeApprovalDeliveryPlan({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		approvalKind: params.approvalKind,
-		request: params.request,
-		adapter: params.adapter
-	});
-	const deliveredKeys = /* @__PURE__ */ new Set();
-	const pendingEntries = [];
-	const deliveredTargets = [];
-	for (const plannedTarget of deliveryPlan.targets) try {
-		const preparedTarget = await params.prepareTarget({
-			plannedTarget,
-			request: params.request
-		});
-		if (!preparedTarget) continue;
-		if (deliveredKeys.has(preparedTarget.dedupeKey)) {
-			params.onDuplicateSkipped?.({
-				plannedTarget,
-				preparedTarget,
-				request: params.request
-			});
-			continue;
-		}
-		const entry = await params.deliverTarget({
-			plannedTarget,
-			preparedTarget: preparedTarget.target,
-			request: params.request
-		});
-		if (!entry) continue;
-		deliveredKeys.add(preparedTarget.dedupeKey);
-		pendingEntries.push(entry);
-		deliveredTargets.push(plannedTarget);
-		params.onDelivered?.({
-			plannedTarget,
-			preparedTarget,
-			request: params.request,
-			entry
-		});
-	} catch (error) {
-		params.onDeliveryError?.({
-			error,
-			plannedTarget,
-			request: params.request
-		});
-	}
-	return {
-		entries: pendingEntries,
-		deliveryPlan,
-		deliveredTargets
-	};
-}
-function defaultResolveApprovalKind(request) {
-	return request.id.startsWith("plugin:") ? "plugin" : "exec";
-}
-function createChannelNativeApprovalRuntime(adapter) {
-	const nowMs = adapter.nowMs ?? Date.now;
-	const resolveApprovalKind = adapter.resolveApprovalKind ?? ((request) => defaultResolveApprovalKind(request));
-	let runtimeRequest = null;
-	const routeReporter = createApprovalNativeRouteReporter({
-		handledKinds: new Set(adapter.eventKinds ?? ["exec"]),
-		channel: adapter.channel,
-		channelLabel: adapter.channelLabel,
-		accountId: adapter.accountId,
-		requestGateway: async (method, params) => {
-			if (!runtimeRequest) throw new Error(`${adapter.label}: gateway client not connected`);
-			return await runtimeRequest(method, params);
-		}
-	});
-	const runtime = createExecApprovalChannelRuntime({
-		label: adapter.label,
-		clientDisplayName: adapter.clientDisplayName,
-		cfg: adapter.cfg,
-		gatewayUrl: adapter.gatewayUrl,
-		eventKinds: adapter.eventKinds,
-		isConfigured: adapter.isConfigured,
-		shouldHandle: (request) => {
-			const approvalKind = resolveApprovalKind(request);
-			routeReporter.observeRequest({
-				approvalKind,
-				request
-			});
-			let shouldHandle;
-			try {
-				shouldHandle = adapter.shouldHandle(request);
-			} catch (error) {
-				routeReporter.reportSkipped({
-					approvalKind,
-					request
-				});
-				throw error;
-			}
-			if (shouldHandle) return shouldHandle;
-			routeReporter.reportSkipped({
-				approvalKind,
-				request
-			});
-			return false;
-		},
-		finalizeResolved: adapter.finalizeResolved,
-		finalizeExpired: adapter.finalizeExpired,
-		onStopped: adapter.onStopped,
-		beforeGatewayClientStart: () => {
-			routeReporter.start();
-		},
-		nowMs,
-		deliverRequested: async (request) => {
-			const approvalKind = resolveApprovalKind(request);
-			let deliveryPlan = {
-				targets: [],
-				originTarget: null,
-				notifyOriginWhenDmOnly: false
-			};
-			let deliveredTargets = [];
-			try {
-				const pendingContent = await adapter.buildPendingContent({
-					request,
-					approvalKind,
-					nowMs: nowMs()
-				});
-				const deliveryResult = await deliverApprovalRequestViaChannelNativePlan({
-					cfg: adapter.cfg,
-					accountId: adapter.accountId,
-					approvalKind,
-					request,
-					adapter: adapter.nativeAdapter,
-					prepareTarget: async ({ plannedTarget, request }) => await adapter.prepareTarget({
-						plannedTarget,
-						request,
-						approvalKind,
-						pendingContent
-					}),
-					deliverTarget: async ({ plannedTarget, preparedTarget, request }) => await adapter.deliverTarget({
-						plannedTarget,
-						preparedTarget,
-						request,
-						approvalKind,
-						pendingContent
-					}),
-					onDeliveryError: adapter.onDeliveryError ? ({ error, plannedTarget, request }) => {
-						adapter.onDeliveryError?.({
-							error,
-							plannedTarget,
-							request,
-							approvalKind,
-							pendingContent
-						});
-					} : void 0,
-					onDuplicateSkipped: adapter.onDuplicateSkipped ? ({ plannedTarget, preparedTarget, request }) => {
-						adapter.onDuplicateSkipped?.({
-							plannedTarget,
-							preparedTarget,
-							request,
-							approvalKind,
-							pendingContent
-						});
-					} : void 0,
-					onDelivered: adapter.onDelivered ? ({ plannedTarget, preparedTarget, request, entry }) => {
-						adapter.onDelivered?.({
-							plannedTarget,
-							preparedTarget,
-							request,
-							approvalKind,
-							pendingContent,
-							entry
-						});
-					} : void 0
-				});
-				deliveryPlan = deliveryResult.deliveryPlan;
-				deliveredTargets = deliveryResult.deliveredTargets;
-				return deliveryResult.entries;
-			} finally {
-				await routeReporter.reportDelivery({
-					approvalKind,
-					request,
-					deliveryPlan,
-					deliveredTargets
-				});
-			}
-		}
-	});
-	runtimeRequest = (method, params) => runtime.request(method, params);
-	return {
-		...runtime,
-		async start() {
-			try {
-				await runtime.start();
-			} catch (error) {
-				await routeReporter.stop();
-				throw error;
-			}
-		},
-		async stop() {
-			await routeReporter.stop();
-			await runtime.stop();
-		}
-	};
-}
-//#endregion
-export { resolveChannelNativeApprovalDeliveryPlan as i, deliverApprovalRequestViaChannelNativePlan as n, createExecApprovalChannelRuntime as r, createChannelNativeApprovalRuntime as t };