@remnic/core 9.69.56 → 9.69.57

package/dist/chunk-FF6N7BXC.js

@@ -0,0 +1,389 @@
+import {
+  coerceBool,
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+import {
+  collapseWhitespace
+} from "./chunk-PJKTFXE2.js";
+import {
+  isSafeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  readEnvVar
+} from "./chunk-P2QRMMVQ.js";
+
+// src/provenance.ts
+import { z } from "zod";
+var PROVENANCE_SOURCE_KEY_ORDER = [
+  "sessionKey",
+  "turnId",
+  "observedAt",
+  "quote",
+  "charStart",
+  "charEnd"
+];
+function canonicalProvenanceSource(src) {
+  const out = {};
+  for (const key of PROVENANCE_SOURCE_KEY_ORDER) {
+    const value = src[key];
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function serializeProvenanceFields(fm, lines) {
+  let hasValidSources = false;
+  if (fm.sources && fm.sources.length > 0) {
+    const canonical = [];
+    for (const src of fm.sources) {
+      const result = ProvenanceSourceSchema.safeParse(src);
+      if (result.success) canonical.push(canonicalProvenanceSource(result.data));
+    }
+    if (canonical.length > 0) {
+      lines.push(`sources: ${JSON.stringify(canonical)}`);
+      hasValidSources = true;
+    }
+  }
+  const tag = (fm.provenance === "verified" || fm.provenance === "unverified") && !hasValidSources ? "none" : fm.provenance;
+  if (tag) {
+    lines.push(`provenance: ${tag}`);
+  }
+}
+function parseProvenanceTag(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  if (trimmed === "verified" || trimmed === "unverified" || trimmed === "none") {
+    return trimmed;
+  }
+  return void 0;
+}
+function reconcileProvenanceRead(tag, sources) {
+  if ((tag === "verified" || tag === "unverified") && (!sources || sources.length === 0)) {
+    return "none";
+  }
+  return tag;
+}
+function isStrictIsoTimestamp(s) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.exec(s);
+  if (!m) return false;
+  const y = Number(m[1]), mo = Number(m[2]), da = Number(m[3]);
+  const h = Number(m[4]), mi = Number(m[5]), se = Number(m[6]);
+  const d = new Date(Date.UTC(y, mo - 1, da, h, mi, se));
+  return !Number.isNaN(Date.parse(s)) && d.getUTCFullYear() === y && d.getUTCMonth() === mo - 1 && d.getUTCDate() === da && d.getUTCHours() === h && d.getUTCMinutes() === mi && d.getUTCSeconds() === se;
+}
+function toStrictIsoTimestamp(ts) {
+  if (typeof ts !== "string" || ts.length === 0) return void 0;
+  const value = ts.trim();
+  if (value.length === 0) return void 0;
+  if (isStrictIsoTimestamp(value)) return value;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return void 0;
+  const yearLedPrefix = parseYearLedDatePrefix(value);
+  const yearLedAgrees = yearLedAgreesWithDateParse(parsed, value, yearLedPrefix);
+  const validYearLed = yearLedPrefix !== null && yearLedAgrees;
+  if (!/[-:T]/.test(value) && !validYearLed) {
+    return void 0;
+  }
+  if (/^\d{4}\D/.test(value) && !validYearLed) {
+    return void 0;
+  }
+  const mdy = /^(\d{1,2})\D(\d{1,2})\D(\d{4})/.exec(value);
+  if (mdy) {
+    const a = Number(mdy[1]), b = Number(mdy[2]), yr = Number(mdy[3]);
+    if (!isValidCalendarDate(yr, a, b) && !isValidCalendarDate(yr, b, a)) {
+      return void 0;
+    }
+  }
+  const iso = new Date(parsed).toISOString();
+  return isStrictIsoTimestamp(iso) ? iso : void 0;
+}
+function isValidCalendarDate(y, mo, da) {
+  if (mo < 1 || mo > 12 || da < 1) return false;
+  const leap = y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 29 : 28;
+  const daysInMonth = [31, leap, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return da <= daysInMonth[mo - 1];
+}
+var MONTH_NAMES = {
+  jan: 1,
+  january: 1,
+  feb: 2,
+  february: 2,
+  mar: 3,
+  march: 3,
+  apr: 4,
+  april: 4,
+  may: 5,
+  jun: 6,
+  june: 6,
+  jul: 7,
+  july: 7,
+  aug: 8,
+  august: 8,
+  sep: 9,
+  september: 9,
+  sept: 9,
+  oct: 10,
+  october: 10,
+  nov: 11,
+  november: 11,
+  dec: 12,
+  december: 12
+};
+function parseYearLedDatePrefix(s) {
+  const m = /^(\d{4})[^0-9A-Za-z]+(\d{1,2}|[A-Za-z]{3,})[^0-9A-Za-z:]+(\d{1,2})(?![\d:])/.exec(s);
+  if (!m) return null;
+  const y = Number(m[1]);
+  const da = Number(m[3]);
+  const mo = /^\d+$/.test(m[2]) ? Number(m[2]) : MONTH_NAMES[m[2].toLowerCase()] ?? -1;
+  if (!isValidCalendarDate(y, mo, da)) return null;
+  return { y, mo, da };
+}
+var NAMED_ZONE_OFFSETS_MS = {
+  PST: -8 * 60,
+  PDT: -7 * 60,
+  MST: -7 * 60,
+  MDT: -6 * 60,
+  CST: -6 * 60,
+  CDT: -5 * 60,
+  EST: -5 * 60,
+  EDT: -4 * 60
+};
+function explicitOffsetMs(value) {
+  const nz = /\b([A-Z]{3,4})\s*$/.exec(value);
+  if (nz && NAMED_ZONE_OFFSETS_MS[nz[1]] !== void 0) {
+    return NAMED_ZONE_OFFSETS_MS[nz[1]] * 6e4;
+  }
+  const tryOff = (sign, hh, mm) => {
+    if (hh > 14 || mm > 59) return null;
+    return (sign === "-" ? -1 : 1) * (hh * 60 + mm) * 6e4;
+  };
+  let m;
+  if ((m = /\b(?:GMT|UTC)\b\s*([+-])?(\d{1,2}):(\d{2})/i.exec(value)) || (m = /\b(?:GMT|UTC)\b\s*([+-])?(\d{2})(\d{2})/i.exec(value))) {
+    const r = tryOff(m[1], Number(m[2]), Number(m[3]));
+    if (r !== null) return r;
+  }
+  if (m = /\b(?:GMT|UTC)\b\s*([+-])?(\d{1,2})\b/i.exec(value)) {
+    const r = tryOff(m[1], Number(m[2]), 0);
+    if (r !== null) return r;
+  }
+  if (/\b(?:GMT|UTC)\b/i.test(value)) return 0;
+  if ((m = /(?:\s|(?<=:\d{2}))([+-])(\d{1,2}):(\d{2})\s*$/.exec(value)) || (m = /(?:\s|(?<=:\d{2}))([+-])(\d{2})(\d{2})\s*$/.exec(value)) || (m = /(?:\s|(?<=:\d{2}))([+-])(\d{1,2})\s*$/.exec(value))) {
+    const r = tryOff(m[1], Number(m[2]), m[3] ? Number(m[3]) : 0);
+    if (r !== null) return r;
+  }
+  return null;
+}
+function yearLedAgreesWithDateParse(parsed, value, prefix) {
+  if (prefix === null) return false;
+  const off = explicitOffsetMs(value);
+  if (off !== null) {
+    const shifted = new Date(parsed + off);
+    return shifted.getUTCFullYear() === prefix.y && shifted.getUTCMonth() + 1 === prefix.mo && shifted.getUTCDate() === prefix.da;
+  }
+  const pd = new Date(parsed);
+  const localMatch = pd.getFullYear() === prefix.y && pd.getMonth() + 1 === prefix.mo && pd.getDate() === prefix.da;
+  const utcMatch = pd.getUTCFullYear() === prefix.y && pd.getUTCMonth() + 1 === prefix.mo && pd.getUTCDate() === prefix.da;
+  return localMatch || utcMatch;
+}
+var ProvenanceSourceSchema = z.object({
+  sessionKey: z.string().min(1),
+  observedAt: z.string().min(1).refine(isStrictIsoTimestamp, "must be a valid ISO 8601 timestamp (YYYY-MM-DDTHH:MM:SS[Z|\xB1HH:MM], no calendar overflow)"),
+  quote: z.string().min(1),
+  turnId: z.string().min(1).optional(),
+  charStart: z.number().finite().nonnegative().int().optional(),
+  charEnd: z.number().finite().nonnegative().int().optional()
+}).refine(
+  (src) => src.charStart === void 0 || src.charEnd === void 0 || src.charEnd >= src.charStart,
+  { message: "charEnd must be >= charStart (half-open interval, rule 35)" }
+);
+function parseProvenanceSources(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(parsed)) return void 0;
+  const sources = [];
+  for (const entry of parsed) {
+    const result = ProvenanceSourceSchema.safeParse(entry);
+    if (result.success) sources.push(result.data);
+  }
+  return sources.length > 0 ? sources : void 0;
+}
+function parseProvenanceConfig(raw) {
+  if (raw !== void 0 && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
+    throw new Error(
+      `provenance must be an object (got ${JSON.stringify(raw)}). Use provenance: { enabled: false } to opt out; omit the key to use the default-on behavior (issue #1575).`
+    );
+  }
+  const rawProvenance = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  return {
+    enabled: (() => {
+      if (rawProvenance.enabled === void 0) {
+        const envEnabled = readEnvVar("REMNIC_PROVENANCE_ENABLED") ?? readEnvVar("ENGRAM_PROVENANCE_ENABLED");
+        if (envEnabled !== void 0) {
+          const coerced2 = coerceBool(envEnabled);
+          if (coerced2 === void 0) {
+            throw new Error(
+              `REMNIC_PROVENANCE_ENABLED must be a boolean-like value (true/false/1/0/yes/no/on/off); got ${JSON.stringify(envEnabled)}`
+            );
+          }
+          return coerced2;
+        }
+        return true;
+      }
+      const coerced = coerceBool(rawProvenance.enabled);
+      if (coerced === void 0) {
+        throw new Error(
+          `provenance.enabled must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(rawProvenance.enabled)}). Omit the key to use the default-on behavior (issue #1575).`
+        );
+      }
+      return coerced;
+    })(),
+    maxQuoteChars: (() => {
+      if (rawProvenance.maxQuoteChars === void 0) return 300;
+      const rawCap = coerceNumber(rawProvenance.maxQuoteChars);
+      if (rawCap === void 0 || !Number.isFinite(rawCap) || rawCap < 1 || !Number.isInteger(rawCap)) {
+        throw new Error(
+          `provenance.maxQuoteChars must be a positive integer >= 1 (got ${JSON.stringify(rawProvenance.maxQuoteChars)}).`
+        );
+      }
+      return rawCap;
+    })(),
+    requireSpans: (() => {
+      if (rawProvenance.requireSpans === void 0) return false;
+      const coerced = coerceBool(rawProvenance.requireSpans);
+      if (coerced === void 0) {
+        throw new Error(
+          `provenance.requireSpans must be a boolean or one of "true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off" (got ${JSON.stringify(rawProvenance.requireSpans)}).`
+        );
+      }
+      return coerced;
+    })()
+  };
+}
+function capQuote(quote, maxChars) {
+  const glyphs = Array.from(quote);
+  if (glyphs.length <= maxChars) return quote;
+  let cut = maxChars;
+  while (cut > 0 && !/\s/.test(glyphs[cut - 1])) cut--;
+  if (cut === 0) cut = maxChars;
+  return glyphs.slice(0, cut).join("").trimEnd() + "\u2026";
+}
+function casefold(s) {
+  return s.toLowerCase();
+}
+function locateQuoteOffsets(quote, text) {
+  const exactIdx = text.indexOf(quote);
+  if (exactIdx >= 0) {
+    return { matched: true, offsets: { charStart: exactIdx, charEnd: exactIdx + quote.length } };
+  }
+  const normQuote = collapseWhitespace(casefold(quote));
+  if (normQuote.length === 0) return { matched: false };
+  const normText = collapseWhitespace(casefold(text));
+  const normIdx = normText.indexOf(normQuote);
+  if (normIdx < 0) return { matched: false };
+  const normQuoteLen = normQuote.length;
+  let origIdx = 0;
+  while (origIdx < text.length && /\s/.test(text[origIdx])) origIdx++;
+  let normPos = 0;
+  let origStart = -1;
+  let origEnd = -1;
+  let prevWasWs = true;
+  while (origIdx < text.length && origEnd < 0) {
+    const ch = text[origIdx];
+    if (/\s/.test(ch)) {
+      if (!prevWasWs) {
+        if (normPos === normIdx) origStart = origIdx;
+        normPos++;
+        prevWasWs = true;
+      }
+      origIdx++;
+      continue;
+    }
+    if (normPos === normIdx && origStart < 0) {
+      origStart = origIdx;
+    }
+    normPos++;
+    prevWasWs = false;
+    origIdx++;
+    if (normPos >= normIdx + normQuoteLen) {
+      origEnd = origIdx;
+    }
+  }
+  if (origStart >= 0 && origEnd >= 0) {
+    return { matched: true, offsets: { charStart: origStart, charEnd: origEnd } };
+  }
+  return { matched: true };
+}
+function stripLeadingRolePrefix(quote) {
+  return quote.replace(/^\s*\[(?:context\s+)?(?:user|assistant)\]\s+/i, "");
+}
+function buildFactProvenance(factQuote, turns, config) {
+  if (!config.enabled) return { provenance: "none" };
+  const rawQuote = typeof factQuote === "string" ? factQuote.trim() : "";
+  const noneResult = () => config.requireSpans === true ? { provenance: "none", requireSpansPending: true } : { provenance: "none" };
+  if (rawQuote.length === 0) return noneResult();
+  const strippedQuote = stripLeadingRolePrefix(rawQuote);
+  const useRawQuote = rawQuote === strippedQuote || turns.some(
+    (t) => typeof t?.content === "string" && t.content.length > 0 && locateQuoteOffsets(rawQuote, t.content).matched
+  );
+  const quote = useRawQuote ? rawQuote : strippedQuote;
+  if (quote.length === 0) return noneResult();
+  if (!isSafeMemoryContent(quote)) return noneResult();
+  try {
+    const sources = [];
+    let locatedTurn;
+    for (const turn of turns) {
+      if (!turn || typeof turn.content !== "string" || turn.content.length === 0) continue;
+      const located = locateQuoteOffsets(quote, turn.content);
+      if (!located.matched) continue;
+      if (!locatedTurn) locatedTurn = turn;
+      const observedAt = toStrictIsoTimestamp(turn.timestamp);
+      if (!observedAt) continue;
+      sources.push({
+        sessionKey: turn.sessionKey ?? turn.logicalSessionKey ?? "unknown",
+        ...turn.turnId ? { turnId: turn.turnId } : {},
+        observedAt,
+        quote: capQuote(quote, config.maxQuoteChars),
+        ...located.offsets ? { charStart: located.offsets.charStart, charEnd: located.offsets.charEnd } : {}
+      });
+    }
+    if (sources.length > 0) {
+      return { sources, provenance: "verified" };
+    }
+    const fallbackTurn = locatedTurn ?? turns[turns.length - 1];
+    const fallbackSessionKey = fallbackTurn ? fallbackTurn.sessionKey ?? fallbackTurn.logicalSessionKey ?? "unknown" : "unknown";
+    const fallbackObservedAt = fallbackTurn ? toStrictIsoTimestamp(fallbackTurn.timestamp) ?? (/* @__PURE__ */ new Date(0)).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+    const requireSpansPending = config.requireSpans === true && locatedTurn === void 0;
+    return {
+      sources: [
+        {
+          sessionKey: fallbackSessionKey,
+          observedAt: fallbackObservedAt,
+          quote: capQuote(quote, config.maxQuoteChars)
+        }
+      ],
+      provenance: "unverified",
+      ...requireSpansPending ? { requireSpansPending: true } : {}
+    };
+  } catch {
+    return { provenance: "none" };
+  }
+}
+
+export {
+  serializeProvenanceFields,
+  parseProvenanceTag,
+  reconcileProvenanceRead,
+  parseProvenanceSources,
+  parseProvenanceConfig,
+  locateQuoteOffsets,
+  stripLeadingRolePrefix,
+  buildFactProvenance
+};
+//# sourceMappingURL=chunk-FF6N7BXC.js.map

package/dist/chunk-FNQEXI3D.js

@@ -0,0 +1,22 @@
+// src/types.ts
+var RECALL_DISCLOSURE_LEVELS = ["chunk", "section", "raw"];
+var DEFAULT_RECALL_DISCLOSURE = "chunk";
+function isRecallDisclosure(value) {
+  return typeof value === "string" && RECALL_DISCLOSURE_LEVELS.includes(value);
+}
+function confidenceTier(score) {
+  if (score >= 0.95) return "explicit";
+  if (score >= 0.7) return "implied";
+  if (score >= 0.4) return "inferred";
+  return "speculative";
+}
+var SPECULATIVE_TTL_DAYS = 30;
+
+export {
+  RECALL_DISCLOSURE_LEVELS,
+  DEFAULT_RECALL_DISCLOSURE,
+  isRecallDisclosure,
+  confidenceTier,
+  SPECULATIVE_TTL_DAYS
+};
+//# sourceMappingURL=chunk-FNQEXI3D.js.map