@calmlens/sdk 0.12.0 → 0.13.0

package/cjs/testing.js

@@ -21,9 +21,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_CalmLensError = require("./CalmLensError-CKwMKV0S.js");
-const require_CalmLensWebhooks = require("./CalmLensWebhooks-BTPxKvcD.js");
-const require_CalmLensUtils = require("./CalmLensUtils-Dg3s4loH.js");
+const require_CalmLensVersion = require("./CalmLensVersion-DjhsJ1gj.js");
+const require_CalmLensWebhooks = require("./CalmLensWebhooks-hVquX5L1.js");
+const require_CalmLensUtils = require("./CalmLensUtils-vX5H_vMn.js");
 let zod = require("zod");
 zod = __toESM(zod);
 require("zod/v4");
@@ -60,58 +60,63 @@ const MODERATION_CATEGORY_DEFINITIONS = {
 		docsHref: "/docs/guides/moderation-categories#hate-and-identity-abuse"
 	},
 	"criminal-activity": {
-		summary: "Planning, assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act.",
-		definition: "covers planning, requests for assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act. A request can qualify even when no act occurs and a later reply refuses it. Dangerous activity requires a concrete serious risk of physical harm.",
-		exclusions: "Neutral reporting, prevention, lawful safety advice, fiction without criminal assistance, and vague dangerous references do not qualify. Masks, computers, payment cards, detention or ordinary tools do not establish criminal facilitation by themselves. A clear visual demonstration of how to carry out a crime can qualify.",
+		summary: "Planning, assistance, instructions, encouragement or facilitation of a concrete criminal or seriously dangerous act, 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 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"
 	}
 };
 //#endregion
 //#region ../shared/src/ModerationPolicyDimensions.ts
 const MODERATION_QUALIFIERS = [
-	"nudity",
+	"sexual-nudity",
 	"sexual-activity",
-	"explicit-sexual-language",
+	"sexual-explicit-language",
 	"sexual-solicitation",
-	"physical-attack",
-	"violent-threat",
-	"violent-preparation",
-	"violent-encouragement",
-	"injury",
-	"death",
-	"graphic",
+	"sexual-historical",
+	"sexual-documentary",
+	"sexual-fictional",
+	"sexual-support-prevention",
+	"violence-attack",
+	"violence-threat",
+	"violence-preparation",
+	"violence-encouragement",
+	"violence-injury",
+	"violence-death",
+	"violence-graphic",
+	"violence-historical",
+	"violence-documentary",
+	"violence-fictional",
+	"violence-support-prevention",
 	"self-harm-thoughts",
 	"self-harm-preparation",
 	"self-harm-act",
 	"self-harm-methods",
 	"self-harm-encouragement",
-	"personal-abuse",
-	"targeted-intimidation",
+	"self-harm-documentary",
+	"self-harm-fictional",
+	"self-harm-support-prevention",
+	"harassment-abuse",
+	"harassment-intimidation",
 	"harassment-threat",
-	"sexual-harassment",
+	"harassment-sexual",
 	"harassment-encouragement",
-	"identity-abuse",
-	"dehumanization",
-	"identity-inferiority",
-	"discriminatory-exclusion",
+	"harassment-fictional",
+	"hate-abuse",
+	"hate-dehumanization",
+	"hate-inferiority",
+	"hate-exclusion",
 	"hate-threat",
-	"criminal-demonstration",
-	"criminal-preparation",
-	"criminal-request",
-	"criminal-instructions",
-	"criminal-promotion",
-	"historical",
-	"documentary",
-	"fictional",
-	"support-prevention"
+	"hate-historical",
+	"hate-fictional",
+	"criminal-activity-demonstration",
+	"criminal-activity-preparation",
+	"criminal-activity-request",
+	"criminal-activity-instructions",
+	"criminal-activity-promotion",
+	"criminal-activity-substances",
+	"criminal-activity-fictional"
 ];
-const SHARED_QUALIFIERS = [
-	"historical",
-	"documentary",
-	"fictional",
-	"support-prevention"
-];
-[...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS], [...SHARED_QUALIFIERS];
 //#endregion
 //#region ../../node_modules/zod-meta/esm/index.js
 const ZOD_META_KEY = "__zod_meta__";
@@ -276,7 +281,11 @@ const LIKELIHOOD_SCHEMA = zod.enum([
 	"likely",
 	"very-likely"
 ]);
-const CLASSIFICATION_NOT_EVALUATED_REASON_SCHEMA = zod.enum(["not-supported", "unavailable"]);
+const CLASSIFICATION_NOT_EVALUATED_REASON_SCHEMA = zod.enum([
+	"not-supported",
+	"unavailable",
+	"not-requested"
+]);
 const CLASSIFICATION_QUALIFIER_RESULTS_SCHEMA = zod.partialRecord(zod.enum(MODERATION_QUALIFIERS), zod.discriminatedUnion("status", [zod.object({
 	status: zod.literal("evaluated"),
 	score: zod.number().min(0).max(1),
@@ -404,6 +413,8 @@ const ACTION_SCHEMA = zod.enum([
 	"lenses:write",
 	"upload-presets:read",
 	"upload-presets:write",
+	"reviews:read",
+	"reviews:write",
 	"project:manage"
 ]);
 const PROJECT_ACTIONS = [...[
@@ -413,7 +424,8 @@ const PROJECT_ACTIONS = [...[
 	"connectors",
 	"metadata",
 	"lenses",
-	"upload-presets"
+	"upload-presets",
+	"reviews"
 ].flatMap((feature) => [`${feature}:read`, `${feature}:write`]), "project:manage"];
 const isProjectAction = (action) => PROJECT_ACTIONS.includes(action);
 /** The actions that include `action`: its feature's write action and project:manage. */
@@ -426,7 +438,7 @@ const GRANT_SCHEMA = zod.object({
 const GRANTS_SCHEMA = zod.array(GRANT_SCHEMA).max(100);
 zod.enum([
 	"admin",
-	"member",
+	"editor",
 	"viewer",
 	"custom"
 ]);
@@ -572,8 +584,8 @@ const inferAssetType = (options) => {
 const createPage = (items, query) => {
 	const pageIndex = query.pageIndex ?? 0;
 	const pageSize = query.pageSize ?? 10;
-	if (!Number.isInteger(pageIndex) || pageIndex < 0) throw require_CalmLensError.invalidArgument("pageIndex must be a non-negative integer");
-	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw require_CalmLensError.invalidArgument("pageSize must be an integer from 1 to 100");
+	if (!Number.isInteger(pageIndex) || pageIndex < 0) throw require_CalmLensVersion.invalidArgument("pageIndex must be a non-negative integer");
+	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) throw require_CalmLensVersion.invalidArgument("pageSize must be an integer from 1 to 100");
 	const start = pageIndex * pageSize;
 	return {
 		items: items.slice(start, start + pageSize),
@@ -616,7 +628,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) => require_CalmLensError.invalidArgument(`MockCalmLensServerClient cannot evaluate the filter "${expression}". It supports ==, !=, <, <=, >, >=, =in= and =out=, joined by ; (and) or , (or), without grouping parentheses.`);
+const unsupportedFilter = (expression) => require_CalmLensVersion.invalidArgument(`MockCalmLensServerClient cannot evaluate the filter "${expression}". It supports ==, !=, <, <=, >, >=, =in= and =out=, joined by ; (and) or , (or), without grouping parentheses.`);
 const matchesComparison = (item, comparison) => {
 	const match = COMPARISON.exec(comparison.trim());
 	if (!match) throw unsupportedFilter(comparison);
@@ -684,14 +696,14 @@ const describeBinary = (value) => {
 };
 const MAX_EVENTS_LIMIT = 100;
 const toFailureError = (failure) => {
-	if (failure === "transport-error") return new require_CalmLensError.CalmLensError(require_CalmLensError.SDK_ERROR_CODES.TRANSPORT_ERROR, {
+	if (failure === "transport-error") return new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.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 require_CalmLensError.CalmLensError(require_CalmLensError.SDK_ERROR_CODES.TIMEOUT, {
+		return new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.TIMEOUT, {
 			message: "Request timed out",
 			cause
 		});
@@ -765,9 +777,9 @@ var MockCalmLensServerClient = class {
 	}
 	/** An API error as the real client throws it: status, default message and request ID. */
 	apiError(code, options = {}) {
-		const definition = require_CalmLensError.API_ERROR_DEFINITIONS[code];
+		const definition = require_CalmLensVersion.API_ERROR_DEFINITIONS[code];
 		const requestId = `mock-request-${++this.requestCount}`;
-		return new require_CalmLensError.CalmLensError(code, {
+		return new require_CalmLensVersion.CalmLensError(code, {
 			message: options.message ?? definition.message,
 			status: definition.status,
 			details: options.details,
@@ -779,18 +791,18 @@ var MockCalmLensServerClient = class {
 		});
 	}
 	assertValidUploadMimeType(mimeType) {
-		if (require_CalmLensUtils.isRejectedUploadMimeType(mimeType)) throw this.apiError(require_CalmLensError.API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+		if (require_CalmLensUtils.isRejectedUploadMimeType(mimeType)) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
 			message: require_CalmLensUtils.getRejectedUploadMimeTypeError(mimeType),
 			details: { mimeType }
 		});
 	}
 	invalidPayload(message) {
-		return this.apiError(require_CalmLensError.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
+		return this.apiError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
 	}
 	async findOwnAsset(assetId) {
 		require_CalmLensUtils.encodePathSegment(assetId, "Asset ID");
 		const asset = await this.databaseStorage.getAsset(assetId);
-		if (!asset || asset.projectId !== this.projectId) throw this.apiError(require_CalmLensError.API_ERROR_CODES.ASSET_NOT_FOUND);
+		if (!asset || asset.projectId !== this.projectId) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.ASSET_NOT_FOUND);
 		return asset;
 	}
 	begin(operation, options) {
@@ -889,7 +901,7 @@ var MockCalmLensServerClient = class {
 	}
 	listEvents(options) {
 		const limit = options.limit ?? DEFAULT_EVENTS_LIMIT;
-		if (!Number.isInteger(limit) || limit < 1 || limit > MAX_EVENTS_LIMIT) throw this.apiError(require_CalmLensError.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: `limit must be an integer from 1 to ${MAX_EVENTS_LIMIT}` });
+		if (!Number.isInteger(limit) || limit < 1 || limit > MAX_EVENTS_LIMIT) throw this.apiError(require_CalmLensVersion.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}`,
@@ -897,7 +909,7 @@ var MockCalmLensServerClient = class {
 		};
 		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(require_CalmLensError.API_ERROR_CODES.INVALID_EVENT_CURSOR);
+		if (!Number.isSafeInteger(position) || position > this.eventFeed.length) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.INVALID_EVENT_CURSOR);
 		const events = this.eventFeed.slice(position, position + limit);
 		const next = position + events.length;
 		return {
@@ -1025,7 +1037,7 @@ var MockCalmLensServerClient = class {
 				this.begin("assets.uploadPart", options);
 				const { assetId, part } = options;
 				require_CalmLensUtils.encodePathSegment(assetId, "Asset ID");
-				if (!part) throw require_CalmLensError.invalidArgument("Part options are required");
+				if (!part) throw require_CalmLensVersion.invalidArgument("Part options are required");
 				return this.withIdempotency("assets.uploadPart", options, async () => {
 					const asset = await this.findOwnAsset(assetId);
 					const validation = require_CalmLensUtils.validateAssetPayload(part, {
@@ -1033,9 +1045,9 @@ var MockCalmLensServerClient = class {
 						isFinal: part.isFinal
 					});
 					if (!validation.ok) throw this.invalidPayload(validation.error);
-					if (asset.status !== "uploading") throw this.apiError(require_CalmLensError.API_ERROR_CODES.UPLOAD_NOT_OPEN);
+					if (asset.status !== "uploading") throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.UPLOAD_NOT_OPEN);
 					const expectedPartNumber = (asset.uploadPartsReceived ?? 1) + 1;
-					if (part.partNumber !== expectedPartNumber) throw this.apiError(require_CalmLensError.API_ERROR_CODES.INVALID_UPLOAD_PART_NUMBER, { details: { expectedPartNumber } });
+					if (part.partNumber !== expectedPartNumber) throw this.apiError(require_CalmLensVersion.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);
@@ -1051,7 +1063,7 @@ var MockCalmLensServerClient = class {
 				this.begin("assets.createSignedUrl", signedUrlOptions);
 				const { assetId, ...options } = signedUrlOptions;
 				const asset = await this.findOwnAsset(assetId);
-				if (options.lens && options.transform) throw require_CalmLensError.invalidArgument("Specify either a lens or a transform, not both");
+				if (options.lens && options.transform) throw require_CalmLensVersion.invalidArgument("Specify either a lens or a transform, not both");
 				const expiresInSeconds = options.expiresInSeconds ?? 900;
 				const resource = options.resource ?? "content";
 				const transform = require_CalmLensUtils.transformSelector(options.transform);
@@ -1066,7 +1078,7 @@ var MockCalmLensServerClient = class {
 				const { assetId, folderId } = options;
 				const asset = await this.findOwnAsset(assetId);
 				if (folderId !== null && folderId !== void 0) {
-					if (!await this.resolveFolder(folderId)) throw this.apiError(require_CalmLensError.API_ERROR_CODES.FOLDER_NOT_FOUND);
+					if (!await this.resolveFolder(folderId)) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.FOLDER_NOT_FOUND);
 				}
 				return this.databaseStorage.updateAsset({
 					...asset,
@@ -1077,14 +1089,20 @@ var MockCalmLensServerClient = class {
 			retry: async (options) => {
 				this.begin("assets.retry", options);
 				const asset = await this.findOwnAsset(options?.assetId);
-				if (asset.status !== "error") throw this.apiError(require_CalmLensError.API_ERROR_CODES.ASSET_NOT_RETRYABLE);
-				if (asset.storageDeletedAt) throw this.apiError(require_CalmLensError.API_ERROR_CODES.ASSET_CONTENT_UNAVAILABLE);
+				if (asset.status !== "error") throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.ASSET_NOT_RETRYABLE);
+				if (asset.storageDeletedAt) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.ASSET_CONTENT_UNAVAILABLE);
 				return this.databaseStorage.updateAsset({
 					...asset,
 					status: "pending",
 					updatedAt: this.now()
 				});
 			},
+			/** 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 require_CalmLensUtils.pollForDecision(() => this.findOwnAsset(assetId), waitOptions, require_CalmLensUtils.sleep);
+			},
 			deleteContent: async (options) => {
 				this.begin("assets.deleteContent", options);
 				const asset = await this.findOwnAsset(options?.assetId);
@@ -1157,7 +1175,7 @@ var MockCalmLensServerClient = class {
 				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(require_CalmLensError.API_ERROR_CODES.FOLDER_NOT_EMPTY, { details: {
+				if (hasAssets || hasChildren) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.FOLDER_NOT_EMPTY, { details: {
 					hasAssets,
 					hasChildren
 				} });
@@ -1172,7 +1190,7 @@ var MockCalmLensServerClient = class {
 					let candidate = await this.findOwnFolder(targetParentId);
 					const visited = /* @__PURE__ */ new Set();
 					while (candidate) {
-						if (candidate.id === folderId || visited.has(candidate.id)) throw this.apiError(require_CalmLensError.API_ERROR_CODES.FOLDER_PARENT_CYCLE);
+						if (candidate.id === folderId || visited.has(candidate.id)) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.FOLDER_PARENT_CYCLE);
 						visited.add(candidate.id);
 						candidate = candidate.parentId ? await this.resolveFolder(candidate.parentId) : void 0;
 					}
@@ -1189,7 +1207,7 @@ var MockCalmLensServerClient = class {
 	}
 	async ensureLens(options) {
 		this.begin("ensureLens", options);
-		if (!options?.identifier) throw require_CalmLensError.invalidArgument("Lens identifier is required");
+		if (!options?.identifier) throw require_CalmLensVersion.invalidArgument("Lens identifier is required");
 		return this.ensureLensDefinition(options);
 	}
 	ensureLensDefinition(options) {
@@ -1216,7 +1234,7 @@ var MockCalmLensServerClient = class {
 			this.lenses.set(lens.identifier, lens);
 			return lens;
 		}
-		throw this.apiError(require_CalmLensError.API_ERROR_CODES.LENS_VERSION_CONFLICT, { details: {
+		throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.LENS_VERSION_CONFLICT, { details: {
 			currentVersion: existing.version,
 			minimumVersion: existing.version + 1,
 			requestedVersion: options.version
@@ -1224,19 +1242,19 @@ var MockCalmLensServerClient = class {
 	}
 	async ensureLenses(options) {
 		this.begin("ensureLenses", options);
-		if (!Array.isArray(options?.lenses) || options.lenses.length === 0) throw require_CalmLensError.invalidArgument("At least one lens is required");
-		if (options.lenses.some((lens) => !lens?.identifier)) throw require_CalmLensError.invalidArgument("Lens identifier is required");
+		if (!Array.isArray(options?.lenses) || options.lenses.length === 0) throw require_CalmLensVersion.invalidArgument("At least one lens is required");
+		if (options.lenses.some((lens) => !lens?.identifier)) throw require_CalmLensVersion.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(require_CalmLensError.API_ERROR_CODES.INVALID_IDEMPOTENCY_KEY);
+		if (!key || key.length > 255 || !/^[\x21-\x7e]+$/.test(key)) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.INVALID_IDEMPOTENCY_KEY);
 		const fingerprint = `${operation}:${require_CalmLensWebhooks.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(require_CalmLensError.API_ERROR_CODES.IDEMPOTENCY_KEY_REUSED);
+			if (saved.fingerprint !== fingerprint) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.IDEMPOTENCY_KEY_REUSED);
 			return saved.asset;
 		}
 		const asset = await run();
@@ -1251,11 +1269,11 @@ var MockCalmLensServerClient = class {
 		return this.withIdempotency(operation, options, () => this.createAsset(options, false));
 	}
 	async createAsset(options, queue) {
-		if (!options || typeof options !== "object") throw require_CalmLensError.invalidArgument("Asset options are required");
+		if (!options || typeof options !== "object") throw require_CalmLensVersion.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(require_CalmLensError.API_ERROR_CODES.USE_UPLOAD_PART);
+		if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.USE_UPLOAD_PART);
 		if ("content" in options) {
 			this.assertValidUploadMimeType(options.content.type);
 			if (!("plainText" in options.content)) {
@@ -1272,7 +1290,7 @@ var MockCalmLensServerClient = class {
 			if (!validation.ok) throw this.invalidPayload(validation.error);
 		}
 		if (options.externalId) {
-			if ((await this.databaseStorage.listAssets(this.projectId)).some((asset) => asset.externalId === options.externalId)) throw this.apiError(require_CalmLensError.API_ERROR_CODES.DUPLICATE_EXTERNAL_ID);
+			if ((await this.databaseStorage.listAssets(this.projectId)).some((asset) => asset.externalId === options.externalId)) throw this.apiError(require_CalmLensVersion.API_ERROR_CODES.DUPLICATE_EXTERNAL_ID);
 		}
 		const id = this.createId();
 		const now = this.now();
@@ -1312,11 +1330,11 @@ var MockCalmLensServerClient = class {
 	async findOwnFolder(folderId) {
 		require_CalmLensUtils.encodePathSegment(folderId, "Folder ID");
 		const folder = await this.resolveFolder(folderId);
-		if (!folder) throw this.apiError(require_CalmLensError.API_ERROR_CODES.FOLDER_NOT_FOUND);
+		if (!folder) throw this.apiError(require_CalmLensVersion.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(require_CalmLensError.API_ERROR_CODES.DUPLICATE_FOLDER_NAME, { message: `A folder named "${name}" already exists in this location.` });
+		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(require_CalmLensVersion.API_ERROR_CODES.DUPLICATE_FOLDER_NAME, { message: `A folder named "${name}" already exists in this location.` });
 	}
 	getSizeInBytes(options) {
 		if ("content" in options) {

package/esm/CalmLensConnection-D8VsTdsA.js

@@ -0,0 +1,192 @@
+import { c as invalidArgument, o as CalmLensError, s as SDK_ERROR_CODES, u as API_ERROR_CODES } from "./CalmLensVersion-DK4BMEST.js";
+import { a as stringifyQuery, b as getRejectedUploadMimeTypeError, d as CalmLensTransport, g as validateAssetPayload, h as getAssetPayloadByteLength, i as randomUuid, m as assetToData, v as MAX_IMAGE_UPLOAD_BYTES, x as isRejectedUploadMimeType, y as MIN_MULTIPART_IMAGE_UPLOAD_BYTES } from "./CalmLensUtils-B4i3Z2He.js";
+//#region src/client/CalmLensConnection.ts
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_MAX_RESPONSE_BYTES = 33554432;
+/**
+* Bytes as a fetch body. They're sent as they are rather than in a Blob: React Native can't
+* build a Blob from bytes, and every fetch accepts a Uint8Array.
+*/
+const toBodyBytes = (value) => value.buffer instanceof ArrayBuffer ? value : Uint8Array.from(value);
+const toRawUploadBody = (payload) => {
+	const data = assetToData(payload);
+	if (data instanceof Response) {
+		if (!data.body) throw new CalmLensError(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Response upload data must have a body" });
+		return data.body;
+	}
+	if (data instanceof ArrayBuffer || data instanceof Blob) return data;
+	if ("getReader" in data) return data;
+	return toBodyBytes(data);
+};
+const setOptionalQueryValue = (params, key, value) => {
+	if (value !== void 0 && value !== null) params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+};
+const assertValidUploadMimeType = (mimeType) => {
+	if (isRejectedUploadMimeType(mimeType)) throw new CalmLensError(API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+		message: getRejectedUploadMimeTypeError(mimeType),
+		details: { mimeType }
+	});
+};
+const isImageMimeType = (mimeType) => mimeType.toLowerCase().startsWith("image/");
+const invalidPayload = (message) => new CalmLensError(API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
+/** Checks upload options before anything is sent. */
+const prepareSubmitAssetOptions = (options) => {
+	if (!options || typeof options !== "object") throw invalidArgument("Asset options are required");
+	if (!("content" in options) && !("url" in options) && !("part" in options)) throw invalidPayload("Either file content, URL, or multipart part is required");
+	if (!options.name) throw invalidPayload("Asset name is required");
+	if (!("part" in options) && "isFinal" in options) throw invalidPayload("isFinal is only valid for multipart uploads");
+	if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw new CalmLensError(API_ERROR_CODES.USE_UPLOAD_PART, { message: "Use uploadPart for multipart upload parts after the first part" });
+	if ("content" in options) {
+		assertValidUploadMimeType(options.content.type);
+		if (!("plainText" in options.content)) {
+			const validation = validateAssetPayload(options.content);
+			if (!validation.ok) throw invalidPayload(validation.error);
+		}
+	}
+	if ("part" in options) {
+		assertValidUploadMimeType(options.part.type);
+		const partSizeInBytes = options.part.sizeInBytes ?? getAssetPayloadByteLength(options.part);
+		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
+			if (partSizeInBytes > MAX_IMAGE_UPLOAD_BYTES) throw new CalmLensError(API_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE, { message: "Multipart image uploads cannot exceed 20MB." });
+			if (options.part.isFinal && partSizeInBytes < MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw new CalmLensError(API_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL, { message: "Multipart image uploads must total at least 10MB." });
+		}
+		const validation = validateAssetPayload(options.part, {
+			multipart: true,
+			isFinal: options.part.isFinal
+		});
+		if (!validation.ok) throw invalidPayload(validation.error);
+	}
+	return options;
+};
+const newIdempotencyKey = () => randomUuid();
+/** Text content is small, so it keeps the API deadline; binary files may be arbitrarily large. */
+const isTextPayload = (payload) => "plainText" in payload;
+const isAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id && typeof data.status === "string";
+const isUploadedAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id;
+const expectUploadedAsset = (data) => {
+	if (!isUploadedAsset(data)) throw new CalmLensError(SDK_ERROR_CODES.INVALID_RESPONSE, {
+		message: "Expected an uploaded asset response",
+		status: 200
+	});
+	return data;
+};
+const expectAsset = (data) => {
+	if (!isAsset(data)) throw new CalmLensError(SDK_ERROR_CODES.INVALID_RESPONSE, {
+		message: "Expected an asset response",
+		status: 200
+	});
+	return data;
+};
+/** Fills in the default API base URL and drops trailing slashes. */
+const resolveConnectionOptions = (options) => ({
+	...options,
+	baseUrl: (options.baseUrl ?? `https://api.calmlens.com/v1`).replace(/\/+$/, "")
+});
+/** One client's transport, base URL and deadlines, and the requests both clients make. */
+var CalmLensConnection = class {
+	constructor(options, apiKey) {
+		this.options = options;
+		const resolveFetch = () => {
+			const fetchImpl = this.options.fetch ?? globalThis.fetch;
+			if (typeof fetchImpl !== "function") throw new CalmLensError(SDK_ERROR_CODES.NO_FETCH, { message: "No fetch implementation is available; pass one as the fetch option" });
+			return fetchImpl;
+		};
+		this.transport = new CalmLensTransport({
+			apiKey,
+			fetch: ((input, init) => resolveFetch()(input, init)),
+			signal: options.signal,
+			maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+			maxResponseBytes: options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES
+		});
+	}
+	get timeoutMs() {
+		return this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	}
+	url(path, query) {
+		const search = query ? stringifyQuery(query) : "";
+		return `${this.options.baseUrl}${path}${search ? `?${search}` : ""}`;
+	}
+	/** A JSON request whose deadline covers reading the response. */
+	json(method, path, { query, body, headers, idempotencyKey } = {}) {
+		return this.transport.json({
+			method,
+			url: this.url(path, query),
+			headers: body === void 0 ? headers : {
+				...headers,
+				"Content-Type": "application/json"
+			},
+			body: body === void 0 ? void 0 : JSON.stringify(body),
+			idempotencyKey,
+			timeoutMs: this.timeoutMs,
+			deadline: "body"
+		});
+	}
+	upload(url, payload, headers, idempotencyKey) {
+		return this.transport.json({
+			method: "POST",
+			url,
+			headers,
+			body: toRawUploadBody(payload),
+			idempotencyKey,
+			timeoutMs: isTextPayload(payload) ? this.timeoutMs : this.options.uploadTimeoutMs,
+			deadline: "body",
+			fetch: this.options.uploadFetch
+		});
+	}
+	/**
+	* Uploads file content or a first multipart part to `uploadsPath` (`.../assets`), as raw
+	* bytes with the options in the query.
+	*/
+	submitRawUpload(uploadsPath, options, queue, authHeaders = {}) {
+		const query = new URLSearchParams();
+		query.set("name", options.name);
+		query.set("queue", String(queue));
+		setOptionalQueryValue(query, "description", options.description);
+		setOptionalQueryValue(query, "processingOptions", options.processingOptions);
+		setOptionalQueryValue(query, "visibility", options.visibility);
+		setOptionalQueryValue(query, "metadata", options.metadata);
+		setOptionalQueryValue(query, "externalId", options.externalId);
+		setOptionalQueryValue(query, "externalUrl", options.externalUrl);
+		setOptionalQueryValue(query, "folderId", options.folderId);
+		setOptionalQueryValue(query, "uploadPresetId", options.uploadPresetId);
+		const isMultipart = "part" in options;
+		const payload = isMultipart ? options.part : options.content;
+		query.set("contentType", payload.type);
+		setOptionalQueryValue(query, "sizeInBytes", payload.sizeInBytes ?? getAssetPayloadByteLength(payload));
+		if (isMultipart) {
+			const part = payload;
+			const multipartOptions = options;
+			query.set("partNumber", String(part.partNumber ?? 1));
+			query.set("isFinal", String(part.isFinal ?? false));
+			setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? multipartOptions.sizeInBytes);
+			setOptionalQueryValue(query, "totalSizeInBytes", multipartOptions.totalSizeInBytes);
+		}
+		return this.upload(this.url(`${uploadsPath}?${query}`), payload, {
+			...authHeaders,
+			"Content-Type": payload.type,
+			"X-CalmLens-Upload": isMultipart ? "part" : "content"
+		}, options.idempotencyKey ?? newIdempotencyKey());
+	}
+	/** Uploads the next part of a multipart upload to `partPath` (`.../assets/{id}/part`). */
+	uploadPart(partPath, { part, queue, idempotencyKey }, authHeaders = {}) {
+		if (!part) throw invalidArgument("Part options are required");
+		const validation = validateAssetPayload(part, {
+			multipart: true,
+			isFinal: part.isFinal
+		});
+		if (!validation.ok) throw invalidPayload(validation.error);
+		const query = new URLSearchParams({
+			partNumber: String(part.partNumber),
+			isFinal: String(part.isFinal ?? false)
+		});
+		if (queue !== void 0) query.set("queue", String(queue));
+		setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? getAssetPayloadByteLength(part));
+		return this.upload(this.url(`${partPath}?${query}`), part, {
+			...authHeaders,
+			"X-CalmLens-Upload": "part"
+		}, idempotencyKey ?? newIdempotencyKey());
+	}
+};
+//#endregion
+export { newIdempotencyKey as a, invalidPayload as i, expectAsset as n, prepareSubmitAssetOptions as o, expectUploadedAsset as r, resolveConnectionOptions as s, CalmLensConnection as t };