@openclaw/imessage 2026.9.1-beta.1 → 2026.9.2

package/dist/{send-DVQY6M5M.js → send-DC981dqK.js}

@@ -1,17 +1,18 @@
-import { d as resolveIMessageChatDbLookupPath, l as resolveIMessageRemoteHost, n as hasExclusiveIMessageLocalDatabase, o as resolveIMessageAccount } from "./accounts-DIpGOIiN.js";
-import { l as parseIMessageTarget, n as formatIMessageChatTarget, s as normalizeIMessageHandle } from "./message-tool-api-BwIxJDoz.js";
-import { c as rememberIMessageReplyCache, h as chatContextFromIMessageTarget, p as getOptionalIMessageRuntime, v as resolveIMessageDirectChatService } from "./monitor-reply-cache-BdeUQaHO.js";
-import { a as IMessageRpcRequestError, n as sanitizeIMessageFinalOutboundText, o as createIMessageRpcClient, t as protectIMessageFencedRoleMarkers } from "./sanitize-outbound-g651fIhi.js";
-import { l as getIMessageApprovalApprovers, u as imessageApprovalAuth } from "./group-policy-BipELT2x.js";
-import { a as rememberPersistedIMessageEcho, r as forgetPersistedIMessageEchoKey } from "./persisted-echo-cache-DGxy-J4t.js";
-import { d as normalizeConversationKey, f as normalizeIMessageGuid, i as registerIMessageApprovalReactionTarget, l as enumerateApprovalTargetKeys, s as buildIMessageApprovalConversationKeyForInbound, u as enumerateConversationKeyForms } from "./approval-reactions-Cvwmdlev.js";
-import { i as runIMessageCliJsonCommand, r as resolveAuthorizedIMessageReplyReference, t as withIMessageRemoteFile } from "./remote-file-CyTTuRAt.js";
+import { d as resolveIMessageChatDbLookupPath, l as resolveIMessageRemoteHost, n as hasExclusiveIMessageLocalDatabase, o as resolveIMessageAccount } from "./accounts-CCirBEIm.js";
+import { l as parseIMessageTarget, n as formatIMessageChatTarget, s as normalizeIMessageHandle } from "./message-tool-api-CUoFESHj.js";
+import { a as IMessageRpcRequestError, d as rememberIMessageReplyCache, g as chatContextFromIMessageTarget, n as sanitizeIMessageFinalOutboundText, o as createIMessageRpcClient, s as runIMessageCliJsonCommand, t as protectIMessageFencedRoleMarkers, y as resolveIMessageDirectChatService } from "./sanitize-outbound-Bvo4g1Mp.js";
+import { l as getIMessageApprovalApprovers, u as imessageApprovalAuth } from "./group-policy-Cp8SDG4G.js";
+import { n as getOptionalIMessageRuntime, t as getIMessageRuntime } from "./runtime-Cza4CY5T.js";
+import { c as IMESSAGE_SENT_ECHOES_TTL_MS, d as resolveIMessageEchoMediaKey, p as resolveIMessageSentEchoEntryKey, s as IMESSAGE_SENT_ECHOES_NAMESPACE } from "./state-contract-DvahEY4X.js";
+import { d as normalizeConversationKey, i as registerIMessageApprovalReactionTarget, l as enumerateApprovalTargetKeys, s as buildIMessageApprovalConversationKeyForInbound, u as enumerateConversationKeyForms } from "./approval-reactions-sVpDno7d.js";
+import { n as normalizeIMessageGuid } from "./reaction-context-Br-vAJFp.js";
+import { r as resolveAuthorizedIMessageReplyReference, t as withIMessageRemoteFile } from "./remote-file-Biz5PjXi.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeSurface } from "openclaw/plugin-sdk/lazy-runtime";
 import { accessSync, constants } from "node:fs";
 import { basename } from "node:path";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { sleep } from "openclaw/plugin-sdk/runtime-env";
+import { logVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
 import { extractOriginalFilename, kindFromMime, resolveOutboundAttachmentFromUrl } from "openclaw/plugin-sdk/media-runtime";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import { PlatformMessageNotDispatchedError, isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
@@ -94,14 +95,14 @@ const iMessageApprovalControlBindings = {
 const TARGET_NAMESPACE = "imessage.approval-polls";
 const TOMBSTONE_NAMESPACE = "imessage.approval-poll-tombstones";
 const MAX_ENTRIES = 1e3;
-const DEFAULT_TARGET_TTL_MS = 1440 * 60 * 1e3;
+const DEFAULT_TARGET_TTL_MS = 864e5;
 /**
 * Messages has no close-poll API, so a resolved approval's balloon stays
 * tappable forever. Tombstones outlive the binding so late taps are swallowed
 * instead of reaching the agent as "Poll vote: ..." prose. Persisted, because a
 * gateway restart must not turn old polls back into chat noise.
 */
-const TOMBSTONE_TTL_MS = 720 * 60 * 60 * 1e3;
+const TOMBSTONE_TTL_MS = 2592e6;
 const APPROVAL_DECISIONS = /* @__PURE__ */ new Set([
 	"allow-once",
 	"allow-always",
@@ -453,6 +454,127 @@ const iMessageApprovalPollTargets = {
 	clearForTest: clearIMessageApprovalPollTargetsForTest
 };
 //#endregion
+//#region extensions/imessage/src/monitor/echo-text-corruption.ts
+function isLeadingEchoTextCorruptionMarker(code) {
+	return code === 0 || code === 65279 || code === 65533 || code === 65534 || code === 65535;
+}
+function stripLeadingEchoTextCorruptionMarkers(text) {
+	let offset = 0;
+	while (offset < text.length && isLeadingEchoTextCorruptionMarker(text.charCodeAt(offset))) offset += 1;
+	return offset === 0 ? text : text.slice(offset);
+}
+//#endregion
+//#region extensions/imessage/src/monitor/persisted-echo-cache.ts
+function normalizeText(text) {
+	if (!text) return;
+	return stripLeadingEchoTextCorruptionMarkers(text.replace(/\r\n?/g, "\n").trim()).trim() || void 0;
+}
+function normalizeMessageId(messageId) {
+	const normalized = messageId?.trim();
+	if (!normalized || normalized === "ok" || normalized === "unknown") return;
+	return normalized;
+}
+let mirror = null;
+let persistenceFailureLogged = false;
+function reportFailure(scope, err) {
+	if (persistenceFailureLogged) return;
+	persistenceFailureLogged = true;
+	logVerbose(`imessage echo-cache: ${scope} disabled after first failure: ${String(err)}`);
+}
+function normalizeMedia(media) {
+	if (!resolveIMessageEchoMediaKey(media)) return;
+	const contentType = media?.contentType?.trim().toLowerCase() || void 0;
+	const kind = media?.kind ?? void 0;
+	return {
+		...kind ? { kind } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+function openPersistedEchoStore() {
+	return getIMessageRuntime().state.openSyncKeyedStore({
+		namespace: IMESSAGE_SENT_ECHOES_NAMESPACE,
+		maxEntries: 256
+	});
+}
+function remainingTtlMs(timestamp) {
+	const remaining = IMESSAGE_SENT_ECHOES_TTL_MS - Math.max(0, Date.now() - timestamp);
+	return remaining > 0 ? remaining : void 0;
+}
+function resolveEntryTtlMs(entry, ttlMs) {
+	if (typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0) return ttlMs;
+	return remainingTtlMs(entry.timestamp);
+}
+function isLiveEntry(entry, now = Date.now()) {
+	const cutoff = now - IMESSAGE_SENT_ECHOES_TTL_MS;
+	return entry.timestamp >= cutoff && (entry.expiresAt == null || entry.expiresAt > now);
+}
+function loadMirrorFromStore() {
+	try {
+		mirror = openPersistedEchoStore().entries().map(({ value }) => value).filter((entry) => isLiveEntry(entry)).toSorted((a, b) => a.timestamp - b.timestamp).slice(-256);
+	} catch (err) {
+		reportFailure("read", err);
+		mirror = [];
+	}
+}
+function readRecentEntries() {
+	loadMirrorFromStore();
+	return mirror ?? [];
+}
+function persistEntry(entry, ttlMs) {
+	const effectiveTtlMs = resolveEntryTtlMs(entry, ttlMs);
+	if (!effectiveTtlMs) return;
+	const key = resolveIMessageSentEchoEntryKey(entry);
+	try {
+		openPersistedEchoStore().register(key, entry, { ttlMs: effectiveTtlMs });
+	} catch (err) {
+		reportFailure("write", err);
+		return;
+	}
+	return key;
+}
+function rememberPersistedIMessageEcho(params) {
+	const text = normalizeText(params.text);
+	const media = normalizeMedia(params.media);
+	const messageId = normalizeMessageId(params.messageId);
+	const entry = {
+		scope: params.scope,
+		timestamp: Date.now(),
+		...text ? { text } : {},
+		...media ? { media } : {},
+		...messageId ? { messageId } : {},
+		...params.pending ? { pending: true } : {}
+	};
+	if (typeof params.ttlMs === "number" && Number.isFinite(params.ttlMs) && params.ttlMs > 0) entry.expiresAt = entry.timestamp + params.ttlMs;
+	if (!entry.text && !entry.media && !entry.messageId) return;
+	loadMirrorFromStore();
+	const key = persistEntry(entry, params.ttlMs);
+	mirror = [...mirror ?? [], entry].filter((candidate) => isLiveEntry(candidate)).slice(-256);
+	return key;
+}
+function forgetPersistedIMessageEchoKey(key) {
+	if (!key) return;
+	try {
+		openPersistedEchoStore().delete(key);
+	} catch (err) {
+		reportFailure("delete", err);
+	}
+	mirror = (mirror ?? []).filter((entry) => resolveIMessageSentEchoEntryKey(entry) !== key);
+}
+function hasPersistedIMessageEcho(params) {
+	const text = normalizeText(params.text);
+	const mediaKey = resolveIMessageEchoMediaKey(params.media);
+	const messageId = normalizeMessageId(params.messageId);
+	if (!text && !mediaKey && !messageId) return false;
+	for (const entry of readRecentEntries()) {
+		if (entry.scope !== params.scope) continue;
+		if (messageId && entry.messageId === messageId) return true;
+		const hasConflictingMessageIds = Boolean(messageId && entry.messageId && messageId !== entry.messageId);
+		if (text && (!hasConflictingMessageIds || params.skipIdShortCircuit) && entry.text === text && (!entry.pending || params.includePendingText)) return true;
+		if (mediaKey && !hasConflictingMessageIds && resolveIMessageEchoMediaKey(entry.media) === mediaKey && (!entry.pending || params.includePendingText)) return true;
+	}
+	return false;
+}
+//#endregion
 //#region extensions/imessage/src/send.ts
 const MIN_PENDING_PERSISTED_ECHO_TTL_MS = 6e4;
 const PENDING_PERSISTED_ECHO_GRACE_MS = 5e3;
@@ -722,16 +844,17 @@ async function trySendAttachmentForTarget(params) {
 	if (params.target.kind === "handle" && !params.audioAsVoice && params.sendTransport !== "bridge" && (params.service === "sms" || params.service === "imessage")) return null;
 	if (params.remoteHost && params.sendTransport === "applescript") return null;
 	let attachmentChatTarget = null;
-	if (params.remoteHost) if (params.target.kind === "chat_guid") attachmentChatTarget = params.target.chatGuid;
-	else if (params.target.kind === "chat_identifier") attachmentChatTarget = params.target.chatIdentifier;
-	else if (params.target.kind === "handle") {
-		const normalizedHandle = normalizeIMessageHandle(params.target.to);
-		if (normalizedHandle) {
-			const service = params.target.service !== "auto" ? params.target.service : params.service;
-			attachmentChatTarget = `${service === "sms" ? "SMS" : service === "imessage" ? "iMessage" : "any"};-;${normalizedHandle}`;
-		}
-	} else attachmentChatTarget = formatIMessageChatTarget(params.target.chatId);
-	else try {
+	if (params.remoteHost) {
+		if (params.target.kind === "chat_guid") attachmentChatTarget = params.target.chatGuid;
+		else if (params.target.kind === "chat_identifier") attachmentChatTarget = params.target.chatIdentifier;
+		else if (params.target.kind === "handle") {
+			const normalizedHandle = normalizeIMessageHandle(params.target.to);
+			if (normalizedHandle) {
+				const service = params.target.service !== "auto" ? params.target.service : params.service;
+				attachmentChatTarget = `${service === "sms" ? "SMS" : service === "imessage" ? "iMessage" : "any"};-;${normalizedHandle}`;
+			}
+		} else attachmentChatTarget = formatIMessageChatTarget(params.target.chatId);
+	} else try {
 		attachmentChatTarget = await resolveAttachmentChatTarget({
 			target: params.target,
 			service: params.service,
@@ -881,7 +1004,7 @@ async function sendMessageIMessage(to, text, opts) {
 	const timeoutMs = opts.timeoutMs ?? Math.max(account.config.probeTimeoutMs ?? 0, 18e4);
 	const pendingEchoTtlMs = resolvePendingPersistedEchoTtlMs(timeoutMs);
 	const region = opts.region?.trim() || account.config.region?.trim() || "US";
-	const maxBytes = typeof opts.maxBytes === "number" ? opts.maxBytes : typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : 16 * 1024 * 1024;
+	const maxBytes = typeof opts.maxBytes === "number" ? opts.maxBytes : typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : 16777216;
 	let message = opts.approvalPrompt ? addApprovalReactionHintToText({
 		text,
 		allowedDecisions: opts.approvalPrompt.allowedDecisions
@@ -1173,4 +1296,4 @@ async function sendMessageIMessage(to, text, opts) {
 	}
 }
 //#endregion
-export { maybeResolveIMessageApprovalPollVote as a, mapSentPollOptionsToDecisions as i, buildApprovalPollOptions as n, iMessageApprovalControlBindings as o, iMessageApprovalPollTargets as r, sendMessageIMessage as t };
+export { iMessageApprovalPollTargets as a, iMessageApprovalControlBindings as c, buildApprovalPollOptions as i, hasPersistedIMessageEcho as n, mapSentPollOptionsToDecisions as o, stripLeadingEchoTextCorruptionMarkers as r, maybeResolveIMessageApprovalPollVote as s, sendMessageIMessage as t };

package/dist/state-contract-DvahEY4X.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+//#region extensions/imessage/src/state-contract.ts
+const IMESSAGE_REPLY_CACHE_NAMESPACE = "imessage.reply-cache";
+const IMESSAGE_REPLY_CACHE_MAX_ENTRIES = 2e3;
+const IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE = "imessage.reply-cache-counter";
+const IMESSAGE_REPLY_CACHE_COUNTER_KEY = "short-id-counter";
+const IMESSAGE_REPLY_CACHE_TTL_MS = 216e5;
+function resolveIMessageReplyCacheEntryKey(messageId) {
+	return createHash("sha256").update(messageId, "utf8").digest("hex").slice(0, 32);
+}
+const MAX_FAILURE_RETRY_MAP_SIZE = 512;
+const MAX_FAILURE_RETRY_MAP_JSON_BYTES = 48e3;
+const textEncoder = new TextEncoder();
+const IMESSAGE_CATCHUP_CURSOR_NAMESPACE = "imessage.catchup-cursors";
+function resolveIMessageCatchupCursorKey(accountId) {
+	return createHash("sha256").update(accountId, "utf8").digest("hex").slice(0, 32);
+}
+/**
+* Bound the retry map so a pathological storm of unique failing GUIDs
+* cannot grow the cursor value without limit. Keeps the `maxSize` entries
+* with the highest counts (closest to give-up) when over the bound.
+*/
+function capFailureRetriesMap(map, maxSize = MAX_FAILURE_RETRY_MAP_SIZE, maxBytes = MAX_FAILURE_RETRY_MAP_JSON_BYTES) {
+	const entries = Object.entries(map);
+	if (entries.length <= maxSize && textEncoder.encode(JSON.stringify(map)).byteLength <= maxBytes) return map;
+	entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+	const capped = {};
+	for (const [guid, count] of entries.slice(0, maxSize)) {
+		capped[guid] = count;
+		if (textEncoder.encode(JSON.stringify(capped)).byteLength > maxBytes) {
+			delete capped[guid];
+			break;
+		}
+	}
+	return capped;
+}
+const IMESSAGE_SENT_ECHOES_TTL_MS = 432e5;
+const IMESSAGE_SENT_ECHOES_NAMESPACE = "imessage.sent-echoes";
+function resolveIMessageSentEchoEntryKey(entry) {
+	return createHash("sha256").update(JSON.stringify([
+		entry.scope,
+		entry.text ?? "",
+		resolveIMessageEchoMediaKey(entry.media) ?? "",
+		entry.messageId ?? "",
+		entry.timestamp
+	])).digest("hex").slice(0, 32);
+}
+function resolveIMessageEchoMediaKey(media) {
+	const contentType = media?.contentType?.trim().toLowerCase() || void 0;
+	const kind = media?.kind && media.kind !== "unknown" ? media.kind : void 0;
+	if (kind) return `kind:${kind}`;
+	const normalizedContentType = contentType?.split(";", 1)[0]?.trim();
+	return normalizedContentType ? `mime:${normalizedContentType}` : void 0;
+}
+//#endregion
+export { IMESSAGE_REPLY_CACHE_NAMESPACE as a, IMESSAGE_SENT_ECHOES_TTL_MS as c, resolveIMessageEchoMediaKey as d, resolveIMessageReplyCacheEntryKey as f, IMESSAGE_REPLY_CACHE_MAX_ENTRIES as i, capFailureRetriesMap as l, IMESSAGE_REPLY_CACHE_COUNTER_KEY as n, IMESSAGE_REPLY_CACHE_TTL_MS as o, resolveIMessageSentEchoEntryKey as p, IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE as r, IMESSAGE_SENT_ECHOES_NAMESPACE as s, IMESSAGE_CATCHUP_CURSOR_NAMESPACE as t, resolveIMessageCatchupCursorKey as u };

package/dist/state-migrations-D-fyHVcb.js

@@ -0,0 +1,277 @@
+import { a as resolveDefaultIMessageAccountId, i as listIMessageAccountIds, o as resolveIMessageAccount } from "./accounts-CCirBEIm.js";
+import { a as IMESSAGE_REPLY_CACHE_NAMESPACE, c as IMESSAGE_SENT_ECHOES_TTL_MS, f as resolveIMessageReplyCacheEntryKey, i as IMESSAGE_REPLY_CACHE_MAX_ENTRIES, l as capFailureRetriesMap, n as IMESSAGE_REPLY_CACHE_COUNTER_KEY, o as IMESSAGE_REPLY_CACHE_TTL_MS, p as resolveIMessageSentEchoEntryKey, r as IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE, s as IMESSAGE_SENT_ECHOES_NAMESPACE, t as IMESSAGE_CATCHUP_CURSOR_NAMESPACE, u as resolveIMessageCatchupCursorKey } from "./state-contract-DvahEY4X.js";
+import fs from "node:fs";
+import path from "node:path";
+import { asFiniteNumber, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import { fileExists } from "openclaw/plugin-sdk/file-access-runtime";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+//#region extensions/imessage/src/state-migrations.ts
+function resolveMigrationStateDir(params) {
+	return params.stateDir ?? resolveStateDir(params.env);
+}
+function remainingTtlMs(timestamp, ttlMs) {
+	const remaining = ttlMs - Math.max(0, Date.now() - timestamp);
+	return remaining > 0 ? remaining : void 0;
+}
+function readJsonl(pathValue) {
+	try {
+		return fs.readFileSync(pathValue, "utf8").split(/\n+/).flatMap((line) => {
+			if (!line) return [];
+			try {
+				return [JSON.parse(line)];
+			} catch {
+				return [];
+			}
+		});
+	} catch (err) {
+		throw new Error(`Failed reading ${pathValue}: ${String(err)}`, { cause: err });
+	}
+}
+function parseReplyCacheEntry(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const parsed = raw;
+	if (typeof parsed.accountId !== "string" || typeof parsed.messageId !== "string" || typeof parsed.shortId !== "string" || typeof parsed.timestamp !== "number") return null;
+	return {
+		accountId: parsed.accountId,
+		messageId: parsed.messageId,
+		shortId: parsed.shortId,
+		timestamp: parsed.timestamp,
+		...typeof parsed.chatGuid === "string" ? { chatGuid: parsed.chatGuid } : {},
+		...typeof parsed.chatIdentifier === "string" ? { chatIdentifier: parsed.chatIdentifier } : {},
+		...typeof parsed.chatId === "number" ? { chatId: parsed.chatId } : {},
+		...typeof parsed.isFromMe === "boolean" ? { isFromMe: parsed.isFromMe } : {}
+	};
+}
+function readReplyCacheMaxShortId(sourcePath) {
+	let max = 0;
+	for (const raw of readJsonl(sourcePath)) {
+		if (!raw || typeof raw !== "object") continue;
+		const shortId = raw.shortId;
+		if (typeof shortId !== "string") continue;
+		const numeric = Number.parseInt(shortId, 10);
+		if (Number.isFinite(numeric) && numeric > max) max = numeric;
+	}
+	return max;
+}
+function readReplyCounterValue(value) {
+	if (!value || typeof value !== "object") return null;
+	const counter = value.counter;
+	return asFiniteNumber(counter) ?? null;
+}
+function shouldReplaceReplyCounter(existingValue, incomingValue) {
+	const incomingCounter = readReplyCounterValue(incomingValue);
+	if (incomingCounter === null) return false;
+	const existingCounter = readReplyCounterValue(existingValue);
+	return existingCounter === null || incomingCounter > existingCounter;
+}
+function parseSentEchoEntry(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const parsed = raw;
+	if (typeof parsed.scope !== "string" || typeof parsed.timestamp !== "number") return null;
+	return {
+		scope: parsed.scope,
+		timestamp: parsed.timestamp,
+		...typeof parsed.text === "string" ? { text: parsed.text } : {},
+		...typeof parsed.messageId === "string" ? { messageId: parsed.messageId } : {}
+	};
+}
+function listReplyCacheEntries(sourcePath) {
+	const entriesByKey = /* @__PURE__ */ new Map();
+	for (const entry of readJsonl(sourcePath).map(parseReplyCacheEntry)) {
+		if (!entry) continue;
+		const ttlMs = remainingTtlMs(entry.timestamp, IMESSAGE_REPLY_CACHE_TTL_MS);
+		if (!ttlMs) continue;
+		const key = resolveIMessageReplyCacheEntryKey(entry.messageId);
+		entriesByKey.delete(key);
+		entriesByKey.set(key, {
+			value: entry,
+			ttlMs
+		});
+	}
+	return [...entriesByKey.entries()].slice(-IMESSAGE_REPLY_CACHE_MAX_ENTRIES).map(([key, entry]) => ({
+		key,
+		value: entry.value,
+		ttlMs: entry.ttlMs
+	}));
+}
+function listSentEchoEntries(sourcePath) {
+	return readJsonl(sourcePath).map(parseSentEchoEntry).filter((entry) => Boolean(entry)).slice(-256).flatMap((entry) => {
+		const ttlMs = remainingTtlMs(entry.timestamp, IMESSAGE_SENT_ECHOES_TTL_MS);
+		if (!ttlMs) return [];
+		return [{
+			key: resolveIMessageSentEchoEntryKey(entry),
+			value: entry,
+			ttlMs
+		}];
+	});
+}
+function resolveLegacyCatchupCursorPath(stateDir, 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(stateDir, "imessage", "catchup", `${safePrefix}__${hash}.json`);
+}
+function listLegacyCatchupCursorPaths(stateDir) {
+	const dir = path.join(stateDir, "imessage", "catchup");
+	try {
+		return fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path.join(dir, entry.name));
+	} catch {
+		return [];
+	}
+}
+function normalizeCatchupCursor(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const value = raw;
+	if (typeof value.lastSeenMs !== "number" || !Number.isFinite(value.lastSeenMs) || typeof value.lastSeenRowid !== "number" || !Number.isFinite(value.lastSeenRowid)) return null;
+	const failureRetries = sanitizeCatchupFailureRetries(value.failureRetries);
+	const hasRetries = Object.keys(failureRetries).length > 0;
+	return {
+		lastSeenMs: value.lastSeenMs,
+		lastSeenRowid: value.lastSeenRowid,
+		updatedAt: typeof value.updatedAt === "number" ? value.updatedAt : 0,
+		...hasRetries ? { failureRetries } : {}
+	};
+}
+function readCatchupCursor(sourcePath) {
+	let parsed;
+	try {
+		parsed = JSON.parse(fs.readFileSync(sourcePath, "utf8"));
+	} catch (err) {
+		throw new Error(`Failed reading ${sourcePath}: ${String(err)}`, { cause: err });
+	}
+	const cursor = normalizeCatchupCursor(parsed);
+	if (!cursor) throw new Error(`Invalid iMessage catchup cursor: ${sourcePath}`);
+	return cursor;
+}
+function sanitizeCatchupFailureRetries(raw) {
+	if (!raw || typeof raw !== "object") return {};
+	const out = {};
+	for (const [guid, count] of Object.entries(raw)) if (typeof count === "number" && Number.isFinite(count) && count > 0) out[guid] = Math.floor(count);
+	return capFailureRetriesMap(out);
+}
+function shouldReplaceCatchupCursor(existingValue, incomingValue) {
+	const incoming = normalizeCatchupCursor(incomingValue);
+	if (!incoming) return false;
+	const existing = normalizeCatchupCursor(existingValue);
+	return !existing || incoming.lastSeenRowid > existing.lastSeenRowid || incoming.lastSeenRowid === existing.lastSeenRowid && incoming.lastSeenMs > existing.lastSeenMs;
+}
+function detectReplyCacheMigration(params) {
+	const stateDir = resolveMigrationStateDir(params);
+	const sourcePath = path.join(stateDir, "imessage", "reply-cache.jsonl");
+	if (!fileExists(sourcePath)) return [];
+	const plans = [];
+	plans.push({
+		kind: "plugin-state-import",
+		label: "iMessage reply short-id counter",
+		sourcePath,
+		targetPath: `plugin state:${IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE}`,
+		pluginId: "imessage",
+		namespace: IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE,
+		maxEntries: 1,
+		scopeKey: "",
+		stateDir,
+		preview: `- iMessage reply short-id counter: ${sourcePath} → plugin state (${IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE})`,
+		readEntries: () => {
+			const maxShortId = readReplyCacheMaxShortId(sourcePath);
+			return maxShortId > 0 ? [{
+				key: IMESSAGE_REPLY_CACHE_COUNTER_KEY,
+				value: { counter: maxShortId }
+			}] : [];
+		},
+		shouldReplaceExistingEntry: ({ existingValue, incomingValue }) => shouldReplaceReplyCounter(existingValue, incomingValue)
+	});
+	plans.push({
+		kind: "plugin-state-import",
+		label: "iMessage reply short-id cache",
+		sourcePath,
+		targetPath: `plugin state:${IMESSAGE_REPLY_CACHE_NAMESPACE}`,
+		pluginId: "imessage",
+		namespace: IMESSAGE_REPLY_CACHE_NAMESPACE,
+		maxEntries: IMESSAGE_REPLY_CACHE_MAX_ENTRIES,
+		scopeKey: "",
+		stateDir,
+		cleanupSource: "rename",
+		cleanupWhenEmpty: true,
+		preview: `- iMessage reply short-id cache: ${sourcePath} → plugin state (${IMESSAGE_REPLY_CACHE_NAMESPACE})`,
+		readEntries: () => listReplyCacheEntries(sourcePath)
+	});
+	return plans;
+}
+function detectSentEchoMigration(params) {
+	const stateDir = resolveMigrationStateDir(params);
+	const sourcePath = path.join(stateDir, "imessage", "sent-echoes.jsonl");
+	if (!fileExists(sourcePath)) return [];
+	return [{
+		kind: "plugin-state-import",
+		label: "iMessage sent-echo dedupe cache",
+		sourcePath,
+		targetPath: `plugin state:${IMESSAGE_SENT_ECHOES_NAMESPACE}`,
+		pluginId: "imessage",
+		namespace: IMESSAGE_SENT_ECHOES_NAMESPACE,
+		maxEntries: 256,
+		scopeKey: "",
+		stateDir,
+		cleanupSource: "rename",
+		cleanupWhenEmpty: true,
+		preview: `- iMessage sent-echo dedupe cache: ${sourcePath} → plugin state (${IMESSAGE_SENT_ECHOES_NAMESPACE})`,
+		readEntries: () => listSentEchoEntries(sourcePath)
+	}];
+}
+function detectCatchupCursorMigrations(params) {
+	const stateDir = resolveMigrationStateDir(params);
+	const accountIds = uniqueStrings([resolveDefaultIMessageAccountId(params.cfg), ...listIMessageAccountIds(params.cfg)].map((accountId) => resolveIMessageAccount({
+		cfg: params.cfg,
+		accountId
+	}).accountId));
+	const configuredPaths = new Set(accountIds.map((accountId) => resolveLegacyCatchupCursorPath(stateDir, accountId)));
+	const configuredPlans = accountIds.flatMap((accountId) => {
+		const sourcePath = resolveLegacyCatchupCursorPath(stateDir, accountId);
+		if (!fileExists(sourcePath)) return [];
+		return {
+			kind: "plugin-state-import",
+			label: "iMessage catchup cursor",
+			sourcePath,
+			targetPath: `plugin state:${IMESSAGE_CATCHUP_CURSOR_NAMESPACE}`,
+			pluginId: "imessage",
+			namespace: IMESSAGE_CATCHUP_CURSOR_NAMESPACE,
+			maxEntries: 256,
+			scopeKey: "",
+			stateDir,
+			cleanupSource: "rename",
+			preview: `- iMessage catchup cursor: ${sourcePath} → plugin state (${IMESSAGE_CATCHUP_CURSOR_NAMESPACE})`,
+			readEntries: () => {
+				const cursor = readCatchupCursor(sourcePath);
+				return [{
+					key: resolveIMessageCatchupCursorKey(accountId),
+					value: cursor
+				}];
+			},
+			shouldReplaceExistingEntry: (replaceParams) => shouldReplaceCatchupCursor(replaceParams.existingValue, replaceParams.incomingValue)
+		};
+	});
+	const orphanPlans = listLegacyCatchupCursorPaths(stateDir).filter((sourcePath) => !configuredPaths.has(sourcePath)).map((sourcePath) => ({
+		kind: "plugin-state-import",
+		label: "iMessage orphan catchup cursor",
+		sourcePath,
+		targetPath: `plugin state:${IMESSAGE_CATCHUP_CURSOR_NAMESPACE}`,
+		pluginId: "imessage",
+		namespace: IMESSAGE_CATCHUP_CURSOR_NAMESPACE,
+		maxEntries: 256,
+		scopeKey: "",
+		stateDir,
+		cleanupSource: "rename",
+		cleanupWhenEmpty: true,
+		preview: `- iMessage orphan catchup cursor: ${sourcePath} → archived legacy state`,
+		readEntries: () => []
+	}));
+	return [...configuredPlans, ...orphanPlans];
+}
+async function detectIMessageLegacyStateMigrations(params) {
+	return [
+		...detectCatchupCursorMigrations(params),
+		...detectReplyCacheMigration(params),
+		...detectSentEchoMigration(params)
+	];
+}
+//#endregion
+export { detectIMessageLegacyStateMigrations };

package/node_modules/typebox/build/format/email.mjs

@@ -1,4 +1,4 @@
-const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\.)*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\x20-\x7e])*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
 /**
  * Returns true if the value is an Email
  * @specification https://datatracker.ietf.org/doc/html/rfc5322

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -1,6 +1,9 @@
 import * as FormatBidi from './format/bidi.mjs';
 import * as LabelUnicode from './label/unicode.mjs';
 import * as LabelPuny from './label/puny.mjs';
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
 function IsValidLabelLength(value) {
     return value.length > 0 && value.length <= 63;
 }
@@ -8,9 +11,24 @@ function IsLabel(value) {
     return IsValidLabelLength(value) && (LabelPuny.IsPunyLabel(value) ||
         LabelUnicode.IsUnicodeLabel(value));
 }
+// ------------------------------------------------------------------
+// NormalizeHostname
+//
+// Normalizes a hostname for label validation. Normalizes for NFC
+// such that equivalent codepoint sequences can be uniformly
+// compared. It also removes codepoints that IDNA mapping ignores,
+// and converts full stop variants to ASCII '.' so the hostname can
+// be split into labels.
+// ------------------------------------------------------------------
 function NormalizeHostname(value) {
-    return value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
+    return value
+        .normalize('NFC')
+        .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
+        .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING
 }
+// ------------------------------------------------------------------
+// IsIdnHostname
+// ------------------------------------------------------------------
 export function IsIdnHostname(value) {
     if (value.length === 0 || value.includes(' '))
         return false;

package/node_modules/typebox/build/format/json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsJsonPointer(value: string): boolean;

package/node_modules/typebox/build/format/json_pointer.mjs

@@ -1,8 +1,8 @@
 const JsonPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
 /**
  * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsJsonPointer(value) {
     return JsonPointer.test(value);

package/node_modules/typebox/build/format/json_pointer_uri_fragment.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a json pointer uri fragment
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsJsonPointerUriFragment(value: string): boolean;

package/node_modules/typebox/build/format/json_pointer_uri_fragment.mjs

@@ -1,8 +1,8 @@
 const JsonPointerUriFragment = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
 /**
  * Returns true if the value is a json pointer uri fragment
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsJsonPointerUriFragment(value) {
     return JsonPointerUriFragment.test(value);

package/node_modules/typebox/build/format/relative_json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a relative json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsRelativeJsonPointer(value: string): boolean;

package/node_modules/typebox/build/format/relative_json_pointer.mjs

@@ -1,8 +1,8 @@
 const RelativeJsonPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
 /**
  * Returns true if the value is a relative json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsRelativeJsonPointer(value) {
     return RelativeJsonPointer.test(value);