@remnic/core 9.3.693 → 9.3.695

package/dist/{chunk-YN4ZT4CW.js → chunk-3LYJIA76.js}

@@ -216,4 +216,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-YN4ZT4CW.js.map
+//# sourceMappingURL=chunk-3LYJIA76.js.map

package/dist/{chunk-ADUAF5EV.js → chunk-3P2XEQSV.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-VFVG4NS2.js";
+} from "./chunk-MOBRVKWE.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
@@ -118,4 +118,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-ADUAF5EV.js.map
+//# sourceMappingURL=chunk-3P2XEQSV.js.map

package/dist/{chunk-KYH53EFD.js → chunk-4NNDJOAO.js}

@@ -1,6 +1,6 @@
 import {
   listNamespaces
-} from "./chunk-FM7KLRKN.js";
+} from "./chunk-6GAUF4OU.js";
 import {
   runConsolidationProvenanceCheck
 } from "./chunk-7XH7VJN4.js";
@@ -9,7 +9,7 @@ import {
 } from "./chunk-YBPYIAA5.js";
 import {
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-HXNMDPHN.js";
+} from "./chunk-G663XUEG.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -35,17 +35,17 @@ import {
 } from "./chunk-3PY7VHV7.js";
 import {
   parseConfig
-} from "./chunk-UTUYAPLY.js";
+} from "./chunk-EK6FYL2E.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-SAC5V6JT.js";
+} from "./chunk-XXA6T3O4.js";
 import {
   analyzeGraphHealth
-} from "./chunk-KF74X62T.js";
+} from "./chunk-YGKUAX2B.js";
 import {
   StorageManager
-} from "./chunk-VFVG4NS2.js";
+} from "./chunk-MOBRVKWE.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -788,7 +788,7 @@ async function summarizeBufferSurpriseDistribution(storage, config) {
   }
 }
 async function summarizeGraphEdgeDecayStatus(config) {
-  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-D7OESCBR.js");
+  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-JLOF3YW4.js");
   const enabled = config.graphEdgeDecayEnabled === true;
   if (!enabled) {
     return {
@@ -1347,4 +1347,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-KYH53EFD.js.map
+//# sourceMappingURL=chunk-4NNDJOAO.js.map

package/dist/{chunk-QFG23CRE.js → chunk-52QIAN76.js}

@@ -1,6 +1,6 @@
 import {
   runPostConsolidationMaterialize
-} from "./chunk-ADUAF5EV.js";
+} from "./chunk-3P2XEQSV.js";
 import {
   discoverMemoryExtensions,
   renderExtensionsBlock,
@@ -217,4 +217,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-QFG23CRE.js.map
+//# sourceMappingURL=chunk-52QIAN76.js.map

package/dist/chunk-5AT62NQH.js

@@ -0,0 +1,553 @@
+import {
+  gatewayTaskChainOptions
+} from "./chunk-5TYA4OCF.js";
+import {
+  extractJsonCandidates
+} from "./chunk-RGMVMVMF.js";
+import {
+  log
+} from "./chunk-NU3CSQ4H.js";
+
+// src/extraction-faithfulness.ts
+import { createHash } from "crypto";
+var FAITHFULNESS_SYSTEM_PROMPT = `You are a faithfulness verifier for a memory system. Given a QUOTE from the source conversation and an extracted FACT, determine whether the FACT is supported by the QUOTE.
+
+Rules:
+- "entailed" \u2014 the FACT directly follows from the QUOTE (paraphrase is OK).
+- "contradicted" \u2014 the FACT asserts something the QUOTE directly negates.
+- "unsupported" \u2014 the FACT introduces information not present in the QUOTE.
+
+Answer with a JSON array. Each element: {"index": <int>, "verdict": "entailed"|"contradicted"|"unsupported", "rationale": "<one sentence>"}.
+
+Examples:
+QUOTE: "I've been using Vim for about ten years now."
+FACT: "The user has used Vim for approximately a decade."
+{"index": 0, "verdict": "entailed", "rationale": "Paraphrase of the same duration."}
+
+QUOTE: "I've been using Vim for about ten years now."
+FACT: "The user prefers Emacs."
+{"index": 0, "verdict": "unsupported", "rationale": "QUOTE mentions Vim, not Emacs."}
+
+QUOTE: "I stopped drinking coffee last month."
+FACT: "The user drinks coffee regularly."
+{"index": 0, "verdict": "contradicted", "rationale": "QUOTE says they stopped; FACT claims the opposite."}`;
+var FAITHFULNESS_PROMPT_HASH = createHash("sha256").update(FAITHFULNESS_SYSTEM_PROMPT).digest("hex");
+function buildBatchPrompt(inputs, contextChars) {
+  const parts = [];
+  for (let i = 0; i < inputs.length; i++) {
+    const inp = inputs[i];
+    if (!inp) continue;
+    parts.push(`--- Item ${i} ---
+QUOTE: "${inp.quote}"`);
+    if (inp.context && inp.context.trim().length > 0) {
+      parts.push(`CONTEXT: "${inp.context.slice(0, contextChars)}"`);
+    }
+    parts.push(`FACT: "${inp.factText}"
+
+Respond with the JSON array entry for index ${i}.`);
+  }
+  parts.push(`
+Respond now with a single JSON array covering indexes 0\u2013${inputs.length - 1}.`);
+  return parts.join("\n");
+}
+var VALID_VERDICTS = /* @__PURE__ */ new Set(["entailed", "contradicted", "unsupported"]);
+function parseFaithfulnessResponse(raw, expectedCount) {
+  if (!raw || typeof raw !== "string" || raw.trim().length === 0) {
+    return null;
+  }
+  const candidates = extractJsonCandidates(raw);
+  for (const candidate of candidates) {
+    let parsed;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    const map = parseEntries(parsed, expectedCount);
+    if (map) return map;
+  }
+  try {
+    const single = JSON.parse(raw.trim());
+    const map = parseEntries([single], expectedCount);
+    if (map) return map;
+  } catch {
+  }
+  return null;
+}
+function parseEntries(data, expectedCount) {
+  if (!Array.isArray(data)) {
+    if (data && typeof data === "object") {
+      for (const key of ["results", "verdicts", "entries", "facts"]) {
+        const inner = data[key];
+        if (Array.isArray(inner)) return parseEntries(inner, expectedCount);
+      }
+    }
+    return null;
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of data) {
+    if (!entry || typeof entry !== "object") continue;
+    const obj = entry;
+    const idx = typeof obj.index === "number" ? obj.index : void 0;
+    if (idx === void 0 || idx < 0 || idx >= expectedCount) continue;
+    const verdictRaw = typeof obj.verdict === "string" ? obj.verdict : void 0;
+    if (!verdictRaw || !VALID_VERDICTS.has(verdictRaw)) continue;
+    const rationale = typeof obj.rationale === "string" && obj.rationale.trim().length > 0 ? obj.rationale.trim().slice(0, 500) : void 0;
+    map.set(idx, {
+      index: idx,
+      verdict: verdictRaw,
+      rationale
+    });
+  }
+  return map.size > 0 ? map : null;
+}
+async function callFaithfulnessLlm(systemPrompt, userPrompt, config, localLlm, fallbackLlm, timeoutMs, signal) {
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+  const modelOverride = config.extractionFaithfulnessModel || void 0;
+  const skipLocal = config.modelSource === "gateway" || Boolean(modelOverride);
+  const gatewayChain = gatewayTaskChainOptions(config);
+  let modelUsed = null;
+  if (localLlm && !skipLocal) {
+    try {
+      const result = await callLocalLlm(localLlm, messages, {
+        temperature: 0.1,
+        maxTokens: 2048,
+        responseFormat: { type: "json_object" },
+        timeoutMs,
+        operation: "extraction-faithfulness"
+      });
+      if (result.content) {
+        return { content: result.content, modelUsed: result.modelUsed ?? "local" };
+      }
+    } catch (err) {
+      log.debug(
+        `extraction-faithfulness: local LLM failed, trying fallback: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (fallbackLlm) {
+    try {
+      const result = await fallbackLlm.chatCompletion(
+        messages,
+        {
+          temperature: 0.1,
+          maxTokens: 2048,
+          timeoutMs,
+          ...modelOverride ? { model: modelOverride } : {},
+          ...gatewayChain,
+          ...signal ? { signal } : {}
+        }
+      );
+      if (result?.content) {
+        return { content: result.content, modelUsed: result.modelUsed ?? "fallback" };
+      }
+    } catch (err) {
+      log.debug(
+        `extraction-faithfulness: fallback LLM failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { content: null, modelUsed: null };
+}
+async function callLocalLlm(client, messages, options) {
+  const result = await client.chatCompletion(messages, options);
+  return {
+    content: result?.content ?? null
+  };
+}
+async function checkFaithfulnessBatch(inputs, config, localLlm, fallbackLlm) {
+  const timeoutMs = typeof config.extractionFaithfulnessTimeoutMs === "number" && Number.isFinite(config.extractionFaithfulnessTimeoutMs) && config.extractionFaithfulnessTimeoutMs > 0 ? config.extractionFaithfulnessTimeoutMs : 8e3;
+  const contextChars = typeof config.extractionFaithfulnessContextChars === "number" && Number.isFinite(config.extractionFaithfulnessContextChars) && config.extractionFaithfulnessContextChars > 0 ? config.extractionFaithfulnessContextChars : 400;
+  const results = new Array(inputs.length);
+  const checkableIndices = [];
+  const checkableInputs = [];
+  for (let i = 0; i < inputs.length; i++) {
+    const inp = inputs[i];
+    if (!inp || !inp.quote || inp.quote.trim().length === 0) {
+      results[i] = { ok: false, error: { code: "no_span" } };
+    } else if (!inp.factText || inp.factText.trim().length === 0) {
+      results[i] = { ok: false, error: { code: "no_span" } };
+    } else {
+      checkableIndices.push(i);
+      checkableInputs.push(inp);
+    }
+  }
+  if (checkableInputs.length === 0) {
+    return { results, elapsedMs: 0 };
+  }
+  const userPrompt = buildBatchPrompt(checkableInputs, contextChars);
+  const startedAt = Date.now();
+  let timedOut = false;
+  const controller = new AbortController();
+  let resolveTimeout;
+  const racedTimeout = new Promise((resolve) => {
+    resolveTimeout = resolve;
+  });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+    resolveTimeout(true);
+  }, timeoutMs);
+  try {
+    const callPromise = callFaithfulnessLlm(
+      FAITHFULNESS_SYSTEM_PROMPT,
+      userPrompt,
+      config,
+      localLlm,
+      fallbackLlm,
+      timeoutMs,
+      controller.signal
+    );
+    const settled = await Promise.race([
+      callPromise.then(
+        (r) => ({ done: true, result: r }),
+        // An unexpected throw is treated as "no content" (backend_unavailable)
+        // so the race never rejects and the outer catch is the final safety net.
+        () => ({ done: true, result: { content: null, modelUsed: null } })
+      ),
+      racedTimeout.then(() => ({ done: false }))
+    ]);
+    const elapsedMs = Date.now() - startedAt;
+    if (!settled.done) {
+      for (const idx of checkableIndices) {
+        results[idx] = { ok: false, error: { code: "timeout" } };
+      }
+      return { results, elapsedMs };
+    }
+    const llmResult = settled.result;
+    if (timedOut && !llmResult.content) {
+      for (const idx of checkableIndices) {
+        results[idx] = { ok: false, error: { code: "timeout" } };
+      }
+      return { results, elapsedMs };
+    }
+    if (!llmResult.content) {
+      for (const idx of checkableIndices) {
+        results[idx] = { ok: false, error: { code: "backend_unavailable" } };
+      }
+      return { results, elapsedMs };
+    }
+    const parsed = parseFaithfulnessResponse(llmResult.content, checkableInputs.length);
+    if (!parsed) {
+      for (const idx of checkableIndices) {
+        results[idx] = { ok: false, error: { code: "malformed_output" } };
+      }
+      return { results, elapsedMs };
+    }
+    for (let j = 0; j < checkableIndices.length; j++) {
+      const inputIdx = checkableIndices[j];
+      if (inputIdx === void 0) continue;
+      const entry = parsed.get(j);
+      if (entry) {
+        results[inputIdx] = {
+          ok: true,
+          verdict: entry.verdict,
+          model: llmResult.modelUsed ?? "unknown",
+          ...entry.rationale ? { rationale: entry.rationale } : {}
+        };
+      } else {
+        results[inputIdx] = { ok: false, error: { code: "malformed_output" } };
+      }
+    }
+    return { results, elapsedMs };
+  } catch (err) {
+    const elapsedMs = Date.now() - startedAt;
+    if (timedOut || isAbortError(err)) {
+      for (const idx of checkableIndices) {
+        results[idx] = { ok: false, error: { code: "timeout" } };
+      }
+      return { results, elapsedMs };
+    }
+    log.warn(
+      `extraction-faithfulness: batch check threw unexpectedly: ${err instanceof Error ? err.message : String(err)}`
+    );
+    for (const idx of checkableIndices) {
+      results[idx] = { ok: false, error: { code: "backend_unavailable" } };
+    }
+    return { results, elapsedMs };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object") return false;
+  const maybe = err;
+  return maybe.name === "AbortError" || maybe.message === "This operation was aborted" || maybe.message === "The operation was aborted";
+}
+function createFaithfulnessCounters() {
+  return { entailed: 0, contradicted: 0, unsupported: 0, unchecked: 0, skippedNoSpan: 0 };
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "to",
+  "of",
+  "in",
+  "on",
+  "at",
+  "for",
+  "with",
+  "from",
+  "by",
+  "as",
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "i",
+  "you",
+  "he",
+  "she",
+  "we",
+  "they",
+  "my",
+  "your",
+  "his",
+  "her",
+  "our",
+  "their",
+  "has",
+  "have",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "not",
+  "no",
+  "s",
+  "very",
+  "really",
+  "just",
+  "so",
+  "than",
+  "then",
+  "there",
+  "here",
+  "about",
+  "into",
+  "over",
+  "under"
+]);
+function crudeStem(word) {
+  if (word.length > 5 && word.endsWith("ing")) return word.slice(0, -3);
+  if (word.length > 4 && word.endsWith("ed")) return word.slice(0, -2);
+  if (word.length > 3 && word.endsWith("s") && !word.endsWith("ss")) return word.slice(0, -1);
+  return word;
+}
+function tokenize(text) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const raw of text.toLowerCase().split(/[^a-z0-9]+/)) {
+    if (raw.length <= 1) continue;
+    if (STOPWORDS.has(raw)) continue;
+    tokens.add(crudeStem(raw));
+  }
+  return tokens;
+}
+function overlapCoefficient(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+  for (const t of small) if (large.has(t)) intersection++;
+  return intersection / small.size;
+}
+var LOCATE_QUOTE_MIN_OVERLAP = 0.3;
+function extractContextWindow(sourceText, quote, contextChars) {
+  if (!sourceText || !quote || !(contextChars > 0)) return void 0;
+  const idx = sourceText.indexOf(quote);
+  if (idx < 0) return void 0;
+  const quoteEnd = idx + quote.length;
+  const center = Math.floor((idx + quoteEnd) / 2);
+  const half = Math.floor(contextChars / 2);
+  let start = Math.max(0, center - half);
+  const end = Math.min(sourceText.length, start + contextChars);
+  start = Math.max(0, end - contextChars);
+  const window = sourceText.slice(start, end).trim();
+  return window.length > 0 ? window : void 0;
+}
+function locateFactQuote(factText, sourceText, maxQuoteChars = 600) {
+  if (!factText || !sourceText) return void 0;
+  const factTokens = tokenize(factText);
+  if (factTokens.size === 0) return void 0;
+  const candidates = [];
+  for (const sentence of sourceText.split(/(?<=[.!?])\s+|\n+/)) {
+    const s = sentence.trim();
+    if (s.length > 0) candidates.push(s);
+  }
+  if (candidates.length === 0) return void 0;
+  let best = null;
+  for (const candidate of candidates) {
+    const score = overlapCoefficient(factTokens, tokenize(candidate));
+    if (!best || score > best.score) best = { quote: candidate, score };
+  }
+  if (!best || best.score < LOCATE_QUOTE_MIN_OVERLAP) return void 0;
+  return best.quote.length > maxQuoteChars ? best.quote.slice(0, maxQuoteChars) : best.quote;
+}
+async function runFaithfulnessGateBatch(facts, mode, config, localLlm, fallbackLlm, counters, sourceText = "") {
+  const inputs = [];
+  for (let fi = 0; fi < facts.length; fi++) {
+    const f = facts[fi];
+    if (!f || typeof f.content !== "string" || !f.content.trim()) continue;
+    const sources = Array.isArray(f.sources) ? f.sources : [];
+    const sourceQuotes = sources.map((s) => s && typeof s.quote === "string" ? s.quote.trim() : "").filter((q) => q.length > 0);
+    const usingFallbackLocator = sourceQuotes.length === 0;
+    const quote = sourceQuotes.length > 0 ? sourceQuotes.join("\n") : locateFactQuote(f.content, sourceText);
+    if (!quote) continue;
+    const fallbackContext = usingFallbackLocator ? extractContextWindow(
+      sourceText,
+      quote,
+      config.extractionFaithfulnessContextChars
+    ) : void 0;
+    inputs.push({
+      factIndex: fi,
+      input: {
+        factText: f.content,
+        quote,
+        ...fallbackContext ? { context: fallbackContext } : {}
+      }
+    });
+  }
+  const resultsByFactIndex = /* @__PURE__ */ new Map();
+  if (inputs.length === 0) return resultsByFactIndex;
+  try {
+    const batch = await checkFaithfulnessBatch(
+      inputs.map((x) => x.input),
+      config,
+      localLlm,
+      fallbackLlm
+    );
+    for (let j = 0; j < inputs.length; j++) {
+      const entry = inputs[j];
+      if (entry) resultsByFactIndex.set(entry.factIndex, batch.results[j]);
+    }
+    log.info(
+      `extraction-faithfulness[${mode}]: ${inputs.length} facts checked, ${batch.elapsedMs}ms`
+    );
+  } catch (err) {
+    log.warn(
+      `extraction-faithfulness: pipeline error, tagging ${inputs.length} checkable facts as unchecked (fail-open): ${err instanceof Error ? err.message : String(err)}`
+    );
+    for (const { factIndex } of inputs) {
+      resultsByFactIndex.set(factIndex, { ok: false, error: { code: "backend_unavailable" } });
+    }
+  }
+  return resultsByFactIndex;
+}
+function applyFaithfulnessVerdict(resultsByFactIndex, factLoopIndex, mode, factContent, counters) {
+  if (!resultsByFactIndex) {
+    return { faithfulness: void 0, enforceStatus: void 0 };
+  }
+  const result = resultsByFactIndex.get(factLoopIndex);
+  if (!result) {
+    counters.skippedNoSpan++;
+    return {
+      faithfulness: { verdict: "skipped_no_span", at: (/* @__PURE__ */ new Date()).toISOString() },
+      enforceStatus: void 0
+    };
+  }
+  if (result.ok) {
+    if (result.verdict === "entailed") counters.entailed++;
+    else if (result.verdict === "contradicted") counters.contradicted++;
+    else if (result.verdict === "unsupported") counters.unsupported++;
+    const fm = {
+      verdict: result.verdict,
+      ...result.model ? { model: result.model } : {},
+      ...result.rationale ? { rationale: result.rationale } : {},
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let enforceStatus;
+    if (mode === "enforce" && (result.verdict === "unsupported" || result.verdict === "contradicted")) {
+      enforceStatus = "pending_review";
+      log.info(
+        `extraction-faithfulness[enforce]: routing "${factContent.slice(0, 60)}\u2026" to pending_review (verdict=${result.verdict})`
+      );
+    }
+    return { faithfulness: fm, enforceStatus };
+  }
+  counters.unchecked++;
+  return {
+    faithfulness: { verdict: "unchecked", at: (/* @__PURE__ */ new Date()).toISOString() },
+    enforceStatus: void 0
+  };
+}
+var FAITHFULNESS_KEY_ORDER = ["verdict", "model", "rationale", "at"];
+function serializeFaithfulnessFields(fm, lines) {
+  if (!fm.faithfulness) return;
+  const fm2 = fm.faithfulness;
+  const canonical = {};
+  for (const key of FAITHFULNESS_KEY_ORDER) {
+    const val = fm2[key];
+    if (val !== void 0 && val !== null && val !== "") {
+      canonical[key] = val;
+    }
+  }
+  if (!canonical.verdict) return;
+  lines.push(`faithfulness: ${JSON.stringify(canonical)}`);
+}
+function parseFaithfulnessField(raw) {
+  if (!raw || typeof raw !== "string" || raw.trim().length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    const obj = parsed;
+    const verdictRaw = typeof obj.verdict === "string" ? obj.verdict : void 0;
+    if (!verdictRaw) return void 0;
+    const validVerdicts = /* @__PURE__ */ new Set([
+      "entailed",
+      "contradicted",
+      "unsupported",
+      "unchecked",
+      "skipped_no_span"
+    ]);
+    if (!validVerdicts.has(verdictRaw)) return void 0;
+    const result = {
+      verdict: verdictRaw
+    };
+    if (typeof obj.model === "string" && obj.model.length > 0) {
+      result.model = obj.model;
+    }
+    if (typeof obj.rationale === "string" && obj.rationale.length > 0) {
+      result.rationale = obj.rationale.slice(0, 500);
+    }
+    if (typeof obj.at === "string" && obj.at.length > 0) {
+      result.at = obj.at;
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  FAITHFULNESS_PROMPT_HASH,
+  parseFaithfulnessResponse,
+  checkFaithfulnessBatch,
+  createFaithfulnessCounters,
+  extractContextWindow,
+  locateFactQuote,
+  runFaithfulnessGateBatch,
+  applyFaithfulnessVerdict,
+  serializeFaithfulnessFields,
+  parseFaithfulnessField
+};
+//# sourceMappingURL=chunk-5AT62NQH.js.map