@calmlens/sdk 0.0.0-stage → 0.6.0

package/esm/index.js

@@ -0,0 +1,1240 @@
+import { _ as getRawBase64, a as SDK_ERRORS, b as _objectSpread2, c as MAX_IMAGE_UPLOAD_BYTES, d as isRejectedUploadMimeType, f as PUBLIC_ERROR_CODES, g as getAssetPayloadByteLength, h as assetToData, i as CalmLensError, l as MIN_MULTIPART_IMAGE_UPLOAD_BYTES, n as validateClientOptions, o as calmLensError, p as stringifyJsonCanonical, r as _objectWithoutProperties, s as DOMAIN, t as toTextAssetOptions, u as getRejectedUploadMimeTypeError, v as validateAssetPayload, y as _asyncToGenerator } from "./CalmLensUtils-UthMaLx_.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"
+	}
+};
+//#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);
+};
+createMetaType({ id: "docPropertyInfo" });
+//#endregion
+//#region ../shared/src/ZodUtils.ts
+const SIZE_LIMITS = {
+	small: 64,
+	medium: 200,
+	large: 1500
+};
+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$type;
+		const sizeLimit = 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"
+]);
+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 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;
+	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
+		}
+	};
+};
+const encoder = new TextEncoder();
+const hmacSha256Hex = function() {
+	var _ref = _asyncToGenerator(function* (secret, message) {
+		const key = yield crypto.subtle.importKey("raw", encoder.encode(secret), {
+			name: "HMAC",
+			hash: "SHA-256"
+		}, false, ["sign"]);
+		const signature = yield crypto.subtle.sign("HMAC", key, encoder.encode(message));
+		return Array.from(new Uint8Array(signature), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	});
+	return function hmacSha256Hex(_x, _x2) {
+		return _ref.apply(this, arguments);
+	};
+}();
+/** Constant-time comparison of two strings of the same length. */
+const timingSafeEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	let diff = 0;
+	for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+	return diff === 0;
+};
+/** `v1=<hex HMAC-SHA256 of "<timestamp>.<body>">`, the `x-calmlens-signature` header value. */
+const createWebhookSignatureHeader = function() {
+	var _ref2 = _asyncToGenerator(function* (secret, timestamp, body) {
+		return `v1=${yield hmacSha256Hex(secret, `${timestamp}.${body}`)}`;
+	});
+	return function createWebhookSignatureHeader(_x3, _x4, _x5) {
+		return _ref2.apply(this, arguments);
+	};
+}();
+/** Headers for one signed delivery of `body`. */
+const createWebhookHeaders = function() {
+	var _ref3 = _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(_x6) {
+		return _ref3.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.
+*/
+function verifyWebhookSignature(_x7) {
+	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;
+	});
+	return _verifyWebhookSignature.apply(this, arguments);
+}
+//#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 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 ("uint8Array" in payload && payload.uint8Array) {
+		const { uint8Array } = payload, rest = _objectWithoutProperties(payload, _excluded);
+		return _objectSpread2(_objectSpread2({}, 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)]) });
+	}
+	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" });
+		return data.body;
+	}
+	if (data instanceof ArrayBuffer || data instanceof Blob) return data;
+	if ("getReader" in data) return data;
+	return new Blob([toBlobPartBytes(data)]);
+};
+const setOptionalQueryValue = (params, key, value) => {
+	if (value !== void 0 && value !== null) params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+};
+const assertValidUploadMimeType = (mimeType) => {
+	if (isRejectedUploadMimeType(mimeType)) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+		message: getRejectedUploadMimeTypeError(mimeType),
+		details: { mimeType }
+	});
+};
+const isImageMimeType = (mimeType) => mimeType.toLowerCase().startsWith("image/");
+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 ("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 ("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);
+		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);
+		}
+		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 });
+	}
+	return options;
+};
+const appendCdnSelector = (url, options) => {
+	if (options.lens && options.transform) throw calmLensError({ id: "upload/invalid-payload" }, { message: "Specify either a lens or a transform, not both" });
+	if (options.lens) return `${url}/@${encodeURIComponent(options.lens)}`;
+	if (!options.transform) return url;
+	return `${url}/${encodeURI(options.transform.replace(/^\/+/, ""))}`;
+};
+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,
+		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 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 getEvents = api.endpoint().paramsOf().queryOf().responseOf().build({
+		id: "getEvents",
+		method: "get",
+		path: "/projects/:projectId/events"
+	});
+	return {
+		getFolders,
+		getFolder,
+		postFolder,
+		patchFolder,
+		deleteFolder,
+		moveFolder,
+		getAssetsPage,
+		getAsset,
+		getAssetChildren,
+		patchAsset,
+		postUploadAsset,
+		postAssetSignedUrl,
+		postAssetPart,
+		moveAsset,
+		retryAsset,
+		ensureLens: api.endpoint().bodyOf().paramsOf().responseOf().build({
+			id: "ensureLens",
+			method: "put",
+			path: "/lenses/:lensIdentifier"
+		}),
+		ensureLenses: api.endpoint().bodyOf().paramsOf().responseOf().build({
+			id: "ensureLenses",
+			method: "put",
+			path: "/projects/:projectId/lenses"
+		}),
+		getEvents
+	};
+};
+var CalmLensClient = class CalmLensClient {
+	/**
+	* 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
+	*
+	* @example
+	* ```javascript
+	* // In your webhook handler (e.g. a Fetch API Request)
+	* 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,
+	* });
+	*
+	* 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);
+		})();
+	}
+	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();
+		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);
+	}
+	/** Scope cancellation/timeout to an operation without changing this client's defaults. */
+	withRequestOptions(options) {
+		const client = new CalmLensClient(_objectSpread2(_objectSpread2({}, this.options), options));
+		client.multipartUploadQueues = this.multipartUploadQueues;
+		client.multipartImageUploadSizes = this.multipartImageUploadSizes;
+		return client;
+	}
+	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 });
+	}
+	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;
+		})();
+	}
+	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/${encodeURIComponent(assetId)}/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;
+		})();
+	}
+	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;
+		})();
+	}
+	get cdn() {
+		var _this3 = this;
+		return {
+			/**
+			* Create a CDN URL for asset content or previews.
+			* Private assets require an authenticated request or signed URL.
+			*/
+			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)}/${encodeURIComponent(assetIdentifier)}/${resource}`;
+				return appendCdnSelector(url, options);
+			},
+			/**
+			* Fetch asset content or previews from the CDN.
+			* Private assets are authenticated with the client's API key.
+			*/
+			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));
+				});
+				return function serve(_x4) {
+					return _ref6.apply(this, arguments);
+				};
+			}()
+		};
+	}
+	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);
+			};
+		}() };
+	}
+	get assets() {
+		var _this5 = this;
+		return {
+			/**
+			* List all assets for a project
+			* @param options - Pagination and filtering options
+			* @returns Promise with paginated assets
+			*/
+			list: function() {
+				var _ref8 = _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(_x6) {
+					return _ref8.apply(this, arguments);
+				};
+			}(),
+			/**
+			* Retrieve a specific asset by ID
+			* @param assetId - The asset ID
+			* @returns Promise with asset data
+			*/
+			retrieve: function() {
+				var _ref9 = _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 _ref9.apply(this, arguments);
+				};
+			}(),
+			update: function() {
+				var _ref11 = _asyncToGenerator(function* (_ref10) {
+					let { assetId } = _ref10, body = _objectWithoutProperties(_ref10, _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 _ref11.apply(this, arguments);
+				};
+			}(),
+			/**
+			* Get child assets of a parent asset
+			* @param assetId - The parent asset ID
+			* @param options - Pagination options
+			* @returns Promise with paginated child assets
+			*/
+			listChildren: function() {
+				var _ref13 = _asyncToGenerator(function* (_ref12) {
+					var _options$pageIndex2;
+					let { assetId } = _ref12, options = _objectWithoutProperties(_ref12, _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(_x9) {
+					return _ref13.apply(this, arguments);
+				};
+			}(),
+			/**
+			* 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
+			*/
+			create: function() {
+				var _ref14 = _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(_x10) {
+					return _ref14.apply(this, arguments);
+				};
+			}(),
+			/**
+			* 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
+			*/
+			moderate: function() {
+				var _ref15 = _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;
+				});
+				return function moderate(_x11) {
+					return _ref15.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 _ref16 = _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);
+				});
+				return function uploadPart(_x12) {
+					return _ref16.apply(this, arguments);
+				};
+			}(),
+			/**
+			* 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.
+			*/
+			createSignedUrl: function() {
+				var _ref18 = _asyncToGenerator(function* (_ref17) {
+					var _options$resource2, _options$expiresInSec;
+					let { assetId } = _ref17, options = _objectWithoutProperties(_ref17, _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(_x13) {
+					return _ref18.apply(this, arguments);
+				};
+			}(),
+			move: function() {
+				var _ref19 = _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(_x14) {
+					return _ref19.apply(this, arguments);
+				};
+			}(),
+			/**
+			* 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 _ref20 = _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(_x15) {
+					return _ref20.apply(this, arguments);
+				};
+			}()
+		};
+	}
+	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 _ref21 = _asyncToGenerator(function* (options = {}) {
+				return (yield _this6.endpoints.getEvents.submit({
+					params: { projectId: _this6.options.projectId },
+					query: options
+				})).data;
+			});
+			return function list() {
+				return _ref21.apply(this, arguments);
+			};
+		}() };
+	}
+	get folders() {
+		var _this7 = this;
+		return {
+			list: function() {
+				var _ref22 = _asyncToGenerator(function* () {
+					return (yield _this7.endpoints.getFolders.submit({ params: { projectId: _this7.options.projectId } })).data.folders;
+				});
+				return function list() {
+					return _ref22.apply(this, arguments);
+				};
+			}(),
+			retrieve: function() {
+				var _ref23 = _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(_x16) {
+					return _ref23.apply(this, arguments);
+				};
+			}(),
+			create: function() {
+				var _ref24 = _asyncToGenerator(function* (options) {
+					return (yield _this7.endpoints.postFolder.submit({
+						params: { projectId: _this7.options.projectId },
+						body: options
+					})).data;
+				});
+				return function create(_x17) {
+					return _ref24.apply(this, arguments);
+				};
+			}(),
+			update: function() {
+				var _ref26 = _asyncToGenerator(function* (_ref25) {
+					let { folderId } = _ref25, body = _objectWithoutProperties(_ref25, _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(_x18) {
+					return _ref26.apply(this, arguments);
+				};
+			}(),
+			delete: function() {
+				var _ref27 = _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(_x19) {
+					return _ref27.apply(this, arguments);
+				};
+			}(),
+			move: function() {
+				var _ref28 = _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(_x20) {
+					return _ref28.apply(this, arguments);
+				};
+			}()
+		};
+	}
+	/**
+	* 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;
+		})();
+	}
+	/**
+	* 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);
+				}
+			}
+			if (missingOptions.length === 0) return lenses.map((option) => _this9.ensuredLenses.get(getEnsureLensCacheKey(option)));
+			const batchCacheKey = JSON.stringify([...missingKeys].sort());
+			let pending = _this9.pendingEnsureLenses.get(batchCacheKey);
+			if (!pending) {
+				pending = _this9.submitEnsureLenses(missingOptions);
+				_this9.pendingEnsureLenses.set(batchCacheKey, pending);
+				pending.then(() => _this9.pendingEnsureLenses.delete(batchCacheKey), () => _this9.pendingEnsureLenses.delete(batchCacheKey));
+			}
+			yield pending;
+			return lenses.map((option) => _this9.ensuredLenses.get(getEnsureLensCacheKey(option)));
+		})();
+	}
+	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);
+			}
+		})();
+	}
+};
+//#endregion
+export { CalmLensClient, CalmLensError, MEDIA_TEST_SIGNALS, WEBHOOK_DELIVERY_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_SIGNATURE_TOLERANCE_SECONDS, WEBHOOK_TIMESTAMP_HEADER, createWebhookHeaders, generateMediaTestCode, toWebhookEventPayload, verifyWebhookSignature };