@remnic/core 9.27.0 → 9.28.0

package/dist/{chunk-JDOJZTFF.js → chunk-VFNI3RPT.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-CIQXI47W.js";
+} from "./chunk-Q5VJUNXA.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-JDOJZTFF.js.map
+//# sourceMappingURL=chunk-VFNI3RPT.js.map

package/dist/chunk-VNA7W7QF.js

@@ -0,0 +1,134 @@
+// src/entity-retrieval-boundaries.ts
+var UNICODE_WORD_OR_NUMBER_RE = /[\p{L}\p{M}\p{N}]/u;
+function firstUnicodeCharacter(value) {
+  const codePoint = value.codePointAt(0);
+  return codePoint === void 0 ? "" : String.fromCodePoint(codePoint);
+}
+function lastUnicodeCharacter(value) {
+  const codePoint = [...value].at(-1);
+  return codePoint ?? "";
+}
+var JAPANESE_PARTICLE_RE = /^[のはがをにへともやかでだ]$/u;
+var JAPANESE_MULTI_CHARACTER_PARTICLES = [
+  "\u306B\u3064\u3044\u3066",
+  "\u306B\u3068\u3063\u3066",
+  "\u306B\u3088\u3063\u3066",
+  "\u306B\u95A2\u3057\u3066",
+  "\u306B\u5BFE\u3057\u3066",
+  "\u3068\u306F",
+  "\u3067\u306F",
+  "\u306B\u306F",
+  "\u306B\u3082",
+  "\u3063\u3066"
+];
+var KOREAN_PARTICLES = [
+  "\uC5D0\uC11C",
+  "\uC5D0\uAC8C",
+  "\uD55C\uD14C",
+  "\uC73C\uB85C",
+  "\uAE4C\uC9C0",
+  "\uBD80\uD130",
+  "\uBCF4\uB2E4",
+  "\uCC98\uB7FC",
+  "\uAC19\uC774",
+  "\uC774\uB098",
+  "\uB77C\uB3C4",
+  "\uBC16\uC5D0",
+  "\uB9C8\uB2E4",
+  "\uC870\uCC28",
+  "\uC774\uB791",
+  "\uD558\uACE0",
+  "\uC740",
+  "\uB294",
+  "\uC774",
+  "\uAC00",
+  "\uC744",
+  "\uB97C",
+  "\uC758",
+  "\uAED8",
+  "\uC640",
+  "\uACFC",
+  "\uB3C4",
+  "\uB9CC",
+  "\uB4E0",
+  "\uC5D0",
+  "\uB85C",
+  "\uB098",
+  "\uB791"
+];
+var KOREAN_UNSPACED_QUESTION_PARTICLES = ["\uC740", "\uB294", "\uC774", "\uAC00"];
+var KOREAN_INTERROGATIVE_PREFIXES = [
+  "\uC5B4\uB514",
+  "\uBB34\uC5C7",
+  "\uBB50",
+  "\uC65C",
+  "\uC5B4\uB5BB\uAC8C",
+  "\uC5B8\uC81C",
+  "\uB204\uAD6C",
+  "\uC5B4\uB290",
+  "\uBA87",
+  "\uC5BC\uB9C8"
+];
+var HANGUL_RUN_RE = /^[\p{Script=Hangul}]+/u;
+var UNICODE_WORD_SEGMENTER = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "word" }) : null;
+var KOREAN_WORD_SEGMENTER = typeof Intl.Segmenter === "function" ? new Intl.Segmenter("ko", { granularity: "word" }) : null;
+var JAPANESE_WORD_SEGMENTER = typeof Intl.Segmenter === "function" ? new Intl.Segmenter("ja", { granularity: "word" }) : null;
+var JAPANESE_KANA_RE = /[\p{Script=Hiragana}\p{Script=Katakana}]/u;
+function isJapaneseParticleBoundary(suffix) {
+  const firstSegment = JAPANESE_WORD_SEGMENTER?.segment(suffix).containing(0)?.segment;
+  if (firstSegment !== void 0) {
+    if (JAPANESE_MULTI_CHARACTER_PARTICLES.some((particle) => particle === firstSegment)) return true;
+    return JAPANESE_PARTICLE_RE.test(firstSegment);
+  }
+  const firstCharacter = firstUnicodeCharacter(suffix);
+  return JAPANESE_MULTI_CHARACTER_PARTICLES.some((particle) => suffix.startsWith(particle)) || JAPANESE_PARTICLE_RE.test(firstCharacter) && !UNICODE_WORD_OR_NUMBER_RE.test(firstUnicodeCharacter(suffix.slice(firstCharacter.length)));
+}
+function isIntlWordBoundary(source, index) {
+  if (index <= 0 || index >= source.length) return true;
+  return UNICODE_WORD_SEGMENTER?.segment(source).containing(index)?.index === index;
+}
+function isKoreanUnspacedQuestionBoundary(suffix) {
+  return KOREAN_UNSPACED_QUESTION_PARTICLES.some(
+    (particle) => suffix.startsWith(particle) && KOREAN_INTERROGATIVE_PREFIXES.some((prefix) => suffix.startsWith(prefix, particle.length))
+  );
+}
+function isKoreanParticleBoundary(suffix) {
+  if (isKoreanUnspacedQuestionBoundary(suffix)) return true;
+  const firstSegment = KOREAN_WORD_SEGMENTER?.segment(suffix).containing(0)?.segment;
+  if (firstSegment !== void 0) {
+    return KOREAN_PARTICLES.some((particle) => particle === firstSegment);
+  }
+  const particleRun = suffix.match(HANGUL_RUN_RE)?.[0] ?? "";
+  const nextCharacter = firstUnicodeCharacter(suffix.slice(particleRun.length));
+  return KOREAN_PARTICLES.some((particle) => particle === particleRun) && (nextCharacter.length === 0 || !UNICODE_WORD_OR_NUMBER_RE.test(nextCharacter));
+}
+function isUnicodePhraseBoundary(character, suffix = "", source = "", boundaryIndex = -1, strictUnicode = false, allowLeadingParticle = false) {
+  return character.length === 0 || !UNICODE_WORD_OR_NUMBER_RE.test(character) || allowLeadingParticle && isJapaneseParticleBoundary(character) || isJapaneseParticleBoundary(suffix) || !strictUnicode && boundaryIndex >= 0 && !JAPANESE_KANA_RE.test(suffix) && isIntlWordBoundary(source, boundaryIndex) || allowLeadingParticle && isKoreanParticleBoundary(character) || isKoreanParticleBoundary(suffix);
+}
+function containsPhrase(haystack, needle) {
+  if (!needle) return false;
+  const caseInsensitive = /^[a-z0-9 ]+$/i.test(needle);
+  const searchHaystack = caseInsensitive ? haystack.toLowerCase() : haystack;
+  const searchNeedle = caseInsensitive ? needle.toLowerCase() : needle;
+  let offset = searchHaystack.indexOf(searchNeedle);
+  while (offset >= 0) {
+    const before = lastUnicodeCharacter(searchHaystack.slice(0, offset));
+    const after = searchHaystack.slice(offset + searchNeedle.length);
+    if (isUnicodePhraseBoundary(before, "", searchHaystack, offset, caseInsensitive, true) && isUnicodePhraseBoundary(
+      firstUnicodeCharacter(after),
+      after,
+      searchHaystack,
+      offset + searchNeedle.length,
+      caseInsensitive
+    )) {
+      return true;
+    }
+    offset = searchHaystack.indexOf(searchNeedle, offset + searchNeedle.length);
+  }
+  return false;
+}
+
+export {
+  containsPhrase
+};
+//# sourceMappingURL=chunk-VNA7W7QF.js.map

package/dist/chunk-VNA7W7QF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/entity-retrieval-boundaries.ts"],"sourcesContent":["const UNICODE_WORD_OR_NUMBER_RE = /[\\p{L}\\p{M}\\p{N}]/u;\n\nfunction firstUnicodeCharacter(value: string): string {\n  const codePoint = value.codePointAt(0);\n  return codePoint === undefined ? \"\" : String.fromCodePoint(codePoint);\n}\n\nfunction lastUnicodeCharacter(value: string): string {\n  const codePoint = [...value].at(-1);\n  return codePoint ?? \"\";\n}\n\nconst JAPANESE_PARTICLE_RE = /^[のはがをにへともやかでだ]$/u;\nconst JAPANESE_MULTI_CHARACTER_PARTICLES = [\n  \"について\",\n  \"にとって\",\n  \"によって\",\n  \"に関して\",\n  \"に対して\",\n  \"とは\",\n  \"では\",\n  \"には\",\n  \"にも\",\n  \"って\",\n] as const;\nconst KOREAN_PARTICLES = [\n  \"에서\", \"에게\", \"한테\", \"으로\", \"까지\", \"부터\", \"보다\", \"처럼\", \"같이\",\n  \"이나\", \"라도\", \"밖에\", \"마다\", \"조차\", \"이랑\", \"하고\", \"은\", \"는\",\n  \"이\", \"가\", \"을\", \"를\", \"의\", \"께\", \"와\", \"과\", \"도\", \"만\", \"든\",\n  \"에\", \"로\", \"나\", \"랑\",\n] as const;\nconst KOREAN_UNSPACED_QUESTION_PARTICLES = [\"은\", \"는\", \"이\", \"가\"] as const;\nconst KOREAN_INTERROGATIVE_PREFIXES = [\n  \"어디\", \"무엇\", \"뭐\", \"왜\", \"어떻게\", \"언제\", \"누구\", \"어느\", \"몇\", \"얼마\",\n] as const;\n\nconst HANGUL_RUN_RE = /^[\\p{Script=Hangul}]+/u;\n\nconst UNICODE_WORD_SEGMENTER =\n  typeof Intl.Segmenter === \"function\" ? new Intl.Segmenter(undefined, { granularity: \"word\" }) : null;\nconst KOREAN_WORD_SEGMENTER =\n  typeof Intl.Segmenter === \"function\" ? new Intl.Segmenter(\"ko\", { granularity: \"word\" }) : null;\n\nconst JAPANESE_WORD_SEGMENTER =\n  typeof Intl.Segmenter === \"function\" ? new Intl.Segmenter(\"ja\", { granularity: \"word\" }) : null;\nconst JAPANESE_KANA_RE = /[\\p{Script=Hiragana}\\p{Script=Katakana}]/u;\n\nfunction isJapaneseParticleBoundary(suffix: string): boolean {\n  const firstSegment = JAPANESE_WORD_SEGMENTER?.segment(suffix).containing(0)?.segment;\n  if (firstSegment !== undefined) {\n    if (JAPANESE_MULTI_CHARACTER_PARTICLES.some((particle) => particle === firstSegment)) return true;\n    return JAPANESE_PARTICLE_RE.test(firstSegment);\n  }\n  const firstCharacter = firstUnicodeCharacter(suffix);\n  return (\n    JAPANESE_MULTI_CHARACTER_PARTICLES.some((particle) => suffix.startsWith(particle)) ||\n    (JAPANESE_PARTICLE_RE.test(firstCharacter) &&\n      !UNICODE_WORD_OR_NUMBER_RE.test(firstUnicodeCharacter(suffix.slice(firstCharacter.length))))\n  );\n}\n\nfunction isIntlWordBoundary(source: string, index: number): boolean {\n  if (index <= 0 || index >= source.length) return true;\n  return UNICODE_WORD_SEGMENTER?.segment(source).containing(index)?.index === index;\n}\n\nfunction isKoreanUnspacedQuestionBoundary(suffix: string): boolean {\n  return KOREAN_UNSPACED_QUESTION_PARTICLES.some((particle) =>\n    suffix.startsWith(particle) &&\n    KOREAN_INTERROGATIVE_PREFIXES.some((prefix) => suffix.startsWith(prefix, particle.length)),\n  );\n}\n\nfunction isKoreanParticleBoundary(suffix: string): boolean {\n  if (isKoreanUnspacedQuestionBoundary(suffix)) return true;\n  const firstSegment = KOREAN_WORD_SEGMENTER?.segment(suffix).containing(0)?.segment;\n  if (firstSegment !== undefined) {\n    return KOREAN_PARTICLES.some((particle) => particle === firstSegment);\n  }\n  const particleRun = suffix.match(HANGUL_RUN_RE)?.[0] ?? \"\";\n  const nextCharacter = firstUnicodeCharacter(suffix.slice(particleRun.length));\n  return (\n    KOREAN_PARTICLES.some((particle) => particle === particleRun) &&\n    (nextCharacter.length === 0 || !UNICODE_WORD_OR_NUMBER_RE.test(nextCharacter))\n  );\n}\n\nfunction isUnicodePhraseBoundary(\n  character: string,\n  suffix: string = \"\",\n  source: string = \"\",\n  boundaryIndex: number = -1,\n  strictUnicode = false,\n  allowLeadingParticle = false,\n): boolean {\n  return (\n    character.length === 0\n    || !UNICODE_WORD_OR_NUMBER_RE.test(character)\n    || (allowLeadingParticle && isJapaneseParticleBoundary(character))\n    || isJapaneseParticleBoundary(suffix)\n    || (!strictUnicode &&\n      boundaryIndex >= 0 &&\n      !JAPANESE_KANA_RE.test(suffix) &&\n      isIntlWordBoundary(source, boundaryIndex))\n    || (allowLeadingParticle && isKoreanParticleBoundary(character))\n    || isKoreanParticleBoundary(suffix)\n  );\n}\n\nexport function containsPhrase(haystack: string, needle: string): boolean {\n  if (!needle) return false;\n  const caseInsensitive = /^[a-z0-9 ]+$/i.test(needle);\n  const searchHaystack = caseInsensitive ? haystack.toLowerCase() : haystack;\n  const searchNeedle = caseInsensitive ? needle.toLowerCase() : needle;\n  let offset = searchHaystack.indexOf(searchNeedle);\n  while (offset >= 0) {\n    const before = lastUnicodeCharacter(searchHaystack.slice(0, offset));\n    const after = searchHaystack.slice(offset + searchNeedle.length);\n    if (\n      isUnicodePhraseBoundary(before, \"\", searchHaystack, offset, caseInsensitive, true)\n      && isUnicodePhraseBoundary(\n        firstUnicodeCharacter(after),\n        after,\n        searchHaystack,\n        offset + searchNeedle.length,\n        caseInsensitive,\n      )\n    ) {\n      return true;\n    }\n    offset = searchHaystack.indexOf(searchNeedle, offset + searchNeedle.length);\n  }\n  return false;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-EYJSW2RV.js → chunk-VYYNBJXH.js}

@@ -1,9 +1,9 @@
-import {
-  namespaceCollectionName
-} from "./chunk-SK3EYPKC.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-MEBQFQ26.js";
+} from "./chunk-AHFZXUZM.js";
+import {
+  namespaceCollectionName
+} from "./chunk-ZN4UZWMT.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken
@@ -207,4 +207,4 @@ export {
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-EYJSW2RV.js.map
+//# sourceMappingURL=chunk-VYYNBJXH.js.map

package/dist/chunk-WNIUPHWV.js

@@ -0,0 +1,152 @@
+import {
+  isAgentAccessSecretRef
+} from "./chunk-IJ6WHMFB.js";
+import {
+  coerceBool,
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+
+// src/replica-peers-config.ts
+var DEFAULT_POLL_INTERVAL_MS = 3e5;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_FILE_COUNT_DELTA = 100;
+var DEFAULT_MAX_WATERMARK_AGE_DELTA_MS = 9e5;
+var MAX_TIMER_DELAY_MS = 2147483647;
+function expandEnvValue(value) {
+  const resolved = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+    const envValue = process.env[name];
+    if (envValue === void 0 || envValue === "") {
+      throw new Error(`replicaPeers: environment variable ${name} is not set`);
+    }
+    return envValue;
+  });
+  const unterminated = resolved.match(/\$\{[^}]*$/);
+  if (unterminated) {
+    throw new Error(`replicaPeers: unterminated environment variable placeholder: ${unterminated[0]}`);
+  }
+  const remaining = resolved.match(/\$\{[^}]*\}/);
+  if (remaining) {
+    throw new Error(`replicaPeers: malformed environment variable placeholder: ${remaining[0]}`);
+  }
+  return resolved;
+}
+function parseIntegerAtLeast(value, min, dflt, label, max = Number.MAX_SAFE_INTEGER) {
+  if (value === void 0) return dflt;
+  const coerced = coerceNumber(value);
+  if (coerced === void 0 || !Number.isFinite(coerced) || !Number.isInteger(coerced) || coerced < min) {
+    throw new Error(`${label} must be an integer greater than or equal to ${min}; got ${JSON.stringify(value)}`);
+  }
+  if (coerced > max) {
+    throw new Error(`${label} must be an integer no greater than ${max}; got ${JSON.stringify(value)}`);
+  }
+  return coerced;
+}
+function asRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function parseReplicaPeerToken(raw, index) {
+  if (raw === void 0) return void 0;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      throw new Error(`replicaPeers.peers[${index}].token must be a non-empty string or a SecretRef object`);
+    }
+    const expanded = expandEnvValue(trimmed);
+    if (expanded.trim().length === 0) {
+      throw new Error(`replicaPeers.peers[${index}].token expanded to an empty value`);
+    }
+    return expanded;
+  }
+  if (isAgentAccessSecretRef(raw)) return raw;
+  throw new Error(`replicaPeers.peers[${index}].token must be a string or a SecretRef object`);
+}
+function parseReplicaPeer(value, index) {
+  const record = asRecord(value, `replicaPeers.peers[${index}]`);
+  if (typeof record.url !== "string" || record.url.trim().length === 0) {
+    throw new Error(`replicaPeers.peers[${index}].url must be a non-empty string`);
+  }
+  const url = expandEnvValue(record.url.trim());
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`replicaPeers.peers[${index}].url is not a valid URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`replicaPeers.peers[${index}].url must be an http(s) URL (got ${parsed.protocol})`);
+  }
+  if (parsed.search.length > 0 || parsed.hash.length > 0 || parsed.username.length > 0 || parsed.password.length > 0) {
+    throw new Error(`replicaPeers.peers[${index}].url must be a clean base URL (no query, fragment, or embedded credentials)`);
+  }
+  const token = parseReplicaPeerToken(record.token, index);
+  const canonical = parsed.toString().replace(/\/+$/, "");
+  return token === void 0 ? { url: canonical } : { url: canonical, token };
+}
+function parseStrictBool(value, fallback, label) {
+  if (value === void 0) return fallback;
+  const coerced = coerceBool(value);
+  if (coerced === void 0) {
+    throw new Error(`${label} must be a boolean (got ${JSON.stringify(value)})`);
+  }
+  return coerced;
+}
+function parseReplicaPeersConfig(cfg) {
+  const raw = cfg.replicaPeers;
+  if (raw !== void 0 && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
+    throw new Error(`replicaPeers must be a plain object (got ${JSON.stringify(raw)})`);
+  }
+  const block = raw ?? {};
+  if (block.peers !== void 0 && !Array.isArray(block.peers)) {
+    throw new Error(`replicaPeers.peers must be an array (got ${JSON.stringify(block.peers)})`);
+  }
+  const peers = (block.peers ?? []).map(parseReplicaPeer);
+  return {
+    enabled: parseStrictBool(block.enabled, false, "replicaPeers.enabled"),
+    peers,
+    pollIntervalMs: parseIntegerAtLeast(block.pollIntervalMs, 1, DEFAULT_POLL_INTERVAL_MS, "replicaPeers.pollIntervalMs"),
+    requestTimeoutMs: parseIntegerAtLeast(block.requestTimeoutMs, 1, DEFAULT_REQUEST_TIMEOUT_MS, "replicaPeers.requestTimeoutMs", MAX_TIMER_DELAY_MS),
+    maxFileCountDelta: parseIntegerAtLeast(block.maxFileCountDelta, 0, DEFAULT_MAX_FILE_COUNT_DELTA, "replicaPeers.maxFileCountDelta"),
+    maxWatermarkAgeDeltaMs: parseIntegerAtLeast(
+      block.maxWatermarkAgeDeltaMs,
+      0,
+      DEFAULT_MAX_WATERMARK_AGE_DELTA_MS,
+      "replicaPeers.maxWatermarkAgeDeltaMs"
+    )
+  };
+}
+function resolveReplicaPeersConfig(block) {
+  const record = block !== null && typeof block === "object" && !Array.isArray(block) ? block : {};
+  return {
+    enabled: coerceBool(record.enabled) ?? false,
+    peers: resolveReplicaPeers(record.peers),
+    pollIntervalMs: resolveIntegerAtLeast(record.pollIntervalMs, 1, DEFAULT_POLL_INTERVAL_MS),
+    requestTimeoutMs: resolveIntegerAtLeast(record.requestTimeoutMs, 1, DEFAULT_REQUEST_TIMEOUT_MS, MAX_TIMER_DELAY_MS),
+    maxFileCountDelta: resolveIntegerAtLeast(record.maxFileCountDelta, 0, DEFAULT_MAX_FILE_COUNT_DELTA),
+    maxWatermarkAgeDeltaMs: resolveIntegerAtLeast(record.maxWatermarkAgeDeltaMs, 0, DEFAULT_MAX_WATERMARK_AGE_DELTA_MS)
+  };
+}
+function resolveIntegerAtLeast(value, min, dflt, max = Number.MAX_SAFE_INTEGER) {
+  if (value === void 0) return dflt;
+  const coerced = coerceNumber(value);
+  return coerced !== void 0 && Number.isFinite(coerced) && Number.isInteger(coerced) && coerced >= min && coerced <= max ? coerced : dflt;
+}
+function resolveReplicaPeers(value) {
+  if (!Array.isArray(value)) return [];
+  const peers = [];
+  value.forEach((entry, index) => {
+    try {
+      peers.push(parseReplicaPeer(entry, index));
+    } catch {
+    }
+  });
+  return peers;
+}
+
+export {
+  parseReplicaPeersConfig,
+  resolveReplicaPeersConfig
+};
+//# sourceMappingURL=chunk-WNIUPHWV.js.map

package/dist/chunk-WNIUPHWV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/replica-peers-config.ts"],"sourcesContent":["/**\n * `replicaPeers` config surface (issue #2149) — types + parser.\n *\n * Deliberately split out of replica-divergence.ts as a LIGHT module: it imports\n * no heavy modules (no corpus-watermark, no access-token-capabilities). PluginConfig\n * carries `replicaPeers: ReplicaPeersConfig`, so types.ts imports ReplicaPeersConfig\n * from HERE. If that type instead lived in replica-divergence.ts (which pulls in the\n * corpus census graph), then types.ts -> replica-divergence.ts -> corpus-watermark.ts\n * -> types.ts would form a heavy import cycle that rollup-plugin-dts re-expands across\n * every PluginConfig-inlining entry, OOMing the default-heap DTS worker (the issue\n * #1562 heap cliff). Keeping the config surface corpus-free severs that cycle.\n */\n\nimport { coerceBool, coerceNumber } from \"./connectors/coerce.js\";\nimport { isAgentAccessSecretRef } from \"./resolve-auth-token.js\";\nimport type { AgentAccessAuthToken } from \"./types.js\";\n\nconst DEFAULT_POLL_INTERVAL_MS = 300_000; // 5 min\nconst DEFAULT_REQUEST_TIMEOUT_MS = 10_000;\nconst DEFAULT_MAX_FILE_COUNT_DELTA = 100;\nconst DEFAULT_MAX_WATERMARK_AGE_DELTA_MS = 900_000; // 15 min\n/** Node clamps a `setTimeout`/`AbortSignal.timeout` delay above 2^31-1 ms to 1ms,\n *  which would make `withDeadline` fire immediately and mark every peer unreachable. */\nconst MAX_TIMER_DELAY_MS = 2_147_483_647;\n\nexport interface ReplicaPeerConfig {\n  /** Base URL of the peer's agent-access HTTP server (http/https). */\n  url: string;\n  /**\n   * Bearer token for the peer's authenticated `/health`. A literal string\n   * (env-expanded) or an unresolved SecretRef preserved verbatim and resolved\n   * at poll time — mirrors `agentAccessHttp.authToken` exactly.\n   */\n  token?: AgentAccessAuthToken;\n}\n\nexport interface ReplicaPeersConfig {\n  /** Master gate. Default false — a daemon with no peers behaves exactly as before. */\n  enabled: boolean;\n  /** Peers to poll. Default []. */\n  peers: ReplicaPeerConfig[];\n  /** How often a peer is re-polled (SWR TTL), ms. Default 5 min. */\n  pollIntervalMs: number;\n  /** Per-peer request timeout, ms. Default 10s. */\n  requestTimeoutMs: number;\n  /** File-count delta (per namespace) beyond which a peer is flagged diverged. Default 100. */\n  maxFileCountDelta: number;\n  /** Newest-write timestamp gap (per namespace) beyond which a peer is flagged diverged, ms. Default 15 min. */\n  maxWatermarkAgeDeltaMs: number;\n}\n\n/**\n * Expand `${ENV_VAR}` placeholders in a config string, matching config.ts's\n * `resolveEnvVars` semantics (throw on unset var / malformed placeholder).\n * Inlined rather than imported because config.ts imports THIS module for\n * `parseReplicaPeersConfig`, so importing back would be circular — the same\n * reason extraction-liveness.ts inlines its numeric validation.\n */\nfunction expandEnvValue(value: string): string {\n  const resolved = value.replace(/\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g, (_match, name: string) => {\n    const envValue = process.env[name];\n    if (envValue === undefined || envValue === \"\") {\n      throw new Error(`replicaPeers: environment variable ${name} is not set`);\n    }\n    return envValue;\n  });\n  // An UNTERMINATED `${NAME` matches neither the replacement regex nor the\n  // balanced leftover check below, so the literal typo would be sent as the\n  // bearer token and surface as a misleading `http_401` (round 8, codex P2).\n  const unterminated = resolved.match(/\\$\\{[^}]*$/);\n  if (unterminated) {\n    throw new Error(`replicaPeers: unterminated environment variable placeholder: ${unterminated[0]}`);\n  }\n  const remaining = resolved.match(/\\$\\{[^}]*\\}/);\n  if (remaining) {\n    throw new Error(`replicaPeers: malformed environment variable placeholder: ${remaining[0]}`);\n  }\n  return resolved;\n}\n\n/**\n * An absent key falls back to the default; any PRESENT value (including an\n * explicit `null`) must coerce to an integer `>= min`, else THROW. A fractional\n * or out-of-range value is rejected, never floored/reinterpreted (§1/§17/§39).\n */\nfunction parseIntegerAtLeast(value: unknown, min: number, dflt: number, label: string, max = Number.MAX_SAFE_INTEGER): number {\n  if (value === undefined) return dflt;\n  const coerced = coerceNumber(value);\n  if (coerced === undefined || !Number.isFinite(coerced) || !Number.isInteger(coerced) || coerced < min) {\n    throw new Error(`${label} must be an integer greater than or equal to ${min}; got ${JSON.stringify(value)}`);\n  }\n  if (coerced > max) {\n    throw new Error(`${label} must be an integer no greater than ${max}; got ${JSON.stringify(value)}`);\n  }\n  return coerced;\n}\n\nfunction asRecord(value: unknown, label: string): Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new Error(`${label} must be an object`);\n  }\n  return value as Record<string, unknown>;\n}\n\nfunction parseReplicaPeerToken(raw: unknown, index: number): AgentAccessAuthToken | undefined {\n  // Only an OMITTED token selects unauthenticated polling. A present `null` (round\n  // 4, codex P2) or an explicit empty/whitespace string (round 6, codex P2) is a\n  // present-but-invalid credential: silently dropping it polls without the token\n  // and surfaces a healthy peer as `http_401`, hiding the real config error.\n  if (raw === undefined) return undefined;\n  if (typeof raw === \"string\") {\n    const trimmed = raw.trim();\n    if (trimmed.length === 0) {\n      throw new Error(`replicaPeers.peers[${index}].token must be a non-empty string or a SecretRef object`);\n    }\n    // Re-validate AFTER expansion: `${PEER_TOKEN}` pointing at a whitespace-only\n    // env value clears the check above, then resolveAgentAccessAuthToken\n    // normalizes it to undefined — silently downgrading an explicitly\n    // authenticated peer to an unauthenticated poll read as http_401 (round 9).\n    const expanded = expandEnvValue(trimmed);\n    if (expanded.trim().length === 0) {\n      throw new Error(`replicaPeers.peers[${index}].token expanded to an empty value`);\n    }\n    return expanded;\n  }\n  if (isAgentAccessSecretRef(raw)) return raw;\n  throw new Error(`replicaPeers.peers[${index}].token must be a string or a SecretRef object`);\n}\n\nfunction parseReplicaPeer(value: unknown, index: number): ReplicaPeerConfig {\n  const record = asRecord(value, `replicaPeers.peers[${index}]`);\n  if (typeof record.url !== \"string\" || record.url.trim().length === 0) {\n    throw new Error(`replicaPeers.peers[${index}].url must be a non-empty string`);\n  }\n  const url = expandEnvValue(record.url.trim());\n  let parsed: URL;\n  try {\n    parsed = new URL(url);\n  } catch {\n    throw new Error(`replicaPeers.peers[${index}].url is not a valid URL`);\n  }\n  if (parsed.protocol !== \"http:\" && parsed.protocol !== \"https:\") {\n    throw new Error(`replicaPeers.peers[${index}].url must be an http(s) URL (got ${parsed.protocol})`);\n  }\n  // The health path is appended to this base by string concatenation, so a query\n  // or fragment would corrupt the request URL (`https://h?x` + `/engram/v1/health`\n  // targets `/` with a mangled query; a fragment drops the path). Reject them at\n  // parse time — a peer URL must be a clean base (round 6, codex). Embedded\n  // credentials (`user:pass@host`) are rejected too: Node's fetch refuses to\n  // construct a request from a URL with credentials, so a healthy peer would\n  // falsely read as unreachable while redaction hid the config mistake.\n  if (parsed.search.length > 0 || parsed.hash.length > 0 || parsed.username.length > 0 || parsed.password.length > 0) {\n    throw new Error(`replicaPeers.peers[${index}].url must be a clean base URL (no query, fragment, or embedded credentials)`);\n  }\n  const token = parseReplicaPeerToken(record.token, index);\n  // Store the CANONICAL form: `new URL()` tolerates surrounding whitespace that\n  // the raw string keeps, and the health path is appended by concatenation - so\n  // \" https://peer /engram/v1/health\" reads as an unreachable healthy peer.\n  const canonical = parsed.toString().replace(/\\/+$/, \"\");\n  return token === undefined ? { url: canonical } : { url: canonical, token };\n}\n\n/**\n * Parse the `replicaPeers` config block. Mirrors the nested-block validation of\n * the other config-block parsers; coerces string booleans (§24) and rejects\n * invalid numbers/urls/shapes (§1/§39).\n */\n/**\n * Strict boolean for the parse path: absent -> the default, present -> must be\n * a recognized boolean token. A value like `1` must NOT silently reinterpret as\n * `false`, which would leave monitoring off after an operator tried to enable\n * it (round 3, codex P2). The lenient read-boundary resolver still defaults.\n */\nfunction parseStrictBool(value: unknown, fallback: boolean, label: string): boolean {\n  if (value === undefined) return fallback;\n  const coerced = coerceBool(value);\n  if (coerced === undefined) {\n    throw new Error(`${label} must be a boolean (got ${JSON.stringify(value)})`);\n  }\n  return coerced;\n}\n\nexport function parseReplicaPeersConfig(cfg: Record<string, unknown>): ReplicaPeersConfig {\n  const raw = cfg.replicaPeers;\n  if (raw !== undefined && (raw === null || typeof raw !== \"object\" || Array.isArray(raw))) {\n    throw new Error(`replicaPeers must be a plain object (got ${JSON.stringify(raw)})`);\n  }\n  const block = (raw ?? {}) as Record<string, unknown>;\n  if (block.peers !== undefined && !Array.isArray(block.peers)) {\n    throw new Error(`replicaPeers.peers must be an array (got ${JSON.stringify(block.peers)})`);\n  }\n  const peers = (block.peers ?? []).map(parseReplicaPeer);\n  return {\n    enabled: parseStrictBool(block.enabled, false, \"replicaPeers.enabled\"),\n    peers,\n    pollIntervalMs: parseIntegerAtLeast(block.pollIntervalMs, 1, DEFAULT_POLL_INTERVAL_MS, \"replicaPeers.pollIntervalMs\"),\n    requestTimeoutMs: parseIntegerAtLeast(block.requestTimeoutMs, 1, DEFAULT_REQUEST_TIMEOUT_MS, \"replicaPeers.requestTimeoutMs\", MAX_TIMER_DELAY_MS),\n    maxFileCountDelta: parseIntegerAtLeast(block.maxFileCountDelta, 0, DEFAULT_MAX_FILE_COUNT_DELTA, \"replicaPeers.maxFileCountDelta\"),\n    maxWatermarkAgeDeltaMs: parseIntegerAtLeast(\n      block.maxWatermarkAgeDeltaMs,\n      0,\n      DEFAULT_MAX_WATERMARK_AGE_DELTA_MS,\n      \"replicaPeers.maxWatermarkAgeDeltaMs\",\n    ),\n  };\n}\n\n/**\n * READ-boundary resolver (mirrors `resolveExtractionLivenessConfig`, issue #2155).\n * `parseConfig` always populates `replicaPeers`, but a host adapter, an older\n * persisted config, or a hand-built `PluginConfig` can hand a READ surface\n * (/health, doctor) an absent, partial, or loosely-typed block. Every replica\n * surface must degrade to the documented default (disabled, no peers, no polling)\n * rather than throw — `/health` must stay answerable. Unlike the strict parser, a\n * present-but-invalid field falls back to its default here instead of throwing, and\n * a malformed peer entry is dropped rather than aborting the whole block.\n */\nexport function resolveReplicaPeersConfig(block: unknown): ReplicaPeersConfig {\n  const record =\n    block !== null && typeof block === \"object\" && !Array.isArray(block) ? (block as Record<string, unknown>) : {};\n  return {\n    enabled: coerceBool(record.enabled) ?? false,\n    peers: resolveReplicaPeers(record.peers),\n    pollIntervalMs: resolveIntegerAtLeast(record.pollIntervalMs, 1, DEFAULT_POLL_INTERVAL_MS),\n    requestTimeoutMs: resolveIntegerAtLeast(record.requestTimeoutMs, 1, DEFAULT_REQUEST_TIMEOUT_MS, MAX_TIMER_DELAY_MS),\n    maxFileCountDelta: resolveIntegerAtLeast(record.maxFileCountDelta, 0, DEFAULT_MAX_FILE_COUNT_DELTA),\n    maxWatermarkAgeDeltaMs: resolveIntegerAtLeast(record.maxWatermarkAgeDeltaMs, 0, DEFAULT_MAX_WATERMARK_AGE_DELTA_MS),\n  };\n}\n\n/** Lenient sibling of {@link parseIntegerAtLeast}: a present-but-invalid value falls back, never throws. */\nfunction resolveIntegerAtLeast(value: unknown, min: number, dflt: number, max = Number.MAX_SAFE_INTEGER): number {\n  if (value === undefined) return dflt;\n  const coerced = coerceNumber(value);\n  return coerced !== undefined && Number.isFinite(coerced) && Number.isInteger(coerced) && coerced >= min && coerced <= max ? coerced : dflt;\n}\n\n/** Lenient peer list: a non-array is empty; a malformed entry is dropped, never thrown (read boundary). */\nfunction resolveReplicaPeers(value: unknown): ReplicaPeerConfig[] {\n  if (!Array.isArray(value)) return [];\n  const peers: ReplicaPeerConfig[] = [];\n  value.forEach((entry, index) => {\n    try {\n      peers.push(parseReplicaPeer(entry, index));\n    } catch {\n      // Read surfaces never throw on a bad peer — parseConfig is the enforcing boundary.\n    }\n  });\n  return peers;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WRJVB3C2.js

@@ -0,0 +1,118 @@
+import {
+  assertPathInsideRoot
+} from "./chunk-GCASGYIO.js";
+import {
+  getMemoryProjectionPath,
+  initializeMemoryProjectionDb
+} from "./chunk-3CSX3ETE.js";
+import {
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
+import {
+  isErrnoCode
+} from "./chunk-5UZXUTVO.js";
+
+// src/memory-projection-mutations.ts
+import { lstat, realpath } from "fs/promises";
+var PROJECTION_WRITE_BUSY_TIMEOUT_MS = 100;
+var PROJECTION_WRITE_RETRY_COUNT = 4;
+var PROJECTION_WRITE_RETRY_DELAY_MS = 100;
+function isSqliteBusyError(error) {
+  const messages = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== null && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    if (current instanceof Error) messages.push(current.message);
+    if (!("cause" in current)) break;
+    current = current.cause;
+  }
+  const lower = messages.join("\n").toLowerCase();
+  return lower.includes("database is locked") || lower.includes("sqlite_busy");
+}
+async function validateProjectionPath(memoryDir, projectionPath) {
+  let projectionStat;
+  try {
+    projectionStat = await lstat(projectionPath);
+  } catch (error) {
+    if (isErrnoCode(error, "ENOENT")) return false;
+    throw error;
+  }
+  if (projectionStat.isSymbolicLink() || !projectionStat.isFile()) {
+    throw new Error(`Refusing memory projection rewrite through unsafe database path: ${projectionPath}.`);
+  }
+  const [memoryRoot, projectionReal] = await Promise.all([
+    realpath(memoryDir),
+    realpath(projectionPath)
+  ]);
+  assertPathInsideRoot(memoryRoot, projectionReal, projectionPath);
+  return true;
+}
+async function rewriteProjectedEntityReferenceRows(memoryDir, entries, memoryId) {
+  if (memoryId !== void 0 && memoryId.length === 0) {
+    throw new Error("Projection memoryId must not be empty.");
+  }
+  const scopedMemory = memoryId !== void 0;
+  const validEntries = entries.filter(
+    ([previousEntityRef, nextEntityRef]) => previousEntityRef.length > 0 && nextEntityRef.length > 0 && previousEntityRef !== nextEntityRef
+  );
+  if (validEntries.length === 0) return;
+  const projectionPath = getMemoryProjectionPath(memoryDir);
+  if (!await validateProjectionPath(memoryDir, projectionPath)) return;
+  let lastError;
+  for (let attempt = 0; attempt < PROJECTION_WRITE_RETRY_COUNT; attempt += 1) {
+    if (!await validateProjectionPath(memoryDir, projectionPath)) return;
+    let db = null;
+    try {
+      db = openBetterSqlite3(projectionPath, { fileMustExist: true });
+      db.pragma(`busy_timeout = ${PROJECTION_WRITE_BUSY_TIMEOUT_MS}`);
+      initializeMemoryProjectionDb(db);
+      const updateCurrent = db.prepare(
+        scopedMemory ? "UPDATE memory_current SET entity_ref = ? WHERE memory_id = ? AND entity_ref = ?" : "UPDATE memory_current SET entity_ref = ? WHERE entity_ref = ?"
+      );
+      const updateMentions = db.prepare(
+        scopedMemory ? `
+            UPDATE memory_entity_mentions
+            SET entity_ref = ?
+            WHERE memory_id = ? AND entity_ref = ? AND mention_source = 'frontmatter.entityRef'
+          ` : `
+            UPDATE memory_entity_mentions
+            SET entity_ref = ?
+            WHERE entity_ref = ? AND mention_source = 'frontmatter.entityRef'
+          `
+      );
+      const rewrite = db.transaction(() => {
+        for (const [previousEntityRef, nextEntityRef] of validEntries) {
+          const params = scopedMemory ? [nextEntityRef, memoryId, previousEntityRef] : [nextEntityRef, previousEntityRef];
+          updateCurrent.run(...params);
+          updateMentions.run(...params);
+        }
+      });
+      rewrite();
+      return;
+    } catch (error) {
+      lastError = error;
+      if (!isSqliteBusyError(error) || attempt === PROJECTION_WRITE_RETRY_COUNT - 1) {
+        throw error;
+      }
+      const { promise, resolve } = Promise.withResolvers();
+      setTimeout(resolve, PROJECTION_WRITE_RETRY_DELAY_MS);
+      await promise;
+    } finally {
+      db?.close();
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Projection rewrite failed.");
+}
+async function rewriteProjectedMemoryEntityReference(memoryDir, memoryId, previousEntityRef, nextEntityRef) {
+  await rewriteProjectedEntityReferenceRows(memoryDir, [[previousEntityRef, nextEntityRef]], memoryId);
+}
+async function rewriteProjectedEntityReferences(memoryDir, replacements) {
+  await rewriteProjectedEntityReferenceRows(memoryDir, Object.entries(replacements));
+}
+
+export {
+  rewriteProjectedMemoryEntityReference,
+  rewriteProjectedEntityReferences
+};
+//# sourceMappingURL=chunk-WRJVB3C2.js.map

package/dist/chunk-WRJVB3C2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-projection-mutations.ts"],"sourcesContent":["import { lstat, realpath } from \"node:fs/promises\";\nimport { isErrnoCode } from \"./utils/errno.js\";\nimport { assertPathInsideRoot } from \"./utils/path-containment.js\";\nimport { getMemoryProjectionPath, initializeMemoryProjectionDb } from \"./memory-projection-store.js\";\nimport { type BetterSqlite3Database, openBetterSqlite3 } from \"./runtime/better-sqlite.js\";\n\nconst PROJECTION_WRITE_BUSY_TIMEOUT_MS = 100;\nconst PROJECTION_WRITE_RETRY_COUNT = 4;\nconst PROJECTION_WRITE_RETRY_DELAY_MS = 100;\n\nfunction isSqliteBusyError(error: unknown): boolean {\n  const messages: string[] = [];\n  const seen = new Set<unknown>();\n  let current: unknown = error;\n  while (current !== null && typeof current === \"object\" && !seen.has(current)) {\n    seen.add(current);\n    if (current instanceof Error) messages.push(current.message);\n    if (!(\"cause\" in current)) break;\n    current = current.cause;\n  }\n  const lower = messages.join(\"\\n\").toLowerCase();\n  return lower.includes(\"database is locked\") || lower.includes(\"sqlite_busy\");\n}\n\nasync function validateProjectionPath(\n  memoryDir: string,\n  projectionPath: string,\n): Promise<boolean> {\n  let projectionStat;\n  try {\n    projectionStat = await lstat(projectionPath);\n  } catch (error) {\n    if (isErrnoCode(error, \"ENOENT\")) return false;\n    throw error;\n  }\n  if (projectionStat.isSymbolicLink() || !projectionStat.isFile()) {\n    throw new Error(`Refusing memory projection rewrite through unsafe database path: ${projectionPath}.`);\n  }\n  const [memoryRoot, projectionReal] = await Promise.all([\n    realpath(memoryDir),\n    realpath(projectionPath),\n  ]);\n  assertPathInsideRoot(memoryRoot, projectionReal, projectionPath);\n  return true;\n}\n\nasync function rewriteProjectedEntityReferenceRows(\n  memoryDir: string,\n  entries: ReadonlyArray<readonly [string, string]>,\n  memoryId?: string,\n): Promise<void> {\n  if (memoryId !== undefined && memoryId.length === 0) {\n    throw new Error(\"Projection memoryId must not be empty.\");\n  }\n  const scopedMemory = memoryId !== undefined;\n  const validEntries = entries.filter(\n    ([previousEntityRef, nextEntityRef]) =>\n      previousEntityRef.length > 0 && nextEntityRef.length > 0 && previousEntityRef !== nextEntityRef,\n  );\n  if (validEntries.length === 0) return;\n\n  const projectionPath = getMemoryProjectionPath(memoryDir);\n  if (!(await validateProjectionPath(memoryDir, projectionPath))) return;\n\n  let lastError: unknown;\n  for (let attempt = 0; attempt < PROJECTION_WRITE_RETRY_COUNT; attempt += 1) {\n    if (!(await validateProjectionPath(memoryDir, projectionPath))) return;\n    let db: BetterSqlite3Database | null = null;\n    try {\n      db = openBetterSqlite3(projectionPath, { fileMustExist: true });\n      db.pragma(`busy_timeout = ${PROJECTION_WRITE_BUSY_TIMEOUT_MS}`);\n      initializeMemoryProjectionDb(db);\n      const updateCurrent = db.prepare(\n        scopedMemory\n          ? \"UPDATE memory_current SET entity_ref = ? WHERE memory_id = ? AND entity_ref = ?\"\n          : \"UPDATE memory_current SET entity_ref = ? WHERE entity_ref = ?\",\n      );\n      const updateMentions = db.prepare(\n        scopedMemory\n          ? `\n            UPDATE memory_entity_mentions\n            SET entity_ref = ?\n            WHERE memory_id = ? AND entity_ref = ? AND mention_source = 'frontmatter.entityRef'\n          `\n          : `\n            UPDATE memory_entity_mentions\n            SET entity_ref = ?\n            WHERE entity_ref = ? AND mention_source = 'frontmatter.entityRef'\n          `,\n      );\n      const rewrite = db.transaction(() => {\n        for (const [previousEntityRef, nextEntityRef] of validEntries) {\n          const params = scopedMemory\n            ? [nextEntityRef, memoryId, previousEntityRef]\n            : [nextEntityRef, previousEntityRef];\n          updateCurrent.run(...params);\n          updateMentions.run(...params);\n        }\n      });\n      rewrite();\n      return;\n    } catch (error) {\n      lastError = error;\n      if (!isSqliteBusyError(error) || attempt === PROJECTION_WRITE_RETRY_COUNT - 1) {\n        throw error;\n      }\n      const { promise, resolve } = Promise.withResolvers<void>();\n      setTimeout(resolve, PROJECTION_WRITE_RETRY_DELAY_MS);\n      await promise;\n    } finally {\n      db?.close();\n    }\n  }\n\n  throw lastError instanceof Error ? lastError : new Error(\"Projection rewrite failed.\");\n}\n\nexport async function rewriteProjectedMemoryEntityReference(\n  memoryDir: string,\n  memoryId: string,\n  previousEntityRef: string,\n  nextEntityRef: string,\n): Promise<void> {\n  await rewriteProjectedEntityReferenceRows(memoryDir, [[previousEntityRef, nextEntityRef]], memoryId);\n}\n\nexport async function rewriteProjectedEntityReferences(\n  memoryDir: string,\n  replacements: Readonly<Record<string, string>>,\n): Promise<void> {\n  await rewriteProjectedEntityReferenceRows(memoryDir, Object.entries(replacements));\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-BHLN7L7M.js → chunk-WVVK2RFM.js}

@@ -4,17 +4,17 @@ import {
 import {
   loadPersistedNativeKnowledgeChunks
 } from "./chunk-2DQ2XREU.js";
-import {
-  commitPreparedFileAtomically
-} from "./chunk-R6YJI3HE.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-FRVTCCGD.js";
+} from "./chunk-GJPCP5CA.js";
+import {
+  commitPreparedFileAtomically
+} from "./chunk-R6YJI3HE.js";
 import {
   StorageManager,
   assertInjectedStorageRooted
-} from "./chunk-CIQXI47W.js";
+} from "./chunk-Q5VJUNXA.js";
 import {
   MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
   buildLifecycleEventsForMemory,
@@ -1024,4 +1024,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-BHLN7L7M.js.map
+//# sourceMappingURL=chunk-WVVK2RFM.js.map

package/dist/{chunk-DQEMWVMT.js → chunk-X7Y7WX73.js}

@@ -246,4 +246,4 @@ export {
   decryptCapsuleFile,
   decryptCapsuleFileInMemory
 };
-//# sourceMappingURL=chunk-DQEMWVMT.js.map
+//# sourceMappingURL=chunk-X7Y7WX73.js.map

package/dist/{chunk-HEXSNYJD.js → chunk-YOBNCD3Z.js}

@@ -1,9 +1,9 @@
-import {
-  runGraphEdgeDecayMaintenanceAcrossNamespaces
-} from "./chunk-HNZKVLAN.js";
 import {
   normalizeDreamsStatusWindowHours
 } from "./chunk-EQWEIIKQ.js";
+import {
+  runGraphEdgeDecayMaintenanceAcrossNamespaces
+} from "./chunk-HNZKVLAN.js";
 import {
   runContradictionScan
 } from "./chunk-BJJAX3IZ.js";
@@ -28,13 +28,13 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-NUWMZIYZ.js";
+} from "./chunk-UR5SIN7H.js";
 import {
   projectTagProjectId
 } from "./chunk-MQVINOJQ.js";
 import {
   validateBriefingFormat
-} from "./chunk-CI26JDZA.js";
+} from "./chunk-GQSMYXKL.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -484,4 +484,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-HEXSNYJD.js.map
+//# sourceMappingURL=chunk-YOBNCD3Z.js.map

package/dist/chunk-YXZG5TVN.js

@@ -0,0 +1,40 @@
+// src/entity-id-normalization.ts
+var BUILTIN_ALIASES = {
+  openclaw: "openclaw",
+  "open-claw": "openclaw"
+};
+function normalizeEntityNameWithPattern(raw, type, aliases, pattern, normalizeUnicode) {
+  const rawStr = typeof raw === "string" ? raw : "";
+  const typeStr = typeof type === "string" && type.trim().length > 0 ? type : "entity";
+  const typePrefix = `${typeStr.toLowerCase()}-`;
+  let name = normalizeUnicode ? rawStr.normalize("NFC").toLowerCase().trim() : rawStr.toLowerCase().trim();
+  if (name.startsWith(typePrefix)) name = name.slice(typePrefix.length);
+  let normalized = name.replace(pattern, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  let legacyNormalized;
+  if (normalizeUnicode) {
+    let legacyName = rawStr.toLowerCase().trim();
+    if (legacyName.startsWith(typePrefix)) legacyName = legacyName.slice(typePrefix.length);
+    legacyNormalized = legacyName.replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  const unicodeAlias = aliases !== void 0 && Object.hasOwn(aliases, normalized) ? aliases[normalized] : void 0;
+  const legacyAlias = legacyNormalized !== void 0 && legacyNormalized !== normalized && aliases !== void 0 && Object.hasOwn(aliases, legacyNormalized) ? aliases[legacyNormalized] : void 0;
+  const userAlias = typeof unicodeAlias === "string" && unicodeAlias.length > 0 ? unicodeAlias : legacyAlias;
+  if (typeof userAlias === "string" && userAlias.length > 0) {
+    normalized = userAlias;
+  } else if (Object.hasOwn(BUILTIN_ALIASES, normalized)) {
+    normalized = BUILTIN_ALIASES[normalized];
+  }
+  return `${typeStr.toLowerCase()}-${normalized}`;
+}
+function normalizeEntityName(raw, type, aliases) {
+  return normalizeEntityNameWithPattern(raw, type, aliases, /[^\p{L}\p{M}\p{N}]+/gu, true);
+}
+function normalizeLegacyEntityName(raw, type, aliases) {
+  return normalizeEntityNameWithPattern(raw, type, aliases, /[^a-z0-9]+/g, false);
+}
+
+export {
+  normalizeEntityName,
+  normalizeLegacyEntityName
+};
+//# sourceMappingURL=chunk-YXZG5TVN.js.map

package/dist/chunk-YXZG5TVN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/entity-id-normalization.ts"],"sourcesContent":["const BUILTIN_ALIASES: Record<string, string> = {\n  openclaw: \"openclaw\",\n  \"open-claw\": \"openclaw\",\n};\n\nfunction normalizeEntityNameWithPattern(\n  raw: string,\n  type: string,\n  aliases: Readonly<Record<string, string>> | undefined,\n  pattern: RegExp,\n  normalizeUnicode: boolean\n): string {\n  const rawStr = typeof raw === \"string\" ? raw : \"\";\n  const typeStr = typeof type === \"string\" && type.trim().length > 0 ? type : \"entity\";\n  const typePrefix = `${typeStr.toLowerCase()}-`;\n  let name = normalizeUnicode ? rawStr.normalize(\"NFC\").toLowerCase().trim() : rawStr.toLowerCase().trim();\n  if (name.startsWith(typePrefix)) name = name.slice(typePrefix.length);\n\n  let normalized = name.replace(pattern, \"-\").replace(/-+/g, \"-\").replace(/^-|-$/g, \"\");\n  let legacyNormalized: string | undefined;\n  if (normalizeUnicode) {\n    let legacyName = rawStr.toLowerCase().trim();\n    if (legacyName.startsWith(typePrefix)) legacyName = legacyName.slice(typePrefix.length);\n    legacyNormalized = legacyName.replace(/[^a-z0-9]+/g, \"-\").replace(/-+/g, \"-\").replace(/^-|-$/g, \"\");\n  }\n  const unicodeAlias = aliases !== undefined && Object.hasOwn(aliases, normalized) ? aliases[normalized] : undefined;\n  const legacyAlias =\n    legacyNormalized !== undefined && legacyNormalized !== normalized && aliases !== undefined &&\n    Object.hasOwn(aliases, legacyNormalized)\n      ? aliases[legacyNormalized]\n      : undefined;\n  const userAlias =\n    typeof unicodeAlias === \"string\" && unicodeAlias.length > 0\n      ? unicodeAlias\n      : legacyAlias;\n  if (typeof userAlias === \"string\" && userAlias.length > 0) {\n    normalized = userAlias;\n  } else if (Object.hasOwn(BUILTIN_ALIASES, normalized)) {\n    normalized = BUILTIN_ALIASES[normalized];\n  }\n\n  return `${typeStr.toLowerCase()}-${normalized}`;\n}\n\nexport function normalizeEntityName(raw: string, type: string, aliases?: Readonly<Record<string, string>>): string {\n  return normalizeEntityNameWithPattern(raw, type, aliases, /[^\\p{L}\\p{M}\\p{N}]+/gu, true);\n}\n\nexport function normalizeLegacyEntityName(\n  raw: string,\n  type: string,\n  aliases?: Readonly<Record<string, string>>\n): string {\n  return normalizeEntityNameWithPattern(raw, type, aliases, /[^a-z0-9]+/g, false);\n}\n"],"mappings":";AAAA,IAAM,kBAA0C;AAAA,EAC9C,UAAU;AAAA,EACV,aAAa;AACf;AAEA,SAAS,+BACP,KACA,MACA,SACA,SACA,kBACQ;AACR,QAAM,SAAS,OAAO,QAAQ,WAAW,MAAM;AAC/C,QAAM,UAAU,OAAO,SAAS,YAAY,KAAK,KAAK,EAAE,SAAS,IAAI,OAAO;AAC5E,QAAM,aAAa,GAAG,QAAQ,YAAY,CAAC;AAC3C,MAAI,OAAO,mBAAmB,OAAO,UAAU,KAAK,EAAE,YAAY,EAAE,KAAK,IAAI,OAAO,YAAY,EAAE,KAAK;AACvG,MAAI,KAAK,WAAW,UAAU,EAAG,QAAO,KAAK,MAAM,WAAW,MAAM;AAEpE,MAAI,aAAa,KAAK,QAAQ,SAAS,GAAG,EAAE,QAAQ,OAAO,GAAG,EAAE,QAAQ,UAAU,EAAE;AACpF,MAAI;AACJ,MAAI,kBAAkB;AACpB,QAAI,aAAa,OAAO,YAAY,EAAE,KAAK;AAC3C,QAAI,WAAW,WAAW,UAAU,EAAG,cAAa,WAAW,MAAM,WAAW,MAAM;AACtF,uBAAmB,WAAW,QAAQ,eAAe,GAAG,EAAE,QAAQ,OAAO,GAAG,EAAE,QAAQ,UAAU,EAAE;AAAA,EACpG;AACA,QAAM,eAAe,YAAY,UAAa,OAAO,OAAO,SAAS,UAAU,IAAI,QAAQ,UAAU,IAAI;AACzG,QAAM,cACJ,qBAAqB,UAAa,qBAAqB,cAAc,YAAY,UACjF,OAAO,OAAO,SAAS,gBAAgB,IACnC,QAAQ,gBAAgB,IACxB;AACN,QAAM,YACJ,OAAO,iBAAiB,YAAY,aAAa,SAAS,IACtD,eACA;AACN,MAAI,OAAO,cAAc,YAAY,UAAU,SAAS,GAAG;AACzD,iBAAa;AAAA,EACf,WAAW,OAAO,OAAO,iBAAiB,UAAU,GAAG;AACrD,iBAAa,gBAAgB,UAAU;AAAA,EACzC;AAEA,SAAO,GAAG,QAAQ,YAAY,CAAC,IAAI,UAAU;AAC/C;AAEO,SAAS,oBAAoB,KAAa,MAAc,SAAoD;AACjH,SAAO,+BAA+B,KAAK,MAAM,SAAS,yBAAyB,IAAI;AACzF;AAEO,SAAS,0BACd,KACA,MACA,SACQ;AACR,SAAO,+BAA+B,KAAK,MAAM,SAAS,eAAe,KAAK;AAChF;","names":[]}