@bitfab/sdk 0.65.4 → 0.65.5

package/dist/http-CG1Irqxx.js

@@ -0,0 +1,2154 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { f as warn, g as runWithCaptureSuppressed, p as warnOnce, v as asyncStorageReady, y as createAsyncLocalStorage } from "./autoTrace-CZu0BXhG.js";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { ExportResultCode } from "@opentelemetry/core";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { AlwaysOnSampler, BasicTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+//#region src/version.generated.ts
+const __version__ = "0.65.5";
+const __packageName__ = "@bitfab/sdk";
+//#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(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(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 = 3e4;
+const GIT_MAX_BUFFER = 1048576;
+const DISABLE_ENV = "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,
+		maxBuffer: GIT_MAX_BUFFER,
+		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]) 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 = asyncStorageReady.then(() => {
+	const shared = globalThis;
+	const existing = shared[REPLAY_CONTEXT_STORAGE_SYMBOL];
+	if (existing) {
+		replayContextStorage = existing;
+		return;
+	}
+	const created = 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 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
+	};
+	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 {
+				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$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function spanOriginOf(payload) {
+	const rawSpan = payload.rawSpan;
+	if (!isRecord$1(rawSpan)) return;
+	const origin = rawSpan.span_origin;
+	if (!isRecord$1(origin) || !isRecord$1(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(value) {
+	return typeof value === "object" && value !== null;
+}
+function rawSpanOf(payload) {
+	return isRecord(payload.rawSpan) ? payload.rawSpan : void 0;
+}
+function spanDataOf(payload) {
+	const spanData = rawSpanOf(payload)?.span_data;
+	return isRecord(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(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.loaded = new Promise((resolve) => {
+			this.resolveLoaded = resolve;
+		});
+		this.firstReadEnded = new Promise((resolve) => {
+			this.resolveFirstReadEnded = resolve;
+		});
+	}
+	disabled() {
+		return !this.enabled || simulationPlanEnvDisabled();
+	}
+	refresh() {
+		if (this.stopped || this.disabled()) return;
+		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;
+		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.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()) return;
+		return this.loaded;
+	}
+	send(payload, traceFunctionKey, submit, drop) {
+		this.refresh();
+		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.refresh();
+		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) 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?.();
+			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) 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);
+	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(name);
+	if (raw === void 0) return fallback;
+	const value = Number(raw);
+	if (Number.isInteger(value) && value > 0 && value <= max) return value;
+	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(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 ? ExportResultCode.SUCCESS : ExportResultCode.FAILED });
+		}, (error) => {
+			resultCallback({
+				code: 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(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 !== ExportResultCode.SUCCESS) this.failedExports += 1;
+				resultCallback(result);
+			});
+		} catch (error) {
+			this.failedExports += 1;
+			resultCallback({
+				code: 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();
+	}
+};
+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 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 BasicTracerProvider({
+			sampler: new AlwaysOnSampler(),
+			resource: 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);
+	}
+	submit(operation, payload, meta = {}) {
+		if (this.closed) {
+			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) 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: SpanStatusCode.ERROR });
+			endSpan(span, meta.endTime);
+		} catch (error) {
+			logError("failed to queue an OpenTelemetry span", error);
+		}
+	}
+	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 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;
+	}
+};
+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);
+}
+//#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) {
+	warnOnce("external-span-dropped", `a span was dropped because the send step failed: ${describeError(error)}`);
+}
+function warnDroppedExternalTrace(error) {
+	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) {
+			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
+	};
+}
+//#endregion
+export { readEnv as C, MixedTracingError as S, getReplayContext as _, http_exports as a, gitRunner as b, recordCallerTraceMetadata as c, DECLARED_NODE_FIELD as d, ROOT_TRACE_FUNCTION_KEY_FIELD as f, MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES as g, makeSpanOrigin as h, flushTraces as i, retireTraceMetadata as l, isFrameworkInstrumentation as m, SPAN_TYPES as n, unrefTimer as o, SimulationPlan as p, experimentIdWireFields as r, callerTraceMetadata as s, HttpClient as t, CONTENT_OFF_KEY as u, replayContextReady as v, __version__ as w, BitfabError as x, runWithReplayContext as y };
+
+//# sourceMappingURL=http-CG1Irqxx.js.map