@calmlens/sdk 0.11.0 → 0.12.0

package/cjs/index.js

@@ -1,817 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_CalmLensWebhooks = require("./CalmLensWebhooks-CH2PaPs0.js");
-//#endregion
-//#region src/client/CalmLensVersion.ts
-/** This SDK's version, from its package.json. */
-const SDK_VERSION = "0.11.0";
-const runtimeName = () => {
-	const runtime = globalThis;
-	if (runtime.Bun?.version) return `bun/${runtime.Bun.version}`;
-	if (runtime.Deno?.version?.deno) return `deno/${runtime.Deno.version.deno}`;
-	if (runtime.navigator?.userAgent === "Cloudflare-Workers") return "workerd";
-	if (runtime.process?.versions?.node) return `node/${runtime.process.versions.node}`;
-	return "unknown";
-};
-/** The `User-Agent` the SDK sends from server runtimes, e.g. `calmlens-js/0.10.0 (node/22.12.0)`. */
-const getUserAgent = () => `calmlens-js/${SDK_VERSION} (${runtimeName()})`;
-/** True in a web page, where API keys would be visible to every visitor. */
-const isBrowserRuntime = () => typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
-//#endregion
-//#region src/client/CalmLensTransport.ts
-/** Retry delays grow from this base, doubling per attempt, with jitter. */
-const RETRY_BASE_DELAY_MS = 500;
-const RETRY_MAX_DELAY_MS = 8e3;
-/** A `Retry-After` longer than this is returned to the caller instead of waited out. */
-const RETRY_AFTER_MAX_MS = 6e4;
-const RETRYABLE_STATUSES = /* @__PURE__ */ new Set([
-	429,
-	502,
-	503,
-	504
-]);
-const timeoutReason = () => {
-	const reason = /* @__PURE__ */ new Error("The operation timed out.");
-	reason.name = "TimeoutError";
-	return reason;
-};
-/**
-* Links the callers' signals and a per-attempt deadline. `AbortSignal.any` holds its sources
-* weakly, so a long-lived caller signal doesn't collect a listener per streamed response;
-* runtimes without it get explicit listeners that `release` removes.
-*/
-const createAttemptSignal = (signals, timeoutMs) => {
-	const callers = signals.filter((signal) => signal !== void 0);
-	const deadline = new AbortController();
-	let timedOut = false;
-	let signal;
-	let onAbort;
-	if (typeof AbortSignal.any === "function") signal = AbortSignal.any([...callers, deadline.signal]);
-	else {
-		const controller = new AbortController();
-		signal = controller.signal;
-		onAbort = (event) => controller.abort(event.target.reason);
-		for (const source of [...callers, deadline.signal]) if (source.aborted) controller.abort(source.reason);
-		else source.addEventListener("abort", onAbort, { once: true });
-	}
-	let timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
-		timedOut = true;
-		deadline.abort(timeoutReason());
-	}, timeoutMs);
-	return {
-		signal,
-		isTimedOut: () => timedOut,
-		isCancelled: () => callers.some((caller) => caller.aborted),
-		clearDeadline: () => {
-			if (timer !== void 0) clearTimeout(timer);
-			timer = void 0;
-		},
-		release: () => {
-			if (timer !== void 0) clearTimeout(timer);
-			timer = void 0;
-			if (onAbort) for (const caller of callers) caller.removeEventListener("abort", onAbort);
-		}
-	};
-};
-/**
-* A redirect the SDK must not follow: it would send the API key to another origin. Browsers report
-* a manual redirect as an opaque response; other runtimes return the 3xx with its Location.
-*/
-const isRedirect = (response) => response.type === "opaqueredirect" || response.status >= 300 && response.status < 400 && response.headers.has("location");
-/** Turns anything thrown while sending or reading a request into a `CalmLensError`. */
-const toFailure = (cause, attempt) => {
-	if (require_CalmLensWebhooks.CalmLensError.isCalmLensError(cause)) return cause;
-	if (attempt.isCancelled()) return new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.CANCELLED, {
-		message: "Request cancelled",
-		cause
-	});
-	if (attempt.isTimedOut()) return new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.TIMEOUT, {
-		message: "Request timed out",
-		cause
-	});
-	return new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.TRANSPORT_ERROR, {
-		message: "Request failed",
-		cause
-	});
-};
-const sleep = (ms, signal) => new Promise((resolve, reject) => {
-	if (signal?.aborted) {
-		reject(new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.CANCELLED, { message: "Request cancelled" }));
-		return;
-	}
-	const onAbort = () => {
-		clearTimeout(timer);
-		reject(new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.CANCELLED, { message: "Request cancelled" }));
-	};
-	const timer = setTimeout(() => {
-		signal?.removeEventListener("abort", onAbort);
-		resolve();
-	}, ms);
-	signal?.addEventListener("abort", onAbort, { once: true });
-});
-/** Exponential backoff with jitter: half the delay is fixed, the other half random. */
-const getRetryDelayMs = (attempt, random = Math.random) => {
-	const delay = Math.min(RETRY_MAX_DELAY_MS, RETRY_BASE_DELAY_MS * 2 ** attempt);
-	return Math.round(delay / 2 + random() * (delay / 2));
-};
-/** Parses `Retry-After` as seconds or an HTTP date, in seconds from `now`. */
-const parseRetryAfter = (value, now = Date.now()) => {
-	if (!value) return void 0;
-	const trimmed = value.trim();
-	if (/^\d+$/.test(trimmed)) return Number(trimmed);
-	const date = Date.parse(trimmed);
-	if (Number.isNaN(date)) return void 0;
-	return Math.max(0, Math.ceil((date - now) / 1e3));
-};
-/** Bodies that can be sent again unchanged. Streams are consumed by the first attempt. */
-const isReplayableBody = (body) => body === void 0 || body === null || typeof body === "string" || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body) || body instanceof URLSearchParams;
-const isApiErrorPayload = (value) => !!value && typeof value === "object" && typeof value.code === "string";
-/** Reads at most `limit` bytes of a body, failing with `sdk/response-too-large` beyond that. */
-const readBody = async (response, limit) => {
-	const declared = Number(response.headers.get("content-length"));
-	const tooLarge = () => new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.RESPONSE_TOO_LARGE, {
-		message: `Response body exceeds ${limit} bytes`,
-		status: response.status,
-		requestId: response.headers.get("x-request-id") ?? void 0,
-		headers: response.headers
-	});
-	if (Number.isFinite(declared) && declared > limit) {
-		await response.body?.cancel().catch(() => {});
-		throw tooLarge();
-	}
-	if (!response.body) return /* @__PURE__ */ new Uint8Array(0);
-	const reader = response.body.getReader();
-	const chunks = [];
-	let total = 0;
-	for (;;) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		total += value.byteLength;
-		if (total > limit) {
-			await reader.cancel().catch(() => {});
-			throw tooLarge();
-		}
-		chunks.push(value);
-	}
-	const bytes = new Uint8Array(total);
-	let offset = 0;
-	for (const chunk of chunks) {
-		bytes.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return bytes;
-};
-const responseInfo = (response) => ({
-	status: response.status,
-	requestId: response.headers.get("x-request-id") ?? void 0,
-	headers: response.headers,
-	retryAfter: parseRetryAfter(response.headers.get("retry-after"))
-});
-/** The `CalmLensError` for a non-2xx response whose body has been read. */
-const toHttpError = (response, bytes) => {
-	let data;
-	try {
-		data = JSON.parse(new TextDecoder().decode(bytes));
-	} catch {}
-	if (isApiErrorPayload(data)) {
-		const { code, message, details, traceId } = data;
-		return new require_CalmLensWebhooks.CalmLensError(code, {
-			message: message ?? code,
-			...responseInfo(response),
-			details: details || traceId ? {
-				...details,
-				...traceId ? { traceId } : {}
-			} : void 0
-		});
-	}
-	return new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.HTTP_ERROR, {
-		message: `HTTP ${response.status}`,
-		...responseInfo(response)
-	});
-};
-/** Sends requests with the client's credentials, deadlines, retries and response limits. */
-var CalmLensTransport = class {
-	constructor(settings) {
-		this.settings = settings;
-	}
-	headersFor(request) {
-		const headers = new Headers(request.init?.headers);
-		for (const [name, value] of Object.entries(request.headers ?? {})) headers.set(name, value);
-		if (!headers.has("accept") && request.deadline === "body") headers.set("accept", "application/json");
-		headers.set("x-api-key", this.settings.apiKey);
-		if (!isBrowserRuntime()) headers.set("user-agent", getUserAgent());
-		if (request.idempotencyKey) headers.set("idempotency-key", request.idempotencyKey);
-		return Object.fromEntries(headers.entries());
-	}
-	canRetry(request) {
-		return this.settings.maxRetries > 0 && (request.method === "GET" || request.method === "HEAD" || !!request.idempotencyKey) && isReplayableBody(request.body);
-	}
-	/**
-	* Sends a request and returns the response, retrying transport failures, 429, 502–504 and
-	* `idempotency/request-in-progress` when the request is safe to repeat. Non-2xx responses
-	* throw unless `allowHttpErrors` is set. Call `release` once the body has been read.
-	*/
-	async send(request, { allowHttpErrors = false } = {}) {
-		const fetchImpl = request.fetch ?? this.settings.fetch;
-		const retryable = this.canRetry(request);
-		const headers = this.headersFor(request);
-		for (let attemptNumber = 0;; attemptNumber++) {
-			const canRetryAgain = retryable && attemptNumber < this.settings.maxRetries;
-			const attempt = createAttemptSignal([this.settings.signal, request.init?.signal ?? void 0], request.timeoutMs);
-			let response;
-			try {
-				attempt.signal.throwIfAborted();
-				response = await fetchImpl(request.url, {
-					...request.init,
-					method: request.method,
-					headers,
-					body: request.body,
-					redirect: "manual",
-					signal: attempt.signal,
-					duplex: "half"
-				});
-				if (isRedirect(response)) {
-					await response.body?.cancel().catch(() => {});
-					throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.TRANSPORT_ERROR, { message: `Unexpected redirect (HTTP ${response.status})` });
-				}
-			} catch (cause) {
-				attempt.release();
-				const failure = toFailure(cause, attempt);
-				if (canRetryAgain && failure.code === require_CalmLensWebhooks.SDK_ERROR_CODES.TRANSPORT_ERROR) {
-					await sleep(getRetryDelayMs(attemptNumber), this.settings.signal);
-					continue;
-				}
-				throw failure;
-			}
-			if (request.deadline === "headers") attempt.clearDeadline();
-			if (response.ok) return {
-				response,
-				attempt
-			};
-			if (allowHttpErrors) {
-				const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
-				const delayMs = retryAfter !== void 0 ? retryAfter * 1e3 : getRetryDelayMs(attemptNumber);
-				if (!canRetryAgain || !RETRYABLE_STATUSES.has(response.status) || delayMs > RETRY_AFTER_MAX_MS) return {
-					response,
-					attempt
-				};
-				attempt.release();
-				await response.body?.cancel().catch(() => {});
-				await sleep(delayMs, this.settings.signal);
-				continue;
-			}
-			let error;
-			try {
-				error = toHttpError(response, await readBody(response, this.settings.maxResponseBytes));
-			} catch (cause) {
-				error = toFailure(cause, attempt);
-			} finally {
-				attempt.release();
-			}
-			const retryDelayMs = error.retryAfter !== void 0 ? error.retryAfter * 1e3 : getRetryDelayMs(attemptNumber);
-			if (canRetryAgain && retryDelayMs <= RETRY_AFTER_MAX_MS && (error.status !== void 0 && RETRYABLE_STATUSES.has(error.status) || error.code === require_CalmLensWebhooks.API_ERROR_CODES.IDEMPOTENT_REQUEST_IN_PROGRESS)) {
-				await sleep(retryDelayMs, this.settings.signal);
-				continue;
-			}
-			throw error;
-		}
-	}
-	/** Sends a request and parses its JSON response body. */
-	async json(request) {
-		const { response, attempt } = await this.send(request);
-		try {
-			const bytes = await readBody(response, this.settings.maxResponseBytes);
-			if (bytes.byteLength === 0 && (response.status === 204 || request.method === "DELETE")) return;
-			try {
-				return JSON.parse(new TextDecoder().decode(bytes));
-			} catch (cause) {
-				throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.INVALID_RESPONSE, {
-					message: `Invalid JSON response (HTTP ${response.status})`,
-					...responseInfo(response),
-					cause
-				});
-			}
-		} catch (cause) {
-			throw toFailure(cause, attempt);
-		} finally {
-			attempt.release();
-		}
-	}
-};
-//#endregion
-//#region src/client/CalmLensClient.ts
-const DEFAULT_TIMEOUT_MS = 12e4;
-const DEFAULT_MAX_RETRIES = 2;
-const DEFAULT_MAX_RESPONSE_BYTES = 33554432;
-const toBlobPartBytes = (value) => {
-	if (value instanceof ArrayBuffer) return new Uint8Array(value);
-	return Uint8Array.from(value);
-};
-const normalizePayloadForRequest = (payload) => {
-	if ("base64" in payload && payload.base64) return {
-		...payload,
-		base64: require_CalmLensWebhooks.getRawBase64(payload.base64)
-	};
-	if ("uint8Array" in payload && payload.uint8Array) {
-		const { uint8Array, ...rest } = payload;
-		return {
-			...rest,
-			data: new Blob([toBlobPartBytes(uint8Array)])
-		};
-	}
-	if ("buffer" in payload && payload.buffer) {
-		const { buffer, ...rest } = payload;
-		return {
-			...rest,
-			data: new Blob([toBlobPartBytes(buffer)])
-		};
-	}
-	return payload;
-};
-const toRawUploadBody = (payload) => {
-	const data = require_CalmLensWebhooks.assetToData(normalizePayloadForRequest(payload));
-	if (data instanceof Response) {
-		if (!data.body) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Response upload data must have a body" });
-		return data.body;
-	}
-	if (data instanceof ArrayBuffer || data instanceof Blob) return data;
-	if ("getReader" in data) return data;
-	return new Blob([toBlobPartBytes(data)]);
-};
-const setOptionalQueryValue = (params, key, value) => {
-	if (value !== void 0 && value !== null) params.set(key, typeof value === "string" ? value : JSON.stringify(value));
-};
-const assertValidUploadMimeType = (mimeType) => {
-	if (require_CalmLensWebhooks.isRejectedUploadMimeType(mimeType)) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
-		message: require_CalmLensWebhooks.getRejectedUploadMimeTypeError(mimeType),
-		details: { mimeType }
-	});
-};
-const isImageMimeType = (mimeType) => mimeType.toLowerCase().startsWith("image/");
-const invalidPayload = (message) => new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
-const prepareSubmitAssetOptions = (options) => {
-	if (!options || typeof options !== "object") throw require_CalmLensWebhooks.invalidArgument("Asset options are required");
-	if (!("content" in options) && !("url" in options) && !("part" in options)) throw invalidPayload("Either file content, URL, or multipart part is required");
-	if (!options.name) throw invalidPayload("Asset name is required");
-	if (!("part" in options) && "isFinal" in options) throw invalidPayload("isFinal is only valid for multipart uploads");
-	if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.API_ERROR_CODES.USE_UPLOAD_PART, { message: "Use uploadPart for multipart upload parts after the first part" });
-	if ("content" in options) {
-		assertValidUploadMimeType(options.content.type);
-		if (!("plainText" in options.content)) {
-			const validation = require_CalmLensWebhooks.validateAssetPayload(options.content);
-			if (!validation.ok) throw invalidPayload(validation.error);
-		}
-	}
-	if ("part" in options) {
-		assertValidUploadMimeType(options.part.type);
-		const partSizeInBytes = options.part.sizeInBytes ?? require_CalmLensWebhooks.getAssetPayloadByteLength(options.part);
-		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
-			if (partSizeInBytes > require_CalmLensWebhooks.MAX_IMAGE_UPLOAD_BYTES) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.API_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE, { message: "Multipart image uploads cannot exceed 20MB." });
-			if (options.part.isFinal && partSizeInBytes < require_CalmLensWebhooks.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.API_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL, { message: "Multipart image uploads must total at least 10MB." });
-		}
-		const validation = require_CalmLensWebhooks.validateAssetPayload(options.part, {
-			multipart: true,
-			isFinal: options.part.isFinal
-		});
-		if (!validation.ok) throw invalidPayload(validation.error);
-	}
-	return options;
-};
-const getEnsureLensCacheKey = (options) => require_CalmLensWebhooks.stringifyJsonCanonical({
-	identifier: options.identifier,
-	name: options.name,
-	description: options.description ?? null,
-	type: options.type,
-	active: options.active,
-	transforms: options.transforms ?? null,
-	version: options.version
-});
-const newIdempotencyKey = () => crypto.randomUUID();
-/** Text content is small, so it keeps the API deadline; binary files may be arbitrarily large. */
-const isTextPayload = (payload) => "plainText" in payload;
-const requireId = (value, name) => require_CalmLensWebhooks.encodePathSegment(value, name);
-const isAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id && typeof data.status === "string";
-const inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
-/**
-* The CalmLens API client. Create one per project and reuse it; it holds no connections.
-* Every method takes one options object and throws `CalmLensError` on failure.
-*/
-var CalmLensClient = class CalmLensClient {
-	#apiKey;
-	#state;
-	#transport;
-	/**
-	* Verifies that a webhook delivery came from CalmLens: checks the `v1=` HMAC-SHA256 in
-	* `x-calmlens-signature` over `"<x-calmlens-timestamp>.<raw body>"` and rejects timestamps
-	* more than `toleranceSeconds` (default 300) from now, which stops replayed deliveries.
-	* Also exported as `verifyWebhookSignature`; `parseWebhookEvent` verifies and parses.
-	*
-	* @example
-	* ```ts
-	* const payload = await request.text();
-	* const isValid = await CalmLensClient.verifyWebhookSignature({
-	*   payload,
-	*   headers: request.headers,
-	*   secret: process.env.CALMLENS_WEBHOOK_SECRET!,
-	* });
-	* ```
-	*/
-	static async verifyWebhookSignature(options) {
-		return require_CalmLensWebhooks.verifyWebhookSignature(options);
-	}
-	constructor(options, state) {
-		require_CalmLensWebhooks.validateClientOptions(options);
-		if (isBrowserRuntime() && !options.dangerouslyAllowBrowser) throw require_CalmLensWebhooks.invalidConfig("CalmLensClient is running in a browser, where every visitor could read the API key. Call CalmLens from your server, or set dangerouslyAllowBrowser: true for trusted internal tools.");
-		const { apiKey, ...rest } = options;
-		this.#apiKey = apiKey;
-		this.#state = {
-			options: {
-				...rest,
-				baseUrl: (rest.baseUrl ?? `https://api.calmlens.com/v1`).replace(/\/+$/, ""),
-				cdnBaseUrl: (rest.cdnBaseUrl ?? `https://cdn.calmlens.com/v1`).replace(/\/+$/, "")
-			},
-			ensuredLenses: state?.ensuredLenses ?? /* @__PURE__ */ new Map(),
-			pendingEnsureLenses: state?.pendingEnsureLenses ?? /* @__PURE__ */ new Map()
-		};
-		const resolveFetch = () => {
-			const fetchImpl = this.#state.options.fetch ?? globalThis.fetch;
-			if (typeof fetchImpl !== "function") throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.NO_FETCH, { message: "No fetch implementation is available; pass one as the fetch option" });
-			return fetchImpl;
-		};
-		this.#transport = new CalmLensTransport({
-			apiKey,
-			fetch: ((input, init) => resolveFetch()(input, init)),
-			signal: rest.signal,
-			maxRetries: rest.maxRetries ?? DEFAULT_MAX_RETRIES,
-			maxResponseBytes: rest.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES
-		});
-	}
-	/**
-	* A client with different cancellation, deadlines or retries for the calls made through it,
-	* sharing this client's credentials and lens cache. This client is unchanged.
-	*/
-	withRequestOptions(options) {
-		require_CalmLensWebhooks.validateRequestOptions(options);
-		return new CalmLensClient({
-			...this.#state.options,
-			...options,
-			apiKey: this.#apiKey
-		}, this.#state);
-	}
-	/** Keeps the API key out of `console.log`, `util.inspect` and `JSON.stringify`. */
-	[inspectSymbol]() {
-		const { projectId, baseUrl } = this.#state.options;
-		return `CalmLensClient { projectId: ${JSON.stringify(projectId)}, baseUrl: ${JSON.stringify(baseUrl)} }`;
-	}
-	toJSON() {
-		const { projectId, baseUrl, cdnBaseUrl } = this.#state.options;
-		return {
-			projectId,
-			baseUrl,
-			cdnBaseUrl
-		};
-	}
-	get timeoutMs() {
-		return this.#state.options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	}
-	apiUrl(path, query) {
-		const search = query ? require_CalmLensWebhooks.stringifyQuery(query) : "";
-		return `${this.#state.options.baseUrl}${path}${search ? `?${search}` : ""}`;
-	}
-	get projectPath() {
-		return `/projects/${encodeURIComponent(this.#state.options.projectId)}`;
-	}
-	request(method, path, { query, body } = {}) {
-		return this.#transport.json({
-			method,
-			url: this.apiUrl(path, query),
-			headers: body === void 0 ? void 0 : { "Content-Type": "application/json" },
-			body: body === void 0 ? void 0 : JSON.stringify(body),
-			timeoutMs: this.timeoutMs,
-			deadline: "body"
-		});
-	}
-	uploadRequest(url, payload, headers, idempotencyKey) {
-		const options = this.#state.options;
-		return this.#transport.json({
-			method: "POST",
-			url,
-			headers,
-			body: toRawUploadBody(payload),
-			idempotencyKey,
-			timeoutMs: isTextPayload(payload) ? this.timeoutMs : options.uploadTimeoutMs,
-			deadline: "body",
-			fetch: options.uploadFetch
-		});
-	}
-	async submitRawAssetUpload(options, queue) {
-		const query = new URLSearchParams();
-		query.set("name", options.name);
-		query.set("queue", String(queue));
-		setOptionalQueryValue(query, "description", options.description);
-		setOptionalQueryValue(query, "processingOptions", options.processingOptions);
-		setOptionalQueryValue(query, "visibility", options.visibility);
-		setOptionalQueryValue(query, "metadata", options.metadata);
-		setOptionalQueryValue(query, "externalId", options.externalId);
-		setOptionalQueryValue(query, "externalUrl", options.externalUrl);
-		setOptionalQueryValue(query, "folderId", options.folderId);
-		const isMultipart = "part" in options;
-		const payload = isMultipart ? options.part : options.content;
-		query.set("contentType", payload.type);
-		setOptionalQueryValue(query, "sizeInBytes", payload.sizeInBytes ?? require_CalmLensWebhooks.getAssetPayloadByteLength(payload));
-		if (isMultipart) {
-			const part = payload;
-			const multipartOptions = options;
-			query.set("partNumber", String(part.partNumber ?? 1));
-			query.set("isFinal", String(part.isFinal ?? false));
-			setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? multipartOptions.sizeInBytes);
-			setOptionalQueryValue(query, "totalSizeInBytes", multipartOptions.totalSizeInBytes);
-		}
-		const path = isMultipart ? "assets/multipart-upload" : "assets/upload";
-		const data = await this.uploadRequest(this.apiUrl(`${this.projectPath}/${path}?${query}`), payload, {
-			"Content-Type": payload.type,
-			"X-CalmLens-Upload": isMultipart ? "part" : "content"
-		}, options.idempotencyKey ?? newIdempotencyKey());
-		return this.expectAsset(data);
-	}
-	expectAsset(data) {
-		if (!isAsset(data)) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.INVALID_RESPONSE, {
-			message: "Expected an asset response",
-			status: 200
-		});
-		return data;
-	}
-	async submitAsset(options, queue) {
-		const body = prepareSubmitAssetOptions(options);
-		if ("content" in body || "part" in body) return this.submitRawAssetUpload(body, queue);
-		const { idempotencyKey, ...fields } = body;
-		const data = await this.#transport.json({
-			method: "POST",
-			url: this.apiUrl(`${this.projectPath}/assets`, { queue }),
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(fields),
-			idempotencyKey: idempotencyKey ?? newIdempotencyKey(),
-			timeoutMs: this.timeoutMs,
-			deadline: "body"
-		});
-		return this.expectAsset(data);
-	}
-	get cdn() {
-		return {
-			/**
-			* Builds a CDN URL for asset content or a preview, without a request. Private assets
-			* need a signed URL (`assets.createSignedUrl`) or an authenticated request.
-			*/
-			getAssetUrl: ({ assetIdentifier, ...options }) => {
-				const resource = options.resource ?? "content";
-				const url = `${this.#state.options.cdnBaseUrl}/assets/${encodeURIComponent(this.#state.options.projectId)}/${requireId(assetIdentifier, "Asset identifier")}/${resource}`;
-				return require_CalmLensWebhooks.appendCdnSelector(url, options);
-			},
-			/**
-			* Fetches asset content or a preview from the CDN with the client's API key, and returns
-			* the `Response` as soon as headers arrive, so the body streams. Non-2xx responses are
-			* returned, not thrown; `timeoutMs` covers only the wait for headers.
-			*/
-			serve: async ({ assetIdentifier, init, ...urlOptions }) => {
-				const url = this.cdn.getAssetUrl({
-					assetIdentifier,
-					...urlOptions
-				});
-				const method = init?.method?.toUpperCase() ?? "GET";
-				const { response } = await this.#transport.send({
-					method,
-					url,
-					init,
-					timeoutMs: this.timeoutMs,
-					deadline: "headers",
-					fetch: this.#state.options.cdnFetch
-				}, { allowHttpErrors: true });
-				return response;
-			}
-		};
-	}
-	get text() {
-		return { 
-		/**
-		* Moderates text and waits for the decision. Sends `text` as `text/plain` content named
-		* `text` unless you pass `name`.
-		*/
-moderate: async (options) => this.assets.moderate(require_CalmLensWebhooks.toTextAssetOptions(options)) };
-	}
-	get assets() {
-		return {
-			/** Searches accessible assets by keyword or a natural-language description. */
-			search: async (options) => this.request("GET", `${this.projectPath}/assets/search`, { query: options }),
-			/** Lists one page of the project's assets, with optional filter and ordering. */
-			list: async (options = {}) => this.request("GET", `${this.projectPath}/assets/page`, { query: {
-				...options,
-				pageIndex: options.pageIndex ?? 0
-			} }),
-			/**
-			* Yields every asset matching `options`, fetching pages as needed. Assets created or
-			* deleted while iterating can shift pages, so an asset may be skipped or repeated.
-			*/
-			iterate: (options = {}) => this.iteratePages((pageIndex) => this.assets.list({
-				...options,
-				pageIndex
-			})),
-			/** Retrieves an asset with its status and moderation report. */
-			retrieve: async ({ assetId }) => this.request("GET", `/assets/${requireId(assetId, "Asset ID")}`),
-			/** Updates an asset's editable fields. */
-			update: async ({ assetId, ...body }) => this.request("PATCH", `/assets/${requireId(assetId, "Asset ID")}`, { body }),
-			/** Lists one page of the assets extracted from a website or multimedia document. */
-			listChildren: async ({ assetId, ...options } = {}) => this.request("GET", `/assets/${requireId(assetId, "Asset ID")}/children`, { query: {
-				...options,
-				pageIndex: options.pageIndex ?? 0
-			} }),
-			/** Yields every child of an asset, fetching pages as needed. */
-			iterateChildren: (options) => {
-				requireId(options?.assetId, "Asset ID");
-				return this.iteratePages((pageIndex) => this.assets.listChildren({
-					...options,
-					pageIndex
-				}));
-			},
-			/**
-			* Uploads an asset and queues it for moderation, returning immediately with status
-			* `pending` (or `uploading` for the first multipart part). Retried safely with an
-			* `Idempotency-Key`.
-			*/
-			create: async (options) => this.submitAsset(options, true),
-			/**
-			* Uploads an asset and waits for its moderation decision. Audio and video still finish
-			* in the background. Retried safely with an `Idempotency-Key`.
-			*/
-			moderate: async (options) => {
-				if (options && "content" in options && "plainText" in options.content && (typeof options.content.plainText !== "string" || !options.content.plainText.trim())) throw invalidPayload("Text to moderate must be a non-empty string");
-				return this.submitAsset(options, false);
-			},
-			/**
-			* Uploads the next part of a multipart upload. The upload's queue mode, chosen when it
-			* started, applies when the final part arrives; pass `queue` to override it.
-			*/
-			uploadPart: async ({ assetId, part, queue, idempotencyKey }) => {
-				const encodedAssetId = requireId(assetId, "Asset ID");
-				if (!part) throw require_CalmLensWebhooks.invalidArgument("Part options are required");
-				const validation = require_CalmLensWebhooks.validateAssetPayload(part, {
-					multipart: true,
-					isFinal: part.isFinal
-				});
-				if (!validation.ok) throw invalidPayload(validation.error);
-				const query = new URLSearchParams({
-					partNumber: String(part.partNumber),
-					isFinal: String(part.isFinal ?? false)
-				});
-				if (queue !== void 0) query.set("queue", String(queue));
-				setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? require_CalmLensWebhooks.getAssetPayloadByteLength(part));
-				const data = await this.uploadRequest(this.apiUrl(`/assets/${encodedAssetId}/part?${query}`), part, { "X-CalmLens-Upload": "part" }, idempotencyKey ?? newIdempotencyKey());
-				return this.expectAsset(data);
-			},
-			/**
-			* Creates a short-lived signed CDN URL, so browsers can load private content without
-			* an API key.
-			*/
-			createSignedUrl: async ({ assetId, ...options }) => {
-				const encodedAssetId = requireId(assetId, "Asset ID");
-				if (options.lens && options.transform) throw require_CalmLensWebhooks.invalidArgument("Specify either a lens or a transform, not both");
-				return this.request("POST", `/assets/${encodedAssetId}/signed-url`, { body: {
-					resource: options.resource ?? "content",
-					expiresInSeconds: options.expiresInSeconds ?? 900,
-					lens: options.lens,
-					transform: require_CalmLensWebhooks.transformSelector(options.transform)
-				} });
-			},
-			/** Moves an asset into a folder, or to the project root with `folderId: null`. */
-			move: async ({ assetId, folderId }) => this.request("POST", `/assets/${requireId(assetId, "Asset ID")}/move`, { body: { folderId } }),
-			/**
-			* Processes an asset that failed (status `error`) again. It returns to `pending` and is
-			* moderated like a new upload; its content must still be stored.
-			*/
-			retry: async ({ assetId }) => this.request("POST", `/assets/${requireId(assetId, "Asset ID")}/retry`),
-			/**
-			* Removes an asset's stored content (source, preview and retained extracted text) while
-			* keeping the asset record, metadata and moderation report. The returned asset has
-			* `storageDeletedAt` set; the CDN no longer serves it.
-			*/
-			deleteContent: async ({ assetId }) => this.request("DELETE", `/assets/${requireId(assetId, "Asset ID")}/content`),
-			/** Deletes an asset record together with its stored content. */
-			delete: async ({ assetId }) => {
-				await this.request("DELETE", `/assets/${requireId(assetId, "Asset ID")}`);
-			}
-		};
-	}
-	get events() {
-		return {
-			/**
-			* Lists project events after a cursor, oldest first. Call without `after` to get a cursor
-			* for "now", then poll with the returned `cursor`. Webhook deliveries carry the same events
-			* reshaped as `{ id, type, createdAt, projectId, data }`.
-			*/
-			list: async (options = {}) => this.request("GET", `${this.projectPath}/events`, { query: { ...options } }),
-			/**
-			* Yields pages of events after `after` until no more are waiting. Save each page's
-			* `cursor` to resume later. Without `after`, yields one empty page whose cursor is "now".
-			*/
-			pages: (options = {}) => this.iterateEventPages(options)
-		};
-	}
-	async *iterateEventPages(options) {
-		let after = options.after;
-		for (;;) {
-			const page = await this.events.list({
-				...options,
-				after
-			});
-			yield page;
-			if (!page.hasMore || page.cursor === after) return;
-			after = page.cursor;
-		}
-	}
-	async *iteratePages(listPage) {
-		for (let pageIndex = 0;; pageIndex++) {
-			const page = await listPage(pageIndex);
-			yield* page.items;
-			if (!page.hasMore || page.items.length === 0) return;
-		}
-	}
-	get folders() {
-		return {
-			/** Lists every folder in the project. */
-			list: async () => (await this.request("GET", `${this.projectPath}/folders`)).folders,
-			retrieve: async ({ folderId }) => this.request("GET", `/folders/${requireId(folderId, "Folder ID")}`),
-			/** Creates a folder at the project root or inside `parentId`. */
-			create: async (options) => this.request("POST", `${this.projectPath}/folders`, { body: options }),
-			update: async ({ folderId, ...body }) => this.request("PATCH", `/folders/${requireId(folderId, "Folder ID")}`, { body }),
-			/** Deletes an empty folder; throws `folder/not-empty` otherwise. */
-			delete: async ({ folderId }) => {
-				await this.request("DELETE", `/folders/${requireId(folderId, "Folder ID")}`);
-			},
-			/** Moves a folder under `parentId`, or to the project root with `parentId: null`. */
-			move: async ({ folderId, parentId }) => this.request("POST", `/folders/${requireId(folderId, "Folder ID")}/move`, { body: { parentId } })
-		};
-	}
-	/**
-	* Create a named lens at any positive version, or update it with a greater version.
-	* Supplying the same definition and version is idempotent.
-	*/
-	async ensureLens(options) {
-		if (!options?.identifier) throw require_CalmLensWebhooks.invalidArgument("Lens identifier is required");
-		const [lens] = await this.ensureLenses({ lenses: [options] });
-		return lens;
-	}
-	/**
-	* Create or update several named lenses in one API request.
-	* Each lens follows the same versioning and idempotency rules as ensureLens().
-	*/
-	async ensureLenses({ lenses }) {
-		if (!Array.isArray(lenses) || lenses.length === 0) throw require_CalmLensWebhooks.invalidArgument("At least one lens is required");
-		if (lenses.some((option) => !option?.identifier)) throw require_CalmLensWebhooks.invalidArgument("Lens identifier is required");
-		const { ensuredLenses, pendingEnsureLenses } = this.#state;
-		const missingOptions = [];
-		const missingKeys = /* @__PURE__ */ new Set();
-		for (const option of lenses) {
-			const cacheKey = getEnsureLensCacheKey(option);
-			if (!ensuredLenses.has(cacheKey) && !missingKeys.has(cacheKey)) {
-				missingKeys.add(cacheKey);
-				missingOptions.push(option);
-			}
-		}
-		if (missingOptions.length > 0) {
-			const batchCacheKey = JSON.stringify([...missingKeys].sort());
-			let pending = pendingEnsureLenses.get(batchCacheKey);
-			if (!pending) {
-				pending = this.submitEnsureLenses(missingOptions);
-				pendingEnsureLenses.set(batchCacheKey, pending);
-				pending.then(() => pendingEnsureLenses.delete(batchCacheKey), () => pendingEnsureLenses.delete(batchCacheKey));
-			}
-			await pending;
-		}
-		return lenses.map((option) => {
-			const lens = ensuredLenses.get(getEnsureLensCacheKey(option));
-			if (!lens) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.INVALID_RESPONSE, { message: `CalmLens did not return lens "${option.identifier}"` });
-			return lens;
-		});
-	}
-	async submitEnsureLenses(options) {
-		const result = await this.request("PUT", `${this.projectPath}/lenses`, { body: { lenses: options } });
-		const returned = Array.isArray(result?.lenses) ? result.lenses : [];
-		if (returned.length !== options.length) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.INVALID_RESPONSE, { message: `Expected ${options.length} lenses but CalmLens returned ${returned.length}` });
-		const { ensuredLenses } = this.#state;
-		for (const [index, lens] of returned.entries()) {
-			const optionsForLens = options[index];
-			if (lens?.identifier !== optionsForLens.identifier) throw new require_CalmLensWebhooks.CalmLensError(require_CalmLensWebhooks.SDK_ERROR_CODES.INVALID_RESPONSE, { message: `Expected lens "${optionsForLens.identifier}" at position ${index}` });
-			for (const [cacheKey, cachedLens] of ensuredLenses) if (cachedLens.identifier === optionsForLens.identifier) ensuredLenses.delete(cacheKey);
-			ensuredLenses.set(getEnsureLensCacheKey(optionsForLens), lens);
-		}
-	}
-};
-//#endregion
-exports.CALMLENS_ERROR_CODES = require_CalmLensWebhooks.CALMLENS_ERROR_CODES;
-exports.CalmLensClient = CalmLensClient;
-exports.CalmLensError = require_CalmLensWebhooks.CalmLensError;
-exports.SDK_VERSION = SDK_VERSION;
-exports.WEBHOOK_DELIVERY_HEADER = require_CalmLensWebhooks.WEBHOOK_DELIVERY_HEADER;
-exports.WEBHOOK_SIGNATURE_HEADER = require_CalmLensWebhooks.WEBHOOK_SIGNATURE_HEADER;
-exports.WEBHOOK_SIGNATURE_TOLERANCE_SECONDS = require_CalmLensWebhooks.WEBHOOK_SIGNATURE_TOLERANCE_SECONDS;
-exports.WEBHOOK_TIMESTAMP_HEADER = require_CalmLensWebhooks.WEBHOOK_TIMESTAMP_HEADER;
-exports.parseWebhookEvent = require_CalmLensWebhooks.parseWebhookEvent;
-exports.verifyWebhookSignature = require_CalmLensWebhooks.verifyWebhookSignature;
+const require_CalmLensError = require("./CalmLensError-CKwMKV0S.js");
+const require_src = require("./src-Dsc8Pn6v.js");
+exports.CALMLENS_ERROR_CODES = require_CalmLensError.CALMLENS_ERROR_CODES;
+exports.CalmLensError = require_CalmLensError.CalmLensError;
+exports.SDK_VERSION = require_src.SDK_VERSION;