@calmlens/sdk 0.9.0 → 0.10.0

package/esm/index.js

@@ -1,401 +1,326 @@
-import { C as _objectSpread2, S as _asyncToGenerator, a as validateClientOptions, b as getRawBase64, c as SDK_ERRORS, d as MAX_IMAGE_UPLOAD_BYTES, f as MIN_MULTIPART_IMAGE_UPLOAD_BYTES, g as stringifyJsonCanonical, h as PUBLIC_ERROR_CODES, i as toTextAssetOptions, l as calmLensError, m as isRejectedUploadMimeType, n as encodePathSegment, o as _objectWithoutProperties, p as getRejectedUploadMimeTypeError, r as stringifyQuery, s as CalmLensError, t as appendCdnSelector, u as DOMAIN, v as assetToData, x as validateAssetPayload, y as getAssetPayloadByteLength } from "./CalmLensUtils-Bnikzonc.js";
-import * as zod from "zod";
-import "zod/v4";
-import { Api, FetchRequestBackend, RequestCoalescingMiddleware, RequestEvent, getErrorResponse, isRequestError } from "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"
-	}
-};
+import { A as getRawBase64, C as MIN_MULTIPART_IMAGE_UPLOAD_BYTES, E as stringifyJsonCanonical, O as assetToData, S as MAX_IMAGE_UPLOAD_BYTES, T as isRejectedUploadMimeType, _ as invalidArgument, a as parseWebhookEvent, c as appendCdnSelector, d as toTextAssetOptions, f as validateClientOptions, g as SDK_ERROR_CODES, h as CalmLensError, i as WEBHOOK_TIMESTAMP_HEADER, j as validateAssetPayload, k as getAssetPayloadByteLength, l as encodePathSegment, m as CALMLENS_ERROR_CODES, n as WEBHOOK_SIGNATURE_HEADER, o as verifyWebhookSignature, p as validateRequestOptions, r as WEBHOOK_SIGNATURE_TOLERANCE_SECONDS, t as WEBHOOK_DELIVERY_HEADER, u as stringifyQuery, v as invalidConfig, w as getRejectedUploadMimeTypeError, y as API_ERROR_CODES } from "./CalmLensWebhooks-DLUozliX.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.0";
+const runtimeName = () => {
+	const runtime = globalThis;
+	if (runtime.Bun?.version) return `bun/${runtime.Bun.version}`;
+	if (runtime.Deno?.version?.deno) return `deno/${runtime.Deno.version.deno}`;
+	if (runtime.navigator?.userAgent === "Cloudflare-Workers") return "workerd";
+	if (runtime.process?.versions?.node) return `node/${runtime.process.versions.node}`;
+	return "unknown";
 };
-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 = _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 = _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 = _asyncToGenerator(function* (secret, timestamp, body) {
-		return `v1=${yield hmacSha256Hex(secret, `${timestamp}.${body}`)}`;
+/** Turns anything thrown while sending or reading a request into a `CalmLensError`. */
+const toFailure = (cause, attempt) => {
+	if (CalmLensError.isCalmLensError(cause)) return cause;
+	if (attempt.isCancelled()) return new CalmLensError(SDK_ERROR_CODES.CANCELLED, {
+		message: "Request cancelled",
+		cause
 	});
-	return function createWebhookSignatureHeader(_x, _x2, _x3) {
-		return _ref.apply(this, arguments);
-	};
-}();
-/** Headers for one signed delivery of `body`. */
-const createWebhookHeaders = function() {
-	var _ref2 = _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)
-		};
+	if (attempt.isTimedOut()) return new CalmLensError(SDK_ERROR_CODES.TIMEOUT, {
+		message: "Request timed out",
+		cause
 	});
-	return function createWebhookHeaders(_x4) {
-		return _ref2.apply(this, arguments);
+	return new CalmLensError(SDK_ERROR_CODES.TRANSPORT_ERROR, {
+		message: "Request failed",
+		cause
+	});
+};
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(new CalmLensError(SDK_ERROR_CODES.CANCELLED, { message: "Request cancelled" }));
+		return;
+	}
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(new CalmLensError(SDK_ERROR_CODES.CANCELLED, { message: "Request cancelled" }));
 	};
-}();
-/**
-* 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.
-*/
-function verifyWebhookSignature(_x5) {
-	return _verifyWebhookSignature.apply(this, arguments);
-}
-function _verifyWebhookSignature() {
-	_verifyWebhookSignature = _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 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 CalmLensError(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 CalmLensError(code, {
+			message: message ?? code,
+			...responseInfo(response),
+			details: details || traceId ? {
+				...details,
+				...traceId ? { traceId } : {}
+			} : void 0
+		});
+	}
+	return new CalmLensError(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: "error",
+					signal: attempt.signal,
+					duplex: "half"
+				});
+			} catch (cause) {
+				attempt.release();
+				const failure = toFailure(cause, attempt);
+				if (canRetryAgain && failure.code === 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 === 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 CalmLensError(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 _objectSpread2(_objectSpread2({}, payload), {}, { base64: getRawBase64(payload.base64) });
+	if ("base64" in payload && payload.base64) return {
+		...payload,
+		base64: getRawBase64(payload.base64)
+	};
 	if ("uint8Array" in payload && payload.uint8Array) {
-		const { uint8Array } = payload, rest = _objectWithoutProperties(payload, _excluded);
-		return _objectSpread2(_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 = _objectWithoutProperties(payload, _excluded2);
-		return _objectSpread2(_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 _objectSpread2(_objectSpread2({}, options), {}, { metadata: normalizeMetadataForMultipart(options.metadata) });
-};
-const normalizeAssetOptionsForRequest = (options) => {
-	const normalizedOptions = normalizeMetadataOptionsForRequest(options);
-	if ("part" in normalizedOptions) return _objectSpread2(_objectSpread2({}, normalizedOptions), {}, { part: normalizePayloadForRequest(normalizedOptions.part) });
-	if ("content" in normalizedOptions && !("plainText" in normalizedOptions.content)) return _objectSpread2(_objectSpread2({}, normalizedOptions), {}, { content: normalizePayloadForRequest(normalizedOptions.content) });
-	return normalizedOptions;
-};
 const toRawUploadBody = (payload) => {
 	const data = assetToData(normalizePayloadForRequest(payload));
 	if (data instanceof Response) {
-		if (!data.body) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Response upload data must have a body" });
+		if (!data.body) throw new CalmLensError(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;
@@ -406,913 +331,468 @@ 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 (isRejectedUploadMimeType(mimeType)) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+	if (isRejectedUploadMimeType(mimeType)) throw new CalmLensError(API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
 		message: getRejectedUploadMimeTypeError(mimeType),
 		details: { mimeType }
 	});
 };
 const isImageMimeType = (mimeType) => mimeType.toLowerCase().startsWith("image/");
+const invalidPayload = (message) => new CalmLensError(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
 const prepareSubmitAssetOptions = (options) => {
-	if (!("content" in options) && !("url" in options) && !("part" in options)) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Either file content, URL, or multipart part is required" });
-	if (!options.name) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Asset name is required" });
-	if (!("part" in options) && "isFinal" in options) throw calmLensError(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 calmLensError(PUBLIC_ERROR_CODES.USE_UPLOAD_PART);
+	if (!options || typeof options !== "object") throw 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 CalmLensError(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 = validateAssetPayload(options.content);
-			if (!validation.ok) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+			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 : getAssetPayloadByteLength(options.part);
+		const partSizeInBytes = options.part.sizeInBytes ?? getAssetPayloadByteLength(options.part);
 		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
-			if (partSizeInBytes > MAX_IMAGE_UPLOAD_BYTES) throw calmLensError(PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE);
-			if (options.part.isFinal && partSizeInBytes < MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw calmLensError(PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL);
+			if (partSizeInBytes > MAX_IMAGE_UPLOAD_BYTES) throw new CalmLensError(API_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE, { message: "Multipart image uploads cannot exceed 20MB." });
+			if (options.part.isFinal && partSizeInBytes < MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw new CalmLensError(API_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL, { message: "Multipart image uploads must total at least 10MB." });
 		}
 		const validation = validateAssetPayload(options.part, {
 			multipart: true,
 			isFinal: options.part.isFinal
 		});
-		if (!validation.ok) throw calmLensError(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 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 _objectSpread2(_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 = _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 = _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, _objectSpread2(_objectSpread2({}, init), {}, {
-				redirect: "error",
-				signal
-			}));
-			return bufferBody ? yield toBufferedResponse(response) : response;
-		} catch (cause) {
-			var _signal$reason;
-			throw 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({
-		name: "Calm Lens",
-		baseUrl: options.baseUrl,
-		config: { queryHandling: { stringify: stringifyQuery } },
-		middleware: [
-			RequestCoalescingMiddleware(),
-			{ beforeSend: (context) => {
-				context.updateHeaders({ "X-Api-Key": options.apiKey });
-			} },
-			{ [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 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 CalmLensError) return cause;
-		if (cause.name === "AbortError" || cause.name === "TimeoutError") return calmLensError({ id: cause.name === "TimeoutError" ? "sdk/timeout" : "sdk/cancelled" }, {
-			message: "Request aborted",
-			cause
-		});
-		cause = cause.cause;
-	}
-	const response = error instanceof Error ? getErrorResponse(error) : void 0;
-	if (error instanceof Error && isRequestError(error) && isApiErrorPayload(response === null || response === void 0 ? void 0 : response.data)) {
-		const { code, message, details, traceId } = response.data;
-		return calmLensError({
-			id: code,
-			defaultMessage: message
-		}, {
-			message,
-			status: response === null || response === void 0 ? void 0 : response.status,
-			cause: error,
-			details: _objectSpread2(_objectSpread2({}, details), {}, {
-				traceId,
-				network: true
-			})
-		});
-	}
-	if (error instanceof CalmLensError) return error;
-	return 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) => 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) => 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(_objectSpread2(_objectSpread2({}, config), {}, { params: config.params && Object.fromEntries(Object.entries(config.params).map(([key, value]) => [key, 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 _asyncToGenerator(function* () {
-			return verifyWebhookSignature(options);
-		})();
+	static async verifyWebhookSignature(options) {
+		return 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();
+	constructor(options, state) {
 		validateClientOptions(options);
-		this.options = _objectSpread2({}, options);
-		this.options.baseUrl = (_this$options$baseUrl = this.options.baseUrl) !== null && _this$options$baseUrl !== void 0 ? _this$options$baseUrl : `https://api.${DOMAIN}/v1`;
-		this.options.cdnBaseUrl = (_this$options$cdnBase = this.options.cdnBaseUrl) !== null && _this$options$cdnBase !== void 0 ? _this$options$cdnBase : `https://cdn.${DOMAIN}/v1`;
-		this.api = createApi(this.options);
-		this.endpoints = createEndpoints(this.api);
+		if (isBrowserRuntime() && !options.dangerouslyAllowBrowser) throw 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 CalmLensError(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(_objectSpread2(_objectSpread2({}, this.options), options));
-		client.multipartUploadQueues = this.multipartUploadQueues;
-		client.multipartImageUploadSizes = this.multipartImageUploadSizes;
-		return client;
+		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 calmLensError(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 _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 : 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 _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 : getAssetPayloadByteLength(part));
-			const url = `${_this2.options.baseUrl.replace(/\/$/, "")}/assets/${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 _asyncToGenerator(function* () {
-			let data;
-			try {
-				data = yield response.json();
-			} catch (cause) {
-				throw 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 calmLensError({
-					id: data.code,
-					defaultMessage: data.message
-				}, {
-					message: data.message,
-					status: response.status,
-					details: _objectSpread2(_objectSpread2({}, data.details), {}, {
-						traceId: data.traceId,
-						network: true
-					})
-				});
-				throw 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 calmLensError({ id: "sdk/invalid-response" }, {
-				message: "Expected an asset response",
-				status: response.status
-			});
-			return data;
-		})();
+	apiUrl(path, query) {
+		const search = query ? 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 ?? 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 CalmLensError(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 = _objectWithoutProperties(_ref4, _excluded3);
-				if (!assetIdentifier) throw 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)}/${encodePathSegment(assetIdentifier, "Asset identifier")}/${resource}`;
+			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 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 = _asyncToGenerator(function* (_ref5) {
-					var _this$options$cdnFetc;
-					let { assetIdentifier, init } = _ref5, urlOptions = _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 calmLensError(SDK_ERRORS.NO_CDN_FETCH);
-					return safeFetch(fetchImpl, _this3.options, { bufferBody: false })(_this3.cdn.getAssetUrl(_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 = _asyncToGenerator(function* (options) {
-				return _this4.assets.moderate(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(toTextAssetOptions(options)) };
 	}
 	get assets() {
-		var _this5 = this;
 		return {
-			search: function() {
-				var _ref8 = _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 = _asyncToGenerator(function* (options = {}) {
-					var _options$pageIndex;
-					return (yield _this5.endpoints.getAssetsPage.submit({
-						params: { projectId: _this5.options.projectId },
-						query: _objectSpread2(_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 = _asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw 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 = _asyncToGenerator(function* (_ref11) {
-					let { assetId } = _ref11, body = _objectWithoutProperties(_ref11, _excluded5);
-					if (!assetId) throw 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 = _asyncToGenerator(function* (_ref13 = {}) {
-					var _options$pageIndex2;
-					let { assetId } = _ref13, options = _objectWithoutProperties(_ref13, _excluded6);
-					if (!assetId) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					return (yield _this5.endpoints.getAssetChildren.submit({
-						params: { assetId },
-						query: _objectSpread2(_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 = _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 = _asyncToGenerator(function* (options) {
-					if ("content" in options && "plainText" in options.content && (typeof options.content.plainText !== "string" || !options.content.plainText.trim())) throw calmLensError(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 invalidArgument("Part options are required");
+				const validation = 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 = _asyncToGenerator(function* ({ assetId, part }) {
-					var _part$sizeInBytes3, _this$multipartUpload;
-					if (!assetId) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					if (!part) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Part options are required" });
-					const validation = validateAssetPayload(part, {
-						multipart: true,
-						isFinal: part.isFinal
-					});
-					if (!validation.ok) throw calmLensError(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 : getAssetPayloadByteLength(part);
-					if (existingImageSizeInBytes !== void 0 && partSizeInBytes !== void 0) {
-						const totalSizeInBytes = existingImageSizeInBytes + partSizeInBytes;
-						if (totalSizeInBytes > MAX_IMAGE_UPLOAD_BYTES) throw calmLensError(PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE);
-						if (part.isFinal && totalSizeInBytes < MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw calmLensError(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 ?? 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 = _asyncToGenerator(function* (_ref18) {
-					var _options$resource2, _options$expiresInSec;
-					let { assetId } = _ref18, options = _objectWithoutProperties(_ref18, _excluded7);
-					if (!assetId) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
-					if (options.lens && options.transform) throw 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 = _asyncToGenerator(function* ({ assetId, folderId }) {
-					if (!assetId) throw 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 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 = _asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw 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 = _asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw 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 = _asyncToGenerator(function* ({ assetId }) {
-					if (!assetId) throw 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 = _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 = _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 = _asyncToGenerator(function* ({ folderId }) {
-					if (!folderId) throw 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 = _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 = _asyncToGenerator(function* (_ref28) {
-					let { folderId } = _ref28, body = _objectWithoutProperties(_ref28, _excluded8);
-					if (!folderId) throw 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 = _asyncToGenerator(function* ({ folderId }) {
-					if (!folderId) throw 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 = _asyncToGenerator(function* ({ folderId, parentId }) {
-					if (!folderId) throw 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 _asyncToGenerator(function* () {
-			if (!options.identifier) throw 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 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 _asyncToGenerator(function* () {
-			if (lenses.length === 0) throw calmLensError({ id: "upload/invalid-payload" }, { message: "At least one lens is required" });
-			if (lenses.some((option) => !option.identifier)) throw 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 invalidArgument("At least one lens is required");
+		if (lenses.some((option) => !option?.identifier)) throw 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 CalmLensError(SDK_ERROR_CODES.INVALID_RESPONSE, { message: `CalmLens did not return lens "${option.identifier}"` });
+			return lens;
+		});
 	}
-	submitEnsureLenses(options) {
-		var _this10 = this;
-		return _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 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 CalmLensError(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 CalmLensError(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
-export { CalmLensClient, CalmLensError, MEDIA_TEST_SIGNALS, WEBHOOK_DELIVERY_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_TOLERANCE_SECONDS, WEBHOOK_TIMESTAMP_HEADER, createWebhookHeaders, generateMediaTestCode, toWebhookEventPayload, verifyWebhookSignature };
+export { CALMLENS_ERROR_CODES, CalmLensClient, CalmLensError, SDK_VERSION, WEBHOOK_DELIVERY_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_TOLERANCE_SECONDS, WEBHOOK_TIMESTAMP_HEADER, parseWebhookEvent, verifyWebhookSignature };