@actuarial-ts/core 0.10.0 → 0.12.0

package/src/diagnosticAggregation.ts

@@ -47,22 +47,49 @@ export function auditedDiagnosticContribution(
   sources: readonly DiagnosticSourceLocation[] = [],
   deduplicated = 0,
 ): DiagnosticMeasureContribution {
-  const base = {
+  return ownedDiagnosticContribution(
     sourceId,
-    sources: Object.freeze([...sources]),
+    value,
+    missing,
+    Object.freeze([...sources]),
     deduplicated,
-  } as const;
+  );
+}
+
+/**
+ * `auditedDiagnosticContribution` over a citation list the caller already owns
+ * and froze. Preparation cites one frozen list per source row for every measure
+ * of that row instead of copying it per contribution. Field order matches the
+ * public constructor exactly.
+ */
+export function ownedDiagnosticContribution(
+  sourceId: string,
+  value: number | null | undefined,
+  missing: DiagnosticMissingPolicy,
+  sources: readonly DiagnosticSourceLocation[],
+  deduplicated = 0,
+): DiagnosticMeasureContribution {
   if (value === null || value === undefined)
     return missing === "zero"
       ? Object.freeze({
-          ...base,
+          sourceId,
+          sources,
+          deduplicated,
           status: "imputed-zero" as const,
           value: 0 as const,
         })
-      : Object.freeze({ ...base, status: "missing" as const, value: null });
+      : Object.freeze({
+          sourceId,
+          sources,
+          deduplicated,
+          status: "missing" as const,
+          value: null,
+        });
   if (!Number.isFinite(value))
     return Object.freeze({
-      ...base,
+      sourceId,
+      sources,
+      deduplicated,
       status: "non-finite" as const,
       value: null,
       nonFiniteKind: Number.isNaN(value)
@@ -72,12 +99,105 @@ export function auditedDiagnosticContribution(
           : ("negative-infinity" as const),
     });
   return Object.freeze({
-    ...base,
+    sourceId,
+    sources,
+    deduplicated,
     status: "observed" as const,
     value: Object.is(value, -0) ? 0 : value,
   });
 }
 
+/**
+ * Private, invocation-scoped sharing of finalized statistics. Two frozen
+ * `finalizeDiagnosticContributions` results are interchangeable exactly when
+ * every field is `Object.is`-equal: each finite number has one shortest
+ * round-trip text, signed zero and null stay distinct, and non-finite values
+ * are declined. The pool is bounded and released with the preparation.
+ */
+export function createDiagnosticStatsInterner(maxEntries = 100_000): {
+  intern(stats: DiagnosticMeasureStats): DiagnosticMeasureStats;
+  /** Looks the eight fields up first and allocates the frozen record only when absent. */
+  internFields(
+    value: number | null,
+    sum: number | null,
+    observed: number,
+    missing: number,
+    nonFinite: number,
+    imputedZero: number,
+    deduplicated: number,
+    structural: number,
+  ): DiagnosticMeasureStats;
+} {
+  const pool = new Map<string, DiagnosticMeasureStats>();
+  const text = (value: number | null): string =>
+    value === null ? "null" : Object.is(value, -0) ? "-0" : String(value);
+  const finite = (value: number | null): boolean =>
+    value === null || Number.isFinite(value);
+  const keyOf = (
+    value: number | null,
+    sum: number | null,
+    observed: number,
+    missing: number,
+    nonFinite: number,
+    imputedZero: number,
+    deduplicated: number,
+    structural: number,
+  ): string | undefined => {
+    if (
+      !finite(value) ||
+      !finite(sum) ||
+      !Number.isFinite(observed) ||
+      !Number.isFinite(missing) ||
+      !Number.isFinite(nonFinite) ||
+      !Number.isFinite(imputedZero) ||
+      !Number.isFinite(deduplicated) ||
+      !Number.isFinite(structural)
+    )
+      return undefined;
+    // A single clean observation is the overwhelmingly common shape; its key
+    // needs only the value. The prefix cannot occur in the eight-field form.
+    return sum === value &&
+      observed === 1 &&
+      missing === 0 &&
+      nonFinite === 0 &&
+      imputedZero === 0 &&
+      deduplicated === 0 &&
+      structural === 0
+      ? `
${text(value)}`
+      : `${text(value)}|${text(sum)}|${text(observed)}|${text(missing)}|${text(nonFinite)}|${text(imputedZero)}|${text(deduplicated)}|${text(structural)}`;
+  };
+  return {
+    intern(stats) {
+      if (!Object.isFrozen(stats)) return stats;
+      const key = keyOf(
+        stats.value, stats.sum, stats.observed, stats.missing,
+        stats.nonFinite, stats.imputedZero, stats.deduplicated, stats.structural,
+      );
+      if (key === undefined) return stats;
+      const existing = pool.get(key);
+      if (existing !== undefined) return existing;
+      if (pool.size < maxEntries) pool.set(key, stats);
+      return stats;
+    },
+    internFields(value, sum, observed, missing, nonFinite, imputedZero, deduplicated, structural) {
+      const key = keyOf(value, sum, observed, missing, nonFinite, imputedZero, deduplicated, structural);
+      const existing = key === undefined ? undefined : pool.get(key);
+      if (existing !== undefined) return existing;
+      const stats: DiagnosticMeasureStats = Object.freeze({
+        value, sum, observed, missing, nonFinite, imputedZero, deduplicated, structural,
+      });
+      if (key !== undefined && pool.size < maxEntries) pool.set(key, stats);
+      return stats;
+    },
+  };
+}
+
+/** Exactly `neumaier([value])` without the array: one finite value sums to itself, signed zero normalized. */
+function singleValueSum(value: number): number | null {
+  if (!Number.isFinite(value)) return null;
+  return Object.is(value, -0) ? 0 : value;
+}
+
 function neumaier(values: readonly number[]): number | null {
   let sum = 0;
   let correction = 0;
@@ -107,7 +227,7 @@ export function finalizeDiagnosticContributions(
     const imputedZero = item.status === "imputed-zero" ? 1 : 0;
     const missing = item.status === "missing" ? 1 : imputedZero;
     const nonFinite = item.status === "non-finite" ? 1 : 0;
-    const finiteSum = item.status === "observed" ? neumaier([item.value]) : 0;
+    const finiteSum = item.status === "observed" ? singleValueSum(item.value) : 0;
     const sum = nonFinite > 0 || blockers.length > 0 ? null : finiteSum;
     return Object.freeze({
       value: sum === null || (missingPolicy === "unknown" && missing > 0) ? null : sum,
@@ -115,7 +235,51 @@ export function finalizeDiagnosticContributions(
       deduplicated: 0 + item.deduplicated, structural: blockers.length,
     });
   }
-  const ordered = [...contributions].sort(compareDiagnosticContributions);
+  return finalizeManyContributions(contributions, missingPolicy, blockers);
+}
+
+/**
+ * `finalizeDiagnosticContributions` whose result is shared through `pool`:
+ * for the single-leaf case the eight fields are known before any allocation,
+ * so an equal frozen record already in the pool is returned without creating
+ * a new one. Preparation uses this for every measure of every cell.
+ */
+export function finalizeDiagnosticContributionsInterned(
+  contributions: readonly DiagnosticMeasureContribution[],
+  missingPolicy: DiagnosticMissingPolicy,
+  blockers: readonly DiagnosticStructuralBlocker[],
+  pool: ReturnType<typeof createDiagnosticStatsInterner>,
+): DiagnosticMeasureStats {
+  if (contributions.length === 1) {
+    const item = contributions[0]!;
+    const observed = item.status === "observed" ? 1 : 0;
+    const imputedZero = item.status === "imputed-zero" ? 1 : 0;
+    const missing = item.status === "missing" ? 1 : imputedZero;
+    const nonFinite = item.status === "non-finite" ? 1 : 0;
+    const finiteSum = item.status === "observed" ? singleValueSum(item.value) : 0;
+    const sum = nonFinite > 0 || blockers.length > 0 ? null : finiteSum;
+    const value = sum === null || (missingPolicy === "unknown" && missing > 0) ? null : sum;
+    const deduplicated = 0 + item.deduplicated;
+    const structural = blockers.length;
+    return pool.internFields(
+      value, sum, observed, missing, nonFinite, imputedZero, deduplicated, structural,
+    );
+  }
+  return pool.intern(finalizeManyContributions(contributions, missingPolicy, blockers));
+}
+
+function finalizeManyContributions(
+  contributions: readonly DiagnosticMeasureContribution[],
+  missingPolicy: DiagnosticMissingPolicy,
+  blockers: readonly DiagnosticStructuralBlocker[],
+): DiagnosticMeasureStats {
+  // Contributions gathered from cells in prepared order are usually already in
+  // contract order; copying and sorting is needed only when they are not.
+  let sorted = true;
+  for (let index = 1; index < contributions.length && sorted; index++)
+    if (compareDiagnosticContributions(contributions[index - 1]!, contributions[index]!) > 0)
+      sorted = false;
+  const ordered = sorted ? contributions : [...contributions].sort(compareDiagnosticContributions);
   const observed = ordered.filter((item) => item.status === "observed");
   const imputed = ordered.filter((item) => item.status === "imputed-zero");
   const missing =

package/src/diagnosticAuditText.ts

@@ -0,0 +1,187 @@
+import { canonicalJson } from "./canonical.js";
+import type { DiagnosticSourceLocation } from "./diagnosticDefinitions.js";
+import type { DiagnosticAuditedNumericValue } from "./diagnosticExposure.js";
+import type { DiagnosticInputAuditRecord } from "./diagnosticPreparation.js";
+
+/**
+ * Canonical JSON text of an input audit snapshot, byte-identical to
+ * `canonicalJson(record)`. Snapshots have three fixed shapes whose sorted key
+ * order is known, so each is rendered directly with the same string escaping
+ * and number rules. Any snapshot that does not match its shape exactly (an
+ * unexpected key, prototype or value type) defers to `canonicalJson`, so the
+ * text and every error stay those of the generic serializer.
+ */
+export function auditRecordCanonicalJson(
+  record: DiagnosticInputAuditRecord["record"],
+): string {
+  return snapshotText(record) ?? canonicalJson(record);
+}
+
+type Snapshot = Record<string, unknown>;
+
+/**
+ * `JSON.stringify` for a string. Printable ASCII other than `"` and `\` is
+ * never escaped, so such a string is quoted directly; everything else (control
+ * characters, `"`, `\`, and any non-ASCII, including lone surrogates) goes to
+ * the native serializer, which owns the escape spelling.
+ */
+const quote = (value: string): string => {
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 0x20 || code > 0x7e || code === 0x22 || code === 0x5c)
+      return JSON.stringify(value);
+  }
+  return `"${value}"`;
+};
+const number = (value: number): string | undefined =>
+  Number.isFinite(value) ? (Object.is(value, -0) ? "0" : String(value)) : undefined;
+const hasOwn = (value: object, key: string): boolean =>
+  Object.prototype.hasOwnProperty.call(value, key);
+const plain = (value: unknown): value is Snapshot =>
+  value !== null &&
+  typeof value === "object" &&
+  !Array.isArray(value) &&
+  Object.getPrototypeOf(value) === Object.prototype;
+
+function stringOrNull(value: unknown): string | undefined {
+  return value === null ? "null" : typeof value === "string" ? quote(value) : undefined;
+}
+
+/** Source keys in canonical order: artifactId, sourceCell, sourceFile, sourceRow, sourceSheet. */
+function sourceText(value: unknown): string | undefined {
+  if (value === null) return "null";
+  if (!plain(value)) return undefined;
+  const source = value as Partial<DiagnosticSourceLocation>;
+  if (typeof source.artifactId !== "string") return undefined;
+  let text = `{"artifactId":${quote(source.artifactId)}`;
+  let count = 1;
+  for (const field of ["sourceCell", "sourceFile"] as const)
+    if (hasOwn(source, field)) {
+      const item = source[field];
+      if (typeof item !== "string") return undefined;
+      text += `,"${field}":${quote(item)}`;
+      count++;
+    }
+  if (hasOwn(source, "sourceRow")) {
+    const item = source.sourceRow;
+    const rendered = typeof item === "number" ? number(item) : undefined;
+    if (rendered === undefined) return undefined;
+    text += `,"sourceRow":${rendered}`;
+    count++;
+  }
+  if (hasOwn(source, "sourceSheet")) {
+    const item = source.sourceSheet;
+    if (typeof item !== "string") return undefined;
+    text += `,"sourceSheet":${quote(item)}`;
+    count++;
+  }
+  if (Object.keys(source).length !== count) return undefined;
+  return `${text}}`;
+}
+
+/**
+ * Audited numeric records are immutable SDK-owned values that preparation
+ * shares across rows, so each distinct record's text is built once. Only a
+ * frozen record is remembered, and its text depends on nothing else.
+ */
+const auditedTexts = new WeakMap<object, string>();
+
+function auditedText(value: unknown): string | undefined {
+  if (!plain(value)) return undefined;
+  const cached = auditedTexts.get(value);
+  if (cached !== undefined) return cached;
+  const text = auditedTextOf(value);
+  if (text !== undefined && Object.isFrozen(value)) auditedTexts.set(value, text);
+  return text;
+}
+
+function auditedTextOf(value: Snapshot): string | undefined {
+  const audited = value as Partial<DiagnosticAuditedNumericValue>;
+  const keys = Object.keys(audited).length;
+  if (audited.status === "observed") {
+    const rendered = typeof audited.value === "number" ? number(audited.value) : undefined;
+    return keys === 2 && rendered !== undefined
+      ? `{"status":"observed","value":${rendered}}`
+      : undefined;
+  }
+  if (audited.status === "missing")
+    return keys === 2 && audited.value === null ? '{"status":"missing","value":null}' : undefined;
+  if (audited.status === "non-finite")
+    return keys === 3 && audited.value === null && typeof audited.nonFiniteKind === "string"
+      ? `{"nonFiniteKind":${quote(audited.nonFiniteKind)},"status":"non-finite","value":null}`
+      : undefined;
+  return undefined;
+}
+
+function measuresText(value: unknown): string | undefined {
+  if (!plain(value)) return undefined;
+  const keys = Object.keys(value);
+  for (let index = 1; index < keys.length; index++)
+    if (keys[index - 1]! > keys[index]!) {
+      keys.sort();
+      break;
+    }
+  let text = "{";
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index]!;
+    const rendered = auditedText(value[key]);
+    if (rendered === undefined) return undefined;
+    text += `${index > 0 ? "," : ""}${quote(key)}:${rendered}`;
+  }
+  return `${text}}`;
+}
+
+function snapshotText(record: unknown): string | undefined {
+  if (!plain(record)) return undefined;
+  const keys = Object.keys(record).length;
+  if (hasOwn(record, "rowType")) {
+    // Loss: claimId, complete, measures, origin, recordId, rowType, source, sourceGroup, valuation.
+    if (keys !== 9) return undefined;
+    const claimId = stringOrNull(record.claimId);
+    const measures = measuresText(record.measures);
+    const source = sourceText(record.source);
+    if (
+      claimId === undefined ||
+      typeof record.complete !== "boolean" ||
+      measures === undefined ||
+      typeof record.origin !== "string" ||
+      typeof record.recordId !== "string" ||
+      typeof record.rowType !== "string" ||
+      source === undefined ||
+      typeof record.sourceGroup !== "string" ||
+      typeof record.valuation !== "string"
+    )
+      return undefined;
+    return `{"claimId":${claimId},"complete":${record.complete},"measures":${measures},"origin":${quote(record.origin)},"recordId":${quote(record.recordId)},"rowType":${quote(record.rowType)},"source":${source},"sourceGroup":${quote(record.sourceGroup)},"valuation":${quote(record.valuation)}}`;
+  }
+  if (hasOwn(record, "measureId")) {
+    // Exposure: complete, key, measureId, origin, source, sourceGroup, valuation, value.
+    if (keys !== 8) return undefined;
+    const source = sourceText(record.source);
+    const valuation = stringOrNull(record.valuation);
+    const audited = auditedText(record.value);
+    if (
+      typeof record.complete !== "boolean" ||
+      typeof record.key !== "string" ||
+      typeof record.measureId !== "string" ||
+      typeof record.origin !== "string" ||
+      source === undefined ||
+      typeof record.sourceGroup !== "string" ||
+      valuation === undefined ||
+      audited === undefined
+    )
+      return undefined;
+    return `{"complete":${record.complete},"key":${quote(record.key)},"measureId":${quote(record.measureId)},"origin":${quote(record.origin)},"source":${source},"sourceGroup":${quote(record.sourceGroup)},"valuation":${valuation},"value":${audited}}`;
+  }
+  // Expected cell: origin, source, sourceGroup, valuation.
+  if (keys !== 4) return undefined;
+  const source = sourceText(record.source);
+  if (
+    typeof record.origin !== "string" ||
+    source === undefined ||
+    typeof record.sourceGroup !== "string" ||
+    typeof record.valuation !== "string"
+  )
+    return undefined;
+  return `{"origin":${quote(record.origin)},"source":${source},"sourceGroup":${quote(record.sourceGroup)},"valuation":${quote(record.valuation)}}`;
+}

package/src/diagnosticFormulas.ts

@@ -188,10 +188,50 @@ function pointer(path: string, segment: string | number): string {
   return `${path}/${escaped}`;
 }
 
+// Shared immutable empties for clean operands; every consumer copies or iterates.
+const NO_REASONS: readonly DiagnosticRuleNotEvaluatedReason[] = Object.freeze([]);
+const NO_OVERFLOWS: readonly DiagnosticExpressionOverflow[] = Object.freeze([]);
+const NO_SOURCES: readonly import("./diagnosticDefinitions.js").DiagnosticSourceLocation[] =
+  Object.freeze([]);
+
+// Path segments below the caller's root, pushed and popped during one
+// synchronous evaluation. Rendering happens only when an overflow must cite a
+// path, so the common case allocates nothing. A re-entrant call while the
+// shared stack is in use gets its own stack.
+let sharedSegments: (string | number)[] | null = [];
+// A measure leaf never renders a path; it may evaluate against a fixed empty stack.
+const LEAF_SEGMENTS: (string | number)[] = [];
+
 export function evaluateDiagnosticMeasureExpression(
   expression: DiagnosticDeepReadonly<DiagnosticMeasureExpression>,
   measures: Readonly<Record<string, FinalizedDiagnosticMeasure>>,
   path: string,
+): ExpressionResult {
+  if (expression.op === "measure")
+    return evaluateMeasureExpression(expression, measures, path, LEAF_SEGMENTS);
+  const segments = sharedSegments ?? [];
+  sharedSegments = null;
+  segments.length = 0;
+  try {
+    return evaluateMeasureExpression(expression, measures, path, segments);
+  } finally {
+    sharedSegments = segments;
+  }
+}
+
+function renderPath(root: string, segments: readonly (string | number)[]): string {
+  let path = root;
+  for (let index = 0; index < segments.length; index++)
+    path = pointer(path, segments[index]!);
+  return path;
+}
+
+/** Expression paths are only rendered when an overflow has to cite one. */
+function evaluateMeasureExpression(
+  expression: DiagnosticDeepReadonly<DiagnosticMeasureExpression>,
+  measures: Readonly<Record<string, FinalizedDiagnosticMeasure>>,
+  root: string,
+  segments: (string | number)[],
 ): ExpressionResult {
   if (expression.op === "measure") {
     const value = hasDiagnosticOwn(measures, expression.measureId)
@@ -201,34 +241,44 @@ export function evaluateDiagnosticMeasureExpression(
       ? {
           value: value.quantity.value,
           reasons: value.readiness,
-          overflows: value.expressionOverflows ?? [],
-          sources: value.sources ?? [],
+          overflows: value.expressionOverflows ?? NO_OVERFLOWS,
+          sources: value.sources ?? NO_SOURCES,
         }
-      : { value: null, reasons: ["missing"], overflows: [], sources: [] };
+      : {
+          value: null,
+          reasons: ["missing"],
+          overflows: NO_OVERFLOWS,
+          sources: NO_SOURCES,
+        };
   }
-  const children =
-    expression.op === "add"
-      ? expression.terms.map((term, index) =>
-          evaluateDiagnosticMeasureExpression(
-            term,
-            measures,
-            pointer(pointer(path, "terms"), index),
-          ),
-        )
-      : [
-          evaluateDiagnosticMeasureExpression(
-            expression.left,
-            measures,
-            pointer(path, "left"),
-          ),
-          evaluateDiagnosticMeasureExpression(
-            expression.right,
-            measures,
-            pointer(path, "right"),
-          ),
-        ];
-  const reasons = uniqueReasons(children.flatMap((child) => child.reasons));
-  const overflows = children.flatMap((child) => child.overflows);
+  let children: ExpressionResult[];
+  if (expression.op === "add") {
+    children = new Array(expression.terms.length);
+    segments.push("terms", 0);
+    try {
+      for (let index = 0; index < expression.terms.length; index++) {
+        segments[segments.length - 1] = index;
+        children[index] = evaluateMeasureExpression(expression.terms[index]!, measures, root, segments);
+      }
+    } finally {
+      segments.length -= 2;
+    }
+  } else {
+    segments.push("left");
+    try {
+      const left = evaluateMeasureExpression(expression.left, measures, root, segments);
+      segments[segments.length - 1] = "right";
+      children = [left, evaluateMeasureExpression(expression.right, measures, root, segments)];
+    } finally {
+      segments.length -= 1;
+    }
+  }
+  const reasons = children.every((child) => child.reasons.length === 0)
+    ? NO_REASONS
+    : uniqueReasons(children.flatMap((child) => child.reasons));
+  const overflows = children.every((child) => child.overflows.length === 0)
+    ? NO_OVERFLOWS
+    : children.flatMap((child) => child.overflows);
   const sources = normalizeDiagnosticSourceLocations(
     children.flatMap((child) => child.sources),
   );
@@ -242,7 +292,7 @@ export function evaluateDiagnosticMeasureExpression(
     return {
       value: null,
       reasons: uniqueReasons([...reasons, "expression-overflow"]),
-      overflows: [...overflows, { expressionPath: path, sources }],
+      overflows: [...overflows, { expressionPath: renderPath(root, segments), sources }],
       sources,
     };
   }

package/src/diagnosticFreeze.ts

@@ -1,37 +1,82 @@
 import type { DiagnosticDeepReadonly } from "./diagnosticDefinitions.js";
 
-// Private knowledge of graphs traversed by this freezer. Object.isFrozen alone
-// is not evidence that caller-supplied children are immutable. Weak membership
-// does not keep released diagnostic datasets alive.
-let completedGraphs = new WeakSet<object>();
-let completedCount = 0;
-const MAX_COMPLETED_MEMBERS = 100_000;
+// Owned diagnostic graphs are JSON-shaped: shallow trees whose shared nodes are
+// small leaves (source locations, statistics, findings). Visiting a shared leaf
+// once per reference is far cheaper than remembering millions of visited nodes,
+// so ancestors are tracked only past this depth. A cycle must exceed it and is
+// then cut exactly where a visited-set walk would cut it.
+const UNGUARDED_DEPTH = 64;
 
-/** Freeze owned plain-data snapshots, visiting shared subgraphs only once. */
-export function freezeDiagnosticGraph<T>(value: T): DiagnosticDeepReadonly<T> {
-  // This walk already retains its nodes until success; a strong local set avoids
-  // a second large weak table and is released when the invocation returns.
-  const seen = new Set<object>();
-  const visit = (node: unknown): void => {
-    if (node === null || typeof node !== "object" || seen.has(node) || completedGraphs.has(node)) return;
-    seen.add(node);
-    for (const child of Object.values(node as Record<string, unknown>)) visit(child);
+/** True when Object.prototype carries an enumerable key, so for-in needs an own-key guard. */
+function objectPrototypeEnumerates(): boolean {
+  for (const key in {}) return key !== undefined;
+  return false;
+}
+
+function walk(value: unknown, skipFrozen: boolean): void {
+  const guardInherited = objectPrototypeEnumerates();
+  let ancestors: Set<object> | undefined;
+  const visit = (node: unknown, depth: number): void => {
+    if (node === null || typeof node !== "object") return;
+    if (skipFrozen && Object.isFrozen(node)) return;
+    const guarded = depth > UNGUARDED_DEPTH;
+    if (guarded) {
+      ancestors ??= new Set();
+      if (ancestors.has(node)) return;
+      ancestors.add(node);
+    }
+    // Scalars are checked inline: most children are numbers and strings, and a
+    // call per scalar would dominate the walk.
+    if (Array.isArray(node)) {
+      for (let index = 0; index < node.length; index++) {
+        const child: unknown = node[index];
+        if (child !== null && typeof child === "object") visit(child, depth + 1);
+      }
+    } else {
+      // for-in visits own enumerable string keys in the same order as
+      // Object.keys without allocating a key array per node. Plain records
+      // inherit nothing enumerable unless Object.prototype was extended.
+      const record = node as Record<string, unknown>;
+      const prototype: unknown = Object.getPrototypeOf(record);
+      if (!guardInherited && (prototype === Object.prototype || prototype === null)) {
+        for (const key in record) {
+          const child = record[key];
+          if (child !== null && typeof child === "object") visit(child, depth + 1);
+        }
+      } else {
+        for (const key in record) {
+          if (!Object.hasOwn(record, key)) continue;
+          const child = record[key];
+          if (child !== null && typeof child === "object") visit(child, depth + 1);
+        }
+      }
+    }
+    if (guarded) ancestors!.delete(node);
     Object.freeze(node);
   };
-  visit(value);
-  // Mark only after the whole walk succeeds: a cyclic child must not become
-  // trusted while pointing at a parent whose freeze failed.
-  for (const node of seen) {
-    // This is a traversal shortcut, never an authentication receipt. Forgetting
-    // old membership is safe: a later visit traverses and freezes that graph
-    // again. Bound the weak-table bookkeeping even when millions of source
-    // objects are still strongly retained by a large diagnostic dataset.
-    if (completedCount >= MAX_COMPLETED_MEMBERS) {
-      completedGraphs = new WeakSet<object>();
-      completedCount = 0;
-    }
-    completedGraphs.add(node);
-    completedCount++;
-  }
+  visit(value, 0);
+}
+
+/**
+ * Freeze an owned plain-data snapshot deeply. Every reachable child is visited
+ * and frozen, including children of an already frozen node, because a frozen
+ * root is no evidence that a caller-supplied child is immutable. The walk keeps
+ * no state between calls and allocates nothing for ordinary acyclic graphs.
+ */
+export function freezeDiagnosticGraph<T>(value: T): DiagnosticDeepReadonly<T> {
+  walk(value, false);
+  return value as DiagnosticDeepReadonly<T>;
+}
+
+/**
+ * Freeze a graph that the SDK built entirely itself, where every node that is
+ * already frozen was frozen complete: preparation attaches contributions,
+ * statistics, citation lists and shared empties only after freezing them and
+ * every child below them. Such nodes are skipped instead of re-walked once per
+ * reference. Never use this on a graph that may hold a caller-frozen node with
+ * mutable children; `freezeDiagnosticGraph` exists for that case.
+ */
+export function freezeOwnedDiagnosticGraph<T>(value: T): DiagnosticDeepReadonly<T> {
+  walk(value, true);
   return value as DiagnosticDeepReadonly<T>;
 }