@openclaw/imessage 2026.8.1-beta.3 → 2026.8.1

package/dist/state-migrations-SFdKp3GQ.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-4TK_cDDb.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/security-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/date.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a ISO8601 Date component string
- * @source ajv-formats
+ * @description https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12`
  */
 export declare function IsDate(value: string): boolean;

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

@@ -5,7 +5,7 @@ function IsLeapYear(year) {
 }
 /**
  * Returns true if the value is a ISO8601 Date component string
- * @source ajv-formats
+ * @description https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12`
  */
 export function IsDate(value) {

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

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a ISO8601 DateTime string
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12T20:20:40+00:00`
  */
-export declare function IsDateTime(value: string, strictTimeZone?: boolean): boolean;
+export declare function IsDateTime(value: string): boolean;

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

@@ -2,10 +2,10 @@ import { IsDate } from './date.mjs';
 import { IsTime } from './time.mjs';
 /**
  * Returns true if the value is a ISO8601 DateTime string
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12T20:20:40+00:00`
  */
-export function IsDateTime(value, strictTimeZone = true) {
+export function IsDateTime(value) {
     const dateTime = value.split(/T/i);
-    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone);
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1]);
 }

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

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an Email
- * @specification ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc5322
  */
 export declare function IsEmail(value: string): boolean;

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

@@ -1,7 +1,7 @@
-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])?)*$/i;
+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;
 /**
  * Returns true if the value is an Email
- * @specification ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc5322
  */
 export function IsEmail(value) {
     return Email.test(value);

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

@@ -1,4 +1,4 @@
-import * as Idna from './_idna.mjs';
+import * as Idna from './idna/index.mjs';
 /**
  * Returns true if the value is a valid hostname.
  * @specification https://tools.ietf.org/html/rfc1123
@@ -6,13 +6,5 @@ import * as Idna from './_idna.mjs';
  * @specification https://tools.ietf.org/html/rfc5892
  */
 export function IsHostname(value) {
-    if (value.length === 0 || value.length > 253)
-        return false;
-    if (value.charCodeAt(value.length - 1) === 46)
-        return false;
-    for (const label of value.split('.')) {
-        if (!Idna.IsLabel(label))
-            return false;
-    }
-    return true;
+    return Idna.IsHostname(value);
 }

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

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an IdnEmail
- * @specification ajv-formats (unicode-extension)
+ * @specification https://datatracker.ietf.org/doc/html/rfc4952
  */
 export declare function IsIdnEmail(value: string): boolean;

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

@@ -1,8 +1,8 @@
-const IdnEmail = /^(?!.*\.\.)[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+(?:\.[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+)*@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?)*$/iu;
+const IdnEmail = /^(?:[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+(?:\.[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+)*|"(?:[^"\\]|\\.)*")@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-)(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-))*$/iu;
 /**
  * Returns true if the value is an IdnEmail
- * @specification ajv-formats (unicode-extension)
+ * @specification https://datatracker.ietf.org/doc/html/rfc4952
  */
 export function IsIdnEmail(value) {
-    return IdnEmail.test(value);
+    return IdnEmail.test(value.normalize('NFC'));
 }

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

@@ -3,5 +3,6 @@
  * @specification https://tools.ietf.org/html/rfc3490
  * @specification https://tools.ietf.org/html/rfc5891
  * @specification https://tools.ietf.org/html/rfc5892
+ * @specification https://tools.ietf.org/html/rfc5893
  */
 export declare function IsIdnHostname(value: string): boolean;

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

@@ -1,19 +1,11 @@
-import { IsIdnLabel } from './_idna.mjs';
+import * as Idna from './idna/index.mjs';
 /**
  * Returns true if the value is a valid internationalized (IDN) hostname.
  * @specification https://tools.ietf.org/html/rfc3490
  * @specification https://tools.ietf.org/html/rfc5891
  * @specification https://tools.ietf.org/html/rfc5892
+ * @specification https://tools.ietf.org/html/rfc5893
  */
 export function IsIdnHostname(value) {
-    if (value.length === 0 || value.includes(' '))
-        return false;
-    const canonical = value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
-    if (canonical.length > 253)
-        return false;
-    for (const label of canonical.split('.')) {
-        if (!IsIdnLabel(label))
-            return false;
-    }
-    return true;
+    return Idna.IsIdnHostname(value);
 }

package/node_modules/typebox/build/format/idna/format/bidi.d.mts

@@ -0,0 +1,3 @@
+export declare function HasBidiChars(value: string): boolean;
+export declare function HasRightToLeftCharacters(value: string): boolean;
+export declare function SatisfiesBidiRule(value: string): boolean;

package/node_modules/typebox/build/format/idna/format/bidi.mjs

@@ -0,0 +1,98 @@
+// deno-fmt-ignore-file
+import * as FormatPuny from './puny.mjs';
+import * as Pattern from '../pattern/pattern.mjs';
+// ------------------------------------------------------------------
+// LOCAL REGEX: Allowed Bidi classes per direction (RFC 5893)
+// ------------------------------------------------------------------
+const RE_RTL_ALLOWED = /^(?:R|AL|AN|EN|ES|CS|ET|ON|BN|NSM)$/;
+const RE_LTR_ALLOWED = /^(?:L|EN|ES|CS|ET|ON|BN|NSM)$/;
+const RE_RTL_CLASSES = /^(?:R|AL|AN)$/;
+// ------------------------------------------------------------------
+// HasBidiChars
+//
+// Decodes a punycode label to its Unicode form (if it is one) and
+// checks whether the result is an RTL label per RFC 5893 §1.4.
+// ------------------------------------------------------------------
+export function HasBidiChars(value) {
+    if (FormatPuny.IsAcePrefixed(value)) {
+        try {
+            return HasRightToLeftCharacters(FormatPuny.Decode(value.slice(4).toLowerCase()));
+        }
+        catch {
+            return false;
+        }
+    }
+    return HasRightToLeftCharacters(value);
+}
+// ------------------------------------------------------------------
+// GetBidiClass
+// ------------------------------------------------------------------
+function GetBidiClass(codePoint) {
+    const char = String.fromCodePoint(codePoint);
+    return (Pattern.RE_EUROPEAN_NUMBER.test(char) ? 'EN' :
+        Pattern.RE_ARABIC_INDIC_DIGIT.test(char) ? 'AN' :
+            // Pattern.RE_EUROPEAN_SEPARATOR.test(char) ? 'ES' : // (no-spec-coverage)
+            // Pattern.RE_COMMON_SEPARATOR.test(char) ? 'CS' : // (no-spec-coverage)
+            Pattern.RE_MARK_NONSPACING.test(char) ? 'NSM' :
+                Pattern.RE_SCRIPT_HEBREW.test(char) ? 'R' :
+                    Pattern.RE_SCRIPT_ARABIC_LETTER.test(char) ? 'AL' :
+                        Pattern.RE_LETTER.test(char) ? 'L' :
+                            'ON');
+}
+// ------------------------------------------------------------------
+// HasRightToLeftCharacters
+//
+// Per RFC 5893 §1.4: "An RTL label is a label that contains at least
+// one character of type R, AL, or AN." Used to determine whether a
+// domain name is a "Bidi domain name" (RFC 5893 §1.4), in which case
+// the Bidi Rule applies to every label in the domain.
+// ------------------------------------------------------------------
+export function HasRightToLeftCharacters(value) {
+    for (const ch of value)
+        if (RE_RTL_CLASSES.test(GetBidiClass(ch.codePointAt(0))))
+            return true;
+    return false;
+}
+// ------------------------------------------------------------------
+// SatisfiesBidiRule
+// ------------------------------------------------------------------
+export function SatisfiesBidiRule(value) {
+    let isRtl = false;
+    let allowed = RE_LTR_ALLOWED;
+    let sawEN = false;
+    let sawAN = false;
+    let isFirst = true;
+    // let lastClass: string | null = null // (no-spec-coverage)
+    for (const ch of value) {
+        const bidiClass = GetBidiClass(ch.codePointAt(0));
+        if (isFirst) {
+            // 1. The first character must be a character with Bidi property L, R, or AL.
+            if (bidiClass !== 'L' && bidiClass !== 'R' && bidiClass !== 'AL')
+                return false;
+            isRtl = bidiClass === 'R' || bidiClass === 'AL';
+            allowed = isRtl ? RE_RTL_ALLOWED : RE_LTR_ALLOWED;
+            isFirst = false;
+        }
+        // 2 / 5. Only characters in the allowed set for this direction may appear.
+        if (!allowed.test(bidiClass))
+            return false;
+        if (bidiClass === 'EN')
+            sawEN = true;
+        else if (bidiClass === 'AN')
+            sawAN = true;
+        // if (bidiClass !== 'NSM') lastClass = bidiClass // (no-spec-coverage)
+    }
+    if (isRtl && sawEN && sawAN)
+        return false; // spec coverage path
+    // (no-spec-coverage)
+    // if (isRtl) {
+    //   // 3. The end of the label must be R, AL, EN, or AN (ignoring trailing NSM).
+    //   // if (lastClass !== 'R' && lastClass !== 'AL' && lastClass !== 'EN' && lastClass !== 'AN') return false
+    //   // 4. If an EN is present, no AN may be present, and vice versa.
+    //   if (sawEN && sawAN) return false
+    // } else {
+    //   // 6. The end of the label must be L or EN (ignoring trailing NSM).
+    //   // if (lastClass !== 'L' && lastClass !== 'EN') return false
+    // }
+    return true;
+}

package/node_modules/typebox/build/format/idna/format/puny.d.mts

@@ -0,0 +1,3 @@
+export declare function IsAcePrefixed(value: string): boolean;
+export declare function Decode(value: string): string;
+export declare function Encode(input: string): string;

package/node_modules/typebox/build/format/idna/format/puny.mjs

@@ -0,0 +1,144 @@
+import * as Pattern from '../pattern/pattern.mjs';
+// ------------------------------------------------------------------
+// PunyCode (RFC 3492)
+// ------------------------------------------------------------------
+const PUNYCODE_BASE = 36;
+const PUNYCODE_TMIN = 1;
+const PUNYCODE_TMAX = 26;
+const PUNYCODE_SKEW = 38;
+const PUNYCODE_DAMP = 700;
+const PUNYCODE_INITIAL_BIAS = 72;
+const PUNYCODE_INITIAL_N = 128;
+// ------------------------------------------------------------------
+// ThrowDontCare
+// ------------------------------------------------------------------
+function ThrowDontCare() {
+    throw null;
+}
+// ------------------------------------------------------------------
+// IsAcePrefixed
+// ------------------------------------------------------------------
+export function IsAcePrefixed(value) {
+    return value.toLowerCase().startsWith('xn--');
+}
+// ------------------------------------------------------------------
+// Adapt
+// ------------------------------------------------------------------
+function Adapt(delta, numPoints, firstTime) {
+    delta = firstTime ? Math.floor(delta / PUNYCODE_DAMP) : delta >> 1;
+    delta += Math.floor(delta / numPoints);
+    let k = 0;
+    while (delta > (((PUNYCODE_BASE - PUNYCODE_TMIN) * PUNYCODE_TMAX) >> 1)) {
+        delta = Math.floor(delta / (PUNYCODE_BASE - PUNYCODE_TMIN));
+        k += PUNYCODE_BASE;
+    }
+    return k + Math.floor(((PUNYCODE_BASE - PUNYCODE_TMIN + 1) * delta) / (delta + PUNYCODE_SKEW));
+}
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+export function Decode(value) {
+    const output = [];
+    let n = PUNYCODE_INITIAL_N;
+    let i = 0;
+    let bias = PUNYCODE_INITIAL_BIAS;
+    const delimIdx = value.lastIndexOf('-');
+    if (delimIdx > 0) {
+        for (let j = 0; j < delimIdx; j++) {
+            const cp = value.charCodeAt(j);
+            if (cp >= 128)
+                ThrowDontCare(); // throw new Error('Invalid punycode: non-basic before delimiter')
+            output.push(cp);
+        }
+    }
+    let inIdx = delimIdx < 0 ? 0 : delimIdx + 1;
+    while (inIdx < value.length) {
+        const oldi = i;
+        let w = 1;
+        let k = PUNYCODE_BASE;
+        while (true) {
+            if (inIdx >= value.length)
+                ThrowDontCare(); // throw new Error('Invalid punycode: unexpected end of input')
+            const ch = value.charCodeAt(inIdx++);
+            let digit;
+            if (ch >= 0x61 && ch <= 0x7a)
+                digit = ch - 0x61; // a-z => 0-25
+            else if (ch >= 0x30 && ch <= 0x39)
+                digit = ch - 0x30 + 26; // 0-9 => 26-35
+            // else if (ch >= 0x41 && ch <= 0x5a) digit = ch - 0x41 // A-Z => 0-25 // (no-spec-coverage)
+            else
+                ThrowDontCare(); // throw new Error('Invalid punycode: bad digit character')
+            i += digit * w;
+            const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
+            if (digit < t)
+                break;
+            w *= PUNYCODE_BASE - t;
+            k += PUNYCODE_BASE;
+        }
+        const outLen = output.length + 1;
+        bias = Adapt(i - oldi, outLen, oldi === 0);
+        n += Math.floor(i / outLen);
+        i %= outLen;
+        output.splice(i, 0, n);
+        i++;
+    }
+    return String.fromCodePoint(...output);
+}
+// ------------------------------------------------------------------
+// DigitToChar
+// ------------------------------------------------------------------
+function DigitToChar(digit) {
+    return digit < 26 ? String.fromCharCode(digit + 0x61) : String.fromCharCode(digit - 26 + 0x30);
+}
+// ------------------------------------------------------------------
+// Encode
+//
+// Encodes a Unicode string into its Punycode payload (the part that
+// follows the 'xn--' ACE prefix). Used to compute the true A-label
+// length of a U-label, since the 63-octet label length limit (RFC
+// 5891 §4.2.4) applies to the encoded form, not the code point count.
+// ------------------------------------------------------------------
+const RE_REPLACE_NON_ASCII = new RegExp(Pattern.RE_NON_ASCII.source, 'gu');
+export function Encode(input) {
+    // Extract basic ASCII characters and set initial output array state
+    const basic = input.replace(RE_REPLACE_NON_ASCII, '');
+    const basicLength = basic.length;
+    const result = basicLength > 0 ? [basic, '-'] : [];
+    // Extract unicode codepoints
+    const codePoints = Array.from(input, (char) => char.codePointAt(0));
+    let n = PUNYCODE_INITIAL_N;
+    let delta = 0;
+    let bias = PUNYCODE_INITIAL_BIAS;
+    let handledCPCount = basicLength;
+    while (handledCPCount < codePoints.length) {
+        let m = Infinity;
+        for (const cp of codePoints) {
+            if (cp >= n && cp < m)
+                m = cp;
+        }
+        delta += (m - n) * (handledCPCount + 1);
+        n = m;
+        for (const cp of codePoints) {
+            if (cp < n)
+                delta++;
+            if (cp === n) {
+                let q = delta;
+                for (let k = PUNYCODE_BASE;; k += PUNYCODE_BASE) {
+                    const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
+                    if (q < t)
+                        break;
+                    const digit = t + ((q - t) % (PUNYCODE_BASE - t));
+                    result.push(DigitToChar(digit));
+                    q = Math.floor((q - t) / (PUNYCODE_BASE - t));
+                }
+                result.push(DigitToChar(q));
+                bias = Adapt(delta, handledCPCount + 1, handledCPCount === basicLength);
+                delta = 0;
+                handledCPCount++;
+            }
+        }
+        delta++;
+        n++;
+    }
+    return result.join('');
+}

package/node_modules/typebox/build/format/idna/hostname.d.mts

@@ -0,0 +1 @@
+export declare function IsHostname(value: string): boolean;