@tangle-network/traces 0.23.1 → 1.0.1

package/dist/chunk-CQ6UYZG6.js

@@ -0,0 +1,1217 @@
+import {
+  TOOL_IO_VALUE_MAX_BYTES,
+  boundedString,
+  locateSourceObjects,
+  parseIsoToEpochMs,
+  sourceAttributes,
+  toolArgumentsFromAttributes,
+  toolIoAttributes
+} from "./chunk-DU534HAX.js";
+
+// src/arrays.ts
+function appendAll(target, values) {
+  for (const value of values) target.push(value);
+}
+
+// src/otlp-input.ts
+import { open as open2, readdir, readFile, stat } from "fs/promises";
+import { basename, join } from "path";
+import {
+  ATTR,
+  declaredSpanKind,
+  resolveSpanKind,
+  SPAN_KIND_ATTR_KEYS,
+  validateTraceSpans
+} from "@tangle-network/agent-trace-contract";
+import { TOOL_NAME } from "@tangle-network/agent-eval/trace-attributes";
+
+// src/json-values.ts
+import { open } from "fs/promises";
+var MAX_STRING_BYTES = TOOL_IO_VALUE_MAX_BYTES;
+var READ_BYTES = 1 << 20;
+var QUOTE = 34;
+var BACKSLASH = 92;
+var NEWLINE = 10;
+var NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
+function isWhitespace(byte) {
+  return byte === 32 || byte === 9 || byte === 10 || byte === 13;
+}
+function isBareByte(byte) {
+  return byte >= 48 && byte <= 57 || byte === 45 || byte === 43 || byte === 46 || byte >= 97 && byte <= 122 || byte >= 65 && byte <= 90;
+}
+function wholePrefix(raw, limit) {
+  let end = Math.min(limit, raw.length);
+  for (let i = 0; i < end; ) {
+    if (raw[i] !== BACKSLASH) {
+      i += 1;
+      continue;
+    }
+    const length = raw[i + 1] === 117 ? 6 : 2;
+    if (i + length > end) {
+      end = i;
+      break;
+    }
+    i += length;
+  }
+  if (end > 0) {
+    let start = end - 1;
+    while (start > 0 && (raw[start] & 192) === 128) start -= 1;
+    const first = raw[start];
+    const size = first >= 240 ? 4 : first >= 224 ? 3 : first >= 192 ? 2 : 1;
+    if (start + size > end) end = start;
+  }
+  return end;
+}
+function decode(raw) {
+  return raw.includes(BACKSLASH) ? JSON.parse(`"${raw.toString("utf8")}"`) : raw.toString("utf8");
+}
+var ValueParser = class {
+  constructor(onError) {
+    this.onError = onError;
+  }
+  onError;
+  state = 0 /* Value */;
+  stack = [];
+  line = 1;
+  valueLine = 1;
+  values = 0;
+  /** Unknown until the first value ends or crosses a line: true for one document, false for JSONL. */
+  document;
+  /** The string being read: its raw bytes up to the cap, its length in all, whether it is a key. */
+  stringParts = [];
+  stringKept = 0;
+  stringTotal = 0;
+  stringIsKey = false;
+  /** Backslashes that ended the previous piece of the string being read. */
+  carriedBackslashes = 0;
+  bare = "";
+  done = [];
+  /** Parse `bytes`, which the caller may reuse once this returns, and take the values it completed. */
+  feed(bytes) {
+    let i = 0;
+    while (i < bytes.length) {
+      if (this.state === 4 /* String */) {
+        i = this.readString(bytes, i);
+      } else if (this.state === 5 /* Bare */) {
+        const start = i;
+        while (i < bytes.length && isBareByte(bytes[i])) i += 1;
+        this.bare += bytes.toString("latin1", start, i);
+        if (i < bytes.length) this.endBare();
+      } else if (this.state === 6 /* SkipLine */) {
+        const newline = bytes.indexOf(NEWLINE, i);
+        if (newline === -1) break;
+        this.line += 1;
+        this.state = 0 /* Value */;
+        i = newline + 1;
+      } else {
+        i = this.readStructure(bytes, i);
+      }
+    }
+    return this.done.splice(0);
+  }
+  /** The values the input completed; a value it left open is reported. */
+  end() {
+    if (this.state === 5 /* Bare */) this.endBare();
+    if (this.state !== 6 /* SkipLine */ && (this.state !== 0 /* Value */ || this.stack.length > 0)) {
+      this.onError(this.valueLine, "the input ended inside a value");
+    }
+    return this.done.splice(0);
+  }
+  reset() {
+    this.stack.length = 0;
+    this.stringParts = [];
+    this.bare = "";
+  }
+  /** A value that cannot be JSON: report it, and resume on the next line. */
+  fail(detail) {
+    this.onError(this.valueLine, detail);
+    this.reset();
+    this.state = 6 /* SkipLine */;
+  }
+  /** A newline: whitespace in a document; in JSONL, the end of a value left open on its line. */
+  newline() {
+    const open3 = this.state !== 0 /* Value */ || this.stack.length > 0;
+    if (open3 && this.document === void 0 && this.values === 0) this.document = true;
+    if (open3 && this.document === false) {
+      this.onError(this.valueLine, "the line ended inside a value");
+      this.reset();
+      this.state = 0 /* Value */;
+    }
+    this.line += 1;
+  }
+  readStructure(bytes, at) {
+    const byte = bytes[at];
+    if (isWhitespace(byte)) {
+      if (byte === NEWLINE) this.newline();
+      return at + 1;
+    }
+    if (this.state === 0 /* Value */ && this.stack.length === 0) this.valueLine = this.line;
+    if (this.state === 0 /* Value */) return this.startValue(byte, at);
+    if (this.state === 2 /* Key */) {
+      if (byte === QUOTE) return this.startString(true, at);
+      if (byte === 125 && this.closeEmptyObject()) return at + 1;
+      this.fail("an object key must be a string");
+      return at;
+    }
+    if (this.state === 3 /* Colon */) {
+      if (byte === 58) {
+        this.state = 0 /* Value */;
+        return at + 1;
+      }
+      this.fail("a key must be followed by :");
+      return at;
+    }
+    const top = this.stack.at(-1);
+    if (byte === 44) {
+      this.state = Array.isArray(top.value) ? 0 /* Value */ : 2 /* Key */;
+      return at + 1;
+    }
+    if (byte === 93 && Array.isArray(top.value) || byte === 125 && !Array.isArray(top.value)) {
+      this.stack.pop();
+      this.complete(top.value);
+      return at + 1;
+    }
+    this.fail("a value must be followed by , or the end of its container");
+    return at;
+  }
+  startValue(byte, at) {
+    if (byte === QUOTE) return this.startString(false, at);
+    if (byte === 123 || byte === 91) {
+      this.stack.push({ value: byte === 123 ? {} : [] });
+      this.state = byte === 123 ? 2 /* Key */ : 0 /* Value */;
+      return at + 1;
+    }
+    const top = this.stack.at(-1);
+    if (byte === 93 && top && Array.isArray(top.value) && top.value.length === 0) {
+      this.stack.pop();
+      this.complete(top.value);
+      return at + 1;
+    }
+    if (isBareByte(byte)) {
+      this.bare = "";
+      this.state = 5 /* Bare */;
+      return at;
+    }
+    this.fail(`unexpected ${JSON.stringify(String.fromCharCode(byte))}`);
+    return at;
+  }
+  /** `}` in the key state closes the object only when it has no key yet: `{}`, not `{"a":1,}`. */
+  closeEmptyObject() {
+    const top = this.stack.at(-1);
+    if (Array.isArray(top.value) || Object.keys(top.value).length > 0) return false;
+    this.stack.pop();
+    this.complete(top.value);
+    return true;
+  }
+  startString(isKey, at) {
+    this.stringParts = [];
+    this.stringKept = 0;
+    this.stringTotal = 0;
+    this.stringIsKey = isKey;
+    this.carriedBackslashes = 0;
+    this.state = 4 /* String */;
+    return at + 1;
+  }
+  /**
+   * Read string bytes from `at` to the closing quote, or to the end of
+   * `bytes`. A quote closes the string when an even number of backslashes
+   * precede it, so each quote is looked at once, however long the string.
+   */
+  readString(bytes, at) {
+    const lineEnd = this.document === false ? bytes.indexOf(NEWLINE, at) : -1;
+    const limit = lineEnd === -1 ? bytes.length : lineEnd;
+    let from = at;
+    for (; ; ) {
+      const quote = bytes.indexOf(QUOTE, from);
+      if (quote === -1 || quote >= limit) break;
+      let backslashes = 0;
+      let j = quote - 1;
+      while (j >= at && bytes[j] === BACKSLASH) {
+        backslashes += 1;
+        j -= 1;
+      }
+      if (j < at) backslashes += this.carriedBackslashes;
+      if (backslashes % 2 === 0) {
+        this.keep(bytes, at, quote);
+        this.endString();
+        return quote + 1;
+      }
+      from = quote + 1;
+    }
+    this.keep(bytes, at, limit);
+    if (lineEnd !== -1) {
+      this.newline();
+      return lineEnd + 1;
+    }
+    let run = 0;
+    for (let j = limit - 1; j >= at && bytes[j] === BACKSLASH; j -= 1) run += 1;
+    this.carriedBackslashes = run === limit - at ? this.carriedBackslashes + run : run;
+    return limit;
+  }
+  /** Keep the string's raw bytes in `[from, to)` up to the cap, and count them all. */
+  keep(bytes, from, to) {
+    const length = to - from;
+    this.stringTotal += length;
+    const take = Math.min(MAX_STRING_BYTES - this.stringKept, length);
+    if (take <= 0) return;
+    this.stringParts.push(Buffer.from(bytes.subarray(from, from + take)));
+    this.stringKept += take;
+  }
+  endString() {
+    const raw = this.stringParts.length === 1 ? this.stringParts[0] : Buffer.concat(this.stringParts);
+    this.stringParts = [];
+    let text;
+    try {
+      if (this.stringTotal <= MAX_STRING_BYTES) {
+        text = decode(raw);
+      } else {
+        const longest = `
+[truncated ${this.stringTotal} bytes]`;
+        const kept = wholePrefix(raw, MAX_STRING_BYTES - Buffer.byteLength(longest));
+        text = `${decode(raw.subarray(0, kept))}
+[truncated ${this.stringTotal - kept} bytes]`;
+      }
+    } catch {
+      this.fail("a string holds an invalid escape");
+      return;
+    }
+    if (this.stringIsKey) {
+      this.stack.at(-1).key = text;
+      this.state = 3 /* Colon */;
+    } else {
+      this.complete(text);
+    }
+  }
+  endBare() {
+    const text = this.bare;
+    this.bare = "";
+    if (text === "true" || text === "false" || text === "null") {
+      this.complete(text === "null" ? null : text === "true");
+    } else if (NUMBER.test(text)) {
+      this.complete(Number(text));
+    } else {
+      this.fail(`${JSON.stringify(text.slice(0, 20))} is not a JSON value`);
+    }
+  }
+  complete(value) {
+    const top = this.stack.at(-1);
+    if (top) {
+      if (Array.isArray(top.value)) top.value.push(value);
+      else if (top.key === "__proto__") Object.defineProperty(top.value, top.key, { value, enumerable: true, writable: true, configurable: true });
+      else top.value[top.key] = value;
+      this.state = 1 /* AfterValue */;
+      return;
+    }
+    this.done.push({ value, line: this.valueLine });
+    this.values += 1;
+    this.document ??= false;
+    this.state = 0 /* Value */;
+  }
+};
+async function* readJsonValues(path, onError) {
+  const parser = new ValueParser(onError);
+  const handle = await open(path, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(READ_BYTES);
+    for (; ; ) {
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+      if (bytesRead === 0) break;
+      yield* parser.feed(bytesRead === buffer.length ? buffer : buffer.subarray(0, bytesRead));
+    }
+    yield* parser.end();
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/jsonl.ts
+import { isUtf8 } from "buffer";
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+var JsonlParseError = class extends SyntaxError {
+  sourcePath;
+  lineNumber;
+  byteOffset;
+  byteLength;
+  sha256;
+  receipt;
+  constructor(receipt) {
+    super(`Invalid JSONL at ${receipt.sourcePath}:${receipt.lineNumber}`);
+    this.name = "JsonlParseError";
+    this.sourcePath = receipt.sourcePath;
+    this.lineNumber = receipt.lineNumber;
+    this.byteOffset = receipt.byteOffset;
+    this.byteLength = receipt.byteLength;
+    this.sha256 = receipt.sha256;
+    this.receipt = receipt;
+  }
+};
+function corruptionReceipt(rawLine, path, lineNumber, byteOffset) {
+  return {
+    receiptVersion: 1,
+    kind: "jsonl_corruption",
+    status: "degraded_not_lossless",
+    sourcePath: path,
+    lineNumber,
+    byteOffset,
+    byteLength: rawLine.length,
+    sha256: createHash("sha256").update(rawLine).digest("hex"),
+    rawBytes: "local_source_only"
+  };
+}
+function parseLine(rawLine, path, lineNumber, byteOffset, options) {
+  const jsonBytes = rawLine.at(-1) === 13 ? rawLine.subarray(0, -1) : rawLine;
+  if (jsonBytes.length === 0) return void 0;
+  if (!isUtf8(jsonBytes)) return handleCorruption(rawLine, path, lineNumber, byteOffset, options);
+  try {
+    const json = jsonBytes.toString("utf8");
+    if (json.trim().length === 0) return void 0;
+    const value = JSON.parse(json);
+    if (options.captureSources) locateSourceObjects(value, path, rawLine, byteOffset);
+    return value;
+  } catch {
+    return handleCorruption(rawLine, path, lineNumber, byteOffset, options);
+  }
+}
+function handleCorruption(rawLine, path, lineNumber, byteOffset, options) {
+  const receipt = corruptionReceipt(rawLine, path, lineNumber, byteOffset);
+  if (options.mode === "recover") {
+    options.onCorruption(receipt);
+    return void 0;
+  }
+  throw new JsonlParseError(receipt);
+}
+async function* readJsonl(path, options = { mode: "strict" }) {
+  for await (const row of readJsonlLines(path, options)) yield row.value;
+}
+async function* readJsonlLines(path, options = { mode: "strict" }) {
+  if (options.mode === "recover" && typeof options.onCorruption !== "function") {
+    throw new TypeError("JSONL recover mode requires an onCorruption callback");
+  }
+  options.signal?.throwIfAborted();
+  const input = createReadStream(path, { signal: options.signal });
+  let lineNumber = 0;
+  let byteOffset = 0;
+  let fragments = [];
+  try {
+    for await (const chunk of input) {
+      options.signal?.throwIfAborted();
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      let start = 0;
+      let newline = bytes.indexOf(10);
+      while (newline !== -1) {
+        options.signal?.throwIfAborted();
+        fragments.push(bytes.subarray(start, newline));
+        const rawLine = fragments.length === 1 ? fragments[0] : Buffer.concat(fragments);
+        fragments = [];
+        lineNumber += 1;
+        const parsed = parseLine(rawLine, path, lineNumber, byteOffset, options);
+        if (parsed !== void 0) yield { value: parsed, lineNumber };
+        byteOffset += rawLine.length + 1;
+        start = newline + 1;
+        newline = bytes.indexOf(10, start);
+      }
+      if (start < bytes.length) fragments.push(bytes.subarray(start));
+    }
+    if (fragments.length > 0) {
+      options.signal?.throwIfAborted();
+      const rawLine = fragments.length === 1 ? fragments[0] : Buffer.concat(fragments);
+      lineNumber += 1;
+      const parsed = parseLine(rawLine, path, lineNumber, byteOffset, options);
+      if (parsed !== void 0) yield { value: parsed, lineNumber };
+    }
+  } finally {
+    input.destroy();
+  }
+}
+async function takeJsonl(path, limit, options = { mode: "strict" }) {
+  if (!Number.isInteger(limit) || limit < 0) throw new RangeError("limit must be a non-negative integer");
+  const rows = [];
+  if (limit === 0) return rows;
+  for await (const row of readJsonl(path, options)) {
+    rows.push(row);
+    if (rows.length === limit) break;
+  }
+  return rows;
+}
+
+// src/otlp-input.ts
+var OTLP_FILE_EXTENSIONS = [".jsonl", ".ndjson"];
+var OTLP_DIRECTORY_NAME = "otlp";
+var SNIFF_LINES = 5;
+var DURATION_UNMEASURABLE_ATTR = "traces.duration_unmeasurable";
+var RAW_FIELD_ATTRIBUTES = Object.freeze({
+  trace_id: "traces.raw_attribute.trace_id",
+  end_time: "traces.raw_attribute.end_time",
+  "status.code": "traces.raw_attribute.status.code",
+  kind: "traces.raw_attribute.openinference.span.kind",
+  links: "traces.raw_attribute.links"
+});
+var SUBSTITUTED_FIELDS_ATTR = "traces.substituted_fields";
+var TRACE_ID_MINTED_ATTR = "traces.trace_id_minted";
+var SOURCE_UNREADABLE_ROWS_ATTR = "traces.source.unreadable_rows";
+var SOURCE_UNREADABLE_KINDS_ATTR = "traces.source.unreadable_row_kinds";
+async function jsonlFilesUnder(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) appendAll(files, await jsonlFilesUnder(path));
+    else if (OTLP_FILE_EXTENSIONS.some((ext) => entry.name.toLowerCase().endsWith(ext))) files.push(path);
+  }
+  return files;
+}
+async function otlpDirectoriesUnder(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const dirs = [];
+  for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) {
+    if (!entry.isDirectory()) continue;
+    const path = join(dir, entry.name);
+    if (entry.name === OTLP_DIRECTORY_NAME) dirs.push(path);
+    else appendAll(dirs, await otlpDirectoriesUnder(path));
+  }
+  return dirs;
+}
+async function sniffOtlpFile(path) {
+  if (await isOtlpJsonFile(path)) return { otlp: true };
+  let seen = 0;
+  let first = null;
+  const head = new AbortController();
+  try {
+    for await (const { value: row } of readJsonlLines(path, {
+      mode: "recover",
+      onCorruption: () => {
+        if (++seen >= SNIFF_LINES) head.abort();
+      },
+      signal: head.signal
+    })) {
+      if (isObject(row) && nonEmptyString(row.span_id) !== null && nonEmptyString(row.name) !== null) return { otlp: true };
+      if (isStandardOtlpRow(row)) return { otlp: true };
+      first ??= { row };
+      if (++seen >= SNIFF_LINES) break;
+    }
+  } catch (error) {
+    if (!head.signal.aborted) throw error;
+  }
+  if (seen === 0) return { otlp: false, reason: "file is empty" };
+  return { otlp: false, reason: first === null ? "no line parses as JSON" : describeNonSpanRow(first.row) };
+}
+function describeNonSpanRow(row) {
+  if (!isObject(row)) return `rows are ${row === null ? "null" : Array.isArray(row) ? "arrays" : typeof row}, not spans`;
+  const marker = nonEmptyString(row.type) ?? nonEmptyString(row.event) ?? nonEmptyString(row.kind);
+  const keys = Object.keys(row).slice(0, 4).join(", ");
+  return marker !== null ? `rows carry no span_id; they look like \`${marker}\` events (keys: ${keys})` : `rows carry no span_id (keys: ${keys})`;
+}
+async function resolveOtlpInputFiles(path) {
+  let info;
+  try {
+    info = await stat(path);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`no OTLP file or directory at ${path}`);
+    }
+    throw error;
+  }
+  if (!info.isDirectory()) return { files: [path], skipped: [] };
+  const otlpDirs = basename(path) === OTLP_DIRECTORY_NAME ? [path] : await otlpDirectoriesUnder(path);
+  const candidates = otlpDirs.length > 0 ? (await Promise.all(otlpDirs.map(jsonlFilesUnder))).flat() : await jsonlFilesUnder(path);
+  if (candidates.length === 0) {
+    throw new Error(`no ${OTLP_FILE_EXTENSIONS.join(" / ")} files under ${path}`);
+  }
+  const files = [];
+  const skipped = [];
+  for (const candidate of candidates) {
+    const sniff = await sniffOtlpFile(candidate);
+    if (sniff.otlp) files.push(candidate);
+    else skipped.push({ path: candidate, reason: sniff.reason });
+  }
+  if (files.length === 0) {
+    throw new Error(
+      `no OTLP span files under ${path}: ${skipped.length} JSONL file(s) hold something else (${skipped.slice(0, 3).map((entry) => `${basename(entry.path)} \u2014 ${entry.reason}`).join("; ")})`
+    );
+  }
+  return { files, skipped };
+}
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function statusCode(value) {
+  if (value === "OK" || value === "STATUS_CODE_OK") return "OK";
+  if (value === "ERROR" || value === "STATUS_CODE_ERROR") return "ERROR";
+  return "UNSET";
+}
+function readStatusCode(declared) {
+  const code = statusCode(declared);
+  if (declared === `STATUS_CODE_${code}`) return { code, substituted: false };
+  return declared === void 0 ? { code, substituted: true } : { code, substituted: true, raw: declared };
+}
+function isToolTelemetrySpan(attributes) {
+  const spanType = nonEmptyString(attributes["span.type"])?.toLowerCase();
+  return spanType === "tool.execution" || spanType === "tool.blocked_on_user";
+}
+var LOCAL_TOOL_ATTRIBUTES = ["tool_name", "mcp.tool.name", "tool.input", "tool.output"];
+function inferSpanKind(name, attributes) {
+  if (isToolTelemetrySpan(attributes)) return "CHAIN";
+  const evidence = { ...attributes };
+  for (const key of SPAN_KIND_ATTR_KEYS) delete evidence[key];
+  const resolved = resolveSpanKind({ name, attributes: evidence });
+  if (resolved !== "UNKNOWN") return resolved;
+  const spanType = nonEmptyString(attributes["span.type"])?.toLowerCase();
+  const lowered = name.toLowerCase();
+  if (spanType === "llm_request" || lowered.includes("llm")) return "LLM";
+  if (spanType === "tool" || lowered.includes("tool") || LOCAL_TOOL_ATTRIBUTES.some((key) => attributes[key] != null)) {
+    return "TOOL";
+  }
+  if (spanType === "interaction" || lowered.includes("interaction") || lowered.includes("agent")) return "AGENT";
+  return "UNKNOWN";
+}
+function capturedToolIo(attributes) {
+  const input = attributes["input.value"] ?? attributes["tool.input"] ?? attributes.tool_input ?? attributes["gen_ai.tool.call.arguments"] ?? attributes["tool.arguments"] ?? attributes.tool_arguments ?? attributes.arguments ?? attributes.args ?? attributes.full_command;
+  const capture = toolArgumentsFromAttributes({ ...attributes, "input.value": input });
+  return toolIoAttributes({
+    input: capture.args,
+    output: attributes["output.value"] ?? attributes["tool.output"] ?? attributes.tool_output ?? attributes["gen_ai.tool.call.result"],
+    argsCaptured: capture.argsCaptured
+  });
+}
+function resolveRowKind(row, attributes, name) {
+  const declared = declaredSpanKind({ kind: row.kind, attributes });
+  if (declared.kind !== null) return { kind: declared.kind, declaredRaw: declared.raw, substituted: false };
+  if (isToolTelemetrySpan(attributes)) return { kind: "CHAIN", declaredRaw: declared.raw, substituted: true };
+  return { kind: inferSpanKind(name, attributes), declaredRaw: declared.raw, substituted: true };
+}
+function readLinks(value, traceId) {
+  if (!Array.isArray(value)) return [];
+  const links = [];
+  for (const entry of value) {
+    if (!isObject(entry)) continue;
+    const spanId = nonEmptyString(entry.span_id);
+    if (spanId === null) continue;
+    const attributes = isObject(entry.attributes) ? { ...entry.attributes } : void 0;
+    links.push({
+      trace_id: nonEmptyString(entry.trace_id) ?? traceId,
+      span_id: spanId,
+      ...attributes ? { attributes } : {}
+    });
+  }
+  return links;
+}
+function bridgeContractAttributes(attributes) {
+  const toolName = nonEmptyString(attributes[ATTR.toolName]);
+  if (toolName !== null && nonEmptyString(attributes[TOOL_NAME]) === null) {
+    attributes[TOOL_NAME] = toolName;
+  }
+}
+function parseTime(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return null;
+  try {
+    return parseIsoToEpochMs(value);
+  } catch {
+    return null;
+  }
+}
+function otlpRowToSpan(row, fallbackTraceId) {
+  if (!isObject(row)) {
+    const shape = row === null ? "null" : Array.isArray(row) ? "an array" : typeof row;
+    return { issue: { kind: "not-an-object", detail: `row is ${shape}` } };
+  }
+  const spanId = nonEmptyString(row.span_id);
+  if (spanId === null) return { issue: { kind: "missing-span-id", detail: "row carries no span_id" } };
+  const startMs = parseTime(row.start_time);
+  if (startMs === null) {
+    return { issue: { kind: "unreadable-timestamp", detail: `span ${spanId} has no readable start_time` } };
+  }
+  const attributes = isObject(row.attributes) ? { ...row.attributes } : {};
+  const resource = isObject(row.resource) ? row.resource : void 0;
+  const resourceAttributes = isObject(resource?.attributes) ? resource.attributes : void 0;
+  if (resourceAttributes) {
+    for (const [key, value] of Object.entries(resourceAttributes)) {
+      if (value != null && attributes[key] === void 0) attributes[key] = value;
+    }
+  }
+  const substituted = [];
+  const substitute = (field, declared) => {
+    substituted.push(field);
+    const key = RAW_FIELD_ATTRIBUTES[field];
+    if (declared === void 0) delete attributes[key];
+    else attributes[key] = declared;
+  };
+  const declaredTraceId = nonEmptyString(row.trace_id);
+  const traceId = declaredTraceId ?? fallbackTraceId;
+  if (declaredTraceId === null) {
+    substitute("trace_id", row.trace_id);
+    attributes[TRACE_ID_MINTED_ATTR] = true;
+  }
+  const parsedEndMs = parseTime(row.end_time);
+  const rawEndMs = parsedEndMs ?? startMs;
+  const durationUnmeasurable = rawEndMs < startMs;
+  const endMs = durationUnmeasurable ? startMs : rawEndMs;
+  if (durationUnmeasurable || parsedEndMs === null) substitute("end_time", row.end_time);
+  if (durationUnmeasurable) attributes[DURATION_UNMEASURABLE_ATTR] = true;
+  const withheld = durationUnmeasurable ? {
+    kind: "negative-duration",
+    field: "end_time",
+    detail: `span ${spanId} ends ${startMs - rawEndMs}ms before it starts; the span is analysed and its duration is withheld (not repaired), so it appears in every count except the latency ones`
+  } : void 0;
+  const name = nonEmptyString(row.name) ?? "span";
+  bridgeContractAttributes(attributes);
+  const { kind, declaredRaw, substituted: kindSubstituted } = resolveRowKind(row, attributes, name);
+  if (kindSubstituted) substitute("kind", declaredRaw ?? void 0);
+  attributes[ATTR.spanKind] = kind;
+  if (kind === "TOOL") Object.assign(attributes, capturedToolIo(attributes));
+  const status = isObject(row.status) ? row.status : void 0;
+  const statusMessage = nonEmptyString(status?.message);
+  const { code: statusCodeValue, substituted: statusSubstituted, raw: rawStatusCode } = readStatusCode(status?.code);
+  if (statusSubstituted) substitute("status.code", rawStatusCode);
+  const links = readLinks(row.links, traceId);
+  if (row.links !== void 0 && canonicalJson(links) !== canonicalJson(row.links)) {
+    substitute("links", row.links);
+  }
+  if (substituted.length > 0) attributes[SUBSTITUTED_FIELDS_ATTR] = substituted.join(",");
+  else delete attributes[SUBSTITUTED_FIELDS_ATTR];
+  return {
+    span: {
+      trace_id: traceId,
+      span_id: spanId,
+      parent_span_id: nonEmptyString(row.parent_span_id),
+      name,
+      start_time: new Date(startMs).toISOString(),
+      end_time: new Date(endMs).toISOString(),
+      status: { code: statusCodeValue, ...statusMessage ? { message: statusMessage } : {} },
+      attributes,
+      ...links.length > 0 ? { links } : {}
+    },
+    ...withheld ? { withheld } : {}
+  };
+}
+function isOtlpJsonEnvelope(row) {
+  return isObject(row) && Array.isArray(row.resourceSpans);
+}
+function isCamelCaseSpanRow(row) {
+  return isObject(row) && row.trace_id === void 0 && typeof row.traceId === "string" && (typeof row.spanId === "string" || typeof row.id === "string");
+}
+function isStandardOtlpRow(row) {
+  return isOtlpJsonEnvelope(row) || isCamelCaseSpanRow(row);
+}
+var ENVELOPE_START = /^\s*\{\s*"resourceSpans"\s*:/u;
+var ENVELOPE_HEAD_BYTES = 4096;
+async function isOtlpJsonFile(path) {
+  const handle = await open2(path, "r");
+  try {
+    const head = Buffer.alloc(ENVELOPE_HEAD_BYTES);
+    const { bytesRead } = await handle.read(head, 0, head.length, 0);
+    return ENVELOPE_START.test(head.toString("utf8", 0, bytesRead));
+  } finally {
+    await handle.close();
+  }
+}
+var OTEL_SPAN_KINDS = ["SPAN_KIND_UNSPECIFIED", "SPAN_KIND_INTERNAL", "SPAN_KIND_SERVER", "SPAN_KIND_CLIENT", "SPAN_KIND_PRODUCER", "SPAN_KIND_CONSUMER"];
+var OTEL_STATUS_CODES = ["STATUS_CODE_UNSET", "STATUS_CODE_OK", "STATUS_CODE_ERROR"];
+var OTEL_SPAN_KIND_ATTR = "otel.span.kind";
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function plainAttributeValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return boundedString(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value) && value.every(isPrimitive)) return value.map((item) => typeof item === "string" ? boundedString(item) : item);
+  return boundedString(JSON.stringify(value));
+}
+function anyValue(value) {
+  if (!isObject(value)) return void 0;
+  if (typeof value.stringValue === "string") return boundedString(value.stringValue);
+  if (typeof value.boolValue === "boolean") return value.boolValue;
+  if (value.intValue !== void 0) {
+    const number = Number(value.intValue);
+    return Number.isSafeInteger(number) ? number : String(value.intValue);
+  }
+  if (value.doubleValue !== void 0) {
+    const number = Number(value.doubleValue);
+    return Number.isFinite(number) ? number : String(value.doubleValue);
+  }
+  if (isObject(value.arrayValue)) {
+    return plainAttributeValue(Array.isArray(value.arrayValue.values) ? value.arrayValue.values.map(anyValue) : []);
+  }
+  if (isObject(value.kvlistValue)) return plainAttributeValue(attributeBag(value.kvlistValue.values));
+  if (typeof value.bytesValue === "string") return value.bytesValue;
+  return void 0;
+}
+function attributeBag(value) {
+  const bag = {};
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (!isObject(entry) || typeof entry.key !== "string") continue;
+      const plain = anyValue(entry.value);
+      if (plain !== void 0) bag[entry.key] = plain;
+    }
+  } else if (isObject(value)) {
+    for (const [key, entry] of Object.entries(value)) {
+      const plain = plainAttributeValue(entry);
+      if (plain !== void 0) bag[key] = plain;
+    }
+  }
+  return bag;
+}
+function otlpId(value, bytes) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  if (value.length === bytes * 2 && /^[0-9a-f]+$/iu.test(value)) return value.toLowerCase();
+  if (/^[A-Za-z0-9+/]+={0,2}$/u.test(value)) {
+    const decoded = Buffer.from(value, "base64");
+    if (decoded.length === bytes && decoded.toString("base64") === value) return decoded.toString("hex");
+  }
+  return value;
+}
+function nanosToIso(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  try {
+    const nanos = BigInt(typeof value === "number" ? Math.trunc(value) : value.trim());
+    return nanos > 0n ? new Date(Number(nanos / 1000000n)).toISOString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function statusRow(code, message) {
+  if (code === void 0 || code === null) return void 0;
+  const text = nonEmptyString(message);
+  return { code: typeof code === "number" ? OTEL_STATUS_CODES[code] ?? code : code, ...text ? { message: boundedString(text) } : {} };
+}
+function contractRowOf(span2, context = {}) {
+  const served = span2.spanId === void 0;
+  const rawSpanId = served && typeof span2.id === "string" && typeof span2.traceId === "string" && span2.id.startsWith(`${span2.traceId}:`) ? span2.id.slice(span2.traceId.length + 1) : span2.spanId ?? span2.id;
+  const traceId = otlpId(span2.traceId, 16);
+  const spanId = otlpId(rawSpanId, 8);
+  const start = nanosToIso(span2.startTimeUnixNano ?? span2.startUnixNano);
+  const end = nanosToIso(span2.endTimeUnixNano ?? span2.endUnixNano);
+  const attributes = attributeBag(span2.attributes);
+  const otelKind = typeof span2.kind === "number" ? OTEL_SPAN_KINDS[span2.kind] : nonEmptyString(span2.kind) ?? void 0;
+  if (otelKind !== void 0 && attributes[OTEL_SPAN_KIND_ATTR] === void 0) attributes[OTEL_SPAN_KIND_ATTR] = otelKind;
+  const status = served ? statusRow(span2.statusCode, span2.statusMessage) : statusRow(isObject(span2.status) ? span2.status.code ?? OTEL_STATUS_CODES[0] : OTEL_STATUS_CODES[0], isObject(span2.status) ? span2.status.message : void 0);
+  const links = !served && Array.isArray(span2.links) ? span2.links.map((link) => isObject(link) ? {
+    ...otlpId(link.traceId, 16) === void 0 ? {} : { trace_id: otlpId(link.traceId, 16) },
+    ...otlpId(link.spanId, 8) === void 0 ? {} : { span_id: otlpId(link.spanId, 8) },
+    ...link.attributes === void 0 ? {} : { attributes: attributeBag(link.attributes) }
+  } : link) : void 0;
+  return {
+    ...traceId === void 0 ? {} : { trace_id: traceId },
+    ...spanId === void 0 ? {} : { span_id: spanId },
+    parent_span_id: otlpId(span2.parentSpanId, 8) ?? null,
+    ...typeof span2.name === "string" ? { name: span2.name } : {},
+    ...start === void 0 ? {} : { start_time: start },
+    ...end === void 0 ? {} : { end_time: end },
+    ...status === void 0 ? {} : { status },
+    attributes,
+    ...links === void 0 ? {} : { links },
+    ...context.resource ? { resource: context.resource } : {},
+    ...context.scope ? { scope: context.scope } : {}
+  };
+}
+function* envelopeRows(envelope) {
+  for (const resourceSpans of envelope.resourceSpans) {
+    if (!isObject(resourceSpans)) {
+      yield resourceSpans;
+      continue;
+    }
+    const resource = isObject(resourceSpans.resource) ? { attributes: attributeBag(resourceSpans.resource.attributes) } : void 0;
+    const scopes = resourceSpans.scopeSpans ?? resourceSpans.instrumentationLibrarySpans;
+    if (!Array.isArray(scopes)) continue;
+    for (const scopeSpans of scopes) {
+      if (!isObject(scopeSpans)) {
+        yield scopeSpans;
+        continue;
+      }
+      const declared = scopeSpans.scope ?? scopeSpans.instrumentationLibrary;
+      const scope = isObject(declared) ? {
+        ...typeof declared.name === "string" ? { name: declared.name } : {},
+        ...typeof declared.version === "string" ? { version: declared.version } : {}
+      } : void 0;
+      if (!Array.isArray(scopeSpans.spans)) continue;
+      for (const span2 of scopeSpans.spans) yield isObject(span2) ? contractRowOf(span2, { resource, scope }) : span2;
+    }
+  }
+}
+function* contractRows(value) {
+  if (isOtlpJsonEnvelope(value)) yield* envelopeRows(value);
+  else if (isCamelCaseSpanRow(value)) yield contractRowOf(value);
+  else yield value;
+}
+var MAX_WHOLE_DOCUMENT_BYTES = 256 * 1024 * 1024;
+async function* fileRows(file, issues) {
+  if (await isOtlpJsonFile(file)) {
+    for await (const { value, line } of readJsonValues(file, (line2, detail) => issues.push({ kind: "unparseable-line", file, line: line2, detail }))) {
+      for (const row of contractRows(value)) yield { value: row, line };
+    }
+    return;
+  }
+  const firstIssue = issues.length;
+  let parsed = 0;
+  for await (const { value, lineNumber } of readJsonlLines(file, {
+    mode: "recover",
+    onCorruption: (receipt) => {
+      issues.push({ kind: "unparseable-line", file, line: receipt.lineNumber, detail: `line is not JSON (${receipt.byteLength} bytes)` });
+    }
+  })) {
+    parsed += 1;
+    for (const row of contractRows(value)) yield { value: row, line: lineNumber };
+  }
+  if (parsed > 0 || issues.length === firstIssue || (await stat(file)).size > MAX_WHOLE_DOCUMENT_BYTES) return;
+  let document;
+  try {
+    document = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return;
+  }
+  issues.splice(firstIssue);
+  for (const value of Array.isArray(document) ? document : [document]) {
+    for (const row of contractRows(value)) yield { value: row, line: 1 };
+  }
+}
+async function readOtlpInput(path) {
+  const { files: paths, skipped } = await resolveOtlpInputFiles(path);
+  const files = [];
+  const rows = [];
+  const spans = [];
+  const issues = [];
+  const withheld = [];
+  const seenIdentities = /* @__PURE__ */ new Map();
+  for (const file of paths) {
+    const fallbackTraceId = `otlp:${basename(file)}`;
+    let rowsFromFile = 0;
+    let spansFromFile = 0;
+    let repeatsFromFile = 0;
+    const traceIds = /* @__PURE__ */ new Set();
+    for await (const { value: row, line } of fileRows(file, issues)) {
+      rowsFromFile += 1;
+      rows.push(row);
+      const converted = otlpRowToSpan(row, fallbackTraceId);
+      if (converted.withheld) withheld.push({ ...converted.withheld, file, line });
+      if (converted.span) {
+        const identity = JSON.stringify([converted.span.trace_id, converted.span.span_id]);
+        const content = canonicalJson(converted.span);
+        const seen = seenIdentities.get(identity);
+        if (seen !== void 0) {
+          if (seen === content) {
+            repeatsFromFile += 1;
+            traceIds.add(converted.span.trace_id);
+            continue;
+          }
+          issues.push({
+            kind: "conflicting-span-id",
+            file,
+            line,
+            detail: `span ${converted.span.span_id} in trace ${converted.span.trace_id} was already read with DIFFERENT content; the later row was dropped`
+          });
+          continue;
+        }
+        seenIdentities.set(identity, content);
+        spans.push(converted.span);
+        traceIds.add(converted.span.trace_id);
+        spansFromFile += 1;
+      } else if (converted.issue) {
+        issues.push({ ...converted.issue, file, line });
+      }
+    }
+    files.push({
+      path: file,
+      rows: rowsFromFile,
+      spans: spansFromFile,
+      repeats: repeatsFromFile,
+      traceIds: [...traceIds]
+    });
+  }
+  const unreadable = stampUnreadableSourceRows(spans, issues);
+  return {
+    files,
+    skipped,
+    rows,
+    spans,
+    // Cast, not conversion: `validateTraceSpans` trusts nothing about its input
+    // and reports whatever it finds, which is exactly what a foreign trace needs.
+    validation: validateTraceSpans(rows),
+    issues,
+    withheld,
+    unreadable
+  };
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function stampUnreadableSourceRows(spans, issues) {
+  let inherited = 0;
+  const kinds = /* @__PURE__ */ new Set();
+  for (const span2 of spans) {
+    inherited = Math.max(inherited, positiveInteger(span2.attributes[SOURCE_UNREADABLE_ROWS_ATTR]));
+    const declared = span2.attributes[SOURCE_UNREADABLE_KINDS_ATTR];
+    if (typeof declared === "string") {
+      for (const kind of declared.split(",")) if (kind.length > 0) kinds.add(kind);
+    }
+  }
+  for (const issue of issues) kinds.add(issue.kind);
+  const total = inherited + issues.length;
+  const sortedKinds = [...kinds].sort();
+  if (total > 0) {
+    for (const span2 of spans) {
+      span2.attributes[SOURCE_UNREADABLE_ROWS_ATTR] = total;
+      span2.attributes[SOURCE_UNREADABLE_KINDS_ATTR] = sortedKinds.join(",");
+    }
+  }
+  return { rows: total, kinds: sortedKinds, inherited };
+}
+
+// src/version.ts
+import { readFileSync } from "fs";
+var fromSource;
+function tracesVersion() {
+  if (true) return "1.0.1";
+  if (fromSource) return fromSource;
+  const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+  if (typeof pkg.version !== "string" || !pkg.version) throw new Error("package.json is missing version");
+  fromSource = pkg.version;
+  return fromSource;
+}
+function tracesCommit() {
+  return true ? "1feb8c181d7a" : "source";
+}
+
+// src/otlp.ts
+import {
+  applyLlmSpanOtlpAttributes,
+  LLM_COST_USD,
+  LLM_INPUT_TOKENS,
+  LLM_MODEL_NAME,
+  LLM_OUTPUT_TOKENS,
+  OPENINFERENCE_SPAN_KIND,
+  TOOL_NAME as TOOL_NAME2
+} from "@tangle-network/agent-eval/trace-attributes";
+
+// src/span-validation.ts
+var STATUS_CODES = /* @__PURE__ */ new Set(["OK", "ERROR", "UNSET"]);
+function validateOtlpSpans(input, source = "OTLP spans") {
+  if (!Array.isArray(input)) throw new TypeError(`${source} must be an array`);
+  const spans = [];
+  const identities = /* @__PURE__ */ new Set();
+  for (const [index, value] of input.entries()) {
+    const path = `${source}[${index}]`;
+    const record = requireObject(value, path);
+    const traceId = requireNonEmptyString(record.trace_id, `${path}.trace_id`);
+    const spanId = requireNonEmptyString(record.span_id, `${path}.span_id`);
+    const parentSpanId = record.parent_span_id;
+    if (parentSpanId !== null) {
+      requireNonEmptyString(parentSpanId, `${path}.parent_span_id`);
+    }
+    requireNonEmptyString(record.name, `${path}.name`);
+    const startTime = requireNonEmptyString(record.start_time, `${path}.start_time`);
+    const endTime = requireNonEmptyString(record.end_time, `${path}.end_time`);
+    const startMs = parseTimestamp(startTime, `${path}.start_time`);
+    const endMs = parseTimestamp(endTime, `${path}.end_time`);
+    if (endMs < startMs) {
+      throw new RangeError(
+        `${path}.end_time must not precede start_time (${endTime} < ${startTime})`
+      );
+    }
+    const status = requireObject(record.status, `${path}.status`);
+    if (!STATUS_CODES.has(status.code)) {
+      throw new TypeError(`${path}.status.code must be OK, ERROR, or UNSET`);
+    }
+    if (status.message !== void 0 && typeof status.message !== "string") {
+      throw new TypeError(`${path}.status.message must be a string when present`);
+    }
+    requireObject(record.attributes, `${path}.attributes`);
+    requireLinks(record.links, `${path}.links`);
+    const identity = JSON.stringify([traceId, spanId]);
+    if (identities.has(identity)) {
+      throw new Error(`${source} contains duplicate span identity (${traceId}, ${spanId})`);
+    }
+    identities.add(identity);
+    spans.push(value);
+  }
+  return spans;
+}
+function requireLinks(value, path) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) throw new TypeError(`${path} must be an array when present`);
+  for (const [index, entry] of value.entries()) {
+    const link = requireObject(entry, `${path}[${index}]`);
+    requireNonEmptyString(link.trace_id, `${path}[${index}].trace_id`);
+    requireNonEmptyString(link.span_id, `${path}[${index}].span_id`);
+    if (link.attributes !== void 0) requireObject(link.attributes, `${path}[${index}].attributes`);
+  }
+}
+function parseTimestamp(value, path) {
+  try {
+    return parseIsoToEpochMs(value);
+  } catch {
+    throw new TypeError(`${path} must be a finite ISO-8601 or epoch-millis timestamp`);
+  }
+}
+function requireObject(value, path) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${path} must be an object`);
+  }
+  return value;
+}
+function requireNonEmptyString(value, path) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${path} must be a non-empty string`);
+  }
+  return value;
+}
+
+// src/otlp.ts
+function span(input) {
+  const attributes = {
+    [OPENINFERENCE_SPAN_KIND]: input.kind
+  };
+  if (input.service != null) attributes["service.name"] = input.service;
+  if (input.agent != null) attributes["agent.name"] = input.agent;
+  if (input.tool != null) attributes[TOOL_NAME2] = input.tool;
+  applyLlmSpanOtlpAttributes(attributes, {
+    model: input.model ?? void 0,
+    inputTokens: input.inputTokens ?? void 0,
+    outputTokens: input.outputTokens ?? void 0,
+    reasoningTokens: input.reasoningTokens ?? void 0,
+    cachedTokens: input.cachedInputTokens ?? void 0,
+    cacheWriteTokens: input.cacheWriteInputTokens ?? void 0,
+    costUsd: input.costUsd ?? void 0
+  });
+  if (input.step != null) attributes.step = input.step;
+  if (input.content != null && input.content.length > 0) attributes["content"] = input.content;
+  if (input.extra) Object.assign(attributes, input.extra);
+  if (input.content) Object.assign(attributes, sourceAttributes("content", input.contentSource));
+  const status = { code: input.status ?? "OK" };
+  if (input.statusMessage && input.statusMessage.length > 0) status.message = input.statusMessage;
+  return {
+    trace_id: input.traceId,
+    span_id: input.spanId,
+    parent_span_id: input.parentSpanId ?? null,
+    name: input.name,
+    start_time: input.startTime,
+    end_time: input.endTime ?? input.startTime,
+    status,
+    attributes,
+    ...input.links && input.links.length > 0 ? { links: input.links.map((link) => ({ ...link })) } : {}
+  };
+}
+function producerField(attributes, field) {
+  const declared = attributes[SUBSTITUTED_FIELDS_ATTR];
+  if (typeof declared !== "string" || !declared.split(",").includes(field)) return { substituted: false };
+  const key = RAW_FIELD_ATTRIBUTES[field];
+  return key in attributes ? { substituted: true, wrote: true, value: attributes[key] } : { substituted: true, wrote: false };
+}
+var EXPORT_RULE = Object.freeze({
+  trace_id: "analysed",
+  end_time: "faithful",
+  "status.code": "faithful",
+  kind: "declared-or-analysed",
+  links: "faithful"
+});
+function producerEntry(attributes, field, key, analysed) {
+  const producer = producerField(attributes, field);
+  if (producer.substituted) {
+    if (producer.wrote && EXPORT_RULE[field] !== "analysed") return { [key]: producer.value };
+    if (EXPORT_RULE[field] === "faithful") return {};
+  }
+  return analysed === void 0 ? {} : { [key]: analysed };
+}
+function toOpenInferenceSpan(s) {
+  const a = s.attributes;
+  const attributes = { ...a };
+  attributes["inference.observation_kind"] ??= a[OPENINFERENCE_SPAN_KIND];
+  if (a["agent.name"] != null) attributes["inference.agent_name"] ??= a["agent.name"];
+  if (a[LLM_MODEL_NAME] != null) attributes["inference.llm.model_name"] ??= a[LLM_MODEL_NAME];
+  if (a[LLM_INPUT_TOKENS] != null) attributes["inference.llm.input_tokens"] ??= a[LLM_INPUT_TOKENS];
+  if (a[LLM_OUTPUT_TOKENS] != null) attributes["inference.llm.output_tokens"] ??= a[LLM_OUTPUT_TOKENS];
+  if (a[LLM_COST_USD] != null) attributes["inference.llm.cost.total"] ??= a[LLM_COST_USD];
+  const resourceAttrs = {};
+  if (a["service.name"] != null) resourceAttrs["service.name"] = a["service.name"];
+  if (a["agent.name"] != null) resourceAttrs["agent.name"] = a["agent.name"];
+  for (const k of ["tangle.subject.key", "git.repository", "git.branch", "git.commit", "tangle.cwd", "traces.repo_resolution_source"]) {
+    if (a[k] != null) resourceAttrs[k] = a[k];
+  }
+  for (const k of ["container.image.name", "container.image.digest", "tangle.sandbox.id", "tangle.environment.cwd"]) {
+    if (a[k] != null) resourceAttrs[k] = a[k];
+  }
+  for (const k of ["traces.source.unreadable_rows", "traces.source.unreadable_row_kinds"]) {
+    if (a[k] != null) resourceAttrs[k] = a[k];
+  }
+  resourceAttrs["traces.version"] = tracesVersion();
+  const analysedKind = typeof a[OPENINFERENCE_SPAN_KIND] === "string" ? a[OPENINFERENCE_SPAN_KIND] : "UNKNOWN";
+  return {
+    // Substituted fields carry the PRODUCER's value, or no field at all when the
+    // producer wrote none — see `producerField`. Emitting the analysed value
+    // here is what made a re-export validate cleaner than its own source.
+    ...producerEntry(a, "trace_id", "trace_id", s.trace_id),
+    span_id: s.span_id,
+    parent_span_id: s.parent_span_id ?? "",
+    name: s.name,
+    ...producerEntry(a, "kind", "kind", analysedKind),
+    start_time: s.start_time,
+    ...producerEntry(a, "end_time", "end_time", s.end_time),
+    status: {
+      ...producerEntry(a, "status.code", "code", `STATUS_CODE_${s.status.code}`),
+      message: s.status.message ?? ""
+    },
+    resource: { attributes: resourceAttrs },
+    scope: { name: "tangle-traces", version: "" },
+    attributes,
+    ...producerEntry(
+      a,
+      "links",
+      "links",
+      s.links && s.links.length > 0 ? s.links.map((link) => ({ ...link })) : void 0
+    )
+  };
+}
+function* iterSerializedSpans(spans) {
+  for (const s of validateOtlpSpans(spans, "serialized spans")) {
+    yield `${JSON.stringify(toOpenInferenceSpan(s))}
+`;
+  }
+}
+var OTLP_WRITE_CHUNK_CHARS = 4 * 1024 * 1024;
+async function writeOtlpFile(spans, path) {
+  const { open: open3 } = await import("fs/promises");
+  const handle = await open3(path, "w");
+  try {
+    let chunk = "";
+    for (const line of iterSerializedSpans(spans)) {
+      chunk += line;
+      if (chunk.length >= OTLP_WRITE_CHUNK_CHARS) {
+        await handle.write(chunk);
+        chunk = "";
+      }
+    }
+    if (chunk.length > 0) await handle.write(chunk);
+  } finally {
+    await handle.close();
+  }
+  return path;
+}
+
+export {
+  appendAll,
+  readJsonl,
+  takeJsonl,
+  TRACE_ID_MINTED_ATTR,
+  otlpRowToSpan,
+  isStandardOtlpRow,
+  isOtlpJsonFile,
+  readOtlpInput,
+  validateOtlpSpans,
+  tracesVersion,
+  tracesCommit,
+  span,
+  toOpenInferenceSpan,
+  iterSerializedSpans,
+  writeOtlpFile
+};