@calmlens/sdk 0.0.0-stage → 0.5.0

package/cjs/index.js

@@ -0,0 +1,1206 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_CalmLensUtils = require("./CalmLensUtils-0QaxbI3A.js");
+let zod = require("zod");
+zod = require_CalmLensUtils.__toESM(zod);
+require("zod/v4");
+let api_def = require("api-def");
+//#region ../shared/src/ModerationCategoryDefinitions.ts
+const MODERATION_CATEGORY_DEFINITIONS = {
+	sexual: {
+		summary: "Sexual acts, explicit sexual anatomy, sexual services, sexual assault depictions and clearly erotic material.",
+		definition: "covers sexual acts, explicit sexual anatomy, sexual services and clearly erotic material. Descriptions of sexual assault can qualify without erotic intent. Fictional, illustrated and generated depictions can also qualify.",
+		exclusions: "Ordinary affection, swimwear, fitness, fashion, non-erotic medical diagrams and general sexual-health education do not qualify on their own. A person accepting money or wearing revealing clothing does not establish sexual content without a qualifying act, display or offer.",
+		docsHref: "/docs/guides/moderation-categories#sexual-content"
+	},
+	violence: {
+		summary: "Physical attacks, injury, death, threats against others, and planning or encouraging physical violence.",
+		definition: "covers physical attacks, bodily injury, death and threats against others. Accidental or medical injuries and natural death also count; an attacker or intent to harm is not required. It also includes planning, requesting, encouraging or praising physical violence. A depicted or described act can qualify in fiction or news reporting even when the author condemns it.",
+		exclusions: "Solely intentional self-injury or suicide belongs under self-harm. Property damage alone, figurative language, abstract discussion of violence, injury or death and merely possessing a weapon do not establish violence. Consensual sport or training without injury or abuse is excluded.",
+		docsHref: "/docs/guides/moderation-categories#violence"
+	},
+	"self-harm": {
+		summary: "Intentional self-injury, suicide, preparation, methods or encouragement; text also includes current or recurring self-harm thoughts.",
+		definition: "covers intentional self-injury, suicide, current self-harm risk, preparation, methods and encouragement. For text, it also includes current or recurring self-harm thoughts and an explicitly expressed desire to die. Asking for support does not cancel a separate disclosure of current risk or behavior.",
+		exclusions: "For images, require evidence of a self-directed act, preparation, harmful methods or encouragement. An injury or covered body does not establish that harm was self-inflicted. General sadness, neutral statistics, prevention, recovery and healed scars alone are excluded.",
+		docsHref: "/docs/guides/moderation-categories#self-harm"
+	},
+	harassment: {
+		summary: "Targeted personal abuse, humiliation, bullying or serious intimidation; ordinary criticism and neutral reporting are excluded.",
+		definition: "covers personal abuse, humiliation, bullying and serious intimidation directed at a person or identifiable group. The target can be named, implied or defined by an activity or affiliation. A protected identity is not required.",
+		exclusions: "Disagreement, ordinary criticism of conduct or competence, untargeted profanity and neutral reporting of abuse do not qualify without a separate personal attack. Criticism can still qualify when it also contains personal degradation.",
+		docsHref: "/docs/guides/moderation-categories#harassment-and-bullying"
+	},
+	hate: {
+		summary: "Identity-based abuse, dehumanization, discriminatory exclusion or threats against people because of protected characteristics.",
+		definition: "covers attacks on people because of race, ethnicity, nationality, religion, caste, sex, gender identity, sexual orientation or disability. It includes dehumanization, asserted inferiority, discriminatory exclusion, identity-based abuse and threats.",
+		exclusions: "Both the protected target and the identity-based attack must be supported. Identity mentions, cultural clothing, religious imagery, criticism of beliefs or an unrelated threat do not establish hate. Neutral reporting, condemnation and opposition to hate are excluded unless a separate attack is expressed or endorsed.",
+		docsHref: "/docs/guides/moderation-categories#hate-and-identity-abuse"
+	},
+	"criminal-activity": {
+		summary: "Planning, assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act.",
+		definition: "covers planning, requests for assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act. A request can qualify even when no act occurs and a later reply refuses it. Dangerous activity requires a concrete serious risk of physical harm.",
+		exclusions: "Neutral reporting, prevention, lawful safety advice, fiction without criminal assistance, and vague dangerous references do not qualify. Masks, computers, payment cards, detention or ordinary tools do not establish criminal facilitation by themselves. A clear visual demonstration of how to carry out a crime can qualify.",
+		docsHref: "/docs/guides/moderation-categories#criminal-and-dangerous-activity"
+	}
+};
+//#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"
+			]),
+			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;
+const encoder = new TextEncoder();
+const hmacSha256Hex = function() {
+	var _ref = require_CalmLensUtils._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 = require_CalmLensUtils._asyncToGenerator(function* (secret, timestamp, body) {
+		return `v1=${yield hmacSha256Hex(secret, `${timestamp}.${body}`)}`;
+	});
+	return function createWebhookSignatureHeader(_x3, _x4, _x5) {
+		return _ref2.apply(this, arguments);
+	};
+}();
+(function() {
+	var _ref3 = require_CalmLensUtils._asyncToGenerator(function* (options) {
+		var _options$timestampSec;
+		const timestamp = (_options$timestampSec = options.timestampSeconds) !== null && _options$timestampSec !== void 0 ? _options$timestampSec : Math.floor(Date.now() / 1e3);
+		return {
+			"content-type": "application/json",
+			[WEBHOOK_DELIVERY_HEADER]: options.deliveryId,
+			[WEBHOOK_TIMESTAMP_HEADER]: String(timestamp),
+			[WEBHOOK_SIGNATURE_HEADER]: yield createWebhookSignatureHeader(options.secret, timestamp, options.body)
+		};
+	});
+	return function createWebhookHeaders(_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 = require_CalmLensUtils._asyncToGenerator(function* ({ payload, signature, timestamp, secret, toleranceSeconds = 300, now }) {
+		if (!secret || !signature || timestamp === null || timestamp === void 0) return false;
+		const timestampText = String(timestamp).trim();
+		if (!/^\d+$/.test(timestampText)) return false;
+		const nowMs = now === void 0 ? Date.now() : now instanceof Date ? now.getTime() : now;
+		if (Math.abs(Math.floor(nowMs / 1e3) - Number(timestampText)) > toleranceSeconds) return false;
+		const candidates = signature.split(",").map((part) => part.trim()).filter((part) => part.startsWith("v1=")).map((part) => part.slice(3).toLowerCase());
+		if (candidates.length === 0) return false;
+		const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+		const expected = yield hmacSha256Hex(secret, `${timestampText}.${body}`);
+		let matched = false;
+		for (const candidate of candidates) if (timingSafeEqual(expected, candidate)) matched = true;
+		return matched;
+	});
+	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 require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, payload), {}, { base64: require_CalmLensUtils.getRawBase64(payload.base64) });
+	if ("uint8Array" in payload && payload.uint8Array) {
+		const { uint8Array } = payload, rest = require_CalmLensUtils._objectWithoutProperties(payload, _excluded);
+		return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, rest), {}, { data: new Blob([toBlobPartBytes(uint8Array)]) });
+	}
+	if ("buffer" in payload && payload.buffer) {
+		const { buffer } = payload, rest = require_CalmLensUtils._objectWithoutProperties(payload, _excluded2);
+		return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, rest), {}, { data: new Blob([toBlobPartBytes(buffer)]) });
+	}
+	return payload;
+};
+const normalizeMetadataForMultipart = (metadata) => {
+	if (!Array.isArray(metadata)) return metadata;
+	return Object.fromEntries(metadata.map((item, index) => [index, item]));
+};
+const normalizeMetadataOptionsForRequest = (options) => {
+	if (!("metadata" in options) || !Array.isArray(options.metadata)) return options;
+	return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, options), {}, { metadata: normalizeMetadataForMultipart(options.metadata) });
+};
+const normalizeAssetOptionsForRequest = (options) => {
+	const normalizedOptions = normalizeMetadataOptionsForRequest(options);
+	if ("part" in normalizedOptions) return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, normalizedOptions), {}, { part: normalizePayloadForRequest(normalizedOptions.part) });
+	if ("content" in normalizedOptions && !("plainText" in normalizedOptions.content)) return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, normalizedOptions), {}, { content: normalizePayloadForRequest(normalizedOptions.content) });
+	return normalizedOptions;
+};
+const toRawUploadBody = (payload) => {
+	const data = require_CalmLensUtils.assetToData(normalizePayloadForRequest(payload));
+	if (data instanceof Response) {
+		if (!data.body) throw require_CalmLensUtils.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 (require_CalmLensUtils.isRejectedUploadMimeType(mimeType)) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+		message: require_CalmLensUtils.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 require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Either file content, URL, or multipart part is required" });
+	if (!options.name) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset name is required" });
+	if (!("part" in options) && "isFinal" in options) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "isFinal is only valid for multipart uploads" });
+	if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.USE_UPLOAD_PART);
+	if ("content" in options) {
+		assertValidUploadMimeType(options.content.type);
+		if (!("plainText" in options.content)) {
+			const validation = require_CalmLensUtils.validateAssetPayload(options.content);
+			if (!validation.ok) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+		}
+	}
+	if ("part" in options) {
+		var _options$part$sizeInB;
+		assertValidUploadMimeType(options.part.type);
+		const partSizeInBytes = (_options$part$sizeInB = options.part.sizeInBytes) !== null && _options$part$sizeInB !== void 0 ? _options$part$sizeInB : require_CalmLensUtils.getAssetPayloadByteLength(options.part);
+		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
+			if (partSizeInBytes > require_CalmLensUtils.MAX_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE);
+			if (options.part.isFinal && partSizeInBytes < require_CalmLensUtils.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL);
+		}
+		const validation = require_CalmLensUtils.validateAssetPayload(options.part, {
+			multipart: true,
+			isFinal: options.part.isFinal
+		});
+		if (!validation.ok) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+	}
+	return options;
+};
+const appendCdnSelector = (url, options) => {
+	if (options.lens && options.transform) throw require_CalmLensUtils.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 require_CalmLensUtils.stringifyJsonCanonical({
+		identifier: options.identifier,
+		name: options.name,
+		description: (_options$description = options.description) !== null && _options$description !== void 0 ? _options$description : null,
+		type: options.type,
+		active: options.active,
+		transforms: (_options$transforms = options.transforms) !== null && _options$transforms !== void 0 ? _options$transforms : null,
+		version: options.version
+	});
+};
+const withApiKeyHeader = (init, apiKey) => {
+	const headers = new Headers(init === null || init === void 0 ? void 0 : init.headers);
+	headers.set("X-Api-Key", apiKey);
+	return require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, init), {}, {
+		redirect: "error",
+		headers: Object.fromEntries(headers.entries())
+	});
+};
+const requestSignal = (options, signal) => {
+	var _options$timeoutMs;
+	const signals = [
+		options.signal,
+		signal,
+		AbortSignal.timeout((_options$timeoutMs = options.timeoutMs) !== null && _options$timeoutMs !== void 0 ? _options$timeoutMs : 12e4)
+	].filter((value) => value != null);
+	return AbortSignal.any(signals);
+};
+const safeFetch = (fetchImpl, options) => function() {
+	var _ref = require_CalmLensUtils._asyncToGenerator(function* (input, init) {
+		var _init$signal;
+		const signal = requestSignal(options, (_init$signal = init === null || init === void 0 ? void 0 : init.signal) !== null && _init$signal !== void 0 ? _init$signal : input instanceof Request ? input.signal : void 0);
+		try {
+			signal.throwIfAborted();
+			return yield fetchImpl(input, require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, init), {}, {
+				redirect: "error",
+				signal
+			}));
+		} catch (cause) {
+			var _signal$reason;
+			throw require_CalmLensUtils.calmLensError({ id: signal.aborted ? ((_signal$reason = signal.reason) === null || _signal$reason === void 0 ? void 0 : _signal$reason.name) === "TimeoutError" ? "sdk/timeout" : "sdk/cancelled" : "sdk/transport-error" }, {
+				message: signal.aborted ? "Request aborted" : "Request failed",
+				cause
+			});
+		}
+	});
+	return function(_x, _x2) {
+		return _ref.apply(this, arguments);
+	};
+}();
+const createApi = (options) => {
+	return new api_def.Api({
+		name: "Calm Lens",
+		baseUrl: options.baseUrl,
+		middleware: [
+			(0, api_def.RequestCoalescingMiddleware)(),
+			{ beforeSend: (context) => {
+				context.updateHeaders({ "X-Api-Key": options.apiKey });
+			} },
+			{ [api_def.RequestEvent.ERROR]: (context) => {
+				if (context.error) throw normalizeApiError(context.error);
+			} }
+		],
+		requestBackend: options.requestBackend ? Object.assign(Object.create(options.requestBackend), "fetch" in options.requestBackend && typeof options.requestBackend.fetch === "function" ? { fetch: safeFetch(options.requestBackend.fetch, options) } : {}) : new api_def.FetchRequestBackend(safeFetch(globalThis.fetch, options))
+	});
+};
+const isApiErrorPayload = (value) => {
+	return !!value && typeof value === "object" && typeof value.code === "string";
+};
+const normalizeApiError = (error) => {
+	let cause = error;
+	const seen = /* @__PURE__ */ new Set();
+	while (cause instanceof Error && !seen.has(cause)) {
+		seen.add(cause);
+		if (cause instanceof require_CalmLensUtils.CalmLensError) return cause;
+		if (cause.name === "AbortError" || cause.name === "TimeoutError") return require_CalmLensUtils.calmLensError({ id: cause.name === "TimeoutError" ? "sdk/timeout" : "sdk/cancelled" }, {
+			message: "Request aborted",
+			cause
+		});
+		cause = cause.cause;
+	}
+	const response = error instanceof Error ? (0, api_def.getErrorResponse)(error) : void 0;
+	if (error instanceof Error && (0, api_def.isRequestError)(error) && isApiErrorPayload(response === null || response === void 0 ? void 0 : response.data)) {
+		const { code, message, details, traceId } = response.data;
+		return require_CalmLensUtils.calmLensError({
+			id: code,
+			defaultMessage: message
+		}, {
+			message,
+			status: response === null || response === void 0 ? void 0 : response.status,
+			cause: error,
+			details: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, details), {}, {
+				traceId,
+				network: true
+			})
+		});
+	}
+	if (error instanceof require_CalmLensUtils.CalmLensError) return error;
+	return require_CalmLensUtils.calmLensError({ id: response ? response.ok ? "sdk/invalid-response" : "sdk/http-error" : "sdk/transport-error" }, {
+		message: response ? `HTTP ${response.status}` : error.message,
+		status: response === null || response === void 0 ? void 0 : response.status,
+		cause: error
+	});
+};
+const createEndpoints = (api) => {
+	const getFolders = api.endpoint().paramsOf().responseOf().build({
+		id: "getFolders",
+		method: "get",
+		path: "/projects/:projectId/folders"
+	});
+	const getFolder = api.endpoint().paramsOf().responseOf().build({
+		id: "getFolder",
+		method: "get",
+		path: "/folders/:folderId"
+	});
+	const postFolder = api.endpoint().paramsOf().bodyOf().responseOf().build({
+		id: "postFolder",
+		method: "post",
+		path: "/projects/:projectId/folders"
+	});
+	const patchFolder = api.endpoint().paramsOf().bodyOf().responseOf().build({
+		id: "patchFolder",
+		method: "patch",
+		path: "/folders/:folderId"
+	});
+	const deleteFolder = api.endpoint().paramsOf().responseOf().build({
+		id: "deleteFolder",
+		method: "delete",
+		path: "/folders/:folderId"
+	});
+	const moveFolder = api.endpoint().paramsOf().bodyOf().responseOf().build({
+		id: "moveFolder",
+		method: "post",
+		path: "/folders/:folderId/move"
+	});
+	const getAssetsPage = api.endpoint().queryOf().paramsOf().responseOf().build({
+		id: "getAssetsPage",
+		method: "get",
+		path: "/projects/:projectId/assets/page"
+	});
+	const 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 require_CalmLensUtils._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();
+		if (!options.apiKey) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "API key is required" });
+		if (!options.projectId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Project ID is required" });
+		if (options.timeoutMs !== void 0 && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0)) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "timeoutMs must be a positive integer" });
+		this.options = require_CalmLensUtils._objectSpread2({}, options);
+		this.options.baseUrl = (_this$options$baseUrl = this.options.baseUrl) !== null && _this$options$baseUrl !== void 0 ? _this$options$baseUrl : `https://api.${require_CalmLensUtils.DOMAIN}/v1`;
+		this.options.cdnBaseUrl = (_this$options$cdnBase = this.options.cdnBaseUrl) !== null && _this$options$cdnBase !== void 0 ? _this$options$cdnBase : `https://cdn.${require_CalmLensUtils.DOMAIN}/v1`;
+		this.api = createApi(this.options);
+		this.endpoints = createEndpoints(this.api);
+	}
+	/** Scope cancellation/timeout to an operation without changing this client's defaults. */
+	withRequestOptions(options) {
+		const client = new CalmLensClient(require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, this.options), options));
+		client.multipartUploadQueues = this.multipartUploadQueues;
+		client.multipartImageUploadSizes = this.multipartImageUploadSizes;
+		return client;
+	}
+	getUploadFetch() {
+		var _this$options$request, _ref2, _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 = (_ref2 = (_this$options$uploadF = this.options.uploadFetch) !== null && _this$options$uploadF !== void 0 ? _this$options$uploadF : requestBackendFetch) !== null && _ref2 !== void 0 ? _ref2 : globalThis.fetch;
+		if (!fetchImpl) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.SDK_ERRORS.NO_CDN_FETCH);
+		return safeFetch(fetchImpl, this.options);
+	}
+	submitRawAssetUpload(options, queue) {
+		var _this = this;
+		return require_CalmLensUtils._asyncToGenerator(function* () {
+			var _payload$sizeInBytes;
+			const query = new URLSearchParams();
+			query.set("name", options.name);
+			query.set("queue", String(queue));
+			setOptionalQueryValue(query, "description", options.description);
+			setOptionalQueryValue(query, "processingOptions", options.processingOptions);
+			setOptionalQueryValue(query, "visibility", options.visibility);
+			setOptionalQueryValue(query, "metadata", options.metadata);
+			setOptionalQueryValue(query, "externalId", options.externalId);
+			setOptionalQueryValue(query, "externalUrl", options.externalUrl);
+			setOptionalQueryValue(query, "folderId", options.folderId);
+			const isMultipart = "part" in options;
+			const payload = isMultipart ? options.part : options.content;
+			query.set("contentType", payload.type);
+			setOptionalQueryValue(query, "sizeInBytes", (_payload$sizeInBytes = payload.sizeInBytes) !== null && _payload$sizeInBytes !== void 0 ? _payload$sizeInBytes : require_CalmLensUtils.getAssetPayloadByteLength(payload));
+			if (isMultipart) {
+				var _part$partNumber, _part$isFinal, _part$sizeInBytes;
+				const part = payload;
+				const multipartOptions = options;
+				query.set("partNumber", String((_part$partNumber = part.partNumber) !== null && _part$partNumber !== void 0 ? _part$partNumber : 1));
+				query.set("isFinal", String((_part$isFinal = part.isFinal) !== null && _part$isFinal !== void 0 ? _part$isFinal : false));
+				setOptionalQueryValue(query, "sizeInBytes", (_part$sizeInBytes = part.sizeInBytes) !== null && _part$sizeInBytes !== void 0 ? _part$sizeInBytes : multipartOptions.sizeInBytes);
+			}
+			const baseUrl = _this.options.baseUrl.replace(/\/$/, "");
+			const path = isMultipart ? "assets/multipart-upload" : "assets/upload";
+			const url = `${baseUrl}/projects/${encodeURIComponent(_this.options.projectId)}/${path}?${query}`;
+			const response = yield _this.getUploadFetch()(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": payload.type,
+					"X-Api-Key": _this.options.apiKey,
+					"X-CalmLens-Upload": isMultipart ? "part" : "content"
+				},
+				body: toRawUploadBody(payload),
+				duplex: "half"
+			});
+			const asset = yield _this.parseRawUploadResponse(response);
+			if (isMultipart && asset.status === "uploading") {
+				_this.multipartUploadQueues.set(asset.id, queue);
+				if (isImageMimeType(payload.type)) {
+					var _asset$sizeInBytes;
+					_this.multipartImageUploadSizes.set(asset.id, (_asset$sizeInBytes = asset.sizeInBytes) !== null && _asset$sizeInBytes !== void 0 ? _asset$sizeInBytes : 0);
+				}
+			}
+			return asset;
+		})();
+	}
+	submitRawAssetPart(assetId, part, queue) {
+		var _this2 = this;
+		return require_CalmLensUtils._asyncToGenerator(function* () {
+			var _part$isFinal2, _part$sizeInBytes2;
+			const query = new URLSearchParams({
+				queue: String(queue),
+				partNumber: String(part.partNumber),
+				isFinal: String((_part$isFinal2 = part.isFinal) !== null && _part$isFinal2 !== void 0 ? _part$isFinal2 : false)
+			});
+			setOptionalQueryValue(query, "sizeInBytes", (_part$sizeInBytes2 = part.sizeInBytes) !== null && _part$sizeInBytes2 !== void 0 ? _part$sizeInBytes2 : require_CalmLensUtils.getAssetPayloadByteLength(part));
+			const url = `${_this2.options.baseUrl.replace(/\/$/, "")}/assets/${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 require_CalmLensUtils._asyncToGenerator(function* () {
+			let data;
+			try {
+				data = yield response.json();
+			} catch (cause) {
+				throw require_CalmLensUtils.calmLensError({ id: cause instanceof Error && ["TimeoutError", "AbortError"].includes(cause.name) ? cause.name === "TimeoutError" ? "sdk/timeout" : "sdk/cancelled" : response.ok ? "sdk/invalid-response" : "sdk/http-error" }, {
+					message: `Invalid JSON response (HTTP ${response.status})`,
+					status: response.status,
+					cause
+				});
+			}
+			if (!response.ok) {
+				if (isApiErrorPayload(data)) throw require_CalmLensUtils.calmLensError({
+					id: data.code,
+					defaultMessage: data.message
+				}, {
+					message: data.message,
+					status: response.status,
+					details: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, data.details), {}, {
+						traceId: data.traceId,
+						network: true
+					})
+				});
+				throw require_CalmLensUtils.calmLensError({ id: "sdk/http-error" }, {
+					message: `HTTP ${response.status}`,
+					status: response.status
+				});
+			}
+			if (!data || typeof data !== "object" || !("id" in data) || typeof data.id !== "string" || !data.id || !("status" in data) || ![
+				"uploading",
+				"pending",
+				"approved",
+				"rejected",
+				"error"
+			].includes(String(data.status))) throw require_CalmLensUtils.calmLensError({ id: "sdk/invalid-response" }, {
+				message: "Expected an asset response",
+				status: response.status
+			});
+			return data;
+		})();
+	}
+	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: (_ref3) => {
+				var _options$resource;
+				let { assetIdentifier } = _ref3, options = require_CalmLensUtils._objectWithoutProperties(_ref3, _excluded3);
+				if (!assetIdentifier) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset identifier is required" });
+				const resource = (_options$resource = options.resource) !== null && _options$resource !== void 0 ? _options$resource : "content";
+				const url = `${this.options.cdnBaseUrl.replace(/\/$/, "")}/assets/${encodeURIComponent(this.options.projectId)}/${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 _ref5 = require_CalmLensUtils._asyncToGenerator(function* (_ref4) {
+					var _this$options$cdnFetc;
+					let { assetIdentifier, init } = _ref4, urlOptions = require_CalmLensUtils._objectWithoutProperties(_ref4, _excluded4);
+					const fetchImpl = (_this$options$cdnFetc = _this3.options.cdnFetch) !== null && _this$options$cdnFetc !== void 0 ? _this$options$cdnFetc : globalThis.fetch;
+					if (!fetchImpl) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.SDK_ERRORS.NO_CDN_FETCH);
+					return safeFetch(fetchImpl, _this3.options)(_this3.cdn.getAssetUrl(require_CalmLensUtils._objectSpread2({ assetIdentifier }, urlOptions)), withApiKeyHeader(init, _this3.options.apiKey));
+				});
+				return function serve(_x3) {
+					return _ref5.apply(this, arguments);
+				};
+			}()
+		};
+	}
+	get text() {
+		var _this4 = this;
+		return { moderate: function() {
+			var _ref6 = require_CalmLensUtils._asyncToGenerator(function* (options) {
+				return _this4.assets.moderate(require_CalmLensUtils.toTextAssetOptions(options));
+			});
+			return function moderate(_x4) {
+				return _ref6.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 _ref7 = require_CalmLensUtils._asyncToGenerator(function* (options) {
+					var _options$pageIndex;
+					return (yield _this5.endpoints.getAssetsPage.submit({
+						params: { projectId: _this5.options.projectId },
+						query: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, options), {}, { pageIndex: (_options$pageIndex = options.pageIndex) !== null && _options$pageIndex !== void 0 ? _options$pageIndex : 0 })
+					})).data;
+				});
+				return function list(_x5) {
+					return _ref7.apply(this, arguments);
+				};
+			}(),
+			/**
+			* Retrieve a specific asset by ID
+			* @param assetId - The asset ID
+			* @returns Promise with asset data
+			*/
+			retrieve: function() {
+				var _ref8 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId }) {
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					return (yield _this5.endpoints.getAsset.submit({ params: { assetId } })).data;
+				});
+				return function retrieve(_x6) {
+					return _ref8.apply(this, arguments);
+				};
+			}(),
+			update: function() {
+				var _ref10 = require_CalmLensUtils._asyncToGenerator(function* (_ref9) {
+					let { assetId } = _ref9, body = require_CalmLensUtils._objectWithoutProperties(_ref9, _excluded5);
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					return (yield _this5.endpoints.patchAsset.submit({
+						params: { assetId },
+						body
+					})).data;
+				});
+				return function update(_x7) {
+					return _ref10.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 _ref12 = require_CalmLensUtils._asyncToGenerator(function* (_ref11) {
+					var _options$pageIndex2;
+					let { assetId } = _ref11, options = require_CalmLensUtils._objectWithoutProperties(_ref11, _excluded6);
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					return (yield _this5.endpoints.getAssetChildren.submit({
+						params: { assetId },
+						query: require_CalmLensUtils._objectSpread2(require_CalmLensUtils._objectSpread2({}, options), {}, { pageIndex: (_options$pageIndex2 = options.pageIndex) !== null && _options$pageIndex2 !== void 0 ? _options$pageIndex2 : 0 })
+					})).data;
+				});
+				return function listChildren(_x8) {
+					return _ref12.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 _ref13 = require_CalmLensUtils._asyncToGenerator(function* (options) {
+					const body = prepareSubmitAssetOptions(options);
+					if ("content" in body || "part" in body) return yield _this5.submitRawAssetUpload(body, true);
+					return (yield _this5.endpoints.postUploadAsset.submit({
+						body: normalizeAssetOptionsForRequest(body),
+						params: { projectId: _this5.options.projectId },
+						query: { queue: true }
+					})).data;
+				});
+				return function create(_x9) {
+					return _ref13.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 _ref14 = require_CalmLensUtils._asyncToGenerator(function* (options) {
+					if ("content" in options && "plainText" in options.content && (typeof options.content.plainText !== "string" || !options.content.plainText.trim())) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Text to moderate must be a non-empty string" });
+					const body = prepareSubmitAssetOptions(options);
+					if ("content" in body || "part" in body) return yield _this5.submitRawAssetUpload(body, false);
+					return (yield _this5.endpoints.postUploadAsset.submit({
+						body: normalizeAssetOptionsForRequest(body),
+						params: { projectId: _this5.options.projectId },
+						query: { queue: false }
+					})).data;
+				});
+				return function moderate(_x10) {
+					return _ref14.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 _ref15 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId, part }) {
+					var _part$sizeInBytes3, _this$multipartUpload;
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					if (!part) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Part options are required" });
+					const validation = require_CalmLensUtils.validateAssetPayload(part, {
+						multipart: true,
+						isFinal: part.isFinal
+					});
+					if (!validation.ok) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+					const existingImageSizeInBytes = _this5.multipartImageUploadSizes.get(assetId);
+					const partSizeInBytes = (_part$sizeInBytes3 = part.sizeInBytes) !== null && _part$sizeInBytes3 !== void 0 ? _part$sizeInBytes3 : require_CalmLensUtils.getAssetPayloadByteLength(part);
+					if (existingImageSizeInBytes !== void 0 && partSizeInBytes !== void 0) {
+						const totalSizeInBytes = existingImageSizeInBytes + partSizeInBytes;
+						if (totalSizeInBytes > require_CalmLensUtils.MAX_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE);
+						if (part.isFinal && totalSizeInBytes < require_CalmLensUtils.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw require_CalmLensUtils.calmLensError(require_CalmLensUtils.PUBLIC_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL);
+					}
+					return yield _this5.submitRawAssetPart(assetId, part, (_this$multipartUpload = _this5.multipartUploadQueues.get(assetId)) !== null && _this$multipartUpload !== void 0 ? _this$multipartUpload : false);
+				});
+				return function uploadPart(_x11) {
+					return _ref15.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 _ref17 = require_CalmLensUtils._asyncToGenerator(function* (_ref16) {
+					var _options$resource2, _options$expiresInSec;
+					let { assetId } = _ref16, options = require_CalmLensUtils._objectWithoutProperties(_ref16, _excluded7);
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					if (options.lens && options.transform) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Specify either a lens or a transform, not both" });
+					return (yield _this5.endpoints.postAssetSignedUrl.submit({
+						body: {
+							resource: (_options$resource2 = options.resource) !== null && _options$resource2 !== void 0 ? _options$resource2 : "content",
+							expiresInSeconds: (_options$expiresInSec = options.expiresInSeconds) !== null && _options$expiresInSec !== void 0 ? _options$expiresInSec : 900,
+							lens: options.lens,
+							transform: options.transform
+						},
+						params: { assetId }
+					})).data;
+				});
+				return function createSignedUrl(_x12) {
+					return _ref17.apply(this, arguments);
+				};
+			}(),
+			move: function() {
+				var _ref18 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId, folderId }) {
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					return (yield _this5.endpoints.moveAsset.submit({
+						params: { assetId },
+						body: { folderId }
+					})).data;
+				});
+				return function move(_x13) {
+					return _ref18.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 _ref19 = require_CalmLensUtils._asyncToGenerator(function* ({ assetId }) {
+					if (!assetId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Asset ID is required" });
+					return (yield _this5.endpoints.retryAsset.submit({ params: { assetId } })).data;
+				});
+				return function retry(_x14) {
+					return _ref19.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 _ref20 = require_CalmLensUtils._asyncToGenerator(function* (options = {}) {
+				return (yield _this6.endpoints.getEvents.submit({
+					params: { projectId: _this6.options.projectId },
+					query: options
+				})).data;
+			});
+			return function list() {
+				return _ref20.apply(this, arguments);
+			};
+		}() };
+	}
+	get folders() {
+		var _this7 = this;
+		return {
+			list: function() {
+				var _ref21 = require_CalmLensUtils._asyncToGenerator(function* () {
+					return (yield _this7.endpoints.getFolders.submit({ params: { projectId: _this7.options.projectId } })).data.folders;
+				});
+				return function list() {
+					return _ref21.apply(this, arguments);
+				};
+			}(),
+			retrieve: function() {
+				var _ref22 = require_CalmLensUtils._asyncToGenerator(function* ({ folderId }) {
+					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
+					return (yield _this7.endpoints.getFolder.submit({ params: { folderId } })).data;
+				});
+				return function retrieve(_x15) {
+					return _ref22.apply(this, arguments);
+				};
+			}(),
+			create: function() {
+				var _ref23 = require_CalmLensUtils._asyncToGenerator(function* (options) {
+					return (yield _this7.endpoints.postFolder.submit({
+						params: { projectId: _this7.options.projectId },
+						body: options
+					})).data;
+				});
+				return function create(_x16) {
+					return _ref23.apply(this, arguments);
+				};
+			}(),
+			update: function() {
+				var _ref25 = require_CalmLensUtils._asyncToGenerator(function* (_ref24) {
+					let { folderId } = _ref24, body = require_CalmLensUtils._objectWithoutProperties(_ref24, _excluded8);
+					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
+					return (yield _this7.endpoints.patchFolder.submit({
+						params: { folderId },
+						body
+					})).data;
+				});
+				return function update(_x17) {
+					return _ref25.apply(this, arguments);
+				};
+			}(),
+			delete: function() {
+				var _ref26 = require_CalmLensUtils._asyncToGenerator(function* ({ folderId }) {
+					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
+					yield _this7.endpoints.deleteFolder.submit({ params: { folderId } });
+				});
+				return function _delete(_x18) {
+					return _ref26.apply(this, arguments);
+				};
+			}(),
+			move: function() {
+				var _ref27 = require_CalmLensUtils._asyncToGenerator(function* ({ folderId, parentId }) {
+					if (!folderId) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Folder ID is required" });
+					return (yield _this7.endpoints.moveFolder.submit({
+						params: { folderId },
+						body: { parentId }
+					})).data;
+				});
+				return function move(_x19) {
+					return _ref27.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 require_CalmLensUtils._asyncToGenerator(function* () {
+			if (!options.identifier) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Lens identifier is required" });
+			const [lens] = yield _this8.ensureLenses({ lenses: [options] });
+			return lens;
+		})();
+	}
+	/**
+	* Create or update several named lenses in one API request.
+	* Each lens follows the same versioning and idempotency rules as ensureLens().
+	*/
+	ensureLenses({ lenses }) {
+		var _this9 = this;
+		return require_CalmLensUtils._asyncToGenerator(function* () {
+			if (lenses.length === 0) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "At least one lens is required" });
+			if (lenses.some((option) => !option.identifier)) throw require_CalmLensUtils.calmLensError({ id: "upload/invalid-payload" }, { message: "Lens identifier is required" });
+			const missingOptions = [];
+			const missingKeys = /* @__PURE__ */ new Set();
+			for (const option of lenses) {
+				const cacheKey = getEnsureLensCacheKey(option);
+				if (!_this9.ensuredLenses.has(cacheKey) && !missingKeys.has(cacheKey)) {
+					missingKeys.add(cacheKey);
+					missingOptions.push(option);
+				}
+			}
+			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 require_CalmLensUtils._asyncToGenerator(function* () {
+			const result = yield _this10.endpoints.ensureLenses.submit({
+				body: { lenses: options },
+				params: { projectId: _this10.options.projectId }
+			});
+			for (const [index, lens] of result.data.lenses.entries()) {
+				const optionsForLens = options[index];
+				if (!optionsForLens) throw require_CalmLensUtils.calmLensError({ id: "sdk/invalid-response" }, { message: "CalmLens returned an unexpected lens response" });
+				for (const [cacheKey, cachedLens] of _this10.ensuredLenses) if (cachedLens.identifier === optionsForLens.identifier) _this10.ensuredLenses.delete(cacheKey);
+				_this10.ensuredLenses.set(getEnsureLensCacheKey(optionsForLens), lens);
+			}
+		})();
+	}
+};
+//#endregion
+exports.CalmLensClient = CalmLensClient;
+exports.CalmLensError = require_CalmLensUtils.CalmLensError;
+exports.MEDIA_TEST_SIGNALS = MEDIA_TEST_SIGNALS;
+exports.WEBHOOK_DELIVERY_HEADER = WEBHOOK_DELIVERY_HEADER;
+exports.WEBHOOK_SIGNATURE_HEADER = WEBHOOK_SIGNATURE_HEADER;
+exports.WEBHOOK_SIGNATURE_TOLERANCE_SECONDS = WEBHOOK_SIGNATURE_TOLERANCE_SECONDS;
+exports.WEBHOOK_TIMESTAMP_HEADER = WEBHOOK_TIMESTAMP_HEADER;
+exports.generateMediaTestCode = generateMediaTestCode;
+exports.verifyWebhookSignature = verifyWebhookSignature;