@logbrew/sdk 0.1.9 → 0.1.10

package/README.md

@@ -102,7 +102,7 @@ npx logbrew-release-artifacts upload-js \
 
 Non-loopback endpoints require `--allow-hosted`, a UUID `projectId` created by `manifest-js --project-id`, HTTPS, and no embedded auth values, query strings, or fragments. Local loopback preparation remains valid without a project ID. The upload command never uses normal SDK ingest keys or account/session API auth values. Full backend-symbolicated issue support is separate from artifact upload until your project has completed hosted symbolication for its release.
 
-When you capture a JavaScript error, use `createIssueAttributesFromError()` to keep error metadata structured and source-map-friendly without sending raw stack text by default. Pass a Debug ID map from your app-owned build setup when you want the issue event to carry release-artifact metadata:
+When you capture a JavaScript error, use `createIssueAttributesFromError()` to keep error metadata structured and source-map-friendly without sending raw stack text by default. The helper also follows `Error.cause` and `AggregateError.errors` into a bounded parent-first exception graph. Automatic messages are marked redacted, every node reports whether frames were captured, truncated, or unavailable, and unsafe accessors, cycles, or the eight-node cap mark the graph truncated instead of inventing evidence. React, browser, Node, Next.js, and React Native helpers reuse this same core projection. See the shared [exception-chain contract](../../docs/exception-chain-evidence.md). Pass a Debug ID map from your app-owned build setup when you want the issue event to carry release-artifact metadata:
 
 ```js
 import { createIssueAttributesFromError, LogBrewClient } from "@logbrew/sdk";

package/core.cjs

@@ -129,14 +129,17 @@ const {
   traceMetadataFromLogContext
 } = buildLogContextHelpers({ SdkError });
 
-const { javascriptStackFrames, validateIssueStackFrames } = buildIssueStackHelpers({ SdkError });
+const {
+  javascriptStackEvidence,
+  validateIssueStackFrames
+} = buildIssueStackHelpers({ SdkError });
 const {
   MAX_ISSUE_BREADCRUMBS,
   cloneIssueDiagnostics,
   createIssueException,
   validateIssueBreadcrumb,
   validateIssueDiagnostics
-} = buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp });
+} = buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp, validateIssueStackFrames });
 const {
   cloneTelemetryContext,
   mergeTelemetryContexts,
@@ -1363,7 +1366,8 @@ function createIssueAttributesFromError(error, options = {}) {
     throw new SdkError("validation_error", "error issue options must be an object");
   }
   const details = errorDetails(error);
-  const stackFrames = javascriptStackFrames(details.stack, options.debugIdMap);
+  const stackEvidence = javascriptStackEvidence(details.stack, options.debugIdMap);
+  const stackFrames = stackEvidence.frames;
   const frame = stackFrames[0] ?? null;
   const source = stringOrUndefined(options.source) ?? "javascript.error";
   const metadata = {
@@ -1388,33 +1392,151 @@ function createIssueAttributesFromError(error, options = {}) {
     ...(options.includeErrorStack === true && details.stack ? { errorStack: details.stack } : {})
   };
 
+  const exception = createIssueException(
+    boundedIssueExceptionType(details.name),
+    stringOrUndefined(options.mechanism) ?? "javascript.error",
+    options.handled === undefined ? true : options.handled
+  );
+  const exceptionChain = createJavaScriptExceptionChain(error, {
+    details,
+    exception,
+    stackEvidence,
+    debugIdMap: options.debugIdMap
+  });
   return {
     title: stringOrUndefined(options.title) ?? details.name,
     level: normalizeSeverity("issue level", options.level ?? "error"),
     ...(stringOrUndefined(options.message) ? { message: options.message } : details.message ? { message: details.message } : {}),
-    exception: createIssueException(
-      boundedIssueExceptionType(details.name),
-      stringOrUndefined(options.mechanism) ?? "javascript.error",
-      options.handled === undefined ? true : options.handled
-    ),
+    exception,
+    exceptionChain,
     ...(stackFrames.length > 0 ? { stackFrames } : {}),
     metadata: compactMetadata(metadata)
   };
 }
 
+function createJavaScriptExceptionChain(error, root) {
+  const state = {
+    entries: [],
+    seen: new Set(),
+    truncated: false,
+    debugIdMap: root.debugIdMap
+  };
+  if (isObjectLike(error)) {
+    state.seen.add(error);
+  }
+  appendJavaScriptExceptionNode(error, undefined, "reported", state, root);
+  collectJavaScriptExceptionChildren(error, 0, state);
+  return { entries: state.entries, truncated: state.truncated };
+}
+
+function appendJavaScriptExceptionNode(value, parentId, relationship, state, known = undefined) {
+  if (state.entries.length >= 8) {
+    state.truncated = true;
+    return undefined;
+  }
+  const details = known?.details ?? errorDetails(value);
+  const stackEvidence = known?.stackEvidence
+    ?? javascriptStackEvidence(details.stack, state.debugIdMap);
+  const mechanism = known?.exception?.mechanism ?? {
+    type: relationship === "aggregate_member" ? "javascript.aggregate_member" : "javascript.cause",
+    handled: true
+  };
+  const messageEvidence = exceptionMessageEvidence(details.message);
+  const id = state.entries.length;
+  state.entries.push({
+    id,
+    ...(parentId === undefined ? {} : { parentId }),
+    relationship,
+    type: known?.exception?.type ?? errorCauseType(value),
+    ...messageEvidence,
+    mechanism,
+    ...(stackEvidence.frames.length === 0 ? {} : { stackFrames: stackEvidence.frames }),
+    stackFramesState: stackEvidence.frames.length === 0
+      ? "not_captured"
+      : stackEvidence.truncated
+        ? "truncated"
+        : "captured"
+  });
+  return id;
+}
+
+function collectJavaScriptExceptionChildren(value, parentId, state) {
+  if (!isObjectLike(value)) {
+    return;
+  }
+  const cause = safeProperty(value, "cause");
+  if (cause.available && cause.value !== undefined && cause.value !== null) {
+    collectJavaScriptExceptionChild(cause.value, parentId, "cause", state);
+  } else if (!cause.available) {
+    state.truncated = true;
+  }
+  const errors = safeProperty(value, "errors");
+  if (!errors.available) {
+    state.truncated = true;
+  } else if (Array.isArray(errors.value)) {
+    for (const child of errors.value) {
+      collectJavaScriptExceptionChild(child, parentId, "aggregate_member", state);
+    }
+  }
+}
+
+function collectJavaScriptExceptionChild(value, parentId, relationship, state) {
+  if (state.entries.length >= 8) {
+    state.truncated = true;
+    return;
+  }
+  if (isObjectLike(value)) {
+    if (state.seen.has(value)) {
+      state.truncated = true;
+      return;
+    }
+    state.seen.add(value);
+  }
+  const id = appendJavaScriptExceptionNode(value, parentId, relationship, state);
+  if (id !== undefined) {
+    collectJavaScriptExceptionChildren(value, id, state);
+  }
+}
+
+function exceptionMessageEvidence(value) {
+  if (typeof value !== "string") {
+    return { messageState: "not_captured" };
+  }
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  if (normalized === "") {
+    return { messageState: "not_captured" };
+  }
+  return { messageState: "redacted" };
+}
+
 function errorDetails(error) {
   if (error instanceof Error) {
+    const name = safeProperty(error, "name");
+    const message = safeProperty(error, "message");
+    const stack = safeProperty(error, "stack");
     return {
-      name: stringOrUndefined(error.name) ?? "Error",
-      message: stringOrUndefined(error.message),
-      stack: typeof error.stack === "string" && error.stack.trim() !== "" ? error.stack : undefined
+      name: name.available ? stringOrUndefined(name.value) ?? "Error" : "Error",
+      message: message.available ? stringOrUndefined(message.value) : undefined,
+      stack: stack.available && typeof stack.value === "string" && stack.value.trim() !== ""
+        ? stack.value
+        : undefined
     };
   }
   if (error && typeof error === "object") {
-    const name = typeof error.name === "string" && error.name.trim() !== "" ? error.name : "Error";
-    const message = typeof error.message === "string" && error.message.trim() !== "" ? error.message : undefined;
-    const stack = typeof error.stack === "string" && error.stack.trim() !== "" ? error.stack : undefined;
-    return { name, message, stack };
+    const name = safeProperty(error, "name");
+    const message = safeProperty(error, "message");
+    const stack = safeProperty(error, "stack");
+    return {
+      name: name.available && typeof name.value === "string" && name.value.trim() !== ""
+        ? name.value
+        : "Error",
+      message: message.available && typeof message.value === "string" && message.value.trim() !== ""
+        ? message.value
+        : undefined,
+      stack: stack.available && typeof stack.value === "string" && stack.value.trim() !== ""
+        ? stack.value
+        : undefined
+    };
   }
   if (typeof error === "string" && error.trim() !== "") {
     return { name: "Error", message: error };
@@ -1422,6 +1544,14 @@ function errorDetails(error) {
   return { name: "Error" };
 }
 
+function safeProperty(value, name) {
+  try {
+    return { available: true, value: value[name] };
+  } catch {
+    return { available: false, value: undefined };
+  }
+}
+
 function boundedIssueExceptionType(value) {
   const normalized = typeof value === "string" ? value.trim() : "";
   const characters = Array.from(normalized);
@@ -1488,12 +1618,18 @@ function collectNestedErrorCauses(parent, state) {
   if (!isObjectLike(parent)) {
     return;
   }
-  if ("cause" in parent) {
-    collectErrorCause(parent.cause, "cause", state);
+  const cause = safeProperty(parent, "cause");
+  if (!cause.available) {
+    state.truncated = true;
+  } else if (cause.value !== undefined && cause.value !== null) {
+    collectErrorCause(cause.value, "cause", state);
   }
-  if (Array.isArray(parent.errors)) {
+  const errors = safeProperty(parent, "errors");
+  if (!errors.available) {
+    state.truncated = true;
+  } else if (Array.isArray(errors.value)) {
     state.sawExceptionGroup = true;
-    for (const [index, child] of parent.errors.entries()) {
+    for (const [index, child] of errors.value.entries()) {
       collectErrorCause(child, `errors[${index}]`, state);
     }
   }
@@ -1523,12 +1659,21 @@ function collectErrorCause(value, source, state) {
 
 function errorCauseType(value) {
   if (isObjectLike(value)) {
-    const constructorName = safeCauseTypeName(value.constructor?.name);
+    const constructor = safeProperty(value, "constructor");
+    const constructorNameValue = constructor.available && isObjectLike(constructor.value)
+      ? safeProperty(constructor.value, "name")
+      : { available: false, value: undefined };
+    const constructorName = constructorNameValue.available
+      ? safeCauseTypeName(constructorNameValue.value)
+      : undefined;
     if (value instanceof Error) {
       if (constructorName && constructorName !== "Error") {
         return constructorName;
       }
-      const builtinName = BUILTIN_ERROR_NAMES.has(value.name) ? value.name : undefined;
+      const name = safeProperty(value, "name");
+      const builtinName = name.available && BUILTIN_ERROR_NAMES.has(name.value)
+        ? name.value
+        : undefined;
       return builtinName ?? constructorName ?? "Error";
     }
     return constructorName ?? "Object";

package/index.d.cts

@@ -298,6 +298,40 @@ export type IssueException = {
   mechanism?: IssueExceptionMechanism;
 };
 
+export type IssueExceptionRelationship =
+  | "reported"
+  | "cause"
+  | "context"
+  | "aggregate_member"
+  | "suppressed";
+export type IssueExceptionMessageState = "captured" | "truncated" | "redacted" | "not_captured";
+export type IssueExceptionStackFramesState = "captured" | "truncated" | "not_captured";
+
+/** One parent-first runtime exception with its own message and structured stack state. */
+export type IssueExceptionChainEntry = {
+  /** Contiguous zero-based node identity. */
+  id: number;
+  /** Earlier parent node. Omitted only for the reported root exception. */
+  parentId?: number;
+  relationship: IssueExceptionRelationship;
+  type: string;
+  /** Bounded message only when messageState is captured or truncated. */
+  message?: string;
+  messageState: IssueExceptionMessageState;
+  module?: string;
+  mechanism?: IssueExceptionMechanism;
+  /** This exact exception's bounded structured frames. */
+  stackFrames?: IssueStackFrame[];
+  stackFramesState: IssueExceptionStackFramesState;
+};
+
+/** At most eight parent-first runtime exceptions. */
+export type IssueExceptionChain = {
+  entries: IssueExceptionChainEntry[];
+  /** True when a cycle or node cap omitted additional exceptions. */
+  truncated: boolean;
+};
+
 export type IssueBreadcrumbLevel = "debug" | "info" | "warning" | "error" | "critical";
 export type IssueBreadcrumbLevelInput = IssueBreadcrumbLevel | "trace" | "log" | "warn" | "fatal";
 export type IssueBreadcrumbDataValue = string | number | boolean | null;
@@ -329,6 +363,8 @@ export type IssueAttributes = {
   level: SeverityInput;
   message?: string;
   exception?: IssueException;
+  /** Parent-first runtime exception evidence; the first node agrees with legacy exception/stackFrames. */
+  exceptionChain?: IssueExceptionChain;
   /** Ordered privacy-bounded generated frames, capped at 32. */
   stackFrames?: IssueStackFrame[];
   /** Oldest-to-newest issue history, capped at the most recent 64 entries. */
@@ -845,7 +881,10 @@ export declare function createNetworkMilestoneAttributes(
 /** Build a local-only, token-free support-ticket create payload draft without calling backend routes. */
 export declare function createSupportTicketDraft(input: SupportTicketDraftInput): SupportTicketDraft;
 
-/** Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata. */
+/**
+ * Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata.
+ * Parent-first cause and AggregateError evidence is bounded to the public exception-chain contract.
+ */
 export declare function createIssueAttributesFromError(
   error: unknown,
   options?: JavaScriptErrorIssueOptions

package/index.d.ts

@@ -298,6 +298,40 @@ export type IssueException = {
   mechanism?: IssueExceptionMechanism;
 };
 
+export type IssueExceptionRelationship =
+  | "reported"
+  | "cause"
+  | "context"
+  | "aggregate_member"
+  | "suppressed";
+export type IssueExceptionMessageState = "captured" | "truncated" | "redacted" | "not_captured";
+export type IssueExceptionStackFramesState = "captured" | "truncated" | "not_captured";
+
+/** One parent-first runtime exception with its own message and structured stack state. */
+export type IssueExceptionChainEntry = {
+  /** Contiguous zero-based node identity. */
+  id: number;
+  /** Earlier parent node. Omitted only for the reported root exception. */
+  parentId?: number;
+  relationship: IssueExceptionRelationship;
+  type: string;
+  /** Bounded message only when messageState is captured or truncated. */
+  message?: string;
+  messageState: IssueExceptionMessageState;
+  module?: string;
+  mechanism?: IssueExceptionMechanism;
+  /** This exact exception's bounded structured frames. */
+  stackFrames?: IssueStackFrame[];
+  stackFramesState: IssueExceptionStackFramesState;
+};
+
+/** At most eight parent-first runtime exceptions. */
+export type IssueExceptionChain = {
+  entries: IssueExceptionChainEntry[];
+  /** True when a cycle or node cap omitted additional exceptions. */
+  truncated: boolean;
+};
+
 export type IssueBreadcrumbLevel = "debug" | "info" | "warning" | "error" | "critical";
 export type IssueBreadcrumbLevelInput = IssueBreadcrumbLevel | "trace" | "log" | "warn" | "fatal";
 export type IssueBreadcrumbDataValue = string | number | boolean | null;
@@ -329,6 +363,8 @@ export type IssueAttributes = {
   level: SeverityInput;
   message?: string;
   exception?: IssueException;
+  /** Parent-first runtime exception evidence; the first node agrees with legacy exception/stackFrames. */
+  exceptionChain?: IssueExceptionChain;
   /** Ordered privacy-bounded generated frames, capped at 32. */
   stackFrames?: IssueStackFrame[];
   /** Oldest-to-newest issue history, capped at the most recent 64 entries. */
@@ -845,7 +881,10 @@ export declare function createNetworkMilestoneAttributes(
 /** Build a local-only, token-free support-ticket create payload draft without calling backend routes. */
 export declare function createSupportTicketDraft(input: SupportTicketDraftInput): SupportTicketDraft;
 
-/** Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata. */
+/**
+ * Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata.
+ * Parent-first cause and AggregateError evidence is bounded to the public exception-chain contract.
+ */
 export declare function createIssueAttributesFromError(
   error: unknown,
   options?: JavaScriptErrorIssueOptions

package/issue-diagnostics.cjs

@@ -1,7 +1,10 @@
 "use strict";
 
 const MAX_ISSUE_BREADCRUMBS = 64;
+const MAX_ISSUE_EXCEPTIONS = 8;
 const MAX_EXCEPTION_TYPE_LENGTH = 256;
+const MAX_EXCEPTION_MESSAGE_LENGTH = 1024;
+const MAX_EXCEPTION_MODULE_LENGTH = 512;
 const MAX_MECHANISM_TYPE_LENGTH = 64;
 const MAX_BREADCRUMB_NAME_LENGTH = 64;
 const MAX_BREADCRUMB_MESSAGE_LENGTH = 512;
@@ -21,7 +24,7 @@ const BREADCRUMB_LEVEL_ALIASES = new Map([
   ["critical", "critical"]
 ]);
 
-function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
+function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp, validateIssueStackFrames }) {
   function validationError(message) {
     return new SdkError("validation_error", message);
   }
@@ -75,6 +78,133 @@ function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
     });
   }
 
+  function validateIssueExceptionChain(chain, legacyException, legacyStackFrames) {
+    if (chain === undefined) {
+      return undefined;
+    }
+    requireObject("issue exceptionChain", chain);
+    rejectUnknownKeys("issue exceptionChain", chain, new Set(["entries", "truncated"]));
+    if (!Array.isArray(chain.entries)
+      || chain.entries.length < 1
+      || chain.entries.length > MAX_ISSUE_EXCEPTIONS) {
+      throw validationError(
+        `issue exceptionChain entries must contain 1-${MAX_ISSUE_EXCEPTIONS} exceptions`
+      );
+    }
+    if (typeof chain.truncated !== "boolean") {
+      throw validationError("issue exceptionChain truncated must be a boolean");
+    }
+    const entries = chain.entries.map((entry, index) => validateIssueExceptionChainEntry(entry, index));
+    const reportedException = {
+      type: entries[0].type,
+      ...(entries[0].mechanism === undefined ? {} : { mechanism: entries[0].mechanism })
+    };
+    if (legacyException === undefined
+      || JSON.stringify(reportedException) !== JSON.stringify(legacyException)) {
+      throw validationError("issue exceptionChain reported exception must match exception");
+    }
+    const reportedFrames = entries[0].stackFrames;
+    const canonicalLegacyFrames = validateIssueStackFrames(legacyStackFrames);
+    if (entries[0].stackFramesState === "not_captured") {
+      if (canonicalLegacyFrames !== undefined) {
+        throw validationError("issue exceptionChain reported stack must match stackFrames");
+      }
+    } else if (JSON.stringify(reportedFrames) !== JSON.stringify(canonicalLegacyFrames)) {
+      throw validationError("issue exceptionChain reported stack must match stackFrames");
+    }
+    return {
+      entries,
+      truncated: chain.truncated
+    };
+  }
+
+  function validateIssueExceptionChainEntry(entry, index) {
+    requireObject(`issue exceptionChain entry ${index}`, entry);
+    rejectUnknownKeys(
+      `issue exceptionChain entry ${index}`,
+      entry,
+      new Set([
+        "id",
+        "parentId",
+        "relationship",
+        "type",
+        "message",
+        "messageState",
+        "module",
+        "mechanism",
+        "stackFrames",
+        "stackFramesState"
+      ])
+    );
+    if (!Number.isInteger(entry.id) || entry.id !== index) {
+      throw validationError(`issue exceptionChain entry ${index} id must equal its array index`);
+    }
+    const relationship = entry.relationship;
+    const parentId = entry.parentId;
+    if (index === 0) {
+      if (relationship !== "reported" || parentId !== undefined) {
+        throw validationError("issue exceptionChain entry 0 must be the parentless reported exception");
+      }
+    } else if (!new Set(["cause", "context", "aggregate_member", "suppressed"]).has(relationship)
+      || !Number.isInteger(parentId)
+      || parentId < 0
+      || parentId >= index) {
+      throw validationError(`issue exceptionChain entry ${index} parent relationship is invalid`);
+    }
+    const type = boundedText(
+      `issue exceptionChain entry ${index} type`,
+      entry.type,
+      MAX_EXCEPTION_TYPE_LENGTH,
+      { rejectLocationText: true }
+    );
+    const messageState = entry.messageState;
+    if (!new Set(["captured", "truncated", "redacted", "not_captured"]).has(messageState)) {
+      throw validationError(`issue exceptionChain entry ${index} messageState is invalid`);
+    }
+    const message = entry.message === undefined
+      ? undefined
+      : boundedText(
+          `issue exceptionChain entry ${index} message`,
+          entry.message,
+          MAX_EXCEPTION_MESSAGE_LENGTH
+        );
+    if ((messageState === "captured" || messageState === "truncated") !== (message !== undefined)) {
+      throw validationError(`issue exceptionChain entry ${index} message does not match messageState`);
+    }
+    const moduleName = entry.module === undefined
+      ? undefined
+      : boundedText(
+          `issue exceptionChain entry ${index} module`,
+          entry.module,
+          MAX_EXCEPTION_MODULE_LENGTH,
+          { rejectLocationText: true }
+        );
+    const mechanism = validateIssueExceptionMechanism(entry.mechanism);
+    const stackFramesState = entry.stackFramesState;
+    if (!new Set(["captured", "truncated", "not_captured"]).has(stackFramesState)) {
+      throw validationError(`issue exceptionChain entry ${index} stackFramesState is invalid`);
+    }
+    const stackFrames = validateIssueStackFrames(entry.stackFrames);
+    if ((stackFramesState === "captured" || stackFramesState === "truncated")
+      !== (stackFrames !== undefined)) {
+      throw validationError(
+        `issue exceptionChain entry ${index} stackFrames do not match stackFramesState`
+      );
+    }
+    return {
+      id: entry.id,
+      ...(parentId === undefined ? {} : { parentId }),
+      relationship,
+      type,
+      ...(message === undefined ? {} : { message }),
+      messageState,
+      ...(moduleName === undefined ? {} : { module: moduleName }),
+      ...(mechanism === undefined ? {} : { mechanism }),
+      ...(stackFrames === undefined ? {} : { stackFrames }),
+      stackFramesState
+    };
+  }
+
   function validateIssueBreadcrumb(breadcrumb, defaultTimestamp) {
     requireObject("issue breadcrumb", breadcrumb);
     rejectUnknownKeys(
@@ -121,6 +251,11 @@ function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
 
   function validateIssueDiagnostics(attributes) {
     const exception = validateIssueException(attributes.exception);
+    const exceptionChain = validateIssueExceptionChain(
+      attributes.exceptionChain,
+      exception,
+      attributes.stackFrames
+    );
     const breadcrumbs = validateIssueBreadcrumbs(attributes.breadcrumbs);
     if (
       attributes.breadcrumbsTruncated !== undefined
@@ -130,6 +265,7 @@ function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
     }
     return {
       ...(exception === undefined ? {} : { exception }),
+      ...(exceptionChain === undefined ? {} : { exceptionChain }),
       ...(breadcrumbs === undefined ? {} : { breadcrumbs }),
       ...(attributes.breadcrumbsTruncated === true ? { breadcrumbsTruncated: true } : {})
     };
@@ -145,6 +281,20 @@ function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
           : { mechanism: { ...attributes.exception.mechanism } })
       };
     }
+    if (attributes.exceptionChain !== undefined) {
+      diagnostics.exceptionChain = {
+        entries: attributes.exceptionChain.entries.map((entry) => ({
+          ...entry,
+          ...(entry.mechanism === undefined
+            ? {}
+            : { mechanism: { ...entry.mechanism } }),
+          ...(entry.stackFrames === undefined
+            ? {}
+            : { stackFrames: entry.stackFrames.map((frame) => ({ ...frame })) })
+        })),
+        truncated: attributes.exceptionChain.truncated
+      };
+    }
     if (Array.isArray(attributes.breadcrumbs)) {
       diagnostics.breadcrumbs = attributes.breadcrumbs.map((breadcrumb) => ({
         ...breadcrumb,
@@ -257,6 +407,7 @@ function buildIssueDiagnosticsHelpers({ SdkError, requireTimestamp }) {
 
   return {
     MAX_ISSUE_BREADCRUMBS,
+    MAX_ISSUE_EXCEPTIONS,
     cloneIssueDiagnostics,
     createIssueException,
     validateIssueBreadcrumb,

package/issue-stack.cjs

@@ -7,22 +7,28 @@ const SAFE_DEBUG_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-
 const LOCAL_ABSOLUTE_PATH_PATTERN = /^(?:\/(?:Users|home|private|tmp|var|Volumes)\/|[A-Za-z]:[\\/])/u;
 
 function buildIssueStackHelpers({ SdkError }) {
-  function javascriptStackFrames(stack, debugIdMap) {
+  function javascriptStackEvidence(stack, debugIdMap) {
     if (typeof stack !== "string" || stack.trim() === "") {
-      return [];
+      return { frames: [], truncated: false };
     }
     const frames = [];
+    let truncated = false;
     for (const rawLine of stack.split(/\r?\n/u)) {
       const parsed = parseJavaScriptStackFrame(rawLine);
       if (parsed) {
-        const debugId = debugIdForFrame(parsed.filename, debugIdMap, SdkError);
-        frames.push({ ...parsed, ...(debugId ? { debugId } : {}) });
         if (frames.length === MAX_ISSUE_STACK_FRAMES) {
+          truncated = true;
           break;
         }
+        const debugId = debugIdForFrame(parsed.filename, debugIdMap, SdkError);
+        frames.push({ ...parsed, ...(debugId ? { debugId } : {}) });
       }
     }
-    return frames;
+    return { frames, truncated };
+  }
+
+  function javascriptStackFrames(stack, debugIdMap) {
+    return javascriptStackEvidence(stack, debugIdMap).frames;
   }
 
   function validateIssueStackFrames(stackFrames) {
@@ -84,7 +90,7 @@ function buildIssueStackHelpers({ SdkError }) {
     });
   }
 
-  return { javascriptStackFrames, validateIssueStackFrames };
+  return { javascriptStackEvidence, javascriptStackFrames, validateIssueStackFrames };
 }
 
 function parseJavaScriptStackFrame(rawLine) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/sdk",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Public LogBrew JavaScript SDK for building, validating, and flushing event batches.",
   "type": "module",
   "main": "./index.cjs",