@calmlens/sdk 0.9.1 → 0.10.1

package/esm/testing.js

@@ -1,5 +1,245 @@
-import { C as _objectSpread2, S as _asyncToGenerator, _ as assetDataToUint8Array, a as validateClientOptions, g as stringifyJsonCanonical, h as PUBLIC_ERROR_CODES, i as toTextAssetOptions, l as calmLensError, m as isRejectedUploadMimeType, n as encodePathSegment, o as _objectWithoutProperties, p as getRejectedUploadMimeTypeError, t as appendCdnSelector, v as assetToData, x as validateAssetPayload, y as getAssetPayloadByteLength } from "./CalmLensUtils-O1xk_Ts0.js";
+import { D as assetDataToUint8Array, E as stringifyJsonCanonical, O as assetToData, T as isRejectedUploadMimeType, _ as invalidArgument, b as API_ERROR_DEFINITIONS, c as appendCdnSelector, d as toTextAssetOptions, f as validateClientOptions, g as SDK_ERROR_CODES, h as CalmLensError, i as WEBHOOK_TIMESTAMP_HEADER, j as validateAssetPayload, k as getAssetPayloadByteLength, l as encodePathSegment, n as WEBHOOK_SIGNATURE_HEADER, s as hmacSha256Hex, t as WEBHOOK_DELIVERY_HEADER, w as getRejectedUploadMimeTypeError, y as API_ERROR_CODES } from "./CalmLensWebhooks-DLUozliX.js";
 import * as zod from "zod";
+import "zod/v4";
+//#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 ?? {}
+		};
+	}, type);
+};
+createMetaType({ id: "docPropertyInfo" });
+//#endregion
+//#region ../shared/src/ZodUtils.ts
+const SIZE_LIMITS = {
+	small: 64,
+	medium: 200,
+	large: 1500,
+	xlarge: 1e4,
+	token: 1e4
+};
+const saneStringField = (options) => {
+	return zod.string().transform((value) => value.trim()).refine((value) => {
+		if (options?.minWidth && value.length < options.minWidth) return false;
+		return true;
+	}, "Not long enough").refine((value) => {
+		const sizeLimit = options?.maxLength ?? SIZE_LIMITS[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 ../shared/src/Permissions.ts
 const ACTION_SCHEMA = zod.enum([
 	"assets:read",
@@ -55,11 +295,10 @@ const permits = (grants, action, folderId, folders) => grants.some((grant) => {
 	let current = folderId;
 	const visited = /* @__PURE__ */ new Set();
 	while (current && !visited.has(current)) {
-		var _folders$find$parentI, _folders$find;
 		if (current === grant.folderId) return true;
 		if (!grant.includeSubfolders) return false;
 		visited.add(current);
-		current = (_folders$find$parentI = (_folders$find = folders.find((folder) => folder.id === current)) === null || _folders$find === void 0 ? void 0 : _folders$find.parentId) !== null && _folders$find$parentI !== void 0 ? _folders$find$parentI : null;
+		current = folders.find((folder) => folder.id === current)?.parentId ?? null;
 	}
 	return false;
 });
@@ -83,7 +322,7 @@ const getMockApiKeyGrants = (apiKey) => {
 	if (!apiKey.startsWith("sk_test_")) return [];
 	try {
 		return GRANTS_SCHEMA.parse(JSON.parse(fromBase64Url(apiKey.slice(8))));
-	} catch (_unused) {
+	} catch {
 		return [];
 	}
 };
@@ -93,50 +332,37 @@ var InMemoryMockImageStorage = class {
 	constructor() {
 		this.content = /* @__PURE__ */ new Map();
 	}
-	putContent(assetId, content) {
-		var _this = this;
-		return _asyncToGenerator(function* () {
-			const validation = validateAssetPayload(content);
-			if (!validation.ok) throw new Error(validation.error);
-			const bytes = yield assetDataToUint8Array(assetToData(content));
-			_this.content.set(assetId, {
-				assetId,
-				parts: /* @__PURE__ */ new Map([[1, bytes]]),
-				type: content.type
-			});
-		})();
+	async putContent(assetId, content) {
+		const validation = validateAssetPayload(content);
+		if (!validation.ok) throw new Error(validation.error);
+		const bytes = await assetDataToUint8Array(assetToData(content));
+		this.content.set(assetId, {
+			assetId,
+			parts: /* @__PURE__ */ new Map([[1, bytes]]),
+			type: content.type
+		});
 	}
-	putPart(assetId, part) {
-		var _this2 = this;
-		return _asyncToGenerator(function* () {
-			var _this$content$get, _part$partNumber, _part$type;
-			const validation = validateAssetPayload(part, {
-				multipart: true,
-				isFinal: part.isFinal
-			});
-			if (!validation.ok) throw new Error(validation.error);
-			const bytes = yield assetDataToUint8Array(assetToData(part));
-			const existing = (_this$content$get = _this2.content.get(assetId)) !== null && _this$content$get !== void 0 ? _this$content$get : {
-				assetId,
-				parts: /* @__PURE__ */ new Map(),
-				type: part.type
-			};
-			existing.parts.set((_part$partNumber = part.partNumber) !== null && _part$partNumber !== void 0 ? _part$partNumber : 1, bytes);
-			existing.type = (_part$type = part.type) !== null && _part$type !== void 0 ? _part$type : existing.type;
-			_this2.content.set(assetId, existing);
-		})();
-	}
-	getContent(assetId) {
-		var _this3 = this;
-		return _asyncToGenerator(function* () {
-			return _this3.content.get(assetId);
-		})();
-	}
-	deleteContent(assetId) {
-		var _this4 = this;
-		return _asyncToGenerator(function* () {
-			_this4.content.delete(assetId);
-		})();
+	async putPart(assetId, part) {
+		const validation = validateAssetPayload(part, {
+			multipart: true,
+			isFinal: part.isFinal
+		});
+		if (!validation.ok) throw new Error(validation.error);
+		const bytes = await assetDataToUint8Array(assetToData(part));
+		const existing = this.content.get(assetId) ?? {
+			assetId,
+			parts: /* @__PURE__ */ new Map(),
+			type: part.type
+		};
+		existing.parts.set(part.partNumber ?? 1, bytes);
+		existing.type = part.type ?? existing.type;
+		this.content.set(assetId, existing);
+	}
+	async getContent(assetId) {
+		return this.content.get(assetId);
+	}
+	async deleteContent(assetId) {
+		this.content.delete(assetId);
 	}
 };
 var InMemoryMockDatabaseStorage = class {
@@ -144,69 +370,39 @@ var InMemoryMockDatabaseStorage = class {
 		this.assets = /* @__PURE__ */ new Map();
 		this.folders = /* @__PURE__ */ new Map();
 	}
-	createAsset(asset) {
-		var _this5 = this;
-		return _asyncToGenerator(function* () {
-			_this5.assets.set(asset.id, asset);
-			return asset;
-		})();
-	}
-	updateAsset(asset) {
-		var _this6 = this;
-		return _asyncToGenerator(function* () {
-			_this6.assets.set(asset.id, asset);
-			return asset;
-		})();
-	}
-	getAsset(assetId) {
-		var _this7 = this;
-		return _asyncToGenerator(function* () {
-			return _this7.assets.get(assetId);
-		})();
-	}
-	listAssets(projectId) {
-		var _this8 = this;
-		return _asyncToGenerator(function* () {
-			return [..._this8.assets.values()].filter((asset) => asset.projectId === projectId);
-		})();
-	}
-	deleteAsset(assetId) {
-		var _this9 = this;
-		return _asyncToGenerator(function* () {
-			_this9.assets.delete(assetId);
-		})();
-	}
-	createFolder(folder) {
-		var _this10 = this;
-		return _asyncToGenerator(function* () {
-			_this10.folders.set(folder.id, folder);
-			return folder;
-		})();
-	}
-	updateFolder(folder) {
-		var _this11 = this;
-		return _asyncToGenerator(function* () {
-			_this11.folders.set(folder.id, folder);
-			return folder;
-		})();
-	}
-	getFolder(folderId) {
-		var _this12 = this;
-		return _asyncToGenerator(function* () {
-			return _this12.folders.get(folderId);
-		})();
-	}
-	listFolders(projectId) {
-		var _this13 = this;
-		return _asyncToGenerator(function* () {
-			return [..._this13.folders.values()].filter((folder) => folder.projectId === projectId).sort((a, b) => a.name.localeCompare(b.name));
-		})();
-	}
-	deleteFolder(folderId) {
-		var _this14 = this;
-		return _asyncToGenerator(function* () {
-			_this14.folders.delete(folderId);
-		})();
+	async createAsset(asset) {
+		this.assets.set(asset.id, asset);
+		return asset;
+	}
+	async updateAsset(asset) {
+		this.assets.set(asset.id, asset);
+		return asset;
+	}
+	async getAsset(assetId) {
+		return this.assets.get(assetId);
+	}
+	async listAssets(projectId) {
+		return [...this.assets.values()].filter((asset) => asset.projectId === projectId);
+	}
+	async deleteAsset(assetId) {
+		this.assets.delete(assetId);
+	}
+	async createFolder(folder) {
+		this.folders.set(folder.id, folder);
+		return folder;
+	}
+	async updateFolder(folder) {
+		this.folders.set(folder.id, folder);
+		return folder;
+	}
+	async getFolder(folderId) {
+		return this.folders.get(folderId);
+	}
+	async listFolders(projectId) {
+		return [...this.folders.values()].filter((folder) => folder.projectId === projectId).sort((a, b) => a.name.localeCompare(b.name));
+	}
+	async deleteFolder(folderId) {
+		this.folders.delete(folderId);
 	}
 };
 //#endregion
@@ -233,62 +429,164 @@ const inferAssetType = (options) => {
 	return "file";
 };
 const createPage = (items, query) => {
-	var _query$pageIndex, _query$pageSize;
-	const pageIndex = (_query$pageIndex = query.pageIndex) !== null && _query$pageIndex !== void 0 ? _query$pageIndex : 0;
-	const pageSize = (_query$pageSize = query.pageSize) !== null && _query$pageSize !== void 0 ? _query$pageSize : 10;
+	const pageIndex = query.pageIndex ?? 0;
+	const pageSize = query.pageSize ?? 10;
+	if (!Number.isInteger(pageIndex) || pageIndex < 0) throw invalidArgument("pageIndex must be a non-negative integer");
+	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw invalidArgument("pageSize must be an integer from 1 to 100");
 	const start = pageIndex * pageSize;
 	return {
 		items: items.slice(start, start + pageSize),
 		total: items.length,
 		pageIndex,
 		pageSize,
-		ordering: [],
+		ordering: query.ordering ?? [],
 		hasMore: start + pageSize < items.length
 	};
 };
+const compareValues = (left, right) => {
+	if (left === right) return 0;
+	if (left === void 0 || left === null) return -1;
+	if (right === void 0 || right === null) return 1;
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	return String(left).localeCompare(String(right));
+};
+/** Sorts like the API's `ordering`; without one, newest first. */
+const orderItems = (items, ordering) => {
+	const rules = ordering?.length ? ordering : [{
+		field: "createdAt",
+		direction: "DESC"
+	}];
+	return [...items].sort((a, b) => {
+		for (const rule of rules) {
+			const result = compareValues(a[rule.field], b[rule.field]);
+			if (result !== 0) return rule.direction === "DESC" ? -result : result;
+		}
+		return 0;
+	});
+};
+const COMPARISON = /^([A-Za-z][\w.]*)(==|!=|=in=|=out=|>=|<=|=gt=|=ge=|=lt=|=le=|>|<)(.+)$/;
+const parseFilterValue = (raw) => {
+	const value = raw.trim();
+	if (/^".*"$/.test(value) || /^'.*'$/.test(value)) return value.slice(1, -1);
+	if (value === "null") return null;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value !== "" && !Number.isNaN(Number(value))) return Number(value);
+	return value;
+};
+const readField = (item, path) => path.split(".").reduce((value, key) => value && typeof value === "object" ? value[key] : void 0, item);
+const unsupportedFilter = (expression) => invalidArgument(`MockCalmLensClient cannot evaluate the filter "${expression}". It supports ==, !=, <, <=, >, >=, =in= and =out=, joined by ; (and) or , (or), without grouping parentheses.`);
+const matchesComparison = (item, comparison) => {
+	const match = COMPARISON.exec(comparison.trim());
+	if (!match) throw unsupportedFilter(comparison);
+	const [, field, operator, rawValue] = match;
+	const actual = readField(item, field);
+	const isList = operator === "=in=" || operator === "=out=";
+	if (isList && !/^\(.*\)$/.test(rawValue.trim())) throw unsupportedFilter(comparison);
+	const values = isList ? rawValue.trim().slice(1, -1).split(",").map(parseFilterValue) : [parseFilterValue(rawValue)];
+	const equals = (expected) => Array.isArray(actual) ? actual.includes(expected) : expected === null ? actual === null || actual === void 0 : actual === expected;
+	switch (operator) {
+		case "==": return equals(values[0]);
+		case "!=": return !equals(values[0]);
+		case "=in=": return values.some(equals);
+		case "=out=": return !values.some(equals);
+		case ">":
+		case "=gt=": return compareValues(actual, values[0]) > 0;
+		case ">=":
+		case "=ge=": return compareValues(actual, values[0]) >= 0;
+		case "<":
+		case "=lt=": return compareValues(actual, values[0]) < 0;
+		default: return compareValues(actual, values[0]) <= 0;
+	}
+};
+/** Splits on `separator` outside quotes and parentheses; grouping parentheses are refused. */
+const splitTopLevel = (text, separator) => {
+	const parts = [];
+	let depth = 0;
+	let quote = null;
+	let current = "";
+	for (const char of text) {
+		if (quote) {
+			if (char === quote) quote = null;
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === "(") depth++;
+		else if (char === ")") depth--;
+		else if (char === separator && depth === 0) {
+			parts.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	parts.push(current);
+	return parts;
+};
+/**
+* Applies an RSQL `filter` like the API for simple expressions: comparisons joined by `;`
+* (and) and `,` (or). Anything it can't evaluate throws instead of returning wrong results.
+*/
+const filterAssets = (items, filter) => {
+	if (!filter) return items;
+	const alternatives = splitTopLevel(filter, ",").map((group) => splitTopLevel(group, ";"));
+	for (const condition of alternatives.flat()) if (condition.trim().startsWith("(")) throw unsupportedFilter(condition);
+	return items.filter((item) => alternatives.some((conditions) => conditions.every((condition) => matchesComparison(item, condition))));
+};
 //#endregion
 //#region src/testing/MockCalmLensClient.ts
-const _excluded = ["assetIdentifier"];
-const _excluded2 = ["assetIdentifier"];
-const _excluded3 = ["assetId"];
-const _excluded4 = ["assetId"];
-const _excluded5 = ["assetId"];
-const _excluded6 = ["folderId"];
-const assertValidUploadMimeType = (mimeType) => {
-	if (isRejectedUploadMimeType(mimeType)) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
-		message: getRejectedUploadMimeTypeError(mimeType),
-		details: { mimeType }
-	});
+const DEFAULT_EVENTS_LIMIT = 50;
+/** Stands in for binary payloads when comparing idempotent requests, like the API's size check. */
+const describeBinary = (value) => {
+	if (value instanceof Blob) return `[blob:${value.size}]`;
+	if (value instanceof ArrayBuffer) return `[bytes:${value.byteLength}]`;
+	if (ArrayBuffer.isView(value)) return `[bytes:${value.byteLength}]`;
+	return value;
 };
+const MAX_EVENTS_LIMIT = 100;
 const toFailureError = (failure) => {
-	if (failure === "transport-error") return calmLensError({ id: "sdk/transport-error" }, {
+	if (failure === "transport-error") return new CalmLensError(SDK_ERROR_CODES.TRANSPORT_ERROR, {
 		message: "Request failed",
 		cause: /* @__PURE__ */ new TypeError("Simulated network failure")
 	});
-	if (failure === "timeout") return calmLensError({ id: "sdk/timeout" }, {
-		message: "Request aborted",
-		cause: new DOMException("The operation timed out.", "TimeoutError")
-	});
+	if (failure === "timeout") {
+		const cause = /* @__PURE__ */ new Error("The operation timed out.");
+		cause.name = "TimeoutError";
+		return new CalmLensError(SDK_ERROR_CODES.TIMEOUT, {
+			message: "Request timed out",
+			cause
+		});
+	}
 	return failure;
 };
+/**
+* An in-memory stand-in for `CalmLensClient` with the same methods, validation and error
+* codes. API errors carry the HTTP status, a `requestId` and response headers like the real
+* client's, so error handling can be tested without a network.
+*/
 var MockCalmLensClient = class {
 	/** Accepts the same options as `CalmLensClient` (validated the same way), plus `mockOptions`. */
 	constructor(options) {
-		var _options$mockOptions$, _options$mockOptions, _options$mockOptions$2, _options$mockOptions2, _options$mockOptions$3, _options$mockOptions3, _options$mockOptions$4, _options$mockOptions4, _options$mockOptions$5, _options$mockOptions5, _options$mockOptions$6, _options$mockOptions6, _options$mockOptions$7, _options$mockOptions7, _options$cdnBaseUrl;
-		this.options = options;
 		this.lenses = /* @__PURE__ */ new Map();
+		this.eventFeed = [];
+		this.uploadQueues = /* @__PURE__ */ new Map();
+		this.idempotentResults = /* @__PURE__ */ new Map();
+		this.requestCount = 0;
 		this.pendingFailures = [];
 		this.calls = [];
 		validateClientOptions(options);
-		this.databaseStorage = (_options$mockOptions$ = (_options$mockOptions = options.mockOptions) === null || _options$mockOptions === void 0 ? void 0 : _options$mockOptions.databaseStorage) !== null && _options$mockOptions$ !== void 0 ? _options$mockOptions$ : new InMemoryMockDatabaseStorage();
-		this.imageStorage = (_options$mockOptions$2 = (_options$mockOptions2 = options.mockOptions) === null || _options$mockOptions2 === void 0 ? void 0 : _options$mockOptions2.imageStorage) !== null && _options$mockOptions$2 !== void 0 ? _options$mockOptions$2 : new InMemoryMockImageStorage();
-		this.createId = (_options$mockOptions$3 = (_options$mockOptions3 = options.mockOptions) === null || _options$mockOptions3 === void 0 ? void 0 : _options$mockOptions3.createId) !== null && _options$mockOptions$3 !== void 0 ? _options$mockOptions$3 : crypto.randomUUID.bind(crypto);
-		this.now = (_options$mockOptions$4 = (_options$mockOptions4 = options.mockOptions) === null || _options$mockOptions4 === void 0 ? void 0 : _options$mockOptions4.now) !== null && _options$mockOptions$4 !== void 0 ? _options$mockOptions$4 : Date.now;
-		this.queuedStatus = (_options$mockOptions$5 = (_options$mockOptions5 = options.mockOptions) === null || _options$mockOptions5 === void 0 ? void 0 : _options$mockOptions5.queuedStatus) !== null && _options$mockOptions$5 !== void 0 ? _options$mockOptions$5 : "pending";
-		this.analyzedStatus = (_options$mockOptions$6 = (_options$mockOptions6 = options.mockOptions) === null || _options$mockOptions6 === void 0 ? void 0 : _options$mockOptions6.analyzedStatus) !== null && _options$mockOptions$6 !== void 0 ? _options$mockOptions$6 : "approved";
+		this.projectId = options.projectId;
+		this.databaseStorage = options.mockOptions?.databaseStorage ?? new InMemoryMockDatabaseStorage();
+		this.imageStorage = options.mockOptions?.imageStorage ?? new InMemoryMockImageStorage();
+		this.createId = options.mockOptions?.createId ?? crypto.randomUUID.bind(crypto);
+		this.now = options.mockOptions?.now ?? Date.now;
+		this.queuedStatus = options.mockOptions?.queuedStatus ?? "pending";
+		this.analyzedStatus = options.mockOptions?.analyzedStatus ?? "approved";
 		this.apiKeyGrants = getMockApiKeyGrants(options.apiKey);
-		this.signedUrlBaseUrl = (_options$mockOptions$7 = (_options$mockOptions7 = options.mockOptions) === null || _options$mockOptions7 === void 0 ? void 0 : _options$mockOptions7.signedUrlBaseUrl) !== null && _options$mockOptions$7 !== void 0 ? _options$mockOptions$7 : "mock://calmlens";
-		this.cdnBaseUrl = (_options$cdnBaseUrl = options.cdnBaseUrl) !== null && _options$cdnBaseUrl !== void 0 ? _options$cdnBaseUrl : "mock://calmlens/v1";
+		this.signedUrlBaseUrl = options.mockOptions?.signedUrlBaseUrl ?? "mock://calmlens";
+		this.cdnBaseUrl = (options.cdnBaseUrl ?? "mock://calmlens/v1").replace(/\/+$/, "");
+	}
+	/** Keeps the API key out of `console.log` and `util.inspect`. */
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return `MockCalmLensClient { projectId: ${JSON.stringify(this.projectId)} }`;
 	}
 	/**
 	* Makes the next call (or the next call to `operation`) throw `failure` instead of running,
@@ -304,14 +602,54 @@ var MockCalmLensClient = class {
 	callsTo(operation) {
 		return this.calls.filter((call) => call.operation === operation);
 	}
-	findOwnAsset(assetId) {
-		var _this = this;
-		return _asyncToGenerator(function* () {
-			if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-			const asset = yield _this.databaseStorage.getAsset(assetId);
-			if (!asset || asset.projectId !== _this.options.projectId) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
-			return asset;
-		})();
+	/**
+	* Adds an event to the feed `events.list` reads, as if CalmLens had recorded it. Returns the
+	* stored event; pass it to `toWebhookEventPayload` to build a matching webhook body.
+	*/
+	enqueueEvent(input) {
+		const now = this.now();
+		const event = {
+			id: this.createId(),
+			projectId: this.projectId,
+			severity: "low",
+			title: input.type,
+			facts: [],
+			createdAt: now,
+			updatedAt: now,
+			...input
+		};
+		this.eventFeed.push(event);
+		return event;
+	}
+	/** An API error as the real client throws it: status, default message and request ID. */
+	apiError(code, options = {}) {
+		const definition = API_ERROR_DEFINITIONS[code];
+		const requestId = `mock-request-${++this.requestCount}`;
+		return new CalmLensError(code, {
+			message: options.message ?? definition.message,
+			status: definition.status,
+			details: options.details,
+			requestId,
+			headers: new Headers({
+				"content-type": "application/json",
+				"x-request-id": requestId
+			})
+		});
+	}
+	assertValidUploadMimeType(mimeType) {
+		if (isRejectedUploadMimeType(mimeType)) throw this.apiError(API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+			message: getRejectedUploadMimeTypeError(mimeType),
+			details: { mimeType }
+		});
+	}
+	invalidPayload(message) {
+		return this.apiError(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
+	}
+	async findOwnAsset(assetId) {
+		encodePathSegment(assetId, "Asset ID");
+		const asset = await this.databaseStorage.getAsset(assetId);
+		if (!asset || asset.projectId !== this.projectId) throw this.apiError(API_ERROR_CODES.ASSET_NOT_FOUND);
+		return asset;
 	}
 	begin(operation, options) {
 		this.calls.push({
@@ -324,515 +662,545 @@ var MockCalmLensClient = class {
 			throw toFailureError(pending.failure);
 		}
 	}
+	jsonResponse(status, body, url) {
+		const requestId = `mock-request-${++this.requestCount}`;
+		const response = new Response(JSON.stringify(body), {
+			status,
+			headers: {
+				"content-type": "application/json",
+				"x-request-id": requestId
+			}
+		});
+		Object.defineProperty(response, "url", { value: url });
+		return response;
+	}
 	get cdn() {
-		var _this2 = this;
 		return {
-			getAssetUrl: (_ref) => {
-				var _options$resource;
-				let { assetIdentifier } = _ref, options = _objectWithoutProperties(_ref, _excluded);
-				if (!assetIdentifier) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset identifier is required" });
-				const resource = (_options$resource = options.resource) !== null && _options$resource !== void 0 ? _options$resource : "content";
-				const url = `${this.cdnBaseUrl.replace(/\/$/, "")}/assets/${encodeURIComponent(this.options.projectId)}/${encodePathSegment(assetIdentifier, "Asset identifier")}/${resource}`;
+			getAssetUrl: ({ assetIdentifier, ...options }) => {
+				const resource = options.resource ?? "content";
+				const url = `${this.cdnBaseUrl}/assets/${encodeURIComponent(this.projectId)}/${encodePathSegment(assetIdentifier, "Asset identifier")}/${resource}`;
 				return appendCdnSelector(url, options);
 			},
-			serve: function() {
-				var _ref2 = _asyncToGenerator(function* (serveOptions) {
-					var _asset$folderId, _await$this$databaseS, _this$databaseStorage, _this$databaseStorage2, _storedContent$type;
-					_this2.begin("cdn.serve", serveOptions);
-					const { assetIdentifier } = serveOptions, options = _objectWithoutProperties(serveOptions, _excluded2);
-					if (!assetIdentifier) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset identifier is required" });
-					const asset = (yield _this2.databaseStorage.listAssets(_this2.options.projectId)).find((asset) => asset.id === assetIdentifier || asset.externalId === assetIdentifier);
-					if (!asset) return new Response("Asset not found", { status: 404 });
-					if (asset.visibility !== "public" && !permits(_this2.apiKeyGrants, "assets:download", (_asset$folderId = asset.folderId) !== null && _asset$folderId !== void 0 ? _asset$folderId : null, (_await$this$databaseS = yield (_this$databaseStorage = (_this$databaseStorage2 = _this2.databaseStorage).listFolders) === null || _this$databaseStorage === void 0 ? void 0 : _this$databaseStorage.call(_this$databaseStorage2, _this2.options.projectId)) !== null && _await$this$databaseS !== void 0 ? _await$this$databaseS : [])) return new Response(JSON.stringify({
-						code: "asset/api-key-missing-permission",
-						message: "This API key needs assets:download permission for this asset’s folder."
-					}), {
-						status: 403,
-						headers: { "Content-Type": "application/json" }
-					});
-					const storedContent = yield _this2.imageStorage.getContent(asset.id);
-					if (!storedContent) return new Response("Asset content not found", { status: 404 });
-					const parts = [...storedContent.parts.entries()].sort(([left], [right]) => left - right).map(([, value]) => value);
-					const byteLength = parts.reduce((sum, value) => sum + value.byteLength, 0);
-					const bytes = new Uint8Array(byteLength);
-					let offset = 0;
-					for (const part of parts) {
-						bytes.set(part, offset);
-						offset += part.byteLength;
+			/**
+			* Serves stored content like the CDN: `200` with `Content-Type`, `Content-Length`,
+			* `ETag` and `X-Request-Id`, or a JSON error body with `404`/`403`. Never throws for
+			* HTTP errors, like the real client.
+			*/
+			serve: async (serveOptions) => {
+				this.begin("cdn.serve", serveOptions);
+				const { assetIdentifier, init, ...options } = serveOptions;
+				const url = this.cdn.getAssetUrl({
+					assetIdentifier,
+					...options
+				});
+				const asset = (await this.databaseStorage.listAssets(this.projectId)).find((asset) => asset.id === assetIdentifier || asset.externalId === assetIdentifier);
+				const notFound = () => this.jsonResponse(404, {
+					code: "asset/not-found",
+					message: "Asset not found"
+				}, url);
+				if (!asset) return notFound();
+				if (asset.visibility !== "public" && !permits(this.apiKeyGrants, "assets:download", asset.folderId ?? null, await this.databaseStorage.listFolders?.(this.projectId) ?? [])) return this.jsonResponse(403, {
+					code: "asset/api-key-missing-permission",
+					message: "This API key needs assets:download permission for this asset’s folder."
+				}, url);
+				const storedContent = await this.imageStorage.getContent(asset.id);
+				if (!storedContent) return notFound();
+				const parts = [...storedContent.parts.entries()].sort(([left], [right]) => left - right).map(([, value]) => value);
+				const byteLength = parts.reduce((sum, value) => sum + value.byteLength, 0);
+				const bytes = new Uint8Array(byteLength);
+				let offset = 0;
+				for (const part of parts) {
+					bytes.set(part, offset);
+					offset += part.byteLength;
+				}
+				const requestId = `mock-request-${++this.requestCount}`;
+				const isHead = init?.method?.toUpperCase() === "HEAD";
+				const response = new Response(isHead ? null : bytes, {
+					status: 200,
+					headers: {
+						"Content-Type": storedContent.type ?? "application/octet-stream",
+						"Content-Length": String(byteLength),
+						"Cache-Control": asset.visibility === "public" ? "public, max-age=31536000" : "private, no-store",
+						ETag: `"${asset.id}-${asset.updatedAt}"`,
+						"X-Request-Id": requestId,
+						"X-Mock-CalmLens-CDN-URL": url
 					}
-					return new Response(bytes, {
-						status: 200,
-						headers: {
-							"Content-Type": (_storedContent$type = storedContent.type) !== null && _storedContent$type !== void 0 ? _storedContent$type : "application/octet-stream",
-							"X-Mock-CalmLens-CDN-URL": _this2.cdn.getAssetUrl(_objectSpread2({ assetIdentifier }, options))
-						}
-					});
 				});
-				return function serve(_x) {
-					return _ref2.apply(this, arguments);
-				};
-			}()
+				Object.defineProperty(response, "url", { value: url });
+				return response;
+			}
 		};
 	}
 	get events() {
-		var _this3 = this;
-		return { 
-		/** The mock does not record events; it always returns an empty page at "now". */
-list: function() {
-			var _ref3 = _asyncToGenerator(function* (options = {}) {
-				var _options$after;
-				_this3.begin("events.list", options);
-				return {
-					events: [],
-					cursor: (_options$after = options.after) !== null && _options$after !== void 0 ? _options$after : `${_this3.now()}_`,
-					hasMore: false
-				};
+		return {
+			/**
+			* Reads the mock feed like the API: without `after`, no events and a cursor for "now";
+			* with `after`, up to `limit` events added since, oldest first. Add events with
+			* `enqueueEvent`.
+			*/
+			list: async (options = {}) => {
+				this.begin("events.list", options);
+				return this.listEvents(options);
+			},
+			pages: (options = {}) => this.iterateEventPages(options)
+		};
+	}
+	listEvents(options) {
+		const limit = options.limit ?? DEFAULT_EVENTS_LIMIT;
+		if (!Number.isInteger(limit) || limit < 1 || limit > MAX_EVENTS_LIMIT) throw this.apiError(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: `limit must be an integer from 1 to ${MAX_EVENTS_LIMIT}` });
+		if (!options.after) return {
+			events: [],
+			cursor: `mock_${this.eventFeed.length}`,
+			hasMore: false
+		};
+		const match = /^mock_(\d+)$/.exec(options.after);
+		const position = match ? Number(match[1]) : NaN;
+		if (!Number.isSafeInteger(position) || position > this.eventFeed.length) throw this.apiError(API_ERROR_CODES.INVALID_EVENT_CURSOR);
+		const events = this.eventFeed.slice(position, position + limit);
+		const next = position + events.length;
+		return {
+			events,
+			cursor: `mock_${next}`,
+			hasMore: next < this.eventFeed.length
+		};
+	}
+	async *iterateEventPages(options) {
+		let after = options.after;
+		for (;;) {
+			const page = await this.events.list({
+				...options,
+				after
 			});
-			return function list() {
-				return _ref3.apply(this, arguments);
-			};
-		}() };
+			yield page;
+			if (!page.hasMore || page.cursor === after) return;
+			after = page.cursor;
+		}
+	}
+	async *iteratePages(listPage) {
+		for (let pageIndex = 0;; pageIndex++) {
+			const page = await listPage(pageIndex);
+			yield* page.items;
+			if (!page.hasMore || page.items.length === 0) return;
+		}
 	}
 	get text() {
-		var _this4 = this;
-		return { moderate: function() {
-			var _ref4 = _asyncToGenerator(function* (options) {
-				_this4.begin("text.moderate", options);
-				return _this4.moderateAsset(toTextAssetOptions(options));
-			});
-			return function moderate(_x2) {
-				return _ref4.apply(this, arguments);
-			};
-		}() };
+		return { moderate: async (options) => {
+			this.begin("text.moderate", options);
+			return this.moderateAsset(toTextAssetOptions(options), "text.moderate");
+		} };
 	}
 	get assets() {
-		var _this5 = this;
 		return {
-			list: function() {
-				var _ref5 = _asyncToGenerator(function* (options = {}) {
-					var _options$pageIndex;
-					_this5.begin("assets.list", options);
-					const assets = yield _this5.databaseStorage.listAssets(_this5.options.projectId);
-					return createPage(assets, _objectSpread2(_objectSpread2({}, options), {}, { pageIndex: (_options$pageIndex = options.pageIndex) !== null && _options$pageIndex !== void 0 ? _options$pageIndex : 0 }));
-				});
-				return function list() {
-					return _ref5.apply(this, arguments);
-				};
-			}(),
-			retrieve: function() {
-				var _ref6 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.retrieve", options);
-					const { assetId } = options;
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					const asset = yield _this5.databaseStorage.getAsset(assetId);
-					if (!asset) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
-					return asset;
-				});
-				return function retrieve(_x3) {
-					return _ref6.apply(this, arguments);
-				};
-			}(),
-			listChildren: function() {
-				var _ref7 = _asyncToGenerator(function* (childrenOptions = {}) {
-					var _options$pageIndex2;
-					_this5.begin("assets.listChildren", childrenOptions);
-					const { assetId } = childrenOptions, options = _objectWithoutProperties(childrenOptions, _excluded3);
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					const assets = yield _this5.databaseStorage.listAssets(_this5.options.projectId);
-					return createPage(assets.filter((asset) => asset.parentId === assetId), _objectSpread2(_objectSpread2({}, options), {}, { pageIndex: (_options$pageIndex2 = options.pageIndex) !== null && _options$pageIndex2 !== void 0 ? _options$pageIndex2 : 0 }));
-				});
-				return function listChildren() {
-					return _ref7.apply(this, arguments);
+			/**
+			* Matches `query` (case-insensitively) against each asset's name, ID, external ID,
+			* description and tags, best match first. Mock scores are 1 for an exact match and 0.5
+			* otherwise; `mode` is accepted but there is no semantic search.
+			*/
+			search: async (options) => {
+				this.begin("assets.search", options);
+				const query = typeof options?.query === "string" ? options.query.trim() : "";
+				if (!query || query.length > 200) throw this.invalidPayload("query must be 1 to 200 characters");
+				const limit = options.limit ?? 10;
+				const needle = query.toLowerCase();
+				const fields = [
+					"name",
+					"id",
+					"externalId",
+					"description"
+				];
+				return {
+					query,
+					items: (await this.databaseStorage.listAssets(this.projectId)).map((asset) => {
+						const matchedFields = [];
+						for (const field of fields) if (String(asset[field] ?? "").toLowerCase().includes(needle)) matchedFields.push(field);
+						if (asset.tags?.some((tag) => tag.toLowerCase().includes(needle))) matchedFields.push("tags");
+						return {
+							asset,
+							score: fields.some((field) => String(asset[field] ?? "").toLowerCase() === needle) ? 1 : .5,
+							matchedFields
+						};
+					}).filter((result) => result.matchedFields.length > 0).sort((a, b) => b.score - a.score).slice(0, limit),
+					semanticStatus: "disabled"
 				};
-			}(),
-			update: function() {
-				var _ref8 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.update", options);
-					const { assetId } = options, body = _objectWithoutProperties(options, _excluded4);
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					const asset = yield _this5.databaseStorage.getAsset(assetId);
-					if (!asset || asset.projectId !== _this5.options.projectId) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
-					const changes = Object.fromEntries(Object.entries(body).filter(([, value]) => value !== void 0));
-					return _this5.databaseStorage.updateAsset(_objectSpread2(_objectSpread2(_objectSpread2({}, asset), changes), {}, { updatedAt: _this5.now() }));
+			},
+			/** Lists assets with the real client's paging, `ordering`, `folderId` and `filter`. */
+			list: async (options = {}) => {
+				this.begin("assets.list", options);
+				let assets = await this.databaseStorage.listAssets(this.projectId);
+				if (options.folderId !== void 0) assets = assets.filter((asset) => (asset.folderId ?? null) === options.folderId);
+				assets = filterAssets(assets, options.filter);
+				return createPage(orderItems(assets, options.ordering), {
+					...options,
+					pageIndex: options.pageIndex ?? 0
 				});
-				return function update(_x4) {
-					return _ref8.apply(this, arguments);
-				};
-			}(),
-			create: function() {
-				var _ref9 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.create", options);
-					return _this5.createAsset(options, _this5.queuedStatus);
+			},
+			iterate: (options = {}) => this.iteratePages((pageIndex) => this.assets.list({
+				...options,
+				pageIndex
+			})),
+			retrieve: async (options) => {
+				this.begin("assets.retrieve", options);
+				return this.findOwnAsset(options?.assetId);
+			},
+			listChildren: async (childrenOptions = {}) => {
+				this.begin("assets.listChildren", childrenOptions);
+				const { assetId, ...options } = childrenOptions;
+				encodePathSegment(assetId, "Asset ID");
+				const assets = await this.databaseStorage.listAssets(this.projectId);
+				return createPage(orderItems(assets.filter((asset) => asset.parentId === assetId), options.ordering), {
+					...options,
+					pageIndex: options.pageIndex ?? 0
 				});
-				return function create(_x5) {
-					return _ref9.apply(this, arguments);
-				};
-			}(),
-			moderate: function() {
-				var _ref10 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.moderate", options);
-					return _this5.moderateAsset(options);
+			},
+			iterateChildren: (options) => {
+				encodePathSegment(options?.assetId, "Asset ID");
+				return this.iteratePages((pageIndex) => this.assets.listChildren({
+					...options,
+					pageIndex
+				}));
+			},
+			update: async (options) => {
+				this.begin("assets.update", options);
+				const { assetId, ...body } = options;
+				const asset = await this.findOwnAsset(assetId);
+				const changes = Object.fromEntries(Object.entries(body).filter(([, value]) => value !== void 0));
+				return this.databaseStorage.updateAsset({
+					...asset,
+					...changes,
+					updatedAt: this.now()
 				});
-				return function moderate(_x6) {
-					return _ref10.apply(this, arguments);
-				};
-			}(),
-			uploadPart: function() {
-				var _ref11 = _asyncToGenerator(function* (options) {
-					var _asset$uploadPartsRec;
-					_this5.begin("assets.uploadPart", options);
-					const { assetId, part } = options;
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					if (!part) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Part options are required" });
-					const asset = yield _this5.databaseStorage.getAsset(assetId);
-					if (!asset) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
+			},
+			create: async (options) => {
+				this.begin("assets.create", options);
+				return this.withIdempotency("assets.create", options, () => this.createAsset(options, true));
+			},
+			moderate: async (options) => {
+				this.begin("assets.moderate", options);
+				return this.moderateAsset(options, "assets.moderate");
+			},
+			/** Continues a multipart upload: parts must arrive in order while it is `uploading`. */
+			uploadPart: async (options) => {
+				this.begin("assets.uploadPart", options);
+				const { assetId, part } = options;
+				encodePathSegment(assetId, "Asset ID");
+				if (!part) throw invalidArgument("Part options are required");
+				return this.withIdempotency("assets.uploadPart", options, async () => {
+					const asset = await this.findOwnAsset(assetId);
 					const validation = validateAssetPayload(part, {
 						multipart: true,
 						isFinal: part.isFinal
 					});
-					if (!validation.ok) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
-					yield _this5.imageStorage.putPart(assetId, part);
-					const updated = _objectSpread2(_objectSpread2({}, asset), {}, {
-						status: part.isFinal ? _this5.queuedStatus : "uploading",
-						uploadPartsReceived: Math.max((_asset$uploadPartsRec = asset.uploadPartsReceived) !== null && _asset$uploadPartsRec !== void 0 ? _asset$uploadPartsRec : 0, part.partNumber),
-						updatedAt: _this5.now()
+					if (!validation.ok) throw this.invalidPayload(validation.error);
+					if (asset.status !== "uploading") throw this.apiError(API_ERROR_CODES.UPLOAD_NOT_OPEN);
+					const expectedPartNumber = (asset.uploadPartsReceived ?? 1) + 1;
+					if (part.partNumber !== expectedPartNumber) throw this.apiError(API_ERROR_CODES.INVALID_UPLOAD_PART_NUMBER, { details: { expectedPartNumber } });
+					await this.imageStorage.putPart(assetId, part);
+					const queue = options.queue ?? this.uploadQueues.get(assetId) ?? false;
+					if (part.isFinal) this.uploadQueues.delete(assetId);
+					return this.databaseStorage.updateAsset({
+						...asset,
+						status: part.isFinal ? queue ? this.queuedStatus : this.analyzedStatus : "uploading",
+						uploadPartsReceived: part.partNumber,
+						updatedAt: this.now()
 					});
-					return _this5.databaseStorage.updateAsset(updated);
-				});
-				return function uploadPart(_x7) {
-					return _ref11.apply(this, arguments);
-				};
-			}(),
-			createSignedUrl: function() {
-				var _ref12 = _asyncToGenerator(function* (signedUrlOptions) {
-					var _options$expiresInSec, _options$resource2;
-					_this5.begin("assets.createSignedUrl", signedUrlOptions);
-					const { assetId } = signedUrlOptions, options = _objectWithoutProperties(signedUrlOptions, _excluded5);
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					if (!(yield _this5.databaseStorage.getAsset(assetId))) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
-					const expiresInSeconds = (_options$expiresInSec = options.expiresInSeconds) !== null && _options$expiresInSec !== void 0 ? _options$expiresInSec : 900;
-					const resource = (_options$resource2 = options.resource) !== null && _options$resource2 !== void 0 ? _options$resource2 : "content";
-					if (options.lens && options.transform) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Specify either a lens or a transform, not both" });
-					const selector = options.lens ? `&lens=${encodeURIComponent(options.lens)}` : options.transform ? `&transform=${encodeURIComponent(options.transform)}` : "";
-					return {
-						url: `${_this5.signedUrlBaseUrl}/assets/${assetId}/${resource}?expiresInSeconds=${expiresInSeconds}${selector}`,
-						expiresAt: _this5.now() + expiresInSeconds * 1e3
-					};
 				});
-				return function createSignedUrl(_x8) {
-					return _ref12.apply(this, arguments);
-				};
-			}(),
-			move: function() {
-				var _ref13 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.move", options);
-					const { assetId, folderId } = options;
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					const asset = yield _this5.databaseStorage.getAsset(assetId);
-					if (!asset || asset.projectId !== _this5.options.projectId) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
-					if (folderId !== null && folderId !== void 0) {
-						if (!(yield _this5.resolveFolder(folderId))) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-					}
-					const updated = _objectSpread2(_objectSpread2({}, asset), {}, {
-						folderId: folderId !== null && folderId !== void 0 ? folderId : null,
-						updatedAt: _this5.now()
-					});
-					return _this5.databaseStorage.updateAsset(updated);
-				});
-				return function move(_x9) {
-					return _ref13.apply(this, arguments);
+			},
+			createSignedUrl: async (signedUrlOptions) => {
+				this.begin("assets.createSignedUrl", signedUrlOptions);
+				const { assetId, ...options } = signedUrlOptions;
+				const asset = await this.findOwnAsset(assetId);
+				if (options.lens && options.transform) throw invalidArgument("Specify either a lens or a transform, not both");
+				const expiresInSeconds = options.expiresInSeconds ?? 900;
+				const resource = options.resource ?? "content";
+				const selector = options.lens ? `&lens=${encodeURIComponent(options.lens)}` : options.transform ? `&transform=${encodeURIComponent(options.transform)}` : "";
+				return {
+					url: `${this.signedUrlBaseUrl}/assets/${asset.id}/${resource}?expiresInSeconds=${expiresInSeconds}${selector}`,
+					expiresAt: this.now() + expiresInSeconds * 1e3
 				};
-			}(),
-			retry: function() {
-				var _ref14 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.retry", options);
-					const { assetId } = options;
-					if (!assetId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset ID is required" });
-					const asset = yield _this5.databaseStorage.getAsset(assetId);
-					if (!asset || asset.projectId !== _this5.options.projectId) throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_FOUND);
-					if (asset.status !== "error") throw calmLensError(PUBLIC_ERROR_CODES.ASSET_NOT_RETRYABLE);
-					return _this5.databaseStorage.updateAsset(_objectSpread2(_objectSpread2({}, asset), {}, {
-						status: "pending",
-						updatedAt: _this5.now()
-					}));
+			},
+			move: async (options) => {
+				this.begin("assets.move", options);
+				const { assetId, folderId } = options;
+				const asset = await this.findOwnAsset(assetId);
+				if (folderId !== null && folderId !== void 0) {
+					if (!await this.resolveFolder(folderId)) throw this.apiError(API_ERROR_CODES.FOLDER_NOT_FOUND);
+				}
+				return this.databaseStorage.updateAsset({
+					...asset,
+					folderId: folderId ?? null,
+					updatedAt: this.now()
 				});
-				return function retry(_x10) {
-					return _ref14.apply(this, arguments);
-				};
-			}(),
-			deleteContent: function() {
-				var _ref15 = _asyncToGenerator(function* (options) {
-					var _asset$storageDeleted;
-					_this5.begin("assets.deleteContent", options);
-					const asset = yield _this5.findOwnAsset(options.assetId);
-					yield _this5.imageStorage.deleteContent(asset.id);
-					return _this5.databaseStorage.updateAsset(_objectSpread2(_objectSpread2({}, asset), {}, {
-						extractedText: null,
-						storageDeletedAt: (_asset$storageDeleted = asset.storageDeletedAt) !== null && _asset$storageDeleted !== void 0 ? _asset$storageDeleted : _this5.now(),
-						updatedAt: _this5.now()
-					}));
+			},
+			retry: async (options) => {
+				this.begin("assets.retry", options);
+				const asset = await this.findOwnAsset(options?.assetId);
+				if (asset.status !== "error") throw this.apiError(API_ERROR_CODES.ASSET_NOT_RETRYABLE);
+				if (asset.storageDeletedAt) throw this.apiError(API_ERROR_CODES.ASSET_CONTENT_UNAVAILABLE);
+				return this.databaseStorage.updateAsset({
+					...asset,
+					status: "pending",
+					updatedAt: this.now()
 				});
-				return function deleteContent(_x11) {
-					return _ref15.apply(this, arguments);
-				};
-			}(),
-			delete: function() {
-				var _ref16 = _asyncToGenerator(function* (options) {
-					_this5.begin("assets.delete", options);
-					const asset = yield _this5.findOwnAsset(options.assetId);
-					yield _this5.imageStorage.deleteContent(asset.id);
-					yield _this5.databaseStorage.deleteAsset(asset.id);
+			},
+			deleteContent: async (options) => {
+				this.begin("assets.deleteContent", options);
+				const asset = await this.findOwnAsset(options?.assetId);
+				await this.imageStorage.deleteContent(asset.id);
+				return this.databaseStorage.updateAsset({
+					...asset,
+					extractedText: null,
+					storageDeletedAt: asset.storageDeletedAt ?? this.now(),
+					updatedAt: this.now()
 				});
-				return function _delete(_x12) {
-					return _ref16.apply(this, arguments);
-				};
-			}()
+			},
+			delete: async (options) => {
+				this.begin("assets.delete", options);
+				const asset = await this.findOwnAsset(options?.assetId);
+				await this.imageStorage.deleteContent(asset.id);
+				await this.databaseStorage.deleteAsset(asset.id);
+			}
 		};
 	}
 	get folders() {
-		var _this6 = this;
 		return {
-			list: function() {
-				var _ref17 = _asyncToGenerator(function* () {
-					_this6.begin("folders.list", void 0);
-					return [..._this6.databaseStorage.listFolders ? yield _this6.databaseStorage.listFolders(_this6.options.projectId) : []].sort((a, b) => a.name.localeCompare(b.name));
-				});
-				return function list() {
-					return _ref17.apply(this, arguments);
-				};
-			}(),
-			retrieve: function() {
-				var _ref18 = _asyncToGenerator(function* (options) {
-					_this6.begin("folders.retrieve", options);
-					const { folderId } = options;
-					if (!folderId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Folder ID is required" });
-					const folder = yield _this6.resolveFolder(folderId);
-					if (!folder) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-					return folder;
-				});
-				return function retrieve(_x13) {
-					return _ref18.apply(this, arguments);
-				};
-			}(),
-			create: function() {
-				var _ref19 = _asyncToGenerator(function* (options) {
-					var _options$parentId, _options$parentId2;
-					_this6.begin("folders.create", options);
-					if (!options.name) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Folder name is required" });
-					if (options.parentId) {
-						if (!(yield _this6.resolveFolder(options.parentId))) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-					}
-					yield _this6.assertUniqueFolderName(options.name, (_options$parentId = options.parentId) !== null && _options$parentId !== void 0 ? _options$parentId : null);
-					const folder = {
-						id: _this6.createId(),
-						projectId: _this6.options.projectId,
-						parentId: (_options$parentId2 = options.parentId) !== null && _options$parentId2 !== void 0 ? _options$parentId2 : null,
-						name: options.name,
-						createdAt: _this6.now(),
-						updatedAt: _this6.now()
-					};
-					if (_this6.databaseStorage.createFolder) return yield _this6.databaseStorage.createFolder(folder);
-					return folder;
-				});
-				return function create(_x14) {
-					return _ref19.apply(this, arguments);
-				};
-			}(),
-			update: function() {
-				var _ref20 = _asyncToGenerator(function* (options) {
-					_this6.begin("folders.update", options);
-					const { folderId } = options, body = _objectWithoutProperties(options, _excluded6);
-					if (!folderId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Folder ID is required" });
-					const folder = yield _this6.resolveFolder(folderId);
-					if (!folder) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-					if (body.name !== void 0 && body.name !== folder.name) {
-						var _folder$parentId;
-						yield _this6.assertUniqueFolderName(body.name, (_folder$parentId = folder.parentId) !== null && _folder$parentId !== void 0 ? _folder$parentId : null, folderId);
-					}
-					const updated = _objectSpread2(_objectSpread2(_objectSpread2({}, folder), body.name !== void 0 ? { name: body.name } : {}), {}, { updatedAt: _this6.now() });
-					if (_this6.databaseStorage.updateFolder) return yield _this6.databaseStorage.updateFolder(updated);
-					return updated;
-				});
-				return function update(_x15) {
-					return _ref20.apply(this, arguments);
+			list: async () => {
+				this.begin("folders.list", void 0);
+				return [...this.databaseStorage.listFolders ? await this.databaseStorage.listFolders(this.projectId) : []].sort((a, b) => a.name.localeCompare(b.name));
+			},
+			retrieve: async (options) => {
+				this.begin("folders.retrieve", options);
+				return this.findOwnFolder(options?.folderId);
+			},
+			create: async (options) => {
+				this.begin("folders.create", options);
+				if (!options?.name) throw this.invalidPayload("Folder name is required");
+				if (options.parentId) await this.findOwnFolder(options.parentId);
+				await this.assertUniqueFolderName(options.name, options.parentId ?? null);
+				const folder = {
+					id: this.createId(),
+					projectId: this.projectId,
+					parentId: options.parentId ?? null,
+					name: options.name,
+					createdAt: this.now(),
+					updatedAt: this.now()
 				};
-			}(),
-			delete: function() {
-				var _ref21 = _asyncToGenerator(function* (options) {
-					_this6.begin("folders.delete", options);
-					const { folderId } = options;
-					if (!folderId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Folder ID is required" });
-					if (!(yield _this6.resolveFolder(folderId))) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-					const hasAssets = (yield _this6.databaseStorage.listAssets(_this6.options.projectId)).some((asset) => asset.folderId === folderId);
-					const hasChildren = (_this6.databaseStorage.listFolders ? yield _this6.databaseStorage.listFolders(_this6.options.projectId) : []).some((f) => f.parentId === folderId);
-					if (hasAssets || hasChildren) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_EMPTY, { details: {
-						hasAssets,
-						hasChildren
-					} });
-					if (_this6.databaseStorage.deleteFolder) yield _this6.databaseStorage.deleteFolder(folderId);
-				});
-				return function _delete(_x16) {
-					return _ref21.apply(this, arguments);
+				return this.databaseStorage.createFolder ? await this.databaseStorage.createFolder(folder) : folder;
+			},
+			update: async (options) => {
+				this.begin("folders.update", options);
+				const { folderId, ...body } = options;
+				const folder = await this.findOwnFolder(folderId);
+				if (body.name !== void 0 && body.name !== folder.name) await this.assertUniqueFolderName(body.name, folder.parentId ?? null, folderId);
+				const updated = {
+					...folder,
+					...body.name !== void 0 ? { name: body.name } : {},
+					updatedAt: this.now()
 				};
-			}(),
-			move: function() {
-				var _ref22 = _asyncToGenerator(function* (options) {
-					_this6.begin("folders.move", options);
-					const { folderId, parentId } = options;
-					if (!folderId) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Folder ID is required" });
-					const folder = yield _this6.resolveFolder(folderId);
-					if (!folder) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-					const targetParentId = parentId !== null && parentId !== void 0 ? parentId : null;
-					if (targetParentId) {
-						const parent = yield _this6.resolveFolder(targetParentId);
-						if (!parent) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_NOT_FOUND);
-						let candidate = parent;
-						const visited = /* @__PURE__ */ new Set();
-						while (candidate) {
-							if (candidate.id === folderId || visited.has(candidate.id)) throw calmLensError(PUBLIC_ERROR_CODES.FOLDER_PARENT_CYCLE);
-							visited.add(candidate.id);
-							candidate = candidate.parentId ? yield _this6.resolveFolder(candidate.parentId) : void 0;
-						}
+				return this.databaseStorage.updateFolder ? await this.databaseStorage.updateFolder(updated) : updated;
+			},
+			delete: async (options) => {
+				this.begin("folders.delete", options);
+				const { folderId } = options;
+				await this.findOwnFolder(folderId);
+				const hasAssets = (await this.databaseStorage.listAssets(this.projectId)).some((asset) => asset.folderId === folderId);
+				const hasChildren = (this.databaseStorage.listFolders ? await this.databaseStorage.listFolders(this.projectId) : []).some((f) => f.parentId === folderId);
+				if (hasAssets || hasChildren) throw this.apiError(API_ERROR_CODES.FOLDER_NOT_EMPTY, { details: {
+					hasAssets,
+					hasChildren
+				} });
+				await this.databaseStorage.deleteFolder?.(folderId);
+			},
+			move: async (options) => {
+				this.begin("folders.move", options);
+				const { folderId, parentId } = options;
+				const folder = await this.findOwnFolder(folderId);
+				const targetParentId = parentId ?? null;
+				if (targetParentId) {
+					let candidate = await this.findOwnFolder(targetParentId);
+					const visited = /* @__PURE__ */ new Set();
+					while (candidate) {
+						if (candidate.id === folderId || visited.has(candidate.id)) throw this.apiError(API_ERROR_CODES.FOLDER_PARENT_CYCLE);
+						visited.add(candidate.id);
+						candidate = candidate.parentId ? await this.resolveFolder(candidate.parentId) : void 0;
 					}
-					if (targetParentId !== folder.parentId) yield _this6.assertUniqueFolderName(folder.name, targetParentId, folderId);
-					const updated = _objectSpread2(_objectSpread2({}, folder), {}, {
-						parentId: targetParentId,
-						updatedAt: _this6.now()
-					});
-					if (_this6.databaseStorage.updateFolder) return yield _this6.databaseStorage.updateFolder(updated);
-					return updated;
-				});
-				return function move(_x17) {
-					return _ref22.apply(this, arguments);
+				}
+				if (targetParentId !== folder.parentId) await this.assertUniqueFolderName(folder.name, targetParentId, folderId);
+				const updated = {
+					...folder,
+					parentId: targetParentId,
+					updatedAt: this.now()
 				};
-			}()
+				return this.databaseStorage.updateFolder ? await this.databaseStorage.updateFolder(updated) : updated;
+			}
 		};
 	}
-	ensureLens(options) {
-		var _this7 = this;
-		return _asyncToGenerator(function* () {
-			_this7.begin("ensureLens", options);
-			return _this7.ensureLensDefinition(options);
-		})();
+	async ensureLens(options) {
+		this.begin("ensureLens", options);
+		if (!options?.identifier) throw invalidArgument("Lens identifier is required");
+		return this.ensureLensDefinition(options);
 	}
 	ensureLensDefinition(options) {
-		var _existing$description, _options$description, _existing$transforms, _options$transforms;
 		const existing = this.lenses.get(options.identifier);
 		if (!existing) {
-			const lens = _objectSpread2(_objectSpread2({
+			const lens = {
 				id: this.createId(),
-				projectId: this.options.projectId,
-				userId: null
-			}, options), {}, {
+				projectId: this.projectId,
+				userId: null,
+				...options,
 				createdAt: this.now(),
 				updatedAt: this.now()
-			});
+			};
 			this.lenses.set(lens.identifier, lens);
 			return lens;
 		}
-		if (existing.name === options.name && ((_existing$description = existing.description) !== null && _existing$description !== void 0 ? _existing$description : null) === ((_options$description = options.description) !== null && _options$description !== void 0 ? _options$description : null) && existing.type === options.type && existing.active === options.active && stringifyJsonCanonical((_existing$transforms = existing.transforms) !== null && _existing$transforms !== void 0 ? _existing$transforms : null) === stringifyJsonCanonical((_options$transforms = options.transforms) !== null && _options$transforms !== void 0 ? _options$transforms : null) && existing.version === options.version) return existing;
+		if (existing.name === options.name && (existing.description ?? null) === (options.description ?? null) && existing.type === options.type && existing.active === options.active && stringifyJsonCanonical(existing.transforms ?? null) === stringifyJsonCanonical(options.transforms ?? null) && existing.version === options.version) return existing;
 		if (options.version > existing.version) {
-			const lens = _objectSpread2(_objectSpread2(_objectSpread2({}, existing), options), {}, { updatedAt: this.now() });
+			const lens = {
+				...existing,
+				...options,
+				updatedAt: this.now()
+			};
 			this.lenses.set(lens.identifier, lens);
 			return lens;
 		}
-		throw calmLensError(PUBLIC_ERROR_CODES.LENS_VERSION_CONFLICT, { details: {
+		throw this.apiError(API_ERROR_CODES.LENS_VERSION_CONFLICT, { details: {
 			currentVersion: existing.version,
 			minimumVersion: existing.version + 1,
 			requestedVersion: options.version
 		} });
 	}
-	ensureLenses(options) {
-		var _this8 = this;
-		return _asyncToGenerator(function* () {
-			_this8.begin("ensureLenses", options);
-			if (options.lenses.length === 0) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "At least one lens is required" });
-			return options.lenses.map((option) => _this8.ensureLensDefinition(option));
-		})();
-	}
-	moderateAsset(options) {
-		var _this9 = this;
-		return _asyncToGenerator(function* () {
-			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" });
-			return _this9.createAsset(options, _this9.analyzedStatus);
-		})();
-	}
-	createAsset(options, status) {
-		var _this10 = this;
-		return _asyncToGenerator(function* () {
-			var _options$folderId, _options$visibility, _options$part$partNum;
-			if (!("content" in options) && !("url" in options) && !("part" in options)) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Either file content, URL, or multipart part is required" });
-			if (!options.name) throw calmLensError(PUBLIC_ERROR_CODES.INVALID_UPLOAD_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) {
-				assertValidUploadMimeType(options.part.type);
-				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 });
+	async ensureLenses(options) {
+		this.begin("ensureLenses", options);
+		if (!Array.isArray(options?.lenses) || options.lenses.length === 0) throw invalidArgument("At least one lens is required");
+		if (options.lenses.some((lens) => !lens?.identifier)) throw invalidArgument("Lens identifier is required");
+		return options.lenses.map((option) => this.ensureLensDefinition(option));
+	}
+	/** Replays the first result for a reused idempotency key, like the API. */
+	async withIdempotency(operation, options, run) {
+		const key = options?.idempotencyKey;
+		if (key === void 0) return run();
+		if (!key || key.length > 255 || !/^[\x21-\x7e]+$/.test(key)) throw this.apiError(API_ERROR_CODES.INVALID_IDEMPOTENCY_KEY);
+		const fingerprint = `${operation}:${stringifyJsonCanonical(JSON.parse(JSON.stringify(options, (_key, value) => describeBinary(value))))}`;
+		const saved = this.idempotentResults.get(key);
+		if (saved) {
+			if (saved.fingerprint !== fingerprint) throw this.apiError(API_ERROR_CODES.IDEMPOTENCY_KEY_REUSED);
+			return saved.asset;
+		}
+		const asset = await run();
+		this.idempotentResults.set(key, {
+			fingerprint,
+			asset
+		});
+		return asset;
+	}
+	async moderateAsset(options, operation) {
+		if (options && "content" in options && "plainText" in options.content && (typeof options.content.plainText !== "string" || !options.content.plainText.trim())) throw this.invalidPayload("Text to moderate must be a non-empty string");
+		return this.withIdempotency(operation, options, () => this.createAsset(options, false));
+	}
+	async createAsset(options, queue) {
+		if (!options || typeof options !== "object") throw invalidArgument("Asset options are required");
+		if (!("content" in options) && !("url" in options) && !("part" in options)) throw this.invalidPayload("Either file content, URL, or multipart part is required");
+		if (!options.name) throw this.invalidPayload("Asset name is required");
+		if (!("part" in options) && "isFinal" in options) throw this.invalidPayload("isFinal is only valid for multipart uploads");
+		if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw this.apiError(API_ERROR_CODES.USE_UPLOAD_PART);
+		if ("content" in options) {
+			this.assertValidUploadMimeType(options.content.type);
+			if (!("plainText" in options.content)) {
+				const validation = validateAssetPayload(options.content);
+				if (!validation.ok) throw this.invalidPayload(validation.error);
 			}
-			const id = _this10.createId();
-			const now = _this10.now();
-			const type = inferAssetType(options);
-			const sizeInBytes = _this10.getSizeInBytes(options);
-			const asset = {
-				id,
-				projectId: _this10.options.projectId,
-				folderId: (_options$folderId = options.folderId) !== null && _options$folderId !== void 0 ? _options$folderId : null,
-				createdAt: now,
-				updatedAt: now,
-				name: options.name,
-				description: options.description,
-				externalId: options.externalId,
-				externalUrl: "url" in options ? options.url : "content" in options ? options.externalUrl : void 0,
-				type,
-				metadata: options.metadata,
-				status: "part" in options && !options.part.isFinal ? "uploading" : status,
-				processingOptions: options.processingOptions,
-				visibility: (_options$visibility = options.visibility) !== null && _options$visibility !== void 0 ? _options$visibility : "private",
-				sizeInBytes,
-				uploadPartsReceived: "part" in options ? (_options$part$partNum = options.part.partNumber) !== null && _options$part$partNum !== void 0 ? _options$part$partNum : 1 : void 0
-			};
-			if ("content" in options) {
-				if (!("plainText" in options.content)) yield _this10.imageStorage.putContent(id, options.content);
-			} else if ("part" in options) yield _this10.imageStorage.putPart(id, options.part);
-			return _this10.databaseStorage.createAsset(asset);
-		})();
-	}
-	resolveFolder(folderId) {
-		var _this11 = this;
-		return _asyncToGenerator(function* () {
-			if (!_this11.databaseStorage.getFolder) return void 0;
-			const folder = yield _this11.databaseStorage.getFolder(folderId);
-			if (!folder || folder.projectId !== _this11.options.projectId) return;
-			return folder;
-		})();
-	}
-	assertUniqueFolderName(name, parentId, excludeFolderId) {
-		var _this12 = this;
-		return _asyncToGenerator(function* () {
-			if ((_this12.databaseStorage.listFolders ? yield _this12.databaseStorage.listFolders(_this12.options.projectId) : []).find((f) => f.id !== excludeFolderId && f.parentId === (parentId !== null && parentId !== void 0 ? parentId : null) && f.name === name)) throw calmLensError(PUBLIC_ERROR_CODES.DUPLICATE_FOLDER_NAME, { message: `A folder named "${name}" already exists in this location.` });
-		})();
+		}
+		if ("part" in options) {
+			this.assertValidUploadMimeType(options.part.type);
+			const validation = validateAssetPayload(options.part, {
+				multipart: true,
+				isFinal: options.part.isFinal
+			});
+			if (!validation.ok) throw this.invalidPayload(validation.error);
+		}
+		if (options.externalId) {
+			if ((await this.databaseStorage.listAssets(this.projectId)).some((asset) => asset.externalId === options.externalId)) throw this.apiError(API_ERROR_CODES.DUPLICATE_EXTERNAL_ID);
+		}
+		const id = this.createId();
+		const now = this.now();
+		const isOpenUpload = "part" in options && !options.part.isFinal;
+		const asset = {
+			id,
+			projectId: this.projectId,
+			folderId: options.folderId ?? null,
+			createdAt: now,
+			updatedAt: now,
+			name: options.name,
+			description: options.description,
+			externalId: options.externalId,
+			externalUrl: "url" in options ? options.url : "content" in options ? options.externalUrl : void 0,
+			type: inferAssetType(options),
+			metadata: options.metadata,
+			status: isOpenUpload ? "uploading" : queue ? this.queuedStatus : this.analyzedStatus,
+			processingOptions: options.processingOptions,
+			visibility: options.visibility ?? "private",
+			sizeInBytes: this.getSizeInBytes(options),
+			uploadPartsReceived: "part" in options ? options.part.partNumber ?? 1 : void 0
+		};
+		if ("content" in options) {
+			if (!("plainText" in options.content)) await this.imageStorage.putContent(id, options.content);
+		} else if ("part" in options) {
+			await this.imageStorage.putPart(id, options.part);
+			if (isOpenUpload) this.uploadQueues.set(id, queue);
+		}
+		return this.databaseStorage.createAsset(asset);
+	}
+	async resolveFolder(folderId) {
+		if (!this.databaseStorage.getFolder) return void 0;
+		const folder = await this.databaseStorage.getFolder(folderId);
+		if (!folder || folder.projectId !== this.projectId) return;
+		return folder;
+	}
+	async findOwnFolder(folderId) {
+		encodePathSegment(folderId, "Folder ID");
+		const folder = await this.resolveFolder(folderId);
+		if (!folder) throw this.apiError(API_ERROR_CODES.FOLDER_NOT_FOUND);
+		return folder;
+	}
+	async assertUniqueFolderName(name, parentId, excludeFolderId) {
+		if ((this.databaseStorage.listFolders ? await this.databaseStorage.listFolders(this.projectId) : []).find((f) => f.id !== excludeFolderId && f.parentId === (parentId ?? null) && f.name === name)) throw this.apiError(API_ERROR_CODES.DUPLICATE_FOLDER_NAME, { message: `A folder named "${name}" already exists in this location.` });
 	}
 	getSizeInBytes(options) {
 		if ("content" in options) {
 			if ("plainText" in options.content) return new TextEncoder().encode(options.content.plainText).byteLength;
 			return getAssetPayloadByteLength(options.content);
 		}
-		if ("part" in options) {
-			var _options$sizeInBytes;
-			return (_options$sizeInBytes = options.sizeInBytes) !== null && _options$sizeInBytes !== void 0 ? _options$sizeInBytes : getAssetPayloadByteLength(options.part);
-		}
+		if ("part" in options) return options.part.sizeInBytes ?? options.sizeInBytes ?? getAssetPayloadByteLength(options.part);
+	}
+};
+//#endregion
+//#region src/testing/MockWebhooks.ts
+/** The JSON body of a webhook delivery for a stored event (or an event from `events.list`). */
+const toWebhookEventPayload = (event) => ({
+	id: event.id,
+	type: event.type,
+	createdAt: event.createdAt,
+	projectId: event.projectId,
+	data: {
+		severity: event.severity,
+		title: event.title,
+		description: event.description ?? null,
+		assetId: event.assetId ?? null,
+		asset: event.asset ?? null,
+		facts: event.facts
 	}
+});
+/** `v1=<hex HMAC-SHA256 of "<timestamp>.<body>">`, the `x-calmlens-signature` header value. */
+const createWebhookSignatureHeader = async (secret, timestamp, body) => `v1=${await hmacSha256Hex(secret, `${timestamp}.${body}`)}`;
+/** Headers for one signed delivery of `body`, as CalmLens sends them. */
+const createWebhookHeaders = async (options) => {
+	const timestamp = options.timestampSeconds ?? Math.floor(Date.now() / 1e3);
+	return {
+		"content-type": "application/json",
+		[WEBHOOK_DELIVERY_HEADER]: options.deliveryId,
+		[WEBHOOK_TIMESTAMP_HEADER]: String(timestamp),
+		[WEBHOOK_SIGNATURE_HEADER]: await createWebhookSignatureHeader(options.secret, timestamp, options.body)
+	};
 };
 //#endregion
-export { InMemoryMockDatabaseStorage, InMemoryMockImageStorage, MOCK_API_KEY_PREFIX, MockCalmLensClient, createMockApiKey };
+export { InMemoryMockDatabaseStorage, InMemoryMockImageStorage, MEDIA_TEST_SIGNALS, MOCK_API_KEY_PREFIX, MockCalmLensClient, createMockApiKey, createWebhookHeaders, createWebhookSignatureHeader, generateMediaTestCode, toWebhookEventPayload };