@calmlens/sdk 0.13.0 → 0.15.0

package/README.md

@@ -38,8 +38,8 @@ const client = new CalmLensServerClient({
 // Text (comments, captions, bios): waits for the decision
 const comment = await client.text.moderate({ text: "Great photo!", externalId: "comment-42" });
 
-if (comment.status === "approved") {
-  // publish it; if comment.report?.flagged is true, also queue it for review
+if (comment.moderation.status === "approved") {
+  // publish it; if comment.moderation.action is "alert", also queue it for review
 } else {
   // "rejected": don't publish it
 }
@@ -50,16 +50,19 @@ const image = await client.assets.create({
   content: { data: file, type: "image/jpeg" },
   externalId: "post-7",
 });
-console.log(image.status); // "pending"
+console.log(image.processing.status, image.moderation.status); // "processing" "pending"
 ```
 
-| `status` | `report.flagged` | Meaning |
-| --- | --- | --- |
-| `approved` | `false` | Safe to show. |
-| `approved` | `true` | Show it, but your policy asked to be alerted. |
-| `rejected` | `true` | Your policy hid or purged it. Don't show it. |
-| `pending` | — | Still being classified. |
-| `error` | — | Processing failed. |
+| `processing.status` | `moderation.status` | `moderation.action` | Meaning |
+| --- | --- | --- | --- |
+| `done` | `approved` | `null` | Safe to show. |
+| `done` | `approved` | `alert` | Show it, but your policy asked to be alerted. |
+| `done` | `rejected` | `hide` or `purge` | Your policy hid or purged it. Don't show it. |
+| `uploading` or `processing` | `pending` | `null` | Still being received or classified. |
+| `failed` | `pending` | `null` | Processing failed; see `assets.retry`. |
+
+A reviewer's decision (`moderation.reviewerAction`) takes precedence over the automated one in
+`moderation.status`; `moderation.action` keeps what your policy did.
 
 See [How CalmLens works](https://calmlens.com/docs/how-it-works) and [Testing your integration](https://calmlens.com/docs/guides/testing) for test inputs that trigger rejections safely.
 
@@ -146,16 +149,18 @@ Both resolve to the stored `Asset`, a plain object with camelCase keys exactly a
 ```typescript
 const asset = await client.text.moderate({ text: "Great photo!", externalId: "comment-42" });
 asset.id;            // string
-asset.status;        // "approved" | "rejected" | "error"; "pending" for audio and video, which always run in the background
-asset.type;          // "plaintext-document" for text
-asset.report?.flagged;                       // boolean
-asset.report?.score;                         // number, the overall score
-asset.report?.categories.harassment.status;  // "evaluated" | "partial" | "not-evaluated"
-asset.moderationAction;                      // the policy action applied, if any
-asset.createdAt;     // milliseconds since the Unix epoch
+asset.processing.status;  // "uploading" | "processing" | "done" | "failed"; audio and video keep processing in the background
+asset.moderation.status;  // "pending" | "approved" | "rejected"
+asset.moderation.action;  // "alert" | "hide" | "purge", what your policy did with flagged content; null when nothing was flagged
+asset.moderation.report?.score;                         // number, the overall score
+asset.moderation.report?.categories.harassment.status;  // "evaluated" | "partial" | "not-evaluated"
+asset.content.status;     // "temporary" | "stored" | "removed"
+asset.content.removalReason; // "policy" | "retention" | "requested" | "parent-removed" | "disposed" | null
+asset.type;               // "plaintext-document" for text
+asset.createdAt;          // milliseconds since the Unix epoch
 ```
 
-Always present: `id`, `projectId`, `name`, `type`, `status`, `createdAt` and `updatedAt`. Every other field may be `null` or missing: `report` is absent when processing failed (`status: "error"`) or has not finished, `moderationAction` when no policy action applied, `externalId`, `description`, `metadata`, `folderId`, `visibility` and `processingOptions` when you did not set them, and `sizeInBytes`, `fileFormat`, `imageData`, `documentData`, `previewImage` and `extractedText` when they do not apply to the content. Inside a report, a category's `score` and `likelihood` exist only when its `status` is `evaluated` or `partial` (see [Moderation Reports](#moderation-reports)).
+Always present: `id`, `projectId`, `name`, `type`, `createdAt`, `updatedAt`, `processing`, `moderation` and `content` (with their `status` fields). Other fields may be `null`: `moderation.report` until classification finishes (and when processing failed), `moderation.action` when nothing was flagged, the `moderation.reviewer*` fields until a reviewer decides, `externalId`, `description`, `metadata`, `folderId`, `visibility` and `processingOptions` when you did not set them, and `content.format`, `content.sizeInBytes`, `content.image`, `content.previewImage` and `content.extractedText` when they do not apply to the content. Content is `temporary` until processing finishes and then `removed` (reason `retention`) unless you set `processingOptions.keepContentAfterProcessing`. Inside a report, a category's `score` and `likelihood` exist only when its `status` is `evaluated` or `partial` (see [Moderation Reports](#moderation-reports)).
 
 ##### assets.retrieve(options)
 
@@ -168,8 +173,8 @@ async assets.retrieve(options: { assetId: string }): Promise<Asset>
 **Example:**
 ```typescript
 const asset = await client.assets.retrieve({ assetId: "asset-uuid-here" });
-console.log(asset.status);
-console.log(asset.report); // Classification results
+console.log(asset.moderation.status);
+console.log(asset.moderation.report); // Classification results
 ```
 
 ##### ensureLens(options)
@@ -233,14 +238,14 @@ const result = await client.assets.list({
 
 console.log(`Found ${result.total} assets`);
 result.items.forEach(asset => {
-  console.log(`${asset.name}: ${asset.status}`);
+  console.log(`${asset.name}: ${asset.moderation.status}`);
 });
 ```
 
 To read every matching asset, iterate instead of paging by hand. Pages are fetched as you go; assets created or deleted meanwhile can shift pages, so one may be skipped or repeated.
 
 ```typescript
-for await (const asset of client.assets.iterate({ filter: "status==rejected", pageSize: 100 })) {
+for await (const asset of client.assets.iterate({ filter: "moderation.status==rejected", pageSize: 100 })) {
   console.log(asset.id);
 }
 ```
@@ -294,26 +299,26 @@ await client.assets.move({
 
 ##### assets.retry(options)
 
-Process an asset that failed (status `error`) again. It returns to `pending` and is moderated like a
-new upload, so handle the result the same way (webhook or polling). Its content must still be stored:
+Process an asset whose processing failed (`processing.status` `failed`) again. It returns to
+`processing` and is moderated like a new upload, so handle the result the same way (webhook or polling). Its content must still be stored:
 otherwise this throws `asset/content-unavailable`, and you need to upload it again.
 
 ```typescript
 const asset = await client.assets.retry({ assetId: "asset-uuid" });
-// asset.status === "pending"
+// asset.processing.status === "processing"
 ```
 
 ##### assets.waitForDecision(options)
 
-Wait for an asset's moderation decision and get the decided asset: `approved`, `rejected` or `error`.
-The SDK checks the asset every few seconds and rejects with `sdk/timeout` if there's no decision within
+Wait for an asset's moderation decision and get the decided asset: it returns once `moderation.status`
+is `approved` or `rejected`, or `processing.status` is `failed`. The SDK checks the asset every few seconds and rejects with `sdk/timeout` if there's no decision within
 `timeoutMs` (default 60000). Pass `signal` to stop waiting early (`sdk/cancelled`). Use it after
 `assets.create`, or with an asset ID you stored earlier. Webhooks report decisions without polling.
 
 ```typescript
 const queued = await client.assets.create({ name: "photo.jpg", content: { blob, type: "image/jpeg" } });
 const decided = await client.assets.waitForDecision({ assetId: queued.id, timeoutMs: 30_000 });
-if (decided.status === "rejected") hidePhoto(decided.id);
+if (decided.moderation.status === "rejected") hidePhoto(decided.id);
 ```
 
 ##### folders.list()
@@ -461,7 +466,7 @@ const analyzed = await client.assets.moderate({
     isFinal: true
   }
 });
-console.log(analyzed.status);
+console.log(analyzed.moderation.status);
 ```
 
 #### Static Methods
@@ -499,7 +504,7 @@ const client = new CalmLensAppClient({
 });
 
 const asset = await client.assets.moderate({ name: file.name, content: { data: file, type: file.type } });
-// asset.status is present when the preset shows decisions to uploaders
+// asset.status (the moderation status) is present when the preset shows decisions to uploaders
 ```
 
 **Options:** `uploadPresetId` (required), `token` (a string, or a function that returns one or a promise of one), plus `baseUrl`, `fetch`, `uploadFetch`, `timeoutMs`, `uploadTimeoutMs`, `maxRetries`, `maxResponseBytes` and `signal` as for `CalmLensServerClient`. Passing `apiKey` throws `sdk/invalid-config`.
@@ -533,12 +538,11 @@ Assets can be of the following types:
 
 ## Asset Status
 
-Assets progress through these statuses:
-- `uploading` - Multipart upload is accepting more parts
-- `pending` - Asset is being processed
-- `approved` - Processing completed and delivery is allowed; an `alert` action can still leave `report.flagged` set to `true`
-- `rejected` - A hide, purge, child-asset, or manual rejection decision was applied
-- `error` - Processing failed
+An asset's state is split in three:
+
+- `processing.status`: `uploading` (a multipart upload is accepting more parts), `processing`, then `done` or `failed`
+- `moderation.status`: `pending` until moderation finishes, then `approved` or `rejected`. A reviewer's decision (`moderation.reviewerAction`) takes precedence over the automated one. `moderation.action` is what your policy did with flagged content (`alert`, `hide` or `purge`), or `null` when nothing was flagged; an `alert` leaves the asset `approved`.
+- `content.status`: `temporary` (kept only until processing finishes), `stored` or `removed`, with `content.removalReason` `policy` (purged), `retention` (`keepContentAfterProcessing` off), `requested`, `parent-removed` or `disposed`
 
 ## Moderation Reports
 
@@ -623,11 +627,11 @@ The API keeps a response for 24 hours. Reusing a key for a different request fai
 
 ## Forward compatibility
 
-The SDK does not validate responses against its types, so fields and values added to the API later reach your code unchanged. `AssetStatus`, `AssetType` and `AssetVisibility` include `string` for that reason: handle values you don't know (for example, treat an unknown status as "not ready"). Event types and fact keys are typed for the ones this version knows; keep a default branch when you switch on them.
+The SDK does not validate responses against its types, so fields and values added to the API later reach your code unchanged. `AssetProcessingStatus`, `AssetModerationStatus`, `AssetModerationAction`, `AssetReviewerAction`, `AssetContentStatus`, `AssetContentRemovalReason`, `AssetType` and `AssetVisibility` include `string` for that reason: handle values you don't know (for example, treat an unknown status as "not ready"). Event types and fact keys are typed for the ones this version knows; keep a default branch when you switch on them.
 
 ## Testing
 
-`@calmlens/sdk/testing` exports `MockCalmLensServerClient`, an in-memory stand-in for `CalmLensServerClient`,, in-memory storage implementations, mock API key helpers, webhook delivery builders and `generateMediaTestCode`, for testing without network requests.
+`@calmlens/sdk/testing` exports `MockCalmLensServerClient`, an in-memory stand-in for `CalmLensServerClient`,, in-memory storage implementations, mock API key helpers, webhook delivery builders and `generateMediaTestCode`, for testing without network requests. `generateMediaTestCode(signal, testInputKey)` returns the spoken or on-screen test phrase for your project's secret test input key, shown under **Assets → Try test inputs** in the portal; a phrase with another project's key is moderated normally.
 
 The `@calmlens/sdk`, `/server` and `/app` entry points do not load or export testing helpers, to keep production bundles small. Keep `/testing` imports in test files.
 
@@ -642,7 +646,7 @@ const client = new MockCalmLensServerClient({
 
 `MockCalmLensServerClient` accepts the same options as `CalmLensServerClient` (`apiKey`, `projectId`, `baseUrl`, `cdnBaseUrl`, `timeoutMs`, ...) and validates them the same way, plus `mockOptions`. `cdn.getAssetUrl` uses `cdnBaseUrl` (default `mock://calmlens/v1`).
 
-It behaves like the API where tests depend on it: errors carry the API's code, HTTP `status`, a `requestId` and `headers`; `assets.list` applies `ordering`, `folderId` and simple `filter` expressions (comparisons joined by `;` and `,`; anything else throws `sdk/invalid-argument` rather than returning wrong results); `assets.search` matches names, IDs, external IDs, descriptions and tags; multipart parts must arrive in order and the queue mode chosen at the start applies to the final part; a reused `idempotencyKey` replays the first result; and `cdn.serve` returns CDN-like responses with JSON error bodies. `client.enqueueEvent({ type, ... })` adds an event that `events.list` and `events.pages` then return.
+It behaves like the API where tests depend on it: errors carry the API's code, HTTP `status`, a `requestId` and `headers`; `assets.list` applies `ordering`, `folderId` and simple `filter` expressions (comparisons joined by `;` and `,`; anything else throws `sdk/invalid-argument` rather than returning wrong results); `assets.search` matches names, IDs, external IDs, descriptions and tags; multipart parts must arrive in order and the queue mode chosen at the start applies to the final part; `mockOptions.queuedOutcome` (default `pending`) and `mockOptions.analyzedOutcome` (default `approved`) set where queued and waited-for uploads end up (`pending`, `approved`, `rejected` or `failed`); content is removed with reason `retention` once processing is done unless `keepContentAfterProcessing` is set, and `assets.deleteContent` removes it with reason `requested`; a reused `idempotencyKey` replays the first result; and `cdn.serve` returns CDN-like responses with JSON error bodies. `client.enqueueEvent({ type, ... })` adds an event that `events.list` and `events.pages` then return.
 
 Every call is recorded in `client.calls` as `{ operation, options }`, where `operation` is the method path (`"text.moderate"`, `"assets.retrieve"`, `"events.list"`, ...) and `options` is the object you passed. `client.callsTo(operation)` filters them. To test failure handling, `client.failNextRequest()` makes the next call throw the same `CalmLensError` the real client throws when the network fails (`sdk/transport-error`); pass `"timeout"` for `sdk/timeout`, or any `Error` to throw it as is, and `{ operation }` to fail only that method. Each queued failure is used once.
 
@@ -661,7 +665,7 @@ To test a webhook handler, build a signed delivery the way CalmLens sends it:
 ```typescript
 import { createWebhookHeaders, toWebhookEventPayload } from "@calmlens/sdk/testing";
 
-const event = client.enqueueEvent({ type: "asset.classified", assetId: asset.id });
+const event = client.enqueueEvent({ type: "asset.approved", assetId: asset.id });
 const body = JSON.stringify(toWebhookEventPayload(event));
 const headers = await createWebhookHeaders({ secret, body, deliveryId: "delivery-1" });
 const response = await app.request("/api/webhooks/calmlens", { method: "POST", body, headers });

package/cjs/{CalmLensConnection-DzRDCMOP.js → CalmLensConnection-DoemramF.js}

@@ -1,5 +1,5 @@
-const require_CalmLensVersion = require("./CalmLensVersion-DjhsJ1gj.js");
-const require_CalmLensUtils = require("./CalmLensUtils-vX5H_vMn.js");
+const require_CalmLensVersion = require("./CalmLensVersion-CuxKdijk.js");
+const require_CalmLensUtils = require("./CalmLensUtils-Cv1Ylp9-.js");
 //#region src/client/CalmLensConnection.ts
 const DEFAULT_TIMEOUT_MS = 12e4;
 const DEFAULT_MAX_RETRIES = 2;
@@ -62,7 +62,8 @@ const prepareSubmitAssetOptions = (options) => {
 const newIdempotencyKey = () => require_CalmLensUtils.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 hasStringStatus = (value) => !!value && typeof value === "object" && typeof value.status === "string";
+const isAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id && hasStringStatus(data.processing) && hasStringStatus(data.moderation);
 const isUploadedAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id;
 const expectUploadedAsset = (data) => {
 	if (!isUploadedAsset(data)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.INVALID_RESPONSE, {

package/cjs/{CalmLensUtils-vX5H_vMn.js → CalmLensUtils-Cv1Ylp9-.js}

@@ -1,4 +1,4 @@
-const require_CalmLensVersion = require("./CalmLensVersion-DjhsJ1gj.js");
+const require_CalmLensVersion = require("./CalmLensVersion-CuxKdijk.js");
 const MAX_IMAGE_UPLOAD_BYTES = /* @__PURE__ */ (() => 20971520)();
 const MIN_MULTIPART_IMAGE_UPLOAD_BYTES = /* @__PURE__ */ (() => 10485760)();
 const REJECTED_UPLOAD_MIME_TYPE_SET = /* @__PURE__ */ new Set([
@@ -537,12 +537,11 @@ const stringifyQuery = (query) => {
 	for (const [key, value] of Object.entries(query)) appendQueryValue(parts, key, value);
 	return parts.join("&");
 };
-/** Statuses that are a moderation decision; `assets.waitForDecision` returns at the first. */
-const DECIDED_ASSET_STATUSES = [
-	"approved",
-	"rejected",
-	"error"
-];
+/**
+* Whether an asset has a moderation decision (`moderation.status` `approved` or `rejected`) or
+* failed processing; `assets.waitForDecision` returns at the first such state.
+*/
+const isAssetDecided = (asset) => asset.moderation.status === "approved" || asset.moderation.status === "rejected" || asset.processing.status === "failed";
 const DECISION_POLL_FIRST_DELAY_MS = 500;
 const DECISION_POLL_MAX_DELAY_MS = 5e3;
 const DEFAULT_DECISION_TIMEOUT_MS = 6e4;
@@ -557,13 +556,14 @@ const pollForDecision = async (retrieve, { timeoutMs = DEFAULT_DECISION_TIMEOUT_
 	for (;;) {
 		if (signal?.aborted) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.CANCELLED, { message: "Request cancelled" });
 		const asset = await retrieve();
-		if (DECIDED_ASSET_STATUSES.includes(asset.status)) return asset;
+		if (isAssetDecided(asset)) return asset;
 		const remaining = deadline - now();
 		if (remaining <= 0) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.TIMEOUT, {
-			message: `Asset ${asset.id} had no moderation decision after ${timeoutMs}ms (status ${asset.status})`,
+			message: `Asset ${asset.id} had no moderation decision after ${timeoutMs}ms (processing ${asset.processing.status}, moderation ${asset.moderation.status})`,
 			details: {
 				assetId: asset.id,
-				status: asset.status
+				processingStatus: asset.processing.status,
+				moderationStatus: asset.moderation.status
 			}
 		});
 		await sleep(Math.min(delay, remaining), signal);

package/cjs/{CalmLensVersion-DjhsJ1gj.js → CalmLensVersion-CuxKdijk.js}

@@ -39,6 +39,8 @@ const API_ERROR_CODES = {
 	UPLOAD_PRESET_NOT_FOUND: "upload-preset/not-found",
 	UPLOAD_PRESET_DISABLED: "upload-preset/disabled",
 	UPLOAD_PRESET_TOKEN_REQUIRED: "upload-preset/token-required",
+	REMOTE_URL_NOT_ALLOWED: "upload/remote-url-not-allowed",
+	WEBSITE_RATE_LIMIT_EXCEEDED: "upload/website-rate-limit-exceeded",
 	UPLOAD_PRESET_CONTENT_TYPE_NOT_ALLOWED: "upload-preset/content-type-not-allowed",
 	UPLOAD_PRESET_TOO_LARGE: "upload-preset/too-large",
 	UPLOAD_PRESET_DAILY_LIMIT_REACHED: "upload-preset/daily-limit-reached",
@@ -46,7 +48,18 @@ const API_ERROR_CODES = {
 	UPLOAD_PRESET_FIELD_NOT_ALLOWED: "upload-preset/field-not-allowed",
 	UPLOAD_TOKEN_INVALID: "upload-token/invalid",
 	UPLOAD_TOKEN_EXPIRED: "upload-token/expired",
-	UPLOAD_TOKEN_USED: "upload-token/used"
+	UPLOAD_TOKEN_USED: "upload-token/used",
+	INVALID_REMOTE_URL: "asset/invalid-remote-url",
+	REMOTE_URL_UNAVAILABLE: "asset/remote-url-unavailable",
+	APPEAL_NOT_FOUND: "appeal/not-found",
+	APPEAL_JUDGMENT_NOT_FOUND: "appeal/judgment-not-found",
+	APPEAL_ASSET_NOT_FOUND: "appeal/asset-not-found",
+	APPEAL_PERMISSION_DENIED: "appeal/permission-denied",
+	APPEAL_ALREADY_REVIEWED: "appeal/already-reviewed",
+	APPEAL_DECISION_CHANGED: "appeal/decision-changed",
+	APPEAL_INVALID_ACTION: "appeal/invalid-action",
+	APPEAL_SAFETY_HELD: "appeal/safety-held",
+	APPEAL_CONTENT_UNAVAILABLE: "appeal/content-unavailable"
 };
 /** The HTTP status and default message the API returns with each documented error code. */
 const API_ERROR_DEFINITIONS = {
@@ -202,6 +215,14 @@ const API_ERROR_DEFINITIONS = {
 		status: 401,
 		message: "This upload preset only accepts uploads with an upload token. Sign one on your server with uploadTokens.sign and pass it to the client."
 	},
+	"upload/remote-url-not-allowed": {
+		status: 403,
+		message: "This project doesn't accept URLs from this domain. Change the allowed or blocked domains under Project settings."
+	},
+	"upload/website-rate-limit-exceeded": {
+		status: 429,
+		message: "This project has submitted too many websites in the last minute. Wait for the Retry-After period, or lower the pace of submissions."
+	},
 	"upload-preset/content-type-not-allowed": {
 		status: 415,
 		message: "This upload preset doesn't accept this file type."
@@ -233,6 +254,50 @@ const API_ERROR_DEFINITIONS = {
 	"upload-token/used": {
 		status: 409,
 		message: "The upload token has already been used. Each token uploads one asset."
+	},
+	"asset/invalid-remote-url": {
+		status: 400,
+		message: "Remote URLs must use HTTP or HTTPS and cannot target private networks, localhost names or URL credentials."
+	},
+	"asset/remote-url-unavailable": {
+		status: 422,
+		message: "The URL responded with an error status. Check that it is publicly reachable."
+	},
+	"appeal/not-found": {
+		status: 404,
+		message: "The appeal does not exist in this project."
+	},
+	"appeal/judgment-not-found": {
+		status: 404,
+		message: "The judgment event is unavailable, belongs to another project or cannot supply an asset decision. Supply explicit context instead."
+	},
+	"appeal/asset-not-found": {
+		status: 404,
+		message: "The linked asset does not exist in this project."
+	},
+	"appeal/permission-denied": {
+		status: 403,
+		message: "You cannot review this project's appeals."
+	},
+	"appeal/already-reviewed": {
+		status: 409,
+		message: "A reviewer already resolved this appeal."
+	},
+	"appeal/decision-changed": {
+		status: 409,
+		message: "The linked asset's decision changed after the appealed decision. Submit a new appeal for the current decision."
+	},
+	"appeal/invalid-action": {
+		status: 400,
+		message: "The decision's action is not valid for this appeal."
+	},
+	"appeal/safety-held": {
+		status: 409,
+		message: "A safety hold prevents this appeal from being submitted or applied."
+	},
+	"appeal/content-unavailable": {
+		status: 409,
+		message: "The appeal's content is unavailable, or approval would require restoring removed content."
 	}
 };
 //#endregion
@@ -325,7 +390,7 @@ const invalidConfig = (message) => new CalmLensError(SDK_ERROR_CODES.INVALID_CON
 //#endregion
 //#region src/client/CalmLensVersion.ts
 /** This SDK's version, from its package.json. */
-const SDK_VERSION = "0.13.0";
+const SDK_VERSION = "0.15.0";
 const runtimeName = () => {
 	const runtime = globalThis;
 	if (isReactNativeRuntime()) return "react-native";

package/cjs/{CalmLensWebhooks-hVquX5L1.js → CalmLensWebhooks-qrL-Zdu3.js}

@@ -1,5 +1,5 @@
-const require_CalmLensVersion = require("./CalmLensVersion-DjhsJ1gj.js");
-const require_CalmLensUtils = require("./CalmLensUtils-vX5H_vMn.js");
+const require_CalmLensVersion = require("./CalmLensVersion-CuxKdijk.js");
+const require_CalmLensUtils = require("./CalmLensUtils-Cv1Ylp9-.js");
 //#region ../shared/src/JsonUtils.ts
 const stringifyJsonCanonical = (value) => JSON.stringify(value, (_key, nestedValue) => {
 	if (!nestedValue || typeof nestedValue !== "object" || Array.isArray(nestedValue)) return nestedValue;