@calmlens/sdk 0.9.1 → 0.10.1

package/cjs/index.js

@@ -1,403 +1,336 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_CalmLensUtils = require("./CalmLensUtils-B6vwJijv.js");
-let zod = require("zod");
-zod = require_CalmLensUtils.__toESM(zod);
-require("zod/v4");
-let api_def = require("api-def");
-//#region ../shared/src/ModerationCategoryDefinitions.ts
-const MODERATION_CATEGORY_DEFINITIONS = {
-	sexual: {
-		summary: "Sexual acts, explicit sexual anatomy, sexual services, sexual assault depictions and clearly erotic material.",
-		definition: "covers sexual acts, explicit sexual anatomy, sexual services and clearly erotic material. Descriptions of sexual assault can qualify without erotic intent. Fictional, illustrated and generated depictions can also qualify.",
-		exclusions: "Ordinary affection, swimwear, fitness, fashion, non-erotic medical diagrams and general sexual-health education do not qualify on their own. A person accepting money or wearing revealing clothing does not establish sexual content without a qualifying act, display or offer.",
-		docsHref: "/docs/guides/moderation-categories#sexual-content"
-	},
-	violence: {
-		summary: "Physical attacks, injury, death, threats against others, and planning or encouraging physical violence.",
-		definition: "covers physical attacks, bodily injury, death and threats against others. Accidental or medical injuries and natural death also count; an attacker or intent to harm is not required. It also includes planning, requesting, encouraging or praising physical violence. A depicted or described act can qualify in fiction or news reporting even when the author condemns it.",
-		exclusions: "Solely intentional self-injury or suicide belongs under self-harm. Property damage alone, figurative language, abstract discussion of violence, injury or death and merely possessing a weapon do not establish violence. Consensual sport or training without injury or abuse is excluded.",
-		docsHref: "/docs/guides/moderation-categories#violence"
-	},
-	"self-harm": {
-		summary: "Intentional self-injury, suicide, preparation, methods or encouragement; text also includes current or recurring self-harm thoughts.",
-		definition: "covers intentional self-injury, suicide, current self-harm risk, preparation, methods and encouragement. For text, it also includes current or recurring self-harm thoughts and an explicitly expressed desire to die. Asking for support does not cancel a separate disclosure of current risk or behavior.",
-		exclusions: "For images, require evidence of a self-directed act, preparation, harmful methods or encouragement. An injury or covered body does not establish that harm was self-inflicted. General sadness, neutral statistics, prevention, recovery and healed scars alone are excluded.",
-		docsHref: "/docs/guides/moderation-categories#self-harm"
-	},
-	harassment: {
-		summary: "Targeted personal abuse, humiliation, bullying or serious intimidation; ordinary criticism and neutral reporting are excluded.",
-		definition: "covers personal abuse, humiliation, bullying and serious intimidation directed at a person or identifiable group. The target can be named, implied or defined by an activity or affiliation. A protected identity is not required.",
-		exclusions: "Disagreement, ordinary criticism of conduct or competence, untargeted profanity and neutral reporting of abuse do not qualify without a separate personal attack. Criticism can still qualify when it also contains personal degradation.",
-		docsHref: "/docs/guides/moderation-categories#harassment-and-bullying"
-	},
-	hate: {
-		summary: "Identity-based abuse, dehumanization, discriminatory exclusion or threats against people because of protected characteristics.",
-		definition: "covers attacks on people because of race, ethnicity, nationality, religion, caste, sex, gender identity, sexual orientation or disability. It includes dehumanization, asserted inferiority, discriminatory exclusion, identity-based abuse and threats.",
-		exclusions: "Both the protected target and the identity-based attack must be supported. Identity mentions, cultural clothing, religious imagery, criticism of beliefs or an unrelated threat do not establish hate. Neutral reporting, condemnation and opposition to hate are excluded unless a separate attack is expressed or endorsed.",
-		docsHref: "/docs/guides/moderation-categories#hate-and-identity-abuse"
-	},
-	"criminal-activity": {
-		summary: "Planning, assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act.",
-		definition: "covers planning, requests for assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act. A request can qualify even when no act occurs and a later reply refuses it. Dangerous activity requires a concrete serious risk of physical harm.",
-		exclusions: "Neutral reporting, prevention, lawful safety advice, fiction without criminal assistance, and vague dangerous references do not qualify. Masks, computers, payment cards, detention or ordinary tools do not establish criminal facilitation by themselves. A clear visual demonstration of how to carry out a crime can qualify.",
-		docsHref: "/docs/guides/moderation-categories#criminal-and-dangerous-activity"
-	}
-};
+const require_CalmLensWebhooks = require("./CalmLensWebhooks-DJnaLpRy.js");
 //#endregion
-//#region ../shared/src/ModerationPolicyDimensions.ts
-const MODERATION_QUALIFIERS = [
-	"nudity",
-	"sexual-activity",
-	"explicit-sexual-language",
-	"sexual-solicitation",
-	"physical-attack",
-	"violent-threat",
-	"violent-preparation",
-	"violent-encouragement",
-	"injury",
-	"death",
-	"graphic",
-	"self-harm-thoughts",
-	"self-harm-preparation",
-	"self-harm-act",
-	"self-harm-methods",
-	"self-harm-encouragement",
-	"personal-abuse",
-	"targeted-intimidation",
-	"harassment-threat",
-	"sexual-harassment",
-	"harassment-encouragement",
-	"identity-abuse",
-	"dehumanization",
-	"identity-inferiority",
-	"discriminatory-exclusion",
-	"hate-threat",
-	"criminal-demonstration",
-	"criminal-preparation",
-	"criminal-request",
-	"criminal-instructions",
-	"criminal-promotion",
-	"historical",
-	"documentary",
-	"fictional",
-	"support-prevention"
-];
-const SHARED_QUALIFIERS = [
-	"historical",
-	"documentary",
-	"fictional",
-	"support-prevention"
-];
-[...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS];
-//#endregion
-//#region ../../node_modules/zod-meta/esm/index.js
-const createMetaType = (type) => {
-	return Object.assign((value) => {
-		return {
-			type,
-			data: value !== null && value !== void 0 ? value : {}
-		};
-	}, type);
+//#region src/client/CalmLensVersion.ts
+/** This SDK's version, from its package.json. */
+const SDK_VERSION = "0.10.1";
+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";
 };
-createMetaType({ id: "docPropertyInfo" });
+/** 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 ../shared/src/ZodUtils.ts
-const SIZE_LIMITS = {
-	small: 64,
-	medium: 200,
-	large: 1500,
-	xlarge: 1e4,
-	token: 1e4
-};
-const saneStringField = (options) => {
-	return zod.string().transform((value) => value.trim()).refine((value) => {
-		if ((options === null || options === void 0 ? void 0 : options.minWidth) && value.length < options.minWidth) return false;
-		return true;
-	}, "Not long enough").refine((value) => {
-		var _options$maxLength, _options$type;
-		const sizeLimit = (_options$maxLength = options === null || options === void 0 ? void 0 : options.maxLength) !== null && _options$maxLength !== void 0 ? _options$maxLength : SIZE_LIMITS[(_options$type = options === null || options === void 0 ? void 0 : options.type) !== null && _options$type !== void 0 ? _options$type : "medium"];
-		return typeof value === "string" && value.length < sizeLimit;
-	}, "Too long");
-};
-const CLASSIFICATION_INPUT_TYPE_SCHEMA = zod.enum(["text", "image"]);
-const CLASSIFICATION_CATEGORIES = [
-	"sexual",
-	"violence",
-	"self-harm",
-	"harassment",
-	"hate",
-	"criminal-activity"
-];
-const CLASSIFICATION_CATEGORY_SCHEMA = zod.enum(CLASSIFICATION_CATEGORIES);
-zod.object({
-	category: CLASSIFICATION_CATEGORY_SCHEMA,
-	displayName: saneStringField(),
-	description: saneStringField(),
-	supportedInputTypes: zod.array(CLASSIFICATION_INPUT_TYPE_SCHEMA).min(1)
-});
-MODERATION_CATEGORY_DEFINITIONS.sexual.summary, MODERATION_CATEGORY_DEFINITIONS.violence.summary, MODERATION_CATEGORY_DEFINITIONS["self-harm"].summary, MODERATION_CATEGORY_DEFINITIONS.harassment.summary, MODERATION_CATEGORY_DEFINITIONS.hate.summary, MODERATION_CATEGORY_DEFINITIONS["criminal-activity"].summary;
-const LIKELIHOOD_SCHEMA = zod.enum([
-	"very-unlikely",
-	"unlikely",
-	"possible",
-	"likely",
-	"very-likely"
+//#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 CLASSIFICATION_NOT_EVALUATED_REASON_SCHEMA = zod.enum(["not-supported", "unavailable"]);
-const CLASSIFICATION_QUALIFIER_RESULTS_SCHEMA = zod.partialRecord(zod.enum(MODERATION_QUALIFIERS), zod.discriminatedUnion("status", [zod.object({
-	status: zod.literal("evaluated"),
-	score: zod.number().min(0).max(1),
-	scopeScore: zod.number().min(0).max(1).optional(),
-	likelihood: LIKELIHOOD_SCHEMA
-}).strict().refine(({ score, scopeScore }) => scopeScore === void 0 || scopeScore <= score, {
-	message: "Only confidence cannot exceed Any confidence",
-	path: ["scopeScore"]
-}), zod.object({
-	status: zod.literal("not-evaluated"),
-	reason: CLASSIFICATION_NOT_EVALUATED_REASON_SCHEMA
-}).strict()]));
-const CLASSIFICATION_CATEGORY_REPORT_SCHEMA = zod.discriminatedUnion("status", [
-	zod.object({
-		status: zod.literal("evaluated"),
-		likelihood: LIKELIHOOD_SCHEMA,
-		score: zod.number().min(0).max(1),
-		qualifiers: CLASSIFICATION_QUALIFIER_RESULTS_SCHEMA.optional()
-	}).strict(),
-	zod.object({
-		status: zod.literal("partial"),
-		likelihood: LIKELIHOOD_SCHEMA,
-		score: zod.number().min(0).max(1),
-		qualifiers: CLASSIFICATION_QUALIFIER_RESULTS_SCHEMA.optional()
-	}).strict(),
-	zod.object({
-		status: zod.literal("not-evaluated"),
-		reason: CLASSIFICATION_NOT_EVALUATED_REASON_SCHEMA,
-		qualifiers: CLASSIFICATION_QUALIFIER_RESULTS_SCHEMA.optional()
-	}).strict()
-]);
-const CATEGORIES_SCHEMA = zod.object({
-	sexual: CLASSIFICATION_CATEGORY_REPORT_SCHEMA,
-	violence: CLASSIFICATION_CATEGORY_REPORT_SCHEMA,
-	"self-harm": CLASSIFICATION_CATEGORY_REPORT_SCHEMA,
-	harassment: CLASSIFICATION_CATEGORY_REPORT_SCHEMA,
-	hate: CLASSIFICATION_CATEGORY_REPORT_SCHEMA,
-	"criminal-activity": CLASSIFICATION_CATEGORY_REPORT_SCHEMA
-}).strict();
-const CLASSIFICATION_LABEL_SCHEMA = zod.object({
-	description: saneStringField(),
-	score: zod.number(),
-	topicalityScore: zod.number().nullish(),
-	likelihood: LIKELIHOOD_SCHEMA,
-	knowledgeBaseId: saneStringField().nullish()
-});
-zod.object({
-	processedAt: zod.number(),
-	categories: CATEGORIES_SCHEMA,
-	flagged: zod.boolean(),
-	score: zod.number(),
-	notes: saneStringField().nullish(),
-	media: zod.object({
-		durationSeconds: zod.number().positive(),
-		frameIntervalSeconds: zod.number().positive().optional(),
-		sampledFrames: zod.number().int().nonnegative(),
-		audioTranscribed: zod.boolean(),
-		segments: zod.array(zod.object({
-			source: zod.enum([
-				"frame",
-				"speech",
-				"frame-text",
-				"clip"
-			]),
-			startSeconds: zod.number().nonnegative(),
-			endSeconds: zod.number().nonnegative(),
-			categories: CATEGORIES_SCHEMA
-		}).strict())
-	}).strict().optional(),
-	labels: zod.array(CLASSIFICATION_LABEL_SCHEMA).nullish()
-}).strict();
-//#endregion
-//#region ../shared/src/MediaTestTriggers.ts
-const MEDIA_TEST_SIGNALS = [...CLASSIFICATION_CATEGORIES, "violence.graphic"];
-const HEX_WORDS = [
-	"zero",
-	"one",
-	"two",
-	"three",
-	"four",
-	"five",
-	"six",
-	"seven",
-	"eight",
-	"nine",
-	"alpha",
-	"bravo",
-	"charlie",
-	"delta",
-	"echo",
-	"foxtrot"
-];
-/** Read this aloud, or render it as large, high-contrast text in a video frame. */
-function generateMediaTestCode(signal, projectId) {
-	if (!MEDIA_TEST_SIGNALS.includes(signal)) throw new Error("Unsupported media test signal");
-	const suffix = projectId.slice(-8).toLowerCase();
-	if (!/^[a-f0-9]{8}$/.test(suffix)) throw new Error("Expected a project ID with an eight-character hexadecimal suffix");
-	return `Calm Lens test ${[...suffix].map((character) => HEX_WORDS[Number.parseInt(character, 16)]).join(" ")} ${signal.replace(/[.-]/g, " ")} end test`;
-}
-//#endregion
-//#region ../shared/src/CryptoUtils.ts
-const encoder = new TextEncoder();
-/** Lowercase hex of `bytes`, two characters per byte. */
-const bytesToHex = (bytes) => Array.from(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
-(function() {
-	var _ref = require_CalmLensUtils._asyncToGenerator(function* (value) {
-		return bytesToHex(yield crypto.subtle.digest("SHA-256", encoder.encode(value)));
-	});
-	return function sha256Hex(_x) {
-		return _ref.apply(this, arguments);
-	};
-})();
-/** HMAC-SHA256 of `message` keyed with `secret` (both UTF-8 encoded), as lowercase hex. */
-const hmacSha256Hex = function() {
-	var _ref2 = require_CalmLensUtils._asyncToGenerator(function* (secret, message) {
-		const key = yield crypto.subtle.importKey("raw", encoder.encode(secret), {
-			name: "HMAC",
-			hash: "SHA-256"
-		}, false, ["sign"]);
-		return bytesToHex(yield crypto.subtle.sign("HMAC", key, encoder.encode(message)));
-	});
-	return function hmacSha256Hex(_x2, _x3) {
-		return _ref2.apply(this, arguments);
-	};
-}();
+const timeoutReason = () => {
+	const reason = /* @__PURE__ */ new Error("The operation timed out.");
+	reason.name = "TimeoutError";
+	return reason;
+};
 /**
-* Compares two strings without leaking, through timing, where they first differ. Strings of
-* different lengths are unequal immediately (the length itself is not secret here).
+* 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 timingSafeEqual = (a, b) => {
-	if (a.length !== b.length) return false;
-	let difference = 0;
-	for (let index = 0; index < a.length; index++) difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
-	return difference === 0;
-};
-//#endregion
-//#region src/client/CalmLensWebhooks.ts
-const WEBHOOK_DELIVERY_HEADER = "x-calmlens-delivery";
-const WEBHOOK_TIMESTAMP_HEADER = "x-calmlens-timestamp";
-const WEBHOOK_SIGNATURE_HEADER = "x-calmlens-signature";
-/** Deliveries whose timestamp is further than this from the receiver's clock are rejected. */
-const WEBHOOK_SIGNATURE_TOLERANCE_SECONDS = 300;
-/** The JSON body of a webhook delivery for a stored event. */
-const toWebhookEventPayload = (event) => {
-	var _event$description, _event$assetId, _event$asset;
+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 {
-		id: event.id,
-		type: event.type,
-		createdAt: event.createdAt,
-		projectId: event.projectId,
-		data: {
-			severity: event.severity,
-			title: event.title,
-			description: (_event$description = event.description) !== null && _event$description !== void 0 ? _event$description : null,
-			assetId: (_event$assetId = event.assetId) !== null && _event$assetId !== void 0 ? _event$assetId : null,
-			asset: (_event$asset = event.asset) !== null && _event$asset !== void 0 ? _event$asset : null,
-			facts: event.facts
+		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);
 		}
 	};
 };
-/** `v1=<hex HMAC-SHA256 of "<timestamp>.<body>">`, the `x-calmlens-signature` header value. */
-const createWebhookSignatureHeader = function() {
-	var _ref = require_CalmLensUtils._asyncToGenerator(function* (secret, timestamp, body) {
-		return `v1=${yield hmacSha256Hex(secret, `${timestamp}.${body}`)}`;
-	});
-	return function createWebhookSignatureHeader(_x, _x2, _x3) {
-		return _ref.apply(this, arguments);
-	};
-}();
-/** Headers for one signed delivery of `body`. */
-const createWebhookHeaders = function() {
-	var _ref2 = require_CalmLensUtils._asyncToGenerator(function* (options) {
-		var _options$timestampSec;
-		const timestamp = (_options$timestampSec = options.timestampSeconds) !== null && _options$timestampSec !== void 0 ? _options$timestampSec : Math.floor(Date.now() / 1e3);
-		return {
-			"content-type": "application/json",
-			[WEBHOOK_DELIVERY_HEADER]: options.deliveryId,
-			[WEBHOOK_TIMESTAMP_HEADER]: String(timestamp),
-			[WEBHOOK_SIGNATURE_HEADER]: yield createWebhookSignatureHeader(options.secret, timestamp, options.body)
-		};
-	});
-	return function createWebhookHeaders(_x4) {
-		return _ref2.apply(this, arguments);
-	};
-}();
 /**
-* Verifies a webhook delivery: `x-calmlens-signature` must contain a `v1=` HMAC-SHA256 of
-* `"<x-calmlens-timestamp>.<raw body>"`, and the timestamp must be within `toleranceSeconds`
-* (default 300) of now. Returns `false` for anything missing or malformed.
+* 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.
 */
-function verifyWebhookSignature(_x5) {
-	return _verifyWebhookSignature.apply(this, arguments);
-}
-function _verifyWebhookSignature() {
-	_verifyWebhookSignature = require_CalmLensUtils._asyncToGenerator(function* ({ payload, signature, timestamp, secret, toleranceSeconds = 300, now }) {
-		if (!secret || !signature || timestamp === null || timestamp === void 0) return false;
-		const timestampText = String(timestamp).trim();
-		if (!/^\d+$/.test(timestampText)) return false;
-		const nowMs = now === void 0 ? Date.now() : now instanceof Date ? now.getTime() : now;
-		if (Math.abs(Math.floor(nowMs / 1e3) - Number(timestampText)) > toleranceSeconds) return false;
-		const candidates = signature.split(",").map((part) => part.trim()).filter((part) => part.startsWith("v1=")).map((part) => part.slice(3).toLowerCase());
-		if (candidates.length === 0) return false;
-		const body = typeof payload === "string" ? payload : JSON.stringify(payload);
-		const expected = yield hmacSha256Hex(secret, `${timestampText}.${body}`);
-		let matched = false;
-		for (const candidate of candidates) if (timingSafeEqual(expected, candidate)) matched = true;
-		return matched;
+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)
 	});
-	return _verifyWebhookSignature.apply(this, arguments);
-}
+};
+/** 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 _excluded = ["uint8Array"];
-const _excluded2 = ["buffer"];
-const _excluded3 = ["assetIdentifier"];
-const _excluded4 = ["assetIdentifier", "init"];
-const _excluded5 = ["assetId"];
-const _excluded6 = ["assetId"];
-const _excluded7 = ["assetId"];
-const _excluded8 = ["folderId"];
+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 require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, payload), {}, { base64: require_CalmLensUtils.getRawBase64(payload.base64) });
+	if ("base64" in payload && payload.base64) return {
+		...payload,
+		base64: require_CalmLensWebhooks.getRawBase64(payload.base64)
+	};
 	if ("uint8Array" in payload && payload.uint8Array) {
-		const { uint8Array } = payload, rest = require_CalmLensUtils._objectWithoutProperties(payload, _excluded);
-		return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, rest), {}, { data: new Blob([toBlobPartBytes(uint8Array)]) });
+		const { uint8Array, ...rest } = payload;
+		return {
+			...rest,
+			data: new Blob([toBlobPartBytes(uint8Array)])
+		};
 	}
 	if ("buffer" in payload && payload.buffer) {
-		const { buffer } = payload, rest = require_CalmLensUtils._objectWithoutProperties(payload, _excluded2);
-		return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, rest), {}, { data: new Blob([toBlobPartBytes(buffer)]) });
+		const { buffer, ...rest } = payload;
+		return {
+			...rest,
+			data: new Blob([toBlobPartBytes(buffer)])
+		};
 	}
 	return payload;
 };
-const normalizeMetadataForMultipart = (metadata) => {
-	if (!Array.isArray(metadata)) return metadata;
-	return Object.fromEntries(metadata.map((item, index) => [index, item]));
-};
-const normalizeMetadataOptionsForRequest = (options) => {
-	if (!("metadata" in options) || !Array.isArray(options.metadata)) return options;
-	return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, options), {}, { metadata: normalizeMetadataForMultipart(options.metadata) });
-};
-const normalizeAssetOptionsForRequest = (options) => {
-	const normalizedOptions = normalizeMetadataOptionsForRequest(options);
-	if ("part" in normalizedOptions) return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, normalizedOptions), {}, { part: normalizePayloadForRequest(normalizedOptions.part) });
-	if ("content" in normalizedOptions && !("plainText" in normalizedOptions.content)) return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, normalizedOptions), {}, { content: normalizePayloadForRequest(normalizedOptions.content) });
-	return normalizedOptions;
-};
 const toRawUploadBody = (payload) => {
-	const data = require_CalmLensUtils.assetToData(normalizePayloadForRequest(payload));
+	const data = require_CalmLensWebhooks.assetToData(normalizePayloadForRequest(payload));
 	if (data instanceof Response) {
-		if (!data.body) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Response upload data must have a body" });
+		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;
@@ -408,923 +341,477 @@ 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_CalmLensUtils.isRejectedUploadMimeType(mimeType)) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
-		message: require_CalmLensUtils.getRejectedUploadMimeTypeError(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 (!("content" in options) && !("url" in options) && !("part" in options)) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Either file content, URL, or multipart part is required" });
-	if (!options.name) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset name is required" });
-	if (!("part" in options) && "isFinal" in options) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "isFinal is only valid for multipart uploads" });
-	if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.USE_UPLOAD_PART);
+	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_CalmLensUtils.validateAssetPayload(options.content);
-			if (!validation.ok) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+			const validation = require_CalmLensWebhooks.validateAssetPayload(options.content);
+			if (!validation.ok) throw invalidPayload(validation.error);
 		}
 	}
 	if ("part" in options) {
-		var _options$part$sizeInB;
 		assertValidUploadMimeType(options.part.type);
-		const partSizeInBytes = (_options$part$sizeInB = options.part.sizeInBytes) !== null && _options$part$sizeInB !== void 0 ? _options$part$sizeInB : require_CalmLensUtils.getAssetPayloadByteLength(options.part);
+		const partSizeInBytes = options.part.sizeInBytes ?? require_CalmLensWebhooks.getAssetPayloadByteLength(options.part);
 		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
-			if (partSizeInBytes > require_CalmLensUtils.MAX_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE);
-			if (options.part.isFinal && partSizeInBytes < require_CalmLensUtils.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL);
+			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_CalmLensUtils.validateAssetPayload(options.part, {
+		const validation = require_CalmLensWebhooks.validateAssetPayload(options.part, {
 			multipart: true,
 			isFinal: options.part.isFinal
 		});
-		if (!validation.ok) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+		if (!validation.ok) throw invalidPayload(validation.error);
 	}
 	return options;
 };
-const getEnsureLensCacheKey = (options) => {
-	var _options$description, _options$transforms;
-	return require_CalmLensUtils.stringifyJsonCanonical({
-		identifier: options.identifier,
-		name: options.name,
-		description: (_options$description = options.description) !== null && _options$description !== void 0 ? _options$description : null,
-		type: options.type,
-		active: options.active,
-		transforms: (_options$transforms = options.transforms) !== null && _options$transforms !== void 0 ? _options$transforms : null,
-		version: options.version
-	});
-};
-const withApiKeyHeader = (init, apiKey) => {
-	const headers = new Headers(init === null || init === void 0 ? void 0 : init.headers);
-	headers.set("X-Api-Key", apiKey);
-	return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, init), {}, {
-		redirect: "error",
-		headers: Object.fromEntries(headers.entries())
-	});
-};
-const requestSignal = (options, signal) => {
-	var _options$timeoutMs;
-	const signals = [
-		options.signal,
-		signal,
-		AbortSignal.timeout((_options$timeoutMs = options.timeoutMs) !== null && _options$timeoutMs !== void 0 ? _options$timeoutMs : 12e4)
-	].filter((value) => value != null);
-	return AbortSignal.any(signals);
-};
-/** Copies a fully read body into a new Response, so later JSON parsing cannot hit the network. */
-const toBufferedResponse = function() {
-	var _ref = require_CalmLensUtils._asyncToGenerator(function* (response) {
-		const body = response.status === 204 || response.status === 304 ? null : yield response.arrayBuffer();
-		const headers = new Headers(response.headers);
-		headers.delete("content-encoding");
-		headers.delete("content-length");
-		const buffered = new Response(body, {
-			status: response.status,
-			statusText: response.statusText,
-			headers
-		});
-		Object.defineProperty(buffered, "url", { value: response.url });
-		return buffered;
-	});
-	return function toBufferedResponse(_x) {
-		return _ref.apply(this, arguments);
-	};
-}();
-/**
-* Wraps fetch with the client's deadline, cancellation and redirect policy. Every failure,
-* including body reads, decompression and truncated bodies when `bufferBody` is set, becomes a
-* `CalmLensError` (`sdk/transport-error`, `sdk/timeout` or `sdk/cancelled`) with the original
-* error as its `cause`.
-*/
-const safeFetch = (fetchImpl, options, { bufferBody }) => function() {
-	var _ref2 = require_CalmLensUtils._asyncToGenerator(function* (input, init) {
-		var _init$signal;
-		const signal = requestSignal(options, (_init$signal = init === null || init === void 0 ? void 0 : init.signal) !== null && _init$signal !== void 0 ? _init$signal : input instanceof Request ? input.signal : void 0);
-		try {
-			signal.throwIfAborted();
-			const response = yield fetchImpl(input, require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, init), {}, {
-				redirect: "error",
-				signal
-			}));
-			return bufferBody ? yield toBufferedResponse(response) : response;
-		} catch (cause) {
-			var _signal$reason;
-			throw require_CalmLensUtils.calmLensError({ id: signal.aborted ? ((_signal$reason = signal.reason) === null || _signal$reason === void 0 ? void 0 : _signal$reason.name) === "TimeoutError" ? "sdk/timeout" : "sdk/cancelled" : "sdk/transport-error" }, {
-				message: signal.aborted ? "Request aborted" : "Request failed",
-				cause
-			});
-		}
-	});
-	return function(_x2, _x3) {
-		return _ref2.apply(this, arguments);
-	};
-}();
-const createApi = (options) => {
-	return new api_def.Api({
-		name: "Calm Lens",
-		baseUrl: options.baseUrl,
-		config: { queryHandling: { stringify: require_CalmLensUtils.stringifyQuery } },
-		middleware: [
-			(0, api_def.RequestCoalescingMiddleware)(),
-			{ beforeSend: (context) => {
-				context.updateHeaders({ "X-Api-Key": options.apiKey });
-			} },
-			{ [api_def.RequestEvent.ERROR]: (context) => {
-				if (context.error) throw normalizeApiError(context.error);
-			} }
-		],
-		requestBackend: options.requestBackend ? Object.assign(Object.create(options.requestBackend), "fetch" in options.requestBackend && typeof options.requestBackend.fetch === "function" ? { fetch: safeFetch(options.requestBackend.fetch, options, { bufferBody: true }) } : {}) : new api_def.FetchRequestBackend(safeFetch(globalThis.fetch, options, { bufferBody: true }))
-	});
-};
-const isApiErrorPayload = (value) => {
-	return !!value && typeof value === "object" && typeof value.code === "string";
-};
-const normalizeApiError = (error) => {
-	let cause = error;
-	const seen = /* @__PURE__ */ new Set();
-	while (cause instanceof Error && !seen.has(cause)) {
-		seen.add(cause);
-		if (cause instanceof require_CalmLensUtils.CalmLensError) return cause;
-		if (cause.name === "AbortError" || cause.name === "TimeoutError") return require_CalmLensUtils.calmLensError({ id: cause.name === "TimeoutError" ? "sdk/timeout" : "sdk/cancelled" }, {
-			message: "Request aborted",
-			cause
-		});
-		cause = cause.cause;
-	}
-	const response = error instanceof Error ? (0, api_def.getErrorResponse)(error) : void 0;
-	if (error instanceof Error && (0, api_def.isRequestError)(error) && isApiErrorPayload(response === null || response === void 0 ? void 0 : response.data)) {
-		const { code, message, details, traceId } = response.data;
-		return require_CalmLensUtils.calmLensError({
-			id: code,
-			defaultMessage: message
-		}, {
-			message,
-			status: response === null || response === void 0 ? void 0 : response.status,
-			cause: error,
-			details: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, details), {}, {
-				traceId,
-				network: true
-			})
-		});
-	}
-	if (error instanceof require_CalmLensUtils.CalmLensError) return error;
-	return require_CalmLensUtils.calmLensError({ id: response ? response.ok ? "sdk/invalid-response" : "sdk/http-error" : "sdk/transport-error" }, {
-		message: response ? `HTTP ${response.status}` : error.message,
-		status: response === null || response === void 0 ? void 0 : response.status,
-		cause: error
-	});
-};
-const createEndpoints = (api) => {
-	const getFolders = api.endpoint().paramsOf().responseOf().build({
-		id: "getFolders",
-		method: "get",
-		path: "/projects/:projectId/folders"
-	});
-	const getFolder = api.endpoint().paramsOf().responseOf().build({
-		id: "getFolder",
-		method: "get",
-		path: "/folders/:folderId"
-	});
-	const postFolder = api.endpoint().paramsOf().bodyOf().responseOf().build({
-		id: "postFolder",
-		method: "post",
-		path: "/projects/:projectId/folders"
-	});
-	const patchFolder = api.endpoint().paramsOf().bodyOf().responseOf().build({
-		id: "patchFolder",
-		method: "patch",
-		path: "/folders/:folderId"
-	});
-	const deleteFolder = api.endpoint().paramsOf().responseOf().build({
-		id: "deleteFolder",
-		method: "delete",
-		path: "/folders/:folderId"
-	});
-	const moveFolder = api.endpoint().paramsOf().bodyOf().responseOf().build({
-		id: "moveFolder",
-		method: "post",
-		path: "/folders/:folderId/move"
-	});
-	const getAssetsPage = api.endpoint().queryOf().paramsOf().responseOf().build({
-		id: "getAssetsPage",
-		method: "get",
-		path: "/projects/:projectId/assets/page"
-	});
-	const searchAssets = api.endpoint().paramsOf().queryOf().responseOf().build({
-		id: "searchAssets",
-		method: "get",
-		path: "/projects/:projectId/assets/search"
-	});
-	const getAsset = api.endpoint().paramsOf().responseOf().build({
-		id: "getAsset",
-		method: "get",
-		path: "/assets/:assetId"
-	});
-	const getAssetChildren = api.endpoint().paramsOf().queryOf().responseOf().build({
-		id: "getAssetChildren",
-		method: "get",
-		path: "/assets/:assetId/children"
-	});
-	const patchAsset = api.endpoint().paramsOf().bodyOf().responseOf().build({
-		id: "patchAsset",
-		method: "patch",
-		path: "/assets/:assetId"
-	});
-	const postUploadAsset = api.endpoint().bodyOf({ encoding: "multipart/form-data" }).paramsOf().queryOf().responseOf().build({
-		id: "postUploadAsset",
-		method: "post",
-		path: "/projects/:projectId/assets"
-	});
-	const postAssetSignedUrl = api.endpoint().bodyOf().paramsOf().responseOf().build({
-		id: "postAssetSignedUrl",
-		method: "post",
-		path: "/assets/:assetId/signed-url"
-	});
-	const postAssetPart = api.endpoint().bodyOf({ encoding: "multipart/form-data" }).paramsOf().queryOf().responseOf().build({
-		id: "postAssetPart",
-		method: "post",
-		path: "/assets/:assetId/part"
-	});
-	const moveAsset = api.endpoint().paramsOf().bodyOf().responseOf().build({
-		id: "moveAsset",
-		method: "post",
-		path: "/assets/:assetId/move"
-	});
-	const retryAsset = api.endpoint().paramsOf().responseOf().build({
-		id: "retryAsset",
-		method: "post",
-		path: "/assets/:assetId/retry"
-	});
-	const deleteAsset = api.endpoint().paramsOf().responseOf().build({
-		id: "deleteAsset",
-		method: "delete",
-		path: "/assets/:assetId"
-	});
-	const deleteAssetContent = api.endpoint().paramsOf().responseOf().build({
-		id: "deleteAssetContent",
-		method: "delete",
-		path: "/assets/:assetId/content"
-	});
-	const getEvents = api.endpoint().paramsOf().queryOf().responseOf().build({
-		id: "getEvents",
-		method: "get",
-		path: "/projects/:projectId/events"
-	});
-	const ensureLens = api.endpoint().bodyOf().paramsOf().responseOf().build({
-		id: "ensureLens",
-		method: "put",
-		path: "/lenses/:lensIdentifier"
-	});
-	const ensureLenses = api.endpoint().bodyOf().paramsOf().responseOf().build({
-		id: "ensureLenses",
-		method: "put",
-		path: "/projects/:projectId/lenses"
-	});
-	return encodePathParams({
-		getFolders,
-		getFolder,
-		postFolder,
-		patchFolder,
-		deleteFolder,
-		moveFolder,
-		getAssetsPage,
-		searchAssets,
-		getAsset,
-		getAssetChildren,
-		patchAsset,
-		postUploadAsset,
-		postAssetSignedUrl,
-		postAssetPart,
-		moveAsset,
-		retryAsset,
-		deleteAsset,
-		deleteAssetContent,
-		ensureLens,
-		ensureLenses,
-		getEvents
-	});
-};
+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");
 /**
-* api-def inserts `/:param` values into the path verbatim, so every endpoint encodes its path
-* params here: an ID can never add path segments, a query string or a fragment.
+* 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.
 */
-const encodePathParams = (endpoints) => {
-	for (const endpoint of Object.values(endpoints)) {
-		const submit = endpoint.submit.bind(endpoint);
-		endpoint.submit = (config) => submit(require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, config), {}, { params: config.params && Object.fromEntries(Object.entries(config.params).map(([key, value]) => [key, require_CalmLensUtils.encodePathSegment(value, key)])) }));
-	}
-	return endpoints;
-};
 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.
-	*
-	* @param options.payload - The raw request body, exactly as received (verify before parsing)
-	* @param options.signature - The 'x-calmlens-signature' header value
-	* @param options.timestamp - The 'x-calmlens-timestamp' header value
-	* @param options.secret - The connector's signing secret
-	* @param options.toleranceSeconds - Allowed clock distance in seconds (default 300)
-	* @param options.now - Override the current time (Date or epoch milliseconds), for tests
-	* @returns Promise<boolean> - True if the signature is valid and fresh, false otherwise
+	* Also exported as `verifyWebhookSignature`; `parseWebhookEvent` verifies and parses.
 	*
 	* @example
-	* ```javascript
-	* // In your webhook handler (e.g. a Fetch API Request)
+	* ```ts
 	* const payload = await request.text();
 	* const isValid = await CalmLensClient.verifyWebhookSignature({
 	*   payload,
-	*   signature: request.headers.get('x-calmlens-signature'),
-	*   timestamp: request.headers.get('x-calmlens-timestamp'),
-	*   secret: WEBHOOK_SECRET,
+	*   headers: request.headers,
+	*   secret: process.env.CALMLENS_WEBHOOK_SECRET!,
 	* });
-	*
-	* if (!isValid) {
-	*   return new Response('Unauthorized', { status: 401 });
-	* }
-	* const event = JSON.parse(payload); // { id, type, createdAt, projectId, data }
 	* ```
 	*/
-	static verifyWebhookSignature(options) {
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			return verifyWebhookSignature(options);
-		})();
+	static async verifyWebhookSignature(options) {
+		return require_CalmLensWebhooks.verifyWebhookSignature(options);
 	}
-	constructor(options) {
-		var _this$options$baseUrl, _this$options$cdnBase;
-		this.options = options;
-		this.ensuredLenses = /* @__PURE__ */ new Map();
-		this.pendingEnsureLenses = /* @__PURE__ */ new Map();
-		this.multipartImageUploadSizes = /* @__PURE__ */ new Map();
-		this.multipartUploadQueues = /* @__PURE__ */ new Map();
-		require_CalmLensUtils.validateClientOptions(options);
-		this.options = require_CalmLensUtils._objectSpread2({}, options);
-		this.options.baseUrl = (_this$options$baseUrl = this.options.baseUrl) !== null && _this$options$baseUrl !== void 0 ? _this$options$baseUrl : `https://api.${require_CalmLensUtils.DOMAIN}/v1`;
-		this.options.cdnBaseUrl = (_this$options$cdnBase = this.options.cdnBaseUrl) !== null && _this$options$cdnBase !== void 0 ? _this$options$cdnBase : `https://cdn.${require_CalmLensUtils.DOMAIN}/v1`;
-		this.api = createApi(this.options);
-		this.endpoints = createEndpoints(this.api);
+	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
+		});
 	}
-	/** Scope cancellation/timeout to an operation without changing this client's defaults. */
+	/**
+	* 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) {
-		const client = new CalmLensClient(require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, this.options), options));
-		client.multipartUploadQueues = this.multipartUploadQueues;
-		client.multipartImageUploadSizes = this.multipartImageUploadSizes;
-		return client;
+		require_CalmLensWebhooks.validateRequestOptions(options);
+		return new CalmLensClient({
+			...this.#state.options,
+			...options,
+			apiKey: this.#apiKey
+		}, this.#state);
 	}
-	getUploadFetch() {
-		var _this$options$request, _ref3, _this$options$uploadF;
-		const requestBackendFetch = (_this$options$request = this.options.requestBackend) === null || _this$options$request === void 0 ? void 0 : _this$options$request.fetch;
-		const fetchImpl = (_ref3 = (_this$options$uploadF = this.options.uploadFetch) !== null && _this$options$uploadF !== void 0 ? _this$options$uploadF : requestBackendFetch) !== null && _ref3 !== void 0 ? _ref3 : globalThis.fetch;
-		if (!fetchImpl) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.SDK_ERRORS.NO_CDN_FETCH);
-		return safeFetch(fetchImpl, this.options, { bufferBody: true });
+	/** 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)} }`;
 	}
-	submitRawAssetUpload(options, queue) {
-		var _this = this;
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			var _payload$sizeInBytes;
-			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 = payload.sizeInBytes) !== null && _payload$sizeInBytes !== void 0 ? _payload$sizeInBytes : require_CalmLensUtils.getAssetPayloadByteLength(payload));
-			if (isMultipart) {
-				var _part$partNumber, _part$isFinal, _part$sizeInBytes;
-				const part = payload;
-				const multipartOptions = options;
-				query.set("partNumber", String((_part$partNumber = part.partNumber) !== null && _part$partNumber !== void 0 ? _part$partNumber : 1));
-				query.set("isFinal", String((_part$isFinal = part.isFinal) !== null && _part$isFinal !== void 0 ? _part$isFinal : false));
-				setOptionalQueryValue(query, "sizeInBytes", (_part$sizeInBytes = part.sizeInBytes) !== null && _part$sizeInBytes !== void 0 ? _part$sizeInBytes : multipartOptions.sizeInBytes);
-			}
-			const baseUrl = _this.options.baseUrl.replace(/\/$/, "");
-			const path = isMultipart ? "assets/multipart-upload" : "assets/upload";
-			const url = `${baseUrl}/projects/${encodeURIComponent(_this.options.projectId)}/${path}?${query}`;
-			const response = yield _this.getUploadFetch()(url, {
-				method: "POST",
-				headers: {
-					"Content-Type": payload.type,
-					"X-Api-Key": _this.options.apiKey,
-					"X-CalmLens-Upload": isMultipart ? "part" : "content"
-				},
-				body: toRawUploadBody(payload),
-				duplex: "half"
-			});
-			const asset = yield _this.parseRawUploadResponse(response);
-			if (isMultipart && asset.status === "uploading") {
-				_this.multipartUploadQueues.set(asset.id, queue);
-				if (isImageMimeType(payload.type)) {
-					var _asset$sizeInBytes;
-					_this.multipartImageUploadSizes.set(asset.id, (_asset$sizeInBytes = asset.sizeInBytes) !== null && _asset$sizeInBytes !== void 0 ? _asset$sizeInBytes : 0);
-				}
-			}
-			return asset;
-		})();
+	toJSON() {
+		const { projectId, baseUrl, cdnBaseUrl } = this.#state.options;
+		return {
+			projectId,
+			baseUrl,
+			cdnBaseUrl
+		};
 	}
-	submitRawAssetPart(assetId, part, queue) {
-		var _this2 = this;
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			var _part$isFinal2, _part$sizeInBytes2;
-			const query = new URLSearchParams({
-				queue: String(queue),
-				partNumber: String(part.partNumber),
-				isFinal: String((_part$isFinal2 = part.isFinal) !== null && _part$isFinal2 !== void 0 ? _part$isFinal2 : false)
-			});
-			setOptionalQueryValue(query, "sizeInBytes", (_part$sizeInBytes2 = part.sizeInBytes) !== null && _part$sizeInBytes2 !== void 0 ? _part$sizeInBytes2 : require_CalmLensUtils.getAssetPayloadByteLength(part));
-			const url = `${_this2.options.baseUrl.replace(/\/$/, "")}/assets/${require_CalmLensUtils.encodePathSegment(assetId, "Asset ID")}/part?${query}`;
-			const response = yield _this2.getUploadFetch()(url, {
-				method: "POST",
-				headers: {
-					"X-Api-Key": _this2.options.apiKey,
-					"X-CalmLens-Upload": "part"
-				},
-				body: toRawUploadBody(part),
-				duplex: "half"
-			});
-			const asset = yield _this2.parseRawUploadResponse(response);
-			if (asset.status === "uploading") {
-				var _asset$sizeInBytes2;
-				_this2.multipartImageUploadSizes.set(asset.id, (_asset$sizeInBytes2 = asset.sizeInBytes) !== null && _asset$sizeInBytes2 !== void 0 ? _asset$sizeInBytes2 : 0);
-			} else {
-				_this2.multipartImageUploadSizes.delete(assetId);
-				_this2.multipartUploadQueues.delete(assetId);
-			}
-			return asset;
-		})();
+	get timeoutMs() {
+		return this.#state.options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 	}
-	parseRawUploadResponse(response) {
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			let data;
-			try {
-				data = yield response.json();
-			} catch (cause) {
-				throw require_CalmLensUtils.calmLensError({ id: response.ok ? "sdk/invalid-response" : "sdk/http-error" }, {
-					message: `Invalid JSON response (HTTP ${response.status})`,
-					status: response.status,
-					cause
-				});
-			}
-			if (!response.ok) {
-				if (isApiErrorPayload(data)) throw require_CalmLensUtils.calmLensError({
-					id: data.code,
-					defaultMessage: data.message
-				}, {
-					message: data.message,
-					status: response.status,
-					details: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, data.details), {}, {
-						traceId: data.traceId,
-						network: true
-					})
-				});
-				throw require_CalmLensUtils.calmLensError({ id: "sdk/http-error" }, {
-					message: `HTTP ${response.status}`,
-					status: response.status
-				});
-			}
-			if (!data || typeof data !== "object" || !("id" in data) || typeof data.id !== "string" || !data.id || !("status" in data) || ![
-				"uploading",
-				"pending",
-				"approved",
-				"rejected",
-				"error"
-			].includes(String(data.status))) throw require_CalmLensUtils.calmLensError({ id: "sdk/invalid-response" }, {
-				message: "Expected an asset response",
-				status: response.status
-			});
-			return data;
-		})();
+	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() {
-		var _this3 = this;
 		return {
 			/**
-			* Create a CDN URL for asset content or previews.
-			* Private assets require an authenticated request or signed URL.
+			* 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: (_ref4) => {
-				var _options$resource;
-				let { assetIdentifier } = _ref4, options = require_CalmLensUtils._objectWithoutProperties(_ref4, _excluded3);
-				if (!assetIdentifier) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset identifier is required" });
-				const resource = (_options$resource = options.resource) !== null && _options$resource !== void 0 ? _options$resource : "content";
-				const url = `${this.options.cdnBaseUrl.replace(/\/$/, "")}/assets/${encodeURIComponent(this.options.projectId)}/${require_CalmLensUtils.encodePathSegment(assetIdentifier, "Asset identifier")}/${resource}`;
-				return require_CalmLensUtils.appendCdnSelector(url, options);
+			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);
 			},
 			/**
-			* Fetch asset content or previews from the CDN.
-			* Private assets are authenticated with the client's API key.
+			* 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: function() {
-				var _ref6 = require_CalmLensUtils._asyncToGenerator(function* (_ref5) {
-					var _this$options$cdnFetc;
-					let { assetIdentifier, init } = _ref5, urlOptions = require_CalmLensUtils._objectWithoutProperties(_ref5, _excluded4);
-					const fetchImpl = (_this$options$cdnFetc = _this3.options.cdnFetch) !== null && _this$options$cdnFetc !== void 0 ? _this$options$cdnFetc : globalThis.fetch;
-					if (!fetchImpl) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.SDK_ERRORS.NO_CDN_FETCH);
-					return safeFetch(fetchImpl, _this3.options, { bufferBody: false })(_this3.cdn.getAssetUrl(require_CalmLensUtils._objectSpread2({ assetIdentifier }, urlOptions)), withApiKeyHeader(init, _this3.options.apiKey));
+			serve: async ({ assetIdentifier, init, ...urlOptions }) => {
+				const url = this.cdn.getAssetUrl({
+					assetIdentifier,
+					...urlOptions
 				});
-				return function serve(_x4) {
-					return _ref6.apply(this, arguments);
-				};
-			}()
+				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() {
-		var _this4 = this;
-		return { moderate: function() {
-			var _ref7 = require_CalmLensUtils._asyncToGenerator(function* (options) {
-				return _this4.assets.moderate(require_CalmLensUtils.toTextAssetOptions(options));
-			});
-			return function moderate(_x5) {
-				return _ref7.apply(this, arguments);
-			};
-		}() };
+		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() {
-		var _this5 = this;
 		return {
-			search: function() {
-				var _ref8 = require_CalmLensUtils._asyncToGenerator(function* (options) {
-					return (yield _this5.endpoints.searchAssets.submit({
-						params: { projectId: _this5.options.projectId },
-						query: options
-					})).data;
-				});
-				return function search(_x6) {
-					return _ref8.apply(this, arguments);
-				};
-			}(),
+			/** 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
+			} }),
 			/**
-			* List all assets for a project
-			* @param options - Pagination and filtering options
-			* @returns Promise with paginated assets
+			* 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.
 			*/
-			list: function() {
-				var _ref9 = require_CalmLensUtils._asyncToGenerator(function* (options = {}) {
-					var _options$pageIndex;
-					return (yield _this5.endpoints.getAssetsPage.submit({
-						params: { projectId: _this5.options.projectId },
-						query: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, options), {}, { pageIndex: (_options$pageIndex = options.pageIndex) !== null && _options$pageIndex !== void 0 ? _options$pageIndex : 0 })
-					})).data;
-				});
-				return function list() {
-					return _ref9.apply(this, arguments);
-				};
-			}(),
-			/**
-			* Retrieve a specific asset by ID
-			* @param assetId - The asset ID
-			* @returns Promise with asset data
-			*/
-			retrieve: function() {
-				var _ref10 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.getAsset.submit({ params: { assetId } })).data;
-				});
-				return function retrieve(_x7) {
-					return _ref10.apply(this, arguments);
-				};
-			}(),
-			update: function() {
-				var _ref12 = require_CalmLensUtils._asyncToGenerator(function* (_ref11) {
-					let { assetId } = _ref11, body = require_CalmLensUtils._objectWithoutProperties(_ref11, _excluded5);
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.patchAsset.submit({
-						params: { assetId },
-						body
-					})).data;
-				});
-				return function update(_x8) {
-					return _ref12.apply(this, arguments);
-				};
-			}(),
+			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
+				}));
+			},
 			/**
-			* Get child assets of a parent asset
-			* @param assetId - The parent asset ID
-			* @param options - Pagination options
-			* @returns Promise with paginated child assets
+			* 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`.
 			*/
-			listChildren: function() {
-				var _ref14 = require_CalmLensUtils._asyncToGenerator(function* (_ref13 = {}) {
-					var _options$pageIndex2;
-					let { assetId } = _ref13, options = require_CalmLensUtils._objectWithoutProperties(_ref13, _excluded6);
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.getAssetChildren.submit({
-						params: { assetId },
-						query: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, options), {}, { pageIndex: (_options$pageIndex2 = options.pageIndex) !== null && _options$pageIndex2 !== void 0 ? _options$pageIndex2 : 0 })
-					})).data;
-				});
-				return function listChildren() {
-					return _ref14.apply(this, arguments);
-				};
-			}(),
+			create: async (options) => this.submitAsset(options, true),
 			/**
-			* Submit a new asset for processing (queued asynchronously)
-			* The asset will be queued for classification and returned immediately.
-			* @param options - Asset submission options
-			* @returns Promise with created asset
+			* Uploads an asset and waits for its moderation decision. Audio and video still finish
+			* in the background. Retried safely with an `Idempotency-Key`.
 			*/
-			create: function() {
-				var _ref15 = require_CalmLensUtils._asyncToGenerator(function* (options) {
-					const body = prepareSubmitAssetOptions(options);
-					if ("content" in body || "part" in body) return yield _this5.submitRawAssetUpload(body, true);
-					return (yield _this5.endpoints.postUploadAsset.submit({
-						body: normalizeAssetOptionsForRequest(body),
-						params: { projectId: _this5.options.projectId },
-						query: { queue: true }
-					})).data;
-				});
-				return function create(_x9) {
-					return _ref15.apply(this, arguments);
-				};
-			}(),
+			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);
+			},
 			/**
-			* Submit a new asset and moderate it synchronously
-			* The asset will be classified immediately before the response is returned.
-			* This may take longer but ensures the asset is fully processed.
-			* @param options - Asset submission options
-			* @returns Promise with created and analyzed asset
+			* 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.
 			*/
-			moderate: function() {
-				var _ref16 = require_CalmLensUtils._asyncToGenerator(function* (options) {
-					if ("content" in options && "plainText" in options.content && (typeof options.content.plainText !== "string" || !options.content.plainText.trim())) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Text to moderate must be a non-empty string" });
-					const body = prepareSubmitAssetOptions(options);
-					if ("content" in body || "part" in body) return yield _this5.submitRawAssetUpload(body, false);
-					return (yield _this5.endpoints.postUploadAsset.submit({
-						body: normalizeAssetOptionsForRequest(body),
-						params: { projectId: _this5.options.projectId },
-						query: { queue: false }
-					})).data;
+			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
 				});
-				return function moderate(_x10) {
-					return _ref16.apply(this, arguments);
-				};
-			}(),
-			/**
-			* Upload a part for a multipart upload
-			* @param assetId - The asset ID
-			* @param part - The part to upload
-			* @returns Promise with asset data
-			*/
-			uploadPart: function() {
-				var _ref17 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId, part }) {
-					var _part$sizeInBytes3, _this$multipartUpload;
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					if (!part) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Part options are required" });
-					const validation = require_CalmLensUtils.validateAssetPayload(part, {
-						multipart: true,
-						isFinal: part.isFinal
-					});
-					if (!validation.ok) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
-					const existingImageSizeInBytes = _this5.multipartImageUploadSizes.get(assetId);
-					const partSizeInBytes = (_part$sizeInBytes3 = part.sizeInBytes) !== null && _part$sizeInBytes3 !== void 0 ? _part$sizeInBytes3 : require_CalmLensUtils.getAssetPayloadByteLength(part);
-					if (existingImageSizeInBytes !== void 0 && partSizeInBytes !== void 0) {
-						const totalSizeInBytes = existingImageSizeInBytes + partSizeInBytes;
-						if (totalSizeInBytes > require_CalmLensUtils.MAX_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE);
-						if (part.isFinal && totalSizeInBytes < require_CalmLensUtils.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL);
-					}
-					return yield _this5.submitRawAssetPart(assetId, part, (_this$multipartUpload = _this5.multipartUploadQueues.get(assetId)) !== null && _this$multipartUpload !== void 0 ? _this$multipartUpload : false);
+				if (!validation.ok) throw invalidPayload(validation.error);
+				const query = new URLSearchParams({
+					partNumber: String(part.partNumber),
+					isFinal: String(part.isFinal ?? false)
 				});
-				return function uploadPart(_x11) {
-					return _ref17.apply(this, arguments);
-				};
-			}(),
+				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);
+			},
 			/**
-			* Create a short-lived signed CDN URL for an asset.
-			* This is useful for private assets where clients should not send app
-			* auth cookies or API keys to the CDN on every media request.
+			* Creates a short-lived signed CDN URL, so browsers can load private content without
+			* an API key.
 			*/
-			createSignedUrl: function() {
-				var _ref19 = require_CalmLensUtils._asyncToGenerator(function* (_ref18) {
-					var _options$resource2, _options$expiresInSec;
-					let { assetId } = _ref18, options = require_CalmLensUtils._objectWithoutProperties(_ref18, _excluded7);
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					if (options.lens && options.transform) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Specify either a lens or a transform, not both" });
-					return (yield _this5.endpoints.postAssetSignedUrl.submit({
-						body: {
-							resource: (_options$resource2 = options.resource) !== null && _options$resource2 !== void 0 ? _options$resource2 : "content",
-							expiresInSeconds: (_options$expiresInSec = options.expiresInSeconds) !== null && _options$expiresInSec !== void 0 ? _options$expiresInSec : 900,
-							lens: options.lens,
-							transform: options.transform
-						},
-						params: { assetId }
-					})).data;
-				});
-				return function createSignedUrl(_x12) {
-					return _ref19.apply(this, arguments);
-				};
-			}(),
-			move: function() {
-				var _ref20 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId, folderId }) {
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.moveAsset.submit({
-						params: { assetId },
-						body: { folderId }
-					})).data;
-				});
-				return function move(_x13) {
-					return _ref20.apply(this, arguments);
-				};
-			}(),
+			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: 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: function() {
-				var _ref21 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.retryAsset.submit({ params: { assetId } })).data;
-				});
-				return function retry(_x14) {
-					return _ref21.apply(this, arguments);
-				};
-			}(),
+			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: function() {
-				var _ref22 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.deleteAssetContent.submit({ params: { assetId } })).data;
-				});
-				return function deleteContent(_x15) {
-					return _ref22.apply(this, arguments);
-				};
-			}(),
+			deleteContent: async ({ assetId }) => this.request("DELETE", `/assets/${requireId(assetId, "Asset ID")}/content`),
 			/** Deletes an asset record together with its stored content. */
-			delete: function() {
-				var _ref23 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					yield _this5.endpoints.deleteAsset.submit({ params: { assetId } });
-				});
-				return function _delete(_x16) {
-					return _ref23.apply(this, arguments);
-				};
-			}()
+			delete: async ({ assetId }) => {
+				await this.request("DELETE", `/assets/${requireId(assetId, "Asset ID")}`);
+			}
 		};
 	}
 	get events() {
-		var _this6 = this;
-		return { 
-		/**
-		* List 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: function() {
-			var _ref24 = require_CalmLensUtils._asyncToGenerator(function* (options = {}) {
-				return (yield _this6.endpoints.getEvents.submit({
-					params: { projectId: _this6.options.projectId },
-					query: options
-				})).data;
+		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
 			});
-			return function list() {
-				return _ref24.apply(this, arguments);
-			};
-		}() };
+			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() {
-		var _this7 = this;
 		return {
-			list: function() {
-				var _ref25 = require_CalmLensUtils._asyncToGenerator(function* () {
-					return (yield _this7.endpoints.getFolders.submit({ params: { projectId: _this7.options.projectId } })).data.folders;
-				});
-				return function list() {
-					return _ref25.apply(this, arguments);
-				};
-			}(),
-			retrieve: function() {
-				var _ref26 = require_CalmLensUtils._asyncToGenerator(function* ({ folderId }) {
-					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
-					return (yield _this7.endpoints.getFolder.submit({ params: { folderId } })).data;
-				});
-				return function retrieve(_x17) {
-					return _ref26.apply(this, arguments);
-				};
-			}(),
-			create: function() {
-				var _ref27 = require_CalmLensUtils._asyncToGenerator(function* (options) {
-					return (yield _this7.endpoints.postFolder.submit({
-						params: { projectId: _this7.options.projectId },
-						body: options
-					})).data;
-				});
-				return function create(_x18) {
-					return _ref27.apply(this, arguments);
-				};
-			}(),
-			update: function() {
-				var _ref29 = require_CalmLensUtils._asyncToGenerator(function* (_ref28) {
-					let { folderId } = _ref28, body = require_CalmLensUtils._objectWithoutProperties(_ref28, _excluded8);
-					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
-					return (yield _this7.endpoints.patchFolder.submit({
-						params: { folderId },
-						body
-					})).data;
-				});
-				return function update(_x19) {
-					return _ref29.apply(this, arguments);
-				};
-			}(),
-			delete: function() {
-				var _ref30 = require_CalmLensUtils._asyncToGenerator(function* ({ folderId }) {
-					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
-					yield _this7.endpoints.deleteFolder.submit({ params: { folderId } });
-				});
-				return function _delete(_x20) {
-					return _ref30.apply(this, arguments);
-				};
-			}(),
-			move: function() {
-				var _ref31 = require_CalmLensUtils._asyncToGenerator(function* ({ folderId, parentId }) {
-					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
-					return (yield _this7.endpoints.moveFolder.submit({
-						params: { folderId },
-						body: { parentId }
-					})).data;
-				});
-				return function move(_x21) {
-					return _ref31.apply(this, arguments);
-				};
-			}()
+			/** 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.
 	*/
-	ensureLens(options) {
-		var _this8 = this;
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			if (!options.identifier) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Lens identifier is required" });
-			const [lens] = yield _this8.ensureLenses({ lenses: [options] });
-			return lens;
-		})();
+	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().
 	*/
-	ensureLenses({ lenses }) {
-		var _this9 = this;
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			if (lenses.length === 0) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "At least one lens is required" });
-			if (lenses.some((option) => !option.identifier)) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Lens identifier is required" });
-			const missingOptions = [];
-			const missingKeys = /* @__PURE__ */ new Set();
-			for (const option of lenses) {
-				const cacheKey = getEnsureLensCacheKey(option);
-				if (!_this9.ensuredLenses.has(cacheKey) && !missingKeys.has(cacheKey)) {
-					missingKeys.add(cacheKey);
-					missingOptions.push(option);
-				}
+	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) return lenses.map((option) => _this9.ensuredLenses.get(getEnsureLensCacheKey(option)));
+		}
+		if (missingOptions.length > 0) {
 			const batchCacheKey = JSON.stringify([...missingKeys].sort());
-			let pending = _this9.pendingEnsureLenses.get(batchCacheKey);
+			let pending = pendingEnsureLenses.get(batchCacheKey);
 			if (!pending) {
-				pending = _this9.submitEnsureLenses(missingOptions);
-				_this9.pendingEnsureLenses.set(batchCacheKey, pending);
-				pending.then(() => _this9.pendingEnsureLenses.delete(batchCacheKey), () => _this9.pendingEnsureLenses.delete(batchCacheKey));
+				pending = this.submitEnsureLenses(missingOptions);
+				pendingEnsureLenses.set(batchCacheKey, pending);
+				pending.then(() => pendingEnsureLenses.delete(batchCacheKey), () => pendingEnsureLenses.delete(batchCacheKey));
 			}
-			yield pending;
-			return lenses.map((option) => _this9.ensuredLenses.get(getEnsureLensCacheKey(option)));
-		})();
+			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;
+		});
 	}
-	submitEnsureLenses(options) {
-		var _this10 = this;
-		return require_CalmLensUtils._asyncToGenerator(function* () {
-			const result = yield _this10.endpoints.ensureLenses.submit({
-				body: { lenses: options },
-				params: { projectId: _this10.options.projectId }
-			});
-			for (const [index, lens] of result.data.lenses.entries()) {
-				const optionsForLens = options[index];
-				if (!optionsForLens) throw require_CalmLensUtils.calmLensError({ id: "sdk/invalid-response" }, { message: "CalmLens returned an unexpected lens response" });
-				for (const [cacheKey, cachedLens] of _this10.ensuredLenses) if (cachedLens.identifier === optionsForLens.identifier) _this10.ensuredLenses.delete(cacheKey);
-				_this10.ensuredLenses.set(getEnsureLensCacheKey(optionsForLens), 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_CalmLensUtils.CalmLensError;
-exports.MEDIA_TEST_SIGNALS = MEDIA_TEST_SIGNALS;
-exports.WEBHOOK_DELIVERY_HEADER = WEBHOOK_DELIVERY_HEADER;
-exports.WEBHOOK_SIGNATURE_HEADER = WEBHOOK_SIGNATURE_HEADER;
-exports.WEBHOOK_SIGNATURE_TOLERANCE_SECONDS = WEBHOOK_SIGNATURE_TOLERANCE_SECONDS;
-exports.WEBHOOK_TIMESTAMP_HEADER = WEBHOOK_TIMESTAMP_HEADER;
-exports.createWebhookHeaders = createWebhookHeaders;
-exports.generateMediaTestCode = generateMediaTestCode;
-exports.toWebhookEventPayload = toWebhookEventPayload;
-exports.verifyWebhookSignature = verifyWebhookSignature;
+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;