agent-inspect 1.5.0 → 1.6.0

package/packages/core/dist/writers.cjs

@@ -0,0 +1,997 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var crypto = require('crypto');
+var os = require('os');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var os__default = /*#__PURE__*/_interopDefault(os);
+
+// packages/core/src/writers/index.ts
+var DEFAULT_REDACT_KEYS = [
+  "authorization",
+  "cookie",
+  "token",
+  "apiKey",
+  "password",
+  "secret",
+  "email"
+];
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function toKey(s) {
+  return s.toLowerCase();
+}
+function stableHash(value) {
+  const h = crypto__default.default.createHash("sha256").update(value, "utf8").digest("hex");
+  return h.slice(0, 8);
+}
+function compileRules(rules, extraKeys) {
+  const out = /* @__PURE__ */ new Map();
+  const set = (r) => {
+    const k = toKey(r.key);
+    out.set(k, { ...r, key: k });
+  };
+  for (const k of DEFAULT_REDACT_KEYS) {
+    set({ key: k, strategy: "full" });
+  }
+  for (const k of extraKeys ?? []) {
+    if (typeof k === "string" && k.length > 0) {
+      set({ key: k, strategy: "full" });
+    }
+  }
+  for (const r of rules ?? []) {
+    if (typeof r === "string") {
+      set({ key: r, strategy: "full" });
+      continue;
+    }
+    const key = r.key;
+    if (r.strategy === "full") set({ key, strategy: "full" });
+    if (r.strategy === "hash") set({ key, strategy: "hash" });
+    if (r.strategy === "prefix") {
+      set({ key, strategy: "prefix", keep: typeof r.keep === "number" ? r.keep : 8 });
+    }
+  }
+  return [...out.values()];
+}
+var Redactor = class {
+  #rules;
+  constructor(options) {
+    this.#rules = compileRules(options?.rules, options?.extraKeys);
+  }
+  redactValue(key, value) {
+    const k = toKey(key);
+    const rule = this.#rules.find((r) => r.key === k);
+    if (!rule) {
+      return this.#redactNested(value);
+    }
+    if (rule.strategy === "full") return "[REDACTED]";
+    const asString = typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? String(value) : void 0;
+    if (rule.strategy === "prefix") {
+      if (asString === void 0) return "[REDACTED]";
+      const keep = Math.max(0, Math.floor(rule.keep));
+      return asString.length <= keep ? `${asString}\u2026` : `${asString.slice(0, keep)}\u2026`;
+    }
+    if (rule.strategy === "hash") {
+      if (asString === void 0) return "[HASH:unknown]";
+      return `[HASH:${stableHash(asString)}]`;
+    }
+    return this.#redactNested(value);
+  }
+  redactRecord(record) {
+    const out = {};
+    for (const [k, v] of Object.entries(record)) {
+      out[k] = this.redactValue(k, v);
+    }
+    return out;
+  }
+  #redactNested(value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => this.#redactNested(v));
+    }
+    if (isRecord(value)) {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = this.redactValue(k, v);
+      }
+      return out;
+    }
+    return value;
+  }
+};
+
+// packages/core/src/redaction-profiles.ts
+var SHARE_PROFILE_EXTRA_KEYS = [
+  "userEmail",
+  "customerEmail",
+  "phone",
+  "phoneNumber",
+  "address",
+  "ip",
+  "ipAddress",
+  "sessionId",
+  "requestId",
+  "correlationId",
+  "decisionId",
+  "groupId",
+  "customerId",
+  "userId",
+  "accountId",
+  "tenantId",
+  "orgId",
+  "organizationId",
+  "traceId",
+  "spanId",
+  "parentSpanId"
+];
+var STRICT_PROFILE_EXTRA_KEYS = [
+  "prompt",
+  "completion",
+  "input",
+  "output",
+  "inputPreview",
+  "outputPreview",
+  "message",
+  "messages",
+  "transcript",
+  "context",
+  "document",
+  "documents",
+  "chunk",
+  "chunks",
+  "retrieval",
+  "query"
+];
+function resolveRedactionProfile(profile = "local") {
+  switch (profile) {
+    case "local":
+      return { profile: "local", extraKeys: [] };
+    case "share":
+      return {
+        profile: "share",
+        extraKeys: SHARE_PROFILE_EXTRA_KEYS,
+        maxMetadataValueLengthCap: 500,
+        maxPreviewLengthCap: 200
+      };
+    case "strict":
+      return {
+        profile: "strict",
+        extraKeys: [...SHARE_PROFILE_EXTRA_KEYS, ...STRICT_PROFILE_EXTRA_KEYS],
+        maxMetadataValueLengthCap: 200,
+        maxPreviewLengthCap: 80
+      };
+    default:
+      return { profile: "local", extraKeys: [] };
+  }
+}
+
+// packages/core/src/types/persisted-inspect-event.ts
+var INSPECT_KINDS = [
+  "RUN",
+  "AGENT",
+  "LLM",
+  "TOOL",
+  "CHAIN",
+  "RETRIEVER",
+  "DECISION",
+  "RESULT",
+  "ERROR",
+  "LOGIC",
+  "LOG"
+];
+var ATTRIBUTION_CONFIDENCES = [
+  "explicit",
+  "correlated",
+  "heuristic",
+  "unknown"
+];
+var PERSISTED_EVENT_SOURCE_TYPES = [
+  "manual",
+  "json-log",
+  "log4js",
+  "adapter",
+  "ai-sdk",
+  "otel"
+];
+var PERSISTED_EVENT_STATUSES = [
+  "running",
+  "ok",
+  "error",
+  "unknown"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isOptionalString(value) {
+  return value === void 0 || isString(value);
+}
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isOptionalNonNegativeNumber(value) {
+  return value === void 0 || isNonNegativeNumber(value);
+}
+function isInspectKind(value) {
+  return typeof value === "string" && INSPECT_KINDS.includes(value);
+}
+function isAttributionConfidence(value) {
+  return typeof value === "string" && ATTRIBUTION_CONFIDENCES.includes(value);
+}
+function isPersistedEventSourceType(value) {
+  return typeof value === "string" && PERSISTED_EVENT_SOURCE_TYPES.includes(value);
+}
+function isPersistedEventStatus(value) {
+  return typeof value === "string" && PERSISTED_EVENT_STATUSES.includes(value);
+}
+function isPersistedEventSource(value) {
+  if (!isRecord2(value)) return false;
+  if (!isPersistedEventSourceType(value.type)) return false;
+  if (!isOptionalString(value.name)) return false;
+  if (!isOptionalString(value.version)) return false;
+  return true;
+}
+function isPersistedInspectError(value) {
+  if (!isRecord2(value)) return false;
+  if (!isNonEmptyString(value.message)) return false;
+  if (!isOptionalString(value.name)) return false;
+  if (!isOptionalString(value.code)) return false;
+  return true;
+}
+function isPersistedTokenUsage(value) {
+  if (!isRecord2(value)) return false;
+  if (!isOptionalNonNegativeNumber(value.input)) return false;
+  if (!isOptionalNonNegativeNumber(value.output)) return false;
+  if (!isOptionalNonNegativeNumber(value.total)) return false;
+  if (!isOptionalNonNegativeNumber(value.cached)) return false;
+  return true;
+}
+function isPersistedTraceContext(value) {
+  if (!isRecord2(value)) return false;
+  if (!isOptionalString(value.traceId)) return false;
+  if (!isOptionalString(value.spanId)) return false;
+  if (!isOptionalString(value.parentSpanId)) return false;
+  return true;
+}
+function isPersistedInspectEvent(value) {
+  if (!isRecord2(value)) return false;
+  if (value.schemaVersion !== "0.2") return false;
+  if (!isNonEmptyString(value.eventId)) return false;
+  if (!isNonEmptyString(value.runId)) return false;
+  if (!isInspectKind(value.kind)) return false;
+  if (!isNonEmptyString(value.name)) return false;
+  if (!isNonEmptyString(value.timestamp)) return false;
+  if (!isAttributionConfidence(value.confidence)) return false;
+  if (!isPersistedEventSource(value.source)) return false;
+  if (value.parentId !== void 0 && !isNonEmptyString(value.parentId)) {
+    return false;
+  }
+  if (value.status !== void 0 && !isPersistedEventStatus(value.status)) {
+    return false;
+  }
+  if (!isOptionalString(value.startedAt)) return false;
+  if (!isOptionalString(value.endedAt)) return false;
+  if (value.durationMs !== void 0 && !isNonNegativeNumber(value.durationMs)) {
+    return false;
+  }
+  if (value.attributes !== void 0 && !isRecord2(value.attributes)) {
+    return false;
+  }
+  if (value.error !== void 0 && !isPersistedInspectError(value.error)) {
+    return false;
+  }
+  if (value.tokenUsage !== void 0 && !isPersistedTokenUsage(value.tokenUsage)) {
+    return false;
+  }
+  if (value.trace !== void 0 && !isPersistedTraceContext(value.trace)) {
+    return false;
+  }
+  return true;
+}
+var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
+var RUNS_DIR_NAME = "runs";
+var FALLBACK_TRACE_DIR = path__default.default.join(
+  os__default.default.tmpdir(),
+  "agent-inspect",
+  RUNS_DIR_NAME
+);
+function getDefaultTraceDir() {
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
+  try {
+    const home = os__default.default.homedir();
+    if (typeof home !== "string" || home.trim() === "") {
+      return FALLBACK_TRACE_DIR;
+    }
+    return path__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+  } catch {
+    return FALLBACK_TRACE_DIR;
+  }
+}
+function getTraceFilePath(runId, traceDir) {
+  const baseDir = traceDir ?? getDefaultTraceDir();
+  let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
+  safeId = path__default.default.basename(safeId);
+  if (safeId === "" || safeId === "." || safeId === "..") {
+    safeId = "run_unknown";
+  }
+  return path__default.default.join(baseDir, `${safeId}.jsonl`);
+}
+
+// packages/core/src/trace-event-safety.ts
+var DEFAULT_MAX_METADATA_VALUE_LENGTH = 2e3;
+var DEFAULT_MAX_PREVIEW_LENGTH = 500;
+var DEFAULT_MAX_EVENT_BYTES = 65536;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPreviewKey(key) {
+  return key.toLowerCase().includes("preview");
+}
+function truncateString(value, maxLen) {
+  if (maxLen <= 0) return "\u2026";
+  if (value.length <= maxLen) return value;
+  return `${value.slice(0, maxLen)}\u2026`;
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function resolveTraceSafetyOptions(options) {
+  let redactEnabled = true;
+  let redactionRules;
+  {
+    redactEnabled = true;
+  }
+  const profile = "local";
+  const resolvedProfile = resolveRedactionProfile(profile);
+  let maxMetadataValueLength = DEFAULT_MAX_METADATA_VALUE_LENGTH;
+  let maxPreviewLength = DEFAULT_MAX_PREVIEW_LENGTH;
+  return {
+    redactEnabled,
+    redactionRules,
+    redactionProfile: profile,
+    profileExtraKeys: redactEnabled ? resolvedProfile.extraKeys : [],
+    maxMetadataValueLength,
+    maxPreviewLength,
+    maxEventBytes: DEFAULT_MAX_EVENT_BYTES
+  };
+}
+function boundMetadataValue(key, value, opts, seen, depth) {
+  if (depth > 32) return "[MaxDepth]";
+  if (typeof value === "bigint") {
+    return `${value.toString()}n`;
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (typeof value === "symbol") {
+    return "[Symbol]";
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  if (value === void 0) {
+    return null;
+  }
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "string") {
+      const max = isPreviewKey(key) ? opts.maxPreviewLength : opts.maxMetadataValueLength;
+      return truncateString(value, max);
+    }
+    return value;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const maxItems = 50;
+    const out2 = value.slice(0, maxItems).map(
+      (item, index) => boundMetadataValue(String(index), item, opts, seen, depth + 1)
+    );
+    if (value.length > maxItems) {
+      out2.push(`\u2026(+${value.length - maxItems} more)`);
+    }
+    return out2;
+  }
+  const record = value;
+  const out = {};
+  try {
+    for (const [k, v] of Object.entries(record)) {
+      out[k] = boundMetadataValue(k, v, opts, seen, depth + 1);
+    }
+  } catch {
+    return { truncated: true, reason: "metadataEnumerationFailed" };
+  }
+  return out;
+}
+function redactMetadata(metadata, opts) {
+  if (!opts.redactEnabled) return { ...metadata };
+  const redactor = new Redactor({
+    rules: opts.redactionRules,
+    extraKeys: opts.profileExtraKeys
+  });
+  return redactor.redactRecord(metadata);
+}
+function prepareMetadataForDisk(metadata, opts) {
+  try {
+    const preBounded = boundMetadataValue(
+      "metadata",
+      metadata,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    const redacted = redactMetadata(
+      isRecord3(preBounded) ? preBounded : {},
+      opts
+    );
+    const bounded = boundMetadataValue(
+      "metadata",
+      redacted,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    return isRecord3(bounded) ? bounded : {};
+  } catch {
+    return { truncated: true, reason: "metadataPreparationFailed" };
+  }
+}
+function safeGet(record, key) {
+  try {
+    return record[key];
+  } catch {
+    return void 0;
+  }
+}
+function optionalBoundedString(value, _key, opts) {
+  if (typeof value !== "string") return void 0;
+  return truncateString(value, opts.maxMetadataValueLength);
+}
+function requiredBoundedString(value, key, opts) {
+  const out = optionalBoundedString(value, key, opts);
+  return out && out.length > 0 ? out : void 0;
+}
+function preparePersistedSummaryForDisk(key, value, opts) {
+  try {
+    const redactor = new Redactor({
+      rules: opts.redactionRules,
+      extraKeys: opts.profileExtraKeys
+    });
+    const redacted = opts.redactEnabled ? redactor.redactValue(key, value) : value;
+    return boundMetadataValue(key, redacted, opts, /* @__PURE__ */ new WeakSet(), 0);
+  } catch {
+    return { truncated: true, reason: "summaryPreparationFailed" };
+  }
+}
+function preparePersistedErrorForDisk(value, opts) {
+  if (!isRecord3(value)) return void 0;
+  try {
+    const redactor = new Redactor({
+      rules: opts.redactionRules,
+      extraKeys: opts.profileExtraKeys
+    });
+    const rawMessage = safeGet(value, "message");
+    const redactedMessage = opts.redactEnabled ? redactor.redactValue("message", rawMessage) : rawMessage;
+    const boundedMessage = boundMetadataValue(
+      "message",
+      redactedMessage,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    const message = typeof boundedMessage === "string" && boundedMessage.length > 0 ? boundedMessage : "Unknown error";
+    const out = { message };
+    const name = optionalBoundedString(safeGet(value, "name"), "name", opts);
+    const code = optionalBoundedString(safeGet(value, "code"), "code", opts);
+    if (name !== void 0) out.name = name;
+    if (code !== void 0) out.code = code;
+    return out;
+  } catch {
+    return { message: "Error preparation failed" };
+  }
+}
+function prepareTokenUsage(value) {
+  if (!isRecord3(value)) return void 0;
+  const out = {};
+  for (const key of ["input", "output", "total", "cached"]) {
+    const item = safeGet(value, key);
+    if (typeof item === "number" && Number.isFinite(item) && item >= 0) {
+      out[key] = item;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function prepareTraceContext(value, opts) {
+  if (!isRecord3(value)) return void 0;
+  const out = {};
+  const traceId = optionalBoundedString(safeGet(value, "traceId"), "traceId", opts);
+  const spanId = optionalBoundedString(safeGet(value, "spanId"), "spanId", opts);
+  const parentSpanId = optionalBoundedString(
+    safeGet(value, "parentSpanId"),
+    "parentSpanId",
+    opts
+  );
+  if (traceId !== void 0) out.traceId = traceId;
+  if (spanId !== void 0) out.spanId = spanId;
+  if (parentSpanId !== void 0) out.parentSpanId = parentSpanId;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function serializedPersistedEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return void 0;
+  }
+}
+function persistedEventByteLength(event) {
+  const serialized = serializedPersistedEvent(event);
+  return serialized === void 0 ? void 0 : byteLength(serialized);
+}
+function minimalPersistedEvent(event, opts, originalApproxBytes) {
+  return {
+    schemaVersion: "0.2",
+    eventId: truncateString(event.eventId, 128),
+    runId: truncateString(event.runId, 128),
+    kind: event.kind,
+    name: truncateString(event.name, 128),
+    ...event.status !== void 0 ? { status: event.status } : {},
+    timestamp: truncateString(event.timestamp, 128),
+    confidence: event.confidence,
+    source: {
+      type: event.source.type,
+      ...event.source.name !== void 0 ? { name: truncateString(event.source.name, 128) } : {},
+      ...event.source.version !== void 0 ? { version: truncateString(event.source.version, 128) } : {}
+    },
+    attributes: {
+      truncated: true,
+      reason: "maxEventBytes",
+      originalApproxBytes,
+      maxEventBytes: opts.maxEventBytes
+    }
+  };
+}
+function tinyPersistedEvent(event) {
+  return {
+    schemaVersion: "0.2",
+    eventId: truncateString(event.eventId, 32),
+    runId: truncateString(event.runId, 32),
+    kind: event.kind,
+    name: truncateString(event.name, 32),
+    timestamp: truncateString(event.timestamp, 32),
+    confidence: event.confidence,
+    source: { type: event.source.type },
+    attributes: { truncated: true, reason: "maxEventBytes" }
+  };
+}
+function enforcePersistedEventSize(event, opts) {
+  const bytes = persistedEventByteLength(event);
+  if (bytes === void 0) return void 0;
+  if (bytes <= opts.maxEventBytes) return event;
+  const minimal = minimalPersistedEvent(event, opts, bytes);
+  const minimalBytes = persistedEventByteLength(minimal);
+  if (minimalBytes !== void 0 && minimalBytes <= opts.maxEventBytes) {
+    return minimal;
+  }
+  const tiny = tinyPersistedEvent(event);
+  return isPersistedInspectEvent(tiny) ? tiny : void 0;
+}
+function preparePersistedInspectEventForWrite(value, opts = resolveTraceSafetyOptions()) {
+  try {
+    if (!isRecord3(value)) return void 0;
+    const source = safeGet(value, "source");
+    if (!isRecord3(source)) return void 0;
+    const candidate = {
+      schemaVersion: safeGet(value, "schemaVersion"),
+      eventId: requiredBoundedString(safeGet(value, "eventId"), "eventId", opts) ?? "",
+      runId: requiredBoundedString(safeGet(value, "runId"), "runId", opts) ?? "",
+      kind: safeGet(value, "kind"),
+      name: requiredBoundedString(safeGet(value, "name"), "name", opts) ?? "",
+      timestamp: requiredBoundedString(safeGet(value, "timestamp"), "timestamp", opts) ?? "",
+      confidence: safeGet(value, "confidence"),
+      source: {
+        type: safeGet(source, "type")
+      }
+    };
+    const parentId = requiredBoundedString(safeGet(value, "parentId"), "parentId", opts);
+    const status = safeGet(value, "status");
+    const startedAt = optionalBoundedString(safeGet(value, "startedAt"), "startedAt", opts);
+    const endedAt = optionalBoundedString(safeGet(value, "endedAt"), "endedAt", opts);
+    const durationMs = safeGet(value, "durationMs");
+    const sourceName = optionalBoundedString(safeGet(source, "name"), "name", opts);
+    const sourceVersion = optionalBoundedString(safeGet(source, "version"), "version", opts);
+    if (parentId !== void 0) candidate.parentId = parentId;
+    if (status === "running" || status === "ok" || status === "error" || status === "unknown") {
+      candidate.status = status;
+    }
+    if (startedAt !== void 0) candidate.startedAt = startedAt;
+    if (endedAt !== void 0) candidate.endedAt = endedAt;
+    if (typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs >= 0) {
+      candidate.durationMs = durationMs;
+    }
+    if (sourceName !== void 0) candidate.source.name = sourceName;
+    if (sourceVersion !== void 0) candidate.source.version = sourceVersion;
+    const attributes = safeGet(value, "attributes");
+    if (isRecord3(attributes)) {
+      candidate.attributes = prepareMetadataForDisk(attributes, opts);
+    }
+    if (safeGet(value, "inputSummary") !== void 0) {
+      candidate.inputSummary = preparePersistedSummaryForDisk(
+        "input",
+        safeGet(value, "inputSummary"),
+        opts
+      );
+    }
+    if (safeGet(value, "outputSummary") !== void 0) {
+      candidate.outputSummary = preparePersistedSummaryForDisk(
+        "output",
+        safeGet(value, "outputSummary"),
+        opts
+      );
+    }
+    const error = preparePersistedErrorForDisk(safeGet(value, "error"), opts);
+    if (error !== void 0) candidate.error = error;
+    const tokenUsage = prepareTokenUsage(safeGet(value, "tokenUsage"));
+    if (tokenUsage !== void 0) candidate.tokenUsage = tokenUsage;
+    const trace = prepareTraceContext(safeGet(value, "trace"), opts);
+    if (trace !== void 0) candidate.trace = trace;
+    if (!isPersistedInspectEvent(candidate)) return void 0;
+    return enforcePersistedEventSize(candidate, opts);
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/src/writers/index.ts
+var DEFAULT_TRACE_SAFETY = resolveTraceSafetyOptions();
+function createInitialStats() {
+  return {
+    writtenEvents: 0,
+    droppedEvents: 0,
+    flushCount: 0
+  };
+}
+function markFlush(stats) {
+  stats.flushCount += 1;
+  stats.lastFlushAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneStats(stats) {
+  return { ...stats };
+}
+function normalizeError(error) {
+  if (error instanceof Error && error.message.trim() !== "") {
+    return error.message;
+  }
+  if (typeof error === "string" && error.trim() !== "") {
+    return error;
+  }
+  return "Unknown trace writer error";
+}
+function recordDropped(stats, error) {
+  stats.droppedEvents += 1;
+  stats.lastError = normalizeError(error);
+}
+function prepareWriterEvent(event) {
+  return preparePersistedInspectEventForWrite(event, DEFAULT_TRACE_SAFETY);
+}
+function resolveFilePath(event, options) {
+  if (options.filePath && options.filePath.trim() !== "") {
+    return path__default.default.resolve(options.filePath);
+  }
+  return getTraceFilePath(event.runId, options.dir);
+}
+function serializeEvent2(event) {
+  return `${JSON.stringify(event)}
+`;
+}
+async function appendEventLine(event, options) {
+  const filePath = resolveFilePath(event, options);
+  await promises.mkdir(path__default.default.dirname(filePath), { recursive: true });
+  await promises.appendFile(filePath, serializeEvent2(event), "utf-8");
+}
+async function appendEventBatch(events, options) {
+  const byPath = /* @__PURE__ */ new Map();
+  let dropped = 0;
+  let lastError;
+  for (const event of events) {
+    try {
+      const filePath = resolveFilePath(event, options);
+      const line = serializeEvent2(event);
+      const lines = byPath.get(filePath);
+      if (lines) {
+        lines.push(line);
+      } else {
+        byPath.set(filePath, [line]);
+      }
+    } catch (error) {
+      dropped += 1;
+      lastError = normalizeError(error);
+    }
+  }
+  let written = 0;
+  for (const [filePath, lines] of byPath) {
+    try {
+      await promises.mkdir(path__default.default.dirname(filePath), { recursive: true });
+      await promises.appendFile(filePath, lines.join(""), "utf-8");
+      written += lines.length;
+    } catch (error) {
+      dropped += lines.length;
+      lastError = normalizeError(error);
+    }
+  }
+  return lastError ? { written, dropped, lastError } : { written, dropped };
+}
+function memoryWriter() {
+  const events = [];
+  const stats = createInitialStats();
+  return {
+    async write(event) {
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return;
+      }
+      events.push(safe);
+      stats.writtenEvents += 1;
+    },
+    async flush() {
+      markFlush(stats);
+    },
+    async close() {
+    },
+    getStats() {
+      return cloneStats(stats);
+    },
+    getEvents() {
+      return events.map((event) => structuredClone(event));
+    },
+    clear() {
+      events.length = 0;
+    }
+  };
+}
+function nullWriter() {
+  const stats = createInitialStats();
+  return {
+    async write() {
+      stats.writtenEvents += 1;
+    },
+    async flush() {
+      markFlush(stats);
+    },
+    async close() {
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+function fileWriter(options = {}) {
+  const stats = createInitialStats();
+  let closed = false;
+  let queue = Promise.resolve();
+  const enqueue = (event) => {
+    const operation = queue.then(async () => {
+      if (closed) {
+        recordDropped(stats, "Trace writer is closed");
+        return;
+      }
+      try {
+        await appendEventLine(event, options);
+        stats.writtenEvents += 1;
+      } catch (error) {
+        recordDropped(stats, error);
+      }
+    });
+    queue = operation.catch(() => {
+    });
+    return operation.catch(() => {
+    });
+  };
+  return {
+    write(event) {
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return Promise.resolve();
+      }
+      return enqueue(safe);
+    },
+    async flush() {
+      await queue;
+      markFlush(stats);
+    },
+    async close() {
+      if (closed) return;
+      await queue;
+      closed = true;
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+function positiveInteger(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) return fallback;
+  return Math.floor(value);
+}
+function nonNegativeInteger(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value < 0) return fallback;
+  return Math.floor(value);
+}
+function bufferedFileWriter(options = {}) {
+  const stats = createInitialStats();
+  const maxQueueSize = positiveInteger(options.maxQueueSize, 1e3);
+  const flushIntervalMs = nonNegativeInteger(options.flushIntervalMs, 250);
+  const maxBatchSize = positiveInteger(options.maxBatchSize, 100);
+  const overflow = options.overflow ?? "drop-oldest";
+  const pending = [];
+  let closed = false;
+  let timer;
+  let chain = Promise.resolve();
+  const clearTimer = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const scheduleFlush = () => {
+    if (closed || timer !== void 0 || pending.length === 0) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      void drain(false);
+    }, flushIntervalMs);
+    if (timer && typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") {
+      timer.unref();
+    }
+  };
+  const drainBatch = async (drainAll) => {
+    clearTimer();
+    do {
+      const batch = pending.splice(0, maxBatchSize);
+      if (batch.length === 0) break;
+      const result = await appendEventBatch(batch, options);
+      stats.writtenEvents += result.written;
+      stats.droppedEvents += result.dropped;
+      if (result.lastError) {
+        stats.lastError = result.lastError;
+      }
+    } while (drainAll && pending.length > 0);
+    if (pending.length > 0) scheduleFlush();
+  };
+  const drain = (drainAll) => {
+    const operation = chain.then(() => drainBatch(drainAll));
+    chain = operation.catch(() => {
+    });
+    return operation.catch(() => {
+    });
+  };
+  return {
+    async write(event) {
+      if (closed) {
+        recordDropped(stats, "Trace writer is closed");
+        return;
+      }
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return;
+      }
+      if (pending.length >= maxQueueSize) {
+        if (overflow === "drop-newest") {
+          recordDropped(stats, "Trace writer queue overflow");
+          return;
+        }
+        pending.shift();
+        recordDropped(stats, "Trace writer queue overflow");
+      }
+      try {
+        pending.push(safe);
+      } catch (error) {
+        recordDropped(stats, error);
+        return;
+      }
+      scheduleFlush();
+    },
+    async flush() {
+      await drain(true);
+      markFlush(stats);
+    },
+    async close() {
+      if (closed) return;
+      await drain(true);
+      closed = true;
+      clearTimer();
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+function compositeWriter(writersOrOptions) {
+  const stats = createInitialStats();
+  const writers = Array.isArray(writersOrOptions) ? [...writersOrOptions] : [...writersOrOptions.writers];
+  let closed = false;
+  const recordChildFailure = (error) => {
+    stats.droppedEvents += 1;
+    stats.lastError = normalizeError(error);
+  };
+  return {
+    async write(event) {
+      if (closed) {
+        recordDropped(stats, "Trace writer is closed");
+        return;
+      }
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return;
+      }
+      const childResults = await Promise.all(
+        writers.map(async (writer) => {
+          try {
+            await writer.write(structuredClone(safe));
+            return true;
+          } catch (error) {
+            recordChildFailure(error);
+            return false;
+          }
+        })
+      );
+      if (childResults.some(Boolean)) {
+        stats.writtenEvents += 1;
+      } else {
+        recordDropped(stats, "No composite trace writer accepted the event");
+      }
+    },
+    async flush() {
+      await Promise.all(
+        writers.map(async (writer) => {
+          try {
+            await writer.flush?.();
+          } catch (error) {
+            stats.lastError = normalizeError(error);
+          }
+        })
+      );
+      markFlush(stats);
+    },
+    async close() {
+      if (closed) return;
+      await Promise.all(
+        writers.map(async (writer) => {
+          try {
+            await writer.close?.();
+          } catch (error) {
+            stats.lastError = normalizeError(error);
+          }
+        })
+      );
+      closed = true;
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+
+exports.bufferedFileWriter = bufferedFileWriter;
+exports.compositeWriter = compositeWriter;
+exports.fileWriter = fileWriter;
+exports.memoryWriter = memoryWriter;
+exports.nullWriter = nullWriter;
+//# sourceMappingURL=writers.cjs.map
+//# sourceMappingURL=writers.cjs.map