@pixelzx/genesis 2026.6.27 → 2026.6.28

package/dist/catchup-Dfw4DEMS.js

@@ -0,0 +1,300 @@
+import { n as resolvePreferredGenesisTmpDir } from "./tmp-genesis-dir-h5HSqKoN.js";
+import { _ as resolveStateDir } from "./paths-Bv2rGpO9.js";
+import { n as writeJsonFileAtomically, t as readJsonFileWithFallback } from "./json-store-BuW_6QaZ.js";
+import "./state-paths-vR-SLZZ5.js";
+import { c as createBlueBubblesClientFromParts, g as normalizeWebhookMessage, j as resolveBlueBubblesServerAccount, u as asRecord } from "./probe-pZ61Idl1.js";
+import { a as warmupBlueBubblesInboundDedupe, n as processMessage } from "./monitor-processing-BMv5voti.js";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region extensions/bluebubbles/src/catchup.ts
+const DEFAULT_MAX_AGE_MINUTES = 120;
+const MAX_MAX_AGE_MINUTES = 720;
+const DEFAULT_PER_RUN_LIMIT = 50;
+const MAX_PER_RUN_LIMIT = 500;
+const DEFAULT_FIRST_RUN_LOOKBACK_MINUTES = 30;
+const DEFAULT_MAX_FAILURE_RETRIES = 10;
+const MAX_MAX_FAILURE_RETRIES = 1e3;
+const MAX_FAILURE_RETRY_MAP_SIZE = 5e3;
+const FETCH_TIMEOUT_MS = 15e3;
+function resolveStateDirFromEnv(env = process.env) {
+	if (env.GENESIS_STATE_DIR?.trim()) return resolveStateDir(env);
+	if (env.VITEST || env.NODE_ENV === "test") {
+		const name = "genesis-vitest-" + process.pid;
+		return path.join(resolvePreferredGenesisTmpDir(), name);
+	}
+	return resolveStateDir(env);
+}
+function resolveCursorFilePath(accountId) {
+	const safePrefix = accountId.replace(/[^a-zA-Z0-9_-]/g, "_") || "account";
+	const hash = createHash("sha256").update(accountId, "utf8").digest("hex").slice(0, 12);
+	return path.join(resolveStateDirFromEnv(), "bluebubbles", "catchup", `${safePrefix}__${hash}.json`);
+}
+function sanitizeFailureRetriesInput(raw) {
+	if (!raw || typeof raw !== "object") return {};
+	const out = {};
+	for (const [guid, count] of Object.entries(raw)) {
+		if (!guid || typeof guid !== "string") continue;
+		if (typeof count !== "number" || !Number.isFinite(count) || count <= 0) continue;
+		out[guid] = Math.floor(count);
+	}
+	return out;
+}
+async function loadBlueBubblesCatchupCursor(accountId) {
+	const { value } = await readJsonFileWithFallback(resolveCursorFilePath(accountId), null);
+	if (!value || typeof value !== "object") return null;
+	if (typeof value.lastSeenMs !== "number" || !Number.isFinite(value.lastSeenMs)) return null;
+	const failureRetries = sanitizeFailureRetriesInput(value.failureRetries);
+	const hasRetries = Object.keys(failureRetries).length > 0;
+	return {
+		lastSeenMs: value.lastSeenMs,
+		updatedAt: typeof value.updatedAt === "number" ? value.updatedAt : 0,
+		...hasRetries ? { failureRetries } : {}
+	};
+}
+async function saveBlueBubblesCatchupCursor(accountId, lastSeenMs, failureRetries) {
+	const filePath = resolveCursorFilePath(accountId);
+	const sanitized = sanitizeFailureRetriesInput(failureRetries);
+	const hasRetries = Object.keys(sanitized).length > 0;
+	await writeJsonFileAtomically(filePath, {
+		lastSeenMs,
+		updatedAt: Date.now(),
+		...hasRetries ? { failureRetries: sanitized } : {}
+	});
+}
+/**
+* Bound the retry map so a pathological storm of unique failing GUIDs
+* cannot grow the cursor file without limit. Keeps the `maxSize` entries
+* with the highest counts (closest to give-up) when over the bound.
+*
+* The map is already scoped to "currently failing, still-retrying" GUIDs
+* and prunes on every run (entries not observed in the fetched window are
+* dropped), so this is a defense-in-depth cap, not the primary pruning
+* mechanism.
+*/
+function capFailureRetriesMap(map, maxSize) {
+	const entries = Object.entries(map);
+	if (entries.length <= maxSize) return map;
+	entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+	const capped = {};
+	for (let i = 0; i < maxSize; i++) {
+		const [guid, count] = entries[i];
+		capped[guid] = count;
+	}
+	return capped;
+}
+async function fetchBlueBubblesMessagesSince(sinceMs, limit, opts) {
+	const client = createBlueBubblesClientFromParts({
+		baseUrl: opts.baseUrl,
+		password: opts.password,
+		allowPrivateNetwork: opts.allowPrivateNetwork,
+		timeoutMs: opts.timeoutMs ?? FETCH_TIMEOUT_MS
+	});
+	try {
+		const res = await client.request({
+			method: "POST",
+			path: "/api/v1/message/query",
+			body: {
+				limit,
+				sort: "ASC",
+				after: sinceMs,
+				with: [
+					"chat",
+					"chat.participants",
+					"attachment"
+				]
+			},
+			timeoutMs: opts.timeoutMs ?? FETCH_TIMEOUT_MS
+		});
+		if (!res.ok) return {
+			resolved: false,
+			messages: []
+		};
+		const json = await res.json().catch(() => null);
+		if (!json || !Array.isArray(json.data)) return {
+			resolved: false,
+			messages: []
+		};
+		const messages = [];
+		for (const entry of json.data) {
+			const rec = asRecord(entry);
+			if (rec) messages.push(rec);
+		}
+		return {
+			resolved: true,
+			messages
+		};
+	} catch {
+		return {
+			resolved: false,
+			messages: []
+		};
+	}
+}
+function clampCatchupConfig(raw) {
+	const maxAgeMinutes = Math.min(Math.max(raw?.maxAgeMinutes ?? DEFAULT_MAX_AGE_MINUTES, 1), MAX_MAX_AGE_MINUTES);
+	const perRunLimit = Math.min(Math.max(raw?.perRunLimit ?? DEFAULT_PER_RUN_LIMIT, 1), MAX_PER_RUN_LIMIT);
+	const firstRunLookbackMinutes = Math.min(Math.max(raw?.firstRunLookbackMinutes ?? DEFAULT_FIRST_RUN_LOOKBACK_MINUTES, 1), MAX_MAX_AGE_MINUTES);
+	const maxFailureRetries = Math.min(Math.max(Math.floor(raw?.maxFailureRetries ?? DEFAULT_MAX_FAILURE_RETRIES), 1), MAX_MAX_FAILURE_RETRIES);
+	return {
+		maxAgeMs: maxAgeMinutes * 6e4,
+		perRunLimit,
+		firstRunLookbackMs: firstRunLookbackMinutes * 6e4,
+		maxFailureRetries
+	};
+}
+/**
+* Fetch and replay BlueBubbles messages delivered since the persisted
+* catchup cursor, feeding each through the same `processMessage` pipeline
+* live webhooks use. Safe to call on every gateway startup: replays that
+* collide with #66230's inbound dedupe cache are dropped there, so a
+* message already processed via live webhook will not be processed twice.
+*
+* Returns the run summary, or `null` when disabled or aborted before the
+* first query.
+*
+* Concurrent calls for the same accountId are coalesced into a single
+* in-flight run via a module-level singleflight map. Without this, a
+* fire-and-forget trigger (monitor.ts) combined with an overlapping
+* webhook-target re-registration could race: two runs would read the
+* same cursor, compute divergent `nextCursorMs` values, and the last
+* writer could regress the cursor — causing repeated replay of the same
+* backlog on every subsequent startup.
+*/
+const inFlightCatchups = /* @__PURE__ */ new Map();
+function runBlueBubblesCatchup(target, deps = {}) {
+	const accountId = target.account.accountId;
+	const existing = inFlightCatchups.get(accountId);
+	if (existing) return existing;
+	const runPromise = runBlueBubblesCatchupInner(target, deps).finally(() => {
+		inFlightCatchups.delete(accountId);
+	});
+	inFlightCatchups.set(accountId, runPromise);
+	return runPromise;
+}
+async function runBlueBubblesCatchupInner(target, deps) {
+	const raw = target.account.config.catchup;
+	if (raw?.enabled === false) return null;
+	const now = deps.now ?? (() => Date.now());
+	const log = deps.log ?? target.runtime.log;
+	const error = deps.error ?? target.runtime.error;
+	const fetchFn = deps.fetchMessages ?? fetchBlueBubblesMessagesSince;
+	const procFn = deps.processMessageFn ?? processMessage;
+	const accountId = target.account.accountId;
+	const { maxAgeMs, perRunLimit, firstRunLookbackMs, maxFailureRetries } = clampCatchupConfig(raw);
+	const nowMs = now();
+	const existing = await loadBlueBubblesCatchupCursor(accountId).catch(() => null);
+	const cursorBefore = existing?.lastSeenMs ?? null;
+	const prevRetries = existing?.failureRetries ?? {};
+	const earliestAllowed = nowMs - maxAgeMs;
+	const windowStartMs = existing !== null && existing.lastSeenMs <= nowMs ? Math.max(existing.lastSeenMs, earliestAllowed) : Math.max(nowMs - firstRunLookbackMs, earliestAllowed);
+	let baseUrl;
+	let password;
+	let allowPrivateNetwork = false;
+	try {
+		({baseUrl, password, allowPrivateNetwork} = resolveBlueBubblesServerAccount({
+			serverUrl: target.account.baseUrl,
+			password: target.account.config.password,
+			accountId,
+			cfg: target.config
+		}));
+	} catch (err) {
+		error?.(`[${accountId}] BlueBubbles catchup: cannot resolve server account: ${String(err)}`);
+		return null;
+	}
+	await warmupBlueBubblesInboundDedupe(accountId).catch((err) => {
+		error?.(`[${accountId}] BlueBubbles catchup: dedupe warmup failed: ${String(err)}`);
+	});
+	const { resolved, messages } = await fetchFn(windowStartMs, perRunLimit, {
+		baseUrl,
+		password,
+		allowPrivateNetwork
+	});
+	const summary = {
+		querySucceeded: resolved,
+		replayed: 0,
+		skippedFromMe: 0,
+		skippedPreCursor: 0,
+		skippedGivenUp: 0,
+		failed: 0,
+		givenUp: 0,
+		cursorBefore,
+		cursorAfter: nowMs,
+		windowStartMs,
+		windowEndMs: nowMs,
+		fetchedCount: messages.length
+	};
+	if (!resolved) {
+		error?.(`[${accountId}] BlueBubbles catchup: message-query failed; cursor unchanged`);
+		return summary;
+	}
+	let earliestProcessFailureTs = null;
+	let latestFetchedTs = windowStartMs;
+	const nextRetries = {};
+	for (const rec of messages) {
+		const ts = typeof rec.dateCreated === "number" ? rec.dateCreated : 0;
+		if (ts > 0 && ts > latestFetchedTs) latestFetchedTs = ts;
+		if (ts > 0 && ts <= windowStartMs) {
+			summary.skippedPreCursor++;
+			continue;
+		}
+		if (rec.isFromMe === true || rec.is_from_me === true) {
+			summary.skippedFromMe++;
+			continue;
+		}
+		const assocGuid = typeof rec.associatedMessageGuid === "string" ? rec.associatedMessageGuid.trim() : typeof rec.associated_message_guid === "string" ? rec.associated_message_guid.trim() : "";
+		const assocType = rec.associatedMessageType ?? rec.associated_message_type;
+		const balloonId = typeof rec.balloonBundleId === "string" ? rec.balloonBundleId.trim() : "";
+		if (assocGuid && (assocType != null || balloonId)) continue;
+		const normalized = normalizeWebhookMessage({
+			type: "new-message",
+			data: rec
+		});
+		if (!normalized) {
+			summary.failed++;
+			continue;
+		}
+		if (normalized.fromMe) {
+			summary.skippedFromMe++;
+			continue;
+		}
+		const retryKey = normalized.messageId ?? (typeof rec.guid === "string" ? rec.guid : "");
+		const prevCount = retryKey ? prevRetries[retryKey] ?? 0 : 0;
+		if (retryKey && prevCount >= maxFailureRetries) {
+			summary.skippedGivenUp++;
+			nextRetries[retryKey] = prevCount;
+			continue;
+		}
+		try {
+			await procFn(normalized, target);
+			summary.replayed++;
+		} catch (err) {
+			summary.failed++;
+			const nextCount = prevCount + 1;
+			if (retryKey && nextCount >= maxFailureRetries) {
+				summary.givenUp++;
+				nextRetries[retryKey] = nextCount;
+				error?.(`[${accountId}] BlueBubbles catchup: giving up on guid=${retryKey} after ${nextCount} consecutive failures; future sweeps will skip this message. timestamp=${ts}: ${String(err)}`);
+			} else {
+				if (retryKey) nextRetries[retryKey] = nextCount;
+				if (ts > 0 && (earliestProcessFailureTs === null || ts < earliestProcessFailureTs)) earliestProcessFailureTs = ts;
+				error?.(`[${accountId}] BlueBubbles catchup: processMessage failed (retry ${nextCount}/${maxFailureRetries}): ${String(err)}`);
+			}
+		}
+	}
+	const isTruncated = summary.fetchedCount >= perRunLimit;
+	let nextCursorMs = nowMs;
+	if (earliestProcessFailureTs !== null) {
+		const heldCursor = Math.max(earliestProcessFailureTs - 1, cursorBefore ?? windowStartMs);
+		nextCursorMs = Math.min(heldCursor, nowMs);
+	} else if (isTruncated) nextCursorMs = Math.min(Math.max(latestFetchedTs, cursorBefore ?? windowStartMs), nowMs);
+	summary.cursorAfter = nextCursorMs;
+	const retriesToPersist = capFailureRetriesMap(nextRetries, MAX_FAILURE_RETRY_MAP_SIZE);
+	await saveBlueBubblesCatchupCursor(accountId, nextCursorMs, retriesToPersist).catch((err) => {
+		error?.(`[${accountId}] BlueBubbles catchup: cursor save failed: ${String(err)}`);
+	});
+	log?.(`[${accountId}] BlueBubbles catchup: replayed=${summary.replayed} skipped_fromMe=${summary.skippedFromMe} skipped_preCursor=${summary.skippedPreCursor} skipped_givenUp=${summary.skippedGivenUp} failed=${summary.failed} given_up=${summary.givenUp} fetched=${summary.fetchedCount} window_ms=${nowMs - windowStartMs}`);
+	if (isTruncated) error?.(`[${accountId}] BlueBubbles catchup: WARNING fetched=${summary.fetchedCount} hit perRunLimit=${perRunLimit}; cursor advanced only to page boundary, remaining messages will be picked up on next startup. Raise channels.bluebubbles...catchup.perRunLimit to drain larger backlogs in a single pass.`);
+	return summary;
+}
+//#endregion
+export { runBlueBubblesCatchup };

package/dist/channel-4YVnFcIj.js

@@ -0,0 +1,297 @@
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-CTXHUezn.js";
+import { r as createLazyRuntimeModule } from "./lazy-runtime-B-T6H2Zb.js";
+import { p as formatTrimmedAllowFromEntries, s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-u7T-fXUn.js";
+import { t as buildOutboundBaseSessionKey } from "./base-session-key-B-DTLUBu.js";
+import { n as describeAccountSnapshot } from "./account-helpers-BO4UPATV.js";
+import { c as getChatChannelMeta, i as createChatChannelPlugin, r as createChannelPluginBase } from "./core-CYaV0wrq.js";
+import "./channel-core-VlXrdyfV.js";
+import "./routing-C4eysASR.js";
+import { r as createRestrictSendersChannelSecurity } from "./channel-policy-CKro2sO6.js";
+import { c as collectStatusIssuesFromLastError, d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-pM311_XZ.js";
+import { t as sanitizeForPlainText } from "./sanitize-text-B0aeNV74.js";
+import "./outbound-runtime-D7qdGq1B.js";
+import { t as chunkTextForOutbound } from "./text-chunking-Bn3xVWoL.js";
+import { n as buildDmGroupAccountAllowlistAdapter } from "./allowlist-config-edit-3goBsyY-.js";
+import { n as buildPassiveProbedChannelStatusSummary } from "./extension-shared-B4iTRjxK.js";
+import { a as listIMessageAccountIds, n as resolveIMessageAttachmentRoots, o as resolveDefaultIMessageAccountId, r as resolveIMessageRemoteAttachmentRoots, s as resolveIMessageAccount } from "./media-contract-Cu5jtr6E.js";
+import { c as looksLikeIMessageExplicitTargetId, d as parseIMessageTarget, i as resolveIMessageConversationIdFromTarget, l as normalizeIMessageHandle, n as matchIMessageAcpConversation, o as inferIMessageTargetChatType, p as normalizeIMessageMessagingTarget, r as normalizeIMessageAcpConversationId } from "./conversation-id-BwNpVXFJ.js";
+import { n as createIMessageConversationBindingManager } from "./conversation-bindings-Dxujbg9m.js";
+import { n as resolveIMessageGroupToolPolicy, t as resolveIMessageGroupRequireMention } from "./group-policy-BYrJP8Ey.js";
+import { a as imessageSetupAdapter, n as createIMessageSetupWizardProxy } from "./setup-core-CpfGqHuS.js";
+import { t as IMessageChannelConfigSchema } from "./config-schema-CTQkD3bR.js";
+//#region extensions/imessage/src/shared.ts
+const IMESSAGE_CHANNEL = "imessage";
+async function loadIMessageChannelRuntime$1() {
+	return await import("./channel.runtime-MJe9DoSG.js");
+}
+const imessageSetupWizard = createIMessageSetupWizardProxy(async () => (await loadIMessageChannelRuntime$1()).imessageSetupWizard);
+const imessageConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: IMESSAGE_CHANNEL,
+	listAccountIds: listIMessageAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveIMessageAccount),
+	defaultAccountId: resolveDefaultIMessageAccountId,
+	clearBaseFields: [
+		"cliPath",
+		"dbPath",
+		"service",
+		"region",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => formatTrimmedAllowFromEntries(allowFrom),
+	resolveDefaultTo: (account) => account.config.defaultTo
+});
+const imessageSecurityAdapter = createRestrictSendersChannelSecurity({
+	channelKey: IMESSAGE_CHANNEL,
+	resolveDmPolicy: (account) => account.config.dmPolicy,
+	resolveDmAllowFrom: (account) => account.config.allowFrom,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	surface: "iMessage groups",
+	openScope: "any member",
+	groupPolicyPath: "channels.imessage.groupPolicy",
+	groupAllowFromPath: "channels.imessage.groupAllowFrom",
+	mentionGated: false,
+	policyPathSuffix: "dmPolicy"
+});
+function createIMessagePluginBase(params) {
+	return {
+		...createChannelPluginBase({
+			id: IMESSAGE_CHANNEL,
+			meta: {
+				...getChatChannelMeta(IMESSAGE_CHANNEL),
+				aliases: ["imsg"],
+				showConfigured: false
+			},
+			setupWizard: params.setupWizard,
+			capabilities: {
+				chatTypes: ["direct", "group"],
+				media: true
+			},
+			reload: { configPrefixes: ["channels.imessage"] },
+			configSchema: IMessageChannelConfigSchema,
+			config: {
+				...imessageConfigAdapter,
+				isConfigured: (account) => account.configured,
+				describeAccount: (account) => describeAccountSnapshot({
+					account,
+					configured: account.configured
+				})
+			},
+			security: imessageSecurityAdapter,
+			setup: params.setup
+		}),
+		messaging: {
+			resolveInboundAttachmentRoots: (params) => resolveIMessageAttachmentRoots({
+				accountId: params.accountId,
+				cfg: params.cfg
+			}),
+			resolveRemoteInboundAttachmentRoots: (params) => resolveIMessageRemoteAttachmentRoots({
+				accountId: params.accountId,
+				cfg: params.cfg
+			})
+		}
+	};
+}
+//#endregion
+//#region extensions/imessage/src/status-core.ts
+async function probeIMessageStatusAccount(params) {
+	return await params.probeIMessageAccount({
+		timeoutMs: params.timeoutMs,
+		cliPath: params.account.config.cliPath,
+		dbPath: params.account.config.dbPath
+	});
+}
+//#endregion
+//#region extensions/imessage/src/channel.ts
+const loadIMessageChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-MJe9DoSG.js"));
+function buildIMessageBaseSessionKey(params) {
+	return buildOutboundBaseSessionKey({
+		...params,
+		channel: "imessage"
+	});
+}
+function resolveIMessageOutboundSessionRoute(params) {
+	const parsed = parseIMessageTarget(params.target);
+	if (parsed.kind === "handle") {
+		const handle = normalizeIMessageHandle(parsed.to);
+		if (!handle) return null;
+		const peer = {
+			kind: "direct",
+			id: handle
+		};
+		const baseSessionKey = buildIMessageBaseSessionKey({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			accountId: params.accountId,
+			peer
+		});
+		return {
+			sessionKey: baseSessionKey,
+			baseSessionKey,
+			peer,
+			chatType: "direct",
+			from: `imessage:${handle}`,
+			to: `imessage:${handle}`
+		};
+	}
+	const peerId = parsed.kind === "chat_id" ? String(parsed.chatId) : parsed.kind === "chat_guid" ? parsed.chatGuid : parsed.chatIdentifier;
+	if (!peerId) return null;
+	const peer = {
+		kind: "group",
+		id: peerId
+	};
+	const baseSessionKey = buildIMessageBaseSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		accountId: params.accountId,
+		peer
+	});
+	const toPrefix = parsed.kind === "chat_id" ? "chat_id" : parsed.kind === "chat_guid" ? "chat_guid" : "chat_identifier";
+	return {
+		sessionKey: baseSessionKey,
+		baseSessionKey,
+		peer,
+		chatType: "group",
+		from: `imessage:group:${peerId}`,
+		to: `${toPrefix}:${peerId}`
+	};
+}
+const imessagePlugin = createChatChannelPlugin({
+	base: {
+		...createIMessagePluginBase({
+			setupWizard: imessageSetupWizard,
+			setup: imessageSetupAdapter
+		}),
+		allowlist: buildDmGroupAccountAllowlistAdapter({
+			channelId: "imessage",
+			resolveAccount: resolveIMessageAccount,
+			normalize: ({ values }) => formatTrimmedAllowFromEntries(values),
+			resolveDmAllowFrom: (account) => account.config.allowFrom,
+			resolveGroupAllowFrom: (account) => account.config.groupAllowFrom,
+			resolveDmPolicy: (account) => account.config.dmPolicy,
+			resolveGroupPolicy: (account) => account.config.groupPolicy
+		}),
+		groups: {
+			resolveRequireMention: resolveIMessageGroupRequireMention,
+			resolveToolPolicy: resolveIMessageGroupToolPolicy
+		},
+		doctor: { groupAllowFromFallbackToAllowFrom: false },
+		conversationBindings: {
+			supportsCurrentConversationBinding: true,
+			createManager: ({ cfg, accountId }) => createIMessageConversationBindingManager({
+				cfg,
+				accountId: accountId ?? void 0
+			})
+		},
+		bindings: {
+			compileConfiguredBinding: ({ conversationId }) => normalizeIMessageAcpConversationId(conversationId),
+			matchInboundConversation: ({ compiledBinding, conversationId }) => matchIMessageAcpConversation({
+				bindingConversationId: compiledBinding.conversationId,
+				conversationId
+			}),
+			resolveCommandConversation: ({ originatingTo, commandTo, fallbackTo }) => {
+				const conversationId = resolveIMessageConversationIdFromTarget(originatingTo ?? "") ?? resolveIMessageConversationIdFromTarget(commandTo ?? "") ?? resolveIMessageConversationIdFromTarget(fallbackTo ?? "");
+				return conversationId ? { conversationId } : null;
+			}
+		},
+		messaging: {
+			normalizeTarget: normalizeIMessageMessagingTarget,
+			inferTargetChatType: ({ to }) => inferIMessageTargetChatType(to),
+			resolveOutboundSessionRoute: (params) => resolveIMessageOutboundSessionRoute(params),
+			targetResolver: {
+				looksLikeId: looksLikeIMessageExplicitTargetId,
+				hint: "<handle|chat_id:ID>",
+				resolveTarget: async ({ normalized }) => {
+					const to = normalized?.trim();
+					if (!to) return null;
+					const chatType = inferIMessageTargetChatType(to);
+					if (!chatType) return null;
+					return {
+						to,
+						kind: chatType === "direct" ? "user" : "group",
+						source: "normalized"
+					};
+				}
+			}
+		},
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+				cliPath: null,
+				dbPath: null
+			}),
+			collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("imessage", accounts),
+			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+				cliPath: snapshot.cliPath ?? null,
+				dbPath: snapshot.dbPath ?? null
+			}),
+			probeAccount: async ({ account, timeoutMs }) => await probeIMessageStatusAccount({
+				account,
+				timeoutMs,
+				probeIMessageAccount: async (params) => await (await loadIMessageChannelRuntime()).probeIMessageAccount(params)
+			}),
+			resolveAccountSnapshot: ({ account, runtime }) => ({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: account.configured,
+				extra: {
+					cliPath: runtime?.cliPath ?? account.config.cliPath ?? null,
+					dbPath: runtime?.dbPath ?? account.config.dbPath ?? null
+				}
+			}),
+			resolveAccountState: ({ enabled }) => enabled ? "enabled" : "disabled"
+		}),
+		gateway: { startAccount: async (ctx) => {
+			const conversationBindings = createIMessageConversationBindingManager({
+				cfg: ctx.cfg,
+				accountId: ctx.accountId
+			});
+			try {
+				return await (await loadIMessageChannelRuntime()).startIMessageGatewayAccount(ctx);
+			} finally {
+				conversationBindings.stop();
+			}
+		} }
+	},
+	pairing: { text: {
+		idLabel: "imessageSenderId",
+		message: "Genesis: your access has been approved.",
+		notify: async ({ id, cfg }) => await (await loadIMessageChannelRuntime()).notifyIMessageApproval({
+			id,
+			cfg
+		})
+	} },
+	security: imessageSecurityAdapter,
+	outbound: {
+		base: {
+			deliveryMode: "direct",
+			chunker: chunkTextForOutbound,
+			chunkerMode: "text",
+			textChunkLimit: 4e3,
+			sanitizeText: ({ text }) => sanitizeForPlainText(text)
+		},
+		attachedResults: {
+			channel: "imessage",
+			sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => await (await loadIMessageChannelRuntime()).sendIMessageOutbound({
+				cfg,
+				to,
+				text,
+				accountId: accountId ?? void 0,
+				deps,
+				replyToId: replyToId ?? void 0
+			}),
+			sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId }) => await (await loadIMessageChannelRuntime()).sendIMessageOutbound({
+				cfg,
+				to,
+				text,
+				mediaUrl,
+				mediaLocalRoots,
+				accountId: accountId ?? void 0,
+				deps,
+				replyToId: replyToId ?? void 0
+			})
+		}
+	}
+});
+//#endregion
+export { createIMessagePluginBase as n, imessageSetupWizard as r, imessagePlugin as t };