@bitfab/sdk 0.65.7 → 0.65.9

package/dist/{src-DgkDt32g.cjs → src-BWZx-C1S.cjs}

@@ -1,2222 +1,35 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-const require_autoTrace = require("./autoTrace-CQw0qMBt.cjs");
-let _opentelemetry_api = require("@opentelemetry/api");
-let _opentelemetry_core = require("@opentelemetry/core");
-let _opentelemetry_resources = require("@opentelemetry/resources");
-let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-let superjson = require("superjson");
-superjson = __toESM(superjson, 1);
-//#region src/categories.ts
-const CATEGORIES_PATH = "/api/sdk/categories";
-var CategoriesClient = class {
-	constructor(httpClient) {
-		this.httpClient = httpClient;
-	}
-	async save(params) {
-		return (await this.httpClient.request(CATEGORIES_PATH, params)).category;
-	}
-	async get(id) {
-		return (await this.httpClient.get(`${CATEGORIES_PATH}/${encodeURIComponent(id)}`)).category;
-	}
-	async list() {
-		return (await this.httpClient.get(CATEGORIES_PATH)).categories;
-	}
-	async delete(id) {
-		return (await this.httpClient.request(`${CATEGORIES_PATH}/${encodeURIComponent(id)}`, {}, { method: "DELETE" })).category;
-	}
-};
-const AssertionCategoriesClient = CategoriesClient;
-//#endregion
-//#region src/version.generated.ts
-const __version__ = "0.65.7";
-const __packageName__ = "@bitfab/sdk";
-//#endregion
-//#region src/constants.ts
-const DEFAULT_SERVICE_URL = "https://bitfab.ai";
-//#endregion
-//#region src/traceCompletion.ts
-var TraceCompletion = class {
-	constructor() {
-		this.traces = /* @__PURE__ */ new Map();
-		this.closed = /* @__PURE__ */ new Map();
-	}
-	state(traceId) {
-		let state = this.traces.get(traceId);
-		if (state === void 0) {
-			state = {
-				spanIds: /* @__PURE__ */ new Set(),
-				active: /* @__PURE__ */ new Set()
-			};
-			this.traces.set(traceId, state);
-		}
-		return state;
-	}
-	start(traceId, spanId) {
-		if (this.closed.has(traceId)) return;
-		const state = this.state(traceId);
-		state.spanIds.add(spanId);
-		state.active.add(spanId);
-	}
-	open(traceId) {
-		if (!this.closed.has(traceId)) this.state(traceId);
-	}
-	hold(traceId, key) {
-		this.state(traceId).active.add(key);
-	}
-	record(traceId, spanId) {
-		if (!this.closed.has(traceId)) this.state(traceId).spanIds.add(spanId);
-	}
-	end(traceId, spanId) {
-		const state = this.traces.get(traceId);
-		if (state !== void 0) {
-			state.active.delete(spanId);
-			this.drain(traceId, state);
-		}
-	}
-	abort(traceId, spanId) {
-		const state = this.traces.get(traceId);
-		if (state === void 0) return;
-		state.active.delete(spanId);
-		state.spanIds.delete(spanId);
-		if (state.active.size === 0 && state.spanIds.size === 0 && state.complete === void 0) {
-			this.traces.delete(traceId);
-			return;
-		}
-		this.drain(traceId, state);
-	}
-	close(traceId, complete, dropped = false) {
-		const count = this.closed.get(traceId);
-		if (count !== void 0) {
-			complete(count);
-			return;
-		}
-		const state = this.traces.get(traceId);
-		if (state === void 0) return;
-		state.complete = complete;
-		if (dropped) state.active.clear();
-		this.drain(traceId, state);
-	}
-	drain(traceId, state) {
-		if (state.active.size !== 0 || state.complete === void 0) return;
-		this.traces.delete(traceId);
-		this.closed.set(traceId, state.spanIds.size);
-		if (this.closed.size > 1024) {
-			const oldest = this.closed.keys().next().value;
-			if (oldest !== void 0) this.closed.delete(oldest);
-		}
-		state.complete(state.spanIds.size);
-	}
-};
-//#endregion
-//#region src/readEnv.ts
-function readEnv$1(name) {
-	if (typeof process !== "undefined" && process.env) return process.env[name];
-}
-//#endregion
-//#region src/compress.ts
-const DISABLE_COMPRESSION_ENV = "BITFAB_DISABLE_COMPRESSION";
-const MIN_COMPRESSED_BYTES = 8192;
-let gzipNode;
-(typeof process !== "undefined" && process.versions?.node ? import(
-	/* webpackIgnore: true */
-	["node", "zlib"].join(":")
-).then(({ gzip }) => {
-	gzipNode = (data) => new Promise((resolve, reject) => {
-		gzip(data, (error, result) => {
-			if (error) reject(error);
-			else resolve(result);
-		});
-	});
-}).catch(() => {}) : Promise.resolve()).then(() => {});
-function toArrayBuffer(view) {
-	return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
-}
-function compressedRequest(body, rawBytes, compressed) {
-	if (compressed.byteLength >= rawBytes) return {
-		body,
-		rawBytes,
-		wireBytes: rawBytes
-	};
-	return {
-		body: compressed instanceof Uint8Array ? toArrayBuffer(compressed) : compressed,
-		contentEncoding: "gzip",
-		rawBytes,
-		wireBytes: compressed.byteLength
-	};
-}
-async function gzipViaStream(bytes) {
-	const stream = new Blob([bytes]).stream().pipeThrough(new CompressionStream("gzip"));
-	return await new Response(stream).arrayBuffer();
-}
-function encodeRequestBody(body) {
-	if (readEnv$1(DISABLE_COMPRESSION_ENV)) {
-		const rawBytes = new TextEncoder().encode(body).byteLength;
-		return {
-			body,
-			rawBytes,
-			wireBytes: rawBytes
-		};
-	}
-	const bytes = new TextEncoder().encode(body);
-	if (bytes.byteLength < MIN_COMPRESSED_BYTES) return {
-		body,
-		rawBytes: bytes.byteLength,
-		wireBytes: bytes.byteLength
-	};
-	if (gzipNode) return gzipNode(bytes).then((compressed) => compressedRequest(body, bytes.byteLength, compressed), () => ({
-		body,
-		rawBytes: bytes.byteLength,
-		wireBytes: bytes.byteLength
-	}));
-	if (typeof CompressionStream === "undefined") return {
-		body,
-		rawBytes: bytes.byteLength,
-		wireBytes: bytes.byteLength
-	};
-	return gzipViaStream(bytes).then((compressed) => compressedRequest(body, bytes.byteLength, compressed), () => ({
-		body,
-		rawBytes: bytes.byteLength,
-		wireBytes: bytes.byteLength
-	}));
-}
-//#endregion
-//#region src/errors.ts
-var BitfabError = class extends Error {
-	constructor(message, url, status, retryAfterMs) {
-		super(message);
-		this.url = url;
-		this.status = status;
-		this.retryAfterMs = retryAfterMs;
-		this.name = "BitfabError";
-	}
-};
-var MixedTracingError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "MixedTracingError";
-	}
-};
-//#endregion
-//#region src/gitCommand.ts
-const EXIT_GRACE_MS = 500;
-function isUnrefable(value) {
-	return typeof value === "object" && value !== null && "unref" in value && typeof value.unref === "function";
-}
-function unrefStream(stream) {
-	if (isUnrefable(stream)) stream.unref();
-}
-function terminate(child) {
-	if (child.pid && process.platform !== "win32") try {
-		process.kill(-child.pid, "SIGTERM");
-		return;
-	} catch {
-		child.kill("SIGTERM");
-		return;
-	}
-	child.kill("SIGTERM");
-}
-async function gitRunner(options) {
-	let spawn;
-	try {
-		({spawn} = await import("child_process"));
-	} catch {
-		return null;
-	}
-	return (dir, args, env) => new Promise((resolve) => {
-		let child;
-		try {
-			child = spawn("git", args, {
-				cwd: dir,
-				detached: process.platform !== "win32",
-				stdio: [
-					"ignore",
-					"pipe",
-					"pipe"
-				],
-				...env ? { env: {
-					...process.env,
-					...env
-				} } : {}
-			});
-		} catch {
-			resolve(null);
-			return;
-		}
-		const chunks = [];
-		let size = 0;
-		let overflow = false;
-		let exitCode = null;
-		let done = false;
-		const timers = [];
-		const schedule = (callback, ms) => {
-			const timer = setTimeout(callback, ms);
-			if (!options.keepProcessAlive) timer.unref();
-			timers.push(timer);
-		};
-		const finish = () => {
-			if (done) return;
-			done = true;
-			for (const timer of timers) clearTimeout(timer);
-			child.stdout?.destroy();
-			child.stderr?.destroy();
-			resolve(exitCode === 0 && !overflow ? Buffer.concat(chunks).toString("utf8") : null);
-		};
-		child.stdout?.on("data", (chunk) => {
-			size += chunk.length;
-			if (size > options.maxBuffer) {
-				overflow = true;
-				terminate(child);
-				return;
-			}
-			chunks.push(chunk);
-		});
-		child.stderr?.resume();
-		child.on("error", () => {
-			exitCode = null;
-			finish();
-		});
-		child.on("exit", (code) => {
-			exitCode = code;
-			schedule(finish, EXIT_GRACE_MS);
-		});
-		child.on("close", (code) => {
-			exitCode = code ?? exitCode;
-			finish();
-		});
-		schedule(() => terminate(child), options.timeoutMs);
-		if (!options.keepProcessAlive) {
-			child.unref();
-			unrefStream(child.stdout);
-			unrefStream(child.stderr);
-		}
-	});
-}
-//#endregion
-//#region src/gitState.ts
-const GIT_TIMEOUT_MS$1 = 3e4;
-const GIT_MAX_BUFFER$1 = 1048576;
-const DISABLE_ENV$1 = "BITFAB_DISABLE_GIT_STATE";
-const SHA_PATTERN = /^[0-9a-f]{40}$/;
-function sha(value) {
-	const trimmed = value?.trim();
-	return trimmed && SHA_PATTERN.test(trimmed) ? trimmed : null;
-}
-function text(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : null;
-}
-function isEmptyGitState(state) {
-	return Object.values(state).every((value) => value === null);
-}
-async function resolveGitState(cwd) {
-	const git = await gitRunner({
-		timeoutMs: GIT_TIMEOUT_MS$1,
-		maxBuffer: GIT_MAX_BUFFER$1,
-		keepProcessAlive: true
-	});
-	if (!git) return null;
-	const run = async (args, env) => (await git(cwd, args, env))?.trim() ?? null;
-	const [refs, email, branch] = await Promise.all([
-		run([
-			"rev-parse",
-			"--show-toplevel",
-			"HEAD",
-			"HEAD^{tree}"
-		]),
-		run(["config", "user.email"]),
-		run([
-			"symbolic-ref",
-			"--short",
-			"-q",
-			"HEAD"
-		])
-	]);
-	const [root, commitSha, baseSha] = (refs ?? "").split("\n");
-	if (!root) return null;
-	const state = {
-		githubEmail: text(email),
-		branch: text(branch),
-		commitSha: sha(commitSha),
-		baseSha: sha(baseSha),
-		experimentSha: await resolveWorkingTreeSha(run, root.trim())
-	};
-	return isEmptyGitState(state) ? null : state;
-}
-async function resolveWorkingTreeSha(run, root) {
-	let indexPath;
-	let cleanup;
-	try {
-		const { mkdtemp, rm } = await import("fs/promises");
-		const { join } = await import("path");
-		const { tmpdir } = await import("os");
-		const dir = await mkdtemp(join(tmpdir(), "bitfab-git-"));
-		indexPath = join(dir, "index");
-		cleanup = () => rm(dir, {
-			recursive: true,
-			force: true
-		});
-	} catch {
-		return null;
-	}
-	try {
-		const env = { GIT_INDEX_FILE: indexPath };
-		if (await run(["read-tree", "HEAD"], env) === null) return null;
-		if (await run([
-			"add",
-			"-A",
-			"--",
-			root
-		], env) === null) return null;
-		return sha(await run(["write-tree"], env));
-	} catch {
-		return null;
-	} finally {
-		await cleanup().catch(() => {});
-	}
-}
-function resolvedGitState() {
-	if (typeof process === "undefined" || process.env?.[DISABLE_ENV$1]) return Promise.resolve(null);
-	let cwd;
-	try {
-		cwd = process.cwd?.() ?? ".";
-	} catch {
-		return Promise.resolve(null);
-	}
-	return resolveGitState(cwd).catch(() => null);
-}
-//#endregion
-//#region src/replayContext.ts
-let replayContextStorage = null;
-const REPLAY_CONTEXT_STORAGE_SYMBOL = Symbol.for("bitfab.replayContextStorage");
-const replayContextReady = require_autoTrace.asyncStorageReady.then(() => {
-	const shared = globalThis;
-	const existing = shared[REPLAY_CONTEXT_STORAGE_SYMBOL];
-	if (existing) {
-		replayContextStorage = existing;
-		return;
-	}
-	const created = require_autoTrace.createAsyncLocalStorage();
-	if (created) {
-		shared[REPLAY_CONTEXT_STORAGE_SYMBOL] = created;
-		replayContextStorage = created;
-	}
-});
-function getReplayContext() {
-	return replayContextStorage?.getStore() ?? null;
-}
-function runWithReplayContext(ctx, fn) {
-	if (replayContextStorage) return replayContextStorage.run(ctx, fn);
-	return fn();
-}
-//#endregion
-//#region src/payloadBudget.ts
-const MAX_SPAN_CARRIER_BYTES = 28e5;
-const MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES = 78e5;
-const textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
-function byteLength(value) {
-	return textEncoder ? textEncoder.encode(value).length : value.length;
-}
-function carrierByteLength(body) {
-	return carrierBytesOf(textEncoder ? textEncoder.encode(body) : null, body);
-}
-function carrierBytesOf(encoded, body) {
-	if (!encoded) return body.length + 2;
-	let extra = 2;
-	for (let i = 0; i < encoded.length; i++) {
-		const byte = encoded[i];
-		if (byte === 34 || byte === 92) extra += 1;
-		else if (byte < 32) extra += byte === 8 || byte === 9 || byte === 10 || byte === 12 || byte === 13 ? 1 : 5;
-	}
-	return encoded.length + extra;
-}
-const MAX_BYTES_PER_UNIT = 3;
-function fitsCarrierBudget(body, maxBytes = MAX_SPAN_CARRIER_BYTES) {
-	const units = body.length;
-	if (units * MAX_BYTES_PER_UNIT + 2 <= maxBytes) return true;
-	if (units + 2 > maxBytes) return false;
-	return carrierByteLength(body) <= maxBytes;
-}
-const STRUCTURAL_SPAN_KEYS = /* @__PURE__ */ new Set([
-	"name",
-	"type",
-	"function_name",
-	"error_source"
-]);
-function asRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function cloneTrimmable(payload) {
-	const copy = { ...payload };
-	const containers = [];
-	const spanData = asRecord(copy.span_data);
-	if (spanData) {
-		const clone = { ...spanData };
-		copy.span_data = clone;
-		containers.push(clone);
-	}
-	const rawSpan = asRecord(copy.rawSpan);
-	const rawSpanData = rawSpan && asRecord(rawSpan.span_data);
-	if (rawSpan && rawSpanData) {
-		const clone = { ...rawSpanData };
-		copy.rawSpan = {
-			...rawSpan,
-			span_data: clone
-		};
-		containers.push(clone);
-	}
-	if (containers.length === 0) containers.push(copy);
-	return {
-		copy,
-		containers
-	};
-}
-function collectCandidates(containers) {
-	const candidates = [];
-	for (const container of containers) for (const [key, value] of Object.entries(container)) {
-		if (STRUCTURAL_SPAN_KEYS.has(key) || value == null) continue;
-		let size;
-		try {
-			size = byteLength(JSON.stringify(value) ?? "");
-		} catch {
-			continue;
-		}
-		candidates.push({
-			container,
-			key,
-			size
-		});
-	}
-	return candidates.sort((a, b) => b.size - a.size);
-}
-function trimPayloadToBudget(payload, encode, maxBytes = MAX_SPAN_CARRIER_BYTES) {
-	const { copy, containers } = cloneTrimmable(payload);
-	const candidates = collectCandidates(containers);
-	if (candidates.length === 0) return;
-	const trimmed = [];
-	for (const candidate of candidates) {
-		candidate.container[candidate.key] = `<unserializable: too_large_${candidate.size}_bytes>`;
-		trimmed.push(candidate.key);
-		let body;
-		try {
-			body = encode(copy);
-		} catch {
-			return;
-		}
-		if (fitsCarrierBudget(body, maxBytes)) return {
-			value: copy,
-			trimmed
-		};
-	}
-}
-function markPayloadTrimmed(value, trimmed, maxBytes = MAX_SPAN_CARRIER_BYTES) {
-	value.errors = [...Array.isArray(value.errors) ? value.errors : [], {
-		source: "sdk",
-		step: "payload_budget",
-		error: `trimmed oversized field(s) to fit the ${maxBytes}-byte span carrier budget: ${[...new Set(trimmed)].join(", ")}`
-	}];
-}
-//#endregion
-//#region src/serializePayload.ts
-function serializePayloadBody(payload, maxCarrierBytes = MAX_SPAN_CARRIER_BYTES) {
-	return require_autoTrace.runWithCaptureSuppressed(() => encodeWithinBudget(payload, maxCarrierBytes));
-}
-function encodeWithinBudget(payload, maxCarrierBytes) {
-	const encoded = encodePayloadBody(payload);
-	if (fitsCarrierBudget(encoded.body, maxCarrierBytes)) return {
-		body: encoded.body,
-		dropped: encoded.dropped
-	};
-	return applyPayloadBudget(encoded, maxCarrierBytes);
-}
-function applyPayloadBudget(encoded, maxCarrierBytes) {
-	const result = encoded.value ? trimPayloadToBudget(encoded.value, (value) => encodePayloadBody(value).body, maxCarrierBytes) : void 0;
-	if (!result) return {
-		body: encoded.body,
-		dropped: encoded.dropped
-	};
-	require_autoTrace.warnOnce("payload:over-budget", `a span payload exceeded the ${maxCarrierBytes}-byte carrier budget; its largest field(s) (${[...new Set(result.trimmed)].join(", ")}) were replaced with placeholders so the span still ships. The span is incomplete and may not be replayable.`);
-	markPayloadTrimmed(result.value, result.trimmed, maxCarrierBytes);
-	return {
-		body: encodePayloadBody(result.value).body,
-		dropped: encoded.dropped
-	};
-}
-function encodePayloadBody(payload) {
-	try {
-		return {
-			body: JSON.stringify(payload),
-			dropped: [],
-			value: payload
-		};
-	} catch {
-		const dropped = [];
-		const sanitize = (value, seen) => {
-			const t = typeof value;
-			if (value === null || t === "string" || t === "number" || t === "boolean") return value;
-			if (t === "bigint") {
-				dropped.push("BigInt");
-				return "<unserializable: BigInt>";
-			}
-			if (t === "function") {
-				const name = value.name || "Function";
-				dropped.push(name);
-				return `<unserializable: ${name}>`;
-			}
-			if (t === "symbol") {
-				dropped.push("Symbol");
-				return "<unserializable: Symbol>";
-			}
-			if (t !== "object") return;
-			const obj = value;
-			const className = obj.constructor?.name || "object";
-			if (seen.has(obj)) {
-				dropped.push(className);
-				return `<cycle: ${className}>`;
-			}
-			seen.add(obj);
-			let result;
-			if (Array.isArray(obj)) result = obj.map((item) => sanitize(item, seen));
-			else if (typeof obj.toJSON === "function") try {
-				result = sanitize(obj.toJSON(), seen);
-			} catch {
-				dropped.push(className);
-				result = `<unserializable: ${className}>`;
-			}
-			else try {
-				const out = {};
-				for (const [k, v] of Object.entries(obj)) out[k] = sanitize(v, seen);
-				result = out;
-			} catch {
-				require_autoTrace.warnOnce("payload:field-getter-threw", "a value with a throwing getter/proxy could not be serialized into a span payload; it was replaced with a placeholder. The span still ships with its other fields intact.");
-				dropped.push(className);
-				result = `<unserializable: ${className}>`;
-			}
-			seen.delete(obj);
-			return result;
-		};
-		let sanitized;
-		try {
-			sanitized = sanitize(payload, /* @__PURE__ */ new WeakSet());
-		} catch (error) {
-			const marker = { error: `payload_serialize_failed: ${error instanceof Error ? error.message : String(error)}` };
-			return {
-				body: JSON.stringify(marker),
-				dropped,
-				value: marker
-			};
-		}
-		const isRecord = typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized);
-		if (dropped.length > 0 && isRecord) {
-			const obj = sanitized;
-			obj.errors = [...Array.isArray(obj.errors) ? obj.errors : [], {
-				source: "sdk",
-				step: "json_serialize",
-				error: `stubbed non-serializable value(s): ${[...new Set(dropped)].join(", ")}`
-			}];
-		}
-		return {
-			body: JSON.stringify(sanitized),
-			dropped,
-			value: isRecord ? sanitized : void 0
-		};
-	}
-}
-//#endregion
-//#region src/policyRefresh.ts
-var PolicyRefresh = class {
-	constructor() {
-		this.refreshAfter = 0;
-	}
-	due() {
-		return this.inFlight === void 0 && Date.now() >= this.refreshAfter;
-	}
-	hold(durationMs) {
-		this.refreshAfter = Date.now() + durationMs;
-	}
-	releaseHold() {
-		this.refreshAfter = 0;
-	}
-	run(read, onLoaded, onFailed) {
-		if (!this.due()) return;
-		let request;
-		try {
-			request = read().then(onLoaded).catch(onFailed).finally(() => {
-				this.inFlight = void 0;
-			});
-		} catch (error) {
-			onFailed(error);
-			return;
-		}
-		this.inFlight = request;
-	}
-};
-//#endregion
-//#region src/spanOrigin.ts
-const SPAN_ORIGIN_NAME = "bitfab.sdk.typescript";
-const SPAN_INSTRUMENTATIONS = [
-	"span",
-	"trace",
-	"openai-agents",
-	"langgraph",
-	"claude-agent-sdk",
-	"vercel-ai",
-	"rivet"
-];
-const FRAMEWORK_INSTRUMENTATION_SET = /* @__PURE__ */ new Set([
-	"openai-agents",
-	"langgraph",
-	"claude-agent-sdk",
-	"vercel-ai",
-	"rivet"
-]);
-function isFrameworkInstrumentation(value) {
-	return typeof value === "string" && FRAMEWORK_INSTRUMENTATION_SET.has(value);
-}
-function makeSpanOrigin(instrumentation) {
-	return {
-		name: SPAN_ORIGIN_NAME,
-		version: __version__,
-		instrumentation: { name: instrumentation }
-	};
-}
-function isRecord$4(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function spanOriginOf(payload) {
-	const rawSpan = payload.rawSpan;
-	if (!isRecord$4(rawSpan)) return;
-	const origin = rawSpan.span_origin;
-	if (!isRecord$4(origin) || !isRecord$4(origin.instrumentation)) return;
-	const { name, version } = origin;
-	const instrumentation = origin.instrumentation.name;
-	if (typeof name !== "string" || typeof version !== "string" || typeof instrumentation !== "string" || !SPAN_INSTRUMENTATIONS.includes(instrumentation)) return;
-	return {
-		name,
-		version,
-		instrumentation: { name: instrumentation }
-	};
-}
-function spanInstrumentationOf(payload) {
-	return spanOriginOf(payload)?.instrumentation.name;
-}
-function recordedByFramework(payload) {
-	return isFrameworkInstrumentation(spanInstrumentationOf(payload));
-}
-//#endregion
-//#region src/simulationPlan.ts
-const SIMULATION_PLAN_REFRESH_MS = 6e4;
-const SIMULATION_PLAN_RETRY_MS = 1e4;
-const SIMULATION_PLAN_READ_TIMEOUT_MS = 5e3;
-const SIMULATION_PLAN_MAX_HELD = 1e3;
-const DISABLE_SIMULATION_PLAN_ENV = "BITFAB_DISABLE_SIM_PLAN";
-const NO_API_KEY_FOR_SIMULATION_PLAN = "no API key is set";
-const ROOT_TRACE_FUNCTION_KEY_FIELD = "rootTraceFunctionKey";
-const DECLARED_NODE_FIELD = "declaredNode";
-const CONTENT_OFF_KEY = "content_off_by_simulation_plan";
-const CONTENT_KEYS = [
-	"input",
-	"input_meta",
-	"output",
-	"output_meta",
-	"replay_recording",
-	"prompt"
-];
-function planWaitSliceMs(timeoutMs) {
-	return Math.min(SIMULATION_PLAN_READ_TIMEOUT_MS, Math.max(timeoutMs, 0) / 2);
-}
-function parseSimulationPlan(body) {
-	if (typeof body !== "object" || body === null) return null;
-	const nodes = body.nodes;
-	if (!Array.isArray(nodes)) return null;
-	const contentOff = /* @__PURE__ */ new Map();
-	for (const node of nodes) {
-		if (typeof node !== "object" || node === null) continue;
-		const { traceFunctionKey, name, captureContent } = node;
-		if (typeof traceFunctionKey !== "string" || typeof name !== "string" || typeof captureContent !== "boolean") continue;
-		if (captureContent) continue;
-		const names = contentOff.get(traceFunctionKey) ?? /* @__PURE__ */ new Set();
-		names.add(name);
-		contentOff.set(traceFunctionKey, names);
-	}
-	return contentOff;
-}
-function traceIdOf(payload) {
-	const traceId = payload.traceId;
-	if (typeof traceId === "string") return traceId;
-	const id = payload.id;
-	return typeof id === "string" ? id : void 0;
-}
-function isRecord$3(value) {
-	return typeof value === "object" && value !== null;
-}
-function rawSpanOf(payload) {
-	return isRecord$3(payload.rawSpan) ? payload.rawSpan : void 0;
-}
-function spanDataOf(payload) {
-	const spanData = rawSpanOf(payload)?.span_data;
-	return isRecord$3(spanData) ? spanData : void 0;
-}
-function spanNameOf(payload) {
-	const name = spanDataOf(payload)?.name;
-	return typeof name === "string" ? name : void 0;
-}
-function stripContent(payload) {
-	const rawSpan = rawSpanOf(payload);
-	const spanData = spanDataOf(payload);
-	if (rawSpan === void 0 || spanData === void 0) return payload;
-	const kept = { ...spanData };
-	for (const key of CONTENT_KEYS) delete kept[key];
-	kept[CONTENT_OFF_KEY] = true;
-	return {
-		...payload,
-		rawSpan: {
-			...rawSpan,
-			span_data: kept
-		}
-	};
-}
-function simulationPlanEnvDisabled() {
-	const value = readEnv$1(DISABLE_SIMULATION_PLAN_ENV);
-	return typeof value === "string" && value.trim() !== "";
-}
-function missingSimulationPlanEndpoint(error) {
-	return error instanceof BitfabError && error.status === 404;
-}
-function isTraceRootSpan(payload) {
-	const parentId = rawSpanOf(payload)?.parent_id;
-	return parentId === void 0 || parentId === null;
-}
-function declaredInCode(payload) {
-	return payload[DECLARED_NODE_FIELD] === true;
-}
-function recordedError(payload) {
-	const error = spanDataOf(payload)?.error;
-	return error !== void 0 && error !== null;
-}
-var SimulationPlan = class {
-	constructor(source, enabled = true) {
-		this.source = source;
-		this.enabled = enabled;
-		this.policyRefresh = new PolicyRefresh();
-		this.firstReadOver = false;
-		this.rootWaitOver = false;
-		this.held = [];
-		this.stopped = false;
-		this.readStarted = false;
-		this.loaded = new Promise((resolve) => {
-			this.resolveLoaded = resolve;
-		});
-		this.firstReadEnded = new Promise((resolve) => {
-			this.resolveFirstReadEnded = resolve;
-		});
-	}
-	disabled() {
-		return !this.enabled || simulationPlanEnvDisabled();
-	}
-	idle() {
-		return !this.readStarted && this.source.canRead?.() === false;
-	}
-	refresh() {
-		if (this.idle()) return;
-		this.read();
-	}
-	read() {
-		if (this.stopped || this.disabled()) return;
-		this.readStarted = true;
-		this.policyRefresh.run(() => this.source.getSimulationPlan(), (body) => {
-			const parsed = parseSimulationPlan(body);
-			if (parsed === null) this.scheduleRetry("sim-plan-unreadable", "the sim plan response was not understood");
-			else this.markLoaded(parsed);
-			this.endFirstRead();
-		}, (error) => {
-			if (missingSimulationPlanEndpoint(error)) this.markLoaded(/* @__PURE__ */ new Map());
-			else this.scheduleRetry("sim-plan-unavailable", `could not read the sim plan: ${error instanceof Error ? error.message : String(error)}`);
-			this.endFirstRead();
-		});
-	}
-	markLoaded(parsed) {
-		if (this.stopped) return;
-		this.contentOffByKey = parsed;
-		this.policyRefresh.hold(SIMULATION_PLAN_REFRESH_MS);
-		this.resolveLoaded?.();
-		this.resolveLoaded = void 0;
-	}
-	scheduleRetry(warnKey, reason) {
-		if (this.stopped) return;
-		this.policyRefresh.hold(SIMULATION_PLAN_RETRY_MS);
-		if (this.contentOffByKey !== void 0) return;
-		require_autoTrace.warnOnce(warnKey, `${reason}. Until a read succeeds, spans are sent without their inputs and outputs, except each trace's root span and spans recorded by a framework integration. The read is retried on the next span after ${SIMULATION_PLAN_RETRY_MS / 1e3}s.`);
-	}
-	endFirstRead() {
-		this.endRootWait();
-		if (!this.firstReadOver) {
-			this.firstReadOver = true;
-			this.resolveFirstReadEnded?.();
-			this.resolveFirstReadEnded = void 0;
-		}
-		this.releaseHeld();
-	}
-	endRootWait() {
-		this.rootWaitOver = true;
-		if (this.rootWaitTimer !== void 0) {
-			clearTimeout(this.rootWaitTimer);
-			this.rootWaitTimer = void 0;
-		}
-		this.resolveRootWait?.();
-		this.resolveRootWait = void 0;
-	}
-	waitForFirstRead() {
-		this.refresh();
-		if (this.rootWaitOver || this.disabled() || this.idle() || !this.holdingForFirstRead()) return;
-		if (this.rootWait === void 0) {
-			this.rootWait = new Promise((resolve) => {
-				this.resolveRootWait = resolve;
-			});
-			this.rootWaitTimer = setTimeout(() => this.endRootWait(), SIMULATION_PLAN_READ_TIMEOUT_MS);
-		}
-		return this.rootWait;
-	}
-	holdingForFirstRead() {
-		return this.contentOffByKey === void 0 && !this.firstReadOver && !this.stopped;
-	}
-	unavailableNow() {
-		return !this.disabled() && this.contentOffByKey === void 0 && this.firstReadOver;
-	}
-	firstLoad() {
-		if (this.contentOffByKey !== void 0 || this.stopped || this.disabled() || this.idle()) return;
-		return this.loaded;
-	}
-	send(payload, traceFunctionKey, submit, drop) {
-		this.read();
-		if (this.disabled() || traceFunctionKey === void 0 || spanNameOf(payload) === void 0 || recordedByFramework(payload)) {
-			submit(payload);
-			return;
-		}
-		const entry = {
-			payload,
-			traceFunctionKey,
-			submit,
-			drop
-		};
-		if (this.holdingForFirstRead()) {
-			this.hold(entry);
-			return;
-		}
-		this.submitEntry(entry);
-	}
-	sendTrace(payload, submit) {
-		this.read();
-		if (this.disabled() || !this.holdingForFirstRead() || !this.holdsSpanOfTrace(traceIdOf(payload))) {
-			submit(payload);
-			return;
-		}
-		this.hold({
-			payload,
-			traceFunctionKey: void 0,
-			submit
-		});
-	}
-	holdsSpanOfTrace(traceId) {
-		if (traceId === void 0) return false;
-		return this.held.some((entry) => entry.traceFunctionKey !== void 0 && traceIdOf(entry.payload) === traceId);
-	}
-	hold(entry) {
-		this.held.push(entry);
-		let overflowed = false;
-		while (this.held.length > SIMULATION_PLAN_MAX_HELD) {
-			const oldest = this.held.shift();
-			this.submitEntry(oldest);
-			overflowed = true;
-		}
-		if (overflowed) require_autoTrace.warnOnce("sim-plan-held-overflow", `more than ${SIMULATION_PLAN_MAX_HELD} records were waiting for the sim plan, so the oldest were sent without their inputs and outputs.`);
-	}
-	payloadToSend(entry) {
-		if (entry.traceFunctionKey === void 0 || declaredInCode(entry.payload)) return entry.payload;
-		if (this.contentOffByKey !== void 0) return this.apply(entry.payload, entry.traceFunctionKey);
-		if (recordedByFramework(entry.payload) || isTraceRootSpan(entry.payload)) return entry.payload;
-		return stripContent(entry.payload);
-	}
-	submitEntry(entry) {
-		if (entry.traceFunctionKey !== void 0 && this.skipsSpan(entry.payload, entry.traceFunctionKey)) {
-			entry.drop?.();
-			return;
-		}
-		try {
-			entry.submit(this.payloadToSend(entry));
-		} catch (error) {
-			entry.drop?.();
-			require_autoTrace.warnOnce("sim-plan-held-span-dropped", `a span held for the sim plan was dropped when released: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	releaseHeld() {
-		const held = this.held;
-		this.held = [];
-		for (const entry of held) this.submitEntry(entry);
-	}
-	releaseHeldWithoutPlan() {
-		if (this.held.length === 0) return;
-		if (this.contentOffByKey === void 0) require_autoTrace.warnOnce("sim-plan-not-loaded-at-release", `${this.held.length} record(s) were sent without their inputs and outputs because the sim plan had not loaded`);
-		this.releaseHeld();
-	}
-	async release(timeoutMs) {
-		this.refresh();
-		if (this.held.length > 0) await this.waitForFirstReadEnd(timeoutMs);
-		this.releaseHeldWithoutPlan();
-	}
-	waitForFirstReadEnd(timeoutMs) {
-		if (this.firstReadOver) return Promise.resolve();
-		return new Promise((resolve) => {
-			const timer = setTimeout(resolve, Math.max(timeoutMs, 0));
-			this.firstReadEnded.then(() => {
-				clearTimeout(timer);
-				resolve();
-			});
-		});
-	}
-	stop() {
-		if (this.stopped) return;
-		this.releaseHeldWithoutPlan();
-		this.stopped = true;
-		this.endFirstRead();
-	}
-	contentOff(traceFunctionKey, spanName) {
-		return this.contentOffByKey?.get(traceFunctionKey)?.has(spanName) === true;
-	}
-	contentOffNow(traceFunctionKey, spanName) {
-		return !this.stopped && !this.disabled() && this.contentOff(traceFunctionKey, spanName);
-	}
-	skipsSpan(payload, traceFunctionKey) {
-		const name = spanNameOf(payload);
-		return name !== void 0 && this.contentOff(traceFunctionKey, name) && !isTraceRootSpan(payload) && !declaredInCode(payload) && spanInstrumentationOf(payload) !== void 0 && !recordedByFramework(payload) && !recordedError(payload);
-	}
-	apply(payload, traceFunctionKey) {
-		if (recordedByFramework(payload) || declaredInCode(payload)) return payload;
-		const name = spanNameOf(payload);
-		if (name === void 0 || !this.contentOff(traceFunctionKey, name)) return payload;
-		return stripContent(payload);
-	}
-};
-const activeRecords = /* @__PURE__ */ new Map();
-const completedRecords = /* @__PURE__ */ new Map();
-function findRecord(traceId) {
-	return activeRecords.get(traceId) ?? completedRecords.get(traceId);
-}
-function recordCallerTraceMetadata(traceId, metadata) {
-	if (typeof traceId !== "string" || traceId === "") return;
-	if (typeof metadata !== "object" || metadata === null) return;
-	if (Object.keys(metadata).length === 0) return;
-	const existing = findRecord(traceId);
-	if (existing) {
-		Object.assign(existing.caller, metadata);
-		return;
-	}
-	activeRecords.set(traceId, {
-		caller: { ...metadata },
-		derived: {},
-		warnedKeys: /* @__PURE__ */ new Set()
-	});
-}
-function callerTraceMetadata(traceId) {
-	const record = findRecord(traceId);
-	if (!record || Object.keys(record.caller).length === 0) return;
-	return { ...record.caller };
-}
-function retireTraceMetadata(traceId) {
-	const record = activeRecords.get(traceId);
-	if (!record) return;
-	activeRecords.delete(traceId);
-	completedRecords.set(traceId, record);
-	while (completedRecords.size > 128) {
-		const oldest = completedRecords.keys().next();
-		if (oldest.done) return;
-		completedRecords.delete(oldest.value);
-	}
-}
-function warnAboutShadowedKeys(traceId, record) {
-	const shadowed = Object.keys(record.derived).filter((key) => key in record.caller && record.caller[key] !== record.derived[key] && !record.warnedKeys.has(key)).sort();
-	if (shadowed.length === 0) return;
-	for (const key of shadowed) record.warnedKeys.add(key);
-	require_autoTrace.warn(`trace metadata key(s) ${shadowed.join(", ")} on trace ${traceId} were set both by the caller and by an integration's own trace export; the caller's value is the one kept on the trace.`);
-}
-function mergeCallerMetadataIntoTracePayload(payload) {
-	const externalTrace = payload.externalTrace;
-	if (typeof externalTrace !== "object" || externalTrace === null) return payload;
-	const external = externalTrace;
-	const traceId = typeof payload.id === "string" && payload.id !== "" ? payload.id : external.id;
-	if (typeof traceId !== "string" || traceId === "") return payload;
-	const record = findRecord(traceId);
-	if (!record || Object.keys(record.caller).length === 0) return payload;
-	const exported = external.metadata;
-	if (typeof exported === "object" && exported !== null) Object.assign(record.derived, exported);
-	warnAboutShadowedKeys(traceId, record);
-	return {
-		...payload,
-		externalTrace: {
-			...external,
-			metadata: {
-				...record.derived,
-				...record.caller
-			}
-		}
-	};
-}
-//#endregion
-//#region src/transportTypes.ts
-var DeliveryError = class extends Error {
-	constructor(message, options = {}) {
-		super(message);
-		this.name = "DeliveryError";
-		this.retryable = options.retryable ?? false;
-		this.oversized = options.oversized ?? false;
-		this.retryAfterMs = options.retryAfterMs;
-	}
-};
-//#endregion
-//#region src/unrefTimer.ts
-function unrefTimer(timer) {
-	const handle = timer;
-	if (typeof handle.unref === "function") handle.unref();
-}
-//#endregion
-//#region src/otel.ts
-const OPERATION_ATTRIBUTE = "bitfab.operation";
-const PAYLOAD_ATTRIBUTE = "bitfab.payload";
-const MAX_EXPORT_REQUEST_BYTES = 3e6;
-const MAX_DECOMPRESSED_REQUEST_BYTES = 8e6;
-const MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
-const EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
-const MAX_QUEUE_SIZE = 16384;
-const DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-const DIRECT_MAX_REQUEST_BATCH_SIZE = 256;
-const DEFAULT_EXPORT_CONCURRENCY = 32;
-const MAX_EXPORT_CONCURRENCY = 64;
-const SCHEDULE_DELAY_MILLIS = 5e3;
-const EXPORT_TIMEOUT_MILLIS = 3e4;
-const RETRY_BASE_DELAY_MILLIS = 100;
-const RETRY_BACKOFF_CEILING_MILLIS = 5e3;
-const MAX_SEND_ATTEMPTS = 3;
-const DEFAULT_LIFECYCLE_TIMEOUT_MS$1 = 3e4;
-const liveTransports = /* @__PURE__ */ new Set();
-const carrierRefs = /* @__PURE__ */ new WeakMap();
-function readBoundedIntEnv(name, max, fallback, warnKey) {
-	const raw = readEnv$1(name);
-	if (raw === void 0) return fallback;
-	const value = Number(raw);
-	if (Number.isInteger(value) && value > 0 && value <= max) return value;
-	require_autoTrace.warnOnce(warnKey, `${name} must be a positive integer no greater than ${max}; using ${fallback}`);
-	return fallback;
-}
-function logError(message, error) {
-	try {
-		if (error === void 0) console.error(`[bitfab] ${message}`);
-		else console.error(`[bitfab] ${message}`, error);
-	} catch {}
-}
-function otlpValue(value) {
-	if (typeof value === "boolean") return { boolValue: value };
-	if (typeof value === "number") return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
-	if (typeof value === "string") return { stringValue: value };
-	if (Array.isArray(value)) return { arrayValue: { values: value.map(otlpValue) } };
-	return { stringValue: String(value) };
-}
-function otlpAttributes(attributes) {
-	if (!attributes) return [];
-	return Object.entries(attributes).filter(([, value]) => value !== void 0).map(([key, value]) => ({
-		key,
-		value: otlpValue(value)
-	}));
-}
-function hrTimeToNanoString(time) {
-	if (!time) return "0";
-	return `${time[0]}${String(time[1]).padStart(9, "0")}`;
-}
-function spanToOtlp(span) {
-	const spanContext = span.spanContext();
-	const result = {
-		traceId: spanContext.traceId,
-		spanId: spanContext.spanId,
-		name: span.name,
-		kind: span.kind + 1,
-		startTimeUnixNano: hrTimeToNanoString(span.startTime),
-		endTimeUnixNano: hrTimeToNanoString(span.endTime),
-		attributes: otlpAttributes(span.attributes),
-		droppedAttributesCount: span.droppedAttributesCount,
-		droppedEventsCount: span.droppedEventsCount,
-		droppedLinksCount: span.droppedLinksCount,
-		status: {
-			code: span.status.code,
-			...span.status.message ? { message: span.status.message } : {}
-		},
-		flags: spanContext.traceFlags
-	};
-	const parentSpanId = span.parentSpanContext?.spanId;
-	if (parentSpanId) result.parentSpanId = parentSpanId;
-	if (spanContext.traceState) result.traceState = spanContext.traceState.serialize();
-	return result;
-}
-const SPAN_SEPARATOR_BYTES = 1;
-function encodeSpan(span) {
-	const json = JSON.stringify(spanToOtlp(span));
-	return {
-		json,
-		size: byteLength(json),
-		ref: carrierRefs.get(span)
-	};
-}
-function trimEncodedSpan(span) {
-	try {
-		const carrier = JSON.parse(span.json);
-		const attribute = carrier.attributes?.find((entry) => entry.key === PAYLOAD_ATTRIBUTE);
-		const payloadBody = attribute?.value?.stringValue;
-		if (!attribute?.value || payloadBody === void 0) return;
-		const payload = JSON.parse(payloadBody);
-		attribute.value.stringValue = serializePayloadBody(payload, MAX_SPAN_CARRIER_BYTES).body;
-		const json = JSON.stringify(carrier);
-		return {
-			json,
-			size: byteLength(json)
-		};
-	} catch {
-		return;
-	}
-}
-async function prepareRequest(body) {
-	const prepared = encodeRequestBody(body);
-	return prepared instanceof Promise ? await prepared : prepared;
-}
-function requestEnvelope(first) {
-	const scope = first.instrumentationScope;
-	const head = `{"resourceSpans":[{"resource":${JSON.stringify({ attributes: otlpAttributes(first.resource.attributes) })},"scopeSpans":[{"scope":${JSON.stringify({
-		name: scope.name,
-		version: scope.version ?? ""
-	})},"spans":[`;
-	const tail = "]}]}]}";
-	return {
-		head,
-		tail,
-		size: byteLength(head) + byteLength(tail)
-	};
-}
-function encodeRequest(envelope, spans) {
-	return envelope.head + spans.map((span) => span.json).join(",") + envelope.tail;
-}
-function delay(ms) {
-	return new Promise((resolve) => {
-		unrefTimer(setTimeout(resolve, ms));
-	});
-}
-async function withDeadline(work, timeoutMs) {
-	let timer;
-	try {
-		return await Promise.race([work, new Promise((resolve) => {
-			timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
-			unrefTimer(timer);
-		})]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-async function mapWithConcurrency$1(items, limit, task) {
-	const results = new Array(items.length);
-	let next = 0;
-	const workers = Array.from({ length: Math.min(Math.max(limit, 1), items.length) }, async () => {
-		while (next < items.length) {
-			const index = next;
-			next += 1;
-			results[index] = await task(items[index]);
-		}
-	});
-	await Promise.all(workers);
-	return results;
-}
-function isRetryable(error) {
-	return error instanceof DeliveryError && error.retryable;
-}
-function isOversized(error) {
-	return error instanceof DeliveryError && error.oversized;
-}
-function retryWaitMillis(error, attempt, remainingMillis) {
-	const requested = error instanceof DeliveryError ? error.retryAfterMs : void 0;
-	const affordable = remainingMillis / 2;
-	if (requested !== void 0) return requested < affordable ? requested : null;
-	const backoff = Math.min(RETRY_BASE_DELAY_MILLIS * 2 ** attempt, RETRY_BACKOFF_CEILING_MILLIS);
-	const jittered = backoff / 2 + Math.random() * (backoff / 2);
-	return jittered < affordable ? jittered : null;
-}
-var BitfabSpanExporter = class {
-	constructor(directSender, maxRequestBytes, maxRequestBatchSize, exportConcurrency, onDelivered, exportTimeoutMillis = EXPORT_TIMEOUT_MILLIS) {
-		this.directSender = directSender;
-		this.maxRequestBytes = maxRequestBytes;
-		this.maxRequestBatchSize = maxRequestBatchSize;
-		this.exportConcurrency = exportConcurrency;
-		this.onDelivered = onDelivered;
-		this.exportTimeoutMillis = exportTimeoutMillis;
-		this.throttledUntil = 0;
-	}
-	export(spans, resultCallback) {
-		this.exportAsync(spans).then((succeeded) => {
-			resultCallback({ code: succeeded ? _opentelemetry_core.ExportResultCode.SUCCESS : _opentelemetry_core.ExportResultCode.FAILED });
-		}, (error) => {
-			resultCallback({
-				code: _opentelemetry_core.ExportResultCode.FAILED,
-				error
-			});
-		});
-	}
-	async exportAsync(spans) {
-		if (spans.length === 0) return true;
-		let encoded;
-		let envelope;
-		try {
-			encoded = spans.map(encodeSpan);
-			envelope = requestEnvelope(spans[0]);
-		} catch (error) {
-			logError("failed to encode an OpenTelemetry span batch", error);
-			return false;
-		}
-		return (await mapWithConcurrency$1(this.buildRequestBatches(envelope, encoded), this.exportConcurrency, (batch) => this.send(envelope, batch))).every(Boolean);
-	}
-	buildRequestBatches(envelope, spans) {
-		const batches = [];
-		let current = [];
-		let size = envelope.size;
-		for (const span of spans) {
-			const addition = span.size + (current.length > 0 ? SPAN_SEPARATOR_BYTES : 0);
-			if (current.length > 0 && (current.length >= this.maxRequestBatchSize || size + addition > this.maxRequestBytes)) {
-				batches.push({
-					spans: current,
-					size
-				});
-				current = [];
-				size = envelope.size;
-			}
-			current.push(span);
-			size += span.size + (current.length > 1 ? SPAN_SEPARATOR_BYTES : 0);
-		}
-		if (current.length > 0) batches.push({
-			spans: current,
-			size
-		});
-		return batches;
-	}
-	async send(envelope, batch) {
-		try {
-			let requestSpans = batch.spans;
-			let requestRawBytes = batch.size;
-			let alreadyTrimmed = false;
-			while (true) {
-				if (requestRawBytes <= MAX_DECOMPRESSED_REQUEST_BYTES) {
-					const prepared = await prepareRequest(encodeRequest(envelope, requestSpans));
-					if (prepared.wireBytes <= this.maxRequestBytes) {
-						await this.sendWithRetries(prepared);
-						this.reportDelivered(batch.spans);
-						return true;
-					}
-				}
-				if (batch.spans.length !== 1) {
-					logError("an OpenTelemetry span batch exceeded the configured request-size target and could not be exported");
-					return false;
-				}
-				if (alreadyTrimmed) {
-					logError("a single OpenTelemetry span exceeded the configured request-size target after trimming");
-					return false;
-				}
-				const trimmed = trimEncodedSpan(batch.spans[0]);
-				if (!trimmed) {
-					logError("a single OpenTelemetry span exceeded the configured request-size target and could not be trimmed");
-					return false;
-				}
-				requestSpans = [trimmed];
-				requestRawBytes = envelope.size + trimmed.size;
-				alreadyTrimmed = true;
-			}
-		} catch (error) {
-			if (isOversized(error)) {
-				logError(batch.spans.length === 1 ? "a single OpenTelemetry span exceeded the ingestion request limit and could not be exported" : "an OpenTelemetry span batch exceeded the ingestion request limit and could not be exported");
-				return false;
-			}
-			logError("failed to export an OpenTelemetry span batch", error);
-			return false;
-		}
-	}
-	recordThrottle(error) {
-		const requested = error instanceof DeliveryError ? error.retryAfterMs : void 0;
-		if (requested !== void 0) this.throttledUntil = Math.max(this.throttledUntil, Date.now() + requested);
-	}
-	async awaitThrottle(deadline) {
-		const remaining = this.throttledUntil - Date.now();
-		if (remaining <= 0) return;
-		if (remaining >= (deadline - Date.now()) / 2) throw new DeliveryError(`OTLP ingestion is throttled for another ${remaining}ms, longer than the export budget`);
-		await delay(remaining);
-	}
-	async sendWithRetries(request) {
-		const deadline = Date.now() + this.exportTimeoutMillis;
-		for (let attempt = 0; attempt < MAX_SEND_ATTEMPTS; attempt += 1) try {
-			await this.awaitThrottle(deadline);
-			await this.directSender(request, Math.max(0, deadline - Date.now()));
-			return;
-		} catch (error) {
-			if (isOversized(error)) throw error;
-			this.recordThrottle(error);
-			if (attempt === 2 || !isRetryable(error)) throw error;
-			const wait = retryWaitMillis(error, attempt, deadline - Date.now());
-			if (wait === null) throw error;
-			await delay(wait);
-		}
-	}
-	reportDelivered(spans) {
-		if (this.onDelivered === void 0) return;
-		const refs = spans.map((span) => span.ref).filter((ref) => ref !== void 0);
-		if (refs.length === 0) return;
-		try {
-			this.onDelivered(refs);
-		} catch (error) {
-			logError("a delivery listener threw", error);
-		}
-	}
-	async shutdown() {}
-	async forceFlush() {}
-};
-var DeliveryTrackingExporter = class {
-	constructor(exporter) {
-		this.exporter = exporter;
-		this.failedExports = 0;
-	}
-	export(spans, resultCallback) {
-		try {
-			this.exporter.export(spans, (result) => {
-				if (result.code !== _opentelemetry_core.ExportResultCode.SUCCESS) this.failedExports += 1;
-				resultCallback(result);
-			});
-		} catch (error) {
-			this.failedExports += 1;
-			resultCallback({
-				code: _opentelemetry_core.ExportResultCode.FAILED,
-				error
-			});
-		}
-	}
-	takeFailedExports() {
-		const failed = this.failedExports;
-		this.failedExports = 0;
-		return failed;
-	}
-	shutdown() {
-		return this.exporter.shutdown();
-	}
-	forceFlush() {
-		return this.exporter.forceFlush?.() ?? Promise.resolve();
+const require_bamlPeer = require("./bamlPeer-BUoZgNxZ.cjs");
+const require_http = require("./http-DX-fpUSu.cjs");
+const require_autoTrace = require("./autoTrace-CQw0qMBt.cjs");
+let superjson = require("superjson");
+superjson = require_bamlPeer.__toESM(superjson, 1);
+//#region src/categories.ts
+const CATEGORIES_PATH = "/api/sdk/categories";
+var CategoriesClient = class {
+	constructor(httpClient) {
+		this.httpClient = httpClient;
 	}
-};
-var OtelBatchTransport = class {
-	constructor(options) {
-		this.closed = false;
-		const maxRequestBytes = options.maxRequestBytes ?? MAX_EXPORT_REQUEST_BYTES;
-		const maxRequestBatchSize = options.maxRequestBatchSize ?? DIRECT_MAX_REQUEST_BATCH_SIZE;
-		if (maxRequestBatchSize <= 0) throw new BitfabError("maxRequestBatchSize must be a positive integer");
-		this.deliveryTracker = new DeliveryTrackingExporter(new BitfabSpanExporter(options.directSender, maxRequestBytes, maxRequestBatchSize, options.exportConcurrency ?? DEFAULT_EXPORT_CONCURRENCY, options.onDelivered, options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS));
-		this.processor = new _opentelemetry_sdk_trace_base.BatchSpanProcessor(this.deliveryTracker, {
-			maxQueueSize: options.maxQueueSize ?? MAX_QUEUE_SIZE,
-			maxExportBatchSize: options.maxExportBatchSize ?? DIRECT_MAX_EXPORT_BATCH_SIZE,
-			scheduledDelayMillis: SCHEDULE_DELAY_MILLIS,
-			exportTimeoutMillis: options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS
-		});
-		this.provider = new _opentelemetry_sdk_trace_base.BasicTracerProvider({
-			sampler: new _opentelemetry_sdk_trace_base.AlwaysOnSampler(),
-			resource: (0, _opentelemetry_resources.resourceFromAttributes)({
-				"service.name": "bitfab-typescript-sdk",
-				"service.version": __version__
-			}),
-			spanLimits: {
-				attributeCountLimit: 2,
-				attributeValueLengthLimit: Number.POSITIVE_INFINITY
-			},
-			spanProcessors: [this.processor]
-		});
-		this.tracer = this.provider.getTracer("bitfab", __version__);
-		liveTransports.add(this);
+	async save(params) {
+		return (await this.httpClient.request(CATEGORIES_PATH, params)).category;
 	}
-	submit(operation, payload, meta = {}) {
-		if (this.closed) {
-			require_autoTrace.warnOnce("otel-submit-after-shutdown", "OpenTelemetry transport is shut down; dropping spans");
-			return;
-		}
-		try {
-			const { body, dropped } = serializePayloadBody(payload, MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES);
-			if (dropped.length > 0) require_autoTrace.warnOnce("otel-carrier-payload-stubbed", `a span payload held non-serializable value(s) (${[...new Set(dropped)].join(", ")}); they were stubbed so the span still ships, but the trace may be incomplete or not replayable.`);
-			const span = this.tracer.startSpan(meta.name ?? `bitfab.${operation}`, {
-				attributes: {
-					[OPERATION_ATTRIBUTE]: operation,
-					[PAYLOAD_ATTRIBUTE]: body
-				},
-				startTime: meta.startTime
-			});
-			if (meta.ref !== void 0) carrierRefs.set(span, meta.ref);
-			if (meta.errored === true) span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
-			endSpan(span, meta.endTime);
-		} catch (error) {
-			logError("failed to queue an OpenTelemetry span", error);
-		}
+	async get(id) {
+		return (await this.httpClient.get(`${CATEGORIES_PATH}/${encodeURIComponent(id)}`)).category;
 	}
-	async flush(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS$1) {
-		const pending = (this.pendingFlush ?? Promise.resolve(true)).then(() => this.forceFlushOnce());
-		this.pendingFlush = pending.catch(() => false);
-		return withDeadline(pending, timeoutMs);
+	async list() {
+		return (await this.httpClient.get(CATEGORIES_PATH)).categories;
 	}
-	async forceFlushOnce() {
-		try {
-			await this.processor.forceFlush();
-		} catch (error) {
-			logError("failed to flush OpenTelemetry spans", error);
-			this.deliveryTracker.takeFailedExports();
-			return false;
-		}
-		return this.deliveryTracker.takeFailedExports() === 0;
-	}
-	async shutdown(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS$1) {
-		const deadline = Date.now() + Math.max(timeoutMs, 0);
-		this.closed = true;
-		const flushed = await this.flush(Math.max(0, deadline - Date.now()));
-		liveTransports.delete(this);
-		const shutdownCompleted = await withDeadline(this.provider.shutdown().then(() => true).catch((error) => {
-			logError("failed to shut down the OpenTelemetry transport", error);
-			return false;
-		}), Math.max(0, deadline - Date.now()));
-		return flushed && shutdownCompleted;
+	async delete(id) {
+		return (await this.httpClient.request(`${CATEGORIES_PATH}/${encodeURIComponent(id)}`, {}, { method: "DELETE" })).category;
 	}
 };
-function endSpan(span, endTime) {
-	span.end(endTime);
-}
-function createOtelTransport(options) {
-	return new OtelBatchTransport({
-		...options,
-		exportConcurrency: readBoundedIntEnv(EXPORT_CONCURRENCY_ENV, MAX_EXPORT_CONCURRENCY, DEFAULT_EXPORT_CONCURRENCY, "otel-export-concurrency-invalid"),
-		maxRequestBytes: readBoundedIntEnv(MAX_REQUEST_BYTES_ENV, MAX_EXPORT_REQUEST_BYTES, MAX_EXPORT_REQUEST_BYTES, "otel-max-request-bytes-invalid")
-	});
-}
-async function forEachLiveTransport(timeoutMs, run) {
-	const deadline = Date.now() + Math.max(timeoutMs, 0);
-	let succeeded = true;
-	for (const transport of [...liveTransports]) succeeded = await run(transport, Math.max(0, deadline - Date.now())) && succeeded;
-	return succeeded;
-}
-function flushOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS$1) {
-	return forEachLiveTransport(timeoutMs, (transport, remaining) => transport.flush(remaining));
-}
-function shutdownOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS$1) {
-	return forEachLiveTransport(timeoutMs, (transport, remaining) => transport.shutdown(remaining));
-}
-//#endregion
-//#region src/transport.ts
-function createTraceTransport(options) {
-	return createOtelTransport(options);
-}
-function flushTraceTransports(timeoutMs) {
-	return flushOtelTransports(timeoutMs);
-}
-function shutdownTraceTransports(timeoutMs) {
-	return shutdownOtelTransports(timeoutMs);
-}
+const AssertionCategoriesClient = CategoriesClient;
 //#endregion
-//#region src/http.ts
-var http_exports = /* @__PURE__ */ __exportAll({
-	BitfabError: () => BitfabError,
-	HttpClient: () => HttpClient,
-	SPAN_TYPES: () => SPAN_TYPES,
-	awaitOnExit: () => awaitOnExit,
-	awaitPendingRequests: () => awaitPendingRequests,
-	experimentIdWireFields: () => experimentIdWireFields,
-	flushTraces: () => flushTraces,
-	parseRetryAfterMs: () => parseRetryAfterMs,
-	serializePayloadBody: () => serializePayloadBody
-});
-const REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS = 3e5;
-const REPLAY_COMPLETE_REQUEST_TIMEOUT_MS = 12e4;
-const REPLAY_INTERRUPT_REQUEST_TIMEOUT_MS = 5e3;
-const REPLAY_HEARTBEAT_REQUEST_TIMEOUT_MS = 5e3;
-const OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
-const RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
-	429,
-	500,
-	502,
-	503,
-	504
-]);
-const EXIT_FLUSH_TIMEOUT_MS = 5e3;
-const DEFAULT_LIFECYCLE_TIMEOUT_MS = 3e4;
-const pendingTracePromises = /* @__PURE__ */ new Set();
-const liveHttpClients = /* @__PURE__ */ new Set();
-async function releaseHeldExternalSpans(timeoutMs) {
-	const deadline = Date.now() + Math.max(timeoutMs, 0);
-	let released = true;
-	for (const client of [...liveHttpClients]) released = await client.releaseHeldExternalSpans?.(Math.max(0, deadline - Date.now())) !== false && released;
-	return released;
-}
-function stopSimulationPlans() {
-	for (const client of [...liveHttpClients]) client.stopSimulationPlan?.();
-}
-function awaitOnExit(promise) {
-	pendingTracePromises.add(promise);
-	promise.finally(() => {
-		pendingTracePromises.delete(promise);
-	}).catch(() => {});
-	return promise;
-}
-async function flushTraces(timeoutMs = 5e3) {
-	const deadline = Date.now() + Math.max(timeoutMs, 0);
-	const released = await releaseHeldExternalSpans(planWaitSliceMs(timeoutMs));
-	const requestsFlushed = await awaitPendingRequests(Math.max(0, deadline - Date.now()));
-	const releasedAfterDeferred = await releaseHeldExternalSpans(0);
-	const transportsFlushed = await flushTraceTransports(Math.max(0, deadline - Date.now()));
-	return released && releasedAfterDeferred && requestsFlushed && transportsFlushed;
-}
-async function awaitPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-	await replayContextReady.catch(() => {});
-	return waitForPromises(Array.from(pendingTracePromises), timeoutMs);
-}
-async function waitForPromises(promises, timeoutMs) {
-	if (promises.length === 0) return true;
-	let timer;
-	try {
-		return await Promise.race([Promise.allSettled(promises).then(() => true), new Promise((resolve) => {
-			timer = setTimeout(() => resolve(false), timeoutMs);
-			unrefTimer(timer);
-		})]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
-	let isFlushing = false;
-	process.on("beforeExit", () => {
-		if (isFlushing) return;
-		isFlushing = true;
-		const planWaitMs = SIMULATION_PLAN_READ_TIMEOUT_MS;
-		const stopFlushing = () => {
-			isFlushing = false;
-		};
-		const deadline = setTimeout(stopFlushing, 1e4);
-		unrefTimer(deadline);
-		releaseHeldExternalSpans(planWaitMs).catch(() => {}).then(() => {
-			stopSimulationPlans();
-		}).then(() => Promise.allSettled([...Array.from(pendingTracePromises).map((p) => p.catch(() => {})), shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)])).then(() => {
-			clearTimeout(deadline);
-			stopFlushing();
-		});
-	});
-}
-const SPAN_TYPES = [
-	"llm",
-	"agent",
-	"function",
-	"guardrail",
-	"handoff",
-	"custom"
-];
-function readHeader(response, name) {
-	try {
-		return response.headers?.get(name) ?? null;
-	} catch {
-		return null;
-	}
-}
-function parseRetryAfterMs(header) {
-	const value = header?.trim();
-	if (!value) return;
-	const seconds = Number(value);
-	if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1e3 : void 0;
-	const at = Date.parse(value);
-	if (Number.isNaN(at)) return;
-	return Math.max(0, at - Date.now());
-}
-function carrierMeta(operation, payload, ref) {
-	return {
-		ref,
-		name: carrierName(operation, payload),
-		startTime: payloadTimestamp(payload, "started_at"),
-		endTime: payloadTimestamp(payload, "ended_at"),
-		errored: payloadHasError(payload)
-	};
-}
-function carrierName(operation, payload) {
-	if (operation === "external_span") {
-		const spanData = asPayloadRecord(asPayloadRecord(payload.rawSpan)?.span_data);
-		if (typeof spanData?.name === "string") return spanData.name;
-	}
-	if (typeof payload.traceFunctionKey === "string") return payload.traceFunctionKey;
-	return `bitfab.${operation}`;
-}
-function payloadTimestamp(payload, field) {
-	const rawSpan = asPayloadRecord(payload.rawSpan);
-	const rawTrace = asPayloadRecord(payload.externalTrace) ?? asPayloadRecord(payload.rawTrace);
-	const raw = rawSpan?.[field] ?? rawTrace?.[field];
-	if (typeof raw !== "string") return;
-	const parsed = Date.parse(raw);
-	return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function payloadHasError(payload) {
-	if (asPayloadRecord(asPayloadRecord(payload.rawSpan)?.span_data)?.error != null) return true;
-	const errors = payload.errors;
-	return Array.isArray(errors) ? errors.length > 0 : Boolean(errors);
-}
-function asPayloadRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function carrierRef(payload) {
-	const traceId = sourceTraceIdOf(payload);
-	if (traceId === void 0) return;
-	const rawSpan = payload.rawSpan;
-	if (rawSpan === void 0) return { traceId };
-	const spanId = rawSpan?.id;
-	return {
-		traceId,
-		spanId: typeof spanId === "string" ? spanId : `submission-${++carrierSeq}`
-	};
-}
-function sourceTraceIdOf(payload) {
-	if (typeof payload.sourceTraceId === "string") return payload.sourceTraceId;
-	const id = (payload.externalTrace ?? payload.rawTrace)?.id;
-	return typeof id === "string" ? id : void 0;
-}
-let carrierSeq = 0;
-function describeError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function warnDroppedExternalSpan(error) {
-	require_autoTrace.warnOnce("external-span-dropped", `a span was dropped because the send step failed: ${describeError(error)}`);
-}
-function warnDroppedExternalTrace(error) {
-	require_autoTrace.warnOnce("external-trace-dropped", `a trace was dropped because the send step failed: ${describeError(error)}`);
-}
-var HttpClient = class {
-	constructor(config) {
-		this.traceDeliveries = /* @__PURE__ */ new Map();
-		this.deferredWork = /* @__PURE__ */ new Set();
-		this.traceCompletion = new TraceCompletion();
-		this.closed = false;
-		this.apiKey = config.apiKey;
-		this.serviceUrl = config.serviceUrl;
-		this.timeout = config.timeout ?? 12e4;
-		liveHttpClients.add(this);
-	}
-	resolveApiKey() {
-		return typeof this.apiKey === "function" ? this.apiKey() : this.apiKey;
-	}
-	hasApiKey() {
-		try {
-			const apiKey = this.resolveApiKey();
-			return apiKey !== void 0 && apiKey.trim() !== "";
-		} catch {
-			return false;
-		}
-	}
-	getTraceTransport() {
-		if (this.closed) {
-			require_autoTrace.warnOnce("http-client-closed", "the Bitfab client is closed; dropping spans");
-			return;
-		}
-		if (!this.traceTransport) this.traceTransport = createTraceTransport({
-			directSender: (request, timeoutMs) => this.deliverCarriers(request, timeoutMs),
-			onDelivered: (refs) => this.recordDeliveredCarriers(refs)
-		});
-		return this.traceTransport;
-	}
-	async deliverCarriers(request, timeoutMs) {
-		let response;
-		try {
-			response = await this.sendPrepared(OTLP_TRACES_ENDPOINT, request, { timeout: timeoutMs });
-		} catch (error) {
-			const status = error instanceof BitfabError ? error.status : void 0;
-			if (status === void 0) throw new DeliveryError(`OTLP ingestion failed: ${String(error)}`, { retryable: true });
-			throw new DeliveryError(`OTLP ingestion failed with HTTP ${status}`, {
-				retryable: RETRYABLE_STATUSES.has(status),
-				oversized: status === 413,
-				...error instanceof BitfabError && error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {}
-			});
-		}
-		const serverTraceIds = asPayloadRecord(response?.traceIds);
-		if (serverTraceIds !== void 0) this.recordServerTraceIds(serverTraceIds);
-		const partialSuccess = asPayloadRecord(response?.partialSuccess);
-		const rejected = partialSuccess?.rejectedSpans;
-		if (rejected !== void 0 && rejected !== "0" && rejected !== 0) throw new DeliveryError(`OTLP ingestion rejected ${rejected} span(s): ${partialSuccess?.errorMessage ?? "no reason provided"}`);
-	}
-	trackTraceDeliveries(traceIds) {
-		for (const traceId of traceIds) if (!this.traceDeliveries.has(traceId)) this.traceDeliveries.set(traceId, {
-			submittedSpanIds: /* @__PURE__ */ new Set(),
-			ackedSpanIds: /* @__PURE__ */ new Set(),
-			closed: false,
-			closingAcked: false
-		});
-	}
-	peekServerTraceId(traceId) {
-		return this.traceDeliveries.get(traceId)?.serverTraceId;
-	}
-	hasClosedDeliveries(traceIds) {
-		return traceIds.some((traceId) => this.traceDeliveries.get(traceId)?.closed);
-	}
-	takeTraceDeliveries(traceIds) {
-		const reports = {};
-		for (const traceId of traceIds) {
-			const delivery = this.traceDeliveries.get(traceId);
-			if (delivery === void 0) continue;
-			this.traceDeliveries.delete(traceId);
-			reports[traceId] = {
-				spanCount: delivery.submittedSpanIds.size,
-				closed: delivery.closed,
-				delivered: delivery.closingAcked && [...delivery.submittedSpanIds].every((spanId) => delivery.ackedSpanIds.has(spanId)),
-				serverTraceId: delivery.serverTraceId
-			};
-		}
-		return reports;
-	}
-	recordedMeta(operation, payload, ref) {
-		this.recordSubmittedCarrier(ref);
-		return carrierMeta(operation, payload, ref);
-	}
-	recordSubmittedCarrier(ref) {
-		if (ref === void 0) return;
-		const delivery = this.traceDeliveries.get(ref.traceId);
-		if (delivery === void 0) return;
-		if (ref.spanId === void 0) delivery.closed = true;
-		else delivery.submittedSpanIds.add(ref.spanId);
-	}
-	recordServerTraceIds(map) {
-		for (const [sourceTraceId, serverTraceId] of Object.entries(map)) {
-			if (typeof serverTraceId !== "string") continue;
-			const delivery = this.traceDeliveries.get(sourceTraceId);
-			if (delivery === void 0) continue;
-			delivery.serverTraceId = serverTraceId;
-		}
-	}
-	recordDeliveredCarriers(refs) {
-		for (const ref of refs) {
-			const delivery = this.traceDeliveries.get(ref.traceId);
-			if (delivery === void 0) continue;
-			if (ref.spanId === void 0) delivery.closingAcked = true;
-			else delivery.ackedSpanIds.add(ref.spanId);
-		}
-	}
-	trackDeferred(promise) {
-		this.deferredWork.add(promise);
-		promise.finally(() => this.deferredWork.delete(promise)).catch(() => {});
-		return awaitOnExit(promise);
-	}
-	async settleDeferredWork(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-		const deadline = Date.now() + Math.max(timeoutMs, 0);
-		const released = await this.releaseHeldExternalSpans?.(planWaitSliceMs(timeoutMs));
-		await replayContextReady.catch(() => {});
-		const settled = await waitForPromises(Array.from(this.deferredWork), Math.max(0, deadline - Date.now()));
-		const releasedAfterDeferred = await this.releaseHeldExternalSpans?.(0);
-		return released !== false && releasedAfterDeferred !== false && settled;
-	}
-	async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-		const deadline = Date.now() + Math.max(timeoutMs, 0);
-		const settled = await this.settleDeferredWork(Math.max(0, deadline - Date.now()));
-		const flushed = await this.traceTransport?.flush(Math.max(0, deadline - Date.now())) ?? true;
-		return settled && flushed;
-	}
-	close(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
-		if (this.closing) return this.closing;
-		const deadline = Date.now() + Math.max(timeoutMs, 0);
-		this.closing = (async () => {
-			liveHttpClients.delete(this);
-			const settled = await this.settleDeferredWork(Math.max(0, deadline - Date.now()));
-			this.stopSimulationPlan?.();
-			this.closed = true;
-			this.externalSpanTransform = void 0;
-			this.externalTraceTransform = void 0;
-			this.releaseHeldExternalSpans = void 0;
-			this.stopSimulationPlan = void 0;
-			const transport = this.traceTransport;
-			this.traceTransport = void 0;
-			const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
-			return settled && shutdownOk;
-		})();
-		return this.closing;
-	}
-	async request(endpoint, payload, options) {
-		const { body, dropped } = serializePayloadBody(payload);
-		if (dropped.length > 0) try {
-			console.warn(`Bitfab: request body to ${endpoint} held ${dropped.length} non-serializable value(s) (${[...new Set(dropped)].join(", ")}); they were stubbed so the span still sends, but the trace may be incomplete or not replayable. Capture a JSON-safe projection of this input to make it replayable.`);
-		} catch {}
-		return this.sendEncoded(endpoint, body, options);
-	}
-	async sendEncoded(endpoint, body, options) {
-		const prepared = encodeRequestBody(body);
-		const encoded = prepared instanceof Promise ? await prepared : prepared;
-		return this.sendPrepared(endpoint, encoded, options);
-	}
-	async sendPrepared(endpoint, encoded, options) {
-		const url = `${this.serviceUrl}${endpoint}`;
-		const timeout = options?.timeout ?? this.timeout;
-		const method = options?.method ?? "POST";
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeout);
-		const headers = {
-			"Content-Type": "application/json",
-			Authorization: `Bearer ${this.resolveApiKey() ?? ""}`
-		};
-		if (encoded.contentEncoding) headers["Content-Encoding"] = encoded.contentEncoding;
-		try {
-			const response = await fetch(url, {
-				method,
-				headers,
-				body: encoded.body,
-				signal: controller.signal
-			});
-			if (!response.ok) {
-				const errorText = await response.text();
-				throw new BitfabError(`HTTP ${response.status}: ${errorText.slice(0, 500)}`, void 0, response.status, parseRetryAfterMs(readHeader(response, "retry-after")));
-			}
-			const result = await response.json();
-			if (result.error) {
-				if (result.url) throw new BitfabError(`${result.error} Configure it at: ${this.serviceUrl}${result.url}`, result.url);
-				throw new BitfabError(result.error);
-			}
-			return result;
-		} catch (error) {
-			if (error instanceof BitfabError) throw error;
-			if (error instanceof Error) {
-				if (error.name === "AbortError") throw new BitfabError(`Request timed out after ${timeout}ms`);
-				throw new BitfabError(error.message);
-			}
-			throw new BitfabError("Unknown error occurred");
-		} finally {
-			clearTimeout(timeoutId);
-		}
-	}
-	async lookupFunction(name) {
-		return this.request("/api/sdk/functions/lookup", { name });
-	}
-	async getSimulationPlan() {
-		if (!this.hasApiKey()) throw new BitfabError(NO_API_KEY_FOR_SIMULATION_PLAN);
-		return this.get("/api/sdk/sim-plan", SIMULATION_PLAN_READ_TIMEOUT_MS);
-	}
-	async getTraceSpan(traceId, lookup) {
-		const searchParams = new URLSearchParams();
-		if (lookup.id !== void 0) searchParams.set("id", lookup.id);
-		else {
-			if (lookup.name !== void 0) searchParams.set("name", lookup.name);
-			if (lookup.type !== void 0) searchParams.set("type", lookup.type);
-			searchParams.set("occurrence", String(lookup.occurrence ?? "last"));
-		}
-		const endpoint = `/api/sdk/traces/${encodeURIComponent(traceId)}/span?${searchParams.toString()}`;
-		return (await this.get(endpoint)).span;
-	}
-	async getSpan(spanId) {
-		return (await this.get(`/api/sdk/spans/${encodeURIComponent(spanId)}`)).span;
-	}
-	async get(endpoint, timeoutMs, extraHeaders) {
-		const url = `${this.serviceUrl}${endpoint}`;
-		const timeout = timeoutMs ?? this.timeout;
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeout);
-		try {
-			const response = await fetch(url, {
-				method: "GET",
-				headers: {
-					Authorization: `Bearer ${this.resolveApiKey() ?? ""}`,
-					...extraHeaders
-				},
-				signal: controller.signal
-			});
-			if (!response.ok) {
-				const errorText = await response.text();
-				throw new BitfabError(`HTTP ${response.status}: ${errorText.slice(0, 500)}`, void 0, response.status, parseRetryAfterMs(readHeader(response, "retry-after")));
-			}
-			return await response.json();
-		} catch (error) {
-			if (error instanceof BitfabError) throw error;
-			if (error instanceof Error) {
-				if (error.name === "AbortError") throw new BitfabError(`Request timed out after ${timeout}ms`);
-				throw new BitfabError(error.message);
-			}
-			throw new BitfabError("Unknown error occurred");
-		} finally {
-			clearTimeout(timeoutId);
-		}
-	}
-	sendInternalTrace(functionId, payload) {
-		const body = {
-			...payload,
-			functionId,
-			sdkPackage: __packageName__,
-			sdkVersion: __version__
-		};
-		this.getTraceTransport()?.submit("internal_trace", body, carrierMeta("internal_trace", body, void 0));
-	}
-	sendExternalSpan(payload) {
-		const ref = carrierRef(payload);
-		if (ref?.spanId !== void 0) this.traceCompletion.record(ref.traceId, ref.spanId);
-		const drop = () => {
-			if (ref?.spanId !== void 0) this.traceCompletion.abort(ref.traceId, ref.spanId);
-		};
-		const gate = this.externalSpanTransform;
-		if (gate === void 0) {
-			this.submitExternalSpan(payload);
-			return;
-		}
-		try {
-			gate(payload, (ready) => this.submitExternalSpan(ready), drop);
-		} catch (error) {
-			drop();
-			warnDroppedExternalSpan(error);
-		}
-	}
-	submitExternalSpan(payload) {
-		const body = {
-			...payload,
-			sdkVersion: __version__
-		};
-		delete body[ROOT_TRACE_FUNCTION_KEY_FIELD];
-		delete body[DECLARED_NODE_FIELD];
-		this.getTraceTransport()?.submit("external_span", body, this.recordedMeta("external_span", payload, carrierRef(payload)));
-	}
-	sendExternalTrace(rawPayload) {
-		const payload = mergeCallerMetadataIntoTracePayload(rawPayload);
-		const traceId = sourceTraceIdOf(payload);
-		if (payload.completed === true && traceId !== void 0) {
-			this.traceCompletion.close(traceId, (expectedSpanCount) => this.sendCountedExternalTrace({
-				...payload,
-				expectedSpanCount
-			}), payload.dropped === true);
-			return;
-		}
-		if (traceId !== void 0) this.traceCompletion.open(traceId);
-		this.sendCountedExternalTrace(payload);
-	}
-	sendCountedExternalTrace(payload) {
-		try {
-			const gate = this.externalTraceTransform;
-			if (gate === void 0) this.submitExternalTrace(payload);
-			else gate(payload, (ready) => this.submitExternalTrace(ready));
-		} catch (error) {
-			warnDroppedExternalTrace(error);
-		}
-	}
-	submitExternalTrace(payload) {
-		this.getTraceTransport()?.submit("external_trace", {
-			...payload,
-			sdkPackage: __packageName__,
-			sdkVersion: __version__
-		}, this.recordedMeta("external_trace", payload, payload.completed === true ? carrierRef(payload) : void 0));
-	}
-	async patchTrace(traceId, payload) {
-		const endpoint = `/api/sdk/traces/${encodeURIComponent(traceId)}`;
-		await this.request(endpoint, payload, { method: "PATCH" });
-	}
-	async startReplay(traceFunctionKey, limit, traceIds, name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, experimentGroupId, datasetIds, graderIds, dbBranchSettings, attempts, includeOriginalMetadata, onlyWithAssertions, skipAssertionJudging, experimentalSelectiveReplay, notes, metadata, dryRun, experimentGroupName, invocation) {
-		const payload = { traceFunctionKey };
-		if (experimentalSelectiveReplay !== void 0) payload.experimentalSelectiveReplay = experimentalSelectiveReplay;
-		if (limit !== void 0) payload.limit = limit;
-		if (traceIds) payload.traceIds = traceIds;
-		if (name !== void 0) payload.name = name;
-		if (notes !== void 0) payload.notes = notes;
-		if (metadata !== void 0) payload.metadata = metadata;
-		if (codeChangeDescription !== void 0) payload.codeChangeDescription = codeChangeDescription;
-		if (codeChangeFiles !== void 0) payload.codeChangeFiles = codeChangeFiles;
-		if (includeDbBranchLease) {
-			payload.includeDbBranchLease = true;
-			payload.lazyDbBranchLease = true;
-		}
-		if (experimentGroupId !== void 0) payload.experimentGroupId = experimentGroupId;
-		if (experimentGroupName !== void 0) payload.experimentGroupName = experimentGroupName;
-		if (datasetIds !== void 0) {
-			if (datasetIds.length === 1) payload.datasetId = datasetIds[0];
-			else payload.datasetIds = datasetIds;
-		}
-		if (graderIds !== void 0) payload.graderIds = graderIds;
-		if (dbBranchSettings !== void 0) payload.dbBranchSettings = dbBranchSettings;
-		if (attempts !== void 0 && attempts > 1) payload.attempts = attempts;
-		if (includeOriginalMetadata) payload.includeOriginalMetadata = true;
-		if (onlyWithAssertions) payload.onlyWithAssertions = true;
-		if (skipAssertionJudging !== true) payload.judgeAssertions = true;
-		if (dryRun) payload.dryRun = true;
-		if (invocation !== void 0) payload.invocation = invocation;
-		const git = await resolvedGitState();
-		if (git && !isEmptyGitState(git)) payload.git = git;
-		const timeout = includeDbBranchLease ? REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS : 3e4;
-		const response = await this.request("/api/sdk/replay/start", payload, { timeout });
-		const { testRunId, testRunUrl, ...rest } = response;
-		const experimentId = response.experimentId ?? testRunId;
-		const experimentUrl = response.experimentUrl ?? testRunUrl;
-		if (dryRun && response.experimentId === null) return {
-			...rest,
-			experimentId: null,
-			experimentUrl: null
-		};
-		if (experimentId === void 0 || experimentId === null || experimentUrl === void 0 || experimentUrl === null) throw new BitfabError("Replay start response is missing the experiment ID or URL.");
-		return {
-			...rest,
-			experimentId,
-			experimentUrl
-		};
-	}
-	async resumeReplay(experimentId, traceFunctionKey, codeChangeFiles, force) {
-		const payload = {
-			experimentId,
-			traceFunctionKey,
-			lazyDbBranchLease: true
-		};
-		if (force === true) payload.force = true;
-		if (codeChangeFiles !== void 0) payload.codeChangeFiles = codeChangeFiles;
-		const git = await resolvedGitState();
-		if (git && !isEmptyGitState(git)) payload.git = git;
-		const response = await this.request("/api/sdk/replay/resume", payload, { timeout: REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS });
-		const { testRunId, testRunUrl, ...rest } = response;
-		const resumedExperimentId = response.experimentId ?? testRunId;
-		const experimentUrl = response.experimentUrl ?? testRunUrl;
-		if (resumedExperimentId === void 0 || experimentUrl === void 0) throw new BitfabError("Replay resume response is missing the experiment ID or URL.");
-		return {
-			...rest,
-			experimentId: resumedExperimentId,
-			experimentUrl,
-			work: rest.work ?? [],
-			finished: rest.finished ?? [],
-			skippedOriginalTraceIds: rest.skippedOriginalTraceIds ?? [],
-			includeDbBranchLease: rest.includeDbBranchLease ?? false,
-			dbBranchSettings: rest.dbBranchSettings ?? null
-		};
-	}
-	async getExternalSpan(spanId, options) {
-		const query = options?.view === "replay" ? "?view=replay" : "";
-		const url = `${this.serviceUrl}/api/sdk/externalSpans/${spanId}${query}`;
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), 3e4);
-		try {
-			const response = await fetch(url, {
-				method: "GET",
-				headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-				signal: controller.signal
-			});
-			if (!response.ok) {
-				const errorText = await response.text();
-				throw new BitfabError(`HTTP ${response.status}: ${errorText.slice(0, 500)}`);
-			}
-			return await response.json();
-		} catch (error) {
-			if (error instanceof BitfabError) throw error;
-			if (error instanceof Error) {
-				if (error.name === "AbortError") throw new BitfabError("Request timed out after 30000ms");
-				throw new BitfabError(error.message);
-			}
-			throw new BitfabError("Unknown error occurred");
-		} finally {
-			clearTimeout(timeoutId);
-		}
-	}
-	async getSpanTree(externalSpanId, options) {
-		const searchParams = new URLSearchParams();
-		if (options?.includeOutputs === false) searchParams.set("includeOutputs", "false");
-		if (options?.includeRootOutput === false) searchParams.set("includeRootOutput", "false");
-		const encodedQuery = searchParams.toString();
-		const query = encodedQuery ? `?${encodedQuery}` : "";
-		const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}${query}`;
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), 3e4);
-		try {
-			const response = await fetch(url, {
-				method: "GET",
-				headers: { Authorization: `Bearer ${this.resolveApiKey() ?? ""}` },
-				signal: controller.signal
-			});
-			if (!response.ok) {
-				const errorText = await response.text();
-				throw new BitfabError(`HTTP ${response.status}: ${errorText.slice(0, 500)}`);
-			}
-			return await response.json();
-		} catch (error) {
-			if (error instanceof BitfabError) throw error;
-			if (error instanceof Error) {
-				if (error.name === "AbortError") throw new BitfabError("Request timed out after 30000ms");
-				throw new BitfabError(error.message);
-			}
-			throw new BitfabError("Unknown error occurred");
-		} finally {
-			clearTimeout(timeoutId);
-		}
-	}
-	async getReplayStatus(experimentId, expectedSpanCounts) {
-		return this.request("/api/sdk/replay/status", {
-			...experimentIdWireFields(experimentId),
-			expectedSpanCounts
-		}, { timeout: 3e4 });
-	}
-	async completeReplay(experimentId) {
-		return this.request("/api/sdk/replay/complete", experimentIdWireFields(experimentId), { timeout: REPLAY_COMPLETE_REQUEST_TIMEOUT_MS });
-	}
-	async interruptReplay(experimentId) {
-		try {
-			await this.request("/api/sdk/replay/interrupt", experimentIdWireFields(experimentId), { timeout: REPLAY_INTERRUPT_REQUEST_TIMEOUT_MS });
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	async heartbeatReplay(experimentId) {
-		try {
-			await this.request("/api/sdk/replay/heartbeat", experimentIdWireFields(experimentId), { timeout: REPLAY_HEARTBEAT_REQUEST_TIMEOUT_MS });
-		} catch {}
-	}
-	async getReseedSource(traceId) {
-		return this.get(`/api/sdk/traces/${encodeURIComponent(traceId)}/reseedSource`);
-	}
-	async reseedTrace(traceId, runTraceId) {
-		return this.request(`/api/sdk/traces/${encodeURIComponent(traceId)}/reseed`, { runTraceId }, { timeout: 3e4 });
-	}
-	async resolveDbBranchLease(experimentId, traceId, dbBranchSettings, attempt) {
-		return this.request("/api/sdk/replay/resolveDbBranchLease", {
-			...experimentIdWireFields(experimentId),
-			traceId,
-			dbBranchSettings,
-			...attempt !== void 0 && attempt > 0 ? { attempt } : {}
-		}, { timeout: REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS });
-	}
-	async releaseDbBranchLease(neonBranchId) {
-		await this.request("/api/sdk/replay/releaseDbBranchLease", { neonBranchId }, { timeout: 3e4 });
-	}
-};
-function experimentIdWireFields(experimentId) {
-	return {
-		experimentId,
-		testRunId: experimentId
-	};
-}
+//#region src/constants.ts
+const DEFAULT_SERVICE_URL = "https://bitfab.ai";
 //#endregion
 //#region src/serialize.ts
-const MAX_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
-const MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
+const MAX_SERIALIZED_BYTES = require_http.MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
+const MAX_FRAMEWORK_SERIALIZED_BYTES = require_http.MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
 function describeValue(value) {
 	try {
 		const ctorName = value?.constructor?.name;
@@ -2450,7 +263,7 @@ var BitfabClaudeAgentHandler = class {
 		this.activeSubagentSpans = /* @__PURE__ */ new Map();
 		this.hasRootInput = false;
 		this.ownsHttpClient = config._httpClient === void 0;
-		this.httpClient = config._httpClient ?? new HttpClient({
+		this.httpClient = config._httpClient ?? new require_http.HttpClient({
 			apiKey: config.apiKey,
 			serviceUrl: config.serviceUrl ?? "https://bitfab.ai",
 			timeout: config.timeout ?? 1e4
@@ -2543,7 +356,7 @@ var BitfabClaudeAgentHandler = class {
 			trace_id: spanInfo.traceId,
 			started_at: spanInfo.startedAt,
 			ended_at: spanInfo.endedAt ?? nowIso$1(),
-			span_origin: makeSpanOrigin("claude-agent-sdk"),
+			span_origin: require_http.makeSpanOrigin("claude-agent-sdk"),
 			span_data: spanData
 		};
 		if (spanInfo.parentId !== null) rawSpan.parent_id = spanInfo.parentId;
@@ -2805,25 +618,11 @@ var BitfabClaudeAgentHandler = class {
 	}
 };
 //#endregion
-//#region src/optionalPeer.ts
-function importOptionalPeer(specifierParts) {
-	return import(
-		/* webpackIgnore: true */
-		/* @vite-ignore */
-		specifierParts.join("/")
-);
-}
-//#endregion
 //#region src/baml.ts
-let cachedBaml = null;
 async function loadBaml() {
-	if (cachedBaml) return cachedBaml;
-	try {
-		cachedBaml = await importOptionalPeer(["@boundaryml", "baml"]);
-		return cachedBaml;
-	} catch {
-		throw new Error("@boundaryml/baml is required for Bitfab.call(). Install it with: npm install @boundaryml/baml");
-	}
+	const baml = await require_bamlPeer.loadBamlModule();
+	if (!baml) throw new Error("@boundaryml/baml is required for Bitfab.call(). Install it with: npm install @boundaryml/baml. If it is installed and your app is bundled (Next.js with Turbopack, for example), add `import \"@bitfab/sdk/baml\"` once in your server code.");
+	return baml;
 }
 function capitalize(str) {
 	return str.charAt(0).toUpperCase() + str.slice(1);
@@ -3021,10 +820,10 @@ async function runFunctionWithBaml(bamlSource, inputs, providers, envVars) {
 //#region src/bitfabIds.ts
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function validateTraceId(traceId) {
-	if (typeof traceId !== "string" || !UUID_PATTERN.test(traceId)) throw new BitfabError("traceId must be a valid Bitfab trace ID");
+	if (typeof traceId !== "string" || !UUID_PATTERN.test(traceId)) throw new require_http.BitfabError("traceId must be a valid Bitfab trace ID");
 }
 function validateSpanId(id) {
-	if (typeof id !== "string" || !UUID_PATTERN.test(id)) throw new BitfabError("id must be a valid Bitfab span ID");
+	if (typeof id !== "string" || !UUID_PATTERN.test(id)) throw new require_http.BitfabError("id must be a valid Bitfab span ID");
 }
 const SURFACE_API = {
 	"opt-in": "withSpan()",
@@ -3040,7 +839,8 @@ function resolveSurface(requested, parentSurface) {
 	return requested;
 }
 function mixedTracingError(enteredApi, entered, enclosing, traceFunctionKey) {
-	return new MixedTracingError(`opt-in and opt-out tracing can't be mixed in one call stack: ${enteredApi} (${entered})${traceFunctionKey === void 0 ? "" : ` for "${traceFunctionKey}"`} was entered inside a ${SURFACE_API[enclosing]} call (${enclosing}). ${MIXED_SURFACE_REMEDY[entered]}`);
+	const subject = traceFunctionKey === void 0 ? "" : ` for "${traceFunctionKey}"`;
+	return new require_http.MixedTracingError(`opt-in and opt-out tracing can't be mixed in one call stack: ${enteredApi} (${entered})${subject} was entered inside a ${SURFACE_API[enclosing]} call (${enclosing}). ${MIXED_SURFACE_REMEDY[entered]}`);
 }
 function assertSurfacesCompatible(requested, resolved, parentSurface, traceFunctionKey) {
 	if (requested === "inherit" || requested === "neutral") return;
@@ -3178,7 +978,7 @@ function resolveCommitRefFromEnv(env) {
 	};
 }
 async function resolveCommitRefFromGit(cwd) {
-	const git = await gitRunner({
+	const git = await require_http.gitRunner({
 		timeoutMs: GIT_TIMEOUT_MS,
 		maxBuffer: GIT_MAX_BUFFER,
 		keepProcessAlive: false
@@ -3229,11 +1029,11 @@ let gitStarted = false;
 Promise.resolve();
 function startCommitRefResolution() {
 	if (resolved || gitStarted) return;
-	if (read(readEnv$1, DISABLE_ENV) !== null) {
+	if (read(require_http.readEnv, DISABLE_ENV) !== null) {
 		resolved = true;
 		return;
 	}
-	const fromEnv = resolveCommitRefFromEnv(readEnv$1);
+	const fromEnv = resolveCommitRefFromEnv(require_http.readEnv);
 	if (fromEnv) {
 		ref = fromEnv;
 		resolved = true;
@@ -3321,7 +1121,7 @@ var DatasetsClient = class {
 		}));
 	}
 	async update(datasetId, params) {
-		if (params.name === void 0 && params.description === void 0 && params.golden === void 0) throw new BitfabError("Provide name, description, and/or golden to update.");
+		if (params.name === void 0 && params.description === void 0 && params.golden === void 0) throw new require_http.BitfabError("Provide name, description, and/or golden to update.");
 		return normalizeDataset((await this.httpClient.request(datasetPath(datasetId), {
 			...params.name === void 0 ? {} : { name: params.name },
 			...params.description === void 0 ? {} : { description: params.description },
@@ -3391,7 +1191,7 @@ var DatasetsClient = class {
 //#region src/dbSnapshot.ts
 const SUPPORTED_PROVIDERS = ["neon"];
 function validateDbSnapshotConfig(config) {
-	if (!SUPPORTED_PROVIDERS.includes(config.provider)) throw new BitfabError(`dbSnapshot.provider "${config.provider}" is not supported. Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}.`);
+	if (!SUPPORTED_PROVIDERS.includes(config.provider)) throw new require_http.BitfabError(`dbSnapshot.provider "${config.provider}" is not supported. Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}.`);
 }
 function buildSnapshotRef(config, sdkWallClockBeforeFn) {
 	return {
@@ -3449,7 +1249,7 @@ var GradersClient = class {
 	async getLabels(params) {
 		const hasTraceIds = params.traceIds !== void 0 && params.traceIds.length > 0;
 		const hasGraderId = params.graderId !== void 0;
-		if (!hasTraceIds && !hasGraderId) throw new BitfabError("Pass traceIds, graderId, or both: there is nothing to read otherwise.");
+		if (!hasTraceIds && !hasGraderId) throw new require_http.BitfabError("Pass traceIds, graderId, or both: there is nothing to read otherwise.");
 		const query = new URLSearchParams();
 		if (params.traceIds !== void 0 && params.traceIds.length > 0) query.set("traceIds", params.traceIds.join(","));
 		if (params.graderId !== void 0) query.set("graderId", params.graderId);
@@ -3470,11 +1270,17 @@ const LABELS_PATH = "/api/sdk/traces/labels";
 const HUMAN_LABELS_PATH = "/api/sdk/traces/labels/human";
 function assertEveryVerdictNamesAnAssertion(updates) {
 	const unscoped = updates.filter((update) => !("archive" in update && update.archive === true) && (typeof update.assertionId !== "string" || update.assertionId === ""));
-	if (unscoped.length > 0) throw new BitfabError(`Agent verdicts must name an assertion: ${unscoped.map((update) => update.traceId ?? update.originalTraceId).join(", ")}. Pass the assertionId of the assertion each verdict scores to labels.save, saveAll, skip, and abstain. Only archive may omit it, to clear an old whole-trace verdict.`);
+	if (unscoped.length > 0) {
+		const targets = unscoped.map((update) => update.traceId ?? update.originalTraceId);
+		throw new require_http.BitfabError(`Agent verdicts must name an assertion: ${targets.join(", ")}. Pass the assertionId of the assertion each verdict scores to labels.save, saveAll, skip, and abstain. Only archive may omit it, to clear an old whole-trace verdict.`);
+	}
 }
 function assertEveryHumanVerdictNamesAnAssertion(updates) {
 	const unscoped = updates.filter((update) => typeof update.assertionId !== "string" || update.assertionId === "");
-	if (unscoped.length > 0) throw new BitfabError(`Human verdicts must name an assertion: ${unscoped.map((update) => update.traceId).join(", ")}. Pass the assertionId of the assertion each verdict scores to labels.saveHuman and saveHumanAll.`);
+	if (unscoped.length > 0) {
+		const targets = unscoped.map((update) => update.traceId);
+		throw new require_http.BitfabError(`Human verdicts must name an assertion: ${targets.join(", ")}. Pass the assertionId of the assertion each verdict scores to labels.saveHuman and saveHumanAll.`);
+	}
 }
 function labelEvidencePath(traceId, assertionId) {
 	return `/api/sdk/traces/${encodeURIComponent(traceId)}/assertions/${encodeURIComponent(assertionId)}/evidence`;
@@ -3491,7 +1297,7 @@ var LabelsClient = class {
 		assertEveryVerdictNamesAnAssertion(updates);
 		return (await this.httpClient.request(LABELS_PATH, {
 			labels: updates,
-			...experimentId === void 0 ? {} : experimentIdWireFields(experimentId)
+			...experimentId === void 0 ? {} : require_http.experimentIdWireFields(experimentId)
 		})).labels;
 	}
 	async skip(target, experimentId) {
@@ -3711,7 +1517,7 @@ var BitfabLangGraphCallbackHandler = class {
 		this.runToSpan = /* @__PURE__ */ new Map();
 		this.invocations = /* @__PURE__ */ new Map();
 		this.ownsHttpClient = config._httpClient === void 0;
-		this.httpClient = config._httpClient ?? new HttpClient({
+		this.httpClient = config._httpClient ?? new require_http.HttpClient({
 			apiKey: config.apiKey,
 			serviceUrl: config.serviceUrl ?? "https://bitfab.ai",
 			timeout: config.timeout ?? 1e4
@@ -3812,7 +1618,7 @@ var BitfabLangGraphCallbackHandler = class {
 			trace_id: spanInfo.traceId,
 			started_at: spanInfo.startedAt,
 			ended_at: spanInfo.endedAt ?? nowIso(),
-			span_origin: makeSpanOrigin("langgraph"),
+			span_origin: require_http.makeSpanOrigin("langgraph"),
 			span_data: spanData
 		};
 		if (spanInfo.parentId !== null) rawSpan.parent_id = spanInfo.parentId;
@@ -4014,20 +1820,20 @@ function isEncodedToolResult(value) {
 }
 async function loadLangChainCore() {
 	try {
-		return await importOptionalPeer([
+		return await require_bamlPeer.importOptionalPeer([
 			"@langchain",
 			"core",
 			"messages"
 		]);
 	} catch {
-		throw new BitfabError("LangGraph tool replay requires @langchain/core. Install @langchain/langgraph before using getLangGraphIntegration().", "https://docs.bitfab.ai/frameworks/langgraph");
+		throw new require_http.BitfabError("LangGraph tool replay requires @langchain/core. Install @langchain/langgraph before using getLangGraphIntegration().", "https://docs.bitfab.ai/frameworks/langgraph");
 	}
 }
 async function loadLangGraph() {
 	try {
-		return await importOptionalPeer(["@langchain", "langgraph"]);
+		return await require_bamlPeer.importOptionalPeer(["@langchain", "langgraph"]);
 	} catch {
-		throw new BitfabError("Replaying a LangGraph Command requires @langchain/langgraph.", "https://docs.bitfab.ai/frameworks/langgraph");
+		throw new require_http.BitfabError("Replaying a LangGraph Command requires @langchain/langgraph.", "https://docs.bitfab.ai/frameworks/langgraph");
 	}
 }
 async function reviveNested(value, toolCallId) {
@@ -4080,7 +1886,7 @@ var BitfabLangGraphIntegration = class {
 	}
 	wrapTool(tool) {
 		const toolName = tool.name;
-		if (typeof toolName !== "string" || toolName.length === 0) throw new BitfabError("LangGraph replayable tools must have a name.", "https://docs.bitfab.ai/frameworks/langgraph");
+		if (typeof toolName !== "string" || toolName.length === 0) throw new require_http.BitfabError("LangGraph replayable tools must have a name.", "https://docs.bitfab.ai/frameworks/langgraph");
 		const mockToolsOnReplay = this.mockToolsOnReplay;
 		const shouldMock = typeof mockToolsOnReplay === "boolean" ? mockToolsOnReplay : mockToolsOnReplay.includes(toolName);
 		const originalInvoke = tool.invoke.bind(tool);
@@ -4105,7 +1911,7 @@ var BitfabLangGraphIntegration = class {
 		} });
 	}
 	assertReplayToolResultExists(toolName, shouldMock) {
-		const replayContext = getReplayContext();
+		const replayContext = require_http.getReplayContext();
 		if (!replayContext?.mockTree) return;
 		const counterKey = `${this.traceFunctionKey}:${toolName}`;
 		const callIndex = replayContext.callCounters?.get(counterKey) ?? 0;
@@ -4117,7 +1923,7 @@ var BitfabLangGraphIntegration = class {
 			originalSpanId: mockSpan?.sourceSpanId
 		}));
 		const expectsRecordedOutput = replayContext.mockStrategy === "all" || replayContext.mockStrategy === "marked" && shouldMock;
-		if (hasMatchingOverride !== true && expectsRecordedOutput && !mockSpan) throw new BitfabError(`No recorded LangGraph tool result for "${toolName}" at call ${callIndex + 1}; refusing to execute the live tool during replay.`, "https://docs.bitfab.ai/frameworks/langgraph");
+		if (hasMatchingOverride !== true && expectsRecordedOutput && !mockSpan) throw new require_http.BitfabError(`No recorded LangGraph tool result for "${toolName}" at call ${callIndex + 1}; refusing to execute the live tool during replay.`, "https://docs.bitfab.ai/frameworks/langgraph");
 	}
 	wrapInvoke(fn) {
 		return this.client.withSpan(this.traceFunctionKey, {
@@ -4159,7 +1965,7 @@ var BitfabOpenAIAgentHandler = class {
 		this.getActiveSpanContext = config.getActiveSpanContext;
 	}
 	async wrapRun(agent, input, options) {
-		const { run } = await importOptionalPeer(["@openai", "agents"]);
+		const { run } = await require_bamlPeer.importOptionalPeer(["@openai", "agents"]);
 		if (this.getActiveSpanContext?.() != null) return run(agent, input, options);
 		const isStreaming = options?.stream === true;
 		const finalize = async (result) => {
@@ -4254,6 +2060,7 @@ var OrganizationMembersClient = class {
 const MAX_FILES = 60;
 const MAX_FILE_BYTES = 5e5;
 const MAX_TOTAL_BYTES = 2e6;
+const MAX_BRANCH_WALK = 1e3;
 const NUL = String.fromCharCode(0);
 async function resolveAutoCodeChange(label) {
 	if (typeof process === "undefined") return null;
@@ -4286,7 +2093,7 @@ async function captureCodeChangeFromGit(cwd, label) {
 	} catch {
 		return null;
 	}
-	const git = await gitRunner({
+	const git = await require_http.gitRunner({
 		timeoutMs: 3e4,
 		maxBuffer: 67108864,
 		keepProcessAlive: true
@@ -4295,8 +2102,17 @@ async function captureCodeChangeFromGit(cwd, label) {
 	try {
 		const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
 		if (!root) return null;
-		const resolved = await resolveBase(git, root);
+		let resolved = await resolveBase(git, root);
 		if (!resolved) return null;
+		let entries = await listChanges(git, root, resolved.base);
+		if (entries.length === 0 && resolved.base === "HEAD") {
+			const branchPoint = await resolveBranchPoint(git, root);
+			if (branchPoint) {
+				resolved = branchPoint;
+				entries = await listChanges(git, root, branchPoint.base);
+			}
+		}
+		if (entries.length === 0) return null;
 		const { base, against } = resolved;
 		const blobBytes = async (ref, path) => {
 			const out = await git(root, [
@@ -4316,29 +2132,6 @@ async function captureCodeChangeFromGit(cwd, label) {
 				return 0;
 			}
 		};
-		const tracked = await git(root, [
-			"diff",
-			"--name-status",
-			"--find-renames",
-			"-z",
-			base,
-			"--",
-			":!.bitfab"
-		]);
-		const untracked = await git(root, [
-			"ls-files",
-			"--others",
-			"--exclude-standard",
-			"-z",
-			"--",
-			":!.bitfab"
-		]);
-		const entries = [...parseNameStatusZ(tracked ?? ""), ...(untracked ?? "").split(NUL).filter((p) => p.length > 0).map((path) => ({
-			status: "A",
-			beforePath: path,
-			path
-		}))];
-		if (entries.length === 0) return null;
 		const files = [];
 		let totalBytes = 0;
 		for (const { status, beforePath, path } of entries) {
@@ -4374,6 +2167,129 @@ async function captureCodeChangeFromGit(cwd, label) {
 		return null;
 	}
 }
+async function listChanges(git, root, base) {
+	const tracked = await git(root, [
+		"diff",
+		"--name-status",
+		"--find-renames",
+		"-z",
+		base,
+		"--",
+		":!.bitfab"
+	]);
+	const untracked = await git(root, [
+		"ls-files",
+		"--others",
+		"--exclude-standard",
+		"-z",
+		"--",
+		":!.bitfab"
+	]);
+	return [...parseNameStatusZ(tracked ?? ""), ...(untracked ?? "").split(NUL).filter((p) => p.length > 0).map((path) => ({
+		status: "A",
+		beforePath: path,
+		path
+	}))];
+}
+async function defaultBranchCandidates(git, root) {
+	const originHead = (await git(root, [
+		"rev-parse",
+		"--abbrev-ref",
+		"origin/HEAD"
+	]))?.trim();
+	const candidates = [
+		originHead && originHead !== "origin/HEAD" ? originHead : null,
+		"origin/main",
+		"origin/master",
+		"main",
+		"master"
+	].filter((ref) => !!ref);
+	return [...new Set(candidates)];
+}
+async function resolveDefaultBranch(git, root) {
+	for (const ref of await defaultBranchCandidates(git, root)) if (await refExists(git, root, ref)) return ref;
+	return null;
+}
+async function currentBranchRefs(git, root) {
+	const branch = (await git(root, [
+		"symbolic-ref",
+		"--short",
+		"-q",
+		"HEAD"
+	]))?.trim();
+	const refs = /* @__PURE__ */ new Set();
+	if (branch) {
+		refs.add(`refs/heads/${branch}`);
+		const remotes = (await git(root, ["remote"]))?.split(/\s+/) ?? [];
+		for (const remote of remotes.filter((r) => r.length > 0)) refs.add(`refs/remotes/${remote}/${branch}`);
+	}
+	return refs;
+}
+async function ownBranchRefs(git, root) {
+	const upstream = (await git(root, [
+		"rev-parse",
+		"--symbolic-full-name",
+		"@{upstream}"
+	]))?.trim();
+	const own = await currentBranchRefs(git, root);
+	if (upstream) own.add(upstream);
+	return own;
+}
+async function isOnDefaultBranch(git, root, defaultBranch) {
+	const fullName = (await git(root, [
+		"rev-parse",
+		"--symbolic-full-name",
+		defaultBranch
+	]))?.trim();
+	return !!fullName && (await currentBranchRefs(git, root)).has(fullName);
+}
+async function branchTips(git, root) {
+	const own = await ownBranchRefs(git, root);
+	const listing = await git(root, [
+		"for-each-ref",
+		"--format=%(objectname) %(refname)",
+		"refs/heads",
+		"refs/remotes"
+	]);
+	const tips = /* @__PURE__ */ new Map();
+	for (const line of (listing ?? "").split("\n")) {
+		const [sha, ref] = line.trim().split(" ");
+		if (!ref || own.has(ref) || ref.endsWith("/HEAD") || tips.has(sha)) continue;
+		tips.set(sha, ref.replace(/^refs\/(heads|remotes)\//, ""));
+	}
+	return tips;
+}
+async function resolveBranchPoint(git, root) {
+	const head = (await git(root, ["rev-parse", "HEAD"]))?.trim();
+	if (!head) return null;
+	const defaultBranch = await resolveDefaultBranch(git, root);
+	if (defaultBranch && await isOnDefaultBranch(git, root, defaultBranch)) return null;
+	const defaultBase = defaultBranch ? (await git(root, [
+		"merge-base",
+		"HEAD",
+		defaultBranch
+	]))?.trim() : void 0;
+	const walk = [
+		"rev-list",
+		"--first-parent",
+		`--max-count=${MAX_BRANCH_WALK}`,
+		"HEAD",
+		...defaultBase ? [`^${defaultBase}`] : []
+	];
+	const tips = await branchTips(git, root);
+	const history = (await git(root, walk) ?? "").split(/\s+/).filter(Boolean);
+	for (const sha of history.slice(1)) {
+		const name = tips.get(sha);
+		if (name) return {
+			base: sha,
+			against: `vs ${name}`
+		};
+	}
+	return defaultBase && defaultBase !== head ? {
+		base: defaultBase,
+		against: `vs ${defaultBranch}`
+	} : null;
+}
 async function resolveBase(git, root) {
 	const forced = process.env?.BITFAB_CODE_CHANGE_BASE;
 	if (forced && await refExists(git, root, forced)) {
@@ -4481,7 +2397,7 @@ function startReplayHeartbeat(send) {
 			inFlight = void 0;
 		});
 	}, REPLAY_HEARTBEAT_INTERVAL_MS);
-	unrefTimer(timer);
+	require_http.unrefTimer(timer);
 	return { stop: async () => {
 		stopped = true;
 		clearInterval(timer);
@@ -4580,9 +2496,9 @@ const OPTION_FLAG_NAMES = {
 	datasetIds: "dataset-ids"
 };
 function replayEnvironment() {
-	if (readEnv$1(REPLAY_EXECUTION_TARGET_ENV) === HOSTED_EXECUTION_TARGET) return "cloud_replay";
-	if (CI_TRUE_VALUES.has((readEnv$1(CI_ENV) ?? "").toLowerCase())) return "ci";
-	if (CI_PRESENCE_ENV_VARS.some((name) => (readEnv$1(name) ?? "") !== "")) return "ci";
+	if (require_http.readEnv(REPLAY_EXECUTION_TARGET_ENV) === HOSTED_EXECUTION_TARGET) return "cloud_replay";
+	if (CI_TRUE_VALUES.has((require_http.readEnv(CI_ENV) ?? "").toLowerCase())) return "ci";
+	if (CI_PRESENCE_ENV_VARS.some((name) => (require_http.readEnv(name) ?? "") !== "")) return "ci";
 	return "local";
 }
 function flagScalar(value) {
@@ -4621,7 +2537,7 @@ function buildReplayInvocation(entries = []) {
 		flags: invocationFlags(entries),
 		sdk: {
 			language: "typescript",
-			version: __version__
+			version: require_http.__version__
 		},
 		environment: replayEnvironment()
 	};
@@ -4671,7 +2587,7 @@ function jsonFingerprint(value) {
 //#region src/selectiveReplayRuntime.ts
 function validateSelectiveReplayOptions(options) {
 	const validNodes = (nodes) => Array.isArray(nodes) && nodes.length <= 100 && nodes.every((node) => typeof node?.traceFunctionKey === "string" && node.traceFunctionKey.length > 0 && node.traceFunctionKey.length <= 500 && typeof node.spanName === "string" && node.spanName.length > 0 && node.spanName.length <= 500);
-	if (!options || !validNodes(options.mustRun) || options.mustRun.length === 0 || Object.keys(options).some((key) => key !== "mustRun")) throw new BitfabError("experimentalSelectiveReplay accepts only 1–100 mustRun with traceFunctionKey and spanName. Declare replayReusable on eligible spans, not reusableNodes in the replay request.");
+	if (!options || !validNodes(options.mustRun) || options.mustRun.length === 0 || Object.keys(options).some((key) => key !== "mustRun")) throw new require_http.BitfabError("experimentalSelectiveReplay accepts only 1–100 mustRun with traceFunctionKey and spanName. Declare replayReusable on eligible spans, not reusableNodes in the replay request.");
 }
 function policyKey(options) {
 	return JSON.stringify(options.mustRun.map(replayNodeKey).sort());
@@ -4693,12 +2609,12 @@ var SelectiveReplayRuntime = class {
 		this.observedNames = /* @__PURE__ */ new Map();
 		this.unresolvedAssertions = [];
 		validateSelectiveReplayOptions(options);
-		if (plan?.version !== 4 || !Array.isArray(plan.nodes) || plan.nodes.length === 0 || plan.nodes.length > 500 || !Array.isArray(plan.unresolvedMustRun) || !Array.isArray(plan.assertions) || !plan.options) throw new BitfabError("Server did not return a compatible selective replay plan. Update the server or disable experimentalSelectiveReplay.");
+		if (plan?.version !== 4 || !Array.isArray(plan.nodes) || plan.nodes.length === 0 || plan.nodes.length > 500 || !Array.isArray(plan.unresolvedMustRun) || !Array.isArray(plan.assertions) || !plan.options) throw new require_http.BitfabError("Server did not return a compatible selective replay plan. Update the server or disable experimentalSelectiveReplay.");
 		validateSelectiveReplayOptions(plan.options);
-		if (policyKey(plan.options) !== policyKey(options)) throw new BitfabError("Selective replay plan does not match the requested mustRun nodes.");
+		if (policyKey(plan.options) !== policyKey(options)) throw new require_http.BitfabError("Selective replay plan does not match the requested mustRun nodes.");
 		this.required = new Set(options.mustRun.map(replayNodeKey));
 		for (const node of plan.nodes) {
-			if (typeof node.id !== "string" || this.nodes.has(node.id) || typeof node.traceFunctionKey !== "string" || typeof node.spanName !== "string" || typeof node.mustRun !== "boolean" || typeof node.reusable !== "boolean") throw new BitfabError("Invalid selective replay node.");
+			if (typeof node.id !== "string" || this.nodes.has(node.id) || typeof node.traceFunctionKey !== "string" || typeof node.spanName !== "string" || typeof node.mustRun !== "boolean" || typeof node.reusable !== "boolean") throw new require_http.BitfabError("Invalid selective replay node.");
 			this.nodes.set(node.id, node);
 			if (node.recording !== void 0) this.recordings.set(node.id, {
 				input: node.recording.kwargs === void 0 ? jsonFingerprint(node.recording.input) : void 0,
@@ -4711,16 +2627,16 @@ var SelectiveReplayRuntime = class {
 			}
 		}
 		const root = this.nodes.get(plan.rootId);
-		if (!root || root.parentId !== null || !root.mustRun) throw new BitfabError("Selective replay requires a live recorded root.");
+		if (!root || root.parentId !== null || !root.mustRun) throw new require_http.BitfabError("Selective replay requires a live recorded root.");
 		const assertionIds = /* @__PURE__ */ new Set();
 		let wholeTrace = false;
 		for (const assertion of plan.assertions) {
 			const target = assertion?.target;
-			if (typeof assertion?.id !== "string" || assertion.id.length === 0 || assertionIds.has(assertion.id) || target !== null && (typeof target !== "object" || target.kind !== "output" && target.kind !== "span")) throw new BitfabError("Invalid selective replay assertion requirements.");
+			if (typeof assertion?.id !== "string" || assertion.id.length === 0 || assertionIds.has(assertion.id) || target !== null && (typeof target !== "object" || target.kind !== "output" && target.kind !== "span")) throw new require_http.BitfabError("Invalid selective replay assertion requirements.");
 			assertionIds.add(assertion.id);
 			if (target === null) wholeTrace = true;
 			else if (target.kind === "span") {
-				if (typeof target.name !== "string" || target.name.length === 0 || target.occurrence !== void 0 && target.occurrence !== "first" && target.occurrence !== "last" && !(Number.isInteger(target.occurrence) && typeof target.occurrence === "number" && target.occurrence >= 0)) throw new BitfabError("Invalid selective replay assertion target.");
+				if (typeof target.name !== "string" || target.name.length === 0 || target.occurrence !== void 0 && target.occurrence !== "first" && target.occurrence !== "last" && !(Number.isInteger(target.occurrence) && typeof target.occurrence === "number" && target.occurrence >= 0)) throw new require_http.BitfabError("Invalid selective replay assertion target.");
 				this.assertionNames.add(target.name);
 				if (plan.nodes.filter((node) => node.spanName === target.name).length <= (typeof target.occurrence === "number" ? target.occurrence : 0)) this.unresolvedAssertions.push(assertion.id);
 			}
@@ -4728,7 +2644,7 @@ var SelectiveReplayRuntime = class {
 		this.fullTraceForAssertions = wholeTrace || this.unresolvedAssertions.length > 0;
 		const recordedKeys = new Set(plan.nodes.map(replayNodeKey));
 		const unresolved = options.mustRun.filter((node) => !recordedKeys.has(replayNodeKey(node)));
-		if (JSON.stringify(unresolved.map(replayNodeKey).sort()) !== JSON.stringify(plan.unresolvedMustRun.map(replayNodeKey).sort())) throw new BitfabError("Selective replay plan has incomplete mustRun coverage.");
+		if (JSON.stringify(unresolved.map(replayNodeKey).sort()) !== JSON.stringify(plan.unresolvedMustRun.map(replayNodeKey).sort())) throw new require_http.BitfabError("Selective replay plan has incomplete mustRun coverage.");
 		for (const node of plan.nodes) {
 			const ancestors = /* @__PURE__ */ new Set([node.id]);
 			let requiredByManifest = this.required.has(replayNodeKey(node));
@@ -4736,14 +2652,14 @@ var SelectiveReplayRuntime = class {
 			let parentId = node.parentId;
 			while (parentId !== null) {
 				const parent = this.nodes.get(parentId);
-				if (!parent || ancestors.has(parentId) || node.mustRun && !parent.mustRun) throw new BitfabError("Invalid selective replay ancestry.");
+				if (!parent || ancestors.has(parentId) || node.mustRun && !parent.mustRun) throw new require_http.BitfabError("Invalid selective replay ancestry.");
 				ancestors.add(parentId);
 				requiredByManifest || (requiredByManifest = this.required.has(replayNodeKey(parent)));
 				requiredForAssertion || (requiredForAssertion = this.assertionNames.has(parent.spanName));
 				parentId = parent.parentId;
 			}
-			if (!ancestors.has(plan.rootId) || (requiredByManifest || unresolved.length > 0) && !node.mustRun) throw new BitfabError("Selective replay plan could hide required code.");
-			if (requiredForAssertion && !node.mustRun) throw new BitfabError("Selective replay plan could hide assertion evidence.");
+			if (!ancestors.has(plan.rootId) || (requiredByManifest || unresolved.length > 0) && !node.mustRun) throw new require_http.BitfabError("Selective replay plan could hide required code.");
+			if (requiredForAssertion && !node.mustRun) throw new require_http.BitfabError("Selective replay plan could hide assertion evidence.");
 		}
 	}
 	enter(params) {
@@ -4789,7 +2705,7 @@ var SelectiveReplayRuntime = class {
 		};
 		if (params.safetyMock && (mustRun || !reusable)) {
 			decision("blocked", `safety-conflict:${reason}`);
-			this.failure = new BitfabError(`Selective replay cannot execute or safely reuse safety-mocked node ${params.spanName} (${reason}).`);
+			this.failure = new require_http.BitfabError(`Selective replay cannot execute or safely reuse safety-mocked node ${params.spanName} (${reason}).`);
 			throw this.failure;
 		}
 		if (!mustRun && reusable && (params.safetyMock || node?.reusable === true && params.reuseAllowed)) {
@@ -4820,7 +2736,7 @@ var SelectiveReplayRuntime = class {
 };
 //#endregion
 //#region src/replay.ts
-var replay_exports = /* @__PURE__ */ __exportAll({
+var replay_exports = /* @__PURE__ */ require_bamlPeer.__exportAll({
 	BITFAB_PROGRESS_PREFIX: () => BITFAB_PROGRESS_PREFIX,
 	DbBranchReplayError: () => DbBranchReplayError,
 	JUDGE_ASSERTIONS_DEPRECATION_WARNING: () => JUDGE_ASSERTIONS_DEPRECATION_WARNING,
@@ -4854,15 +2770,15 @@ const RESUME_CONFLICTING_OPTIONS = [
 ];
 const CARRIED_OVER_ERROR = "This item errored in an earlier run of this experiment, before it was resumed.";
 function validateResume(resume, options) {
-	if (resume.trim().length === 0) throw new BitfabError("resume must be the ID of the experiment to resume.");
+	if (resume.trim().length === 0) throw new require_http.BitfabError("resume must be the ID of the experiment to resume.");
 	const conflicting = RESUME_CONFLICTING_OPTIONS.filter((name) => options[name] !== void 0 && options[name] !== false);
-	if (conflicting.length > 0) throw new BitfabError(`resume continues experiment ${resume} with the traces, attempts, and graders it started with, so it cannot be combined with ${conflicting.join(", ")}. Drop those options, or start a new replay without resume.`);
+	if (conflicting.length > 0) throw new require_http.BitfabError(`resume continues experiment ${resume} with the traces, attempts, and graders it started with, so it cannot be combined with ${conflicting.join(", ")}. Drop those options, or start a new replay without resume.`);
 }
 async function resumeReplaySession(httpClient, experimentId, traceFunctionKey, codeChangeFiles, force, requestedDbBranch) {
 	const response = await httpClient.resumeReplay(experimentId, traceFunctionKey, codeChangeFiles, force);
 	const work = response.work.map(({ itemIndex, attempt }) => {
 		const serverItem = response.items[itemIndex];
-		if (serverItem === void 0) throw new BitfabError(`Replay resume for experiment ${response.experimentId} named item ${itemIndex}, but the server returned only ${response.items.length} item(s).`);
+		if (serverItem === void 0) throw new require_http.BitfabError(`Replay resume for experiment ${response.experimentId} named item ${itemIndex}, but the server returned only ${response.items.length} item(s).`);
 		return {
 			serverItem,
 			attempt
@@ -4911,14 +2827,14 @@ function carriedOverReplayItem(finished) {
 }
 function resolveAttempts(attempts) {
 	if (attempts === void 0) return 1;
-	if (!Number.isInteger(attempts) || attempts < 1 || attempts > MAX_REPLAY_ATTEMPTS) throw new BitfabError(`attempts must be an integer from 1 to ${MAX_REPLAY_ATTEMPTS} (got ${attempts}).`);
+	if (!Number.isInteger(attempts) || attempts < 1 || attempts > MAX_REPLAY_ATTEMPTS) throw new require_http.BitfabError(`attempts must be an integer from 1 to ${MAX_REPLAY_ATTEMPTS} (got ${attempts}).`);
 	return attempts;
 }
 function resolveDatasetIds(options) {
-	if (options?.datasetId !== void 0 && options?.datasetIds !== void 0) throw new BitfabError("datasetId and datasetIds are the same selector: pass one dataset through datasetId, or several through datasetIds.");
+	if (options?.datasetId !== void 0 && options?.datasetIds !== void 0) throw new require_http.BitfabError("datasetId and datasetIds are the same selector: pass one dataset through datasetId, or several through datasetIds.");
 	if (options?.datasetId !== void 0) return [options.datasetId];
 	if (options?.datasetIds === void 0) return;
-	if (options.datasetIds.length === 0) throw new BitfabError("datasetIds must contain at least one dataset ID.");
+	if (options.datasetIds.length === 0) throw new require_http.BitfabError("datasetIds must contain at least one dataset ID.");
 	return [...new Set(options.datasetIds)];
 }
 function dbBranchEnabled(dbBranch) {
@@ -4982,7 +2898,7 @@ function reportReplayProgress(progress) {
 		stderr.write(`${BITFAB_PROGRESS_PREFIX}${JSON.stringify(progress, replayJsonReplacer)}\n`);
 	} catch {}
 }
-var ReplayError = class extends BitfabError {
+var ReplayError = class extends require_http.BitfabError {
 	constructor(message, items, experimentId, experimentUrl, cause) {
 		super(message, experimentUrl);
 		this.items = items;
@@ -4994,7 +2910,7 @@ var ReplayError = class extends BitfabError {
 		this.testRunUrl = experimentUrl;
 	}
 };
-var DbBranchReplayError = class extends BitfabError {
+var DbBranchReplayError = class extends require_http.BitfabError {
 	constructor(code, message, originalTraceId, cause) {
 		super(message);
 		this.code = code;
@@ -5115,7 +3031,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
 		}
 		if (leaseError) throw new DbBranchReplayError(leaseError.code, leaseError.message, originalTraceId);
 		if (selectiveOptions !== void 0) {
-			if (serverItem.selectiveReplayPlan === void 0) throw new BitfabError("Server did not return a selective replay plan. Update the server or disable experimentalSelectiveReplay.");
+			if (serverItem.selectiveReplayPlan === void 0) throw new require_http.BitfabError("Server did not return a selective replay plan. Update the server or disable experimentalSelectiveReplay.");
 			selectiveReplay = new SelectiveReplayRuntime(serverItem.selectiveReplayPlan, selectiveOptions);
 		}
 		const span = await httpClient.getExternalSpan(originalSpanId, { view: "replay" });
@@ -5142,7 +3058,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
 				includeOutputs,
 				includeRootOutput: false
 			});
-			if (!treeResponse.root) throw new BitfabError(`Replay mock strategy "${mockStrategy}"${hasOverrides ? " with overrides" : ""} requires a span tree root for original span ${originalSpanId}.`);
+			if (!treeResponse.root) throw new require_http.BitfabError(`Replay mock strategy "${mockStrategy}"${hasOverrides ? " with overrides" : ""} requires a span tree root for original span ${originalSpanId}.`);
 			mockTree = buildMockTree(treeResponse.root);
 		} catch (error) {
 			if (mockStrategy !== "marked" || hasOverrides) throw error;
@@ -5182,7 +3098,7 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
 		};
 		try {
 			replayStarted = performance.now();
-			const maybePromise = runWithReplayContext({
+			const maybePromise = require_http.runWithReplayContext({
 				experimentId,
 				traceId: replayedTraceId,
 				inputSourceSpanId: span.id,
@@ -5250,13 +3166,13 @@ async function processItem(httpClient, serverItem, fn, experimentId, mockStrateg
 async function waitForReplayPersistence(httpClient, experimentId, replayedTraceIds, replayLabels = {}, warn = console.warn) {
 	if (!await httpClient.settleDeferredWork(REPLAY_PERSISTENCE_TIMEOUT_MS)) {
 		httpClient.takeTraceDeliveries(replayedTraceIds);
-		throw new BitfabError(`Replay could not settle deferred span work before the deadline, so the expected span counts are incomplete (experiment ${experimentId}).`);
+		throw new require_http.BitfabError(`Replay could not settle deferred span work before the deadline, so the expected span counts are incomplete (experiment ${experimentId}).`);
 	}
 	if (!httpClient.hasClosedDeliveries(replayedTraceIds)) {
 		httpClient.takeTraceDeliveries(replayedTraceIds);
 		return {};
 	}
-	const flushed = await flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
+	const flushed = await require_http.flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
 	const deliveries = httpClient.takeTraceDeliveries(replayedTraceIds);
 	const expectedSpanCounts = {};
 	const readBackTraceIds = {};
@@ -5312,15 +3228,15 @@ function warnJudgeAssertionsDeprecated(write = console.warn) {
 async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, registeredOverrides = []) {
 	if (options?.judgeAssertions !== void 0) warnJudgeAssertionsDeprecated();
 	if (options?.resume !== void 0) validateResume(options.resume, options);
-	else if (options?.force === true) throw new BitfabError("force only applies when resuming an experiment. Pass it together with resume.");
-	if (options?.experimentGroupName !== void 0 && options.experimentGroupId === void 0) throw new BitfabError("experimentGroupName only applies with experimentGroupId. Pass it together with experimentGroupId.");
+	else if (options?.force === true) throw new require_http.BitfabError("force only applies when resuming an experiment. Pass it together with resume.");
+	if (options?.experimentGroupName !== void 0 && options.experimentGroupId === void 0) throw new require_http.BitfabError("experimentGroupName only applies with experimentGroupId. Pass it together with experimentGroupId.");
 	if (options?.experimentalSelectiveReplay !== void 0) {
 		validateSelectiveReplayOptions(options.experimentalSelectiveReplay);
-		if ((options.mock ?? "marked") !== "marked" || normalizeMockOverrides(options.mockOverride).length > 0 || registeredOverrides.length > 0) throw new BitfabError("experimentalSelectiveReplay requires mock: 'marked' and cannot be combined with mock overrides.");
+		if ((options.mock ?? "marked") !== "marked" || normalizeMockOverrides(options.mockOverride).length > 0 || registeredOverrides.length > 0) throw new require_http.BitfabError("experimentalSelectiveReplay requires mock: 'marked' and cannot be combined with mock overrides.");
 	}
 	if (options?.traceIds !== void 0) {
-		if (options.traceIds.length === 0) throw new BitfabError("traceIds must contain at least one trace ID.");
-		if (options.traceIds.length > 100) throw new BitfabError(`traceIds supports at most 100 trace IDs per replay (got ${options.traceIds.length}).`);
+		if (options.traceIds.length === 0) throw new require_http.BitfabError("traceIds must contain at least one trace ID.");
+		if (options.traceIds.length > 100) throw new require_http.BitfabError(`traceIds supports at most 100 trace IDs per replay (got ${options.traceIds.length}).`);
 	}
 	const datasetIds = resolveDatasetIds(options);
 	if (options?.limit !== void 0 && options?.traceIds !== void 0) try {
@@ -5328,8 +3244,8 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
 	} catch {}
 	const requestedAttempts = resolveAttempts(options?.attempts);
 	const maxConcurrency = options?.maxConcurrency ?? 10;
-	if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) throw new BitfabError(`maxConcurrency must be a positive integer (got ${maxConcurrency}).`);
-	await replayContextReady;
+	if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) throw new require_http.BitfabError(`maxConcurrency must be a positive integer (got ${maxConcurrency}).`);
+	await require_http.replayContextReady;
 	let codeChangeDescription = options?.codeChangeDescription;
 	let codeChangeFiles = options?.codeChangeFiles;
 	if (codeChangeFiles === void 0) {
@@ -5387,7 +3303,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
 }
 function throwIfInterrupted(interrupted, items, experimentId, experimentUrl) {
 	if (!interrupted()) return;
-	const cause = new BitfabError(`Experiment ${experimentId} was interrupted, so it was not completed or graded. Resume it by passing { resume: "${experimentId}" } to replay, or with bitfab-replay --resume ${experimentId}.`, experimentUrl);
+	const cause = new require_http.BitfabError(`Experiment ${experimentId} was interrupted, so it was not completed or graded. Resume it by passing { resume: "${experimentId}" } to replay, or with bitfab-replay --resume ${experimentId}.`, experimentUrl);
 	throw new ReplayError(cause.message, items, experimentId, experimentUrl, cause);
 }
 async function runReplaySession(httpClient, fn, session, fullExperimentUrl, maxConcurrency, stopInterruptingOnSignal, markCompleteReturned, interrupted, options, registeredOverrides) {
@@ -5420,7 +3336,7 @@ async function runReplaySession(httpClient, fn, session, fullExperimentUrl, maxC
 				while (flushPending) {
 					flushPending = false;
 					await httpClient.settleDeferredWork(REPLAY_PERSISTENCE_TIMEOUT_MS);
-					await flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
+					await require_http.flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
 				}
 			} finally {
 				flushInFlight = null;
@@ -5545,7 +3461,7 @@ async function runReplaySession(httpClient, fn, session, fullExperimentUrl, maxC
 		}
 		if (completedCount > 0 && missing.length === completedCount) {
 			const serverCount = completeResult.traceCount !== void 0 ? ` The server persisted ${completeResult.traceCount} trace(s) for this run.` : "";
-			const cause = new BitfabError(`Replay completed but the server has no persisted trace for any of the ${completedCount} completed item(s) (experiment ${experimentId}).${serverCount} Trace uploads were awaited, so either the uploads failed (check for "Bitfab: Failed to create" errors above) or the replayed function is not wrapped with withSpan.`);
+			const cause = new require_http.BitfabError(`Replay completed but the server has no persisted trace for any of the ${completedCount} completed item(s) (experiment ${experimentId}).${serverCount} Trace uploads were awaited, so either the uploads failed (check for "Bitfab: Failed to create" errors above) or the replayed function is not wrapped with withSpan.`);
 			throw new ReplayError(cause.message, resultItems, experimentId, fullExperimentUrl, cause);
 		}
 		if (missing.length > 0) try {
@@ -5826,7 +3742,7 @@ function snapshotContext(context) {
 	return snapshot;
 }
 function unavailableCapability(path) {
-	return new BitfabError(`Rivet context capability "${path}" is unavailable during replay. Add first-class support for that public context path before replaying code that uses it.`, RIVET_DOCS_URL);
+	return new require_http.BitfabError(`Rivet context capability "${path}" is unavailable during replay. Add first-class support for that public context path before replaying code that uses it.`, RIVET_DOCS_URL);
 }
 function effectNode(traceFunctionKey, effect, mockSpanId) {
 	return {
@@ -5851,15 +3767,15 @@ function replayEffectStatus(replay, traceFunctionKey, effect, marked) {
 function assertReplayEffectAvailable(replay, traceFunctionKey, effect, marked) {
 	if (!replay) return;
 	const status = replayEffectStatus(replay, traceFunctionKey, effect, marked);
-	if (!status.willMock) throw new BitfabError(`Rivet effect "${effect}" has no live actor context during replay. Add "${effect}" to mockOnReplay or provide a replay override.`, RIVET_DOCS_URL);
-	if (!status.hasRecordedSpan && !status.hasOverride) throw new BitfabError(`No recorded Rivet effect "${effect}" exists at call ${status.callIndex + 1}; the live effect was not executed.`, RIVET_DOCS_URL);
+	if (!status.willMock) throw new require_http.BitfabError(`Rivet effect "${effect}" has no live actor context during replay. Add "${effect}" to mockOnReplay or provide a replay override.`, RIVET_DOCS_URL);
+	if (!status.hasRecordedSpan && !status.hasOverride) throw new require_http.BitfabError(`No recorded Rivet effect "${effect}" exists at call ${status.callIndex + 1}; the live effect was not executed.`, RIVET_DOCS_URL);
 }
 function fixtureName(traceFunctionKey) {
 	return `rivet:${traceFunctionKey}`;
 }
 function snapshotFromReplay(traceFunctionKey, replay) {
 	const fixture = replay.integrationFixtures?.get(fixtureName(traceFunctionKey));
-	if (!isRecord(fixture)) throw new BitfabError(`Trace "${traceFunctionKey}" has no Rivet context fixture. Capture a fresh trace with the Rivet integration before replaying it.`, RIVET_DOCS_URL);
+	if (!isRecord(fixture)) throw new require_http.BitfabError(`Trace "${traceFunctionKey}" has no Rivet context fixture. Capture a fresh trace with the Rivet integration before replaying it.`, RIVET_DOCS_URL);
 	return fixture;
 }
 var BitfabRivetIntegration = class {
@@ -5870,7 +3786,7 @@ var BitfabRivetIntegration = class {
 		this.markedEffects = new Set(options.mockOnReplay ?? []);
 	}
 	withContext(context, fn) {
-		if (!isRecord(context)) throw new BitfabError("Rivet withContext requires a context object");
+		if (!isRecord(context)) throw new require_http.BitfabError("Rivet withContext requires a context object");
 		return runWithRivetContext({
 			context,
 			fixtureContext: createIntegrationFixtureContext(fixtureName(this.traceFunctionKey), snapshotContext(context)),
@@ -5884,7 +3800,7 @@ var BitfabRivetIntegration = class {
 		};
 	}
 	getContext() {
-		const replay = getReplayContext();
+		const replay = require_http.getReplayContext();
 		if (replay) {
 			const existing = this.replayProxies.get(replay);
 			if (existing) return existing;
@@ -5893,13 +3809,13 @@ var BitfabRivetIntegration = class {
 			return proxy;
 		}
 		const binding = getRivetContextBinding();
-		if (!binding) throw new BitfabError("No Rivet context is bound. Call rivet.bind(handler) or rivet.withContext(context, callback) at the Rivet boundary.", RIVET_DOCS_URL);
+		if (!binding) throw new require_http.BitfabError("No Rivet context is bound. Call rivet.bind(handler) or rivet.withContext(context, callback) at the Rivet boundary.", RIVET_DOCS_URL);
 		this.runtime.recordRootFixture(binding.fixtureContext, binding.recordedRoots);
 		if (!binding.proxy) binding.proxy = this.createContextProxy(binding.context, binding);
 		return binding.proxy;
 	}
 	createContextProxy(target, binding) {
-		const replay = getReplayContext();
+		const replay = require_http.getReplayContext();
 		const dbProxy = this.createDbProxy(binding, replay);
 		const groupProxies = /* @__PURE__ */ new Map();
 		for (const group of Object.keys(RIVET_GROUP_EFFECT_METHODS)) if (group !== "db") groupProxies.set(group, this.createGroupProxy(group, binding, replay));
@@ -5963,7 +3879,7 @@ var BitfabRivetIntegration = class {
 	createEffect(effect, targetProvider, methodName, replay) {
 		const marked = this.markedEffects.has(effect);
 		const invoke = (...args) => {
-			assertReplayEffectAvailable(getReplayContext(), this.traceFunctionKey, effect, marked);
+			assertReplayEffectAvailable(require_http.getReplayContext(), this.traceFunctionKey, effect, marked);
 			const target = targetProvider();
 			const method = target ? readProperty(target, methodName) : void 0;
 			if (typeof method !== "function") throw unavailableCapability(effect);
@@ -5981,7 +3897,7 @@ var BitfabRivetIntegration = class {
 	}
 	createTransaction(binding, replay) {
 		return async (callback, options) => {
-			if (typeof callback !== "function") throw new BitfabError("Rivet db.transaction requires a callback");
+			if (typeof callback !== "function") throw new require_http.BitfabError("Rivet db.transaction requires a callback");
 			if (replay) return await callback(this.createMethodProxy(() => void 0, "db.transaction", ["execute"], replay));
 			const context = binding?.context;
 			const db = context ? readProperty(context, "db") : void 0;
@@ -6202,7 +4118,7 @@ var BitfabOpenAITracingProcessor = class {
 		this.startedSpans = /* @__PURE__ */ new Map();
 		this.endedTraces = /* @__PURE__ */ new Set();
 		this.ownsHttpClient = config._httpClient === void 0;
-		this.httpClient = config._httpClient ?? new HttpClient({
+		this.httpClient = config._httpClient ?? new require_http.HttpClient({
 			apiKey: config.apiKey,
 			serviceUrl: config.serviceUrl ?? "https://bitfab.ai",
 			timeout: config.timeout ?? 1e4
@@ -6348,7 +4264,7 @@ var BitfabOpenAITracingProcessor = class {
 		}
 	}
 	buildSpanPayload(serializedSpan, errors) {
-		serializedSpan.span_origin = makeSpanOrigin("openai-agents");
+		serializedSpan.span_origin = require_http.makeSpanOrigin("openai-agents");
 		const payload = {
 			id: randomUuid(),
 			type: "openai",
@@ -6550,7 +4466,7 @@ function markTracedFunction(target, traceFunctionKey, original) {
 }
 function resolveSpanExperimentId(options) {
 	const { experimentId, testRunId } = options;
-	if (experimentId !== void 0 && testRunId !== void 0 && experimentId !== testRunId) throw new BitfabError(`experimentId ("${experimentId}") and its deprecated alias testRunId ("${testRunId}") were both passed with different values. Pass only experimentId.`);
+	if (experimentId !== void 0 && testRunId !== void 0 && experimentId !== testRunId) throw new require_http.BitfabError(`experimentId ("${experimentId}") and its deprecated alias testRunId ("${testRunId}") were both passed with different values. Pass only experimentId.`);
 	return experimentId ?? testRunId;
 }
 const TRUNCATION_LIMIT_ORDER = ["max_depth", "max_captured_subtree_spans"];
@@ -6566,7 +4482,7 @@ function rootTraceFunctionKeyOfTrace(traceId, fallback) {
 	return activeTraceStates.get(traceId)?.traceFunctionKey ?? fallback;
 }
 function rootTraceFunctionKeyOf(payload) {
-	const captured = payload[ROOT_TRACE_FUNCTION_KEY_FIELD];
+	const captured = payload[require_http.ROOT_TRACE_FUNCTION_KEY_FIELD];
 	if (typeof captured === "string") return captured;
 	const traceId = payload.traceId;
 	const live = typeof traceId === "string" ? activeTraceStates.get(traceId)?.traceFunctionKey : void 0;
@@ -6676,13 +4592,10 @@ function wrapAsyncGenerator(source, spanStack, sendSpan) {
 let cachedCollectorClass;
 async function loadCollectorClass() {
 	if (cachedCollectorClass !== void 0) return cachedCollectorClass;
-	try {
-		cachedCollectorClass = (await importOptionalPeer(["@boundaryml", "baml"])).Collector;
-		return cachedCollectorClass;
-	} catch {
-		cachedCollectorClass = null;
-		return null;
-	}
+	const baml = await require_bamlPeer.loadBamlModule();
+	if (!baml) return null;
+	cachedCollectorClass = baml.Collector;
+	return cachedCollectorClass;
 }
 function extractPromptFromCollector(collector) {
 	try {
@@ -6732,7 +4645,7 @@ function extractContextFromCollector(collector) {
 	}
 }
 function isSpanType(value) {
-	return SPAN_TYPES.some((spanType) => spanType === value);
+	return require_http.SPAN_TYPES.some((spanType) => spanType === value);
 }
 const noOpSpan = {
 	id: "",
@@ -6769,7 +4682,7 @@ function getCurrentSpan() {
 	};
 }
 function getCurrentReplayBranch() {
-	const ctx = getReplayContext();
+	const ctx = require_http.getReplayContext();
 	if (!ctx?.dbBranchLease) return null;
 	const traceId = ctx.sourceBitfabTraceId ?? ctx.inputSourceTraceId;
 	if (!traceId) return null;
@@ -6808,7 +4721,7 @@ function getCurrentTrace() {
 		setMetadata(metadata) {
 			try {
 				if (typeof metadata !== "object" || metadata === null) return;
-				recordCallerTraceMetadata(traceId, metadata);
+				require_http.recordCallerTraceMetadata(traceId, metadata);
 			} catch {}
 		},
 		addContext(context) {
@@ -6885,12 +4798,12 @@ var Bitfab = class {
 		if (config.dbSnapshot) validateDbSnapshotConfig(config.dbSnapshot);
 		this.dbSnapshot = config.dbSnapshot;
 		startCommitRefResolution();
-		this.httpClient = new HttpClient({
+		this.httpClient = new require_http.HttpClient({
 			apiKey: () => this.resolveApiKey(),
 			serviceUrl: this.serviceUrl,
 			timeout: this.timeout
 		});
-		this.simulationPlan = new SimulationPlan({
+		this.simulationPlan = new require_http.SimulationPlan({
 			getSimulationPlan: () => this.httpClient.getSimulationPlan(),
 			canRead: () => this.canReadSimulationPlan()
 		}, config.simulationPlan ?? true);
@@ -6914,13 +4827,13 @@ var Bitfab = class {
 			if (args.length === 3) {
 				const propertyKey = args[1];
 				const descriptor = args[2];
-				if (!descriptor || typeof descriptor.value !== "function") throw new BitfabError("@bitfab.trace can only decorate methods");
+				if (!descriptor || typeof descriptor.value !== "function") throw new require_http.BitfabError("@bitfab.trace can only decorate methods");
 				descriptor.value = this.createAutoTraceRoot(traceFunctionKey, String(propertyKey), options, descriptor.value);
 				return;
 			}
 			const method = args[0];
 			const context = args[1];
-			if (typeof method !== "function" || context?.kind !== "method" || context.name === void 0) throw new BitfabError("@bitfab.trace can only decorate methods");
+			if (typeof method !== "function" || context?.kind !== "method" || context.name === void 0) throw new require_http.BitfabError("@bitfab.trace can only decorate methods");
 			return this.createAutoTraceRoot(traceFunctionKey, String(context.name), options, method);
 		};
 		return decorator;
@@ -6928,7 +4841,7 @@ var Bitfab = class {
 	withTrace(traceFunctionKey, optionsOrFn, maybeFn) {
 		const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
 		const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
-		if (!fn) throw new BitfabError("bitfab.withTrace requires a function");
+		if (!fn) throw new require_http.BitfabError("bitfab.withTrace requires a function");
 		const name = fn.name !== "" ? fn.name : traceFunctionKey;
 		return this.createAutoTraceRoot(traceFunctionKey, name, options, fn, AUTO_TRACE_NODE_FUNCTION_NAMES.get(fn) ?? fn.name.replace(/^bound /, ""));
 	}
@@ -6937,13 +4850,13 @@ var Bitfab = class {
 		const decorator = (...args) => {
 			if (args.length === 3) {
 				const descriptor = args[2];
-				if (!descriptor || typeof descriptor.value !== "function") throw new BitfabError("@bitfab.node can only decorate methods");
+				if (!descriptor || typeof descriptor.value !== "function") throw new require_http.BitfabError("@bitfab.node can only decorate methods");
 				descriptor.value = this.createAutoTraceNode(configuration, descriptor.value, String(args[1]));
 				return;
 			}
 			const method = args[0];
 			const context = args[1];
-			if (typeof method !== "function" || context?.kind !== "method") throw new BitfabError("@bitfab.node can only decorate methods");
+			if (typeof method !== "function" || context?.kind !== "method") throw new require_http.BitfabError("@bitfab.node can only decorate methods");
 			return this.createAutoTraceNode(configuration, method, String(context.name));
 		};
 		return decorator;
@@ -6951,15 +4864,15 @@ var Bitfab = class {
 	withNode(optionsOrFn, maybeFn, internalFunctionName) {
 		const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
 		const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
-		if (!fn) throw new BitfabError("bitfab.withNode requires a function");
+		if (!fn) throw new require_http.BitfabError("bitfab.withNode requires a function");
 		const configuration = this.resolveNodeConfiguration(options);
 		const functionName = internalFunctionName ?? fn.name;
-		if (functionName === "") throw new BitfabError("bitfab.withNode requires a named function so the subtree transform can bind its configuration to the correct call.");
+		if (functionName === "") throw new require_http.BitfabError("bitfab.withNode requires a named function so the subtree transform can bind its configuration to the correct call.");
 		return this.createAutoTraceNode(configuration, fn, functionName);
 	}
 	resolveNodeConfiguration(options) {
 		const capture = options.capture ?? true;
-		if (!capture && options.mockOnReplay === true) throw new BitfabError("bitfab.node({ capture: false }) cannot use mockOnReplay: true because an uncaptured node has no recorded output.");
+		if (!capture && options.mockOnReplay === true) throw new require_http.BitfabError("bitfab.node({ capture: false }) cannot use mockOnReplay: true because an uncaptured node has no recorded output.");
 		const experimentId = resolveSpanExperimentId(options);
 		return {
 			capture,
@@ -7103,7 +5016,7 @@ var Bitfab = class {
 				if (firstPlanRead !== void 0) return firstPlanRead.then(() => tracedRoot.apply(this, args));
 				return tracedRoot.apply(this, args);
 			}
-			const link = getReplayContext() || inSeedScope() ? void 0 : { traceFunctionKey };
+			const link = require_http.getReplayContext() || inSeedScope() ? void 0 : { traceFunctionKey };
 			const rootName = rootNameFor(this);
 			const spanDetails = { contexts: [] };
 			return require_autoTrace.invokeThroughAutoTraceEntries(enclosing, (entry, next) => entry.context.invokeNestedRoot(rootName, name, args, next, entry, link, spanDetails), () => {
@@ -7146,7 +5059,7 @@ var Bitfab = class {
 	resolveApiKey() {
 		const key = this.findApiKey(true);
 		if (key) return key;
-		if (this.strict) throw new BitfabError("Bitfab: no API key resolved. Set BITFAB_API_KEY or pass apiKey to new Bitfab(). If a script loads env with dotenv, load it before the module that constructs the client is imported (e.g. `node --env-file=.env script.ts`), or pass `apiKey: () => process.env.BITFAB_API_KEY`.");
+		if (this.strict) throw new require_http.BitfabError("Bitfab: no API key resolved. Set BITFAB_API_KEY or pass apiKey to new Bitfab(). If a script loads env with dotenv, load it before the module that constructs the client is imported (e.g. `node --env-file=.env script.ts`), or pass `apiKey: () => process.env.BITFAB_API_KEY`.");
 		if (this.isCaptureConfigured() && !this.apiKeyWarned) {
 			this.apiKeyWarned = true;
 			console.warn("Bitfab: apiKey is empty - tracing is disabled. Provide a valid API key to enable tracing.");
@@ -7162,11 +5075,11 @@ var Bitfab = class {
 		return this.resolveApiKey() !== void 0;
 	}
 	shouldRecord() {
-		if (!this.isCaptureConfigured() && !getReplayContext() && !inSeedScope()) return false;
+		if (!this.isCaptureConfigured() && !require_http.getReplayContext() && !inSeedScope()) return false;
 		return this.resolveApiKey() !== void 0;
 	}
 	canReadSimulationPlan() {
-		return ((this.captureConfiguredInCode ?? this.captureConfiguredFromEnv ?? readBooleanEnv(CAPTURE_ENABLED_ENV) ?? true) || getReplayContext() !== null || inSeedScope()) && this.findApiKey(true) !== void 0;
+		return ((this.captureConfiguredInCode ?? this.captureConfiguredFromEnv ?? readBooleanEnv(CAPTURE_ENABLED_ENV) ?? true) || require_http.getReplayContext() !== null || inSeedScope()) && this.findApiKey(true) !== void 0;
 	}
 	prepareFrameworkIntegration() {
 		if (this.isCaptureConfigured() && this.strict) this.resolveApiKey();
@@ -7176,8 +5089,8 @@ var Bitfab = class {
 	}
 	async fetchFunctionVersion(methodName) {
 		const result = await this.httpClient.lookupFunction(methodName);
-		if (result.id === null) throw new BitfabError(`Function "${methodName}" not found. Create it at: ${this.serviceUrl}/functions`, "/functions");
-		if (!result.prompt) throw new BitfabError(`Function "${methodName}" has no prompt configured. Add one at: ${this.serviceUrl}/functions/${result.id}`, `/functions/${result.id}`);
+		if (result.id === null) throw new require_http.BitfabError(`Function "${methodName}" not found. Create it at: ${this.serviceUrl}/functions`, "/functions");
+		if (!result.prompt) throw new require_http.BitfabError(`Function "${methodName}" has no prompt configured. Add one at: ${this.serviceUrl}/functions/${result.id}`, `/functions/${result.id}`);
 		return result;
 	}
 	async call(methodName, inputs = {}) {
@@ -7200,9 +5113,9 @@ var Bitfab = class {
 			});
 			return executionResult.result;
 		} catch (error) {
-			if (error instanceof BitfabError) throw error;
-			if (error instanceof Error) throw new BitfabError(error.message);
-			throw new BitfabError("Unknown error occurred during local execution");
+			if (error instanceof require_http.BitfabError) throw error;
+			if (error instanceof Error) throw new require_http.BitfabError(error.message);
+			throw new require_http.BitfabError("Unknown error occurred during local execution");
 		}
 	}
 	getOpenAiTracingProcessor() {
@@ -7318,14 +5231,15 @@ var Bitfab = class {
 			bamlClient = this.bamlClient;
 			method = methodOrClient;
 			options = maybeMethodOrOptions;
-			if (!bamlClient) throw new BitfabError("bamlClient is required for wrapBAML. Pass it in the constructor or as the first argument.");
+			if (!bamlClient) throw new require_http.BitfabError("bamlClient is required for wrapBAML. Pass it in the constructor or as the first argument.");
 		}
 		const methodName = method.name;
-		if (!methodName) throw new BitfabError("wrapBAML requires a named function (e.g., b.ClassifyText).");
+		if (!methodName) throw new require_http.BitfabError("wrapBAML requires a named function (e.g., b.ClassifyText).");
 		loadCollectorClass();
 		const wrappedFn = async (...args) => {
 			const CollectorClass = await loadCollectorClass();
 			if (!CollectorClass) {
+				require_autoTrace.warnOnce("wrapBAML-collector-unavailable", `@boundaryml/baml could not be loaded, so "${methodName}" and every other wrapBAML call run untraced: no prompt, model, or token usage is recorded and onCollector is not called. If @boundaryml/baml is installed and your app is bundled (Next.js with Turbopack, for example), add \`import "@bitfab/sdk/baml"\` once in your server code.`);
 				wrappedFn.collector = null;
 				return await bamlClient[methodName](...args);
 			}
@@ -7335,7 +5249,7 @@ var Bitfab = class {
 			try {
 				trackedClient = bamlClient.withOptions({ collector });
 				const method = trackedClient[methodName];
-				if (typeof method !== "function") throw new BitfabError("bamlClient.withOptions did not return the wrapped method");
+				if (typeof method !== "function") throw new require_http.BitfabError("bamlClient.withOptions did not return the wrapped method");
 				trackedMethod = method;
 			} catch {
 				require_autoTrace.warnOnce(`wrapBAML-setup:${methodName}`, `BAML tracing setup failed for "${methodName}" (incompatible bamlClient or BAML version); calling it untraced. The call still runs; no span is recorded.`);
@@ -7392,7 +5306,7 @@ var Bitfab = class {
 				try {
 					hasParent = getSpanStack().length > 0;
 				} catch (setupError) {
-					if (getReplayContext()) throw setupError;
+					if (require_http.getReplayContext()) throw setupError;
 					require_autoTrace.warnOnce(`withSpan-setup:${traceFunctionKey}`, `tracing setup failed for "${traceFunctionKey}"; running it untraced. The function still runs and returns normally; no span is recorded.`);
 					return fn.apply(this, args);
 				}
@@ -7405,7 +5319,7 @@ var Bitfab = class {
 			try {
 				const currentStack = getSpanStack();
 				const parentContext = currentStack[currentStack.length - 1];
-				const replayCtxForTraceId = parentContext ? null : getReplayContext();
+				const replayCtxForTraceId = parentContext ? null : require_http.getReplayContext();
 				const seedCtxForTraceId = parentContext ? null : getSeedContext();
 				const traceId = parentContext?.traceId ?? replayCtxForTraceId?.traceId ?? seedCtxForTraceId?.traceId ?? randomUuid();
 				const spanId = randomUuid();
@@ -7436,7 +5350,7 @@ var Bitfab = class {
 				newStack = [...currentStack, newContext];
 				const inputs = args;
 				const startedAt = nowIsoTimestamp();
-				const replayCtxAtStart = getReplayContext();
+				const replayCtxAtStart = require_http.getReplayContext();
 				const experimentId = replayCtxAtStart?.experimentId ?? optionExperimentId;
 				if (isRootSpan && !activeTraceStates.has(traceId)) {
 					const dbSnapshotRef = buildSnapshotRef(self.dbSnapshot, startedAt);
@@ -7481,7 +5395,7 @@ var Bitfab = class {
 					enclosingTrace: options.enclosingTrace
 				};
 				const sendSpan = async (params) => {
-					const replayCtx = getReplayContext();
+					const replayCtx = require_http.getReplayContext();
 					try {
 						const endedAt = nowIsoTimestamp();
 						if (!(activeTraceStates.get(traceId)?.dropped === true)) self.sendWrapperSpan({
@@ -7496,7 +5410,7 @@ var Bitfab = class {
 						if (isRootSpan) {
 							const traceState = activeTraceStates.get(traceId);
 							const truncated = truncationMetadata(traceState?.truncation);
-							if (truncated !== void 0) recordCallerTraceMetadata(traceId, truncated);
+							if (truncated !== void 0) require_http.recordCallerTraceMetadata(traceId, truncated);
 							self.sendTraceCompletion({
 								traceFunctionKey,
 								traceId,
@@ -7504,7 +5418,7 @@ var Bitfab = class {
 								endedAt,
 								sessionId: traceState?.sessionId,
 								name: traceState?.name,
-								metadata: callerTraceMetadata(traceId),
+								metadata: require_http.callerTraceMetadata(traceId),
 								contexts: traceState?.contexts ?? [],
 								experimentId: traceState?.experimentId,
 								inputSourceTraceId: traceState?.inputSourceTraceId,
@@ -7522,7 +5436,7 @@ var Bitfab = class {
 								} }
 							});
 							activeTraceStates.delete(traceId);
-							retireTraceMetadata(traceId);
+							require_http.retireTraceMetadata(traceId);
 						}
 					} catch {} finally {
 						self.httpClient.traceCompletion.end(traceId, spanId);
@@ -7568,7 +5482,7 @@ var Bitfab = class {
 					recordSpan(result);
 					return result;
 				};
-				const replayCtxForMock = getReplayContext();
+				const replayCtxForMock = require_http.getReplayContext();
 				if (replayCtxForMock?.selectiveReplay) {
 					const decision = replayCtxForMock.selectiveReplay.enter({
 						traceFunctionKey,
@@ -7608,7 +5522,7 @@ var Bitfab = class {
 						return output;
 					};
 					const emitMockAsync = (pending, mockSource) => {
-						if (!fnReturnsPromise) throw new BitfabError(`Cannot mock synchronous span "${traceFunctionKey}" with an asynchronously-resolved value (lazy recorded-output fetch or an async value function). Make the wrapped function async, or use mock: "all" so recorded outputs are fetched eagerly.`);
+						if (!fnReturnsPromise) throw new require_http.BitfabError(`Cannot mock synchronous span "${traceFunctionKey}" with an asynchronously-resolved value (lazy recorded-output fetch or an async value function). Make the wrapped function async, or use mock: "all" so recorded outputs are fetched eagerly.`);
 						return (async () => {
 							const output = await resolveMockOrAbort(() => pending);
 							sendSpan({
@@ -7622,7 +5536,7 @@ var Bitfab = class {
 					};
 					const resolveRecordedOutput = () => {
 						if (!(mockSpan?.output !== void 0 || mockSpan?.outputMeta !== void 0) && replayCtxForMock.fetchSpanOutput && mockSpan?.externalSpanId) return replayCtxForMock.fetchSpanOutput(mockSpan.externalSpanId);
-						if (!mockSpan) return Promise.reject(new BitfabError(`No recorded span to source output for "${traceFunctionKey}".`));
+						if (!mockSpan) return Promise.reject(new require_http.BitfabError(`No recorded span to source output for "${traceFunctionKey}".`));
 						let output = mockSpan.output;
 						if (mockSpan.outputMeta !== void 0 && mockSpan.outputMeta !== null) output = deserializeValue({
 							json: mockSpan.output,
@@ -7662,7 +5576,7 @@ var Bitfab = class {
 						};
 						const resolution = resolveOverrideFrom(0);
 						if (resolution instanceof Promise) {
-							if (!fnReturnsPromise) throw new BitfabError(`Cannot resolve an asynchronous mock override for synchronous span "${traceFunctionKey}". Make the wrapped function async or return NO_MOCK_OVERRIDE synchronously.`);
+							if (!fnReturnsPromise) throw new require_http.BitfabError(`Cannot resolve an asynchronous mock override for synchronous span "${traceFunctionKey}". Make the wrapped function async or return NO_MOCK_OVERRIDE synchronously.`);
 							return runWithSpanStack(newStack, async () => {
 								const resolved = await resolveMockOrAbort(() => resolution);
 								if (resolved.matched) {
@@ -7674,7 +5588,7 @@ var Bitfab = class {
 									});
 									return resolved.output;
 								}
-								if (shouldMockWithBaseStrategy && !mockSpan) throw new BitfabError(`Replay selected span "${traceFunctionKey}:${baseSpanParams.spanName}" for mocking, but recorded occurrence ${callIndex + 1} is unavailable. The real span was not executed.`);
+								if (shouldMockWithBaseStrategy && !mockSpan) throw new require_http.BitfabError(`Replay selected span "${traceFunctionKey}:${baseSpanParams.spanName}" for mocking, but recorded occurrence ${callIndex + 1} is unavailable. The real span was not executed.`);
 								if (shouldMockWithBaseStrategy) {
 									const output = await resolveMockOrAbort(() => resolveBaseOutput());
 									sendSpan({
@@ -7690,7 +5604,7 @@ var Bitfab = class {
 						}
 						if (resolution.matched) return emitMock(resolution.output, "override");
 					}
-					if (shouldMockWithBaseStrategy && !mockSpan) throw new BitfabError(`Replay selected span "${traceFunctionKey}:${baseSpanParams.spanName}" for mocking, but recorded occurrence ${callIndex + 1} is unavailable. The real span was not executed.`);
+					if (shouldMockWithBaseStrategy && !mockSpan) throw new require_http.BitfabError(`Replay selected span "${traceFunctionKey}:${baseSpanParams.spanName}" for mocking, but recorded occurrence ${callIndex + 1} is unavailable. The real span was not executed.`);
 					if (shouldMockWithBaseStrategy) {
 						const recorded = resolveBaseOutput();
 						if (recorded instanceof Promise) return emitMockAsync(recorded, "recorded");
@@ -7701,10 +5615,10 @@ var Bitfab = class {
 				if (startedSpan) self.httpClient.traceCompletion.abort(startedSpan.traceId, startedSpan.spanId);
 				if (registeredTraceId) {
 					activeTraceStates.delete(registeredTraceId);
-					retireTraceMetadata(registeredTraceId);
+					require_http.retireTraceMetadata(registeredTraceId);
 				}
-				if (setupError instanceof MixedTracingError) throw setupError;
-				if (getReplayContext() || inSeedScope()) throw setupError;
+				if (setupError instanceof require_http.MixedTracingError) throw setupError;
+				if (require_http.getReplayContext() || inSeedScope()) throw setupError;
 				require_autoTrace.warnOnce(`withSpan-setup:${traceFunctionKey}`, `tracing setup failed for "${traceFunctionKey}"; running it untraced. The function still runs and returns normally; no span is recorded.`);
 				return fn.apply(this, args);
 			}
@@ -7714,7 +5628,7 @@ var Bitfab = class {
 	}
 	span(traceFunctionKey, options = {}) {
 		return (originalMethod, context) => {
-			if (context.kind !== "method") throw new BitfabError(`Bitfab span decorators can only decorate methods; ${String(context.name)} is a ${context.kind}`);
+			if (context.kind !== "method") throw new require_http.BitfabError(`Bitfab span decorators can only decorate methods; ${String(context.name)} is a ${context.kind}`);
 			return this.withSpan(traceFunctionKey, options, originalMethod);
 		};
 	}
@@ -7743,18 +5657,18 @@ var Bitfab = class {
 	async getTraceSpan(traceId, lookup) {
 		validateTraceId(traceId);
 		const hasId = lookup.id !== void 0;
-		if (hasId === (lookup.name !== void 0 || lookup.type !== void 0)) throw new BitfabError("Provide id, or name and/or type");
+		if (hasId === (lookup.name !== void 0 || lookup.type !== void 0)) throw new require_http.BitfabError("Provide id, or name and/or type");
 		if (hasId) validateSpanId(lookup.id);
 		else {
-			if (lookup.name !== void 0 && lookup.name.length === 0) throw new BitfabError("name must be a non-empty string");
-			if (lookup.type !== void 0 && !isSpanType(lookup.type)) throw new BitfabError(`type must be one of ${SPAN_TYPES.join(", ")}`);
+			if (lookup.name !== void 0 && lookup.name.length === 0) throw new require_http.BitfabError("name must be a non-empty string");
+			if (lookup.type !== void 0 && !isSpanType(lookup.type)) throw new require_http.BitfabError(`type must be one of ${require_http.SPAN_TYPES.join(", ")}`);
 			const occurrence = lookup.occurrence ?? "last";
-			if (occurrence !== "first" && occurrence !== "last" && (!Number.isInteger(occurrence) || occurrence < 0)) throw new BitfabError("occurrence must be \"first\", \"last\", or a non-negative integer");
+			if (occurrence !== "first" && occurrence !== "last" && (!Number.isInteger(occurrence) || occurrence < 0)) throw new require_http.BitfabError("occurrence must be \"first\", \"last\", or a non-negative integer");
 		}
 		return this.httpClient.getTraceSpan(traceId, lookup);
 	}
 	async getSpan(spanId) {
-		if (typeof spanId !== "string" || spanId.trim().length === 0) throw new BitfabError("spanId must be a non-empty string");
+		if (typeof spanId !== "string" || spanId.trim().length === 0) throw new require_http.BitfabError("spanId must be a non-empty string");
 		return this.httpClient.getSpan(spanId);
 	}
 	getFunction(traceFunctionKey) {
@@ -7796,11 +5710,11 @@ var Bitfab = class {
 			completed: true,
 			...params.dropped && { dropped: true },
 			...params.sessionId && { sessionId: params.sessionId },
-			...params.experimentId !== void 0 && experimentIdWireFields(params.experimentId)
+			...params.experimentId !== void 0 && require_http.experimentIdWireFields(params.experimentId)
 		});
 	}
 	sendsSpanOnCompletion(context) {
-		return context.isRoot || context.declaredNode || isFrameworkInstrumentation(context.instrumentation) || !this.simulationPlan.contentOffNow(context.rootTraceFunctionKey, context.spanName);
+		return context.isRoot || context.declaredNode || require_http.isFrameworkInstrumentation(context.instrumentation) || !this.simulationPlan.contentOffNow(context.rootTraceFunctionKey, context.spanName);
 	}
 	nearestCapturedAncestorSpanIdOf(stack) {
 		for (let index = stack.length - 1; index >= 0; index -= 1) {
@@ -7810,7 +5724,7 @@ var Bitfab = class {
 		return null;
 	}
 	contentOffBySimulationPlan(params) {
-		if (params.rootTraceFunctionKey === void 0 || isFrameworkInstrumentation(params.instrumentation)) return false;
+		if (params.rootTraceFunctionKey === void 0 || require_http.isFrameworkInstrumentation(params.instrumentation)) return false;
 		return this.simulationPlan.contentOffNow(params.rootTraceFunctionKey, params.spanName) || params.parentSpanId !== null && this.simulationPlan.unavailableNow();
 	}
 	sendWrapperSpan(params) {
@@ -7823,7 +5737,7 @@ var Bitfab = class {
 			trace_id: params.traceId,
 			started_at: params.startedAt,
 			ended_at: params.endedAt,
-			span_origin: makeSpanOrigin(params.instrumentation),
+			span_origin: require_http.makeSpanOrigin(params.instrumentation),
 			span_data: {
 				name: params.spanName,
 				...params.replayReusable !== void 0 && { replay_reusable: params.replayReusable },
@@ -7878,7 +5792,7 @@ var Bitfab = class {
 			...params.rootTraceFunctionKey !== void 0 && { ["rootTraceFunctionKey"]: params.rootTraceFunctionKey },
 			...params.declaredNode === true && { ["declaredNode"]: true },
 			rawSpan: externalSpan,
-			...params.experimentId !== void 0 && experimentIdWireFields(params.experimentId),
+			...params.experimentId !== void 0 && require_http.experimentIdWireFields(params.experimentId),
 			...params.mocked && { mocked: true },
 			...params.mockTarget && { mockTarget: params.mockTarget },
 			...params.mockSource && { mockSource: params.mockSource }
@@ -7888,7 +5802,7 @@ var Bitfab = class {
 		let override;
 		if (typeof overrideOrResolverOrMatch === "string") {
 			const keyedOverride = values[0];
-			if (values.length !== 1 || keyedOverride === void 0) throw new BitfabError("registerMockOverride(traceFunctionKey, override) requires a resolver function or { match, value } override.");
+			if (values.length !== 1 || keyedOverride === void 0) throw new require_http.BitfabError("registerMockOverride(traceFunctionKey, override) requires a resolver function or { match, value } override.");
 			if (typeof keyedOverride === "function") override = {
 				match: (node) => node.traceFunctionKey === overrideOrResolverOrMatch,
 				value: keyedOverride
@@ -7897,7 +5811,7 @@ var Bitfab = class {
 				match: (node) => node.traceFunctionKey === overrideOrResolverOrMatch && keyedOverride.match(node),
 				value: keyedOverride.value
 			};
-			else throw new BitfabError("registerMockOverride(traceFunctionKey, override) requires a resolver function or { match, value } override.");
+			else throw new require_http.BitfabError("registerMockOverride(traceFunctionKey, override) requires a resolver function or { match, value } override.");
 		} else if (typeof overrideOrResolverOrMatch !== "function") override = overrideOrResolverOrMatch;
 		else if (values.length === 0) override = {
 			match: () => true,
@@ -7919,10 +5833,10 @@ var Bitfab = class {
 	seedTraceFromCase(traceFunctionKey, options) {
 		const { input } = options;
 		const fn = options.fn?._bitfabWrappedFn ?? options.fn;
-		if (fn && input.length < fn.length) throw new BitfabError(`Seeded case supplies ${input.length} argument(s) but ${fn.name === "" ? "the function" : fn.name} requires ${fn.length}. Fix the case, or omit fn to seed it anyway.`);
+		if (fn && input.length < fn.length) throw new require_http.BitfabError(`Seeded case supplies ${input.length} argument(s) but ${fn.name === "" ? "the function" : fn.name} requires ${fn.length}. Fix the case, or omit fn to seed it anyway.`);
 		const traceId = randomUuid();
 		const startedAt = nowIsoTimestamp();
-		if (options.metadata !== void 0) recordCallerTraceMetadata(traceId, options.metadata);
+		if (options.metadata !== void 0) require_http.recordCallerTraceMetadata(traceId, options.metadata);
 		activeTraceStates.set(traceId, {
 			traceId,
 			traceFunctionKey,
@@ -7955,13 +5869,13 @@ var Bitfab = class {
 				endedAt: startedAt,
 				sessionId: options.sessionId,
 				name: options.name,
-				metadata: callerTraceMetadata(traceId),
+				metadata: require_http.callerTraceMetadata(traceId),
 				contexts: [],
 				ingestionType: "seeded"
 			});
 		} finally {
 			activeTraceStates.delete(traceId);
-			retireTraceMetadata(traceId);
+			require_http.retireTraceMetadata(traceId);
 		}
 		return traceId;
 	}
@@ -7975,10 +5889,10 @@ var Bitfab = class {
 				surface: "neutral"
 			};
 			target = this.withSpan(traceFunctionKey, seedRootOptions, fn);
-		} else if (wrappedKey !== traceFunctionKey) throw new BitfabError(`Function is wrapped with trace function key '${wrappedKey}' but seedTrace was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to seed it under the explicit key.`);
+		} else if (wrappedKey !== traceFunctionKey) throw new require_http.BitfabError(`Function is wrapped with trace function key '${wrappedKey}' but seedTrace was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to seed it under the explicit key.`);
 		await seedContextReady;
 		const traceId = randomUuid();
-		if (options?.metadata !== void 0) recordCallerTraceMetadata(traceId, options.metadata);
+		if (options?.metadata !== void 0) require_http.recordCallerTraceMetadata(traceId, options.metadata);
 		activeTraceStates.set(traceId, {
 			traceId,
 			traceFunctionKey,
@@ -7994,19 +5908,19 @@ var Bitfab = class {
 			await runWithSeedContext({ traceId }, async () => target(...args));
 		} finally {
 			try {
-				const { flushTraces } = await Promise.resolve().then(() => http_exports);
+				const { flushTraces } = await Promise.resolve().then(() => require("./http-DX-fpUSu.cjs")).then((n) => n.http_exports);
 				await flushTraces(3e4);
 			} finally {
 				unrecorded = activeTraceStates.delete(traceId);
-				retireTraceMetadata(traceId);
+				require_http.retireTraceMetadata(traceId);
 			}
 		}
-		if (unrecorded) throw new BitfabError(`seedTrace recorded nothing for '${traceFunctionKey}': the call finished without a root span. Check that an API key resolves (BITFAB_API_KEY or apiKey), and that fn is a regular or async function rather than a generator.`);
+		if (unrecorded) throw new require_http.BitfabError(`seedTrace recorded nothing for '${traceFunctionKey}': the call finished without a root span. Check that an API key resolves (BITFAB_API_KEY or apiKey), and that fn is a regular or async function rather than a generator.`);
 		return traceId;
 	}
 	async reseedTrace(traceFunctionKey, fn, options) {
 		const source = await this.httpClient.getReseedSource(options.traceId);
-		if (source.traceFunctionKey !== traceFunctionKey) throw new BitfabError(`Trace ${options.traceId} belongs to '${source.traceFunctionKey}', not '${traceFunctionKey}'.`);
+		if (source.traceFunctionKey !== traceFunctionKey) throw new require_http.BitfabError(`Trace ${options.traceId} belongs to '${source.traceFunctionKey}', not '${traceFunctionKey}'.`);
 		const args = deserializeInputs({
 			input: source.input,
 			input_meta: source.inputMeta
@@ -8033,7 +5947,7 @@ var Bitfab = class {
 				surface: "neutral"
 			};
 			replayFn = this.withSpan(traceFunctionKey, replayRootOptions, fn);
-		} else if (wrappedKey !== traceFunctionKey) throw new BitfabError(`Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`);
+		} else if (wrappedKey !== traceFunctionKey) throw new require_http.BitfabError(`Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`);
 		const { replay: doReplay } = await Promise.resolve().then(() => replay_exports);
 		return doReplay(this.httpClient, this.serviceUrl, traceFunctionKey, replayFn, options, this.mockOverrides);
 	}
@@ -8053,7 +5967,7 @@ var BitfabFunction = class {
 	}
 	withTrace(optionsOrFn, maybeFn) {
 		if (typeof optionsOrFn === "function") return this.client.withTrace(this.traceFunctionKey, optionsOrFn);
-		if (!maybeFn) throw new BitfabError("BitfabFunction.withTrace requires a function");
+		if (!maybeFn) throw new require_http.BitfabError("BitfabFunction.withTrace requires a function");
 		return this.client.withTrace(this.traceFunctionKey, optionsOrFn, maybeFn);
 	}
 	trace(options = {}) {
@@ -8141,14 +6055,14 @@ const REGISTRATION_FIELDS = /* @__PURE__ */ new Set([
 ]);
 function validateReplayRegistry(registry) {
 	for (const [pipeline, registration] of Object.entries(registry)) {
-		if (typeof registration !== "object" || registration === null) throw new BitfabError(`Replay registry entry '${pipeline}' must be an object with client and fn.`);
+		if (typeof registration !== "object" || registration === null) throw new require_http.BitfabError(`Replay registry entry '${pipeline}' must be an object with client and fn.`);
 		const unknownFields = Object.keys(registration).filter((field) => !REGISTRATION_FIELDS.has(field));
 		if (unknownFields.length > 0) require_autoTrace.warnOnce(`replay-registry-unknown-fields:${pipeline}:${unknownFields.join(",")}`, `Replay registry entry '${pipeline}' has unknown field(s): ${unknownFields.join(", ")}. They are ignored. An entry takes client, fn, traceFunctionKey, options, and optionsFactory. Put replay options such as adaptInputs, mock, and mockOverride inside options. A later SDK release will reject unknown fields.`);
 	}
 }
 async function reseedFromRegistry(registry, pipeline, traceIds) {
 	const registration = registry[pipeline];
-	if (registration === void 0) throw new BitfabError(`Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`);
+	if (registration === void 0) throw new require_http.BitfabError(`Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`);
 	const traceFunctionKey = resolveTraceFunctionKey(registration);
 	const reseeded = [];
 	for (const traceId of traceIds) reseeded.push(await registration.client.reseedTrace(traceFunctionKey, registration.fn, { traceId }));
@@ -8160,7 +6074,7 @@ async function reseedFromRegistry(registry, pipeline, traceIds) {
 }
 async function seedFromRegistry(registry, pipeline, cases, options = {}) {
 	const registration = registry[pipeline];
-	if (registration === void 0) throw new BitfabError(`Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`);
+	if (registration === void 0) throw new require_http.BitfabError(`Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`);
 	const traceFunctionKey = resolveTraceFunctionKey(registration);
 	if (options.run === true) {
 		const traceIds = [];
@@ -8182,7 +6096,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
 		metadata: seedCase.metadata,
 		sessionId: seedCase.sessionId
 	}));
-	const { flushTraces } = await Promise.resolve().then(() => http_exports);
+	const { flushTraces } = await Promise.resolve().then(() => require("./http-DX-fpUSu.cjs")).then((n) => n.http_exports);
 	await flushTraces(3e4);
 	return {
 		pipeline,
@@ -8193,7 +6107,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
 function resolveTraceFunctionKey(registration) {
 	const wrappedKey = registration.fn._bitfabTraceFunctionKey;
 	const key = registration.traceFunctionKey ?? wrappedKey;
-	if (key === void 0) throw new BitfabError("Replay registry entry uses a plain function. Set traceFunctionKey to the key its production handler records.");
+	if (key === void 0) throw new require_http.BitfabError("Replay registry entry uses a plain function. Set traceFunctionKey to the key its production handler records.");
 	return key;
 }
 //#endregion
@@ -8233,12 +6147,6 @@ Object.defineProperty(exports, "BitfabClaudeAgentHandler", {
 		return BitfabClaudeAgentHandler;
 	}
 });
-Object.defineProperty(exports, "BitfabError", {
-	enumerable: true,
-	get: function() {
-		return BitfabError;
-	}
-});
 Object.defineProperty(exports, "BitfabFunction", {
 	enumerable: true,
 	get: function() {
@@ -8329,24 +6237,12 @@ Object.defineProperty(exports, "GradersClient", {
 		return GradersClient;
 	}
 });
-Object.defineProperty(exports, "HttpClient", {
-	enumerable: true,
-	get: function() {
-		return HttpClient;
-	}
-});
 Object.defineProperty(exports, "LabelsClient", {
 	enumerable: true,
 	get: function() {
 		return LabelsClient;
 	}
 });
-Object.defineProperty(exports, "MixedTracingError", {
-	enumerable: true,
-	get: function() {
-		return MixedTracingError;
-	}
-});
 Object.defineProperty(exports, "NO_MOCK_OVERRIDE", {
 	enumerable: true,
 	get: function() {
@@ -8383,12 +6279,6 @@ Object.defineProperty(exports, "TracesClient", {
 		return TracesClient;
 	}
 });
-Object.defineProperty(exports, "__version__", {
-	enumerable: true,
-	get: function() {
-		return __version__;
-	}
-});
 Object.defineProperty(exports, "defineReplayRegistry", {
 	enumerable: true,
 	get: function() {
@@ -8401,12 +6291,6 @@ Object.defineProperty(exports, "finalizers", {
 		return finalizers;
 	}
 });
-Object.defineProperty(exports, "flushTraces", {
-	enumerable: true,
-	get: function() {
-		return flushTraces;
-	}
-});
 Object.defineProperty(exports, "getCurrentReplayBranch", {
 	enumerable: true,
 	get: function() {
@@ -8450,4 +6334,4 @@ Object.defineProperty(exports, "serializeReplayResult", {
 	}
 });
 
-//# sourceMappingURL=src-DgkDt32g.cjs.map
+//# sourceMappingURL=src-BWZx-C1S.cjs.map