@calmlens/sdk 0.16.2 → 0.17.1

package/esm/testing.js

@@ -1,10 +1,39 @@
-import { c as invalidArgument, d as API_ERROR_DEFINITIONS, o as CalmLensError, s as SDK_ERROR_CODES, u as API_ERROR_CODES } from "./CalmLensVersion-l_khh4nS.js";
-import { c as hmacSha256Hex, i as WEBHOOK_TIMESTAMP_HEADER, l as stringifyJsonCanonical, n as WEBHOOK_SIGNATURE_HEADER, s as signUploadTokenWithApiKey, t as WEBHOOK_DELIVERY_HEADER } from "./CalmLensWebhooks-BtrKKLvg.js";
-import { b as getRejectedUploadMimeTypeError, f as sleep, g as validateAssetPayload, h as getAssetPayloadByteLength, m as assetToData, n as encodePathSegment, o as toTextAssetOptions, p as assetDataToUint8Array, r as pollForDecision, s as transformSelector, t as appendCdnSelector, u as validateServerClientOptions, x as isRejectedUploadMimeType } from "./CalmLensUtils-DqniTKJ8.js";
+import { A as invalidArgument, C as MAX_IMAGE_UPLOAD_BYTES, E as isRejectedUploadMimeType, M as API_ERROR_CODES, N as API_ERROR_DEFINITIONS, O as CalmLensError, T as getRejectedUploadMimeTypeError, _ as validateAppClientOptions, b as validateServerClientOptions, f as randomUuid, j as invalidConfig, k as SDK_ERROR_CODES, r as selectModerationContextItems, w as MIN_MULTIPART_IMAGE_UPLOAD_BYTES } from "./ModerationContextLimits-D1x_WAtP.js";
+import { a as WEBHOOK_TIMESTAMP_HEADER, l as signUploadTokenWithApiKey, n as WEBHOOK_DELIVERY_HEADER, r as WEBHOOK_SIGNATURE_HEADER, t as CalmLensServerClient, u as stringifyJsonCanonical } from "./CalmLensServerClient-fQEYKLw4.js";
+import { d as assetDataToUint8Array, f as assetToData, n as MOCK_HOOKS, p as validateAssetPayload, u as sleep } from "./CalmLensConnection-iyNQHA8L.js";
+import { t as hmacSha256Hex } from "./CryptoUtils-B_x8lMIx-DhuWGzqn.js";
+import { t as CalmLensAppClient } from "./CalmLensAppClient-FVMwrHlH.js";
+import { a as placeholderHashToDataURL, r as isFileAccepted } from "./UploadController-txp5NuzH.js";
+import { s as getTestInputTag, u as CLASSIFICATION_CATEGORIES } from "./TestTriggers-DcArt0Nu-s0AQZuWE.js";
 import * as zod from "zod";
-//#region src/contract/Classification-CGDEzhxh.js
+// src/contract/MediaTestTriggers.js
+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. */
+async function generateMediaTestCode(signal, testInputKey) {
+	if (!MEDIA_TEST_SIGNALS.includes(signal)) throw new RangeError("Unsupported media test signal");
+	return `Calm Lens test ${[...await getTestInputTag("media", signal, testInputKey)].map((character) => HEX_WORDS[Number.parseInt(character, 16)]).join(" ")} ${signal.replace(/[.-]/g, " ")} end test`;
+}
+// src/contract/Ids-aHyP9ZcF.js
 var __defProp = Object.defineProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -346,6 +375,17 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
 	return typeof message === "string" ? message : message?.message;
 }
+/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
+function sizeCaps(defChecks) {
+	const caps = [];
+	for (const ch of defChecks ?? []) {
+		const d = ch._zod.def;
+		if (!/_(length|size)$|_equals$/.test(d.check)) break;
+		const max = d.maximum ?? d.length ?? d.size;
+		if (max >= 0) caps.push([max, ch]);
+	}
+	return caps;
+}
 function attachSchema(issues, start, inst) {
 	var _a;
 	for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);
@@ -444,6 +484,7 @@ function hide(inst, key, value) {
 	return own(inst, key, value, false);
 }
 /** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
+/* @__NO_SIDE_EFFECTS__ */
 function derived(computes, table) {
 	for (const key in computes) {
 		const compute = computes[key];
@@ -593,6 +634,7 @@ function newError(Definition) {
 	}
 	return new Definition();
 }
+/* @__NO_SIDE_EFFECTS__ */
 function $constructor(name, initializer, proto, params) {
 	const zodProto = {};
 	function Internals(def) {
@@ -721,8 +763,8 @@ const initializer$1 = (inst, def) => {
 		});
 	}
 };
-const $ZodError = $constructor("$ZodError", initializer$1);
-const $ZodRealError = $constructor("$ZodError", initializer$1, void 0, { Parent: Error });
+const $ZodError = /* @__PURE__ */ $constructor("$ZodError", initializer$1);
+const $ZodRealError = /* @__PURE__ */ $constructor("$ZodError", initializer$1, void 0, { Parent: Error });
 /** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
 * ("toString", "constructor") would otherwise read through to the prototype, and assigning
 * "__proto__" would hit the setter instead of creating a key. */
@@ -1656,7 +1698,7 @@ var Doc = class {
 const version = {
 	major: 4,
 	minor: 6,
-	patch: 5
+	patch: 7
 };
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
 	var _a;
@@ -2348,6 +2390,28 @@ const $ZodDate = /*@__PURE__*/ $constructor("$ZodDate", (inst, def) => {
 		return payload;
 	};
 });
+function capSize(inst, size) {
+	const caps = sizeCaps(inst._zod.def.checks);
+	if (!caps.length) return;
+	const cap = Math.min(...caps.map((c) => c[0]));
+	const parse = inst._zod.parse;
+	inst._zod.parse = (payload, ctx) => {
+		const n = size(payload.value);
+		if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+			for (const [max, ch] of sizeCaps(inst._zod.def.checks)) if (n > max && ch._zod.def.when(payload)) {
+				const start = payload.issues.length;
+				ch._zod.check(payload);
+				payload.issues[start].continue = false;
+				attachSchema(payload.issues, start, inst);
+				return payload;
+			}
+		}
+		return parse(payload, ctx);
+	};
+}
+const arraySize = (input) => Array.isArray(input) ? input.length : -1;
+const mapSize = (input) => input instanceof Map ? input.size : -1;
+const setSize = (input) => input instanceof Set ? input.size : -1;
 function handleArrayResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
@@ -2385,6 +2449,7 @@ const $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def) => {
 		if (proms.length) return Promise.all(proms).then(() => payload);
 		return payload;
 	};
+	capSize(inst, arraySize);
 });
 function handlePropertyResult(result, final, key, input, optin, optout) {
 	const isPresent = key in input;
@@ -2493,7 +2558,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 		}
 		return propValues;
 	});
-	const isObject$2 = isObject;
+	const isObject$1 = isObject;
 	const catchall = def.catchall;
 	let value;
 	const memo = globalConfig.memoizer;
@@ -2501,7 +2566,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$2(input)) {
+		if (!isObject$1(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2631,7 +2696,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
 		return doc.compile();
 	};
 	let fastpass;
-	const isObject$1 = isObject;
+	const isObject$2 = isObject;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -2639,7 +2704,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$1(input)) {
+		if (!isObject$2(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -3217,6 +3282,7 @@ const $ZodMap = /*@__PURE__*/ $constructor("$ZodMap", (inst, def) => {
 		if (proms.length) return Promise.all(proms).then(() => payload);
 		return payload;
 	};
+	capSize(inst, mapSize);
 });
 function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
 	if (keyResult.issues.length) {
@@ -3276,6 +3342,7 @@ const $ZodSet = /*@__PURE__*/ $constructor("$ZodSet", (inst, def) => {
 		if (proms.length) return Promise.all(proms).then(() => payload);
 		return payload;
 	};
+	capSize(inst, setSize);
 });
 function handleSetResult(result, final) {
 	if (result.issues.length) final.issues.push(...result.issues);
@@ -7761,214 +7828,6 @@ ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 	...schemas_exports,
 	...checks_exports
 });
-const ZOD_META_KEY = "__zod_meta__";
-const createMetaType = (type) => {
-	return Object.assign((value) => {
-		return {
-			type,
-			data: value ?? {}
-		};
-	}, type);
-};
-const metaStore = (meta) => {
-	const metaMap = meta.reduce((acc, meta) => {
-		if (meta) acc[meta.type.id] = meta;
-		return acc;
-	}, {});
-	return { [ZOD_META_KEY]: {
-		itemMap: metaMap,
-		get itemList() {
-			return Object.values(metaMap);
-		}
-	} };
-};
-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; dislike, ordinary criticism and neutral reporting alone 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: "Expressions of dislike or anger, such as \"I hate you\" or \"i hate u\", disagreement, ordinary criticism of conduct or competence, untargeted profanity and neutral reporting of abuse do not qualify on their own. Dislike can still qualify when accompanied by personal degradation, threats, serious intimidation or sustained bullying.",
-		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, fraud and scams, and illegal drugs or contraband.",
-		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. It also covers fraud, scams and phishing aimed at the reader, illegal drug use, dealing, production or trafficking, and contraband such as stolen goods, counterfeit money or documents and smuggled or illegally traded weapons.",
-		exclusions: "Neutral reporting, prevention, lawful safety advice, fiction without criminal assistance, and vague dangerous references do not qualify. Medical, pharmaceutical, clinical, research and educational content does not qualify, including prescriptions, dosages, side effects, controlled medicines used as prescribed, pharmacies, hospitals and drug manufacturing by pharmaceutical companies. Lawful alcohol and tobacco, harm reduction, addiction recovery and drug-policy discussion do not qualify either. Masks, computers, payment cards, detention or ordinary tools do not establish criminal facilitation by themselves. A clear visual demonstration of how to carry out a crime can qualify.",
-		docsHref: "/docs/guides/moderation-categories#criminal-and-dangerous-activity"
-	}
-};
-const MODERATION_QUALIFIERS = [
-	"sexual-nudity",
-	"sexual-activity",
-	"sexual-explicit-language",
-	"sexual-solicitation",
-	"sexual-historical",
-	"sexual-documentary",
-	"sexual-educational",
-	"sexual-fictional",
-	"sexual-support-prevention",
-	"violence-attack",
-	"violence-threat",
-	"violence-preparation",
-	"violence-encouragement",
-	"violence-injury",
-	"violence-violent-death",
-	"violence-natural-death",
-	"violence-graphic",
-	"violence-historical",
-	"violence-documentary",
-	"violence-educational",
-	"violence-fictional",
-	"violence-support-prevention",
-	"self-harm-thoughts",
-	"self-harm-preparation",
-	"self-harm-act",
-	"self-harm-methods",
-	"self-harm-encouragement",
-	"self-harm-documentary",
-	"self-harm-educational",
-	"self-harm-fictional",
-	"self-harm-support-prevention",
-	"harassment-abuse",
-	"harassment-intimidation",
-	"harassment-threat",
-	"harassment-sexual",
-	"harassment-encouragement",
-	"harassment-fictional",
-	"hate-abuse",
-	"hate-dehumanization",
-	"hate-inferiority",
-	"hate-exclusion",
-	"hate-threat",
-	"hate-historical",
-	"hate-fictional",
-	"criminal-activity-demonstration",
-	"criminal-activity-preparation",
-	"criminal-activity-request",
-	"criminal-activity-instructions",
-	"criminal-activity-promotion",
-	"criminal-activity-substances",
-	"criminal-activity-fraud",
-	"criminal-activity-fictional"
-];
-const docPropertyInfo = createMetaType({ id: "docPropertyInfo" });
-/**
-* Optional analyses a request can turn on with `processingOptions.features.<id>`. The catalog is
-* the single source for the request and result schemas, cache keys and metering. Features are
-* chosen per request only; there is no project-level default.
-*/
-/** How mature a feature is. Beta results may change shape. */
-const PROCESSING_FEATURE_STAGES = ["beta", "ga"];
-const createFeatureOptionsSchemas = (booleanSchema) => {
-	const enabled = booleanSchema.meta(metaStore([docPropertyInfo({ description: "Whether to run the feature. Every feature is off unless this is true." })]));
-	return {
-		ocr: zod.object({ enabled }).strict().meta(metaStore([docPropertyInfo({
-			description: "Extract image text into a child asset and run normal text moderation. Applies to images, including those extracted from multimedia documents and websites.",
-			namedType: "OcrFeatureOptions"
-		})])),
-		personDetection: zod.object({ enabled }).strict().meta(metaStore([docPropertyInfo({
-			description: "Beta. Locate people in images, including people whose faces are not visible. Results are informational and never change the moderation decision.",
-			namedType: "PersonDetectionFeatureOptions"
-		})])),
-		faceDetection: zod.object({
-			enabled,
-			ageEstimation: booleanSchema.optional().meta(metaStore([docPropertyInfo({
-				description: "Also estimate an age range for each face",
-				defaultValue: false
-			})]))
-		}).strict().meta(metaStore([docPropertyInfo({
-			description: "Beta. Locate faces in images and optionally estimate an age range for each. Faces are not identified or stored as biometric templates. Results are informational and never change the moderation decision.",
-			namedType: "FaceDetectionFeatureOptions"
-		})]))
-	};
-};
-const createProcessingFeaturesSchema = (booleanSchema) => {
-	const options = createFeatureOptionsSchemas(booleanSchema);
-	return zod.object({
-		ocr: options.ocr.nullish(),
-		personDetection: options.personDetection.nullish(),
-		faceDetection: options.faceDetection.nullish()
-	}).strict().meta(metaStore([docPropertyInfo({
-		description: "Optional analyses to run on this asset, keyed by feature. Unknown features are rejected.",
-		namedType: "ProcessingFeatures"
-	})]));
-};
-createProcessingFeaturesSchema(zod.boolean());
-/** Position and size as fractions of the image width and height, from 0 to 1. */
-const BOUNDING_BOX_SCHEMA = zod.object({
-	left: zod.number(),
-	top: zod.number(),
-	width: zod.number().min(0),
-	height: zod.number().min(0)
-}).strict().meta(metaStore([docPropertyInfo({
-	description: "Position and size as fractions of the image width and height, from 0 to 1. `left` and `top` can be slightly negative when the subject extends past the edge.",
-	namedType: "BoundingBox"
-})]));
-const DETECTION_CONFIDENCE_SCHEMA = zod.number().min(0).max(1).describe("Detection confidence from 0 to 1");
-const AGE_RANGE_SCHEMA = zod.object({
-	low: zod.number().int().nonnegative(),
-	high: zod.number().int().nonnegative()
-}).strict().meta(metaStore([docPropertyInfo({
-	description: "Estimated age range in years. Estimates can be off by several years.",
-	namedType: "AgeRange"
-})]));
-const DETECTED_PERSON_SCHEMA = zod.object({
-	box: BOUNDING_BOX_SCHEMA,
-	confidence: DETECTION_CONFIDENCE_SCHEMA
-}).strict().meta(metaStore([docPropertyInfo({
-	description: "A detected person",
-	namedType: "DetectedPerson"
-})]));
-const DETECTED_FACE_SCHEMA = zod.object({
-	box: BOUNDING_BOX_SCHEMA,
-	confidence: DETECTION_CONFIDENCE_SCHEMA,
-	ageRange: AGE_RANGE_SCHEMA.optional()
-}).strict().meta(metaStore([docPropertyInfo({
-	description: "A detected face",
-	namedType: "DetectedFace"
-})]));
-const NOT_EVALUATED_FEATURE_RESULT_SCHEMA = zod.object({
-	status: zod.literal("not-evaluated"),
-	stage: zod.enum(PROCESSING_FEATURE_STAGES),
-	reason: zod.enum(["not-supported", "unavailable"])
-}).strict();
-const createFeatureResultSchema = (shape) => zod.discriminatedUnion("status", [zod.object({
-	status: zod.literal("evaluated"),
-	stage: zod.enum(PROCESSING_FEATURE_STAGES),
-	...shape
-}).strict(), NOT_EVALUATED_FEATURE_RESULT_SCHEMA]);
-const PERSON_DETECTION_RESULT_SCHEMA = createFeatureResultSchema({ people: zod.array(DETECTED_PERSON_SCHEMA) });
-const FACE_DETECTION_RESULT_SCHEMA = createFeatureResultSchema({ faces: zod.array(DETECTED_FACE_SCHEMA) });
-const PROCESSING_FEATURE_RESULTS_SCHEMA = zod.object({
-	personDetection: PERSON_DETECTION_RESULT_SCHEMA.optional(),
-	faceDetection: FACE_DETECTION_RESULT_SCHEMA.optional()
-}).strict().meta(metaStore([docPropertyInfo({
-	description: "Results of the optional features requested in `processingOptions.features`, keyed by feature",
-	namedType: "ProcessingFeatureResults"
-})]));
 (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const CHARS_GLOBAL_BACKSLASH_SUPPORTED_RX = /[\0\b\t\n\r\x1a"'\\]/g;
 	const CHARS_ESCAPE_BACKSLASH_SUPPORTED_MAP = {
@@ -8025,166 +7884,106 @@ const PROCESSING_FEATURE_RESULTS_SCHEMA = zod.object({
 	}
 	module.exports = escapeString;
 })))();
-const SIZE_LIMITS = {
-	small: 64,
-	medium: 200,
-	large: 1500,
-	xlarge: 1e4,
-	token: 1e4
+/**
+* The prefix of every kind of object customers can see, so an ID says what it identifies:
+* `proj_8fK2mQx7Lp4NvB3tRz9Y` is a project. Rows that never leave the backend (usage meters, upload
+* token uses, retained variants, terms acceptances, notices) keep their own internal IDs.
+*/
+const ID_PREFIXES = {
+	organisation: "org",
+	project: "proj",
+	asset: "asset",
+	folder: "fldr",
+	lens: "lens",
+	apiKey: "key",
+	uploadPreset: "preset",
+	connector: "conn",
+	connectorDelivery: "dlv",
+	hashList: "hl",
+	hashListEntry: "hle",
+	policy: "pol",
+	event: "evt",
+	user: "user",
+	member: "mem",
+	invitation: "inv",
+	supportTicket: "tkt",
+	supportTicketMessage: "msg",
+	humanReview: "rev",
+	appeal: "apl",
+	complianceCase: "case",
+	safetyHold: "hold",
+	creditPurchase: "cp",
+	oauthClient: "oac",
+	waitlistEntry: "wl"
 };
-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 ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const ID_BODY = `[0-9A-Za-z]{20}`;
+const ID_PREFIX_VALUES = new Set(Object.values(ID_PREFIXES));
+const patterns = /* @__PURE__ */ new Map();
+/** Matches one ID with `prefix`, or any registered prefix when none is given. */
+const idPattern = (prefix) => {
+	const key = prefix ?? "";
+	let pattern = patterns.get(key);
+	if (!pattern) {
+		const prefixes = prefix ? prefix : [...ID_PREFIX_VALUES].join("|");
+		pattern = new RegExp(`^(?:${prefixes})_${ID_BODY}$`);
+		patterns.set(key, pattern);
+	}
+	return pattern;
 };
-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"),
-	/** Evidence that some of the category's qualifying content is this qualifier. */
-	someScore: zod.number().min(0).max(1),
-	/** Evidence that only this qualifier is in it: all of the qualifying content is one. */
-	allScore: zod.number().min(0).max(1).optional(),
-	likelihood: LIKELIHOOD_SCHEMA
-}).strict().refine(({ someScore, allScore }) => allScore === void 0 || allScore <= someScore, {
-	message: "The All score cannot exceed the Some score",
-	path: ["allScore"]
-}), 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();
-/** What a moderation policy does with a category: nothing, alert, hide or purge. */
-const FLAGGED_CONTENT_ACTION_SCHEMA = zod.enum([
-	"ignore",
-	"alert",
-	"hide",
-	"purge"
-]);
-/** What the project's policy made of the report when the asset was decided. */
-const CLASSIFICATION_REPORT_POLICY_SCHEMA = zod.object({
-	score: zod.number().min(0).max(1).describe("The highest category policy score."),
-	categories: zod.partialRecord(CLASSIFICATION_CATEGORY_SCHEMA, zod.object({
-		score: zod.number().min(0).max(1).describe("How strongly the content meets the policy, from 0 to 1: the category score, lowered by allowances that cover the content and raised to the presence score of a restriction."),
-		action: FLAGGED_CONTENT_ACTION_SCHEMA.describe("What the policy does with this category. `ignore` when the policy score is below the category threshold.")
-	}).strict()).describe("Each assessed category's policy score and action. Unassessed categories are left out.")
-}).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,
-	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(),
-	features: PROCESSING_FEATURE_RESULTS_SCHEMA.optional(),
-	policy: CLASSIFICATION_REPORT_POLICY_SCHEMA.optional().describe("What the project's moderation policy made of this report when the asset was decided. Absent until then.")
-}).strict();
-//#endregion
-//#region src/contract/MediaTestTriggers.js
-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, testInputKey) {
-	if (!MEDIA_TEST_SIGNALS.includes(signal)) throw new Error("Unsupported media test signal");
-	const suffix = testInputKey.toLowerCase();
-	if (!/^[a-f0-9]{8}$/.test(suffix)) throw new Error("Expected an eight-character hexadecimal test input key");
-	return `Calm Lens test ${[...suffix].map((character) => HEX_WORDS[Number.parseInt(character, 16)]).join(" ")} ${signal.replace(/[.-]/g, " ")} end test`;
-}
-//#endregion
-//#region src/contract/Permissions-B5dqc8aj.js
+/** Base62 characters from a CSPRNG, without modulo bias (bytes 248-255 are redrawn). */
+const randomBase62 = (length) => {
+	let result = "";
+	while (result.length < length) {
+		const bytes = crypto.getRandomValues(new Uint8Array(length * 2));
+		for (const byte of bytes) {
+			if (byte >= 248) continue;
+			result += ALPHABET[byte % 62];
+			if (result.length === length) break;
+		}
+	}
+	return result;
+};
+/** A new random ID, such as `newId("proj")` → `proj_8fK2mQx7Lp4NvB3tRz9Y`. */
+const newId = (prefix) => `${prefix}_${randomBase62(20)}`;
+/** Whether `value` is an ID with `prefix` (or with any registered prefix). */
+const isId = (value, prefix) => typeof value === "string" && idPattern(prefix).test(value);
+/** Example IDs for docs, OpenAPI and SDK fixtures: fixed, so generated output stays stable. */
+const EXAMPLE_IDS = {
+	org: "org_3hQ7tLk2Vb9XpR4mWc8N",
+	proj: "proj_8fK2mQx7Lp4NvB3tRz9Y",
+	asset: "asset_5Gm2Rk8XqT3wLp9VbN4c",
+	fldr: "fldr_7Nc4Wq2Lm8Xt5Rk9Bv3P",
+	lens: "lens_2Xr9Lp4Vm7Qk3Tb8Nw5C",
+	key: "key_9Pt3Wm6Rk2Lx8Qv4Nb7C",
+	preset: "preset_4Lk8Qw2Xm9Rt5Vb3Nc7P",
+	conn: "conn_6Rb2Xk9Lm4Qt7Wp3Nv8C",
+	dlv: "dlv_3Vm8Qk2Xt7Lp9Rb4Nw6C",
+	hl: "hl_5Xk3Rm9Lq2Vt8Wb4Np7C",
+	hle: "hle_8Qm4Xk2Rt9Lv3Wb7Np5C",
+	pol: "pol_2Wk7Rm4Xq9Lt3Vb8Np6C",
+	evt: "evt_7Lm3Xq8Rk2Vt9Wb4Np5C",
+	user: "user_4Rk9Xm2Lq7Vt3Wb8Np6C",
+	mem: "mem_9Xm4Rk7Lq2Vt8Wb3Np5C",
+	inv: "inv_3Qk8Xm2Rt9Lv4Wb7Np6C",
+	tkt: "tkt_6Xm2Rk9Lq4Vt7Wb3Np8C",
+	msg: "msg_2Rk7Xm4Lq9Vt3Wb8Np5C",
+	rev: "rev_8Xm3Rk2Lq7Vt9Wb4Np6C",
+	apl: "apl_4Qk9Xm7Rt2Lv8Wb3Np5C",
+	case: "case_7Xm2Rk4Lq9Vt3Wb8Np6C",
+	hold: "hold_3Rk8Xm2Lq7Vt4Wb9Np5C",
+	cp: "cp_9Qk4Xm7Rt3Lv8Wb2Np6C",
+	oac: "oac_5Xm9Rk3Lq2Vt7Wb4Np8C",
+	wl: "wl_2Qk7Xm4Rt9Lv3Wb8Np5C"
+};
+/**
+* A string field holding an ID with `prefix`: a string schema with a pattern, so OpenAPI and the
+* docs show the pattern and the example. Parsed values are typed `string`, not `Id<P>`: typing
+* every stored model's IDs by prefix is a separate change (it surfaces about a thousand call sites
+* across the packages that build records from plain strings).
+*/
+const idField = (prefix) => zod.string().regex(idPattern(prefix), { message: `Must be an ID starting with "${prefix}_"` }).meta({ examples: [EXAMPLE_IDS[prefix]] });
+// src/contract/Permissions-DjKQmOVp.js
 const ACTION_SCHEMA = zod.enum([
 	"assets:read",
 	"assets:download",
@@ -8210,6 +8009,8 @@ const ACTION_SCHEMA = zod.enum([
 	"lenses:write",
 	"upload-presets:read",
 	"upload-presets:write",
+	"hash-lists:read",
+	"hash-lists:write",
 	"reviews:read",
 	"reviews:write",
 	"project:manage"
@@ -8222,6 +8023,7 @@ const PROJECT_ACTIONS = [...[
 	"metadata",
 	"lenses",
 	"upload-presets",
+	"hash-lists",
 	"reviews"
 ].flatMap((feature) => [`${feature}:read`, `${feature}:write`]), "project:manage"];
 const isProjectAction = (action) => PROJECT_ACTIONS.includes(action);
@@ -8229,7 +8031,7 @@ const isProjectAction = (action) => PROJECT_ACTIONS.includes(action);
 const actionsImplying = (action) => !isProjectAction(action) || action === "project:manage" ? [] : action.endsWith(":read") ? [action.replace(/:read$/, ":write"), "project:manage"] : ["project:manage"];
 const GRANT_SCHEMA = zod.object({
 	actions: zod.array(ACTION_SCHEMA),
-	folderId: zod.string().uuid().nullable(),
+	folderId: idField("fldr").nullable(),
 	includeSubfolders: zod.boolean()
 }).strict().refine((g) => g.folderId === null || !g.actions.some(isProjectAction), "Project configuration permissions require project scope");
 const GRANTS_SCHEMA = zod.array(GRANT_SCHEMA).max(100);
@@ -8252,15 +8054,15 @@ const permits = (grants, action, folderId, folders) => grants.some((grant) => {
 	}
 	return false;
 });
-const SYSTEM_PERMISSION_SCHEMA = zod.enum([
-	"system:admin",
-	"system:assets:read-all",
-	"system:uploads:unlimited"
-]);
-zod.array(SYSTEM_PERMISSION_SCHEMA);
+/**
+* What a person can let an AI assistant or the CLI do for them. `read` looks at assets, folders,
+* hash lists and events; `write` also creates, changes and deletes assets, folders and hash lists.
+* Members, API keys, connectors, sharing, downloads and project settings are never delegated.
+*/
+const AGENT_SCOPE_SCHEMA = zod.enum(["read", "write"]);
+zod.array(AGENT_SCOPE_SCHEMA).min(1).max(2);
 zod.enum(["active", "banned"]);
-//#endregion
-//#region src/testing/MockApiKey.ts
+// src/testing/MockApiKey.ts
 const MOCK_API_KEY_PREFIX = "sk_test_";
 const toBase64Url = (value) => btoa(value).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
 const fromBase64Url = (value) => {
@@ -8276,133 +8078,322 @@ const getMockApiKeyGrants = (apiKey) => {
 		return [];
 	}
 };
-//#endregion
-//#region src/testing/MockStorage.ts
-var InMemoryMockImageStorage = class {
-	constructor() {
-		this.content = /* @__PURE__ */ new Map();
-	}
-	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
-		});
-	}
-	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);
-	}
+// src/testing/MockClassification.ts
+/** The parent categories, in the API's order. */
+const MOCK_CATEGORIES = [
+	"sexual",
+	"violence",
+	"self-harm",
+	"harassment",
+	"hate",
+	"criminal-activity",
+	"personal-information",
+	"profanity"
+];
+/** Each category's qualifiers. */
+const MOCK_QUALIFIERS = {
+	"sexual": [
+		"sexual-pornographic-media",
+		"sexual-nudity",
+		"sexual-activity",
+		"sexual-explicit-language",
+		"sexual-assault-media",
+		"sexual-non-consensual",
+		"sexual-intimate-image-abuse",
+		"sexual-extreme",
+		"sexual-minors",
+		"sexual-solicitation",
+		"sexual-paid",
+		"sexual-adult-promotion",
+		"sexual-revealing-clothing",
+		"sexual-suggestive",
+		"sexual-non-erotic-nudity",
+		"sexual-text",
+		"sexual-historical",
+		"sexual-documentary",
+		"sexual-educational",
+		"sexual-discussion",
+		"sexual-fictional",
+		"sexual-support-prevention"
+	],
+	"violence": [
+		"violence-high-impact",
+		"violence-attack",
+		"violence-threat",
+		"violence-preparation",
+		"violence-encouragement",
+		"violence-wish",
+		"violence-coded-incitement",
+		"violence-extremism",
+		"violence-injury",
+		"violence-violent-death",
+		"violence-natural-death",
+		"violence-graphic",
+		"violence-decapitation-act",
+		"violence-gore",
+		"violence-weapon",
+		"violence-sport",
+		"violence-text",
+		"violence-historical",
+		"violence-documentary",
+		"violence-educational",
+		"violence-discussion",
+		"violence-fictional",
+		"violence-fantasy",
+		"violence-support-prevention"
+	],
+	"self-harm": [
+		"self-harm-age-restricted",
+		"self-harm-thoughts",
+		"self-harm-preparation",
+		"self-harm-act",
+		"self-harm-methods",
+		"self-harm-encouragement",
+		"self-harm-historical",
+		"self-harm-documentary",
+		"self-harm-educational",
+		"self-harm-fictional",
+		"self-harm-support-prevention"
+	],
+	"harassment": [
+		"harassment-abuse",
+		"harassment-mild",
+		"harassment-bullying",
+		"harassment-public-target",
+		"harassment-threat",
+		"harassment-sexual",
+		"harassment-encouragement",
+		"harassment-historical",
+		"harassment-documentary",
+		"harassment-educational",
+		"harassment-fictional",
+		"harassment-support-prevention"
+	],
+	"hate": [
+		"hate-nazi-symbols-public-display",
+		"hate-nazi-insignia-public-display",
+		"hate-nazi-genocide-public-peace",
+		"hate-nazi-genocide-denial-or-approval",
+		"hate-adjudicated-nazi-crimes-denial",
+		"hate-abuse",
+		"hate-slurs",
+		"hate-dehumanization",
+		"hate-inferiority",
+		"hate-exclusion",
+		"hate-symbol",
+		"hate-hostility",
+		"hate-threat",
+		"hate-personal",
+		"hate-historical",
+		"hate-documentary",
+		"hate-educational",
+		"hate-fictional",
+		"hate-counterspeech",
+		"hate-support-prevention"
+	],
+	"criminal-activity": [
+		"criminal-activity-demonstration",
+		"criminal-activity-preparation",
+		"criminal-activity-request",
+		"criminal-activity-instructions",
+		"criminal-activity-promotion",
+		"criminal-activity-coded-incitement",
+		"criminal-activity-substances",
+		"criminal-activity-grooming",
+		"criminal-activity-csam",
+		"criminal-activity-alcohol",
+		"criminal-activity-tobacco",
+		"criminal-activity-gambling",
+		"criminal-activity-fraud",
+		"criminal-activity-sexual-solicitation",
+		"criminal-activity-graffiti",
+		"criminal-activity-historical",
+		"criminal-activity-documentary",
+		"criminal-activity-educational",
+		"criminal-activity-discussion",
+		"criminal-activity-fictional",
+		"criminal-activity-support-prevention"
+	],
+	"personal-information": [
+		"personal-information-contact",
+		"personal-information-email",
+		"personal-information-phone",
+		"personal-information-government-id",
+		"personal-information-financial",
+		"personal-information-location",
+		"personal-information-identifiers",
+		"personal-information-credentials",
+		"personal-information-request",
+		"personal-information-self-disclosure",
+		"personal-information-third-party",
+		"personal-information-historical",
+		"personal-information-documentary",
+		"personal-information-educational",
+		"personal-information-fictional",
+		"personal-information-support-prevention"
+	],
+	"profanity": [
+		"profanity-mild",
+		"profanity-strong",
+		"profanity-slurs",
+		"profanity-obfuscated",
+		"profanity-historical",
+		"profanity-documentary",
+		"profanity-educational",
+		"profanity-fictional",
+		"profanity-support-prevention"
+	]
 };
-var InMemoryMockDatabaseStorage = class {
-	constructor() {
-		this.assets = /* @__PURE__ */ new Map();
-		this.folders = /* @__PURE__ */ new Map();
-	}
-	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;
+// src/testing/MockDecision.ts
+const OUTCOMES = [
+	"pending",
+	"failed",
+	"allowed",
+	"limited",
+	"age-restricted",
+	"blocked",
+	"purged"
+];
+/** The policy action that gives each decided status. */
+const STATUS_ACTION = {
+	allowed: "allow",
+	limited: "limit",
+	"age-restricted": "age-restrict",
+	blocked: "block",
+	purged: "purge"
+};
+/** The likelihood the API reports for a score (ClassificationCategories.ts, scoreToLikelihood). */
+const scoreToLikelihood = (score) => score >= .8 ? "very-likely" : score >= .6 ? "likely" : score >= .4 ? "possible" : score >= .2 ? "unlikely" : "very-unlikely";
+const isScore = (score) => typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 1;
+/**
+* A moderation decision for `mockOptions.moderate` or `completeProcessing`, built with
+* `mockDecision(status)`: flag the categories it found, with their scores and qualifiers, and
+* mark the categories it couldn't assess. Each call checks its names and scores and throws
+* `sdk/invalid-argument` for one CalmLens doesn't have.
+*/
+var MockDecision = class {
+	#flags = /* @__PURE__ */ new Map();
+	#notEvaluated = /* @__PURE__ */ new Set();
+	constructor(status) {
+		if (!OUTCOMES.includes(status)) throw invalidArgument(`status must be one of ${OUTCOMES.join(", ")}`);
+		this.status = status;
 	}
-	async updateFolder(folder) {
-		this.folders.set(folder.id, folder);
-		return folder;
+	/**
+	* Records findings in `category` with its `score` (0 to 1) and, optionally, scores for its
+	* qualifiers, such as `{ "violence-threat": 0.9 }`. The policy acts on a category at 0.5 and
+	* above, so `flaggedCategories` lists it there unless the status is `allowed`.
+	*/
+	flag(category, score, qualifiers = {}) {
+		this.#checkCategory(category);
+		if (this.status === "pending" || this.status === "failed") throw invalidArgument(`a ${this.status} decision has no findings`);
+		if (this.#flags.has(category) || this.#notEvaluated.has(category)) throw invalidArgument(`${category} is already in this decision`);
+		if (!isScore(score)) throw invalidArgument(`${category}'s score must be from 0 to 1`);
+		const known = MOCK_QUALIFIERS[category];
+		for (const [qualifier, qualifierScore] of Object.entries(qualifiers)) {
+			if (!known.includes(qualifier)) throw invalidArgument(`${qualifier} is not a qualifier of ${category}`);
+			if (!isScore(qualifierScore)) throw invalidArgument(`${qualifier}'s score must be from 0 to 1`);
+		}
+		this.#flags.set(category, {
+			score,
+			qualifiers: Object.entries(qualifiers)
+		});
+		return this;
 	}
-	async getFolder(folderId) {
-		return this.folders.get(folderId);
+	/** Marks `category` as not assessed (`not-evaluated` for reason `not-supported`). */
+	notEvaluated(category) {
+		this.#checkCategory(category);
+		if (this.status === "pending" || this.status === "failed") throw invalidArgument(`a ${this.status} decision has no findings`);
+		if (this.#flags.has(category) || this.#notEvaluated.has(category)) throw invalidArgument(`${category} is already in this decision`);
+		this.#notEvaluated.add(category);
+		return this;
 	}
-	async listFolders(projectId) {
-		return [...this.folders.values()].filter((folder) => folder.projectId === projectId).sort((a, b) => a.name.localeCompare(b.name));
+	#checkCategory(category) {
+		if (!MOCK_CATEGORIES.includes(category)) throw invalidArgument(`${category} is not a CalmLens category`);
 	}
-	async deleteFolder(folderId) {
-		this.folders.delete(folderId);
+	/**
+	* The report a decided asset gets, as the API sends it: every category (unflagged ones
+	* evaluated with score 0), policy-adjusted results and the automated action and
+	* `flaggedCategories`. `undefined` for `pending` and `failed`.
+	*/
+	report() {
+		const status = this.status;
+		if (status === "pending" || status === "failed") return void 0;
+		const action = (score) => status !== "allowed" && score >= .5 ? STATUS_ACTION[status] : "allow";
+		const evaluated = MOCK_CATEGORIES.filter((category) => !this.#notEvaluated.has(category)).map((category) => [category, this.#flags.get(category)?.score ?? 0]);
+		const categories = Object.fromEntries(MOCK_CATEGORIES.map((category) => {
+			if (this.#notEvaluated.has(category)) return [category, {
+				status: "not-evaluated",
+				reason: "not-supported"
+			}];
+			const flag = this.#flags.get(category);
+			const score = flag?.score ?? 0;
+			return [category, {
+				status: "evaluated",
+				likelihood: scoreToLikelihood(score),
+				score,
+				...flag?.qualifiers.length && { qualifiers: Object.fromEntries(flag.qualifiers.map(([qualifier, someScore]) => [qualifier, {
+					status: "evaluated",
+					someScore,
+					likelihood: scoreToLikelihood(someScore)
+				}])) }
+			}];
+		}));
+		return {
+			categories: Object.fromEntries(evaluated.map(([category, score]) => [category, {
+				score,
+				action: action(score)
+			}])),
+			explanationComplete: true,
+			source: "policy",
+			automatedAction: STATUS_ACTION[status],
+			regions: [],
+			flaggedCategories: evaluated.filter(([, score]) => action(score) !== "allow").map(([category]) => category),
+			raw: { categories }
+		};
 	}
 };
-//#endregion
-//#region src/testing/MockUtils.ts
-const inferAssetType = (options) => {
-	if ("url" in options) return "website";
-	const type = "content" in options ? options.content.type : options.part.type;
-	if (type.startsWith("image/") || [
-		"jpg",
-		"jpeg",
-		"png",
-		"gif",
-		"webp",
-		"avif"
-	].includes(type)) return "image";
-	if (type.startsWith("video/")) return "video";
-	if (type.startsWith("audio/")) return "audio";
-	if (type === "text/plain" || type === "txt" || type.startsWith("text/")) return "plaintext-document";
-	if (type.includes("pdf") || type.includes("document") || [
-		"pdf",
-		"doc",
-		"docx"
-	].includes(type)) return "multimedia-document";
-	return "file";
-};
-const createPage = (items, query) => {
-	const pageSize = query.pageSize ?? 10;
-	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw invalidArgument("Invalid page size");
-	const ordering = query.ordering?.length ? [...query.ordering] : [{
-		field: "createdAt",
-		direction: "DESC"
-	}];
-	if (ordering.some(({ field }) => field !== "createdAt" && field !== "id")) throw invalidArgument("Invalid ordering");
+/** Starts a moderation decision with this status; see `MockDecision`. */
+const mockDecision = (status) => new MockDecision(status);
+/** The default `moderate`: queued work stays pending until `completeProcessing`, which allows it. */
+const defaultModerate = ({ trigger, queued }) => queued && trigger !== "complete" ? "pending" : "allowed";
+// src/testing/MockUtils.ts
+const toBase64Utf8 = (value) => btoa(Array.from(new TextEncoder().encode(value), (byte) => String.fromCharCode(byte)).join(""));
+const fromBase64Utf8 = (value) => new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(atob(value), (char) => char.charCodeAt(0)));
+/**
+* One keyset page like the API's (packages/shared-backend/src/CursorPagination.ts): ordered by
+* `ordering` (newest first by default) with an `id` tie-breaker added, starting after the
+* cursor's values. The cursor is tied to `scope` (the filter, folder or parent) and the
+* ordering, so it only continues the query it came from. `name` and `id` are compared by code
+* point, like the database.
+*/
+const createPage = (items, query, { scope, fail, defaultPageSize = 50, defaultOrdering = [{
+	field: "createdAt",
+	direction: "desc"
+}] }) => {
+	const pageSize = query.pageSize ?? defaultPageSize;
+	if (typeof pageSize !== "number" || !Number.isFinite(pageSize) || pageSize < 1) throw fail("validation/too-small", "pageSize");
+	if (pageSize > 100) throw fail("validation/too-big", "pageSize");
+	if (!Number.isInteger(pageSize)) throw invalidArgument("Invalid page size");
+	const ordering = query.ordering?.length ? [...query.ordering] : [...defaultOrdering];
 	if (!ordering.some(({ field }) => field === "id")) ordering.push({
 		field: "id",
 		direction: ordering[0].direction
 	});
+	const signature = JSON.stringify([scope, ordering]);
 	let remaining = orderItems(items, ordering);
 	if (query.cursor) {
 		let values;
 		try {
-			values = JSON.parse(atob(query.cursor));
-			if (!Array.isArray(values) || values.length !== ordering.length || values.some((value, i) => ordering[i].field === "id" ? typeof value !== "string" : typeof value !== "number" || !Number.isFinite(value))) throw new Error();
+			const parsed = JSON.parse(fromBase64Utf8(query.cursor));
+			values = parsed?.values;
+			if (parsed?.scope !== signature || !Array.isArray(values) || values.length !== ordering.length || values.some((value, i) => STRING_FIELDS.has(ordering[i].field) ? typeof value !== "string" : typeof value !== "number" || !Number.isFinite(value))) throw new Error();
 		} catch {
-			throw invalidArgument("Invalid cursor");
+			throw fail("validation/invalid-cursor");
 		}
 		remaining = remaining.filter((item) => {
 			for (const [i, rule] of ordering.entries()) {
 				const result = compareValues(item[rule.field], values[i]);
-				if (result) return rule.direction === "DESC" ? result < 0 : result > 0;
+				if (result) return rule.direction === "desc" ? result < 0 : result > 0;
 			}
 			return false;
 		});
@@ -8415,26 +8406,31 @@ const createPage = (items, query) => {
 		pageSize,
 		hasMore,
 		ordering,
-		nextCursor: hasMore && last ? btoa(JSON.stringify(ordering.map(({ field }) => last[field]))) : null
+		nextCursor: hasMore && last ? toBase64Utf8(JSON.stringify({
+			scope: signature,
+			values: ordering.map(({ field }) => last[field])
+		})) : null
 	};
 };
+const STRING_FIELDS = /* @__PURE__ */ new Set(["id", "name"]);
 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));
+	const [a, b] = [String(left), String(right)];
+	return a < b ? -1 : a > b ? 1 : 0;
 };
 /** Sorts like the API's `ordering`; without one, newest first. */
 const orderItems = (items, ordering) => {
 	const rules = ordering?.length ? ordering : [{
 		field: "createdAt",
-		direction: "DESC"
+		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;
+			if (result !== 0) return rule.direction === "desc" ? -result : result;
 		}
 		return 0;
 	});
@@ -8450,7 +8446,7 @@ const parseFilterValue = (raw) => {
 	return value;
 };
 const readField = (item, path) => path.split(".").reduce((value, key) => value && typeof value === "object" ? value[key] : void 0, item);
-const unsupportedFilter = (expression) => invalidArgument(`MockCalmLensServerClient cannot evaluate the filter "${expression}". It supports ==, !=, <, <=, >, >=, =in= and =out=, joined by ; (and) or , (or), without grouping parentheses.`);
+const unsupportedFilter = (expression) => invalidArgument(`MockCalmLensServerClient cannot evaluate the filter "${expression}". It supports ==, !=, <, <=, >, >=, =in= and =out=, joined by ; (and) or , (or) and grouped with parentheses.`);
 const matchesComparison = (item, comparison) => {
 	const match = COMPARISON.exec(comparison.trim());
 	if (!match) throw unsupportedFilter(comparison);
@@ -8474,7 +8470,7 @@ const matchesComparison = (item, comparison) => {
 		default: return compareValues(actual, values[0]) <= 0;
 	}
 };
-/** Splits on `separator` outside quotes and parentheses; grouping parentheses are refused. */
+/** Splits on `separator` outside quotes and parentheses. */
 const splitTopLevel = (text, separator) => {
 	const parts = [];
 	let depth = 0;
@@ -8496,757 +8492,1969 @@ const splitTopLevel = (text, separator) => {
 	parts.push(current);
 	return parts;
 };
+/** The expression inside `( … )` when the parentheses enclose all of `text`, else undefined. */
+const unwrapGroup = (text) => {
+	if (!text.startsWith("(") || !text.endsWith(")")) return void 0;
+	let depth = 0;
+	let quote = null;
+	for (const [index, char] of [...text].entries()) if (quote) {
+		if (char === quote) quote = null;
+	} else if (char === "\"" || char === "'") quote = char;
+	else if (char === "(") depth++;
+	else if (char === ")" && --depth === 0) return index === text.length - 1 ? text.slice(1, -1) : void 0;
+};
+/** Evaluates `,` (or) of `;` (and) terms, where a term is a comparison or a `( … )` group. */
+const matchesExpression = (item, expression) => splitTopLevel(expression, ",").some((alternative) => splitTopLevel(alternative, ";").every((term) => {
+	const trimmed = term.trim();
+	if (!trimmed) throw unsupportedFilter(expression);
+	const group = unwrapGroup(trimmed);
+	return group === void 0 ? matchesComparison(item, trimmed) : matchesExpression(item, group);
+}));
 /**
-* 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.
+* Applies an RSQL `filter` like the API: comparisons joined by `;` (and), which binds tighter
+* than `,` (or), and grouped with parentheses. 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))));
+	if (items.length === 0) matchesExpression({}, filter);
+	return items.filter((item) => matchesExpression(item, filter));
 };
-//#endregion
-//#region src/testing/MockCalmLensServerClient.ts
-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_SEARCH_TOKENS = 8;
+/** The keyword fields the API searches, in the order it reports matches. */
+const searchFieldValues = (asset) => [
+	["name", asset.name],
+	["id", asset.id],
+	["externalId", asset.externalId ?? ""],
+	["description", asset.description ?? ""],
+	["tags", asset.tags?.join(" ") ?? ""],
+	["type", asset.type],
+	["content.format", asset.content?.format ?? ""],
+	["content.extension", asset.content?.extension ?? ""],
+	["classification.moderation.status", asset.classification.moderation.status]
+];
+/** The API's keyword score for the whole lowercased query. */
+const keywordScore = (values, query) => {
+	const id = values.get("id");
+	const externalId = values.get("externalId");
+	const name = values.get("name");
+	if (id === query) return 1e3;
+	if (externalId === query) return 950;
+	if (name === query) return 900;
+	if (id.startsWith(query)) return 800;
+	if (externalId.startsWith(query)) return 750;
+	if (name.startsWith(query)) return 700;
+	if (name.includes(query)) return 600;
+	if (values.get("tags").includes(query)) return 500;
+	return 100;
 };
-const MAX_EVENTS_LIMIT = 100;
-const toFailureError = (failure) => {
-	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") {
-		const cause = /* @__PURE__ */ new Error("The operation timed out.");
-		cause.name = "TimeoutError";
-		return new CalmLensError(SDK_ERROR_CODES.TIMEOUT, {
-			message: "Request timed out",
-			cause
-		});
+/**
+* Keyword search as the API runs it: every whitespace-separated token (case-insensitive, at
+* most 8) must appear in some searchable field. Results are ranked by the API's score, then
+* newest first.
+*/
+const searchAssets = (assets, query, limit) => {
+	const normalized = query.trim().toLowerCase();
+	const tokens = [...new Set(normalized.split(/\s+/).filter(Boolean))].slice(0, MAX_SEARCH_TOKENS);
+	if (tokens.length === 0) return [];
+	return assets.map((asset) => {
+		const fields = searchFieldValues(asset).map(([field, value]) => [field, value.toLowerCase()]);
+		return {
+			asset,
+			matches: tokens.every((token) => fields.some(([, value]) => value.includes(token))),
+			score: keywordScore(new Map(fields), normalized),
+			matchedFields: fields.filter(([, value]) => tokens.some((token) => value.includes(token))).map(([field]) => field)
+		};
+	}).filter((result) => result.matches).sort((a, b) => b.score - a.score || b.asset.createdAt - a.asset.createdAt).slice(0, limit).map(({ asset, score, matchedFields }) => ({
+		asset,
+		score,
+		matchedFields
+	}));
+};
+// src/testing/MockCalmLensApi.ts
+const REVIEW_DECISIONS = [
+	"allowed",
+	"limited",
+	"age-restricted",
+	"blocked",
+	"purged"
+];
+const MAX_PAGE_SIZE = 100;
+const MAX_DECISION_NOTE_LENGTH = 1499;
+/** How the API names a reviewer acting through an unnamed API key. */
+const API_KEY_REVIEWER_NAME = "An API key";
+const MAX_SEARCH_LIMIT = 20;
+const MAX_SEARCH_QUERY_LENGTH = 200;
+/**
+* The ThumbHash the mock gives every classified image, standing in for one computed from its
+* pixels. The `placeholder` resource serves it as a PNG, like the CDN.
+*/
+const MOCK_THUMBHASH = "1QcSHQRnh493V4dIh4eXh1h4kJUI";
+/** Like the API: 1 to 255 printable ASCII characters, once HTTP has trimmed the header value. */
+const isValidIdempotencyKey = (key) => key.length > 0 && key.length <= 255 && /^[\x21-\x7e](?:[\x20-\x7e]*[\x21-\x7e])?$/.test(key);
+/** Like the CDN, content a browser could run as a document is served as a download. */
+const isActiveContentType = (type) => {
+	const normalized = type?.toLowerCase().split(";", 1)[0]?.trim();
+	return Boolean(normalized && ([
+		"image/svg+xml",
+		"application/xhtml+xml",
+		"text/html",
+		"application/xml",
+		"text/xml"
+	].includes(normalized) || normalized.endsWith("+xml")));
+};
+/** The asset snapshot events carry (getEventAsset in the API). */
+const toEventAsset = (asset) => ({
+	id: asset.id,
+	externalId: asset.externalId ?? null,
+	uploadPresetId: asset.uploadPresetId ?? null,
+	upload: { status: asset.upload.status },
+	classification: {
+		status: asset.classification.status,
+		moderation: { status: asset.classification.moderation.status }
+	},
+	content: { status: asset.content.status }
+});
+/** A `moderate` answer or `completeProcessing` decision as a checked `MockDecision`. */
+const toDecision = (value) => {
+	if (value instanceof MockDecision) return value;
+	if (typeof value === "string") return new MockDecision(value);
+	throw invalidArgument("a decision must be a status or a mockDecision(...)");
+};
+/** An asset's portal link, as event facts carry it. */
+const assetNameFact = (asset) => ({
+	key: "asset-name",
+	value: asset.name,
+	url: `https://calmlens.com/go/asset/${asset.id}`
+});
+/** Removing content removes the placeholder and average colour with it. */
+const withoutPlaceholder = (image) => image ? {
+	...image,
+	thumbhash: null,
+	averageColor: null
+} : image;
+/** An asset's type from its content type, or `website` for a URL. */
+const inferAssetType = (contentType) => {
+	if (contentType === void 0) return "website";
+	const type = contentType.toLowerCase();
+	if (type.startsWith("image/")) return "image";
+	if (type.startsWith("video/")) return "video";
+	if (type.startsWith("audio/")) return "audio";
+	if (type.startsWith("text/")) return "plaintext-document";
+	if (type.includes("pdf") || type.includes("document")) return "multimedia-document";
+	return "file";
+};
+/** The API's answer to a request it refuses: thrown by handlers, sent as a JSON error body. */
+var ApiFailure = class {
+	constructor(status, code, message, details) {
+		this.status = status;
+		this.code = code;
+		this.message = message;
+		this.details = details;
+	}
+};
+const fail = (code, { message, details } = {}) => new ApiFailure(API_ERROR_DEFINITIONS[code].status, code, message ?? API_ERROR_DEFINITIONS[code].message, details);
+/** A request the API's schema refuses: `validation/<zod issue>` with HTTP 400 and the field. */
+const invalidField = (code, path) => new ApiFailure(400, code, `Invalid ${path}`, { path });
+/** The client methods that send a request, the one it is recorded under first. */
+const operationsOf = (request) => {
+	const { method, segments, query, cdn } = request;
+	if (cdn) return ["cdn.serve"];
+	const [root] = segments;
+	if (root === "projects") {
+		switch (segments.slice(2).join("/")) {
+			case "events": return ["events.list", "events.pages"];
+			case "lenses": return ["ensureLenses", "ensureLens"];
+			case "folders": return method === "GET" ? ["folders.list"] : ["folders.create"];
+			case "hash-lists": return method === "GET" ? ["hashLists.list"] : ["hashLists.create"];
+			case "assets/search": return ["assets.search"];
+			case "assets/batch": return ["assets.batch"];
+			case "assets":
+				if (method === "GET") return ["assets.list", "assets.iterate"];
+				if (query.get("queue") === "true") return ["assets.create"];
+				return isTextUpload(request) ? ["assets.classify", "text.classify"] : ["assets.classify"];
+		}
+		return [];
+	}
+	if (root === "upload-presets") {
+		if (segments[3] === void 0) return [query.get("queue") === "true" ? "assets.create" : "assets.classify"];
+		return segments[4] === "part" ? ["assets.uploadPart"] : ["assets.retrieve"];
+	}
+	const id = segments[1];
+	const action = segments[2];
+	if (root === "folders" && id !== void 0) {
+		if (action === "move") return ["folders.move"];
+		return method === "GET" ? ["folders.retrieve"] : method === "PATCH" ? ["folders.update"] : ["folders.delete"];
+	}
+	if (root === "hash-lists" && id !== void 0) {
+		if (action === "entries") return method === "GET" ? ["hashLists.listEntries"] : ["hashLists.addEntry"];
+		return method === "GET" ? ["hashLists.retrieve"] : method === "PATCH" ? ["hashLists.update"] : ["hashLists.delete"];
+	}
+	if (root === "hash-list-entries" && id !== void 0) return ["hashLists.removeEntry"];
+	if (root !== "assets" || id === void 0) return [];
+	switch (action) {
+		case void 0: return method === "GET" ? ["assets.retrieve", "assets.waitForDecision"] : method === "PATCH" ? ["assets.update"] : ["assets.delete"];
+		case "content": return ["assets.deleteContent"];
+		case "children": return ["assets.listChildren", "assets.iterateChildren"];
+		case "signed-url": return ["assets.createSignedUrl"];
+		case "part": return ["assets.uploadPart"];
+		case "move": return ["assets.move"];
+		case "retry": return ["assets.retry"];
+		case "explain": return ["assets.explain"];
+		case "decision": return ["assets.decide"];
+	}
+	return [];
+};
+const isTextUpload = (request) => request.headers.get("x-calmlens-upload") === "content" && request.headers.get("content-type") === "text/plain";
+/** Like the API: a new folder is 201 Created, a queued batch 202 Accepted, everything else 200. */
+const SUCCESS_STATUS = {
+	"folders.create": 201,
+	"hashLists.create": 201,
+	"assets.batch": 202
+};
+const decodeSegment = (segment) => {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return segment;
 	}
-	return failure;
+};
+const createMonotonicClock = () => {
+	let last = 0;
+	return () => {
+		last = Math.max(Date.now(), last + 1);
+		return last;
+	};
 };
 /**
-* An in-memory stand-in for `CalmLensServerClient` 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.
+* The in-memory CalmLens API and CDN one or more mock clients share: storage, events, lenses,
+* idempotency keys, upload presets, the API key's grants, queued failures and recorded requests.
 */
-var MockCalmLensServerClient = class {
-	/** Accepts the same options as `CalmLensServerClient` (validated the same way), plus `mockOptions`. */
+var MockCalmLensApi = class {
 	constructor(options) {
+		this.calls = [];
 		this.lenses = /* @__PURE__ */ new Map();
 		this.eventFeed = [];
-		this.uploadQueues = /* @__PURE__ */ new Map();
+		this.openUploads = /* @__PURE__ */ new Map();
 		this.idempotentResults = /* @__PURE__ */ new Map();
-		this.requestCount = 0;
 		this.pendingFailures = [];
-		this.calls = [];
-		validateServerClientOptions(options);
+		this.requestCount = 0;
+		this.waitedMs = 0;
+		this.hashLists = /* @__PURE__ */ new Map();
+		this.hashListEntries = /* @__PURE__ */ new Map();
+		this.pageFailure = (code, path) => code === "validation/invalid-cursor" ? fail(API_ERROR_CODES.INVALID_CURSOR) : invalidField(code, path ?? "pageSize");
+		this.options = options;
 		this.projectId = options.projectId;
 		this.apiKey = options.apiKey;
-		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.queuedOutcome = options.mockOptions?.queuedOutcome ?? "pending";
-		this.analyzedOutcome = options.mockOptions?.analyzedOutcome ?? "approved";
-		this.apiKeyGrants = getMockApiKeyGrants(options.apiKey);
-		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 `MockCalmLensServerClient { projectId: ${JSON.stringify(this.projectId)} }`;
-	}
-	/**
-	* Makes the next call (or the next call to `operation`) throw `failure` instead of running,
-	* as if the request never completed. Queue several to fail several calls in a row.
-	*/
-	failNextRequest(failure = "transport-error", { operation } = {}) {
+		this.grants = options.grants;
+		this.databaseStorage = options.databaseStorage;
+		this.imageStorage = options.imageStorage;
+		this.createId = options.createId;
+		this.now = options.now;
+	}
+	/** Queues a failure for the next request, or the next one `operation` sends. */
+	failNextRequest(failure, options = {}) {
+		if (options.retryAfter !== void 0 && !(Number.isInteger(options.retryAfter) && options.retryAfter >= 0)) throw invalidArgument("retryAfter must be a whole number of seconds");
 		this.pendingFailures.push({
 			failure,
-			operation
+			...options
 		});
 	}
-	/** Calls recorded for one operation, oldest first. */
-	callsTo(operation) {
-		return this.calls.filter((call) => call.operation === operation);
+	/** A `fetch` that answers a client's requests from memory; app clients pass their session. */
+	createFetch(endpoints, session) {
+		return ((input, init) => this.handle(input, init, endpoints(), session));
 	}
 	/**
-	* 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.
+	* Adds an event to the feed `events.list` reads, as if CalmLens had recorded it, and returns
+	* the stored event.
 	*/
-	enqueueEvent(input) {
+	async enqueueEvent(input) {
+		const asset = input.asset === void 0 && input.assetId ? await this.databaseStorage.getAsset(input.assetId) : void 0;
+		return this.pushEvent(asset ? {
+			...input,
+			asset: toEventAsset(asset)
+		} : input);
+	}
+	/** Adds an event to the feed, filling the fields the API always sets. */
+	pushEvent(input) {
 		const now = this.now();
 		const event = {
-			id: this.createId(),
+			id: this.createId("evt"),
 			projectId: this.projectId,
 			severity: "low",
 			title: input.type,
+			description: null,
+			assetId: null,
+			asset: null,
 			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
-			})
-		});
+	/** Applies a reviewer's decision to a stored asset (see `MockCalmLensServerClient.decide`). */
+	async decide(assetId, decision) {
+		if (!REVIEW_DECISIONS.includes(decision)) throw invalidArgument(`decision must be one of ${REVIEW_DECISIONS.join(", ")}`);
+		let asset;
+		try {
+			asset = await this.findOwnAsset(assetId);
+		} catch (failure) {
+			throw this.toError(failure);
+		}
+		return structuredClone(await this.recordDecision(asset, decision));
 	}
-	assertValidUploadMimeType(mimeType) {
-		if (isRejectedUploadMimeType(mimeType)) throw this.apiError(API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
-			message: getRejectedUploadMimeTypeError(mimeType),
-			details: { mimeType }
-		});
+	/**
+	* Finishes processing a pending asset as the pipeline would (see
+	* `MockCalmLensServerClient.completeProcessing`): with `decision`, or else what `moderate`
+	* returns for the `complete` trigger.
+	*/
+	async completeProcessing(assetId, decision) {
+		let asset;
+		try {
+			asset = await this.findOwnAsset(assetId);
+		} catch (failure) {
+			throw this.toError(failure);
+		}
+		if (asset.classification.status !== "processing") throw invalidArgument(`asset ${assetId} isn't processing`);
+		const settled = decision === void 0 ? void 0 : toDecision(decision);
+		return structuredClone(await this.moderateStored(asset, "complete", settled));
 	}
-	invalidPayload(message) {
-		return this.apiError(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
+	/**
+	* `POST /assets/:assetId/decision`, like the API: an asset still uploading or processing can't
+	* be decided, one pending moderation can only be blocked or purged, a decision must change the
+	* status and purged content can only be blocked. Mock API keys have no name, so the reviewer is
+	* "An API key".
+	*/
+	async decideAsset(assetId, body) {
+		const { decision, note: rawNote } = body;
+		if (decision === "purged") {
+			if (body.confirmPurge !== true) throw invalidField("validation/invalid-value", "confirmPurge");
+		} else if (!REVIEW_DECISIONS.includes(decision)) throw invalidField("validation/invalid-value", "decision");
+		if (typeof rawNote !== "string") throw invalidField("validation/invalid-type", "note");
+		const note = rawNote.trim();
+		if (!note) throw invalidField("validation/too-small", "note");
+		if (note.length > MAX_DECISION_NOTE_LENGTH) throw invalidField("validation/too-big", "note");
+		const asset = await this.findOwnAsset(assetId);
+		if (asset.upload.status === "uploading" || asset.classification.status === "processing") throw fail(API_ERROR_CODES.ASSET_PROCESSING);
+		const status = asset.classification.moderation.status;
+		if (decision !== "purged" && decision !== "blocked" && status === "pending") throw fail(API_ERROR_CODES.ASSET_DECISION_NOT_ALLOWED);
+		if (status === decision) throw fail(API_ERROR_CODES.ASSET_DECISION_UNCHANGED);
+		if (decision !== "purged" && decision !== "blocked" && status === "purged") throw fail(API_ERROR_CODES.ASSET_CONTENT_PURGED);
+		return this.recordDecision(asset, decision, {
+			note,
+			reviewerName: API_KEY_REVIEWER_NAME
+		});
 	}
-	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;
+	/**
+	* Sets the reviewer's decision: the moderation status, a manual review and the
+	* `asset.<status>` event (after `asset.content-removed` when purging). The test hook records no
+	* reviewer or note; the API's handler records both.
+	*/
+	async recordDecision(asset, decision, review) {
+		const decided = await this.applyOutcome(asset, decision, "requested");
+		const now = this.now();
+		decided.classification.moderation.manualReviews = [...decided.classification.moderation.manualReviews ?? [], {
+			id: this.createId("rev"),
+			decision,
+			note: review?.note ?? null,
+			...review && {
+				reviewerName: review.reviewerName,
+				reviewerEmail: null
+			},
+			reviewedAt: now,
+			appliedToAsset: true
+		}];
+		const stored = await this.databaseStorage.updateAsset(decided);
+		if (decision === "purged") this.recordLifecycleEvent("asset.content-removed", stored);
+		this.pushEvent({
+			type: `asset.${decision}`,
+			severity: decision === "allowed" || decision === "limited" ? "low" : "high",
+			title: `asset.${decision}`,
+			assetId: stored.id,
+			asset: toEventAsset(stored),
+			facts: [
+				{
+					key: "decided-by",
+					value: "reviewer"
+				},
+				{
+					key: "asset-type",
+					value: stored.type
+				},
+				{
+					key: "asset-name",
+					value: stored.name,
+					url: `https://calmlens.com/go/asset/${stored.id}`
+				},
+				...review ? [{
+					key: "reviewer-user-id",
+					value: null
+				}, {
+					key: "reviewer-name",
+					value: review.reviewerName
+				}] : [],
+				{
+					key: "note",
+					value: review?.note ?? null
+				}
+			]
+		});
+		return stored;
 	}
-	begin(operation, options) {
+	/** The `CalmLensError` the real client throws for an API failure, for helpers that send none. */
+	toError(failure) {
+		if (!(failure instanceof ApiFailure)) return failure;
+		const requestId = `mock-request-${++this.requestCount}`;
+		return new CalmLensError(failure.code, {
+			message: failure.message,
+			status: failure.status,
+			details: failure.details ?? {},
+			requestId,
+			headers: new Headers({
+				"content-type": "application/json",
+				"x-request-id": requestId
+			})
+		});
+	}
+	async handle(input, init, endpoints, session) {
+		if (init?.signal?.aborted) throw init.signal.reason;
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		const cdn = url.startsWith(`${endpoints.cdnBaseUrl}/`);
+		const base = cdn ? endpoints.cdnBaseUrl : endpoints.baseUrl;
+		if (!url.startsWith(`${base}/`)) throw new TypeError(`MockCalmLensServerClient does not serve ${url}`);
+		const relative = url.slice(base.length);
+		const queryIndex = relative.indexOf("?");
+		const path = queryIndex === -1 ? relative : relative.slice(0, queryIndex);
+		const headers = new Headers(init?.headers);
+		const bytes = init?.body === void 0 || init.body === null ? /* @__PURE__ */ new Uint8Array(0) : new Uint8Array(await new Response(init.body).arrayBuffer());
+		const request = {
+			method: (init?.method ?? "GET").toUpperCase(),
+			url,
+			segments: path.split("/").filter(Boolean).map(decodeSegment),
+			query: new URLSearchParams(queryIndex === -1 ? "" : relative.slice(queryIndex + 1)),
+			headers,
+			bytes,
+			cdn
+		};
+		const operations = operationsOf(request);
+		const call = {
+			operation: operations[0] ?? "unknown",
+			method: request.method,
+			url,
+			path: `/${request.segments.join("/")}`,
+			query: Object.fromEntries(request.query),
+			headers: Object.fromEntries(headers),
+			body: this.describeBody(request),
+			status: void 0
+		};
 		this.calls.push({
-			operation,
-			options
+			call,
+			operations
 		});
-		const index = this.pendingFailures.findIndex((pending) => pending.operation === void 0 || pending.operation === operation);
+		const index = this.pendingFailures.findIndex((pending) => pending.operation === void 0 || operations.includes(pending.operation));
 		if (index !== -1) {
-			const [pending] = this.pendingFailures.splice(index, 1);
-			throw toFailureError(pending.failure);
+			const [{ failure, details, retryAfter }] = this.pendingFailures.splice(index, 1);
+			if (typeof failure === "string" && failure in API_ERROR_DEFINITIONS) return this.answered(call, this.failureResponse(fail(failure, { details }), url, retryAfter));
+			throw this.toFailureError(failure);
 		}
+		const response = cdn ? await this.serveCdn(request) : await this.answer(request, operations[0], session);
+		return this.answered(call, response);
 	}
-	jsonResponse(status, body, url) {
-		const requestId = `mock-request-${++this.requestCount}`;
-		const response = new Response(JSON.stringify(body), {
+	answered(call, response) {
+		call.status = response.status;
+		return response;
+	}
+	/** What `fetch` throws for a simulated network failure, as the real client reports it. */
+	toFailureError(failure) {
+		if (failure === "transport-error") return /* @__PURE__ */ new TypeError("Simulated network failure");
+		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;
+	}
+	describeBody({ bytes, headers }) {
+		if (bytes.byteLength === 0) return void 0;
+		const type = headers.get("content-type") ?? "";
+		const text = () => new TextDecoder().decode(bytes);
+		if (type === "application/json") try {
+			return JSON.parse(text());
+		} catch {
+			return text();
+		}
+		return type.startsWith("text/") ? text() : bytes.slice();
+	}
+	response(status, body, url, headers, requestId = `mock-request-${++this.requestCount}`) {
+		const response = new Response(body, {
 			status,
 			headers: {
-				"content-type": "application/json",
-				"x-request-id": requestId
+				...headers,
+				"X-Request-Id": requestId
 			}
 		});
 		Object.defineProperty(response, "url", { value: url });
 		return response;
 	}
-	get cdn() {
-		return {
-			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);
-			},
-			/**
-			* 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
-					}
+	jsonResponse(status, body, url, headers = {}, requestId) {
+		return this.response(status, JSON.stringify(body), url, {
+			"Content-Type": "application/json",
+			...headers
+		}, requestId);
+	}
+	/** The API's error body: `{ code, message, requestId, details }`, `requestId` as in the header. */
+	failureResponse(failure, url, retryAfter) {
+		const requestId = `mock-request-${++this.requestCount}`;
+		return this.jsonResponse(failure.status, {
+			code: failure.code,
+			message: failure.message,
+			requestId,
+			details: failure.details ?? {}
+		}, url, retryAfter === void 0 ? {} : { "Retry-After": String(retryAfter) }, requestId);
+	}
+	/** Answers an API request: the API key, idempotency, then the route. */
+	async answer(request, operation, session) {
+		const { url, headers } = request;
+		if (!(request.segments[0] === "upload-presets") && headers.get("x-api-key") !== this.apiKey) return this.failureResponse(fail(API_ERROR_CODES.INVALID_API_KEY), url);
+		const key = headers.get("idempotency-key")?.replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, "");
+		const upload = headers.get("x-calmlens-upload");
+		const fingerprint = JSON.stringify([
+			request.method,
+			request.segments,
+			[...request.query].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
+			headers.get("content-type"),
+			upload,
+			upload ? request.bytes.byteLength : new TextDecoder().decode(request.bytes)
+		]);
+		if (key !== void 0) {
+			if (!isValidIdempotencyKey(key)) return this.failureResponse(fail(API_ERROR_CODES.INVALID_IDEMPOTENCY_KEY), url);
+			const saved = this.idempotentResults.get(key);
+			if (saved) {
+				if (saved.fingerprint !== fingerprint) return this.failureResponse(fail(API_ERROR_CODES.IDEMPOTENCY_KEY_REUSED), url);
+				return this.response(saved.status, saved.body, url, {
+					"Content-Type": "application/json",
+					"Idempotent-Replayed": "true"
 				});
-				Object.defineProperty(response, "url", { value: url });
-				return response;
 			}
-		};
+		}
+		let answer;
+		try {
+			answer = await this.route(request, session);
+		} catch (failure) {
+			if (failure instanceof ApiFailure) return this.failureResponse(failure, url);
+			throw failure;
+		}
+		const [status, body] = answer;
+		const json = JSON.stringify(body ?? {});
+		const finalStatus = operation ? SUCCESS_STATUS[operation] ?? status : status;
+		if (key !== void 0) this.idempotentResults.set(key, {
+			fingerprint,
+			status: finalStatus,
+			body: json
+		});
+		return this.response(finalStatus, json, url, { "Content-Type": "application/json" });
+	}
+	async route(request, session) {
+		const { method, segments } = request;
+		const [root, id, action, ...rest] = segments;
+		if (root === "projects") {
+			if (id !== this.projectId) throw fail(API_ERROR_CODES.API_KEY_PROJECT_MISMATCH);
+			switch (`${method} ${segments.slice(2).join("/")}`) {
+				case "POST assets": return [200, await this.createAsset(request)];
+				case "GET assets": return [200, await this.listAssets(request.query)];
+				case "GET assets/search": return [200, await this.searchAssets(request.query)];
+				case "POST assets/batch": return [202, await this.batch(this.json(request))];
+				case "GET events": return [200, this.listEvents(request.query)];
+				case "GET folders": return [200, await this.listFolders(request.query)];
+				case "POST folders": return [201, await this.createFolder(this.json(request))];
+				case "GET hash-lists": return [200, this.listHashLists(request.query)];
+				case "POST hash-lists": return [201, this.createHashList(this.json(request))];
+				case "PUT lenses": return [200, this.ensureLenses(this.json(request))];
+			}
+		}
+		if (root === "upload-presets" && id !== void 0 && action === "assets") return [200, await this.presetRoute(request, id, rest, session)];
+		if (root === "assets" && id !== void 0 && rest.length === 0) switch (`${method} ${action ?? ""}`) {
+			case "GET ": return [200, await this.findOwnAsset(id)];
+			case "PATCH ": return [200, await this.updateAsset(id, this.json(request))];
+			case "DELETE ": return [200, await this.deleteAsset(id)];
+			case "GET children": return [200, await this.listChildren(id, request.query)];
+			case "POST part": return [200, await this.uploadPart(id, request)];
+			case "POST signed-url": return [200, await this.createSignedUrl(id, this.json(request))];
+			case "POST move": return [200, await this.moveAsset(id, this.json(request))];
+			case "POST retry": return [200, await this.retryAsset(id)];
+			case "POST explain": return [200, await this.explainAsset(id, this.json(request))];
+			case "POST decision": return [200, await this.decideAsset(id, this.json(request))];
+			case "DELETE content": return [200, await this.removeContent(await this.findOwnAsset(id))];
+		}
+		if (root === "folders" && id !== void 0 && rest.length === 0) switch (`${method} ${action ?? ""}`) {
+			case "GET ": return [200, await this.findOwnFolder(id)];
+			case "PATCH ": return [200, await this.updateFolder(id, this.json(request))];
+			case "DELETE ": return [200, await this.deleteFolder(id)];
+			case "POST move": return [200, await this.moveFolder(id, this.json(request))];
+		}
+		if (root === "hash-lists" && id !== void 0 && rest.length === 0) switch (`${method} ${action ?? ""}`) {
+			case "GET ": return [200, this.findHashList(id)];
+			case "PATCH ": return [200, this.updateHashList(id, this.json(request))];
+			case "DELETE ": return [200, this.deleteHashList(id)];
+			case "GET entries": return [200, this.listHashListEntries(id, request.query)];
+			case "POST entries": return this.addHashListEntry(id, this.json(request));
+		}
+		if (root === "hash-list-entries" && id !== void 0 && method === "DELETE" && !action) {
+			if (!this.hashListEntries.delete(id)) throw fail(API_ERROR_CODES.HASH_LIST_ENTRY_NOT_FOUND);
+			return [200, {}];
+		}
+		throw fail(API_ERROR_CODES.ROUTE_NOT_FOUND, { message: `No route for ${method} /${segments.join("/")}` });
 	}
-	get events() {
-		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)
+	createHashList(body) {
+		const { name, description, action } = body;
+		if (typeof name !== "string" || !name.trim() || action !== "flag" && action !== "block") throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "A hash list needs a name and an action of flag or block" });
+		const now = this.now();
+		const list = {
+			id: this.createId("hl"),
+			projectId: this.projectId,
+			name: name.trim(),
+			description: typeof description === "string" ? description : null,
+			action,
+			createdAt: now,
+			updatedAt: now
 		};
+		this.hashLists.set(list.id, list);
+		return list;
 	}
-	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
+	listHashLists(query) {
+		return createPage([...this.hashLists.values()], this.pageQuery(query), {
+			scope: `hash-lists:${this.projectId}`,
+			fail: this.pageFailure
+		});
+	}
+	findHashList(hashListId) {
+		const list = this.hashLists.get(hashListId);
+		if (!list) throw fail(API_ERROR_CODES.HASH_LIST_NOT_FOUND);
+		return list;
+	}
+	updateHashList(hashListId, body) {
+		const updated = {
+			...this.findHashList(hashListId),
+			...typeof body.name === "string" ? { name: body.name.trim() } : {},
+			...body.description !== void 0 ? { description: body.description ?? null } : {},
+			...body.action === "flag" || body.action === "block" ? { action: body.action } : {},
+			updatedAt: this.now()
 		};
-		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;
+		this.hashLists.set(hashListId, updated);
+		return updated;
+	}
+	deleteHashList(hashListId) {
+		this.findHashList(hashListId);
+		this.hashLists.delete(hashListId);
+		for (const [id, entry] of this.hashListEntries) if (entry.hashListId === hashListId) this.hashListEntries.delete(id);
+		return {};
+	}
+	listHashListEntries(hashListId, query) {
+		this.findHashList(hashListId);
+		const pageSize = this.integer(query, "pageSize", 50);
+		const entries = [...this.hashListEntries.values()].filter((entry) => entry.hashListId === hashListId).reverse();
+		const cursor = query.get("cursor");
+		const start = cursor ? Number(atob(cursor)) : 0;
+		if (!Number.isInteger(start) || start < 0) throw fail(API_ERROR_CODES.INVALID_CURSOR);
+		const items = entries.slice(start, start + pageSize);
+		const hasMore = start + pageSize < entries.length;
 		return {
-			events,
-			cursor: `mock_${next}`,
-			hasMore: next < this.eventFeed.length
+			items,
+			hasMore,
+			nextCursor: hasMore ? btoa(String(start + pageSize)) : null,
+			pageSize,
+			ordering: [{
+				field: "createdAt",
+				direction: "desc"
+			}, {
+				field: "id",
+				direction: "desc"
+			}]
 		};
 	}
-	async *iterateEventPages(options) {
-		let after = options.after;
-		for (;;) {
-			const page = await this.events.list({
-				...options,
-				after
-			});
-			yield page;
-			if (!page.hasMore || page.cursor === after) return;
-			after = page.cursor;
+	async addHashListEntry(hashListId, body) {
+		const list = this.findHashList(hashListId);
+		let hash = typeof body.hash === "string" ? body.hash.trim().toLowerCase() : void 0;
+		let quality = typeof body.quality === "number" ? body.quality : null;
+		const assetId = typeof body.assetId === "string" ? body.assetId : void 0;
+		if (hash === void 0 === (assetId === void 0)) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Send either hash or assetId" });
+		if (assetId) {
+			const image = (await this.findOwnAsset(assetId)).content.image;
+			if (!image?.perceptualHash) throw fail(API_ERROR_CODES.HASH_LIST_ASSET_NOT_HASHED);
+			hash = image.perceptualHash;
+			quality = image.perceptualHashQuality ?? null;
 		}
+		if (!/^[0-9a-f]{64}$/.test(hash)) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Use a PDQ hash of 64 hexadecimal characters" });
+		const existing = [...this.hashListEntries.values()].find((entry) => entry.hashListId === list.id && entry.hash === hash);
+		if (existing) return [200, existing];
+		const entry = {
+			id: this.createId("hle"),
+			projectId: this.projectId,
+			hashListId: list.id,
+			hash,
+			quality,
+			label: typeof body.label === "string" ? body.label : null,
+			sourceAssetId: assetId ?? null,
+			createdAt: this.now()
+		};
+		this.hashListEntries.set(entry.id, entry);
+		return [201, entry];
 	}
-	async *iteratePages(listPage) {
-		let cursor;
-		for (;;) {
-			const page = await listPage(cursor);
-			yield* page.items;
-			if (!page.nextCursor || !page.hasMore || page.items.length === 0) return;
-			cursor = page.nextCursor;
+	/** The request's JSON body, or `{}` without one. */
+	json(request) {
+		if (request.bytes.byteLength === 0) return {};
+		try {
+			const body = JSON.parse(new TextDecoder().decode(request.bytes));
+			return body && typeof body === "object" ? body : {};
+		} catch {
+			throw new ApiFailure(400, "validation/invalid-json", "Invalid JSON body");
 		}
 	}
-	get text() {
-		return { moderate: async (options) => {
-			this.begin("text.moderate", options);
-			return this.moderateAsset(toTextAssetOptions(options), "text.moderate");
-		} };
+	/** A whole number from the query, or `fallback` when absent; other values fail like zod. */
+	integer(query, name, fallback) {
+		const raw = query.get(name);
+		if (raw === null) return fallback;
+		const value = Number(raw);
+		if (raw.trim() === "" || !Number.isFinite(value)) throw invalidField("validation/invalid-type", name);
+		if (!Number.isInteger(value)) throw invalidField("validation/invalid-type", name);
+		return value;
+	}
+	/** `ordering[i][field]` and `ordering[i][direction]` pairs, as qs parses them. */
+	ordering(query) {
+		const ordering = [];
+		for (const [key, value] of query) {
+			const match = /^ordering\[(\d+)\]\[(field|direction)\]$/.exec(key);
+			if (!match) continue;
+			const index = Number(match[1]);
+			ordering[index] = {
+				...ordering[index],
+				[match[2]]: value
+			};
+		}
+		return ordering.filter(Boolean);
 	}
-	get assets() {
+	pageQuery(query) {
+		const ordering = this.ordering(query);
 		return {
-			/**
-			* 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"
-				};
-			},
-			/** 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(assets, options);
-			},
-			iterate: (options = {}) => this.iteratePages((cursor) => this.assets.list({
-				...options,
-				cursor
-			})),
-			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(assets.filter((asset) => asset.parentId === assetId), options);
-			},
-			iterateChildren: (options) => {
-				encodePathSegment(options?.assetId, "Asset ID");
-				return this.iteratePages((cursor) => this.assets.listChildren({
-					...options,
-					cursor
-				}));
-			},
-			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()
-				});
-			},
-			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 this.invalidPayload(validation.error);
-					if (asset.processing.status !== "uploading") throw this.apiError(API_ERROR_CODES.UPLOAD_NOT_OPEN);
-					const expectedPartNumber = (asset.processing.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);
-					const now = this.now();
-					const received = {
-						...asset,
-						processing: {
-							...asset.processing,
-							uploadPartsReceived: part.partNumber
-						},
-						updatedAt: now
-					};
-					return this.databaseStorage.updateAsset(part.isFinal ? await this.applyOutcome(received, queue ? this.queuedOutcome : this.analyzedOutcome) : received);
-				});
-			},
-			createSignedUrl: async (signedUrlOptions) => {
-				this.begin("assets.createSignedUrl", signedUrlOptions);
-				const { assetId, ...options } = signedUrlOptions;
-				const asset = await this.findOwnAsset(assetId);
-				const expiresInSeconds = options.expiresInSeconds ?? 900;
-				const resource = options.resource ?? "content";
-				const transform = transformSelector(options.transform);
-				const selector = (options.lens ? `&lens=${encodeURIComponent(options.lens)}` : "") + (transform ? `&transform=${encodeURIComponent(transform)}` : "");
-				return {
-					url: `${this.signedUrlBaseUrl}/assets/${asset.id}/${resource}?expiresInSeconds=${expiresInSeconds}${selector}`,
-					expiresAt: this.now() + expiresInSeconds * 1e3
-				};
-			},
-			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()
-				});
-			},
-			retry: async (options) => {
-				this.begin("assets.retry", options);
-				const asset = await this.findOwnAsset(options?.assetId);
-				if (asset.processing.status !== "failed") throw this.apiError(API_ERROR_CODES.ASSET_NOT_RETRYABLE);
-				if (asset.content.status === "removed") throw this.apiError(API_ERROR_CODES.ASSET_CONTENT_UNAVAILABLE);
-				return this.databaseStorage.updateAsset(await this.applyOutcome(asset, "pending"));
-			},
-			/** Waits like the real client, checking the mock's storage for a decision. */
-			waitForDecision: async (options) => {
-				this.begin("assets.waitForDecision", options);
-				const { assetId, ...waitOptions } = options;
-				return pollForDecision(() => this.findOwnAsset(assetId), waitOptions, sleep);
-			},
-			deleteContent: async (options) => {
-				this.begin("assets.deleteContent", options);
-				const asset = await this.findOwnAsset(options?.assetId);
-				await this.imageStorage.deleteContent(asset.id);
-				const now = this.now();
-				return this.databaseStorage.updateAsset({
-					...asset,
-					content: asset.content.status === "removed" ? asset.content : {
-						...asset.content,
-						status: "removed",
-						removalReason: "requested",
-						updatedAt: now,
-						extractedText: null
-					},
-					updatedAt: now
-				});
-			},
-			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);
-			}
+			pageSize: this.integer(query, "pageSize", 50),
+			cursor: query.get("cursor") ?? void 0,
+			ordering: ordering.length ? ordering : void 0
 		};
 	}
-	/** Signs real upload tokens with the mock's API key, like the real client, without a request. */
-	get uploadTokens() {
-		return { sign: async (options) => {
-			this.begin("uploadTokens.sign", options);
-			return signUploadTokenWithApiKey(this.apiKey, options, {
-				now: this.now(),
-				nonce: this.createId()
-			});
-		} };
+	async findOwnAsset(assetId) {
+		const asset = await this.databaseStorage.getAsset(assetId);
+		if (!asset || asset.projectId !== this.projectId) throw fail(API_ERROR_CODES.ASSET_NOT_FOUND);
+		return asset;
+	}
+	async listAssets(query) {
+		let assets = await this.databaseStorage.listAssets(this.projectId);
+		const folderId = query.get("folderId");
+		if (folderId !== null) assets = assets.filter((asset) => (asset.folderId ?? null) === folderId);
+		const filter = query.get("filter") ?? void 0;
+		assets = filterAssets(assets, filter);
+		return createPage(assets, this.pageQuery(query), {
+			scope: JSON.stringify([
+				this.projectId,
+				filter ?? null,
+				folderId
+			]),
+			fail: this.pageFailure
+		});
 	}
-	get folders() {
+	/**
+	* Keyword search like the API's: every whitespace-separated token must appear,
+	* case-insensitively, in the asset's name, ID, external ID, description, tags, type, content
+	* format or extension, or moderation status. There is no semantic search.
+	*/
+	async searchAssets(params) {
+		const query = (params.get("query") ?? "").trim();
+		if (!query) throw invalidField("validation/too-small", "query");
+		if (query.length > MAX_SEARCH_QUERY_LENGTH) throw invalidField("validation/too-big", "query");
+		const limit = this.integer(params, "limit", 10);
+		if (limit < 1) throw invalidField("validation/too-small", "limit");
+		if (limit > MAX_SEARCH_LIMIT) throw invalidField("validation/too-big", "limit");
 		return {
-			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()
-				};
-				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()
-				};
-				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) 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;
-			}
+			query,
+			items: searchAssets(await this.databaseStorage.listAssets(this.projectId), query, limit),
+			semanticStatus: "disabled"
 		};
 	}
-	async ensureLens(options) {
-		this.begin("ensureLens", options);
-		if (!options?.identifier) throw invalidArgument("Lens identifier is required");
-		return this.ensureLensDefinition(options);
+	async listChildren(assetId, query) {
+		const parent = await this.findOwnAsset(assetId);
+		const assets = await this.databaseStorage.listAssets(this.projectId);
+		return createPage(assets.filter((asset) => asset.parentId === parent.id), this.pageQuery(query), {
+			scope: parent.id,
+			fail: this.pageFailure
+		});
 	}
-	ensureLensDefinition(options) {
-		const existing = this.lenses.get(options.identifier);
-		if (!existing) {
-			const lens = {
-				id: this.createId(),
-				projectId: this.projectId,
-				userId: null,
-				...options,
-				createdAt: this.now(),
-				updatedAt: this.now()
-			};
-			this.lenses.set(lens.identifier, lens);
-			return lens;
+	async updateAsset(assetId, body) {
+		const asset = await this.findOwnAsset(assetId);
+		if (body.externalId) {
+			if ((await this.databaseStorage.listAssets(this.projectId)).some((other) => other.id !== asset.id && other.externalId === body.externalId)) throw fail(API_ERROR_CODES.DUPLICATE_EXTERNAL_ID);
 		}
-		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 = {
-				...existing,
-				...options,
-				updatedAt: this.now()
-			};
-			this.lenses.set(lens.identifier, lens);
-			return lens;
+		return this.databaseStorage.updateAsset({
+			...asset,
+			...body,
+			updatedAt: this.now()
+		});
+	}
+	async deleteAsset(assetId) {
+		const asset = await this.findOwnAsset(assetId);
+		await this.imageStorage.deleteContent(asset.id);
+		await this.databaseStorage.deleteAsset(asset.id);
+		this.recordLifecycleEvent("asset.deleted", asset);
+	}
+	async moveAsset(assetId, body) {
+		const asset = await this.findOwnAsset(assetId);
+		const folderId = body.folderId ?? null;
+		if (folderId !== null && !await this.resolveFolder(folderId)) throw fail(API_ERROR_CODES.FOLDER_NOT_FOUND);
+		return this.databaseStorage.updateAsset({
+			...asset,
+			folderId,
+			updatedAt: this.now()
+		});
+	}
+	async createSignedUrl(assetId, body) {
+		const asset = await this.findOwnAsset(assetId);
+		const expiresInSeconds = body.expiresInSeconds ?? 900;
+		const resource = body.resource ?? "rendered";
+		const selector = (body.lens ? `&lens=${encodeURIComponent(String(body.lens))}` : "") + (body.transform ? `&transform=${encodeURIComponent(String(body.transform))}` : "");
+		return {
+			url: `${this.options.signedUrlBaseUrl}/assets/${asset.id}/${resource}?expiresInSeconds=${expiresInSeconds}${selector}`,
+			expiresAt: this.now() + expiresInSeconds * 1e3
+		};
+	}
+	async retryAsset(assetId) {
+		const asset = await this.findOwnAsset(assetId);
+		if (asset.classification.status !== "failed" || asset.classification.moderation.status !== "pending") throw fail(API_ERROR_CODES.ASSET_NOT_RETRYABLE);
+		if (asset.content.status === "removed") throw fail(API_ERROR_CODES.ASSET_CONTENT_UNAVAILABLE);
+		const retried = await this.databaseStorage.updateAsset(await this.applyOutcome(asset, "pending"));
+		this.recordLifecycleEvent("asset.retried", retried);
+		return this.moderateStored(retried, "retry");
+	}
+	async explainAsset(assetId, body) {
+		const asset = await this.findOwnAsset(assetId);
+		if (asset.classification.status !== "completed") throw fail(API_ERROR_CODES.ASSET_NOT_DECIDED);
+		if (!body.rerun) {
+			if (asset.classification.moderation?.explanationComplete !== false) return asset;
+			return this.databaseStorage.updateAsset({
+				...asset,
+				updatedAt: this.now(),
+				classification: {
+					...asset.classification,
+					moderation: {
+						...asset.classification.moderation,
+						explanationComplete: true
+					}
+				}
+			});
 		}
-		throw this.apiError(API_ERROR_CODES.LENS_VERSION_CONFLICT, { details: {
-			currentVersion: existing.version,
-			minimumVersion: existing.version + 1,
-			requestedVersion: options.version
-		} });
+		if (asset.classification.moderation.manualReviews.length) throw fail(API_ERROR_CODES.ASSET_REVIEWED);
+		if (asset.content.status === "removed") throw fail(API_ERROR_CODES.ASSET_CONTENT_UNAVAILABLE);
+		const rerun = await this.databaseStorage.updateAsset(await this.applyOutcome(asset, "pending"));
+		return this.moderateStored(rerun, "rerun");
 	}
-	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
+	/**
+	* Checks every asset like the API (an ID that is not an asset ID is
+	* `validation/invalid-format`, an unknown
+	* one `asset/not-found`, and either refuses the whole batch), then applies the operation at
+	* once instead of in the background: `delete` deletes each asset with its stored child
+	* assets and records `asset.deleted` with the asset as it was; `remove-content` removes
+	* the content like `deleteContent`. Mock assets carry no safety holds, so none is skipped.
+	*/
+	async batch(body) {
+		const assetIds = Array.isArray(body.assetIds) ? body.assetIds : [];
+		const operation = body.operation;
+		if (assetIds.length === 0) throw invalidField("validation/too-small", "assetIds");
+		if (assetIds.length > 500) throw invalidField("validation/too-big", "assetIds");
+		if (operation !== "delete" && operation !== "remove-content") throw invalidField("validation/invalid-value", "operation");
+		assetIds.forEach((assetId, index) => {
+			if (typeof assetId !== "string" || !isId(assetId, "asset")) throw invalidField("validation/invalid-format", `assetIds.${index}`);
 		});
-		return asset;
+		const assets = [];
+		for (const assetId of new Set(assetIds)) assets.push(await this.findOwnAsset(assetId));
+		for (const asset of assets) if (operation === "delete") {
+			await this.deleteAssetTree(asset);
+			this.recordLifecycleEvent("asset.deleted", asset);
+		} else await this.removeContent(asset);
+		return { queued: true };
 	}
-	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);
+	/**
+	* Removes an asset's content like the API: the record and report stay; stored content,
+	* extracted text and the placeholder go. Content already removed keeps its reason, and an
+	* `asset.content-removed` event is recorded either way.
+	*/
+	async removeContent(asset) {
+		await this.imageStorage.deleteContent(asset.id);
+		let removed = asset;
+		if (asset.content.status === "removed") {
+			if (asset.content.image?.thumbhash) removed = await this.databaseStorage.updateAsset({
+				...asset,
+				content: {
+					...asset.content,
+					image: withoutPlaceholder(asset.content.image)
+				}
+			});
+		} else {
+			const now = this.now();
+			removed = await this.databaseStorage.updateAsset({
+				...asset,
+				context: null,
+				content: {
+					...asset.content,
+					status: "removed",
+					removalReason: "requested",
+					updatedAt: now,
+					extractedText: null,
+					fileMetadata: null,
+					image: withoutPlaceholder(asset.content.image)
+				},
+				updatedAt: now
+			});
+		}
+		this.recordLifecycleEvent("asset.content-removed", removed);
+		return removed;
+	}
+	/** Deletes an asset, its stored child assets and their content. */
+	async deleteAssetTree(asset) {
+		const assets = await this.databaseStorage.listAssets(this.projectId);
+		const deleting = /* @__PURE__ */ new Set([asset.id]);
+		for (let added = true; added;) {
+			added = false;
+			for (const other of assets) if (other.parentId && deleting.has(other.parentId) && !deleting.has(other.id)) {
+				deleting.add(other.id);
+				added = true;
 			}
 		}
-		if ("part" in options) {
-			this.assertValidUploadMimeType(options.part.type);
-			const validation = validateAssetPayload(options.part, {
+		for (const id of deleting) {
+			await this.imageStorage.deleteContent(id);
+			await this.databaseStorage.deleteAsset(id);
+		}
+	}
+	/** The upload fields of `POST .../assets`: raw uploads carry them in the query. */
+	uploadFields(request) {
+		const upload = request.headers.get("x-calmlens-upload");
+		if (upload !== "content" && upload !== "part") return this.json(request);
+		const { query } = request;
+		const text = (name) => query.get(name) ?? void 0;
+		const parsed = (name) => {
+			const raw = query.get(name);
+			if (raw === null) return void 0;
+			try {
+				return JSON.parse(raw);
+			} catch {
+				throw invalidField("validation/invalid-json", name);
+			}
+		};
+		const total = query.get("totalSizeInBytes");
+		return {
+			name: query.get("name") ?? "",
+			description: text("description"),
+			processingOptions: parsed("processingOptions"),
+			visibility: text("visibility"),
+			metadata: parsed("metadata"),
+			authorId: text("authorId"),
+			context: parsed("context"),
+			externalId: text("externalId"),
+			externalUrl: text("externalUrl"),
+			folderId: text("folderId"),
+			uploadPresetId: text("uploadPresetId"),
+			contentType: query.get("contentType") ?? request.headers.get("content-type") ?? "",
+			bytes: request.bytes,
+			part: upload === "part" ? {
+				partNumber: this.integer(query, "partNumber", 1),
+				isFinal: query.get("isFinal") === "true",
+				totalSizeInBytes: total === null ? void 0 : this.integer(query, "totalSizeInBytes", 0)
+			} : void 0
+		};
+	}
+	async createAsset(request) {
+		return this.storeAsset(this.uploadFields(request), request.query.get("queue") === "true");
+	}
+	async storeAsset(fields, queue) {
+		if (!fields.name) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Asset name is required" });
+		const { contentType, part } = fields;
+		const bytes = fields.bytes ?? /* @__PURE__ */ new Uint8Array(0);
+		if (contentType !== void 0 && isRejectedUploadMimeType(contentType)) throw fail(API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+			message: getRejectedUploadMimeTypeError(contentType),
+			details: { mimeType: contentType }
+		});
+		const type = inferAssetType(fields.url === void 0 ? contentType ?? "" : void 0);
+		if (part) {
+			if (part.partNumber > 1) throw fail(API_ERROR_CODES.USE_UPLOAD_PART);
+			const partSize = bytes.byteLength;
+			const sizeError = (part.totalSizeInBytes === void 0 ? void 0 : this.multipartImageSizeError(type, part.totalSizeInBytes, true)) ?? (part.isFinal ? this.multipartTotalSizeError(part.totalSizeInBytes, partSize, true) ?? this.multipartImageSizeError(type, partSize, true) : void 0);
+			if (sizeError) throw fail(sizeError);
+			const validation = validateAssetPayload({ uint8Array: bytes }, {
 				multipart: true,
-				isFinal: options.part.isFinal
+				isFinal: part.isFinal
 			});
-			if (!validation.ok) throw this.invalidPayload(validation.error);
+			if (!validation.ok) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+			if (!part.isFinal) {
+				const totalError = this.multipartTotalSizeError(part.totalSizeInBytes, partSize, false);
+				if (totalError) throw fail(totalError);
+			}
 		}
-		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);
+		if (fields.folderId) await this.findOwnFolder(fields.folderId);
+		if (fields.externalId) {
+			if ((await this.databaseStorage.listAssets(this.projectId)).some((asset) => asset.externalId === fields.externalId)) throw fail(API_ERROR_CODES.DUPLICATE_EXTERNAL_ID);
 		}
-		const id = this.createId();
+		const id = this.createId("asset");
 		const now = this.now();
-		const isOpenUpload = "part" in options && !options.part.isFinal;
-		const keepContent = options.processingOptions?.keepContentAfterProcessing === true;
+		const isOpenUpload = part !== void 0 && !part.isFinal;
+		const processingOptions = fields.processingOptions ?? { keepContentAfterProcessing: false };
+		const keepContent = processingOptions.keepContentAfterProcessing === true;
+		const hasContent = fields.url === void 0;
+		const contextItems = selectModerationContextItems(fields.context?.items ?? []);
 		const asset = {
 			id,
 			projectId: this.projectId,
-			folderId: options.folderId ?? null,
+			parentId: null,
+			folderId: fields.folderId ?? null,
+			uploadPresetId: fields.uploadPresetId ?? 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,
-			processingOptions: options.processingOptions,
-			visibility: options.visibility ?? "private",
-			processing: {
-				status: isOpenUpload ? "uploading" : "processing",
-				updatedAt: now,
-				uploadPartsReceived: "part" in options ? options.part.partNumber ?? 1 : null
-			},
-			moderation: {
-				status: "pending",
-				action: null,
-				note: null,
-				reviewerAction: null,
-				reviewerNote: null,
-				reviewerUserId: null,
-				reviewedAt: null,
-				decidedAt: null,
-				report: null
-			},
+			name: fields.name,
+			description: fields.description ?? null,
+			externalId: fields.externalId ?? null,
+			externalUrl: fields.url ?? fields.externalUrl ?? null,
+			type,
+			metadata: fields.metadata ?? null,
+			authorId: fields.authorId ?? null,
+			context: contextItems.length ? { items: contextItems } : null,
+			tags: null,
+			processingOptions,
+			visibility: fields.visibility ?? "private",
 			content: {
 				status: keepContent ? "stored" : "temporary",
 				removalReason: null,
 				updatedAt: now,
 				safetyHold: null,
-				format: this.getContentFormat(options),
+				format: hasContent ? contentType ?? null : null,
 				extension: null,
-				sizeInBytes: this.getSizeInBytes(options) ?? null,
+				sizeInBytes: hasContent ? bytes.byteLength : null,
 				checksums: null,
 				image: null,
-				previewImage: null,
-				extractedText: null
+				extractedText: null,
+				fileMetadata: null
+			},
+			upload: {
+				status: isOpenUpload ? "uploading" : "completed",
+				updatedAt: now,
+				partsReceived: isOpenUpload ? part.partNumber : null
+			},
+			classification: {
+				status: isOpenUpload ? "pending" : "processing",
+				failureReason: null,
+				updatedAt: now,
+				completedAt: null,
+				moderation: {
+					status: "pending",
+					manualReviews: [],
+					flaggedCategories: [],
+					regions: []
+				}
 			}
 		};
-		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);
+		if (part) {
+			await this.imageStorage.putPart(id, {
+				uint8Array: bytes,
+				type: contentType,
+				partNumber: part.partNumber,
+				isFinal: part.isFinal
+			});
+			if (isOpenUpload) this.openUploads.set(id, {
+				queue,
+				totalSizeInBytes: part.totalSizeInBytes
+			});
+		} else if (hasContent) await this.imageStorage.putContent(id, {
+			uint8Array: bytes,
+			type: contentType ?? ""
+		});
+		if (isOpenUpload) return this.databaseStorage.createAsset(asset);
+		const decision = await this.decisionFor(asset, "upload", queue, hasContent ? bytes : null);
+		const stored = await this.databaseStorage.createAsset(decision.status === "pending" ? asset : await this.decided(asset, decision));
+		this.recordUploaded(asset);
+		this.recordProcessingEvents(stored, decision);
+		return stored;
+	}
+	/** Continues a multipart upload: parts must arrive in order while it is `uploading`. */
+	async uploadPart(assetId, request) {
+		const { query, bytes } = request;
+		const partNumber = this.integer(query, "partNumber", 0);
+		const isFinal = query.get("isFinal") === "true";
+		const asset = await this.findOwnAsset(assetId);
+		if (asset.upload.status !== "uploading") throw fail(API_ERROR_CODES.UPLOAD_NOT_OPEN);
+		const expectedPartNumber = (asset.upload.partsReceived ?? 0) + 1;
+		if (partNumber !== expectedPartNumber) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PART_NUMBER, {
+			message: `Expected part ${expectedPartNumber}`,
+			details: {
+				expectedPartNumber,
+				receivedPartNumber: partNumber
+			}
+		});
+		const received = (asset.content.sizeInBytes ?? 0) + bytes.byteLength;
+		const upload = this.openUploads.get(assetId);
+		const sizeError = this.multipartImageSizeError(asset.type, received, isFinal) ?? this.multipartTotalSizeError(upload?.totalSizeInBytes, received, isFinal);
+		if (sizeError) throw fail(sizeError);
+		const validation = validateAssetPayload({ uint8Array: bytes }, {
+			multipart: true,
+			isFinal
+		});
+		if (!validation.ok) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: validation.error });
+		await this.imageStorage.putPart(assetId, {
+			uint8Array: bytes,
+			partNumber,
+			isFinal
+		});
+		const queueOverride = query.get("queue");
+		const queue = queueOverride === null ? upload?.queue ?? false : queueOverride === "true";
+		if (isFinal) this.openUploads.delete(assetId);
+		const now = this.now();
+		const next = {
+			...asset,
+			updatedAt: now,
+			content: {
+				...asset.content,
+				sizeInBytes: received
+			},
+			upload: {
+				...asset.upload,
+				updatedAt: now,
+				partsReceived: isFinal ? null : partNumber
+			}
+		};
+		if (!isFinal) return this.databaseStorage.updateAsset(next);
+		const processing = await this.applyOutcome(next, "pending");
+		const decision = await this.decisionFor(processing, "upload", queue);
+		const stored = await this.databaseStorage.updateAsset(decision.status === "pending" ? processing : await this.decided(processing, decision));
+		this.recordUploaded(processing);
+		this.recordProcessingEvents(stored, decision);
+		return stored;
+	}
+	/** Like the API: image uploads in parts total 10 MiB (checked at the last part) to 20 MiB. */
+	multipartImageSizeError(type, sizeInBytes, isFinal) {
+		if (type !== "image") return void 0;
+		if (sizeInBytes > MAX_IMAGE_UPLOAD_BYTES) return API_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE;
+		if (isFinal && sizeInBytes < MIN_MULTIPART_IMAGE_UPLOAD_BYTES) return API_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL;
+	}
+	/** Like the API: the parts may not overshoot a declared total, and must reach it at the end. */
+	multipartTotalSizeError(totalSizeInBytes, receivedSizeInBytes, isFinal) {
+		if (totalSizeInBytes === void 0) return void 0;
+		return receivedSizeInBytes > totalSizeInBytes || isFinal && receivedSizeInBytes !== totalSizeInBytes ? API_ERROR_CODES.UPLOAD_SIZE_MISMATCH : void 0;
+	}
+	/**
+	* Asks `moderate` how to decide `asset`, with its content: `bytes` when the caller has them,
+	* otherwise the stored parts in order (none once the content is removed).
+	*/
+	async decisionFor(asset, trigger, queued, bytes) {
+		let data = bytes;
+		if (data === void 0) {
+			const stored = asset.content.status === "removed" ? void 0 : await this.imageStorage.getContent(asset.id);
+			const parts = stored ? [...stored.parts].sort(([a], [b]) => a - b).map(([, part]) => part) : [];
+			data = stored ? new Uint8Array(await new Blob(parts).arrayBuffer()) : null;
+		}
+		const content = {
+			bytes: data,
+			text: data && asset.type === "plaintext-document" ? new TextDecoder().decode(data) : null
+		};
+		return toDecision(await this.options.moderate({
+			asset: structuredClone(asset),
+			content,
+			trigger,
+			queued
+		}));
+	}
+	/** `asset` decided as `decision` says, with its report. */
+	decided(asset, decision) {
+		return this.applyOutcome(asset, decision.status, "policy", decision.report());
+	}
+	/**
+	* Stores a processing asset's `decision` and records its events; a `pending` decision leaves it
+	* processing.
+	*/
+	async settle(asset, decision) {
+		if (decision.status === "pending") return asset;
+		const stored = await this.databaseStorage.updateAsset(await this.decided(asset, decision));
+		this.recordProcessingEvents(stored, decision);
+		return stored;
+	}
+	/** Asks `moderate` (unless `decision` is given) and settles a processing asset. */
+	async moderateStored(asset, trigger, decision) {
+		return this.settle(asset, decision ?? await this.decisionFor(asset, trigger, true));
+	}
+	/** `asset.uploaded`, as the API records it when an upload completes (UploadAssetUtils.ts). */
+	recordUploaded(asset) {
+		this.pushEvent({
+			type: "asset.uploaded",
+			severity: "low",
+			assetId: asset.id,
+			asset: toEventAsset(asset),
+			facts: [
+				{
+					key: "asset-type",
+					value: asset.type
+				},
+				assetNameFact(asset),
+				{
+					key: "file-format",
+					value: asset.content.format ?? null
+				}
+			]
+		});
+	}
+	/**
+	* The events the pipeline records when it settles an asset (AssetClassification.ts and
+	* AssetErrorAlert.ts): `asset.classified` and the automated `asset.<status>`, or
+	* `asset.failed`.
+	*/
+	recordProcessingEvents(asset, decision) {
+		if (decision.status === "pending") return;
+		const event = {
+			assetId: asset.id,
+			asset: toEventAsset(asset)
+		};
+		if (decision.status === "failed") {
+			this.pushEvent({
+				...event,
+				type: "asset.failed",
+				severity: "high",
+				facts: [
+					assetNameFact(asset),
+					{
+						key: "asset-type",
+						value: asset.type
+					},
+					{
+						key: "previous-status",
+						value: "processing"
+					},
+					{
+						key: "failure-reason",
+						value: asset.classification.failureReason ?? "processing-error"
+					}
+				]
+			});
+			return;
 		}
-		return this.databaseStorage.createAsset(isOpenUpload ? asset : await this.applyOutcome(asset, queue ? this.queuedOutcome : this.analyzedOutcome));
+		const flaggedCategories = decision.report()?.flaggedCategories ?? [];
+		this.pushEvent({
+			...event,
+			type: "asset.classified",
+			severity: "low",
+			facts: [
+				{
+					key: "flagged-categories",
+					value: flaggedCategories
+				},
+				{
+					key: "moderation-status",
+					value: decision.status
+				},
+				{
+					key: "asset-type",
+					value: asset.type
+				},
+				assetNameFact(asset)
+			]
+		});
+		this.pushEvent({
+			...event,
+			type: `asset.${decision.status}`,
+			severity: decision.status === "allowed" || decision.status === "limited" ? "low" : "high",
+			facts: [
+				{
+					key: "decided-by",
+					value: "automated"
+				},
+				{
+					key: "flagged-categories",
+					value: flaggedCategories
+				},
+				{
+					key: "asset-type",
+					value: asset.type
+				},
+				assetNameFact(asset)
+			]
+		});
 	}
 	/**
-	* Moves an asset to `outcome` like the pipeline would: a decision finishes processing, and
-	* finished processing removes content kept only temporarily (`keepContentAfterProcessing` off).
+	* Moves an asset to `outcome` like the pipeline would: a decision finishes processing, `purged`
+	* deletes the content (with `purgeReason`, `policy` for the pipeline), and finished processing
+	* removes content kept only temporarily (`keepContentAfterProcessing` off). A classified image
+	* gets a ThumbHash for its placeholder, which goes with purged content.
 	*/
-	async applyOutcome(asset, outcome) {
+	async applyOutcome(asset, outcome, purgeReason = "policy", report) {
 		const now = this.now();
-		const decided = outcome === "approved" || outcome === "rejected";
-		const processingStatus = decided ? "done" : outcome === "failed" ? "failed" : "processing";
-		const removeContent = processingStatus === "done" && asset.content.status === "temporary";
+		const decided = outcome !== "pending" && outcome !== "failed";
+		const classificationStatus = decided ? "completed" : outcome === "failed" ? "failed" : "processing";
+		const purge = outcome === "purged" && asset.content.status !== "removed";
+		const removeContent = purge || classificationStatus === "completed" && asset.content.status === "temporary";
 		if (removeContent) await this.imageStorage.deleteContent(asset.id);
+		const image = decided && asset.type === "image" && asset.content.status !== "removed" && !purge ? {
+			width: null,
+			height: null,
+			perceptualHash: null,
+			perceptualHashQuality: null,
+			...asset.content.image,
+			thumbhash: MOCK_THUMBHASH,
+			averageColor: asset.content.image?.averageColor ?? "#7f7f7f"
+		} : outcome === "purged" ? withoutPlaceholder(asset.content.image) : asset.content.image;
 		return {
 			...asset,
 			updatedAt: now,
-			processing: {
-				...asset.processing,
-				status: processingStatus,
-				updatedAt: now
-			},
-			moderation: {
-				...asset.moderation,
-				status: decided ? outcome : "pending",
-				decidedAt: decided ? now : null
-			},
+			...removeContent && { context: null },
 			content: removeContent ? {
 				...asset.content,
 				status: "removed",
-				removalReason: "retention",
+				removalReason: purge ? purgeReason : "retention",
 				updatedAt: now,
-				extractedText: null
-			} : asset.content
+				extractedText: null,
+				fileMetadata: null,
+				image: withoutPlaceholder(image)
+			} : {
+				...asset.content,
+				image
+			},
+			upload: {
+				...asset.upload,
+				status: "completed",
+				updatedAt: now
+			},
+			classification: {
+				...asset.classification,
+				status: classificationStatus,
+				failureReason: classificationStatus === "failed" ? "processing-error" : null,
+				updatedAt: now,
+				completedAt: decided ? now : null,
+				moderation: {
+					...asset.classification.moderation,
+					status: decided ? outcome : "pending",
+					...report
+				}
+			}
+		};
+	}
+	/** Adds an `asset.deleted`, `asset.content-removed` or `asset.retried` event, like the API. */
+	recordLifecycleEvent(type, asset) {
+		this.pushEvent({
+			type,
+			severity: "low",
+			assetId: asset.id,
+			asset: toEventAsset(asset),
+			facts: [{
+				key: "asset-name",
+				value: asset.name,
+				...type === "asset.deleted" ? {} : { url: `https://calmlens.com/go/asset/${asset.id}` }
+			}, {
+				key: "asset-type",
+				value: asset.type
+			}]
+		});
+	}
+	/**
+	* `/upload-presets/:id/assets[/:assetId[/part]]`: uploads through the preset, with its rules
+	* applied in the API's order (token, content type, size), and checks of its uploads.
+	*/
+	async presetRoute(request, uploadPresetId, rest, session) {
+		if (!session) throw fail(API_ERROR_CODES.UPLOAD_PRESET_NOT_FOUND);
+		const { preset } = session;
+		const toUploaded = (asset) => ({
+			id: asset.id,
+			name: asset.name,
+			uploadPresetId,
+			createdAt: asset.createdAt,
+			...preset.showDecisions !== false && { status: asset.classification.moderation.status }
+		});
+		const [assetId, action] = rest;
+		if (assetId !== void 0) {
+			if (!session.uploads.has(assetId)) throw fail(API_ERROR_CODES.ASSET_NOT_FOUND);
+			const asset = await this.findOwnAsset(assetId);
+			if (request.method === "POST" && action === "part") return toUploaded(await this.uploadPart(assetId, request));
+			if (request.method === "GET" && action === void 0) return toUploaded(asset);
+			throw new ApiFailure(404, "not-found", "No such route");
+		}
+		if (request.method !== "POST") throw new ApiFailure(404, "not-found", "No such route");
+		const fields = this.uploadFields(request);
+		const token = request.headers.get("authorization");
+		if (preset.requireToken && !token) throw fail(API_ERROR_CODES.UPLOAD_PRESET_TOKEN_REQUIRED);
+		if (preset.allowedContentTypes && !isFileAccepted({
+			name: fields.name,
+			type: fields.contentType ?? ""
+		}, preset.allowedContentTypes.join(","))) throw fail(API_ERROR_CODES.UPLOAD_PRESET_CONTENT_TYPE_NOT_ALLOWED);
+		const size = fields.part?.totalSizeInBytes ?? fields.bytes?.byteLength;
+		if (preset.maxFileSizeInBytes !== void 0 && size !== void 0 && size > preset.maxFileSizeInBytes) throw fail(API_ERROR_CODES.UPLOAD_PRESET_TOO_LARGE);
+		const asset = await this.storeAsset({
+			...fields,
+			uploadPresetId,
+			visibility: preset.visibility ?? "public",
+			folderId: preset.folderId ?? void 0,
+			processingOptions: { keepContentAfterProcessing: preset.keepContentAfterProcessing ?? true }
+		}, request.query.get("queue") === "true");
+		session.uploads.add(asset.id);
+		return toUploaded(asset);
+	}
+	/**
+	* Reads the feed like the API: without `cursor`, no events and a `nextCursor` for "now"; with
+	* `cursor`, up to `pageSize` events added since, oldest first. `nextCursor` is never null: it
+	* is where to keep polling from.
+	*/
+	listEvents(query) {
+		const pageSize = this.integer(query, "pageSize", 50);
+		if (pageSize < 1) throw invalidField("validation/too-small", "pageSize");
+		if (pageSize > MAX_PAGE_SIZE) throw invalidField("validation/too-big", "pageSize");
+		const cursor = query.get("cursor");
+		if (!cursor) return {
+			items: [],
+			nextCursor: `mock_${this.eventFeed.length}`,
+			hasMore: false
+		};
+		const match = /^mock_(\d+)$/.exec(cursor);
+		const position = match ? Number(match[1]) : NaN;
+		if (!Number.isSafeInteger(position) || position > this.eventFeed.length) throw fail(API_ERROR_CODES.INVALID_CURSOR);
+		const items = this.eventFeed.slice(position, position + pageSize);
+		const next = position + items.length;
+		return {
+			items,
+			nextCursor: `mock_${next}`,
+			hasMore: next < this.eventFeed.length
 		};
 	}
+	/**
+	* Lists folders like the API: one keyset page of a parent's children, optionally matching
+	* `search`, by name unless `ordering` says otherwise, with the folders above them.
+	*/
+	async listFolders(query) {
+		const all = await this.databaseStorage.listFolders?.(this.projectId) ?? [];
+		const parentId = query.get("parentId");
+		const search = query.get("search")?.trim() || null;
+		const ordering = this.folderOrdering(query);
+		const matching = all.filter((folder) => (folder.parentId ?? null) === parentId && (!search || folder.name.toLowerCase().includes(search.toLowerCase())));
+		const page = createPage(matching, {
+			cursor: query.get("cursor") ?? void 0,
+			pageSize: this.integer(query, "pageSize", 50),
+			ordering
+		}, {
+			scope: JSON.stringify([
+				this.projectId,
+				parentId,
+				search
+			]),
+			fail: this.pageFailure,
+			defaultOrdering: [{
+				field: "name",
+				direction: "asc"
+			}]
+		});
+		const folders = page.items;
+		const ids = /* @__PURE__ */ new Set([...parentId ? [parentId] : [], ...folders.map((folder) => folder.id)]);
+		const byId = new Map(all.map((folder) => [folder.id, folder]));
+		for (const id of ids) {
+			const parent = byId.get(id)?.parentId;
+			if (parent) ids.add(parent);
+		}
+		return {
+			items: folders,
+			ancestors: all.filter((folder) => ids.has(folder.id) && !folders.some((item) => item.id === folder.id)),
+			nextCursor: page.nextCursor,
+			pageSize: page.pageSize,
+			hasMore: page.hasMore,
+			ordering: page.ordering
+		};
+	}
+	/** The folder list's `ordering`: at most one rule, by `name` or `createdAt`. */
+	folderOrdering(query) {
+		const ordering = this.ordering(query);
+		if (ordering.length > 1) throw invalidField("validation/too-big", "ordering");
+		for (const [index, rule] of ordering.entries()) {
+			if (rule.field !== "name" && rule.field !== "createdAt") throw invalidField("validation/invalid-value", `ordering.${index}.field`);
+			if (rule.direction !== "asc" && rule.direction !== "desc") throw invalidField("validation/invalid-value", `ordering.${index}.direction`);
+		}
+		return ordering;
+	}
+	async createFolder(body) {
+		const name = body.name;
+		if (typeof name !== "string" || !name) throw fail(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Folder name is required" });
+		const parentId = body.parentId ?? null;
+		if (parentId) await this.findOwnFolder(parentId);
+		await this.assertUniqueFolderName(name, parentId);
+		const now = this.now();
+		const folder = {
+			id: this.createId("fldr"),
+			projectId: this.projectId,
+			parentId,
+			name,
+			createdAt: now,
+			updatedAt: now
+		};
+		return this.databaseStorage.createFolder ? await this.databaseStorage.createFolder(folder) : folder;
+	}
+	async updateFolder(folderId, body) {
+		const folder = await this.findOwnFolder(folderId);
+		const name = body.name;
+		if (name !== void 0 && name !== folder.name) await this.assertUniqueFolderName(name, folder.parentId ?? null, folderId);
+		const updated = {
+			...folder,
+			...name !== void 0 ? { name } : {},
+			updatedAt: this.now()
+		};
+		return this.databaseStorage.updateFolder ? await this.databaseStorage.updateFolder(updated) : updated;
+	}
+	async deleteFolder(folderId) {
+		await this.findOwnFolder(folderId);
+		const hasAssets = (await this.databaseStorage.listAssets(this.projectId)).some((asset) => asset.folderId === folderId);
+		const hasChildren = (await this.databaseStorage.listFolders?.(this.projectId) ?? []).some((folder) => folder.parentId === folderId);
+		if (hasAssets || hasChildren) throw fail(API_ERROR_CODES.FOLDER_NOT_EMPTY, { details: {
+			hasAssets,
+			hasChildren
+		} });
+		await this.databaseStorage.deleteFolder?.(folderId);
+	}
+	async moveFolder(folderId, body) {
+		const folder = await this.findOwnFolder(folderId);
+		const targetParentId = body.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 fail(API_ERROR_CODES.FOLDER_PARENT_CYCLE);
+				visited.add(candidate.id);
+				candidate = candidate.parentId ? await this.resolveFolder(candidate.parentId) : void 0;
+			}
+		}
+		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;
+	}
 	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;
+		const folder = await this.databaseStorage.getFolder?.(folderId);
+		return folder && folder.projectId === this.projectId ? folder : void 0;
 	}
 	async findOwnFolder(folderId) {
-		encodePathSegment(folderId, "Folder ID");
 		const folder = await this.resolveFolder(folderId);
-		if (!folder) throw this.apiError(API_ERROR_CODES.FOLDER_NOT_FOUND);
+		if (!folder) throw fail(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.` });
+		if ((await this.databaseStorage.listFolders?.(this.projectId) ?? []).find((folder) => folder.id !== excludeFolderId && (folder.parentId ?? null) === parentId && folder.name === name)) throw fail(API_ERROR_CODES.DUPLICATE_FOLDER_NAME, { message: `A folder named "${name}" already exists in this location.` });
 	}
-	getContentFormat(options) {
-		if ("content" in options) return options.content.type;
-		if ("part" in options) return options.part.type;
-		return null;
+	/** Saves each lens in order, like the API: new ones, or changes with a greater version. */
+	ensureLenses(body) {
+		const lenses = Array.isArray(body.lenses) ? body.lenses : [];
+		if (lenses.length === 0) throw invalidField("validation/too-small", "lenses");
+		return { lenses: lenses.map((lens) => this.ensureLens(lens)) };
+	}
+	ensureLens(options) {
+		const existing = this.lenses.get(options.identifier);
+		if (!existing) {
+			const now = this.now();
+			const lens = {
+				id: this.createId("lens"),
+				projectId: this.projectId,
+				...options,
+				createdAt: now,
+				updatedAt: now
+			};
+			this.lenses.set(lens.identifier, lens);
+			return lens;
+		}
+		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 = {
+				...existing,
+				...options,
+				updatedAt: this.now()
+			};
+			this.lenses.set(lens.identifier, lens);
+			return lens;
+		}
+		throw fail(API_ERROR_CODES.LENS_VERSION_CONFLICT, { details: {
+			currentVersion: existing.version,
+			minimumVersion: existing.version + 1,
+			requestedVersion: options.version
+		} });
 	}
-	getSizeInBytes(options) {
-		if ("content" in options) {
-			if ("plainText" in options.content) return new TextEncoder().encode(options.content.plainText).byteLength;
-			return getAssetPayloadByteLength(options.content);
+	/**
+	* Serves stored content like the CDN (`/assets/:projectId/:asset/:resource`): `200` with
+	* `Content-Type`, `Content-Length`, `Cache-Control`, `Cache-Tag`, the CDN's protection headers
+	* and, for images, `ETag` and `Expires`; or a JSON error body with `404`/`403`. A
+	* `placeholder` is the asset's ThumbHash as a PNG.
+	*/
+	async serveCdn(request) {
+		const { url, segments, query } = request;
+		const [root, projectId, assetIdentifier, resource] = segments;
+		const notFound = () => this.jsonResponse(404, {
+			code: "asset/not-found",
+			message: "Asset not found"
+		}, url);
+		if (root !== "assets" || projectId !== this.projectId || !assetIdentifier) return notFound();
+		const asset = (await this.databaseStorage.listAssets(this.projectId)).find((asset) => asset.id === assetIdentifier || asset.externalId === assetIdentifier);
+		if (!asset) return notFound();
+		const notAvailable = () => this.jsonResponse(403, {
+			code: "asset/not-available",
+			message: "Asset is not available"
+		}, url);
+		const grants = request.headers.get("x-api-key") === this.apiKey ? this.grants : [];
+		const folders = await this.databaseStorage.listFolders?.(this.projectId) ?? [];
+		const canDownload = () => permits(grants, "assets:download", asset.folderId ?? null, folders);
+		const status = asset.classification.moderation.status;
+		const isHead = request.method === "HEAD";
+		if (resource === "placeholder") {
+			const thumbhash = asset.content.image?.thumbhash;
+			if (!thumbhash || status === "purged") return notAvailable();
+			const png = Uint8Array.from(atob(placeholderHashToDataURL(thumbhash).split(",", 2)[1]), (char) => char.charCodeAt(0));
+			return this.cdnResponse(isHead, png, url, {
+				"Content-Type": "image/png",
+				"Cache-Control": "public, max-age=3600",
+				"Cache-Tag": `asset-${asset.id}`,
+				ETag: `"${thumbhash}"`
+			});
 		}
-		if ("part" in options) return options.part.sizeInBytes ?? options.sizeInBytes ?? getAssetPayloadByteLength(options.part);
+		const storedContent = await this.imageStorage.getContent(asset.id);
+		if (asset.upload.status === "uploading" || status === "purged" || status === "blocked" || asset.classification.status === "failed" || asset.content.status === "removed" || !storedContent) return notAvailable();
+		let claims = {};
+		try {
+			claims = JSON.parse(query.get("viewerClaims") ?? request.headers.get("X-CalmLens-Viewer-Claims") ?? "{}");
+		} catch {
+			return this.jsonResponse(400, { code: "viewer/invalid-claims" }, url);
+		}
+		if (status === "age-restricted" && claims.ageConfirmed !== true) return this.jsonResponse(403, { code: "viewer/age-confirmation-required" }, url);
+		const isPrivate = asset.visibility !== "public";
+		if (isPrivate && !canDownload()) 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 parts = [...storedContent.parts.entries()].sort(([left], [right]) => left - right).map(([, value]) => value);
+		const bytes = new Uint8Array(parts.reduce((sum, value) => sum + value.byteLength, 0));
+		let offset = 0;
+		for (const part of parts) {
+			bytes.set(part, offset);
+			offset += part.byteLength;
+		}
+		const contentType = storedContent.type ?? "application/octet-stream";
+		const isImage = asset.type === "image";
+		return this.cdnResponse(isHead, bytes, url, {
+			"Content-Type": contentType,
+			"Cache-Control": Object.keys(claims).length ? "private, no-store" : `${isPrivate ? "private" : "public"}, ${isImage ? "max-age=31536000, immutable" : "max-age=3600"}`,
+			"Cache-Tag": `asset-${asset.id}`,
+			...isImage ? {
+				ETag: `"${asset.id}"`,
+				Expires: new Date(this.now() + 31536e6).toUTCString()
+			} : {},
+			"X-Content-Type-Options": "nosniff",
+			"Content-Security-Policy": "sandbox; default-src 'none'",
+			...isActiveContentType(contentType) ? { "Content-Disposition": "attachment" } : {}
+		});
+	}
+	cdnResponse(isHead, bytes, url, headers) {
+		return this.response(200, isHead ? null : bytes, url, {
+			...headers,
+			"Content-Length": String(bytes.byteLength),
+			"X-Mock-CalmLens-CDN-URL": url
+		});
 	}
 };
-//#endregion
-//#region src/testing/MockWebhooks.ts
-/** The JSON body of a webhook delivery for a stored event (or an event from `events.list`). */
+// src/testing/MockStorage.ts
+var InMemoryMockImageStorage = class {
+	constructor() {
+		this.content = /* @__PURE__ */ new Map();
+	}
+	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
+		});
+	}
+	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 {
+	constructor() {
+		this.assets = /* @__PURE__ */ new Map();
+		this.folders = /* @__PURE__ */ new Map();
+	}
+	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);
+	}
+};
+// src/testing/MockCalmLensServerClient.ts
+const apis = /* @__PURE__ */ new WeakMap();
+/** The in-memory API a mock server client runs against, for `MockCalmLensAppClient`. */
+const getMockApi = (client) => {
+	const api = apis.get(client);
+	if (!api) throw invalidConfig("mockOptions.server must be a MockCalmLensServerClient");
+	return api;
+};
+/**
+* Options that make a real client send its requests to `api`: waits only move the mock's clock,
+* multipart size checks are the in-memory API's, and nothing is retried unless the options say so.
+*/
+const mockClientOptions = (api, endpoints, session) => {
+	const fetch = api.createFetch(endpoints, session);
+	const hooks = {
+		sleep: async (ms, signal) => {
+			await sleep(0, signal);
+			api.waitedMs += ms;
+		},
+		now: () => api.waitedMs,
+		uploadTokenTime: () => ({
+			now: api.now(),
+			nonce: randomUuid()
+		}),
+		deferUploadChecks: true,
+		defaultCdnBaseUrl: "mock://calmlens/v1"
+	};
+	return {
+		fetch,
+		uploadFetch: fetch,
+		cdnFetch: fetch,
+		[MOCK_HOOKS]: hooks
+	};
+};
+/**
+* The real `CalmLensServerClient`, answered by an in-memory CalmLens API and CDN instead of the
+* network: every method runs the real client's code, and the in-memory API answers its requests
+* with the API's statuses, bodies, error bodies and headers. Mock helpers decide assets, add
+* events, change the API key's grants, fail requests and list the requests sent.
+*/
+var MockCalmLensServerClient = class extends CalmLensServerClient {
+	#api;
+	#projectId;
+	/**
+	* Accepts the same options as `CalmLensServerClient` (validated the same way), plus
+	* `mockOptions`. `maxRetries` defaults to 0, so a failed request fails once; retry backoff and
+	* `assets.waitForDecision` take no real time.
+	*/
+	constructor(options) {
+		validateServerClientOptions(options);
+		const { mockOptions = {}, ...clientOptions } = options;
+		const api = new MockCalmLensApi({
+			projectId: options.projectId,
+			apiKey: options.apiKey,
+			grants: getMockApiKeyGrants(options.apiKey),
+			databaseStorage: mockOptions.databaseStorage ?? new InMemoryMockDatabaseStorage(),
+			imageStorage: mockOptions.imageStorage ?? new InMemoryMockImageStorage(),
+			createId: mockOptions.createId ?? newId,
+			now: mockOptions.now ?? createMonotonicClock(),
+			moderate: mockOptions.moderate ?? defaultModerate,
+			signedUrlBaseUrl: mockOptions.signedUrlBaseUrl ?? "mock://calmlens"
+		});
+		let endpoints;
+		super({
+			maxRetries: 0,
+			...clientOptions,
+			dangerouslyAllowBrowser: true,
+			...mockClientOptions(api, () => endpoints)
+		});
+		const { baseUrl, cdnBaseUrl } = this.toJSON();
+		endpoints = {
+			baseUrl,
+			cdnBaseUrl
+		};
+		this.#api = api;
+		this.#projectId = options.projectId;
+		this.databaseStorage = api.databaseStorage;
+		this.imageStorage = api.imageStorage;
+		apis.set(this, api);
+	}
+	/** Keeps the API key out of `console.log` and `util.inspect`. */
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return `MockCalmLensServerClient { projectId: ${JSON.stringify(this.#projectId)} }`;
+	}
+	/**
+	* Every request sent to the mock's API and CDN, oldest first, by this client and the
+	* `MockCalmLensAppClient`s that use it, each with the client method that sent it.
+	*/
+	get calls() {
+		return this.#api.calls.map(({ call }) => call);
+	}
+	/**
+	* Requests `operation` sends, oldest first. A request several methods send matches each of
+	* them: `callsTo("text.classify")` also lists `assets.classify` text uploads, and
+	* `callsTo("assets.waitForDecision")` the `assets.retrieve` requests it polls with.
+	*/
+	callsTo(operation) {
+		return this.#api.calls.filter(({ operations }) => operations.includes(operation)).map(({ call }) => call);
+	}
+	/** Forgets the requests recorded so far, so `calls` lists only later ones. */
+	clearCalls() {
+		this.#api.calls.length = 0;
+	}
+	/**
+	* Makes the next request (or the next one `operation` sends) fail instead of reaching the
+	* in-memory API. Each queued failure fails one request, so a retry takes the next queued
+	* failure or reaches the API. An API error code answers with that error and its HTTP status,
+	* with `details` and a `Retry-After` of `retryAfter` seconds when given.
+	*/
+	failNextRequest(failure = "transport-error", options = {}) {
+		this.#api.failNextRequest(failure, options);
+	}
+	/**
+	* Changes the grants of the mock's API key, as editing the key in the portal would: later
+	* requests, such as `cdn.serve`, use them. The key itself stays the same, so idempotency keys
+	* it used still replay.
+	*/
+	setApiKeyGrants(grants) {
+		this.#api.grants = getMockApiKeyGrants(createMockApiKey(grants));
+	}
+	/**
+	* 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) {
+		return this.#api.enqueueEvent(input);
+	}
+	/**
+	* Applies a reviewer's decision to a stored asset, as the portal or API would: the moderation
+	* status changes (`purged` also removes the content, with reason `requested` and an
+	* `asset.content-removed` event), the review joins `manualReviews`, and an `asset.<decision>`
+	* event with a `decided-by: reviewer` fact joins the events feed. Rejects with
+	* `asset/not-found` for an unknown asset. It sends no request.
+	*/
+	decide(assetId, decision) {
+		return this.#api.decide(assetId, decision);
+	}
+	/**
+	* Finishes processing a pending asset as the moderation pipeline would: with `decision`, or
+	* else what `mockOptions.moderate` returns for the `complete` trigger (`allowed` by default).
+	* The asset gets the decision's report, and `asset.classified` and the automated
+	* `asset.<status>` (or `asset.failed`) join the events feed. No review is recorded, so the
+	* asset can still be moderated again. Rejects with `asset/not-found` for an unknown asset and
+	* `sdk/invalid-argument` for one that isn't processing. It sends no request.
+	*/
+	completeProcessing(assetId, decision) {
+		return this.#api.completeProcessing(assetId, decision);
+	}
+};
+// src/testing/MockCalmLensAppClient.ts
+const MOCK_PROJECT_ID = "proj_0000000000000000c1a5";
+/**
+* The real `CalmLensAppClient`, answered by the in-memory API of a `MockCalmLensServerClient`.
+* The API applies `mockOptions.preset` to this client's uploads like CalmLens applies an upload
+* preset: its token, content type and size rules with the API's error codes, and its visibility,
+* folder, content retention and decision display. The client can check and continue only the
+* uploads it made.
+*/
+var MockCalmLensAppClient = class extends CalmLensAppClient {
+	#uploadPresetId;
+	constructor(options) {
+		validateAppClientOptions(options);
+		const { mockOptions = {}, ...clientOptions } = options;
+		const server = mockOptions.server ?? new MockCalmLensServerClient({
+			apiKey: createMockApiKey([{
+				actions: [
+					"assets:create",
+					"assets:read",
+					"assets:update"
+				],
+				folderId: null,
+				includeSubfolders: true
+			}]),
+			projectId: MOCK_PROJECT_ID,
+			mockOptions: { moderate: mockOptions.moderate }
+		});
+		let endpoints;
+		const { cdnFetch: _cdnFetch, ...requestOptions } = mockClientOptions(getMockApi(server), () => endpoints, {
+			preset: mockOptions.preset ?? {},
+			uploads: /* @__PURE__ */ new Set()
+		});
+		super({
+			maxRetries: 0,
+			...clientOptions,
+			...requestOptions
+		});
+		endpoints = {
+			baseUrl: this.toJSON().baseUrl,
+			cdnBaseUrl: server.toJSON().cdnBaseUrl
+		};
+		this.server = server;
+		this.#uploadPresetId = options.uploadPresetId;
+	}
+	/** Keeps tokens out of `console.log` and `util.inspect`. */
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return `MockCalmLensAppClient { uploadPresetId: ${JSON.stringify(this.#uploadPresetId)} }`;
+	}
+};
+// src/testing/MockWebhooks.ts
+/**
+* The JSON body of a webhook delivery for an event, such as one from `events.list`: the event in
+* the same shape `events.list` returns it. Fields that are not part of that shape are left out.
+*/
 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
-	}
+	type: event.type,
+	severity: event.severity,
+	title: event.title,
+	description: event.description ?? null,
+	assetId: event.assetId ?? null,
+	asset: event.asset ?? null,
+	facts: event.facts,
+	createdAt: event.createdAt
 });
 /** `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}`)}`;
@@ -9260,5 +10468,4 @@ const createWebhookHeaders = async (options) => {
 		[WEBHOOK_SIGNATURE_HEADER]: await createWebhookSignatureHeader(options.secret, timestamp, options.body)
 	};
 };
-//#endregion
-export { InMemoryMockDatabaseStorage, InMemoryMockImageStorage, MEDIA_TEST_SIGNALS, MOCK_API_KEY_PREFIX, MockCalmLensServerClient, createMockApiKey, createWebhookHeaders, createWebhookSignatureHeader, generateMediaTestCode, toWebhookEventPayload };
+export { InMemoryMockDatabaseStorage, InMemoryMockImageStorage, MEDIA_TEST_SIGNALS, MOCK_API_KEY_PREFIX, MockCalmLensAppClient, MockCalmLensServerClient, MockDecision, createMockApiKey, createWebhookHeaders, createWebhookSignatureHeader, generateMediaTestCode, mockDecision, signUploadTokenWithApiKey as signUploadToken, toWebhookEventPayload };