agent-inspect 1.5.0 → 1.7.0

package/packages/core/dist/chunk-57S5D6HR.mjs

@@ -0,0 +1,655 @@
+import { resolveRedactionProfile, applyProfileMetadataCaps } from './chunk-EDTQHZPM.mjs';
+import { Redactor } from './chunk-VU6O5QAH.mjs';
+import { isStepType, ensureTraceDir, getTraceFilePath, warn, FALLBACK_TRACE_DIR, parseTraceJsonl } from './chunk-VTIB5MDK.mjs';
+import { isPersistedInspectEvent } from './chunk-74XZ6N7Q.mjs';
+import { writeFile, readFile, readdir, stat, appendFile } from 'fs/promises';
+import path from 'path';
+
+// 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 isRecord(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) {
+  const redact = options?.redact;
+  let redactEnabled = true;
+  let redactionRules;
+  if (redact === false) {
+    redactEnabled = false;
+  } else if (redact === true || redact === void 0) {
+    redactEnabled = true;
+  } else if (isRecord(redact)) {
+    redactEnabled = true;
+    redactionRules = redact.rules;
+  }
+  const profile = options?.redactionProfile ?? "local";
+  const resolvedProfile = resolveRedactionProfile(profile);
+  const userMaxMetadata = typeof options?.maxMetadataValueLength === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : void 0;
+  const userMaxPreview = typeof options?.maxPreviewLength === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : void 0;
+  let maxMetadataValueLength = userMaxMetadata ?? DEFAULT_MAX_METADATA_VALUE_LENGTH;
+  let maxPreviewLength = userMaxPreview ?? DEFAULT_MAX_PREVIEW_LENGTH;
+  if (redactEnabled && profile !== "local") {
+    const capped = applyProfileMetadataCaps(
+      maxMetadataValueLength,
+      maxPreviewLength,
+      resolvedProfile
+    );
+    maxMetadataValueLength = capped.maxMetadataValueLength;
+    maxPreviewLength = capped.maxPreviewLength;
+  }
+  return {
+    redactEnabled,
+    redactionRules,
+    redactionProfile: profile,
+    profileExtraKeys: redactEnabled ? resolvedProfile.extraKeys : [],
+    maxMetadataValueLength,
+    maxPreviewLength,
+    maxEventBytes: typeof options?.maxEventBytes === "number" && Number.isFinite(options.maxEventBytes) && options.maxEventBytes > 0 ? Math.floor(options.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(
+      isRecord(preBounded) ? preBounded : {},
+      opts
+    );
+    const bounded = boundMetadataValue(
+      "metadata",
+      redacted,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    return isRecord(bounded) ? bounded : {};
+  } catch {
+    return { truncated: true, reason: "metadataPreparationFailed" };
+  }
+}
+function truncateErrorStack(event, maxLen) {
+  if (event.event !== "run_completed" && event.event !== "step_completed") {
+    return event;
+  }
+  if (!event.error?.stack || typeof event.error.stack !== "string") {
+    return event;
+  }
+  return {
+    ...event,
+    error: {
+      ...event.error,
+      stack: truncateString(event.error.stack, maxLen)
+    }
+  };
+}
+function replaceMetadataWithTruncationMarker(event, originalApproxBytes) {
+  const marker = {
+    truncated: true,
+    reason: "maxEventBytes",
+    originalApproxBytes
+  };
+  if (event.event === "run_started") {
+    return { ...event, metadata: marker };
+  }
+  if (event.event === "step_started") {
+    return { ...event, metadata: marker };
+  }
+  return event;
+}
+function shrinkMetadataLimits(opts, factor) {
+  return {
+    ...opts,
+    maxMetadataValueLength: Math.max(32, Math.floor(opts.maxMetadataValueLength * factor)),
+    maxPreviewLength: Math.max(16, Math.floor(opts.maxPreviewLength * factor))
+  };
+}
+function applyMetadataToEvent(event, metadata) {
+  if (event.event === "run_started") {
+    return { ...event, metadata };
+  }
+  if (event.event === "step_started") {
+    return { ...event, metadata };
+  }
+  return event;
+}
+function eventHasMetadata(event) {
+  return (event.event === "run_started" || event.event === "step_started") && event.metadata !== void 0;
+}
+function getEventMetadata(event) {
+  if (event.event === "run_started" || event.event === "step_started") {
+    return event.metadata;
+  }
+  return void 0;
+}
+function prepareTraceEventForDisk(event, opts) {
+  try {
+    let working = { ...event };
+    const rawMetadata = getEventMetadata(working);
+    if (rawMetadata !== void 0) {
+      const safe = prepareMetadataForDisk(rawMetadata, opts);
+      working = applyMetadataToEvent(working, safe);
+    }
+    let serialized = serializeEvent(working);
+    if (serialized === "") {
+      return working;
+    }
+    let bytes = byteLength(serialized);
+    if (bytes <= opts.maxEventBytes) {
+      return working;
+    }
+    if (rawMetadata !== void 0) {
+      for (const factor of [0.5, 0.25, 0.1]) {
+        const tighter = shrinkMetadataLimits(opts, factor);
+        const shrunk = prepareMetadataForDisk(rawMetadata, tighter);
+        working = applyMetadataToEvent(working, shrunk);
+        serialized = serializeEvent(working);
+        if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+          return working;
+        }
+      }
+      working = replaceMetadataWithTruncationMarker(working, bytes);
+      serialized = serializeEvent(working);
+      if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+        return working;
+      }
+    }
+    working = truncateErrorStack(working, Math.min(opts.maxMetadataValueLength, 500));
+    serialized = serializeEvent(working);
+    if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+      return working;
+    }
+    if (eventHasMetadata(working)) {
+      working = replaceMetadataWithTruncationMarker(working, bytes);
+      serialized = serializeEvent(working);
+      if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+        return working;
+      }
+      if (working.event === "run_started") {
+        const { metadata: _meta, ...rest } = working;
+        working = rest;
+      } else if (working.event === "step_started") {
+        const { metadata: _meta, ...rest } = working;
+        working = rest;
+      }
+    }
+    return working;
+  } catch {
+    if (event.event === "run_started" || event.event === "step_started") {
+      return applyMetadataToEvent(event, {
+        truncated: true,
+        reason: "prepareTraceEventFailed"
+      });
+    }
+    return event;
+  }
+}
+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 (!isRecord(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 (!isRecord(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 (!isRecord(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 (!isRecord(value)) return void 0;
+    const source = safeGet(value, "source");
+    if (!isRecord(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 (isRecord(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/storage.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function optionalErrorInfo(value) {
+  if (value === void 0) return true;
+  if (!isRecord2(value)) return false;
+  if (typeof value.message !== "string") return false;
+  if ("stack" in value && value.stack !== void 0) {
+    if (typeof value.stack !== "string") return false;
+  }
+  return true;
+}
+function validateEvent(event) {
+  if (!isRecord2(event)) return false;
+  if (event.schemaVersion !== "0.1") return false;
+  if (!finiteNumber(event.timestamp)) return false;
+  if (typeof event.event !== "string") return false;
+  switch (event.event) {
+    case "run_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord2(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "run_completed": {
+      return nonEmptyString(event.runId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    case "step_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.stepId) || !nonEmptyString(event.name) || !isStepType(event.type) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.parentId !== void 0 && typeof event.parentId !== "string") {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord2(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "step_completed": {
+      return nonEmptyString(event.runId) && nonEmptyString(event.stepId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    default:
+      return false;
+  }
+}
+function serializeEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return "";
+  }
+}
+async function initializeTraceFile(runId, traceDir) {
+  try {
+    const usable = await ensureTraceDir(traceDir);
+    const filePath = getTraceFilePath(runId, usable);
+    await writeFile(filePath, "", "utf-8");
+    return filePath;
+  } catch (e) {
+    warn("Failed to initialize trace file", e);
+  }
+  try {
+    const usable = await ensureTraceDir(FALLBACK_TRACE_DIR);
+    const filePath = getTraceFilePath(runId, usable);
+    await writeFile(filePath, "", "utf-8");
+    return filePath;
+  } catch (e) {
+    warn("Failed to initialize trace file on fallback directory", e);
+    return void 0;
+  }
+}
+function ensureEventWithinBounds(event) {
+  const line = serializeEvent(event);
+  if (line === "") return event;
+  const bytes = Buffer.byteLength(line, "utf8");
+  if (bytes <= DEFAULT_MAX_EVENT_BYTES) return event;
+  return prepareTraceEventForDisk(event, resolveTraceSafetyOptions());
+}
+async function writeTraceEvent(event, traceDir) {
+  const bounded = ensureEventWithinBounds(event);
+  if (!validateEvent(bounded)) {
+    warn("Skipped invalid trace event (validation failed)");
+    return;
+  }
+  const line = serializeEvent(bounded);
+  if (line === "") {
+    warn("Skipped trace event (serialization failed)");
+    return;
+  }
+  const payload = `${line}
+`;
+  const tryAppend = async (dir) => {
+    try {
+      const usable = await ensureTraceDir(dir);
+      const filePath = getTraceFilePath(event.runId, usable);
+      await appendFile(filePath, payload, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (await tryAppend(traceDir)) {
+    return;
+  }
+  warn(`Failed to append trace event for run ${event.runId}`);
+  if (await tryAppend(FALLBACK_TRACE_DIR)) {
+    return;
+  }
+  warn("Failed to append trace event to fallback directory");
+}
+async function readTraceFile(runId, traceDir) {
+  try {
+    const filePath = getTraceFilePath(runId, traceDir);
+    return await readFile(filePath, "utf-8");
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return void 0;
+    }
+    warn("Unexpected error reading trace file", e);
+    return void 0;
+  }
+}
+async function readTraceEvents(runId, traceDir) {
+  try {
+    const filePath = getTraceFilePath(runId, traceDir);
+    return await readTraceEventsFromFile(filePath);
+  } catch (e) {
+    warn("Failed to read trace events", e);
+    return [];
+  }
+}
+async function readTraceEventsFromFile(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    return parseTraceJsonl(raw, { validate: validateEvent }).events;
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return [];
+    }
+    warn("Failed to read trace events from file", e);
+    return [];
+  }
+}
+async function listTraceFiles(traceDir) {
+  try {
+    const usable = path.resolve(traceDir);
+    const names = await readdir(usable);
+    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
+    const withStat = await Promise.all(
+      jsonl.map(async (name) => {
+        try {
+          const st = await stat(path.join(usable, name));
+          return { name, mtime: st.mtimeMs };
+        } catch {
+          return { name, mtime: 0 };
+        }
+      })
+    );
+    withStat.sort((a, b) => {
+      if (b.mtime !== a.mtime) return b.mtime - a.mtime;
+      return a.name.localeCompare(b.name);
+    });
+    return withStat.map((x) => x.name);
+  } catch {
+    return [];
+  }
+}
+function getRunIdFromTraceFileName(fileName) {
+  try {
+    const base = path.basename(fileName);
+    if (!base.endsWith(".jsonl")) return void 0;
+    const id = base.slice(0, -".jsonl".length);
+    return id === "" ? void 0 : id;
+  } catch {
+    return void 0;
+  }
+}
+
+export { DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_METADATA_VALUE_LENGTH, DEFAULT_MAX_PREVIEW_LENGTH, getRunIdFromTraceFileName, initializeTraceFile, listTraceFiles, prepareMetadataForDisk, preparePersistedInspectEventForWrite, prepareTraceEventForDisk, readTraceEvents, readTraceEventsFromFile, readTraceFile, resolveTraceSafetyOptions, serializeEvent, validateEvent, writeTraceEvent };
+//# sourceMappingURL=chunk-57S5D6HR.mjs.map
+//# sourceMappingURL=chunk-57S5D6HR.mjs.map