@replayci/replay 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2197 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  observe: () => observe,
+  prepareContracts: () => prepareContracts,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/observe.ts
+var import_contracts_core = require("@replayci/contracts-core");
+
+// src/buffer.ts
+var DEFAULT_CAPTURE_ENDPOINT = "https://app.replayci.com";
+var CAPTURES_PATH = "/api/v1/captures";
+var DEFAULT_MAX_BUFFER = 100;
+var HARD_MAX_BUFFER = 1e3;
+var MAX_ITEM_SIZE = 1e6;
+var MAX_BATCH_SIZE = 50;
+var DEFAULT_FLUSH_MS = 5e3;
+var DEFAULT_TIMEOUT_MS = 5e3;
+var MAX_SEND_TIMEOUT = 1e4;
+var CIRCUIT_BREAKER_FAILURE_LIMIT = 5;
+var CIRCUIT_BREAKER_MS = 10 * 6e4;
+var beforeExitRegistered = false;
+var activeBuffers = /* @__PURE__ */ new Set();
+var CaptureBuffer = class {
+  maxBuffer;
+  flushMs;
+  timeoutMs;
+  apiKey;
+  endpoint;
+  diagnostics;
+  fetchImpl;
+  now;
+  queue = [];
+  timer;
+  flushPromise;
+  failureCount = 0;
+  circuitOpenUntil = 0;
+  remoteDisabled = false;
+  closed = false;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.endpoint = normalizeEndpoint(opts.endpoint);
+    this.maxBuffer = clampMaxBuffer(opts.maxBuffer);
+    this.flushMs = clampPositiveNumber(opts.flushMs, DEFAULT_FLUSH_MS);
+    this.timeoutMs = Math.min(
+      clampPositiveNumber(opts.timeoutMs, DEFAULT_TIMEOUT_MS),
+      MAX_SEND_TIMEOUT
+    );
+    this.diagnostics = opts.diagnostics;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.now = opts.now ?? Date.now;
+    this.scheduleNextDrain();
+  }
+  get size() {
+    return this.queue.length;
+  }
+  get consecutiveFailures() {
+    return this.failureCount;
+  }
+  get disabledUntil() {
+    return this.circuitOpenUntil;
+  }
+  get isRemoteDisabled() {
+    return this.remoteDisabled;
+  }
+  push(item) {
+    if (this.closed || this.remoteDisabled) {
+      return;
+    }
+    if (!fitsWithinItemLimit(item)) {
+      return;
+    }
+    if (this.queue.length >= this.maxBuffer) {
+      this.queue.shift();
+      emitDiagnostics(this.diagnostics, {
+        type: "buffer_overflow",
+        dropped: 1
+      });
+    }
+    this.queue.push(item);
+  }
+  flush() {
+    if (this.closed || this.remoteDisabled) {
+      return Promise.resolve();
+    }
+    if (this.flushPromise) {
+      return this.flushPromise;
+    }
+    const flushPromise = this.flushOnce().catch(() => {
+    }).finally(() => {
+      if (this.flushPromise === flushPromise) {
+        this.flushPromise = void 0;
+      }
+    });
+    this.flushPromise = flushPromise;
+    return flushPromise;
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.queue.length = 0;
+    this.clearTimer();
+    unregisterBuffer(this);
+  }
+  async flushOnce() {
+    if (this.closed || this.remoteDisabled || this.queue.length === 0) {
+      return;
+    }
+    const now = this.now();
+    if (this.circuitOpenUntil > now) {
+      return;
+    }
+    if (this.circuitOpenUntil !== 0) {
+      this.circuitOpenUntil = 0;
+      this.failureCount = 0;
+    }
+    const batch = this.queue.splice(0, Math.min(this.queue.length, MAX_BATCH_SIZE));
+    if (batch.length === 0) {
+      return;
+    }
+    let payload = "";
+    try {
+      payload = JSON.stringify({ captures: batch });
+    } catch {
+      this.handleFailure();
+      return;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    unrefTimer(timeout);
+    try {
+      const response = await this.fetchImpl(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: payload,
+        signal: controller.signal
+      });
+      if (isRemoteDisable(response)) {
+        this.remoteDisabled = true;
+        this.queue.length = 0;
+        this.clearTimer();
+        this.failureCount = 0;
+        this.circuitOpenUntil = Number.MAX_SAFE_INTEGER;
+        return;
+      }
+      if (!response.ok) {
+        this.handleFailure();
+        return;
+      }
+      this.failureCount = 0;
+      this.circuitOpenUntil = 0;
+    } catch {
+      this.handleFailure();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  handleFailure() {
+    this.failureCount += 1;
+    if (this.failureCount >= CIRCUIT_BREAKER_FAILURE_LIMIT) {
+      this.circuitOpenUntil = this.now() + CIRCUIT_BREAKER_MS;
+      this.failureCount = 0;
+    }
+  }
+  scheduleNextDrain() {
+    if (this.closed || this.remoteDisabled) {
+      return;
+    }
+    const timeout = setTimeout(() => {
+      void this.flush().finally(() => {
+        this.scheduleNextDrain();
+      });
+    }, this.flushMs);
+    this.timer = timeout;
+    unrefTimer(timeout);
+  }
+  clearTimer() {
+    if (this.timer !== void 0) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+  }
+};
+function registerBeforeExit(buffer) {
+  activeBuffers.add(buffer);
+  if (beforeExitRegistered || typeof process === "undefined" || typeof process.on !== "function") {
+    return;
+  }
+  beforeExitRegistered = true;
+  process.on("beforeExit", async () => {
+    const flushes = [...activeBuffers].map((activeBuffer) => {
+      try {
+        return activeBuffer.flush();
+      } catch {
+        return Promise.resolve();
+      }
+    });
+    await Promise.allSettled(flushes);
+  });
+}
+function unregisterBuffer(buffer) {
+  activeBuffers.delete(buffer);
+}
+function clampMaxBuffer(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return DEFAULT_MAX_BUFFER;
+  }
+  return Math.min(Math.floor(value), HARD_MAX_BUFFER);
+}
+function clampPositiveNumber(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function normalizeEndpoint(endpoint) {
+  const base = typeof endpoint === "string" && endpoint.length > 0 ? endpoint : DEFAULT_CAPTURE_ENDPOINT;
+  const trimmed = base.replace(/\/+$/, "");
+  return trimmed.endsWith(CAPTURES_PATH) ? trimmed : `${trimmed}${CAPTURES_PATH}`;
+}
+function fitsWithinItemLimit(item) {
+  try {
+    const size = Buffer.byteLength(JSON.stringify(item), "utf8");
+    return size <= MAX_ITEM_SIZE;
+  } catch {
+    return false;
+  }
+}
+function emitDiagnostics(diagnostics, event) {
+  try {
+    diagnostics?.(event);
+  } catch {
+  }
+}
+function isRemoteDisable(response) {
+  return response.headers.get("x-replayci-disable")?.toLowerCase() === "true";
+}
+function unrefTimer(timer) {
+  if (typeof timer === "object" && timer !== null && "unref" in timer) {
+    const unref = timer.unref;
+    try {
+      unref?.call(timer);
+    } catch {
+    }
+  }
+}
+
+// src/providers/anthropic.ts
+function extractToolCallsAnthropic(response) {
+  return getContentBlocks(response).map((block, index) => normalizeAnthropicToolCall(block, index)).filter((toolCall) => toolCall !== null);
+}
+function extractTextBlocksAnthropic(response) {
+  return getContentBlocks(response).map((block) => {
+    const record = toRecord(block);
+    return record.type === "text" && typeof record.text === "string" ? record.text : null;
+  }).filter((text) => text !== null);
+}
+function extractUsageAnthropic(response) {
+  const usage = toRecord(toRecord(response).usage);
+  const promptTokens = toNumber(usage.input_tokens);
+  const completionTokens = toNumber(usage.output_tokens);
+  if (promptTokens === void 0 || completionTokens === void 0) {
+    return void 0;
+  }
+  return {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: promptTokens + completionTokens
+  };
+}
+function extractModelAnthropic(response) {
+  return toString(toRecord(response).model) ?? "";
+}
+function extractContentAnthropic(response) {
+  const textBlocks = extractTextBlocksAnthropic(response);
+  return textBlocks.length > 0 ? textBlocks.join("\n") : null;
+}
+function getContentBlocks(response) {
+  const content = toRecord(response).content;
+  return Array.isArray(content) ? content : [];
+}
+function normalizeAnthropicToolCall(block, index) {
+  const record = toRecord(block);
+  if (record.type !== "tool_use") {
+    return null;
+  }
+  const name = toString(record.name);
+  if (!name) {
+    return null;
+  }
+  return {
+    id: toString(record.id) ?? `tool_call_${index}`,
+    name,
+    arguments: serializeArguments(record.input)
+  };
+}
+function serializeArguments(argumentsValue) {
+  if (typeof argumentsValue === "string") {
+    return argumentsValue;
+  }
+  if (argumentsValue === void 0) {
+    return "null";
+  }
+  try {
+    return JSON.stringify(argumentsValue) ?? "null";
+  } catch {
+    return "null";
+  }
+}
+function toRecord(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function toString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/providers/openai.ts
+function extractToolCallsOpenAI(response) {
+  const message = getOpenAIMessage(response);
+  if (!Array.isArray(message.tool_calls)) {
+    return [];
+  }
+  return message.tool_calls.map((toolCall, index) => normalizeOpenAIToolCall(toolCall, index)).filter((toolCall) => toolCall !== null);
+}
+function extractUsageOpenAI(response) {
+  const usage = toRecord2(toRecord2(response).usage);
+  const promptTokens = toNumber2(usage.prompt_tokens);
+  const completionTokens = toNumber2(usage.completion_tokens);
+  const totalTokens = toNumber2(usage.total_tokens);
+  if (promptTokens === void 0 || completionTokens === void 0 || totalTokens === void 0) {
+    return void 0;
+  }
+  return {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: totalTokens
+  };
+}
+function extractModelOpenAI(response) {
+  return toString2(toRecord2(response).model) ?? "";
+}
+function extractContentOpenAI(response) {
+  const content = getOpenAIMessage(response).content;
+  return typeof content === "string" ? content : null;
+}
+function getOpenAIMessage(response) {
+  const record = toRecord2(response);
+  if (!Array.isArray(record.choices) || record.choices.length === 0) {
+    return {};
+  }
+  const firstChoice = toRecord2(record.choices[0]);
+  return toRecord2(firstChoice.message);
+}
+function normalizeOpenAIToolCall(toolCall, index) {
+  const record = toRecord2(toolCall);
+  const fn = toRecord2(record.function);
+  const name = toString2(fn.name);
+  if (!name) {
+    return null;
+  }
+  return {
+    id: toString2(record.id) ?? `tool_call_${index}`,
+    name,
+    // Preserve malformed JSON strings so validate() can emit argument_parse.
+    arguments: typeof fn.arguments === "string" ? fn.arguments : serializeArguments2(fn.arguments)
+  };
+}
+function serializeArguments2(argumentsValue) {
+  if (typeof argumentsValue === "string") {
+    return argumentsValue;
+  }
+  if (argumentsValue === void 0) {
+    return "null";
+  }
+  try {
+    return JSON.stringify(argumentsValue) ?? "null";
+  } catch {
+    return "null";
+  }
+}
+function toRecord2(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function toString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/providers/extract.ts
+function extractToolCalls(response, provider) {
+  switch (provider) {
+    case "openai":
+      return extractToolCallsOpenAI(response);
+    case "anthropic":
+      return extractToolCallsAnthropic(response);
+  }
+}
+function extractUsage(response, provider) {
+  switch (provider) {
+    case "openai":
+      return extractUsageOpenAI(response);
+    case "anthropic":
+      return extractUsageAnthropic(response);
+  }
+}
+function extractModel(response, provider) {
+  switch (provider) {
+    case "openai":
+      return extractModelOpenAI(response);
+    case "anthropic":
+      return extractModelAnthropic(response);
+  }
+}
+function extractContent(response, provider) {
+  switch (provider) {
+    case "openai":
+      return extractContentOpenAI(response);
+    case "anthropic":
+      return extractContentAnthropic(response);
+  }
+}
+function extractTextBlocks(response, provider) {
+  switch (provider) {
+    case "openai":
+      return void 0;
+    case "anthropic": {
+      const textBlocks = extractTextBlocksAnthropic(response);
+      return textBlocks.length > 0 ? textBlocks : void 0;
+    }
+  }
+}
+
+// src/errors.ts
+var ReplayConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReplayConfigurationError";
+  }
+};
+var ReplayInternalError = class extends Error {
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "ReplayInternalError";
+    this.cause = options?.cause;
+  }
+};
+
+// src/providers/detect.ts
+function detectProvider(client) {
+  if (hasPath(client, "chat.completions.create")) {
+    return "openai";
+  }
+  if (hasPath(client, "messages.create")) {
+    return "anthropic";
+  }
+  throw new ReplayConfigurationError(
+    "Unsupported client. Pass an OpenAI or Anthropic client instance."
+  );
+}
+function hasPath(obj, path) {
+  if (path.length === 0) {
+    return false;
+  }
+  let current = obj;
+  for (const segment of path.split(".")) {
+    if (current == null) {
+      return false;
+    }
+    const record = toRecordLike(current);
+    if (!(segment in record)) {
+      return false;
+    }
+    current = record[segment];
+  }
+  return current !== void 0;
+}
+function toRecordLike(value) {
+  if (value !== null && (typeof value === "object" || typeof value === "function")) {
+    return value;
+  }
+  return {};
+}
+
+// src/stream.ts
+function tapAsyncIterable(response, collector, onComplete) {
+  if (!isRecordLike(response) || !canPatchProperty(response, Symbol.asyncIterator)) {
+    return false;
+  }
+  const originalIteratorFactory = response[Symbol.asyncIterator];
+  if (typeof originalIteratorFactory !== "function") {
+    return false;
+  }
+  let finished = false;
+  response[Symbol.asyncIterator] = function patchedAsyncIterator() {
+    const iterator = originalIteratorFactory.call(this);
+    const complete = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      scheduleSoon(() => {
+        try {
+          onComplete(collector.finalize());
+        } catch {
+        }
+      });
+    };
+    const fail = () => {
+      if (finished) {
+        return;
+      }
+      finished = true;
+      scheduleSoon(() => {
+        try {
+          onComplete(null);
+        } catch {
+        }
+      });
+    };
+    return {
+      next(value) {
+        return Promise.resolve(iterator.next?.(value)).then((result) => {
+          if (result.done) {
+            complete();
+            return result;
+          }
+          try {
+            collector.add(result.value);
+          } catch {
+          }
+          return result;
+        }, (error) => {
+          fail();
+          throw error;
+        });
+      },
+      return(value) {
+        if (typeof iterator.return !== "function") {
+          complete();
+          return Promise.resolve({ done: true, value });
+        }
+        return Promise.resolve(iterator.return(value)).then((result) => {
+          complete();
+          return result;
+        }, (error) => {
+          fail();
+          throw error;
+        });
+      },
+      throw(error) {
+        if (typeof iterator.throw !== "function") {
+          fail();
+          return Promise.reject(error);
+        }
+        return Promise.resolve(iterator.throw(error)).then((result) => {
+          fail();
+          return result;
+        }, (thrown) => {
+          fail();
+          throw thrown;
+        });
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  };
+  return true;
+}
+function createStreamCollector(provider, captureLevel) {
+  return provider === "anthropic" ? createAnthropicCollector(captureLevel) : createOpenAiCollector(captureLevel);
+}
+function createOpenAiCollector(captureLevel) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  const contentParts = [];
+  let model = "";
+  let usage;
+  let byteEstimate = 0;
+  let overflow = false;
+  return {
+    add(chunk) {
+      if (overflow) {
+        return;
+      }
+      const record = toRecord3(chunk);
+      const modelValue = toString3(record.model);
+      if (modelValue) {
+        model = modelValue;
+      }
+      const usageValue = extractOpenAiUsage(record.usage);
+      if (usageValue) {
+        usage = usageValue;
+      }
+      const choices = Array.isArray(record.choices) ? record.choices : [];
+      for (const choice of choices) {
+        const delta = toRecord3(toRecord3(choice).delta);
+        if (captureLevel === "full") {
+          const content = toString3(delta.content);
+          if (content) {
+            contentParts.push(content);
+            byteEstimate += Buffer.byteLength(content, "utf8");
+          }
+        }
+        const deltaToolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+        for (const [fallbackIndex, rawToolCall] of deltaToolCalls.entries()) {
+          const toolCall = toRecord3(rawToolCall);
+          const index = toNumber3(toolCall.index) ?? fallbackIndex;
+          const fn = toRecord3(toolCall.function);
+          const existing = toolCalls.get(index) ?? {
+            id: toString3(toolCall.id) ?? `tool_call_${index}`,
+            name: "",
+            arguments: ""
+          };
+          const name = toString3(fn.name);
+          if (name) {
+            existing.name = name;
+            byteEstimate += Buffer.byteLength(name, "utf8");
+          }
+          if (captureLevel !== "metadata") {
+            const args = toString3(fn.arguments);
+            if (args) {
+              existing.arguments += args;
+              byteEstimate += Buffer.byteLength(args, "utf8");
+            }
+          }
+          toolCalls.set(index, existing);
+        }
+        if (byteEstimate > MAX_ITEM_SIZE) {
+          overflow = true;
+          return;
+        }
+      }
+    },
+    finalize() {
+      if (overflow) {
+        return null;
+      }
+      const orderedToolCalls = [...toolCalls.entries()].sort((a, b) => a[0] - b[0]).map(([, toolCall]) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: captureLevel === "metadata" ? "null" : toolCall.arguments || "null"
+      })).filter((toolCall) => toolCall.name.length > 0);
+      return {
+        model,
+        toolCalls: orderedToolCalls,
+        content: captureLevel === "full" && contentParts.length > 0 ? contentParts.join("") : null,
+        usage
+      };
+    }
+  };
+}
+function createAnthropicCollector(captureLevel) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  const textBlocks = /* @__PURE__ */ new Map();
+  let model = "";
+  let inputTokens;
+  let outputTokens;
+  let byteEstimate = 0;
+  let overflow = false;
+  return {
+    add(chunk) {
+      if (overflow) {
+        return;
+      }
+      const record = toRecord3(chunk);
+      switch (toString3(record.type)) {
+        case "message_start": {
+          const message = toRecord3(record.message);
+          const modelValue = toString3(message.model);
+          if (modelValue) {
+            model = modelValue;
+          }
+          const usage = toRecord3(message.usage);
+          const startInputTokens = toNumber3(usage.input_tokens);
+          if (startInputTokens !== void 0) {
+            inputTokens = startInputTokens;
+          }
+          break;
+        }
+        case "message_delta": {
+          const usage = toRecord3(record.usage);
+          const deltaOutputTokens = toNumber3(usage.output_tokens);
+          if (deltaOutputTokens !== void 0) {
+            outputTokens = deltaOutputTokens;
+          }
+          break;
+        }
+        case "content_block_start": {
+          const index = toNumber3(record.index) ?? 0;
+          const contentBlock = toRecord3(record.content_block);
+          const blockType = toString3(contentBlock.type);
+          if (blockType === "text" && captureLevel === "full") {
+            const text = toString3(contentBlock.text);
+            if (text) {
+              textBlocks.set(index, text);
+              byteEstimate += Buffer.byteLength(text, "utf8");
+            }
+          }
+          if (blockType === "tool_use") {
+            const name = toString3(contentBlock.name);
+            if (!name) {
+              break;
+            }
+            const existing = toolCalls.get(index) ?? {
+              id: toString3(contentBlock.id) ?? `tool_call_${index}`,
+              name,
+              arguments: ""
+            };
+            existing.name = name;
+            if (captureLevel !== "metadata" && contentBlock.input !== void 0) {
+              existing.arguments = serializeArguments3(contentBlock.input);
+              byteEstimate += Buffer.byteLength(existing.arguments, "utf8");
+            }
+            toolCalls.set(index, existing);
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const index = toNumber3(record.index) ?? 0;
+          const delta = toRecord3(record.delta);
+          const deltaType = toString3(delta.type);
+          if (deltaType === "text_delta" && captureLevel === "full") {
+            const text = toString3(delta.text);
+            if (text) {
+              textBlocks.set(index, `${textBlocks.get(index) ?? ""}${text}`);
+              byteEstimate += Buffer.byteLength(text, "utf8");
+            }
+          }
+          if (deltaType === "input_json_delta" && captureLevel !== "metadata") {
+            const partialJson = toString3(delta.partial_json);
+            if (partialJson) {
+              const existing = toolCalls.get(index) ?? {
+                id: `tool_call_${index}`,
+                name: "",
+                arguments: ""
+              };
+              existing.arguments += partialJson;
+              toolCalls.set(index, existing);
+              byteEstimate += Buffer.byteLength(partialJson, "utf8");
+            }
+          }
+          break;
+        }
+      }
+      if (byteEstimate > MAX_ITEM_SIZE) {
+        overflow = true;
+      }
+    },
+    finalize() {
+      if (overflow) {
+        return null;
+      }
+      const orderedTextBlocks = [...textBlocks.entries()].sort((a, b) => a[0] - b[0]).map(([, text]) => text).filter((text) => text.length > 0);
+      const orderedToolCalls = [...toolCalls.entries()].sort((a, b) => a[0] - b[0]).map(([, toolCall]) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: captureLevel === "metadata" ? "null" : toolCall.arguments || "null"
+      })).filter((toolCall) => toolCall.name.length > 0);
+      const usage = inputTokens !== void 0 && outputTokens !== void 0 ? {
+        prompt_tokens: inputTokens,
+        completion_tokens: outputTokens,
+        total_tokens: inputTokens + outputTokens
+      } : void 0;
+      return {
+        model,
+        toolCalls: orderedToolCalls,
+        content: captureLevel === "full" && orderedTextBlocks.length > 0 ? orderedTextBlocks.join("\n") : null,
+        ...captureLevel === "full" && orderedTextBlocks.length > 0 ? { textBlocks: orderedTextBlocks } : {},
+        usage
+      };
+    }
+  };
+}
+function canPatchProperty(target, property) {
+  if (Object.isFrozen(target)) {
+    return false;
+  }
+  if (!Object.isExtensible(target)) {
+    return false;
+  }
+  let current = target;
+  while (current !== null) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, property);
+    if (!descriptor) {
+      current = Object.getPrototypeOf(current);
+      continue;
+    }
+    if ("value" in descriptor) {
+      return descriptor.writable !== false;
+    }
+    return typeof descriptor.set === "function";
+  }
+  return true;
+}
+function extractOpenAiUsage(value) {
+  const usage = toRecord3(value);
+  const promptTokens = toNumber3(usage.prompt_tokens);
+  const completionTokens = toNumber3(usage.completion_tokens);
+  const totalTokens = toNumber3(usage.total_tokens);
+  if (promptTokens === void 0 || completionTokens === void 0 || totalTokens === void 0) {
+    return void 0;
+  }
+  return {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: totalTokens
+  };
+}
+function serializeArguments3(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return "null";
+  }
+  try {
+    return JSON.stringify(value) ?? "null";
+  } catch {
+    return "null";
+  }
+}
+function scheduleSoon(fn) {
+  try {
+    queueMicrotask(fn);
+  } catch {
+    const timer = setTimeout(fn, 0);
+    if (typeof timer === "object" && timer !== null && "unref" in timer) {
+      try {
+        timer.unref?.();
+      } catch {
+      }
+    }
+  }
+}
+function isRecordLike(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function toRecord3(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function toString3(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/runtime.ts
+var runtimeChecked = false;
+function assertSupportedNodeRuntime() {
+  if (runtimeChecked) {
+    return;
+  }
+  assertNodeVersionSupported(process.versions?.node);
+  runtimeChecked = true;
+}
+function assertNodeVersionSupported(nodeVersion) {
+  const major = parseNodeMajorVersion(nodeVersion);
+  if (major !== null && major < 18) {
+    throw new ReplayConfigurationError(
+      `@replayci/replay requires Node.js 18+. Current version: ${nodeVersion}. The SDK uses native fetch, setTimeout().unref(), and process lifecycle hooks that are not available in older versions.`
+    );
+  }
+}
+function parseNodeMajorVersion(nodeVersion) {
+  if (typeof nodeVersion !== "string") {
+    return null;
+  }
+  const match = nodeVersion.match(/^(\d+)/);
+  if (!match) {
+    return null;
+  }
+  const major = Number.parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+// src/captureSchema.ts
+var CAPTURE_SCHEMA_VERSION_LEGACY = "2026-03-04";
+var CAPTURE_SCHEMA_VERSION_CURRENT = "2026-03-06";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((item) => isJsonValue(item));
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.values(value).every((item) => isJsonValue(item));
+}
+function asJsonObject(value, path) {
+  if (!isRecord(value) || !isJsonValue(value)) {
+    throw new Error(`${path} must be a JSON object`);
+  }
+  return value;
+}
+function requireString(value, path) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${path} must be a non-empty string`);
+  }
+  return value;
+}
+function nullableString(value, path) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return requireString(value, path);
+}
+function requireStringArray(value, path) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${path} must be an array of strings`);
+  }
+  return value;
+}
+function requireNonNegativeInt(value, path) {
+  if (!Number.isInteger(value) || Number(value) < 0) {
+    throw new Error(`${path} must be a non-negative integer`);
+  }
+  return Number(value);
+}
+function requireIsoTimestamp(value, path) {
+  const timestamp = requireString(value, path);
+  if (Number.isNaN(Date.parse(timestamp))) {
+    throw new Error(`${path} must be a valid ISO 8601 timestamp`);
+  }
+  return timestamp;
+}
+function requireProvider(value, path) {
+  if (value !== "openai" && value !== "anthropic") {
+    throw new Error(`${path} must be one of: openai, anthropic`);
+  }
+  return value;
+}
+function validateRequest(value, path) {
+  const request = asJsonObject(value, path);
+  if (!Array.isArray(request.tools)) {
+    throw new Error(`${path}.tools must be an array`);
+  }
+  for (const [index, tool] of request.tools.entries()) {
+    if (!isRecord(tool) || typeof tool.name !== "string" || tool.name.length === 0) {
+      throw new Error(`${path}.tools[${index}].name must be a non-empty string`);
+    }
+    if (!isJsonValue(tool)) {
+      throw new Error(`${path}.tools[${index}] must be JSON-serializable`);
+    }
+  }
+  if (request.messages !== void 0) {
+    if (!Array.isArray(request.messages)) {
+      throw new Error(`${path}.messages must be an array when provided`);
+    }
+    for (const [index, message] of request.messages.entries()) {
+      if (!isJsonValue(message)) {
+        throw new Error(`${path}.messages[${index}] must be JSON-serializable`);
+      }
+    }
+  }
+  if (request.tool_choice !== void 0 && typeof request.tool_choice !== "string") {
+    throw new Error(`${path}.tool_choice must be a string when provided`);
+  }
+  return request;
+}
+function validateResponse(value, path) {
+  const response = asJsonObject(value, path);
+  if (!Array.isArray(response.tool_calls)) {
+    throw new Error(`${path}.tool_calls must be an array`);
+  }
+  for (const [index, toolCall] of response.tool_calls.entries()) {
+    if (!isRecord(toolCall)) {
+      throw new Error(`${path}.tool_calls[${index}] must be an object`);
+    }
+    if (typeof toolCall.name !== "string" || toolCall.name.length === 0) {
+      throw new Error(`${path}.tool_calls[${index}].name must be a non-empty string`);
+    }
+    if (toolCall.arguments !== void 0 && typeof toolCall.arguments !== "string") {
+      throw new Error(`${path}.tool_calls[${index}].arguments must be a string when provided`);
+    }
+    if (!isJsonValue(toolCall)) {
+      throw new Error(`${path}.tool_calls[${index}] must be JSON-serializable`);
+    }
+  }
+  if (response.content !== null && response.content !== void 0 && typeof response.content !== "string") {
+    throw new Error(`${path}.content must be a string or null`);
+  }
+  if (response.text_blocks !== void 0) {
+    if (!Array.isArray(response.text_blocks) || response.text_blocks.some((item) => typeof item !== "string")) {
+      throw new Error(`${path}.text_blocks must be an array of strings when provided`);
+    }
+  }
+  return response;
+}
+function validateContractFailure(value, path) {
+  const failure = asJsonObject(value, path);
+  const message = failure.message;
+  const contractFile = failure.contract_file;
+  if (message !== void 0 && typeof message !== "string") {
+    throw new Error(`${path}.message must be a string when provided`);
+  }
+  if (contractFile !== void 0 && typeof contractFile !== "string") {
+    throw new Error(`${path}.contract_file must be a string when provided`);
+  }
+  return {
+    path: requireString(failure.path, `${path}.path`),
+    operator: requireString(failure.operator, `${path}.operator`),
+    expected: failure.expected ?? null,
+    found: failure.found ?? null,
+    ...message !== void 0 ? { message } : {},
+    ...contractFile !== void 0 ? { contract_file: contractFile } : {}
+  };
+}
+function validateValidation(value, path) {
+  const validation = asJsonObject(value, path);
+  if (typeof validation.pass !== "boolean") {
+    throw new Error(`${path}.pass must be a boolean`);
+  }
+  if (!Array.isArray(validation.failures)) {
+    throw new Error(`${path}.failures must be an array`);
+  }
+  if (!Array.isArray(validation.contracts_evaluated) || validation.contracts_evaluated.some((item) => typeof item !== "string")) {
+    throw new Error(`${path}.contracts_evaluated must be an array of strings`);
+  }
+  return {
+    pass: validation.pass,
+    failures: validation.failures.map((failure, index) => validateContractFailure(failure, `${path}.failures[${index}]`)),
+    retries_used: requireNonNegativeInt(validation.retries_used, `${path}.retries_used`),
+    contracts_evaluated: validation.contracts_evaluated
+  };
+}
+function validateUsage(value, path) {
+  const usage = asJsonObject(value, path);
+  return {
+    prompt_tokens: requireNonNegativeInt(usage.prompt_tokens, `${path}.prompt_tokens`),
+    completion_tokens: requireNonNegativeInt(
+      usage.completion_tokens,
+      `${path}.completion_tokens`
+    ),
+    total_tokens: requireNonNegativeInt(usage.total_tokens, `${path}.total_tokens`)
+  };
+}
+function parseCommonCapture(capture, index, modelId, schemaVersion) {
+  const toolNames = requireStringArray(capture.tool_names, `captures[${index}].tool_names`);
+  const primaryToolName = capture.primary_tool_name === void 0 ? toolNames[0] ?? null : nullableString(capture.primary_tool_name, `captures[${index}].primary_tool_name`);
+  return {
+    schema_version: schemaVersion,
+    agent: requireString(capture.agent, `captures[${index}].agent`),
+    timestamp: requireIsoTimestamp(capture.timestamp, `captures[${index}].timestamp`),
+    provider: requireProvider(capture.provider, `captures[${index}].provider`),
+    model_id: modelId,
+    primary_tool_name: primaryToolName,
+    tool_names: toolNames,
+    request: validateRequest(capture.request, `captures[${index}].request`),
+    response: validateResponse(capture.response, `captures[${index}].response`),
+    ...capture.validation !== void 0 ? { validation: validateValidation(capture.validation, `captures[${index}].validation`) } : {},
+    ...capture.usage !== void 0 ? { usage: validateUsage(capture.usage, `captures[${index}].usage`) } : {},
+    latency_ms: requireNonNegativeInt(capture.latency_ms, `captures[${index}].latency_ms`)
+  };
+}
+function parseLegacyCapturedCall(capture, index) {
+  return parseCommonCapture(
+    capture,
+    index,
+    requireString(capture.model, `captures[${index}].model`),
+    CAPTURE_SCHEMA_VERSION_LEGACY
+  );
+}
+function parseCurrentCapturedCall(capture, index) {
+  return parseCommonCapture(
+    capture,
+    index,
+    requireString(capture.model_id, `captures[${index}].model_id`),
+    CAPTURE_SCHEMA_VERSION_CURRENT
+  );
+}
+var CAPTURE_SCHEMA_PARSERS = {
+  [CAPTURE_SCHEMA_VERSION_LEGACY]: parseLegacyCapturedCall,
+  [CAPTURE_SCHEMA_VERSION_CURRENT]: parseCurrentCapturedCall
+};
+
+// src/observe.ts
+var REPLAY_WRAPPED = /* @__PURE__ */ Symbol.for("replayci.wrapped");
+var DEFAULT_AGENT = "default";
+function observe(client, opts = {}) {
+  assertSupportedNodeRuntime();
+  try {
+    if (isDisabled(opts)) {
+      return createNoopHandle(client);
+    }
+    const apiKey = resolveApiKey(opts);
+    if (!apiKey) {
+      return createNoopHandle(client);
+    }
+    const provider = detectProviderSafely(client, opts.diagnostics);
+    if (!provider) {
+      return createNoopHandle(client);
+    }
+    const patchTarget = resolvePatchTarget(client, provider);
+    if (!patchTarget) {
+      emitDiagnostic(opts.diagnostics, {
+        type: "unsupported_client",
+        mode: "observe",
+        detail: `Unsupported ${provider} client shape.`
+      });
+      return createNoopHandle(client);
+    }
+    if (isWrapped(client, patchTarget.target)) {
+      emitDiagnostic(opts.diagnostics, {
+        type: "double_wrap",
+        mode: "observe"
+      });
+      return createNoopHandle(client);
+    }
+    const patchabilityError = getPatchabilityError(patchTarget.target, patchTarget.methodName);
+    if (patchabilityError) {
+      emitDiagnostic(opts.diagnostics, {
+        type: "unsupported_client",
+        mode: "observe",
+        detail: patchabilityError
+      });
+      return createNoopHandle(client);
+    }
+    const captureLevel = normalizeCaptureLevel(opts.captureLevel);
+    const agent = typeof opts.agent === "string" && opts.agent.length > 0 ? opts.agent : DEFAULT_AGENT;
+    const buffer = new CaptureBuffer({
+      apiKey,
+      endpoint: opts.endpoint,
+      maxBuffer: opts.maxBuffer,
+      flushMs: opts.flushMs,
+      timeoutMs: opts.timeoutMs,
+      diagnostics: opts.diagnostics
+    });
+    registerBeforeExit(buffer);
+    const wrappedCreate = function observeWrappedCreate(...args) {
+      const requestSnapshot = snapshotRequest(args[0], captureLevel);
+      const startedAt = Date.now();
+      const result = patchTarget.originalCreate.apply(this, args);
+      return Promise.resolve(result).then((response) => {
+        safelyCaptureResponse({
+          agent,
+          buffer,
+          captureLevel,
+          provider,
+          requestSnapshot,
+          response,
+          startedAt
+        });
+        return response;
+      });
+    };
+    patchTarget.target[patchTarget.methodName] = wrappedCreate;
+    setWrapped(client, patchTarget.target);
+    let restored = false;
+    return {
+      client,
+      restore() {
+        if (restored) {
+          return;
+        }
+        restored = true;
+        if (patchTarget.target[patchTarget.methodName] === wrappedCreate) {
+          if (patchTarget.hadOwnMethod) {
+            patchTarget.target[patchTarget.methodName] = patchTarget.originalCreate;
+          } else {
+            delete patchTarget.target[patchTarget.methodName];
+          }
+        }
+        clearWrapped(client, patchTarget.target);
+        buffer.close();
+      }
+    };
+  } catch {
+    return createNoopHandle(client);
+  }
+}
+function safelyCaptureResponse(input) {
+  try {
+    if (isAsyncIterable(input.response)) {
+      const collector = createStreamCollector(input.provider, input.captureLevel);
+      const tapped = tapAsyncIterable(input.response, collector, (summary) => {
+        safelyPushStreamCapture({
+          ...input,
+          summary
+        });
+      });
+      if (tapped) {
+        return;
+      }
+    }
+    const capture = buildCapturedCall({
+      agent: input.agent,
+      captureLevel: input.captureLevel,
+      provider: input.provider,
+      requestSnapshot: input.requestSnapshot,
+      responseData: {
+        model: extractModel(input.response, input.provider),
+        toolCalls: extractToolCalls(input.response, input.provider),
+        content: input.captureLevel === "full" ? extractContent(input.response, input.provider) : null,
+        textBlocks: input.captureLevel === "full" ? extractTextBlocks(input.response, input.provider) : void 0,
+        usage: extractUsage(input.response, input.provider)
+      },
+      endedAt: Date.now(),
+      startedAt: input.startedAt
+    });
+    if (capture) {
+      input.buffer.push(capture);
+    }
+  } catch {
+  }
+}
+function safelyPushStreamCapture(input) {
+  try {
+    if (input.summary == null) {
+      return;
+    }
+    const capture = buildCapturedCall({
+      agent: input.agent,
+      captureLevel: input.captureLevel,
+      provider: input.provider,
+      requestSnapshot: input.requestSnapshot,
+      responseData: input.summary,
+      startedAt: input.startedAt,
+      endedAt: Date.now()
+    });
+    if (capture) {
+      input.buffer.push(capture);
+    }
+  } catch {
+  }
+}
+function buildCapturedCall(input) {
+  try {
+    const toolCalls = input.responseData.toolCalls.map((toolCall) => input.captureLevel === "metadata" ? { name: toolCall.name } : {
+      name: toolCall.name,
+      arguments: toolCall.arguments
+    });
+    return {
+      schema_version: CAPTURE_SCHEMA_VERSION_CURRENT,
+      agent: input.agent,
+      timestamp: new Date(input.endedAt).toISOString(),
+      provider: input.provider,
+      model_id: input.requestSnapshot.model || input.responseData.model,
+      primary_tool_name: toolCalls[0]?.name ?? null,
+      tool_names: toolCalls.map((toolCall) => toolCall.name),
+      request: input.requestSnapshot.request,
+      response: {
+        tool_calls: toolCalls,
+        content: input.captureLevel === "full" ? input.responseData.content : null,
+        ...input.captureLevel === "full" && input.responseData.textBlocks && input.responseData.textBlocks.length > 0 ? { text_blocks: input.responseData.textBlocks } : {}
+      },
+      ...input.responseData.usage ? { usage: input.responseData.usage } : {},
+      latency_ms: Math.max(0, input.endedAt - input.startedAt)
+    };
+  } catch {
+    return null;
+  }
+}
+function snapshotRequest(request, captureLevel) {
+  try {
+    const record = toRecord4(request);
+    return {
+      model: toString4(record.model) ?? "",
+      stream: record.stream === true,
+      request: {
+        ...captureLevel === "full" ? {
+          messages: cloneMessages(record.messages)
+        } : {},
+        tools: captureTools(record.tools, captureLevel),
+        ...serializeToolChoice(record.tool_choice) ? { tool_choice: serializeToolChoice(record.tool_choice) } : {}
+      }
+    };
+  } catch {
+    return {
+      model: "",
+      stream: false,
+      request: {
+        tools: []
+      }
+    };
+  }
+}
+function cloneMessages(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  try {
+    return structuredClone(value);
+  } catch {
+    return void 0;
+  }
+}
+function captureTools(value, captureLevel) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  let normalized;
+  try {
+    normalized = (0, import_contracts_core.normalizeToolArray)(value).normalized;
+  } catch {
+    return captureToolsRaw(value, captureLevel);
+  }
+  if (captureLevel === "metadata") {
+    return normalized.map((tool) => ({ name: tool.name }));
+  }
+  return normalized;
+}
+function captureToolsRaw(value, captureLevel) {
+  if (captureLevel === "metadata") {
+    return value.map((tool) => {
+      const name = toString4(toRecord4(tool).name);
+      return name ? { name } : null;
+    }).filter((tool) => tool !== null);
+  }
+  return value.map((tool) => cloneTool(tool)).filter((tool) => tool !== null);
+}
+function cloneTool(tool) {
+  const record = toRecord4(tool);
+  const name = toString4(record.name);
+  if (!name) {
+    return null;
+  }
+  try {
+    return structuredClone(record);
+  } catch {
+    return { name };
+  }
+}
+function serializeToolChoice(value) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  const record = toRecord4(value);
+  const type = toString4(record.type);
+  if (!type) {
+    return void 0;
+  }
+  if (type === "function") {
+    const name = toString4(toRecord4(record.function).name);
+    return name ? `function:${name}` : type;
+  }
+  if (type === "tool") {
+    const name = toString4(record.name);
+    return name ? `tool:${name}` : type;
+  }
+  return type;
+}
+function resolvePatchTarget(client, provider) {
+  if (provider === "openai") {
+    return resolveTarget(client, ["chat", "completions"], "create");
+  }
+  return resolveTarget(client, ["messages"], "create");
+}
+function resolveTarget(client, path, methodName) {
+  let current = client;
+  for (const segment of path) {
+    current = toRecord4(current)[segment];
+  }
+  const target = toRecordLike2(current);
+  const originalCreate = target[methodName];
+  if (typeof originalCreate !== "function") {
+    return null;
+  }
+  return {
+    target,
+    methodName,
+    originalCreate,
+    hadOwnMethod: Object.prototype.hasOwnProperty.call(target, methodName)
+  };
+}
+function getPatchabilityError(target, methodName) {
+  if (Object.isFrozen(target)) {
+    return `Cannot patch client: the target object for "${methodName}" is frozen.`;
+  }
+  if (!Object.isExtensible(target)) {
+    return `Cannot patch client: the target object for "${methodName}" is not extensible.`;
+  }
+  let current = target;
+  while (current !== null) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, methodName);
+    if (!descriptor) {
+      current = Object.getPrototypeOf(current);
+      continue;
+    }
+    if ("value" in descriptor && descriptor.writable === false) {
+      return `Cannot patch client: "${methodName}" is non-writable.`;
+    }
+    if (!("value" in descriptor) && typeof descriptor.set !== "function") {
+      return `Cannot patch client: "${methodName}" cannot be reassigned.`;
+    }
+    return null;
+  }
+  return null;
+}
+function detectProviderSafely(client, diagnostics) {
+  try {
+    return detectProvider(client);
+  } catch (error) {
+    emitDiagnostic(diagnostics, {
+      type: "unsupported_client",
+      mode: "observe",
+      detail: error instanceof Error ? error.message : "Unsupported client."
+    });
+    return null;
+  }
+}
+function isWrapped(client, target) {
+  return Boolean(
+    client[REPLAY_WRAPPED] || target[REPLAY_WRAPPED]
+  );
+}
+function setWrapped(client, target) {
+  try {
+    client[REPLAY_WRAPPED] = true;
+  } catch {
+  }
+  try {
+    target[REPLAY_WRAPPED] = true;
+  } catch {
+  }
+}
+function clearWrapped(client, target) {
+  try {
+    delete client[REPLAY_WRAPPED];
+  } catch {
+  }
+  try {
+    delete target[REPLAY_WRAPPED];
+  } catch {
+  }
+}
+function createNoopHandle(client) {
+  return {
+    client,
+    restore() {
+    }
+  };
+}
+function resolveApiKey(opts) {
+  return typeof opts.apiKey === "string" && opts.apiKey.length > 0 ? opts.apiKey : toNonEmptyString(process.env.REPLAYCI_API_KEY);
+}
+function isDisabled(opts) {
+  return opts.disabled === true || isTruthyEnvFlag(process.env.REPLAYCI_DISABLE);
+}
+function isTruthyEnvFlag(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function normalizeCaptureLevel(level) {
+  return level === "metadata" || level === "full" ? level : "redacted";
+}
+function emitDiagnostic(diagnostics, event) {
+  try {
+    diagnostics?.(event);
+  } catch {
+  }
+}
+function isAsyncIterable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.asyncIterator] === "function";
+}
+function toRecord4(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function toRecordLike2(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") ? value : {};
+}
+function toString4(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/validate.ts
+var import_contracts_core3 = require("@replayci/contracts-core");
+
+// src/contracts.ts
+var import_contracts_core2 = require("@replayci/contracts-core");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var CONTRACT_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var MAX_REGEX_BYTES = 1024;
+var NESTED_QUANTIFIER_RE = /\((?:[^()\\]|\\.)*[+*{](?:[^()\\]|\\.)*\)(?:[+*]|\{\d+(?:,\d*)?\})/;
+function loadContracts(input) {
+  const contracts = loadContractsUnchecked(input);
+  if (contracts.length === 0) {
+    throw new ReplayConfigurationError("No contracts found. Check your contracts path.");
+  }
+  validateContractSet(contracts);
+  return contracts;
+}
+function matchContracts(contracts, toolCalls, requestOrContext) {
+  const prepared = contracts;
+  const calledToolNames = new Set(toolCalls.map((toolCall) => toolCall.name));
+  const schemaHash = deriveToolSchemaHash(requestOrContext);
+  return prepared.filter((contract) => {
+    if (!calledToolNames.has(contract.tool)) {
+      return false;
+    }
+    if (contract.tool_schema_hash === void 0) {
+      return true;
+    }
+    return schemaHash !== void 0 && contract.tool_schema_hash === schemaHash;
+  });
+}
+function findUnmatchedTools(toolCalls, matchedContracts) {
+  const matchedToolNames = new Set(matchedContracts.map((contract) => contract.tool));
+  return toolCalls.filter((toolCall) => !matchedToolNames.has(toolCall.name));
+}
+function loadContractsUnchecked(input) {
+  if (typeof input === "string") {
+    return loadContractsFromPaths([input]);
+  }
+  if (Array.isArray(input)) {
+    if (input.length === 0) {
+      return [];
+    }
+    if (input.every((entry) => typeof entry === "string")) {
+      return loadContractsFromPaths(input);
+    }
+    return input.map((contract) => normalizeInlineContract(contract));
+  }
+  return [normalizeInlineContract(input)];
+}
+function loadContractsFromPaths(inputs) {
+  const repoRoot = process.cwd();
+  const contractFiles = inputs.flatMap((input) => {
+    try {
+      return collectContractFiles((0, import_node_path.resolve)(repoRoot, input));
+    } catch (error) {
+      throw new ReplayConfigurationError(
+        `Failed to load contracts from "${input}": ${formatErrorMessage(error)}`
+      );
+    }
+  });
+  return contractFiles.map((contractFile) => {
+    const contractPath = (0, import_node_path.relative)(repoRoot, contractFile);
+    const contract = (0, import_contracts_core2.loadContractSync)({
+      repoRoot,
+      contractPath
+    });
+    return normalizeInlineContract({
+      ...contract,
+      contract_file: contractFile
+    });
+  });
+}
+function collectContractFiles(inputPath) {
+  const stat = (0, import_node_fs.statSync)(inputPath);
+  if (stat.isFile()) {
+    return [inputPath];
+  }
+  if (!stat.isDirectory()) {
+    return [];
+  }
+  return (0, import_node_fs.readdirSync)(inputPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name)).flatMap((entry) => {
+    const fullPath = (0, import_node_path.join)(inputPath, entry.name);
+    if (entry.isDirectory()) {
+      return collectContractFiles(fullPath);
+    }
+    if (entry.isFile() && CONTRACT_EXTENSIONS.has((0, import_node_path.extname)(entry.name).toLowerCase())) {
+      return [fullPath];
+    }
+    return [];
+  });
+}
+function normalizeInlineContract(input) {
+  const source = toRecord5(structuredClone(input));
+  const tool = toString5(source.tool);
+  if (!tool) {
+    throw new ReplayConfigurationError("Inline contract is missing required field: tool");
+  }
+  const assertions = toRecord5(source.assertions);
+  const expectTools = toStringArray(source.expect_tools);
+  const expectedToolCalls = toExpectedToolCalls(source.expected_tool_calls);
+  const contract = {
+    tool,
+    ...toString5(source.tool_schema_hash) ? { tool_schema_hash: toString5(source.tool_schema_hash) } : {},
+    ...isSideEffect(source.side_effect) ? { side_effect: source.side_effect } : {},
+    ...toString5(source.contract_file) ? { contract_file: toString5(source.contract_file) } : {},
+    timeouts: {
+      total_ms: toNonNegativeNumber(toRecord5(source.timeouts).total_ms, 0)
+    },
+    retries: {
+      max_attempts: Math.max(1, toNonNegativeNumber(toRecord5(source.retries).max_attempts, 1)),
+      retry_on: toStringArray(toRecord5(source.retries).retry_on)
+    },
+    rate_limits: {
+      on_429: {
+        respect_retry_after: toBoolean(toRecord5(toRecord5(source.rate_limits).on_429).respect_retry_after, false),
+        max_sleep_seconds: toNonNegativeNumber(
+          toRecord5(toRecord5(source.rate_limits).on_429).max_sleep_seconds,
+          0
+        )
+      }
+    },
+    assertions: {
+      input_invariants: toInvariantArray(assertions.input_invariants),
+      output_invariants: toInvariantArray(assertions.output_invariants)
+    },
+    golden_cases: Array.isArray(source.golden_cases) ? source.golden_cases : [],
+    allowed_errors: toStringArray(source.allowed_errors),
+    ...expectTools.length > 0 ? { expect_tools: expectTools } : {},
+    ...toToolOrder(source.tool_order, expectTools.length > 0) ? {
+      tool_order: toToolOrder(source.tool_order, expectTools.length > 0)
+    } : {},
+    ...isThreshold(source.pass_threshold) ? { pass_threshold: source.pass_threshold } : {},
+    ...expectedToolCalls.length > 0 ? { expected_tool_calls: expectedToolCalls } : {},
+    ...isMatchMode(source.tool_call_match_mode) ? {
+      tool_call_match_mode: source.tool_call_match_mode
+    } : {}
+  };
+  validateSafeRegexes(contract);
+  return contract;
+}
+function validateContractSet(contracts) {
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    const key = `${contract.tool}::${contract.tool_schema_hash ?? ""}`;
+    if (seenKeys.has(key)) {
+      throw new ReplayConfigurationError(
+        `Duplicate contract for tool "${contract.tool}"${contract.tool_schema_hash ? ` and schema hash "${contract.tool_schema_hash}"` : ""}.`
+      );
+    }
+    seenKeys.add(key);
+  }
+}
+function validateSafeRegexes(contract) {
+  const contractLabel = contract.contract_file ?? contract.tool;
+  const invariantGroups = [
+    {
+      label: "assertions.input_invariants",
+      invariants: contract.assertions.input_invariants
+    },
+    {
+      label: "assertions.output_invariants",
+      invariants: contract.assertions.output_invariants
+    }
+  ];
+  for (const [index, expectedToolCall] of (contract.expected_tool_calls ?? []).entries()) {
+    invariantGroups.push({
+      label: `expected_tool_calls[${index}].argument_invariants`,
+      invariants: expectedToolCall.argument_invariants ?? []
+    });
+  }
+  for (const group of invariantGroups) {
+    for (const invariant of group.invariants) {
+      if (typeof invariant.regex !== "string") {
+        continue;
+      }
+      if (Buffer.byteLength(invariant.regex, "utf8") > MAX_REGEX_BYTES) {
+        throw new ReplayConfigurationError(
+          `Regex pattern exceeds ${MAX_REGEX_BYTES} bytes in ${contractLabel} (${group.label}, ${invariant.path}).`
+        );
+      }
+      if (NESTED_QUANTIFIER_RE.test(invariant.regex)) {
+        throw new ReplayConfigurationError(
+          `Nested quantifiers are not allowed in ${contractLabel} (${group.label}, ${invariant.path}).`
+        );
+      }
+      try {
+        void new RegExp(invariant.regex);
+      } catch (error) {
+        throw new ReplayConfigurationError(
+          `Invalid regex in ${contractLabel} (${group.label}, ${invariant.path}): ${formatErrorMessage(error)}`
+        );
+      }
+    }
+  }
+}
+function deriveToolSchemaHash(requestOrContext) {
+  const record = toRecord5(requestOrContext);
+  const boundary = toRecord5(record.boundary);
+  if (typeof boundary.tool_schema_hash === "string") {
+    return boundary.tool_schema_hash;
+  }
+  if (typeof record.tool_schema_hash === "string") {
+    return record.tool_schema_hash;
+  }
+  if (Array.isArray(record.tools)) {
+    try {
+      const { normalized } = (0, import_contracts_core2.normalizeToolArray)(record.tools);
+      return (0, import_contracts_core2.hashToolSchema)(normalized);
+    } catch {
+      return (0, import_contracts_core2.hashToolSchema)(record.tools);
+    }
+  }
+  return void 0;
+}
+function toRecord5(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function toString5(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function toBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function toNonNegativeNumber(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.max(0, value);
+  }
+  return fallback;
+}
+function toInvariantArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => Boolean(entry) && typeof entry === "object").map((entry) => ({
+    path: typeof entry.path === "string" ? entry.path : "$",
+    ...entry.equals !== void 0 ? { equals: entry.equals } : {},
+    ...typeof entry.exists === "boolean" ? { exists: entry.exists } : {},
+    ...typeof entry.type === "string" ? { type: entry.type } : {},
+    ...typeof entry.contains === "string" ? { contains: entry.contains } : {},
+    ...typeof entry.equals_env === "string" ? { equals_env: entry.equals_env } : {},
+    ...typeof entry.note === "string" ? { note: entry.note } : {},
+    ...Array.isArray(entry.one_of) ? { one_of: entry.one_of } : {},
+    ...typeof entry.regex === "string" ? { regex: entry.regex } : {},
+    ...typeof entry.gte === "number" ? { gte: entry.gte } : {},
+    ...typeof entry.lte === "number" ? { lte: entry.lte } : {},
+    ...typeof entry.length_gte === "number" ? { length_gte: entry.length_gte } : {},
+    ...typeof entry.length_lte === "number" ? { length_lte: entry.length_lte } : {}
+  }));
+}
+function toExpectedToolCalls(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => Boolean(entry) && typeof entry === "object").map((entry) => ({
+    name: typeof entry.name === "string" ? entry.name : "",
+    ...Array.isArray(entry.argument_invariants) ? { argument_invariants: toInvariantArray(entry.argument_invariants) } : {}
+  })).filter((entry) => entry.name.length > 0);
+}
+function isThreshold(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function isMatchMode(value) {
+  return value === "any" || value === "strict";
+}
+function toToolOrder(value, hasExpectedTools) {
+  if (value === "any" || value === "strict") {
+    return value;
+  }
+  return hasExpectedTools ? "any" : void 0;
+}
+function isSideEffect(value) {
+  return value === "read" || value === "write" || value === "destructive";
+}
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/validate.ts
+function prepareContracts(input) {
+  assertSupportedNodeRuntime();
+  return loadContracts(input);
+}
+function validate(response, opts) {
+  assertSupportedNodeRuntime();
+  const start = Date.now();
+  try {
+    if (opts == null || opts.contracts == null) {
+      return {
+        pass: false,
+        failures: [{
+          path: "$",
+          operator: "validate_input",
+          expected: "contracts",
+          found: "missing",
+          message: "validate() requires prepared contracts"
+        }],
+        matched_contracts: 0,
+        unmatched_tools: [],
+        evaluation_ms: Date.now() - start
+      };
+    }
+    if (opts.unmatchedPolicy !== void 0 && opts.unmatchedPolicy !== "deny" && opts.unmatchedPolicy !== "allow") {
+      throw new ReplayConfigurationError(
+        `Invalid unmatchedPolicy: "${String(opts.unmatchedPolicy)}". Use "deny" or "allow".`
+      );
+    }
+    const contracts = Array.isArray(opts.contracts) ? opts.contracts : [opts.contracts];
+    const extraction = extractResponse(response);
+    const matchedContracts = matchContracts(contracts, extraction.toolCalls, response);
+    const unmatchedTools = findUnmatchedTools(extraction.toolCalls, matchedContracts);
+    const unmatchedPolicy = opts.unmatchedPolicy ?? "deny";
+    const results = evaluateAllContracts(matchedContracts, extraction);
+    const unmatchedFailures = unmatchedPolicy === "deny" ? unmatchedTools.map((tool) => ({
+      path: "$.tool_calls",
+      operator: "contract_match",
+      expected: "known tool",
+      found: tool.name,
+      message: `No contract for tool "${tool.name}"`
+    })) : [];
+    const failures = [...results.failures, ...unmatchedFailures];
+    return {
+      pass: failures.length === 0,
+      failures,
+      matched_contracts: results.matched.length,
+      unmatched_tools: unmatchedTools.map((tool) => tool.name),
+      evaluation_ms: Date.now() - start
+    };
+  } catch (error) {
+    if (error instanceof ReplayConfigurationError) {
+      throw error;
+    }
+    throw new ReplayInternalError("validate() internal failure", { cause: error });
+  }
+}
+function evaluateAllContracts(matchedContracts, extraction) {
+  const start = Date.now();
+  const failures = [...extraction.failures];
+  for (const contract of matchedContracts) {
+    failures.push(...evaluateExpectTools(contract, extraction.toolCalls));
+    failures.push(...evaluateOutputInvariants(contract, extraction.normalizedResponse));
+    failures.push(...evaluateExpectedToolCallMatchers(contract, extraction.toolCalls));
+  }
+  return {
+    pass: failures.length === 0,
+    failures,
+    matched: matchedContracts,
+    unmatched: [],
+    durationMs: Date.now() - start
+  };
+}
+function extractResponse(response) {
+  const normalizedResponse = createNormalizedResponse(response);
+  const toolCalls = extractToolCallValues(response);
+  const failures = [];
+  const normalizedToolCalls = toolCalls.map((toolCall, index) => {
+    const normalized = normalizeToolCall(toolCall, index);
+    if (normalized.failure) {
+      failures.push(normalized.failure);
+    }
+    return normalized.toolCall;
+  });
+  return {
+    failures,
+    normalizedResponse: normalizedResponse(normalizedToolCalls),
+    toolCalls: normalizedToolCalls
+  };
+}
+function createNormalizedResponse(response) {
+  if (isRecord2(response) && Array.isArray(response.tool_calls)) {
+    return (toolCalls) => ({
+      ...response,
+      tool_calls: toolCalls.map((toolCall) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        function: { name: toolCall.name },
+        arguments: toolCall.parsedArguments
+      }))
+    });
+  }
+  const provider = detectResponseProvider(response);
+  if (provider === "openai") {
+    return (toolCalls) => ({
+      ...toRecord6(response),
+      content: extractContentOpenAI(response),
+      tool_calls: toolCalls.map((toolCall) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        function: { name: toolCall.name },
+        arguments: toolCall.parsedArguments
+      }))
+    });
+  }
+  if (provider === "anthropic") {
+    const textBlocks = extractTextBlocksAnthropic(response);
+    return (toolCalls) => ({
+      ...toRecord6(response),
+      ...textBlocks.length > 0 ? { text_blocks: textBlocks } : {},
+      tool_calls: toolCalls.map((toolCall) => ({
+        id: toolCall.id,
+        name: toolCall.name,
+        function: { name: toolCall.name },
+        arguments: toolCall.parsedArguments
+      }))
+    });
+  }
+  return (toolCalls) => ({
+    ...isRecord2(response) ? response : {},
+    tool_calls: toolCalls.map((toolCall) => ({
+      id: toolCall.id,
+      name: toolCall.name,
+      function: { name: toolCall.name },
+      arguments: toolCall.parsedArguments
+    }))
+  });
+}
+function extractToolCallValues(response) {
+  if (isRecord2(response) && Array.isArray(response.tool_calls)) {
+    return response.tool_calls.map((toolCall, index) => extractTopLevelToolCall(toolCall, index)).filter((toolCall) => toolCall !== null);
+  }
+  const provider = detectResponseProvider(response);
+  return provider ? extractToolCalls(response, provider) : [];
+}
+function evaluateExpectTools(contract, toolCalls) {
+  if (!contract.expect_tools || contract.expect_tools.length === 0) {
+    return [];
+  }
+  const actualNames = toolCalls.map((toolCall) => toolCall.name);
+  const missingPool = [...actualNames];
+  const missingTools = [];
+  for (const expectedTool of contract.expect_tools) {
+    const matchIndex = missingPool.indexOf(expectedTool);
+    if (matchIndex === -1) {
+      missingTools.push(expectedTool);
+      continue;
+    }
+    missingPool.splice(matchIndex, 1);
+  }
+  const matchedCount = contract.expect_tools.length - missingTools.length;
+  const threshold = contract.pass_threshold ?? 1;
+  const matchRatio = contract.expect_tools.length > 0 ? matchedCount / contract.expect_tools.length : 1;
+  const failures = [];
+  if (matchRatio < threshold) {
+    failures.push({
+      path: "$.tool_calls",
+      operator: "expect_tools",
+      expected: contract.expect_tools,
+      found: actualNames,
+      message: `matched ${matchedCount}/${contract.expect_tools.length} (ratio ${matchRatio.toFixed(2)}, threshold ${threshold}), missing: [${missingTools.join(", ")}]`,
+      contract_file: contract.contract_file
+    });
+  }
+  if (contract.tool_order === "strict" && missingTools.length === 0) {
+    const relevantCalls = [];
+    const orderPool = [...contract.expect_tools];
+    for (const actualName of actualNames) {
+      const matchIndex = orderPool.indexOf(actualName);
+      if (matchIndex === -1) {
+        continue;
+      }
+      relevantCalls.push(actualName);
+      orderPool.splice(matchIndex, 1);
+    }
+    const inOrder = contract.expect_tools.every(
+      (expectedTool, index) => relevantCalls[index] === expectedTool
+    );
+    if (!inOrder) {
+      failures.push({
+        path: "$.tool_calls",
+        operator: "tool_order",
+        expected: contract.expect_tools,
+        found: relevantCalls,
+        message: "strict mode: matched calls not in declared order",
+        contract_file: contract.contract_file
+      });
+    }
+  }
+  return failures;
+}
+function evaluateOutputInvariants(contract, normalizedResponse) {
+  const invariantFailures = (0, import_contracts_core3.evaluateInvariants)(
+    normalizedResponse,
+    contract.assertions.output_invariants,
+    process.env
+  );
+  return invariantFailures.map(
+    (failure) => mapInvariantFailure(contract, failure, normalizedResponse)
+  );
+}
+function evaluateExpectedToolCallMatchers(contract, toolCalls) {
+  if (!contract.expected_tool_calls || contract.expected_tool_calls.length === 0) {
+    return [];
+  }
+  const result = (0, import_contracts_core3.evaluateExpectedToolCalls)(
+    toolCalls,
+    contract.expected_tool_calls,
+    contract.pass_threshold ?? 1,
+    contract.tool_call_match_mode ?? "any",
+    process.env
+  );
+  return result.failures.map((failure) => ({
+    path: failure.path,
+    operator: failure.rule,
+    expected: contract.expected_tool_calls?.map((toolCall) => toolCall.name) ?? [],
+    found: toolCalls.map((toolCall) => toolCall.name),
+    message: failure.detail,
+    contract_file: contract.contract_file
+  }));
+}
+function mapInvariantFailure(contract, failure, normalizedResponse) {
+  const invariant = findMatchingInvariant(contract.assertions.output_invariants, failure);
+  const lookup = (0, import_contracts_core3.getPathValue)(normalizedResponse, failure.path);
+  return {
+    path: failure.path,
+    operator: failure.rule,
+    expected: invariant ? getExpectedValueForInvariant(invariant, failure.rule) : "contract invariant",
+    found: getFoundValueForInvariant(lookup, failure.rule),
+    message: failure.detail,
+    contract_file: contract.contract_file
+  };
+}
+function findMatchingInvariant(invariants, failure) {
+  return invariants.find((invariant) => {
+    if (invariant.path !== failure.path) {
+      return false;
+    }
+    switch (failure.rule) {
+      case "equals":
+        return invariant.equals !== void 0;
+      case "exists":
+        return invariant.exists !== void 0;
+      case "type":
+        return invariant.type !== void 0;
+      case "contains":
+        return invariant.contains !== void 0;
+      case "equals_env":
+        return invariant.equals_env !== void 0;
+      case "one_of":
+        return invariant.one_of !== void 0;
+      case "regex":
+        return invariant.regex !== void 0;
+      case "gte":
+        return invariant.gte !== void 0;
+      case "lte":
+        return invariant.lte !== void 0;
+      case "length_gte":
+        return invariant.length_gte !== void 0;
+      case "length_lte":
+        return invariant.length_lte !== void 0;
+      case "path_not_found":
+        return hasValueCheck(invariant);
+      default:
+        return false;
+    }
+  });
+}
+function getExpectedValueForInvariant(invariant, operator) {
+  switch (operator) {
+    case "equals":
+      return invariant.equals;
+    case "exists":
+      return invariant.exists;
+    case "type":
+      return invariant.type;
+    case "contains":
+      return invariant.contains;
+    case "equals_env":
+      return invariant.equals_env ? `env:${invariant.equals_env}` : void 0;
+    case "one_of":
+      return invariant.one_of;
+    case "regex":
+      return invariant.regex;
+    case "gte":
+      return invariant.gte;
+    case "lte":
+      return invariant.lte;
+    case "length_gte":
+      return invariant.length_gte;
+    case "length_lte":
+      return invariant.length_lte;
+    case "path_not_found":
+      return "path exists";
+    default:
+      return "contract invariant";
+  }
+}
+function getFoundValueForInvariant(lookup, operator) {
+  if (!lookup.exists) {
+    return "missing";
+  }
+  switch (operator) {
+    case "type":
+      return Array.isArray(lookup.value) ? "array" : lookup.value === null ? "null" : typeof lookup.value;
+    case "length_gte":
+    case "length_lte":
+      return Array.isArray(lookup.value) || typeof lookup.value === "string" ? lookup.value.length : lookup.value;
+    default:
+      return lookup.value;
+  }
+}
+function normalizeToolCall(toolCall, index) {
+  const parsed = parseArguments(toolCall.arguments);
+  if (parsed.ok) {
+    return {
+      toolCall: {
+        ...toolCall,
+        parsedArguments: parsed.value
+      }
+    };
+  }
+  return {
+    failure: {
+      path: `$.tool_calls[${index}].arguments`,
+      operator: "argument_parse",
+      expected: "valid JSON",
+      found: toolCall.arguments,
+      message: `Tool "${toolCall.name}" returned unparseable arguments`
+    },
+    toolCall: {
+      ...toolCall,
+      parsedArguments: null
+    }
+  };
+}
+function parseArguments(rawArguments) {
+  try {
+    return { ok: true, value: JSON.parse(rawArguments) };
+  } catch {
+    return { ok: false };
+  }
+}
+function extractTopLevelToolCall(toolCall, index) {
+  const record = toRecord6(toolCall);
+  const name = toString6(record.name);
+  if (!name) {
+    return null;
+  }
+  return {
+    id: toString6(record.id) ?? `tool_call_${index}`,
+    name,
+    arguments: serializeArguments4(record.arguments)
+  };
+}
+function detectResponseProvider(response) {
+  const record = toRecord6(response);
+  if (Array.isArray(record.content)) {
+    return "anthropic";
+  }
+  if (!Array.isArray(record.choices) || record.choices.length === 0) {
+    return null;
+  }
+  const firstChoice = toRecord6(record.choices[0]);
+  return isRecord2(firstChoice.message) ? "openai" : null;
+}
+function serializeArguments4(argumentsValue) {
+  if (typeof argumentsValue === "string") {
+    return argumentsValue;
+  }
+  if (argumentsValue === void 0) {
+    return "null";
+  }
+  return JSON.stringify(argumentsValue) ?? "null";
+}
+function hasValueCheck(invariant) {
+  return invariant.equals !== void 0 || invariant.contains !== void 0 || invariant.type !== void 0 || invariant.equals_env !== void 0 || invariant.one_of !== void 0 || invariant.regex !== void 0 || invariant.gte !== void 0 || invariant.lte !== void 0 || invariant.length_gte !== void 0 || invariant.length_lte !== void 0;
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object";
+}
+function toRecord6(value) {
+  return isRecord2(value) ? value : {};
+}
+function toString6(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  observe,
+  prepareContracts,
+  validate
+});