@xbbg/langgraph 1.4.11 → 1.4.12

package/dist/index.js

@@ -63,6 +63,12 @@ var DEFAULT_MAX_SECURITIES = 25;
 var DEFAULT_MAX_FIELDS = 25;
 var DEFAULT_MAX_ROWS = 500;
 var DEFAULT_MAX_STRING_CHARS = 2e3;
+var DEFAULT_MAX_RESULT_BYTES = 1048576;
+var DEFAULT_MAX_RESULT_NODES = 5e4;
+var DEFAULT_MAX_CONTENT_BYTES = 65536;
+var DEFAULT_MAX_CONTENT_ROWS = 50;
+var MIN_RESULT_BYTE_BUDGET = 256;
+var MIN_RESULT_NODE_BUDGET = 10;
 var DEFAULT_MAX_BQL_QUERY_CHARS = 4e3;
 var DEFAULT_MAX_SEARCH_SPEC_CHARS = 1e3;
 var DEFAULT_MAX_STREAM_UPDATES = 10;
@@ -78,11 +84,20 @@ function positiveInteger(value, fallback, name) {
   if (value === void 0) {
     return fallback;
   }
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new RangeError(`${name} must be a positive integer; got ${String(value)}`);
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new RangeError(
+      `${name} must be a positive integer no greater than Number.MAX_SAFE_INTEGER; got ${String(value)}`
+    );
   }
   return value;
 }
+function integerAtLeast(value, fallback, minimum, name) {
+  const normalized = positiveInteger(value, fallback, name);
+  if (normalized < minimum) {
+    throw new RangeError(`${name} must be at least ${String(minimum)}; got ${String(normalized)}`);
+  }
+  return normalized;
+}
 function disabledToolSet(tools) {
   return new Set(tools ?? []);
 }
@@ -98,7 +113,30 @@ function normalizeBloombergToolsOptions(options = {}) {
       "maxBqlQueryChars"
     ),
     maxFields: positiveInteger(options.maxFields, DEFAULT_MAX_FIELDS, "maxFields"),
+    maxContentBytes: integerAtLeast(
+      options.maxContentBytes,
+      DEFAULT_MAX_CONTENT_BYTES,
+      MIN_RESULT_BYTE_BUDGET,
+      "maxContentBytes"
+    ),
+    maxContentRows: positiveInteger(
+      options.maxContentRows,
+      DEFAULT_MAX_CONTENT_ROWS,
+      "maxContentRows"
+    ),
     maxRows: positiveInteger(options.maxRows, DEFAULT_MAX_ROWS, "maxRows"),
+    maxResultBytes: integerAtLeast(
+      options.maxResultBytes,
+      DEFAULT_MAX_RESULT_BYTES,
+      MIN_RESULT_BYTE_BUDGET,
+      "maxResultBytes"
+    ),
+    maxResultNodes: integerAtLeast(
+      options.maxResultNodes,
+      DEFAULT_MAX_RESULT_NODES,
+      MIN_RESULT_NODE_BUDGET,
+      "maxResultNodes"
+    ),
     maxSearchSpecChars: positiveInteger(
       options.maxSearchSpecChars,
       DEFAULT_MAX_SEARCH_SPEC_CHARS,
@@ -178,181 +216,863 @@ function createCoreResolver(options = {}) {
 }
 
 // src/result-limits.ts
+var OMIT = /* @__PURE__ */ Symbol("omit_result_value");
 var MAX_RESULT_DEPTH = 32;
+var MIN_TOOL_RESULT_NODES = 10;
+var MAX_ERROR_DIAGNOSTICS = 8;
+var RESULT_ENVELOPE_RESERVE_BYTES = 768;
+var CONTENT_ENVELOPE_RESERVE_BYTES = 768;
+var MIN_TOOL_RESULT_BYTES = 256;
 var MAX_ENTITLEMENT_EIDS = 1e4;
 var MAX_BLOOMBERG_EID = 2147483647;
 var MAX_EID_SECURITIES = 1e3;
 var MAX_EID_SECURITY_NAME_BYTES = 65536;
 var UTF8_ENCODER = new TextEncoder();
+var TRUNCATION_REASON_ORDER = [
+  "max_rows",
+  "max_string_chars",
+  "max_result_bytes",
+  "max_result_nodes",
+  "max_result_depth",
+  "circular_reference",
+  "binary_data",
+  "accessor_omitted",
+  "unsupported_value",
+  "invalid_entitlement_data",
+  "entitlement_limit",
+  "upstream_truncation"
+];
+var ERROR_SHAPE_KEYS = {
+  error: true,
+  errors: true,
+  fielderrors: true,
+  fieldexception: true,
+  fieldexceptions: true,
+  responseerror: true,
+  responseerrors: true,
+  securityerror: true,
+  securityerrors: true,
+  unsubscribeerror: true
+};
+var PRIORITY_KEYS = [
+  "error",
+  "errors",
+  "responseError",
+  "responseErrors",
+  "securityError",
+  "securityErrors",
+  "fieldException",
+  "fieldExceptions",
+  "fieldErrors",
+  "unsubscribeError",
+  "truncated",
+  "truncatedInput",
+  "eidData",
+  "eidDataTruncation",
+  "diagnostics",
+  "metadata"
+];
 function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function truncateString(value, maxStringChars, state) {
-  if (value.length <= maxStringChars) {
-    return value;
+function addReason(state, reason) {
+  state.reasons.add(reason);
+}
+function consumeVisit(state) {
+  if (state.visitedNodes >= state.limits.maxResultNodes) {
+    addReason(state, "max_result_nodes");
+    return false;
+  }
+  state.visitedNodes += 1;
+  return true;
+}
+function consumeVisitBefore(state, limit) {
+  if (state.visitedNodes >= limit) {
+    addReason(state, "max_result_nodes");
+    return false;
   }
-  state.truncated = true;
-  return `${value.slice(0, maxStringChars)}\u2026[truncated ${value.length - maxStringChars} chars]`;
+  return consumeVisit(state);
 }
-function arrayMetadata(value) {
-  const metadata = {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (!/^(?:0|[1-9]\d*)$/u.test(key)) {
-      metadata[key] = entry;
+function projectionBudget(totalBytes, preferredReserveBytes) {
+  const reserve = Math.min(preferredReserveBytes, Math.floor(totalBytes / 2));
+  return Math.max(4, totalBytes - reserve);
+}
+function jsonStringUnit(value, index) {
+  const code = value.charCodeAt(index);
+  if (code === 34 || code === 92 || code === 8 || code === 12 || code === 10 || code === 13 || code === 9) {
+    return { bytes: 2, width: 1 };
+  }
+  if (code <= 31) {
+    return { bytes: 6, width: 1 };
+  }
+  if (code <= 127) {
+    return { bytes: 1, width: 1 };
+  }
+  if (code <= 2047) {
+    return { bytes: 2, width: 1 };
+  }
+  if (code >= 55296 && code <= 56319) {
+    const next = value.charCodeAt(index + 1);
+    if (next >= 56320 && next <= 57343) {
+      return { bytes: 4, width: 2 };
+    }
+    return { bytes: 6, width: 1 };
+  }
+  if (code >= 56320 && code <= 57343) {
+    return { bytes: 6, width: 1 };
+  }
+  return { bytes: 3, width: 1 };
+}
+function jsonStringByteLength(value, stopAfter = Number.MAX_SAFE_INTEGER) {
+  let byteLength = 2;
+  for (let index = 0; index < value.length; ) {
+    const unit = jsonStringUnit(value, index);
+    byteLength += unit.bytes;
+    if (byteLength > stopAfter) {
+      return stopAfter + 1;
     }
+    index += unit.width;
   }
-  return metadata;
+  return byteLength;
+}
+function utf8ByteLengthAtMost(value, maximum) {
+  let byteLength = 0;
+  for (let index = 0; index < value.length; ) {
+    const code = value.charCodeAt(index);
+    let width = 1;
+    let bytes;
+    if (code <= 127) {
+      bytes = 1;
+    } else if (code <= 2047) {
+      bytes = 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes = 4;
+        width = 2;
+      } else {
+        bytes = 3;
+      }
+    } else {
+      bytes = 3;
+    }
+    byteLength += bytes;
+    if (byteLength > maximum) {
+      return null;
+    }
+    index += width;
+  }
+  return byteLength;
+}
+function safePrefixEnd(value, requestedEnd) {
+  if (requestedEnd > 0 && requestedEnd < value.length && value.charCodeAt(requestedEnd - 1) >= 55296 && value.charCodeAt(requestedEnd - 1) <= 56319 && value.charCodeAt(requestedEnd) >= 56320 && value.charCodeAt(requestedEnd) <= 57343) {
+    return requestedEnd - 1;
+  }
+  return requestedEnd;
+}
+function fitString(value, maximumJsonBytes, state) {
+  const charLimit = safePrefixEnd(value, Math.min(value.length, state.limits.maxStringChars));
+  if (charLimit < value.length) {
+    addReason(state, "max_string_chars");
+  }
+  const suffix = `\u2026[truncated ${value.length - charLimit} chars]`;
+  const characterLimited = charLimit === value.length ? value : `${value.slice(0, charLimit)}${suffix}`;
+  const characterLimitedBytes = jsonStringByteLength(characterLimited, maximumJsonBytes);
+  if (characterLimitedBytes <= maximumJsonBytes) {
+    state.retainedNodes += 1;
+    return { byteLength: characterLimitedBytes, value: characterLimited };
+  }
+  addReason(state, "max_result_bytes");
+  const markerOnly = `\u2026[truncated ${value.length} chars]`;
+  const markerOnlyBytes = jsonStringByteLength(markerOnly, maximumJsonBytes);
+  if (markerOnlyBytes > maximumJsonBytes) {
+    if (maximumJsonBytes < 2) {
+      return OMIT;
+    }
+    state.retainedNodes += 1;
+    return { byteLength: 2, value: "" };
+  }
+  const prefixBudget = Math.max(0, maximumJsonBytes - 2 - 64);
+  let prefixBytes = 0;
+  let prefixEnd = 0;
+  while (prefixEnd < charLimit) {
+    const unit = jsonStringUnit(value, prefixEnd);
+    if (prefixBytes + unit.bytes > prefixBudget) {
+      break;
+    }
+    prefixBytes += unit.bytes;
+    prefixEnd += unit.width;
+  }
+  const fittedSuffix = `\u2026[truncated ${value.length - prefixEnd} chars]`;
+  const fitted = `${value.slice(0, prefixEnd)}${fittedSuffix}`;
+  const fittedBytes = jsonStringByteLength(fitted, maximumJsonBytes);
+  if (fittedBytes > maximumJsonBytes) {
+    state.retainedNodes += 1;
+    return { byteLength: markerOnlyBytes, value: markerOnly };
+  }
+  state.retainedNodes += 1;
+  return { byteLength: fittedBytes, value: fitted };
+}
+function defineJsonProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true
+  });
+}
+function ownEnumerableDescriptor(value, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor?.enumerable === true ? descriptor : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function rememberErrorDiagnostic(state, key, value) {
+  state.hasErrors = true;
+  if (state.diagnostics.length >= MAX_ERROR_DIAGNOSTICS) {
+    return;
+  }
+  const diagnostic = /* @__PURE__ */ Object.create(null);
+  defineJsonProperty(diagnostic, key, value);
+  state.diagnostics.push(Object.freeze(diagnostic));
+}
+function hasReportedError(value) {
+  if (value === void 0 || value === null || value === false || value === "") {
+    return false;
+  }
+  return !Array.isArray(value) || value.length > 0;
+}
+function primitiveBuilt(value, maximumJsonBytes, state) {
+  const json = value === null ? "null" : String(value);
+  const byteLength = json.length;
+  if (byteLength > maximumJsonBytes) {
+    addReason(state, "max_result_bytes");
+    return OMIT;
+  }
+  state.retainedNodes += 1;
+  return { byteLength, value };
+}
+function buildUnsupported(label, maximumJsonBytes, state, reason = "unsupported_value") {
+  addReason(state, reason);
+  return fitString(label, maximumJsonBytes, state);
 }
-function limitEidData(value, maxStringChars, state, depth, seen) {
-  if (typeof value !== "object" || value === null || !isPlainObject(value)) {
-    state.truncated = true;
+function prepareEidData(value, state) {
+  const data = /* @__PURE__ */ Object.create(null);
+  const securityCounts = [];
+  let validContainer = false;
+  if (typeof value === "object" && value !== null) {
+    try {
+      validContainer = isPlainObject(value);
+    } catch {
+      validContainer = false;
+    }
+  }
+  if (!validContainer) {
+    addReason(state, "invalid_entitlement_data");
     return {
-      data: {},
+      data,
+      invalidSecurityCount: 1,
+      scannedSecurityCount: 1,
+      securityCounts,
+      totalEidCount: 0,
+      totalSecurityCount: 1,
       truncation: {
         invalidSecurityCount: 1,
         omittedSecurityCount: 0,
         retainedEidCount: 0,
         retainedSecurityCount: 0,
-        securityCounts: [],
+        scannedSecurityCount: 1,
+        securityCounts,
         totalEidCount: 0,
         totalSecurityCount: 1
       }
     };
   }
-  const data = /* @__PURE__ */ Object.create(null);
-  const securityCounts = [];
-  const entries = Object.entries(value);
+  const eidRecord = value;
+  let complete = true;
+  let invalidSecurityCount = 0;
   let retainedEidCount = 0;
   let retainedSecurityCount = 0;
   let retainedSecurityNameBytes = 0;
+  let scannedSecurityCount = 0;
   let totalEidCount = 0;
-  let invalidSecurityCount = 0;
-  for (const [security, eids] of entries) {
-    if (!Array.isArray(eids)) {
-      state.truncated = true;
+  const remainingNodeBudget = state.limits.maxResultNodes - state.visitedNodes;
+  const reservedSummaryNodes = Math.min(16, Math.max(0, remainingNodeBudget - 1));
+  const eidVisitLimit = state.visitedNodes + Math.max(1, Math.floor((remainingNodeBudget - reservedSummaryNodes) / 2));
+  securityLoop: for (const security in eidRecord) {
+    if (!Object.hasOwn(eidRecord, security)) {
+      continue;
+    }
+    if (!consumeVisitBefore(state, eidVisitLimit)) {
+      complete = false;
+      break;
+    }
+    scannedSecurityCount += 1;
+    const descriptor = ownEnumerableDescriptor(eidRecord, security);
+    if (descriptor === void 0) {
+      continue;
+    }
+    if (!("value" in descriptor) || !Array.isArray(descriptor.value)) {
       invalidSecurityCount += 1;
+      addReason(state, "invalid_entitlement_data");
       continue;
     }
-    let validEids = true;
+    const eids = descriptor.value;
+    const remainingNameBytes = MAX_EID_SECURITY_NAME_BYTES - retainedSecurityNameBytes;
+    const securityNameBytes = utf8ByteLengthAtMost(security, remainingNameBytes);
+    const canRetainSecurity = retainedSecurityCount < MAX_EID_SECURITIES && securityNameBytes !== null;
+    const remainingEidCapacity = Math.max(0, MAX_ENTITLEMENT_EIDS - retainedEidCount);
+    const retained = [];
+    let incomplete = false;
     for (let index = 0; index < eids.length; index += 1) {
-      const eid = eids[index];
-      if (!Object.hasOwn(eids, index) || typeof eid !== "number" || !Number.isInteger(eid) || eid <= 0 || eid > MAX_BLOOMBERG_EID) {
-        validEids = false;
+      if (!consumeVisitBefore(state, eidVisitLimit)) {
+        complete = false;
+        incomplete = true;
         break;
       }
+      const eidDescriptor = Object.getOwnPropertyDescriptor(eids, String(index));
+      const eid = eidDescriptor !== void 0 && "value" in eidDescriptor ? eidDescriptor.value : void 0;
+      if (eidDescriptor === void 0 || !("value" in eidDescriptor) || typeof eid !== "number" || !Number.isInteger(eid) || eid <= 0 || eid > MAX_BLOOMBERG_EID) {
+        invalidSecurityCount += 1;
+        addReason(state, "invalid_entitlement_data");
+        continue securityLoop;
+      }
+      if (canRetainSecurity && retained.length < remainingEidCapacity) {
+        retained.push(eid);
+      }
     }
-    if (!validEids) {
-      state.truncated = true;
-      invalidSecurityCount += 1;
-      continue;
-    }
-    const originalCount = eids.length;
-    totalEidCount += originalCount;
-    const securityNameBytes = UTF8_ENCODER.encode(security).byteLength;
-    const canRetainSecurity = retainedSecurityCount < MAX_EID_SECURITIES && retainedSecurityNameBytes + securityNameBytes <= MAX_EID_SECURITY_NAME_BYTES;
+    totalEidCount = Math.min(Number.MAX_SAFE_INTEGER, totalEidCount + eids.length);
     if (!canRetainSecurity) {
-      state.truncated = true;
+      addReason(state, "entitlement_limit");
+      if (incomplete) {
+        break;
+      }
       continue;
     }
+    retainedEidCount += retained.length;
     retainedSecurityCount += 1;
     retainedSecurityNameBytes += securityNameBytes;
-    const remainingEidCapacity = Math.max(0, MAX_ENTITLEMENT_EIDS - retainedEidCount);
-    const retained = eids.slice(0, remainingEidCapacity);
-    retainedEidCount += retained.length;
-    data[security] = limitValue(retained, MAX_ENTITLEMENT_EIDS, maxStringChars, state, depth, seen);
-    securityCounts.push({
-      originalCount,
-      retainedCount: retained.length
-    });
-    if (retained.length !== originalCount) {
-      state.truncated = true;
+    defineJsonProperty(data, security, retained);
+    securityCounts.push({ originalCount: eids.length, retainedCount: retained.length });
+    if (!incomplete && retained.length !== eids.length) {
+      addReason(state, "entitlement_limit");
+    }
+    if (incomplete) {
+      break;
     }
   }
-  const omittedSecurityCount = entries.length - retainedSecurityCount - invalidSecurityCount;
-  const wasTruncated = retainedSecurityCount !== entries.length || retainedEidCount !== totalEidCount || invalidSecurityCount > 0;
+  const omittedSecurityCount = complete ? scannedSecurityCount - retainedSecurityCount - invalidSecurityCount : null;
+  const wasTruncated = !complete || invalidSecurityCount > 0 || omittedSecurityCount !== 0 || retainedEidCount !== totalEidCount;
+  if (!wasTruncated) {
+    return {
+      data,
+      invalidSecurityCount,
+      scannedSecurityCount,
+      securityCounts,
+      totalEidCount,
+      totalSecurityCount: scannedSecurityCount
+    };
+  }
   return {
     data,
-    ...wasTruncated ? {
-      truncation: {
-        invalidSecurityCount,
-        omittedSecurityCount,
-        retainedEidCount,
-        retainedSecurityCount,
-        securityCounts,
-        totalEidCount,
-        totalSecurityCount: entries.length
-      }
-    } : {}
+    invalidSecurityCount,
+    scannedSecurityCount,
+    securityCounts,
+    totalEidCount: complete ? totalEidCount : null,
+    totalSecurityCount: complete ? scannedSecurityCount : null,
+    truncation: {
+      invalidSecurityCount,
+      omittedSecurityCount,
+      retainedEidCount,
+      retainedSecurityCount,
+      scannedSecurityCount,
+      securityCounts,
+      totalEidCount: complete ? totalEidCount : null,
+      totalSecurityCount: complete ? scannedSecurityCount : null
+    }
   };
 }
-function limitValue(value, maxRows, maxStringChars, state, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof value === "string") {
-    return truncateString(value, maxStringChars, state);
+function eidSummaryRecord(source) {
+  const descriptor = ownEnumerableDescriptor(source, "eidDataTruncation");
+  if (descriptor === void 0 || !("value" in descriptor) || typeof descriptor.value !== "object" || descriptor.value === null) {
+    return void 0;
   }
-  if (value instanceof Date) {
-    return value.toISOString();
+  return descriptor.value;
+}
+function eidSummaryCount(summary, key) {
+  if (summary === void 0) {
+    return void 0;
   }
-  if (depth > MAX_RESULT_DEPTH) {
-    state.truncated = true;
-    return "[Max result depth exceeded]";
+  const descriptor = ownEnumerableDescriptor(summary, key);
+  if (descriptor === void 0 || !("value" in descriptor)) {
+    return void 0;
   }
-  if (Array.isArray(value)) {
-    if (seen.has(value)) {
-      state.truncated = true;
-      return "[Circular]";
+  const value = descriptor.value;
+  return value === null || typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function eidSummarySecurityCounts(summary) {
+  if (summary === void 0) {
+    return [];
+  }
+  const descriptor = ownEnumerableDescriptor(summary, "securityCounts");
+  if (descriptor === void 0 || !("value" in descriptor) || !Array.isArray(descriptor.value)) {
+    return [];
+  }
+  const counts = [];
+  for (let index = 0; index < descriptor.value.length; index += 1) {
+    const entryDescriptor = Object.getOwnPropertyDescriptor(descriptor.value, String(index));
+    if (entryDescriptor === void 0 || !("value" in entryDescriptor) || typeof entryDescriptor.value !== "object" || entryDescriptor.value === null) {
+      break;
     }
-    seen.add(value);
-    const capped = value.length > maxRows ? value.slice(0, maxRows) : value;
-    if (capped.length !== value.length) {
-      state.truncated = true;
+    const originalCount = eidSummaryCount(
+      entryDescriptor.value,
+      "originalCount"
+    );
+    const retainedCount = eidSummaryCount(
+      entryDescriptor.value,
+      "retainedCount"
+    );
+    if (originalCount === void 0 || originalCount !== null && typeof originalCount !== "number" || typeof retainedCount !== "number") {
+      break;
     }
-    const rows = capped.map(
-      (item) => limitValue(item, maxRows, maxStringChars, state, depth + 1, seen)
+    counts.push({ originalCount, retainedCount });
+  }
+  return counts;
+}
+function emittedEidTruncation(source, emittedValue, prepared) {
+  const emitted = typeof emittedValue === "object" && emittedValue !== null ? emittedValue : /* @__PURE__ */ Object.create(null);
+  const prior = eidSummaryRecord(source);
+  const priorSecurityCounts = eidSummarySecurityCounts(prior);
+  const securityCounts = [];
+  let retainedEidCount = 0;
+  let retainedSecurityCount = 0;
+  for (const security in emitted) {
+    if (!Object.hasOwn(emitted, security)) {
+      continue;
+    }
+    const descriptor = ownEnumerableDescriptor(emitted, security);
+    if (descriptor === void 0 || !("value" in descriptor) || !Array.isArray(descriptor.value)) {
+      continue;
+    }
+    const retainedCount = descriptor.value.length;
+    const preparedCount = prepared.securityCounts[retainedSecurityCount];
+    const priorCount = priorSecurityCounts[retainedSecurityCount];
+    securityCounts.push({
+      originalCount: prior === void 0 ? preparedCount?.originalCount ?? retainedCount : priorCount?.originalCount ?? null,
+      retainedCount
+    });
+    retainedEidCount = Math.min(Number.MAX_SAFE_INTEGER, retainedEidCount + retainedCount);
+    retainedSecurityCount += 1;
+  }
+  const priorTotalEidCount = eidSummaryCount(prior, "totalEidCount");
+  const priorTotalSecurityCount = eidSummaryCount(prior, "totalSecurityCount");
+  const totalEidCount = prior === void 0 ? prepared.totalEidCount : priorTotalEidCount === void 0 ? null : priorTotalEidCount;
+  const totalSecurityCount = prior === void 0 ? prepared.totalSecurityCount : priorTotalSecurityCount === void 0 ? null : priorTotalSecurityCount;
+  const priorInvalidSecurityCount = eidSummaryCount(prior, "invalidSecurityCount");
+  const invalidSecurityCount = typeof priorInvalidSecurityCount === "number" ? priorInvalidSecurityCount : prepared.invalidSecurityCount;
+  const priorScannedSecurityCount = eidSummaryCount(prior, "scannedSecurityCount");
+  const scannedSecurityCount = typeof priorScannedSecurityCount === "number" ? priorScannedSecurityCount : prepared.scannedSecurityCount;
+  const omittedSecurityCount = totalSecurityCount === null ? null : Math.max(0, totalSecurityCount - retainedSecurityCount - invalidSecurityCount);
+  const truncated = prior !== void 0 || prepared.truncation !== void 0 || totalEidCount === null || totalSecurityCount === null || retainedEidCount !== totalEidCount || retainedSecurityCount + invalidSecurityCount !== totalSecurityCount;
+  if (!truncated) {
+    return void 0;
+  }
+  return {
+    retainedEidCount,
+    totalEidCount,
+    retainedSecurityCount,
+    totalSecurityCount,
+    securityCounts,
+    invalidSecurityCount,
+    omittedSecurityCount,
+    scannedSecurityCount
+  };
+}
+function appendBuiltProperty(accumulator, key, built, maximumJsonBytes, state) {
+  if (Object.hasOwn(accumulator.value, key)) {
+    return true;
+  }
+  const commaBytes = accumulator.propertyCount === 0 ? 0 : 1;
+  const availableForKey = maximumJsonBytes - accumulator.byteLength - commaBytes - 1 - built.byteLength;
+  if (availableForKey < 2) {
+    addReason(state, "max_result_bytes");
+    return false;
+  }
+  const keyBytes = jsonStringByteLength(key, availableForKey);
+  if (keyBytes > availableForKey) {
+    addReason(state, "max_result_bytes");
+    return false;
+  }
+  defineJsonProperty(accumulator.value, key, built.value);
+  accumulator.byteLength += commaBytes + keyBytes + 1 + built.byteLength;
+  accumulator.propertyCount += 1;
+  return true;
+}
+function buildProperty(source, key, accumulator, maximumJsonBytes, state, depth, rowLimit) {
+  const descriptor = ownEnumerableDescriptor(source, key);
+  if (descriptor === void 0) {
+    return true;
+  }
+  if (key === "eidDataTruncation" && ownEnumerableDescriptor(source, "eidData") !== void 0) {
+    return true;
+  }
+  const commaBytes = accumulator.propertyCount === 0 ? 0 : 1;
+  const availableForKeyAndChild = maximumJsonBytes - accumulator.byteLength - commaBytes - 1;
+  if (availableForKeyAndChild < 4) {
+    addReason(state, "max_result_bytes");
+    return false;
+  }
+  const maximumKeyBytes = availableForKeyAndChild - 2;
+  const keyBytes = jsonStringByteLength(key, maximumKeyBytes);
+  if (keyBytes > maximumKeyBytes) {
+    addReason(state, "max_result_bytes");
+    return false;
+  }
+  const childBudget = availableForKeyAndChild - keyBytes;
+  let rawValue;
+  if ("value" in descriptor) {
+    rawValue = descriptor.value;
+  } else {
+    addReason(state, "accessor_omitted");
+    rawValue = "[Accessor omitted]";
+  }
+  const errorKey = ERROR_SHAPE_KEYS[key.toLowerCase()] === true && hasReportedError(rawValue);
+  if (errorKey) {
+    state.hasErrors = true;
+  }
+  const useSharedRows = key === "rows" || key === "data" && Array.isArray(rawValue);
+  if (key === "eidData") {
+    const prepared = prepareEidData(rawValue, state);
+    const built2 = buildValue(
+      prepared.data,
+      Math.max(2, Math.floor(childBudget / 3)),
+      state,
+      depth + 1,
+      MAX_ENTITLEMENT_EIDS,
+      false
     );
-    const metadata = arrayMetadata(value);
-    if (Object.keys(metadata).length === 0) {
-      return rows;
-    }
-    const output = { rows };
-    for (const [key, entry] of Object.entries(metadata)) {
-      if (key === "eidData") {
-        const limited = limitEidData(entry, maxStringChars, state, depth + 1, seen);
-        output.eidData = limited.data;
-        if (limited.truncation !== void 0) {
-          output.eidDataTruncation = limited.truncation;
+    if (built2 === OMIT || !appendBuiltProperty(accumulator, key, built2, maximumJsonBytes, state)) {
+      return false;
+    }
+    const emittedTruncation = emittedEidTruncation(source, built2.value, prepared);
+    if (emittedTruncation !== void 0) {
+      const summaryCommaBytes = accumulator.propertyCount === 0 ? 0 : 1;
+      const summaryKeyBytes = jsonStringByteLength("eidDataTruncation");
+      const summaryBudget = maximumJsonBytes - accumulator.byteLength - summaryCommaBytes - summaryKeyBytes - 1;
+      const summary = buildValue(
+        emittedTruncation,
+        summaryBudget,
+        state,
+        depth + 1,
+        MAX_EID_SECURITIES,
+        false
+      );
+      if (summary === OMIT || !appendBuiltProperty(accumulator, "eidDataTruncation", summary, maximumJsonBytes, state)) {
+        state.omittedPropertiesAtLeast += 1;
+      }
+    }
+    return true;
+  }
+  const built = buildValue(rawValue, childBudget, state, depth + 1, rowLimit, useSharedRows);
+  if (built === OMIT || !appendBuiltProperty(accumulator, key, built, maximumJsonBytes, state)) {
+    return false;
+  }
+  if (errorKey) {
+    rememberErrorDiagnostic(state, key, built.value);
+  }
+  if ((key === "truncated" || key === "truncatedInput") && rawValue === true) {
+    addReason(state, "upstream_truncation");
+  }
+  return true;
+}
+function hasArrayMetadata(value) {
+  for (const key of PRIORITY_KEYS) {
+    if (ownEnumerableDescriptor(value, key) !== void 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildArrayRows(value, maximumJsonBytes, state, depth, rowLimit, useSharedRows) {
+  if (maximumJsonBytes < 2) {
+    addReason(state, "max_result_bytes");
+    return OMIT;
+  }
+  state.retainedNodes += 1;
+  const output = [];
+  let byteLength = 2;
+  let processedRows = 0;
+  const retainedLength = Math.min(
+    value.length,
+    rowLimit,
+    useSharedRows ? state.remainingRows : Number.MAX_SAFE_INTEGER
+  );
+  for (let index = 0; index < retainedLength; index += 1) {
+    const commaBytes = index === 0 ? 0 : 1;
+    const childBudget = maximumJsonBytes - byteLength - commaBytes;
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    let entry = null;
+    if (descriptor !== void 0 && "value" in descriptor) {
+      entry = descriptor.value;
+    } else if (descriptor !== void 0) {
+      addReason(state, "accessor_omitted");
+      entry = "[Accessor omitted]";
+    }
+    const built = buildValue(entry, childBudget, state, depth + 1, rowLimit, false);
+    if (built === OMIT) {
+      break;
+    }
+    output.push(built.value);
+    byteLength += commaBytes + built.byteLength;
+    processedRows = index + 1;
+  }
+  if (useSharedRows) {
+    state.maximumArrayRows = Math.max(state.maximumArrayRows, processedRows);
+  }
+  if (useSharedRows) {
+    state.remainingRows -= processedRows;
+    state.retainedRows += processedRows;
+  }
+  if (retainedLength < value.length) {
+    addReason(state, "max_rows");
+  }
+  if (processedRows < value.length) {
+    state.omittedRows += value.length - processedRows;
+  }
+  return { byteLength, value: output };
+}
+function buildArray(value, maximumJsonBytes, state, depth, rowLimit, useSharedRows) {
+  if (state.ancestors.has(value)) {
+    return buildUnsupported("[Circular]", maximumJsonBytes, state, "circular_reference");
+  }
+  state.ancestors.add(value);
+  try {
+    if (!hasArrayMetadata(value)) {
+      return buildArrayRows(value, maximumJsonBytes, state, depth, rowLimit, useSharedRows);
+    }
+    if (maximumJsonBytes < 2) {
+      addReason(state, "max_result_bytes");
+      return OMIT;
+    }
+    state.retainedNodes += 1;
+    const accumulator = {
+      byteLength: 2,
+      propertyCount: 0,
+      value: /* @__PURE__ */ Object.create(null)
+    };
+    for (const key of PRIORITY_KEYS) {
+      const isErrorMetadata = key === "diagnostics" || ERROR_SHAPE_KEYS[key.toLowerCase()] === true;
+      if (state.rowsBeforeMetadata && !isErrorMetadata) {
+        continue;
+      }
+      if (!buildProperty(value, key, accumulator, maximumJsonBytes, state, depth, rowLimit)) {
+        state.omittedPropertiesAtLeast += 1;
+      }
+    }
+    const commaBytes = accumulator.propertyCount === 0 ? 0 : 1;
+    const rowsKeyBytes = jsonStringByteLength("rows");
+    const rowsBudget = maximumJsonBytes - accumulator.byteLength - commaBytes - rowsKeyBytes - 1;
+    const rows = consumeVisit(state) ? buildArrayRows(value, rowsBudget, state, depth + 1, rowLimit, useSharedRows) : OMIT;
+    if (rows === OMIT) {
+      state.omittedRows += value.length;
+      state.omittedPropertiesAtLeast += 1;
+    } else if (!appendBuiltProperty(accumulator, "rows", rows, maximumJsonBytes, state)) {
+      state.omittedRows += Math.min(value.length, rowLimit);
+      state.omittedPropertiesAtLeast += 1;
+    }
+    if (state.rowsBeforeMetadata) {
+      for (const key of PRIORITY_KEYS) {
+        if (key === "diagnostics" || ERROR_SHAPE_KEYS[key.toLowerCase()] === true) {
+          continue;
+        }
+        if (!buildProperty(value, key, accumulator, maximumJsonBytes, state, depth, rowLimit)) {
+          state.omittedPropertiesAtLeast += 1;
         }
+      }
+    }
+    return { byteLength: accumulator.byteLength, value: accumulator.value };
+  } finally {
+    state.ancestors.delete(value);
+  }
+}
+function buildObject(value, maximumJsonBytes, state, depth, rowLimit) {
+  if (state.ancestors.has(value)) {
+    return buildUnsupported("[Circular]", maximumJsonBytes, state, "circular_reference");
+  }
+  if (maximumJsonBytes < 2) {
+    addReason(state, "max_result_bytes");
+    return OMIT;
+  }
+  state.ancestors.add(value);
+  state.retainedNodes += 1;
+  try {
+    const accumulator = {
+      byteLength: 2,
+      propertyCount: 0,
+      value: /* @__PURE__ */ Object.create(null)
+    };
+    const processed = /* @__PURE__ */ new Set();
+    for (const key of PRIORITY_KEYS) {
+      processed.add(key);
+      if (!buildProperty(value, key, accumulator, maximumJsonBytes, state, depth, rowLimit)) {
+        state.omittedPropertiesAtLeast += 1;
+      }
+    }
+    for (const key in value) {
+      if (!Object.hasOwn(value, key) || processed.has(key)) {
         continue;
       }
-      output[key] = limitValue(entry, maxRows, maxStringChars, state, depth + 1, seen);
+      if (!buildProperty(value, key, accumulator, maximumJsonBytes, state, depth, rowLimit)) {
+        state.omittedPropertiesAtLeast += 1;
+        break;
+      }
     }
-    return output;
+    return { byteLength: accumulator.byteLength, value: accumulator.value };
+  } finally {
+    state.ancestors.delete(value);
   }
-  if (typeof value === "object" && value !== null) {
-    if (seen.has(value)) {
-      state.truncated = true;
-      return "[Circular]";
-    }
-    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
-      state.truncated = true;
-      return `[binary data: ${value.byteLength} bytes]`;
-    }
-    if (!isPlainObject(value)) {
-      const toJSON = value.toJSON;
-      if (typeof toJSON === "function") {
-        seen.add(value);
-        return limitValue(toJSON.call(value), maxRows, maxStringChars, state, depth + 1, seen);
+}
+function errorRecord(error) {
+  const record3 = {
+    message: error.message,
+    name: error.name
+  };
+  if (error.cause !== void 0) {
+    record3.cause = error.cause;
+  }
+  return record3;
+}
+var ACCESSOR_METHOD = /* @__PURE__ */ Symbol("accessor_method");
+function isCallable(value) {
+  return typeof value === "function";
+}
+function dataMethod(value, name) {
+  let current = value;
+  try {
+    for (let depth = 0; current !== null && depth <= MAX_RESULT_DEPTH; depth += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (descriptor !== void 0) {
+        if (!("value" in descriptor)) {
+          return ACCESSOR_METHOD;
+        }
+        const method = descriptor.value;
+        return isCallable(method) ? method : void 0;
       }
-      return value;
+      current = Object.getPrototypeOf(current);
     }
-    seen.add(value);
-    const output = {};
-    for (const [key, entry] of Object.entries(value)) {
-      output[key] = limitValue(entry, maxRows, maxStringChars, state, depth + 1, seen);
+  } catch {
+    return ACCESSOR_METHOD;
+  }
+  return void 0;
+}
+function buildValue(value, maximumJsonBytes, state, depth, rowLimit, useSharedRows) {
+  if (!consumeVisit(state)) {
+    return OMIT;
+  }
+  if (depth > MAX_RESULT_DEPTH) {
+    return buildUnsupported(
+      "[Max result depth exceeded]",
+      maximumJsonBytes,
+      state,
+      "max_result_depth"
+    );
+  }
+  if (typeof value === "string") {
+    return fitString(value, maximumJsonBytes, state);
+  }
+  if (typeof value === "bigint") {
+    return fitString(value.toString(), maximumJsonBytes, state);
+  }
+  if (value === null || typeof value === "boolean") {
+    return primitiveBuilt(value, maximumJsonBytes, state);
+  }
+  if (typeof value === "number") {
+    const jsonValue = Number.isFinite(value) ? value : null;
+    if (jsonValue === null) {
+      addReason(state, "unsupported_value");
     }
-    return output;
+    return primitiveBuilt(jsonValue, maximumJsonBytes, state);
+  }
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+    addReason(state, "unsupported_value");
+    return primitiveBuilt(null, maximumJsonBytes, state);
+  }
+  if (value instanceof Date) {
+    const milliseconds = value.getTime();
+    if (!Number.isFinite(milliseconds)) {
+      addReason(state, "unsupported_value");
+      return fitString("[Invalid Date]", maximumJsonBytes, state);
+    }
+    return fitString(value.toISOString(), maximumJsonBytes, state);
+  }
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    return buildUnsupported(
+      `[binary data: ${String(value.byteLength)} bytes]`,
+      maximumJsonBytes,
+      state,
+      "binary_data"
+    );
+  }
+  if (Array.isArray(value)) {
+    return buildArray(value, maximumJsonBytes, state, depth, rowLimit, useSharedRows);
+  }
+  if (value instanceof Error) {
+    state.hasErrors = true;
+    if (state.ancestors.has(value)) {
+      return buildUnsupported("[Circular]", maximumJsonBytes, state, "circular_reference");
+    }
+    state.ancestors.add(value);
+    try {
+      const built = buildObject(errorRecord(value), maximumJsonBytes, state, depth, rowLimit);
+      if (built !== OMIT) {
+        rememberErrorDiagnostic(state, "error", built.value);
+      }
+      return built;
+    } finally {
+      state.ancestors.delete(value);
+    }
+  }
+  let plainObject;
+  try {
+    plainObject = isPlainObject(value) ? value : void 0;
+  } catch {
+    return buildUnsupported("[Uninspectable object]", maximumJsonBytes, state);
+  }
+  if (plainObject !== void 0) {
+    return buildObject(plainObject, maximumJsonBytes, state, depth, rowLimit);
+  }
+  const toJSON = dataMethod(value, "toJSON");
+  if (toJSON === ACCESSOR_METHOD) {
+    return buildUnsupported("[Accessor omitted]", maximumJsonBytes, state, "accessor_omitted");
+  }
+  if (toJSON === void 0) {
+    return buildUnsupported("[Unsupported object]", maximumJsonBytes, state);
+  }
+  if (state.ancestors.has(value)) {
+    return buildUnsupported("[Circular]", maximumJsonBytes, state, "circular_reference");
+  }
+  state.ancestors.add(value);
+  try {
+    let converted;
+    try {
+      converted = toJSON.call(value);
+    } catch (error) {
+      state.hasErrors = true;
+      addReason(state, "unsupported_value");
+      converted = {
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+          name: "toJSON"
+        }
+      };
+    }
+    return buildValue(converted, maximumJsonBytes, state, depth + 1, rowLimit, useSharedRows);
+  } finally {
+    state.ancestors.delete(value);
   }
-  return value;
 }
 function rowCountOf(value) {
   if (Array.isArray(value)) {
@@ -362,104 +1082,339 @@ function rowCountOf(value) {
     return null;
   }
   const record3 = value;
-  const rowCount = record3.rowCount;
-  if (typeof rowCount === "number" && Number.isInteger(rowCount) && rowCount >= 0) {
-    return rowCount;
-  }
-  const updateCount = record3.updateCount;
-  if (typeof updateCount === "number" && Number.isInteger(updateCount) && updateCount >= 0) {
-    return updateCount;
+  for (const key of ["rowCount", "updateCount"]) {
+    const descriptor = ownEnumerableDescriptor(record3, key);
+    if (descriptor !== void 0 && "value" in descriptor && typeof descriptor.value === "number" && Number.isSafeInteger(descriptor.value) && descriptor.value >= 0) {
+      return descriptor.value;
+    }
   }
   return null;
 }
-var ERROR_SHAPE_KEYS = /* @__PURE__ */ new Set([
-  "error",
-  "errors",
-  "fielderrors",
-  "fieldexception",
-  "fieldexceptions",
-  "responseerror",
-  "securityerror"
-]);
-function hasErrorShape(value) {
-  const pending = [value];
-  const seen = /* @__PURE__ */ new WeakSet();
-  while (pending.length > 0) {
-    const entry = pending.pop();
-    if (typeof entry !== "object" || entry === null) {
-      continue;
-    }
-    if (seen.has(entry)) {
-      continue;
-    }
-    seen.add(entry);
-    if (Array.isArray(entry)) {
-      for (const child of entry) {
-        pending.push(child);
-      }
-      continue;
-    }
-    for (const [key, child] of Object.entries(entry)) {
-      if (ERROR_SHAPE_KEYS.has(key.toLowerCase()) && child !== void 0) {
-        return true;
-      }
-      pending.push(child);
+function truncationSummary(state) {
+  if (state.reasons.size === 0) {
+    return void 0;
+  }
+  return {
+    reasons: TRUNCATION_REASON_ORDER.filter((reason) => state.reasons.has(reason)),
+    inspectedNodes: state.visitedNodes,
+    retainedNodes: state.retainedNodes,
+    ...state.omittedPropertiesAtLeast === 0 ? {} : { omittedPropertiesAtLeast: state.omittedPropertiesAtLeast },
+    ...state.omittedRows === 0 ? {} : { omittedRows: state.omittedRows }
+  };
+}
+function validateResultLimits(limits) {
+  for (const name of ["maxResultBytes", "maxResultNodes", "maxRows", "maxStringChars"]) {
+    const value = limits[name];
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new RangeError(`${name} must be a positive safe integer; got ${String(value)}`);
     }
   }
-  return false;
+  if (limits.maxResultBytes < 4) {
+    throw new RangeError(`maxResultBytes must be at least 4; got ${String(limits.maxResultBytes)}`);
+  }
 }
-function limitResult(value, maxRows, maxStringChars) {
-  const state = { truncated: false };
+function limitResultWithRowPriority(value, limits, rowsBeforeMetadata) {
+  validateResultLimits(limits);
+  const state = {
+    ancestors: /* @__PURE__ */ new WeakSet(),
+    diagnostics: [],
+    hasErrors: false,
+    maximumArrayRows: 0,
+    limits,
+    omittedPropertiesAtLeast: 0,
+    omittedRows: 0,
+    remainingRows: limits.maxRows,
+    reasons: /* @__PURE__ */ new Set(),
+    retainedNodes: 0,
+    retainedRows: 0,
+    rowsBeforeMetadata,
+    visitedNodes: 0
+  };
   const rowCount = rowCountOf(value);
-  const limitedValue = limitValue(value, maxRows, maxStringChars, state);
+  const built = buildValue(value, limits.maxResultBytes, state, 0, limits.maxRows, true);
+  const result = built === OMIT ? { byteLength: 4, value: null } : built;
+  if (built === OMIT) {
+    addReason(state, "max_result_bytes");
+  }
+  const truncation = truncationSummary(state);
   return {
+    byteLength: result.byteLength,
+    errorDiagnostics: state.diagnostics,
+    inspectedNodes: state.visitedNodes,
+    maximumArrayRows: state.maximumArrayRows,
+    retainedRows: state.retainedRows,
+    hasErrors: state.hasErrors,
     rowCount,
-    truncated: state.truncated,
-    value: limitedValue
+    truncated: truncation !== void 0,
+    ...truncation === void 0 ? {} : { truncation },
+    value: result.value
+  };
+}
+function artifactEnvelope(tool2, limited, truncation) {
+  return {
+    tool: tool2,
+    rowCount: limited.rowCount,
+    truncated: limited.truncated,
+    ...truncation === void 0 ? {} : { truncation },
+    ...limited.hasErrors ? { hasErrors: true } : {},
+    data: limited.value
+  };
+}
+function boundedJsonByteLength(value) {
+  return UTF8_ENCODER.encode(JSON.stringify(value)).byteLength;
+}
+function mergeLimited(first, second) {
+  const reasons = new Set(first.truncation?.reasons ?? []);
+  for (const reason of second.truncation?.reasons ?? []) {
+    reasons.add(reason);
+  }
+  const retainedNodes = second.truncation?.retainedNodes ?? first.truncation?.retainedNodes;
+  const omittedPropertiesAtLeast = (first.truncation?.omittedPropertiesAtLeast ?? 0) + (second.truncation?.omittedPropertiesAtLeast ?? 0);
+  const omittedRows = (first.truncation?.omittedRows ?? 0) + (second.truncation?.omittedRows ?? 0);
+  const truncation = reasons.size === 0 ? void 0 : {
+    reasons: TRUNCATION_REASON_ORDER.filter((reason) => reasons.has(reason)),
+    inspectedNodes: first.inspectedNodes + second.inspectedNodes,
+    ...retainedNodes === void 0 ? {} : { retainedNodes },
+    ...omittedPropertiesAtLeast === 0 ? {} : { omittedPropertiesAtLeast },
+    ...omittedRows === 0 ? {} : { omittedRows }
+  };
+  return {
+    byteLength: second.byteLength,
+    maximumArrayRows: second.maximumArrayRows,
+    retainedRows: second.retainedRows,
+    errorDiagnostics: second.errorDiagnostics.length === 0 ? first.errorDiagnostics : second.errorDiagnostics,
+    hasErrors: first.hasErrors || second.hasErrors,
+    inspectedNodes: first.inspectedNodes + second.inspectedNodes,
+    rowCount: first.rowCount,
+    truncated: truncation !== void 0,
+    ...truncation === void 0 ? {} : { truncation },
+    value: second.value
+  };
+}
+function fitArtifact(tool2, limited, maxResultBytes) {
+  let envelope = artifactEnvelope(tool2, limited, limited.truncation);
+  if (boundedJsonByteLength(envelope) <= maxResultBytes) {
+    return envelope;
+  }
+  const fitLimited = limited.truncated ? limited : { ...limited, truncated: true };
+  const reasons = limited.truncation?.reasons ?? ["max_result_bytes"];
+  envelope = artifactEnvelope(tool2, fitLimited, { reasons });
+  if (boundedJsonByteLength(envelope) <= maxResultBytes) {
+    return envelope;
+  }
+  const primaryReason = reasons.find((reason) => reason !== "max_result_bytes") ?? "max_result_bytes";
+  const compactReasons = primaryReason === "max_result_bytes" ? [primaryReason] : [primaryReason, "max_result_bytes"];
+  envelope = artifactEnvelope(tool2, fitLimited, { reasons: compactReasons });
+  if (boundedJsonByteLength(envelope) <= maxResultBytes) {
+    return envelope;
+  }
+  envelope = artifactEnvelope(tool2, fitLimited, {
+    reasons: ["max_result_bytes"]
+  });
+  if (boundedJsonByteLength(envelope) <= maxResultBytes) {
+    return envelope;
+  }
+  return {
+    tool: tool2,
+    rowCount: limited.rowCount,
+    truncated: true,
+    truncation: { reasons: ["max_result_bytes"] },
+    ...limited.hasErrors ? { hasErrors: true } : {},
+    data: null
   };
 }
-function summarizeEnvelope(envelope) {
-  const rowText = envelope.rowCount === null ? "row count unknown" : `${envelope.rowCount} row${envelope.rowCount === 1 ? "" : "s"}`;
+function rowText(rowCount) {
+  return rowCount === null ? "row count unknown" : `${String(rowCount)} row${rowCount === 1 ? "" : "s"}`;
+}
+function summarizeEnvelope(envelope, contentTruncation) {
   const notes = [];
-  if (envelope.rowCount === 0 || envelope.data === null || envelope.data === void 0) {
+  if (envelope.rowCount === 0 || !envelope.truncated && (envelope.data === null || envelope.data === void 0)) {
     notes.push(
       "empty result; verify identifiers, fields, and date range before concluding no data exists"
     );
   }
-  if (envelope.truncated) {
-    notes.push("artifact truncated to configured limits");
-  }
-  if (hasErrorShape(envelope.data)) {
-    notes.push("inspect result payload for Bloomberg error details");
+  if (envelope.hasErrors === true) {
+    notes.push("Bloomberg error diagnostics included in preview");
   }
+  const artifactReasons = envelope.truncation?.reasons.join(",") ?? "none";
+  const contentReasons = contentTruncation?.reasons.join(",") ?? "none";
   const noteText = notes.length === 0 ? "" : `; ${notes.join("; ")}`;
-  return `${envelope.tool}: ${rowText}; truncated=${String(envelope.truncated)}${noteText}`;
-}
-function resultJsonReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  return value;
+  return `${envelope.tool}: ${rowText(envelope.rowCount)}; artifactTruncated=${String(envelope.truncated)}; contentTruncated=${String(contentTruncation !== void 0)}; artifactReasons=${artifactReasons}; contentReasons=${contentReasons}${noteText}`;
 }
-function formatToolContent(envelope) {
-  const payload = {
+function contentPayload(envelope, limited) {
+  const projected = limited.value;
+  return {
     tool: envelope.tool,
     rowCount: envelope.rowCount,
     truncated: envelope.truncated,
-    data: envelope.data
+    contentTruncated: limited.truncated,
+    ...projected ?? { data: null }
   };
-  return `${summarizeEnvelope(envelope)}
-${JSON.stringify(payload, resultJsonReplacer)}`;
 }
-function createToolResult(tool2, value, maxRows, maxStringChars) {
-  const limited = limitResult(value, maxRows, maxStringChars);
-  const envelope = {
-    tool: tool2,
-    rowCount: limited.rowCount,
-    truncated: limited.truncated,
-    data: limited.value
+function formatToolContent(envelope, preview, maxContentBytes) {
+  const firstPreviewValue = preview.value;
+  const summary = summarizeEnvelope(envelope, preview.truncation);
+  const payload = contentPayload(envelope, preview);
+  const content = `${summary}
+${JSON.stringify(payload)}`;
+  if (UTF8_ENCODER.encode(content).byteLength <= maxContentBytes) {
+    return content;
+  }
+  const compactSummary = `${envelope.tool}: ${rowText(envelope.rowCount)}; artifactTruncated=${String(envelope.truncated)}; contentTruncated=${String(preview.truncated)}; hasErrors=${String(envelope.hasErrors === true)}`;
+  const compactContent = `${compactSummary}
+${JSON.stringify(firstPreviewValue)}`;
+  if (UTF8_ENCODER.encode(compactContent).byteLength <= maxContentBytes) {
+    return compactContent;
+  }
+  return compactSummary;
+}
+function exhaustedProjection(rowCount) {
+  return {
+    byteLength: 4,
+    maximumArrayRows: 0,
+    retainedRows: 0,
+    errorDiagnostics: [],
+    hasErrors: false,
+    inspectedNodes: 0,
+    rowCount,
+    truncated: true,
+    truncation: {
+      inspectedNodes: 0,
+      reasons: ["max_result_nodes"],
+      retainedNodes: 0
+    },
+    value: null
+  };
+}
+function projectResult(value, limits, rowsBeforeMetadata) {
+  return limits.maxResultNodes === 0 ? exhaustedProjection(rowCountOf(value)) : limitResultWithRowPriority(value, limits, rowsBeforeMetadata);
+}
+function withAggregateInspection(limited, inspectedNodes) {
+  return {
+    ...limited,
+    inspectedNodes,
+    ...limited.truncation === void 0 ? {} : {
+      truncation: {
+        ...limited.truncation,
+        inspectedNodes
+      }
+    }
   };
-  return [formatToolContent(envelope), envelope];
+}
+function reusedProjection(value, canonical) {
+  return {
+    byteLength: boundedJsonByteLength(value),
+    errorDiagnostics: [],
+    hasErrors: false,
+    inspectedNodes: 0,
+    maximumArrayRows: canonical.maximumArrayRows,
+    retainedRows: canonical.retainedRows,
+    rowCount: rowCountOf(value),
+    truncated: false,
+    value
+  };
+}
+function canReuseProjection(canonical, byteLength, maxBytes, maxRows) {
+  return byteLength <= maxBytes && canonical.maximumArrayRows <= maxRows;
+}
+function createToolResult(tool2, value, limits) {
+  const initialInspectedNodes = limits.materializedNodes ?? 0;
+  if (limits.maxResultBytes < MIN_TOOL_RESULT_BYTES) {
+    throw new RangeError(
+      `maxResultBytes must be at least ${String(MIN_TOOL_RESULT_BYTES)}; got ${String(limits.maxResultBytes)}`
+    );
+  }
+  if (limits.maxContentBytes < MIN_TOOL_RESULT_BYTES) {
+    throw new RangeError(
+      `maxContentBytes must be at least ${String(MIN_TOOL_RESULT_BYTES)}; got ${String(limits.maxContentBytes)}`
+    );
+  }
+  if (limits.maxResultNodes < MIN_TOOL_RESULT_NODES) {
+    throw new RangeError(
+      `maxResultNodes must be at least ${String(MIN_TOOL_RESULT_NODES)}; got ${String(limits.maxResultNodes)}`
+    );
+  }
+  validateResultLimits(limits);
+  if (!Number.isSafeInteger(initialInspectedNodes) || initialInspectedNodes < 0 || initialInspectedNodes > limits.maxResultNodes) {
+    throw new RangeError(
+      `materializedNodes must be between 0 and maxResultNodes; got ${String(initialInspectedNodes)}`
+    );
+  }
+  const availableNodeBudget = limits.maxResultNodes - initialInspectedNodes;
+  const hasEidMetadata = typeof value === "object" && value !== null && ownEnumerableDescriptor(value, "eidData") !== void 0;
+  const canonicalNodeBudget = availableNodeBudget === 0 ? 0 : Math.max(
+    1,
+    hasEidMetadata ? availableNodeBudget - Math.ceil(availableNodeBudget / 5) : Math.floor(availableNodeBudget / 3)
+  );
+  const canonical = projectResult(
+    value,
+    {
+      maxResultBytes: Math.max(limits.maxResultBytes, limits.maxContentBytes),
+      maxResultNodes: canonicalNodeBudget,
+      maxRows: Math.max(limits.maxRows, limits.maxContentRows),
+      maxStringChars: limits.maxStringChars
+    },
+    false
+  );
+  const artifactDataBudget = projectionBudget(limits.maxResultBytes, RESULT_ENVELOPE_RESERVE_BYTES);
+  const contentDataBudget = projectionBudget(
+    limits.maxContentBytes,
+    CONTENT_ENVELOPE_RESERVE_BYTES
+  );
+  const contentSource = /* @__PURE__ */ Object.create(null);
+  if (canonical.errorDiagnostics.length > 0) {
+    contentSource.diagnostics = canonical.errorDiagnostics;
+  }
+  contentSource.data = canonical.value;
+  const contentSourceBytes = boundedJsonByteLength(contentSource);
+  const reuseArtifact = canReuseProjection(
+    canonical,
+    canonical.byteLength,
+    artifactDataBudget,
+    limits.maxRows
+  );
+  const reuseContent = canReuseProjection(
+    canonical,
+    contentSourceBytes,
+    contentDataBudget,
+    limits.maxContentRows
+  );
+  const remainingNodeBudget = Math.max(0, availableNodeBudget - canonical.inspectedNodes);
+  const artifactNeedsNodes = !reuseArtifact;
+  const contentNeedsNodes = !reuseContent;
+  const artifactNodeBudget = artifactNeedsNodes ? contentNeedsNodes ? Math.floor(remainingNodeBudget / 2) : remainingNodeBudget : 0;
+  const contentNodeBudget = contentNeedsNodes ? remainingNodeBudget - artifactNodeBudget : 0;
+  const artifactProjection = reuseArtifact ? reusedProjection(canonical.value, canonical) : projectResult(
+    canonical.value,
+    {
+      maxResultBytes: artifactDataBudget,
+      maxResultNodes: artifactNodeBudget,
+      maxRows: limits.maxRows,
+      maxStringChars: Number.MAX_SAFE_INTEGER
+    },
+    false
+  );
+  const contentProjection = reuseContent ? reusedProjection(contentSource, canonical) : projectResult(
+    contentSource,
+    {
+      maxResultBytes: contentDataBudget,
+      maxResultNodes: contentNodeBudget,
+      maxRows: limits.maxContentRows,
+      maxStringChars: Number.MAX_SAFE_INTEGER
+    },
+    true
+  );
+  const inspectedNodes = initialInspectedNodes + canonical.inspectedNodes + artifactProjection.inspectedNodes + contentProjection.inspectedNodes;
+  const artifactResult = withAggregateInspection(
+    mergeLimited(canonical, artifactProjection),
+    inspectedNodes
+  );
+  const contentResult = withAggregateInspection(
+    mergeLimited(canonical, contentProjection),
+    inspectedNodes
+  );
+  const envelope = fitArtifact(tool2, artifactResult, limits.maxResultBytes);
+  return [formatToolContent(envelope, contentResult, limits.maxContentBytes), envelope];
 }
 function throwWithToolContext(tool2, error) {
   const prefix = `${tool2} failed`;
@@ -475,7 +1430,82 @@ function throwWithToolContext(tool2, error) {
 }
 
 // src/langchain-tool.ts
+var INPUT_JSON_SCHEMA_CACHE = /* @__PURE__ */ new WeakMap();
+function freezeJsonSchema(root) {
+  const pending = [root];
+  const seen = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const value = pending.pop();
+    if (value === void 0 || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    for (const rawChild of Object.values(value)) {
+      const child = rawChild;
+      if (typeof child === "object" && child !== null) {
+        pending.push(child);
+      }
+    }
+    Object.freeze(value);
+  }
+  return root;
+}
+function cloneJsonSchemaValue(value, seen, active) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("JSON Schema numbers must be finite");
+    }
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`JSON Schema contains unsupported ${typeof value} value`);
+  }
+  const cached = seen.get(value);
+  if (cached !== void 0) {
+    if (active.has(value)) {
+      throw new TypeError("JSON Schema must not contain object cycles");
+    }
+    return cached;
+  }
+  const output = Array.isArray(value) ? [] : {};
+  seen.set(value, output);
+  active.add(value);
+  try {
+    for (const key of Object.keys(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !("value" in descriptor)) {
+        throw new TypeError(`JSON Schema property ${key} must not be an accessor`);
+      }
+      Object.defineProperty(output, key, {
+        configurable: true,
+        enumerable: true,
+        value: cloneJsonSchemaValue(descriptor.value, seen, active),
+        writable: true
+      });
+    }
+  } finally {
+    active.delete(value);
+  }
+  return output;
+}
+function cachedRawJsonSchema(schema) {
+  const cached = INPUT_JSON_SCHEMA_CACHE.get(schema);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const clone = cloneJsonSchemaValue(schema, /* @__PURE__ */ new WeakMap(), /* @__PURE__ */ new WeakSet());
+  const immutable = freezeJsonSchema(clone);
+  INPUT_JSON_SCHEMA_CACHE.set(schema, immutable);
+  return immutable;
+}
 function inputJsonSchema(schema) {
+  const cached = INPUT_JSON_SCHEMA_CACHE.get(schema);
+  if (cached !== void 0) {
+    return cached;
+  }
   const jsonSchema = zodToJsonSchema.zodToJsonSchema(schema, {
     $refStrategy: "none",
     effectStrategy: "input",
@@ -483,12 +1513,14 @@ function inputJsonSchema(schema) {
   });
   delete jsonSchema.$schema;
   delete jsonSchema.definitions;
-  return jsonSchema;
+  const immutable = freezeJsonSchema(jsonSchema);
+  INPUT_JSON_SCHEMA_CACHE.set(schema, immutable);
+  return immutable;
 }
 function toolParameterJsonSchema(toolInstance) {
   const schema = toolInstance.schema;
   if (schema !== null && typeof schema === "object" && !("safeParse" in schema)) {
-    return schema;
+    return cachedRawJsonSchema(schema);
   }
   return inputJsonSchema(schema);
 }
@@ -1347,7 +2379,7 @@ function chartSpecSchema(options) {
 
 // src/ext-tools.ts
 function resultString(resolver, name, value) {
-  return createToolResult(name, value, resolver.options.maxRows, resolver.options.maxStringChars);
+  return createToolResult(name, value, resolver.options);
 }
 function recoveryOverrides(recoveryRate) {
   return recoveryRate === void 0 ? void 0 : { CDS_RR: recoveryRate };
@@ -1821,8 +2853,8 @@ var OVERFLOW_POLICIES = ["block", "drop_newest"];
 var OVERFLOW_POLICY_DEFAULT = "drop_newest";
 var OVERFLOW_POLICY_VALUES = "block, drop_newest";
 var OVERFLOW_POLICY_DOCS = {
-  block: "Retry within a short bounded window on Bloomberg's callback thread, then flag a slow consumer and drop the update.",
-  drop_newest: "Drop the newest update as soon as the buffer is full; never stalls Bloomberg's callback thread."
+  block: "Wait briefly on a bounded forwarding task, never on Bloomberg's callback thread; queue overflow or timeout closes with a data-loss error. Resubscribe for a fresh image.",
+  drop_newest: "Close with a data-loss error when the consumer buffer is full; never waits on Bloomberg's callback thread. Resubscribe for a fresh image."
 };
 
 // src/schemas.ts
@@ -2543,7 +3575,7 @@ function createDepthSnapshotSchema(options) {
 
 // src/tools.ts
 function resultString2(resolver, name, value) {
-  return createToolResult(name, value, resolver.options.maxRows, resolver.options.maxStringChars);
+  return createToolResult(name, value, resolver.options);
 }
 var STREAM_TIMEOUT = /* @__PURE__ */ Symbol("stream_timeout");
 var STREAM_ABORTED = /* @__PURE__ */ Symbol("stream_aborted");
@@ -2567,57 +3599,48 @@ function singleTickerStreamOptions(input) {
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
-function rowsFromArrowTable(value) {
+function truncatedArrowRows(rows, rowCount) {
+  return {
+    rows,
+    rowCount,
+    truncated: true,
+    truncation: {
+      omittedRowsAtLeast: rowCount - rows.length,
+      reason: "max_rows"
+    }
+  };
+}
+function rowsFromArrowTable(value, maxRows) {
   if (!isRecord(value)) {
     return void 0;
   }
-  const toArray = value.toArray;
-  if (typeof toArray === "function") {
-    return Array.from(toArray.call(value));
-  }
   const numRows = value.numRows;
   const get = value.get;
-  if (typeof numRows === "number" && Number.isInteger(numRows) && typeof get === "function") {
+  if (typeof numRows === "number" && Number.isSafeInteger(numRows) && numRows >= 0 && typeof get === "function") {
+    const retainedRows = Math.min(numRows, maxRows);
     const rows = [];
-    for (let index = 0; index < numRows; index += 1) {
+    for (let index = 0; index < retainedRows; index += 1) {
       rows.push(get.call(value, index));
     }
-    return rows;
+    return {
+      materializedRows: retainedRows,
+      value: retainedRows === numRows ? rows : truncatedArrowRows(rows, numRows)
+    };
   }
   return void 0;
 }
-function jsonCompatible(value) {
-  if (typeof value === "bigint") {
-    return value.toString();
+function normalizeStreamUpdate(value, maxRows) {
+  const arrowRows = rowsFromArrowTable(value, maxRows);
+  if (arrowRows !== void 0) {
+    return arrowRows;
   }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (Array.isArray(value)) {
-    return value.map(jsonCompatible);
-  }
-  if (!isRecord(value)) {
-    return value;
-  }
-  const toJSON = value.toJSON;
-  if (typeof toJSON === "function") {
-    return jsonCompatible(toJSON.call(value));
-  }
-  const output = {};
-  for (const [key, entry] of Object.entries(value)) {
-    output[key] = jsonCompatible(entry);
-  }
-  return output;
-}
-function normalizeStreamUpdate(value) {
   if (isRecord(value)) {
     const toObject = value.toObject;
     if (typeof toObject === "function") {
-      return jsonCompatible(toObject.call(value));
+      return { materializedRows: 0, value: toObject.call(value) };
     }
   }
-  const rows = rowsFromArrowTable(value);
-  return rows === void 0 ? jsonCompatible(value) : rows.map(jsonCompatible);
+  return { materializedRows: 0, value };
 }
 async function nextWithinTimeout(iterator, deadlineMs, signal) {
   if (signal?.aborted === true) {
@@ -2656,9 +3679,11 @@ async function nextWithinTimeout(iterator, deadlineMs, signal) {
   }
   return result;
 }
-async function collectSnapshot(subscription, input, signal) {
+async function collectSnapshot(subscription, input, signal, maxRows, maxResultNodes) {
   const updates = [];
   const deadlineMs = Date.now() + input.timeoutMs;
+  const arrowRowAllowance = Math.min(maxRows, Math.floor(maxResultNodes / 3));
+  let remainingArrowRows = arrowRowAllowance;
   let reason = "max_updates";
   let failed = false;
   let caught;
@@ -2676,7 +3701,9 @@ async function collectSnapshot(subscription, input, signal) {
         reason = "done";
         break;
       }
-      updates.push(normalizeStreamUpdate(next.value));
+      const normalized = normalizeStreamUpdate(next.value, remainingArrowRows);
+      updates.push(normalized.value);
+      remainingArrowRows -= normalized.materializedRows;
     }
   } catch (error) {
     failed = true;
@@ -2695,12 +3722,15 @@ async function collectSnapshot(subscription, input, signal) {
     throw caught;
   }
   return {
-    maxUpdates: input.maxUpdates,
-    reason,
-    timeoutMs: input.timeoutMs,
-    updateCount: updates.length,
-    updates,
-    ...unsubscribeError === void 0 ? {} : { unsubscribeError }
+    materializedRows: arrowRowAllowance - remainingArrowRows,
+    result: {
+      maxUpdates: input.maxUpdates,
+      reason,
+      timeoutMs: input.timeoutMs,
+      updateCount: updates.length,
+      updates,
+      ...unsubscribeError === void 0 ? {} : { unsubscribeError }
+    }
   };
 }
 function validationSetting(resolver, value) {
@@ -2865,12 +3895,10 @@ function checkEntitlementsWithResolver(resolver) {
       try {
         const engine = await resolver.getEngine();
         const result = await engine.checkEntitlements(input.service ?? "//blp/refdata", input.eids);
-        return createToolResult(
-          name,
-          result,
-          MAX_ENTITLEMENT_EIDS,
-          resolver.options.maxStringChars
-        );
+        return createToolResult(name, result, {
+          ...resolver.options,
+          maxRows: MAX_ENTITLEMENT_EIDS
+        });
       } catch (error) {
         throwWithToolContext(name, error);
       }
@@ -3180,8 +4208,17 @@ function streamSnapshotWithResolver(resolver) {
         const engine = await resolver.getEngine();
         signal?.throwIfAborted();
         const subscription = await engine.stream(input.tickers, input.fields, streamOptions(input));
-        const result = await collectSnapshot(subscription, input, signal);
-        return resultString2(resolver, name, result);
+        const snapshot = await collectSnapshot(
+          subscription,
+          input,
+          signal,
+          Math.max(resolver.options.maxRows, resolver.options.maxContentRows),
+          resolver.options.maxResultNodes
+        );
+        return createToolResult(name, snapshot.result, {
+          ...resolver.options,
+          materializedNodes: snapshot.materializedRows
+        });
       } catch (error) {
         throwWithToolContext(name, error);
       }
@@ -3203,8 +4240,17 @@ function mktbarSnapshotWithResolver(resolver) {
         const engine = await resolver.getEngine();
         signal?.throwIfAborted();
         const subscription = await engine.mktbar(input.ticker, singleTickerStreamOptions(input));
-        const result = await collectSnapshot(subscription, input, signal);
-        return resultString2(resolver, name, result);
+        const snapshot = await collectSnapshot(
+          subscription,
+          input,
+          signal,
+          Math.max(resolver.options.maxRows, resolver.options.maxContentRows),
+          resolver.options.maxResultNodes
+        );
+        return createToolResult(name, snapshot.result, {
+          ...resolver.options,
+          materializedNodes: snapshot.materializedRows
+        });
       } catch (error) {
         throwWithToolContext(name, error);
       }
@@ -3226,8 +4272,17 @@ function depthSnapshotWithResolver(resolver) {
         const engine = await resolver.getEngine();
         signal?.throwIfAborted();
         const subscription = await engine.depth(input.ticker, singleTickerStreamOptions(input));
-        const result = await collectSnapshot(subscription, input, signal);
-        return resultString2(resolver, name, result);
+        const snapshot = await collectSnapshot(
+          subscription,
+          input,
+          signal,
+          Math.max(resolver.options.maxRows, resolver.options.maxContentRows),
+          resolver.options.maxResultNodes
+        );
+        return createToolResult(name, snapshot.result, {
+          ...resolver.options,
+          materializedNodes: snapshot.materializedRows
+        });
       } catch (error) {
         throwWithToolContext(name, error);
       }