agent-inspect 6.31.11 → 6.31.13

package/packages/core/dist/{chunk-AK5EN4U2.mjs → chunk-YU6XT5A2.mjs}

@@ -143,18 +143,16 @@ var TreeBuilder = class {
         inc(confidenceBreakdown, e.confidence);
         kinds[e.kind] = (kinds[e.kind] ?? 0) + 1;
       }
-      const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
-      const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
-      const status = computeRunStatus(sorted);
-      const durationMs = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
       const name = sorted.find((e) => e.kind === "RUN")?.name;
+      const status = computeRunStatus(sorted);
+      const timing = resolveRunTiming(sorted, status);
       out.push({
         runId,
         name,
         status,
-        startedAt,
-        endedAt: status === "running" ? void 0 : endedAt,
-        durationMs,
+        startedAt: timing.startedAt,
+        endedAt: timing.endedAt,
+        durationMs: timing.durationMs,
         children: roots,
         metadata: {
           totalEvents: sorted.length,
@@ -168,7 +166,58 @@ var TreeBuilder = class {
     return out;
   }
 };
+function resolveRunTiming(sorted, status) {
+  let startedAtMs;
+  let endedAtMs;
+  let explicitDurationMs;
+  for (const event of sorted) {
+    if (event.kind !== "RUN") continue;
+    const attrs = event.attributes ?? {};
+    if (typeof attrs.startedAtMs === "number" && Number.isFinite(attrs.startedAtMs)) {
+      startedAtMs = startedAtMs === void 0 ? attrs.startedAtMs : Math.min(startedAtMs, attrs.startedAtMs);
+    }
+    if (typeof attrs.endedAtMs === "number" && Number.isFinite(attrs.endedAtMs)) {
+      endedAtMs = endedAtMs === void 0 ? attrs.endedAtMs : Math.max(endedAtMs, attrs.endedAtMs);
+    }
+    if ((event.status === "ok" || event.status === "error") && typeof event.durationMs === "number" && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
+      explicitDurationMs = event.durationMs;
+      if (endedAtMs === void 0 && startedAtMs !== void 0) {
+        endedAtMs = startedAtMs + event.durationMs;
+      } else if (endedAtMs === void 0 && Number.isFinite(event.timestamp)) {
+        endedAtMs = event.timestamp + event.durationMs;
+        if (startedAtMs === void 0) {
+          startedAtMs = event.timestamp;
+        }
+      }
+    }
+    if (startedAtMs === void 0 && event.status === "running" && Number.isFinite(event.timestamp)) {
+      startedAtMs = event.timestamp;
+    }
+  }
+  if (startedAtMs !== void 0 && endedAtMs !== void 0 && Number.isFinite(startedAtMs) && Number.isFinite(endedAtMs) && endedAtMs >= startedAtMs && status !== "running") {
+    return {
+      startedAt: startedAtMs,
+      endedAt: endedAtMs,
+      durationMs: endedAtMs - startedAtMs
+    };
+  }
+  if (startedAtMs !== void 0 && explicitDurationMs !== void 0 && status !== "running") {
+    return {
+      startedAt: startedAtMs,
+      endedAt: startedAtMs + explicitDurationMs,
+      durationMs: explicitDurationMs
+    };
+  }
+  const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
+  const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
+  const durationMs = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
+  return {
+    startedAt,
+    endedAt: status === "running" ? void 0 : endedAt,
+    durationMs
+  };
+}
 
 export { TreeBuilder };
-//# sourceMappingURL=chunk-AK5EN4U2.mjs.map
-//# sourceMappingURL=chunk-AK5EN4U2.mjs.map
+//# sourceMappingURL=chunk-YU6XT5A2.mjs.map
+//# sourceMappingURL=chunk-YU6XT5A2.mjs.map

package/packages/core/dist/chunk-YU6XT5A2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/logs/tree-builder.ts"],"names":[],"mappings":"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","file":"chunk-YU6XT5A2.mjs","sourcesContent":["import type {\n  InspectEvent,\n  InspectNode,\n  InspectRunTree,\n  RelationshipSummary,\n} from \"../types/inspect-event.js\";\nimport type { LogIngestConfig } from \"../types/log-config.js\";\n\nexport interface TreeBuilderOptions {\n  config?: LogIngestConfig;\n}\n\nfunction inc<T extends string>(map: Record<T, number>, key: T): void {\n  map[key] = (map[key] ?? 0) + 1;\n}\n\nfunction confidenceRank(confidence: InspectEvent[\"confidence\"]): number {\n  switch (confidence) {\n    case \"unknown\":\n      return 0;\n    case \"heuristic\":\n      return 1;\n    case \"correlated\":\n      return 2;\n    case \"explicit\":\n      return 3;\n    default:\n      return 0;\n  }\n}\n\nfunction computeRunStatus(events: InspectEvent[]): InspectRunTree[\"status\"] {\n  // Derive the run status from the RUN node lifecycle, matching\n  // manualTraceEventsToRunTree and extractMetadata: a run is \"running\" only\n  // until its RUN completion is recorded. The v0.1 bridge writes each node as a\n  // \"started\" event (status \"running\") followed by a \"completed\" event, so a\n  // finished run still carries \"running\" started rows; those must not force the\n  // whole run back to \"running\". Events arrive timestamp-sorted, so the last\n  // terminal RUN status wins.\n  let runTerminal: \"ok\" | \"error\" | undefined;\n  let sawRunEvent = false;\n  for (const e of events) {\n    if (e.kind !== \"RUN\") continue;\n    sawRunEvent = true;\n    if (e.status === \"ok\" || e.status === \"error\") {\n      runTerminal = e.status;\n    }\n  }\n  if (sawRunEvent) {\n    return runTerminal ?? \"running\";\n  }\n\n  // Fallback for traces with no RUN node (e.g. log-only ingestion).\n  let hasRunning = false;\n  for (const e of events) {\n    if (e.status === \"error\") return \"error\";\n    if (e.status === \"running\") hasRunning = true;\n  }\n  return hasRunning ? \"running\" : \"ok\";\n}\n\ninterface PendingEdge {\n  childId: string;\n  parentId: string;\n  childTimestamp: number;\n  childConfidence: InspectEvent[\"confidence\"];\n}\n\n/**\n * Link children to parents without self-edges or cycles. Broken edges become roots.\n */\nexport function linkNodesVisibilityFirst(\n  nodes: Map<string, InspectNode>,\n): { roots: InspectNode[]; summary: RelationshipSummary } {\n  let selfParentCount = 0;\n  let unresolvedParentCount = 0;\n  let normalizedEdgeCount = 0;\n  let cycleCount = 0;\n\n  const pending: PendingEdge[] = [];\n  for (const node of nodes.values()) {\n    const parentId = node.event.parentId;\n    if (!parentId) continue;\n    if (parentId === node.event.eventId) {\n      selfParentCount += 1;\n      normalizedEdgeCount += 1;\n      continue;\n    }\n    if (!nodes.has(parentId)) {\n      unresolvedParentCount += 1;\n      continue;\n    }\n    pending.push({\n      childId: node.event.eventId,\n      parentId,\n      childTimestamp: node.event.timestamp,\n      childConfidence: node.event.confidence,\n    });\n  }\n\n  // Prefer keeping higher-confidence / earlier edges; break the weakest last edge in a cycle.\n  pending.sort((a, b) => {\n    const conf = confidenceRank(b.childConfidence) - confidenceRank(a.childConfidence);\n    if (conf !== 0) return conf;\n    return a.childTimestamp - b.childTimestamp;\n  });\n\n  const parentOf = new Map<string, string>();\n  for (const edge of pending) {\n    parentOf.set(edge.childId, edge.parentId);\n    // Detect if accepting this edge creates a cycle (walk from parent toward roots).\n    let cursor: string | undefined = edge.parentId;\n    const seen = new Set<string>([edge.childId]);\n    let cyclic = false;\n    while (cursor) {\n      if (seen.has(cursor)) {\n        cyclic = true;\n        break;\n      }\n      seen.add(cursor);\n      cursor = parentOf.get(cursor);\n    }\n    if (cyclic) {\n      parentOf.delete(edge.childId);\n      cycleCount += 1;\n      normalizedEdgeCount += 1;\n    }\n  }\n\n  for (const [childId, parentId] of parentOf) {\n    nodes.get(parentId)!.children.push(nodes.get(childId)!);\n  }\n\n  const roots: InspectNode[] = [];\n  for (const node of nodes.values()) {\n    if (!parentOf.has(node.event.eventId)) {\n      roots.push(node);\n    }\n  }\n\n  const assignDepth = (n: InspectNode, depth: number, stack: Set<string>) => {\n    if (stack.has(n.event.eventId)) return;\n    n.depth = depth;\n    stack.add(n.event.eventId);\n    for (const c of n.children) assignDepth(c, depth + 1, stack);\n    stack.delete(n.event.eventId);\n  };\n  for (const r of roots) assignDepth(r, 0, new Set());\n\n  return {\n    roots,\n    summary: {\n      rootCount: roots.length,\n      selfParentCount,\n      cycleCount,\n      unresolvedParentCount,\n      normalizedEdgeCount,\n    },\n  };\n}\n\nexport class TreeBuilder {\n  constructor(options?: TreeBuilderOptions) {\n    void options?.config;\n  }\n\n  build(events: InspectEvent[]): InspectRunTree[] {\n    const byRun = new Map<string, InspectEvent[]>();\n    for (const e of events) {\n      if (!byRun.has(e.runId)) byRun.set(e.runId, []);\n      byRun.get(e.runId)!.push(e);\n    }\n\n    const out: InspectRunTree[] = [];\n    for (const [runId, runEvents] of byRun.entries()) {\n      const sorted = [...runEvents].sort((a, b) => a.timestamp - b.timestamp);\n\n      const nodes = new Map<string, InspectNode>();\n      for (const e of sorted) {\n        nodes.set(e.eventId, { event: e, children: [], depth: 0 });\n      }\n\n      const { roots, summary } = linkNodesVisibilityFirst(nodes);\n\n      // metadata\n      const confidenceBreakdown = {\n        explicit: 0,\n        correlated: 0,\n        heuristic: 0,\n        unknown: 0,\n      } as Record<InspectEvent[\"confidence\"], number>;\n      const kinds = {} as Record<InspectEvent[\"kind\"], number>;\n      for (const e of sorted) {\n        inc(confidenceBreakdown, e.confidence);\n        (kinds as any)[e.kind] = ((kinds as any)[e.kind] ?? 0) + 1;\n      }\n\n      const name = sorted.find((e) => e.kind === \"RUN\")?.name;\n      const status = computeRunStatus(sorted);\n      const timing = resolveRunTiming(sorted, status);\n\n      out.push({\n        runId,\n        name,\n        status,\n        startedAt: timing.startedAt,\n        endedAt: timing.endedAt,\n        durationMs: timing.durationMs,\n        children: roots,\n        metadata: {\n          totalEvents: sorted.length,\n          confidenceBreakdown,\n          kinds,\n          relationshipSummary: summary,\n        },\n      });\n    }\n\n    // newest first for stable display\n    out.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));\n    return out;\n  }\n}\n\n/**\n * Prefer explicit RUN start/end/duration facts when consistent; otherwise use a\n * conservative observed interval from event timestamps. Never invent wall-clock ends.\n */\nexport function resolveRunTiming(\n  sorted: readonly InspectEvent[],\n  status: InspectRunTree[\"status\"],\n): { startedAt?: number; endedAt?: number; durationMs?: number } {\n  let startedAtMs: number | undefined;\n  let endedAtMs: number | undefined;\n  let explicitDurationMs: number | undefined;\n\n  for (const event of sorted) {\n    if (event.kind !== \"RUN\") continue;\n    const attrs = event.attributes ?? {};\n    if (\n      typeof attrs.startedAtMs === \"number\" &&\n      Number.isFinite(attrs.startedAtMs)\n    ) {\n      startedAtMs =\n        startedAtMs === undefined\n          ? attrs.startedAtMs\n          : Math.min(startedAtMs, attrs.startedAtMs);\n    }\n    if (\n      typeof attrs.endedAtMs === \"number\" &&\n      Number.isFinite(attrs.endedAtMs)\n    ) {\n      endedAtMs =\n        endedAtMs === undefined\n          ? attrs.endedAtMs\n          : Math.max(endedAtMs, attrs.endedAtMs);\n    }\n    if (\n      (event.status === \"ok\" || event.status === \"error\") &&\n      typeof event.durationMs === \"number\" &&\n      Number.isFinite(event.durationMs) &&\n      event.durationMs >= 0\n    ) {\n      explicitDurationMs = event.durationMs;\n      // Completion rows often keep the start timestamp; recover end from duration.\n      if (endedAtMs === undefined && startedAtMs !== undefined) {\n        endedAtMs = startedAtMs + event.durationMs;\n      } else if (\n        endedAtMs === undefined &&\n        Number.isFinite(event.timestamp)\n      ) {\n        endedAtMs = event.timestamp + event.durationMs;\n        if (startedAtMs === undefined) {\n          startedAtMs = event.timestamp;\n        }\n      }\n    }\n    if (\n      startedAtMs === undefined &&\n      event.status === \"running\" &&\n      Number.isFinite(event.timestamp)\n    ) {\n      startedAtMs = event.timestamp;\n    }\n  }\n\n  if (\n    startedAtMs !== undefined &&\n    endedAtMs !== undefined &&\n    Number.isFinite(startedAtMs) &&\n    Number.isFinite(endedAtMs) &&\n    endedAtMs >= startedAtMs &&\n    status !== \"running\"\n  ) {\n    return {\n      startedAt: startedAtMs,\n      endedAt: endedAtMs,\n      durationMs: endedAtMs - startedAtMs,\n    };\n  }\n\n  if (\n    startedAtMs !== undefined &&\n    explicitDurationMs !== undefined &&\n    status !== \"running\"\n  ) {\n    return {\n      startedAt: startedAtMs,\n      endedAt: startedAtMs + explicitDurationMs,\n      durationMs: explicitDurationMs,\n    };\n  }\n\n  // Conservative observed interval from event timestamps (no wall-clock invention).\n  const startedAt = sorted.length > 0 ? sorted[0]!.timestamp : undefined;\n  const endedAt = sorted.length > 0 ? sorted[sorted.length - 1]!.timestamp : undefined;\n  const durationMs =\n    startedAt !== undefined &&\n    endedAt !== undefined &&\n    Number.isFinite(startedAt) &&\n    Number.isFinite(endedAt) &&\n    endedAt >= startedAt &&\n    status !== \"running\"\n      ? endedAt - startedAt\n      : undefined;\n\n  return {\n    startedAt,\n    endedAt: status === \"running\" ? undefined : endedAt,\n    durationMs,\n  };\n}\n"]}

package/packages/core/dist/exporters.cjs

@@ -1402,7 +1402,14 @@ function exportOtlpJson(tree, options) {
 
 // packages/core/src/exporters/validation.ts
 var EXPERIMENTAL = "Experimental compatibility export \u2014 verify against your target tooling before relying on it.";
+var UINT64_MAX = 18446744073709551615n;
+var INT64_MIN = -9223372036854775808n;
+var INT64_MAX = 9223372036854775807n;
+var MAX_ANYVALUE_DEPTH = 8;
+var MAX_ANYVALUE_ELEMENTS = 256;
+var MAX_DIAGNOSTIC_ERRORS = 64;
 function pushPath(errors, path4, message) {
+  if (errors.length >= MAX_DIAGNOSTIC_ERRORS) return;
   errors.push(`${path4}: ${message}`);
 }
 function isRecord3(value) {
@@ -1411,7 +1418,59 @@ function isRecord3(value) {
 function isHexId(value, byteLen) {
   return typeof value === "string" && new RegExp(`^[0-9a-fA-F]{${byteLen * 2}}$`).test(value);
 }
-function validateAnyValue(errors, path4, value) {
+function parseDecimalIntegerString(value) {
+  if (typeof value !== "string" || !/^-?\d+$/.test(value)) {
+    return { ok: false, reason: "must be a decimal integer string" };
+  }
+  try {
+    return { ok: true, n: BigInt(value) };
+  } catch {
+    return { ok: false, reason: "out of integer range" };
+  }
+}
+function validateUint64String(errors, path4, value, label) {
+  const parsed = parseDecimalIntegerString(value);
+  if (!parsed.ok) {
+    pushPath(errors, path4, `${label} ${parsed.reason}`);
+    return;
+  }
+  if (parsed.n < 0n || parsed.n > UINT64_MAX) {
+    pushPath(
+      errors,
+      path4,
+      `${label} must be an unsigned 64-bit integer (0..${UINT64_MAX.toString()})`
+    );
+  }
+}
+function validateInt64String(errors, path4, value) {
+  const parsed = parseDecimalIntegerString(value);
+  if (!parsed.ok) {
+    pushPath(errors, path4, parsed.reason);
+    return;
+  }
+  if (parsed.n < INT64_MIN || parsed.n > INT64_MAX) {
+    pushPath(
+      errors,
+      path4,
+      `must be a signed 64-bit integer (${INT64_MIN.toString()}..${INT64_MAX.toString()})`
+    );
+  }
+}
+function validateAnyValue(errors, path4, value, depth = 0, counters = { elements: 0 }) {
+  if (errors.length >= MAX_DIAGNOSTIC_ERRORS) return;
+  if (depth > MAX_ANYVALUE_DEPTH) {
+    pushPath(errors, path4, `AnyValue nesting exceeds depth ${MAX_ANYVALUE_DEPTH}`);
+    return;
+  }
+  counters.elements += 1;
+  if (counters.elements > MAX_ANYVALUE_ELEMENTS) {
+    pushPath(
+      errors,
+      path4,
+      `AnyValue element count exceeds ${MAX_ANYVALUE_ELEMENTS}`
+    );
+    return;
+  }
   if (!isRecord3(value)) {
     pushPath(errors, path4, "must be an AnyValue object");
     return;
@@ -1431,12 +1490,98 @@ function validateAnyValue(errors, path4, value) {
       path4,
       `AnyValue must set exactly one variant (found ${variants.length}: ${variants.join(",")})`
     );
+    return;
   }
-  if (value.intValue !== void 0) {
-    if (typeof value.intValue !== "string" || !/^-?\d+$/.test(value.intValue)) {
-      pushPath(errors, `${path4}.intValue`, "must be a decimal integer string");
+  const arm = variants[0];
+  switch (arm) {
+    case "stringValue":
+      if (typeof value.stringValue !== "string") {
+        pushPath(errors, `${path4}.stringValue`, "must be a string");
+      }
+      break;
+    case "boolValue":
+      if (typeof value.boolValue !== "boolean") {
+        pushPath(errors, `${path4}.boolValue`, "must be a boolean");
+      }
+      break;
+    case "intValue":
+      validateInt64String(errors, `${path4}.intValue`, value.intValue);
+      break;
+    case "doubleValue":
+      if (typeof value.doubleValue !== "number" || !Number.isFinite(value.doubleValue)) {
+        pushPath(errors, `${path4}.doubleValue`, "must be a finite number");
+      }
+      break;
+    case "bytesValue":
+      if (typeof value.bytesValue !== "string") {
+        pushPath(errors, `${path4}.bytesValue`, "must be a base64 string");
+      }
+      break;
+    case "arrayValue": {
+      if (!isRecord3(value.arrayValue)) {
+        pushPath(errors, `${path4}.arrayValue`, "must be an object");
+        break;
+      }
+      const values = value.arrayValue.values;
+      if (values === void 0) break;
+      if (!Array.isArray(values)) {
+        pushPath(errors, `${path4}.arrayValue.values`, "must be an array");
+        break;
+      }
+      values.forEach((item, i) => {
+        validateAnyValue(
+          errors,
+          `${path4}.arrayValue.values[${i}]`,
+          item,
+          depth + 1,
+          counters
+        );
+      });
+      break;
     }
+    case "kvlistValue": {
+      if (!isRecord3(value.kvlistValue)) {
+        pushPath(errors, `${path4}.kvlistValue`, "must be an object");
+        break;
+      }
+      const values = value.kvlistValue.values;
+      if (values === void 0) break;
+      if (!Array.isArray(values)) {
+        pushPath(errors, `${path4}.kvlistValue.values`, "must be an array");
+        break;
+      }
+      values.forEach((item, i) => {
+        const itemPath = `${path4}.kvlistValue.values[${i}]`;
+        if (!isRecord3(item)) {
+          pushPath(errors, itemPath, "must be a KeyValue object");
+          return;
+        }
+        if (typeof item.key !== "string") {
+          pushPath(errors, `${itemPath}.key`, "must be a string");
+        }
+        validateAnyValue(errors, `${itemPath}.value`, item.value, depth + 1, counters);
+      });
+      break;
+    }
+  }
+}
+function validateKeyValueList(errors, path4, attrs) {
+  if (attrs === void 0) return;
+  if (!Array.isArray(attrs)) {
+    pushPath(errors, path4, "must be an array");
+    return;
   }
+  attrs.forEach((attr, ai) => {
+    const attrPath = `${path4}[${ai}]`;
+    if (!isRecord3(attr)) {
+      pushPath(errors, attrPath, "must be an object");
+      return;
+    }
+    if (typeof attr.key !== "string") {
+      pushPath(errors, `${attrPath}.key`, "must be a string");
+    }
+    validateAnyValue(errors, `${attrPath}.value`, attr.value);
+  });
 }
 function validateOtlpJson(content) {
   const errors = [];
@@ -1466,6 +1611,13 @@ function validateOtlpJson(content) {
       pushPath(errors, rsPath, "must be an object");
       return;
     }
+    if (isRecord3(resourceSpan.resource)) {
+      validateKeyValueList(
+        errors,
+        `${rsPath}.resource.attributes`,
+        resourceSpan.resource.attributes
+      );
+    }
     if (!Array.isArray(resourceSpan.scopeSpans)) {
       pushPath(errors, `${rsPath}.scopeSpans`, "must be an array");
       return;
@@ -1476,6 +1628,13 @@ function validateOtlpJson(content) {
         pushPath(errors, ssPath, "must be an object");
         return;
       }
+      if (isRecord3(scopeSpan.scope)) {
+        validateKeyValueList(
+          errors,
+          `${ssPath}.scope.attributes`,
+          scopeSpan.scope.attributes
+        );
+      }
       if (!Array.isArray(scopeSpan.spans)) {
         pushPath(errors, `${ssPath}.spans`, "must be an array");
         return;
@@ -1510,44 +1669,58 @@ function validateOtlpJson(content) {
         if (typeof span.name !== "string") {
           pushPath(errors, `${spanPath}.name`, "must be a string");
         }
-        if (typeof span.startTimeUnixNano !== "string" || !/^\d+$/.test(span.startTimeUnixNano)) {
-          pushPath(
-            errors,
-            `${spanPath}.startTimeUnixNano`,
-            "must be a decimal-string 64-bit integer"
-          );
-        }
-        if (span.endTimeUnixNano !== void 0 && (typeof span.endTimeUnixNano !== "string" || !/^\d+$/.test(span.endTimeUnixNano))) {
-          pushPath(
+        validateUint64String(
+          errors,
+          `${spanPath}.startTimeUnixNano`,
+          span.startTimeUnixNano,
+          "startTimeUnixNano"
+        );
+        if (span.endTimeUnixNano !== void 0) {
+          validateUint64String(
             errors,
             `${spanPath}.endTimeUnixNano`,
-            "must be a decimal-string 64-bit integer when present"
+            span.endTimeUnixNano,
+            "endTimeUnixNano"
           );
         }
-        if (typeof span.startTimeUnixNano === "string" && /^\d+$/.test(span.startTimeUnixNano) && typeof span.endTimeUnixNano === "string" && /^\d+$/.test(span.endTimeUnixNano)) {
-          try {
-            if (BigInt(span.endTimeUnixNano) < BigInt(span.startTimeUnixNano)) {
-              pushPath(
+        if (typeof span.startTimeUnixNano === "string" && typeof span.endTimeUnixNano === "string") {
+          const start = parseDecimalIntegerString(span.startTimeUnixNano);
+          const end = parseDecimalIntegerString(span.endTimeUnixNano);
+          if (start.ok && end.ok && end.n < start.n) {
+            pushPath(
+              errors,
+              `${spanPath}.endTimeUnixNano`,
+              "must be >= startTimeUnixNano"
+            );
+          }
+        }
+        validateKeyValueList(errors, `${spanPath}.attributes`, span.attributes);
+        if (Array.isArray(span.events)) {
+          span.events.forEach((event, ei) => {
+            const eventPath = `${spanPath}.events[${ei}]`;
+            if (!isRecord3(event)) {
+              pushPath(errors, eventPath, "must be an object");
+              return;
+            }
+            if (event.timeUnixNano !== void 0) {
+              validateUint64String(
                 errors,
-                `${spanPath}.endTimeUnixNano`,
-                "must be >= startTimeUnixNano"
+                `${eventPath}.timeUnixNano`,
+                event.timeUnixNano,
+                "timeUnixNano"
               );
             }
-          } catch {
-            pushPath(errors, `${spanPath}.endTimeUnixNano`, "out of integer range");
-          }
+            validateKeyValueList(errors, `${eventPath}.attributes`, event.attributes);
+          });
         }
-        if (Array.isArray(span.attributes)) {
-          span.attributes.forEach((attr, ai) => {
-            const attrPath = `${spanPath}.attributes[${ai}]`;
-            if (!isRecord3(attr)) {
-              pushPath(errors, attrPath, "must be an object");
+        if (Array.isArray(span.links)) {
+          span.links.forEach((link, li) => {
+            const linkPath = `${spanPath}.links[${li}]`;
+            if (!isRecord3(link)) {
+              pushPath(errors, linkPath, "must be an object");
               return;
             }
-            if (typeof attr.key !== "string") {
-              pushPath(errors, `${attrPath}.key`, "must be a string");
-            }
-            validateAnyValue(errors, `${attrPath}.value`, attr.value);
+            validateKeyValueList(errors, `${linkPath}.attributes`, link.attributes);
           });
         }
         if (typeof span.kind === "number") {