@warlock.js/core 5.30.0 → 5.31.0

package/esm/http/uploads/uploaded-file.controller.mjs

@@ -1,10 +1,10 @@
 import { HttpError } from "../errors/errors.mjs";
+import { evaluateConditionalRequest } from "../conditional-request.mjs";
 import { isMissingFileError, variantCacheDirectoryFor } from "./image-variant-cache.mjs";
-import { matchesIfNoneMatch } from "./matches-if-none-match.mjs";
+import { localDiskRoot } from "./local-disk-root.mjs";
 import { detectImageFormat, isVariantSourceFormat } from "./detect-image-format.mjs";
 import { readFileHead } from "./read-file-head.mjs";
 import { resolveUploadPath } from "./resolve-upload-path.mjs";
-import { localDiskRoot } from "./local-disk-root.mjs";
 import { resolveImageVariant } from "./resolve-image-variant.mjs";
 import { parseUploadedFileQuery } from "./parse-uploaded-file-query.mjs";
 import { resolveInlineImageContentType } from "./resolve-inline-image-content-type.mjs";
@@ -70,7 +70,7 @@ async function sendOriginalInline(response, absolutePath, contentType) {
 	});
 }
 /**
-* Serves local uploads, and bounded on-demand variants of the images among them.
+* Serves local uploads and bounded on-demand image variants from any disk.
 *
 * ```ts
 * router.get("/uploads/*", uploadedFileController);
@@ -93,14 +93,15 @@ async function sendOriginalInline(response, absolutePath, contentType) {
 function createUploadedFileController(options = {}) {
 	return async ({ request, response }) => {
 		const diskRoot = localDiskRoot(options.disk);
-		if (!diskRoot) {
-			log.error("uploads", "serve", options.disk === void 0 ? "uploadedFileController needs a local storage driver with a root." : `uploadedFileController needs a local disk; "${options.disk}" is not one.`);
-			return notFound(response);
-		}
+		if (!diskRoot && options.disk === void 0 && options.remote !== true) return notFound(response);
 		const query = parseUploadedFileQuery(request.url);
 		if (query.type === "invalid") return response.badRequest({ error: query.reason });
 		response.header("X-Content-Type-Options", "nosniff");
 		if (query.type === "original") {
+			if (!diskRoot) {
+				log.error("uploads", "serve", options.disk === void 0 ? "uploadedFileController needs a local storage driver with a root." : `uploadedFileController needs a local disk; "${options.disk}" is not one.`);
+				return notFound(response);
+			}
 			const source = await resolveUploadPath(request.params["*"], diskRoot, [path.join(diskRoot, ".cache", "image-variants"), variantCacheDirectoryFor(diskRoot)]);
 			if (!source) return notFound(response);
 			const sniffedFormat = detectImageFormat(await readFileHead(source.absolutePath, 512));
@@ -118,7 +119,14 @@ function createUploadedFileController(options = {}) {
 			};
 			let variant = await resolveImageVariant(variantInput);
 			if (!variant) return notFound(response);
-			if (matchesIfNoneMatch(request.header("if-none-match"), `"${variant.hash}"`)) return response.baseResponse.status(304).send();
+			const precondition = evaluateConditionalRequest({
+				method: request.method,
+				etag: `"${variant.hash}"`,
+				ifMatch: request.header("if-match"),
+				ifNoneMatch: request.header("if-none-match")
+			});
+			if (precondition === "not-modified") return response.baseResponse.status(304).send();
+			if (precondition === "precondition-failed") return response.baseResponse.status(412).send();
 			let body;
 			try {
 				body = await fs.readFile(variant.absolutePath);

package/esm/http/uploads/uploaded-file.controller.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"uploaded-file.controller.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/uploaded-file.controller.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { RequestHandler } from \"../../router\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { HttpError } from \"../errors\";\nimport type { Response } from \"../response\";\nimport {\n  detectImageFormat,\n  IMAGE_SIGNATURE_BYTES,\n  isVariantSourceFormat,\n} from \"./detect-image-format\";\nimport { isMissingFileError, variantCacheDirectoryFor } from \"./image-variant-cache\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport { matchesIfNoneMatch } from \"./matches-if-none-match\";\nimport { parseUploadedFileQuery } from \"./parse-uploaded-file-query\";\nimport { readFileHead } from \"./read-file-head\";\nimport { resolveImageVariant } from \"./resolve-image-variant\";\nimport { resolveInlineImageContentType } from \"./resolve-inline-image-content-type\";\nimport { resolveOriginalContentType } from \"./resolve-original-content-type\";\nimport { resolveUploadPath } from \"./resolve-upload-path\";\n\n/**\n * One year, in seconds: originals and derivatives are both long-lived\n */\nconst ONE_YEAR = 31_536_000;\n\nconst CONTENT_TYPES: Record<VariantOutputFormat, string> = {\n  jpeg: \"image/jpeg\",\n  png: \"image/png\",\n  webp: \"image/webp\",\n  avif: \"image/avif\",\n};\n\nfunction notFound(response: Response) {\n  return response.notFound({ error: \"File Not Found\" });\n}\n\nasync function sendVariant(\n  response: Response,\n  body: Buffer,\n  hash: string,\n  format: VariantOutputFormat,\n) {\n  return response.sendBuffer(body, {\n    contentType: CONTENT_TYPES[format],\n    cacheTime: ONE_YEAR,\n    immutable: true,\n    etag: `\"${hash}\"`,\n  });\n}\n\n/**\n * Serve an upload original that isn't safe to render inline: a non-raster\n * format (html, xml, the svg family, anything unrecognised) is markup a\n * browser will parse and execute, and a raster-sniffed file whose extension\n * doesn't back that format up (see `resolveInlineImageContentType`) is a\n * polyglot — so both go out as a download instead of a rendered response.\n * `Content-Type` stays extension-derived, except the svg/html/xml family,\n * which is downgraded to `application/octet-stream` so the browser never\n * renders it even if it ignores the disposition.\n */\nasync function sendOriginalAsAttachment(response: Response, absolutePath: string) {\n  response.header(\"Content-Security-Policy\", \"sandbox\");\n\n  return response.sendBuffer(await fs.readFile(absolutePath), {\n    contentType: resolveOriginalContentType(absolutePath),\n    cacheTime: ONE_YEAR,\n    immutable: true,\n    inline: false,\n    filename: path.basename(absolutePath),\n  });\n}\n\n/**\n * Serve an upload original inline, once the sniffed raster format and the\n * extension-derived format have been confirmed to agree. The content type is\n * always the SNIFFED image type, passed explicitly — never `sendFile`'s\n * extension-derived guess, which is exactly what let a JPEG named `.html`\n * out as `text/html` before this existed.\n */\nasync function sendOriginalInline(response: Response, absolutePath: string, contentType: string) {\n  return response.sendBuffer(await fs.readFile(absolutePath), {\n    contentType,\n    cacheTime: ONE_YEAR,\n    immutable: true,\n  });\n}\n\n/**\n * Options for {@link createUploadedFileController}\n */\nexport type UploadedFileControllerOptions = {\n  /**\n   * Local disk to serve from; the default disk when omitted. A private disk\n   * should be served from a route that checks access first.\n   */\n  disk?: StorageDriverName;\n};\n\n/**\n * Serves local uploads, and bounded on-demand variants of the images among them.\n *\n * ```ts\n * router.get(\"/uploads/*\", uploadedFileController);\n * router.get(\"/invoices/*\", createUploadedFileController({ disk: \"private\" }), {\n *   middleware: [authMiddleware()],\n * });\n * ```\n *\n * - `GET /uploads/<path>` sends the original file with a one-year cache.\n * - `GET /uploads/<path>?variant=<name>[&format=webp|avif]` sends a derivative\n *   rendered from a variant named in `uploads.images.variants`. No other query\n *   key is accepted, so a client can never ask for an arbitrary size.\n *\n * The path must stay inside the disk root (after symlinks are resolved) and\n * outside the variant cache; anything else is a 404, the same answer a missing\n * file gets. Derivatives are cached on disk under a directory per source\n * (see `resolveImageVariant`), written atomically, generated once per key even\n * under concurrent requests, and sent with an immutable cache and an ETag.\n */\nexport function createUploadedFileController(\n  options: UploadedFileControllerOptions = {},\n): RequestHandler {\n  return async ({ request, response }) => {\n    const diskRoot = localDiskRoot(options.disk);\n\n    if (!diskRoot) {\n      log.error(\n        \"uploads\",\n        \"serve\",\n        options.disk === undefined\n          ? \"uploadedFileController needs a local storage driver with a root.\"\n          : `uploadedFileController needs a local disk; \"${options.disk}\" is not one.`,\n      );\n\n      return notFound(response);\n    }\n\n    const query = parseUploadedFileQuery(request.url);\n\n    if (query.type === \"invalid\") {\n      return response.badRequest({ error: query.reason });\n    }\n\n    // Every uploads response — originals and variants — tells the browser not\n    // to guess a content type from the bytes, so a mislabeled body can never be\n    // sniffed into something executable.\n    response.header(\"X-Content-Type-Options\", \"nosniff\");\n\n    if (query.type === \"original\") {\n      const source = await resolveUploadPath(request.params[\"*\"], diskRoot, [\n        path.join(diskRoot, \".cache\", \"image-variants\"),\n        variantCacheDirectoryFor(diskRoot),\n      ]);\n\n      if (!source) return notFound(response);\n\n      // Inline is decided by SNIFFED bytes, never by extension: an svg (or any\n      // other non-raster file) named `.png` must still download, not render.\n      const head = await readFileHead(source.absolutePath, IMAGE_SIGNATURE_BYTES);\n      const sniffedFormat = detectImageFormat(head);\n\n      if (!isVariantSourceFormat(sniffedFormat)) {\n        return sendOriginalAsAttachment(response, source.absolutePath);\n      }\n\n      // Inline is only safe when the extension-derived type agrees with the\n      // sniffed bytes too — otherwise `sendFile` would advertise the\n      // extension's type (e.g. text/html for JPEG bytes named `.html`).\n      const inlineContentType = resolveInlineImageContentType(source.absolutePath, sniffedFormat);\n\n      if (!inlineContentType) {\n        return sendOriginalAsAttachment(response, source.absolutePath);\n      }\n\n      return sendOriginalInline(response, source.absolutePath, inlineContentType);\n    }\n\n    try {\n      const variantInput = {\n        path: request.params[\"*\"] as string,\n        variant: query.variant,\n        ...(query.format !== undefined ? { format: query.format as VariantOutputFormat } : {}),\n        ...(options.disk !== undefined ? { disk: options.disk } : {}),\n      };\n      let variant = await resolveImageVariant(variantInput);\n\n      if (!variant) return notFound(response);\n\n      if (matchesIfNoneMatch(request.header(\"if-none-match\"), `\"${variant.hash}\"`)) {\n        return response.baseResponse.status(304).send();\n      }\n\n      let body: Buffer;\n\n      try {\n        body = await fs.readFile(variant.absolutePath);\n      } catch (readError) {\n        if (!isMissingFileError(readError)) throw readError;\n\n        // Pruned between the existence check and the read: the source was\n        // rewritten in place and a request for the new version cleared the\n        // old generation. Resolve (and render) once more.\n        variant = await resolveImageVariant(variantInput);\n\n        if (!variant) return notFound(response);\n\n        body = await fs.readFile(variant.absolutePath);\n      }\n\n      return sendVariant(response, body, variant.hash, variant.format);\n    } catch (error) {\n      if (error instanceof HttpError) {\n        return response.send({ error: error.message }, error.status);\n      }\n\n      log.error(\n        \"uploads\",\n        \"variant\",\n        `Could not generate variant \"${query.variant}\" of ${String(request.params[\"*\"])}: ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n\n      return response.serverError({ error: \"Could not generate the image variant.\" });\n    }\n  };\n}\n\n/**\n * Serves the default disk's uploads; see {@link createUploadedFileController}\n */\nexport const uploadedFileController: RequestHandler = createUploadedFileController();\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,MAAM,WAAW;AAEjB,MAAM,gBAAqD;CACzD,MAAM;CACN,KAAK;CACL,MAAM;CACN,MAAM;AACR;AAEA,SAAS,SAAS,UAAoB;CACpC,OAAO,SAAS,SAAS,EAAE,OAAO,iBAAiB,CAAC;AACtD;AAEA,eAAe,YACb,UACA,MACA,MACA,QACA;CACA,OAAO,SAAS,WAAW,MAAM;EAC/B,aAAa,cAAc;EAC3B,WAAW;EACX,WAAW;EACX,MAAM,IAAI,KAAK;CACjB,CAAC;AACH;;;;;;;;;;;AAYA,eAAe,yBAAyB,UAAoB,cAAsB;CAChF,SAAS,OAAO,2BAA2B,SAAS;CAEpD,OAAO,SAAS,WAAW,MAAM,GAAG,SAAS,YAAY,GAAG;EAC1D,aAAa,2BAA2B,YAAY;EACpD,WAAW;EACX,WAAW;EACX,QAAQ;EACR,UAAU,KAAK,SAAS,YAAY;CACtC,CAAC;AACH;;;;;;;;AASA,eAAe,mBAAmB,UAAoB,cAAsB,aAAqB;CAC/F,OAAO,SAAS,WAAW,MAAM,GAAG,SAAS,YAAY,GAAG;EAC1D;EACA,WAAW;EACX,WAAW;CACb,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,6BACd,UAAyC,CAAC,GAC1B;CAChB,OAAO,OAAO,EAAE,SAAS,eAAe;EACtC,MAAM,WAAW,cAAc,QAAQ,IAAI;EAE3C,IAAI,CAAC,UAAU;GACb,IAAI,MACF,WACA,SACA,QAAQ,SAAS,SACb,qEACA,+CAA+C,QAAQ,KAAK,cAClE;GAEA,OAAO,SAAS,QAAQ;EAC1B;EAEA,MAAM,QAAQ,uBAAuB,QAAQ,GAAG;EAEhD,IAAI,MAAM,SAAS,WACjB,OAAO,SAAS,WAAW,EAAE,OAAO,MAAM,OAAO,CAAC;EAMpD,SAAS,OAAO,0BAA0B,SAAS;EAEnD,IAAI,MAAM,SAAS,YAAY;GAC7B,MAAM,SAAS,MAAM,kBAAkB,QAAQ,OAAO,MAAM,UAAU,CACpE,KAAK,KAAK,UAAU,UAAU,gBAAgB,GAC9C,yBAAyB,QAAQ,CACnC,CAAC;GAED,IAAI,CAAC,QAAQ,OAAO,SAAS,QAAQ;GAKrC,MAAM,gBAAgB,kBAAkB,MADrB,aAAa,OAAO,iBAAmC,CAC9B;GAE5C,IAAI,CAAC,sBAAsB,aAAa,GACtC,OAAO,yBAAyB,UAAU,OAAO,YAAY;GAM/D,MAAM,oBAAoB,8BAA8B,OAAO,cAAc,aAAa;GAE1F,IAAI,CAAC,mBACH,OAAO,yBAAyB,UAAU,OAAO,YAAY;GAG/D,OAAO,mBAAmB,UAAU,OAAO,cAAc,iBAAiB;EAC5E;EAEA,IAAI;GACF,MAAM,eAAe;IACnB,MAAM,QAAQ,OAAO;IACrB,SAAS,MAAM;IACf,GAAI,MAAM,WAAW,SAAY,EAAE,QAAQ,MAAM,OAA8B,IAAI,CAAC;IACpF,GAAI,QAAQ,SAAS,SAAY,EAAE,MAAM,QAAQ,KAAK,IAAI,CAAC;GAC7D;GACA,IAAI,UAAU,MAAM,oBAAoB,YAAY;GAEpD,IAAI,CAAC,SAAS,OAAO,SAAS,QAAQ;GAEtC,IAAI,mBAAmB,QAAQ,OAAO,eAAe,GAAG,IAAI,QAAQ,KAAK,EAAE,GACzE,OAAO,SAAS,aAAa,OAAO,GAAG,CAAC,CAAC,KAAK;GAGhD,IAAI;GAEJ,IAAI;IACF,OAAO,MAAM,GAAG,SAAS,QAAQ,YAAY;GAC/C,SAAS,WAAW;IAClB,IAAI,CAAC,mBAAmB,SAAS,GAAG,MAAM;IAK1C,UAAU,MAAM,oBAAoB,YAAY;IAEhD,IAAI,CAAC,SAAS,OAAO,SAAS,QAAQ;IAEtC,OAAO,MAAM,GAAG,SAAS,QAAQ,YAAY;GAC/C;GAEA,OAAO,YAAY,UAAU,MAAM,QAAQ,MAAM,QAAQ,MAAM;EACjE,SAAS,OAAO;GACd,IAAI,iBAAiB,WACnB,OAAO,SAAS,KAAK,EAAE,OAAO,MAAM,QAAQ,GAAG,MAAM,MAAM;GAG7D,IAAI,MACF,WACA,WACA,+BAA+B,MAAM,QAAQ,OAAO,OAAO,QAAQ,OAAO,IAAI,EAAE,IAC9E,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAEzD;GAEA,OAAO,SAAS,YAAY,EAAE,OAAO,wCAAwC,CAAC;EAChF;CACF;AACF;;;;AAKA,MAAa,yBAAyC,6BAA6B"}
+{"version":3,"file":"uploaded-file.controller.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/uploaded-file.controller.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { RequestHandler } from \"../../router\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { HttpError } from \"../errors\";\nimport type { Response } from \"../response\";\nimport {\n  detectImageFormat,\n  IMAGE_SIGNATURE_BYTES,\n  isVariantSourceFormat,\n} from \"./detect-image-format\";\nimport { isMissingFileError, variantCacheDirectoryFor } from \"./image-variant-cache\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport { evaluateConditionalRequest } from \"../conditional-request\";\nimport { parseUploadedFileQuery } from \"./parse-uploaded-file-query\";\nimport { readFileHead } from \"./read-file-head\";\nimport { resolveImageVariant } from \"./resolve-image-variant\";\nimport { resolveInlineImageContentType } from \"./resolve-inline-image-content-type\";\nimport { resolveOriginalContentType } from \"./resolve-original-content-type\";\nimport { resolveUploadPath } from \"./resolve-upload-path\";\n\n/**\n * One year, in seconds: originals and derivatives are both long-lived\n */\nconst ONE_YEAR = 31_536_000;\n\nconst CONTENT_TYPES: Record<VariantOutputFormat, string> = {\n  jpeg: \"image/jpeg\",\n  png: \"image/png\",\n  webp: \"image/webp\",\n  avif: \"image/avif\",\n};\n\nfunction notFound(response: Response) {\n  return response.notFound({ error: \"File Not Found\" });\n}\n\nasync function sendVariant(\n  response: Response,\n  body: Buffer,\n  hash: string,\n  format: VariantOutputFormat,\n) {\n  return response.sendBuffer(body, {\n    contentType: CONTENT_TYPES[format],\n    cacheTime: ONE_YEAR,\n    immutable: true,\n    etag: `\"${hash}\"`,\n  });\n}\n\n/**\n * Serve an upload original that isn't safe to render inline: a non-raster\n * format (html, xml, the svg family, anything unrecognised) is markup a\n * browser will parse and execute, and a raster-sniffed file whose extension\n * doesn't back that format up (see `resolveInlineImageContentType`) is a\n * polyglot — so both go out as a download instead of a rendered response.\n * `Content-Type` stays extension-derived, except the svg/html/xml family,\n * which is downgraded to `application/octet-stream` so the browser never\n * renders it even if it ignores the disposition.\n */\nasync function sendOriginalAsAttachment(response: Response, absolutePath: string) {\n  response.header(\"Content-Security-Policy\", \"sandbox\");\n\n  return response.sendBuffer(await fs.readFile(absolutePath), {\n    contentType: resolveOriginalContentType(absolutePath),\n    cacheTime: ONE_YEAR,\n    immutable: true,\n    inline: false,\n    filename: path.basename(absolutePath),\n  });\n}\n\n/**\n * Serve an upload original inline, once the sniffed raster format and the\n * extension-derived format have been confirmed to agree. The content type is\n * always the SNIFFED image type, passed explicitly — never `sendFile`'s\n * extension-derived guess, which is exactly what let a JPEG named `.html`\n * out as `text/html` before this existed.\n */\nasync function sendOriginalInline(response: Response, absolutePath: string, contentType: string) {\n  return response.sendBuffer(await fs.readFile(absolutePath), {\n    contentType,\n    cacheTime: ONE_YEAR,\n    immutable: true,\n  });\n}\n\n/**\n * Options for {@link createUploadedFileController}\n */\nexport type UploadedFileControllerOptions = {\n  /**\n   * Disk to serve from; remote disks support variants only. Uses the default\n   * disk when omitted. A private disk\n   * should be served from a route that checks access first.\n   */\n  disk?: StorageDriverName;\n\n  /** Allow derivatives from the default cloud disk. Explicit disk selection also opts in. */\n  remote?: boolean;\n};\n\n/**\n * Serves local uploads and bounded on-demand image variants from any disk.\n *\n * ```ts\n * router.get(\"/uploads/*\", uploadedFileController);\n * router.get(\"/invoices/*\", createUploadedFileController({ disk: \"private\" }), {\n *   middleware: [authMiddleware()],\n * });\n * ```\n *\n * - `GET /uploads/<path>` sends the original file with a one-year cache.\n * - `GET /uploads/<path>?variant=<name>[&format=webp|avif]` sends a derivative\n *   rendered from a variant named in `uploads.images.variants`. No other query\n *   key is accepted, so a client can never ask for an arbitrary size.\n *\n * The path must stay inside the disk root (after symlinks are resolved) and\n * outside the variant cache; anything else is a 404, the same answer a missing\n * file gets. Derivatives are cached on disk under a directory per source\n * (see `resolveImageVariant`), written atomically, generated once per key even\n * under concurrent requests, and sent with an immutable cache and an ETag.\n */\nexport function createUploadedFileController(\n  options: UploadedFileControllerOptions = {},\n): RequestHandler {\n  return async ({ request, response }) => {\n    const diskRoot = localDiskRoot(options.disk);\n    // The scaffold's public route must not expose private objects when the\n    // default disk changes to a cloud bucket. Remote access is deliberate.\n    if (!diskRoot && options.disk === undefined && options.remote !== true)\n      return notFound(response);\n\n    const query = parseUploadedFileQuery(request.url);\n\n    if (query.type === \"invalid\") {\n      return response.badRequest({ error: query.reason });\n    }\n\n    // Every uploads response — originals and variants — tells the browser not\n    // to guess a content type from the bytes, so a mislabeled body can never be\n    // sniffed into something executable.\n    response.header(\"X-Content-Type-Options\", \"nosniff\");\n\n    if (query.type === \"original\") {\n      if (!diskRoot) {\n        log.error(\n          \"uploads\",\n          \"serve\",\n          options.disk === undefined\n            ? \"uploadedFileController needs a local storage driver with a root.\"\n            : `uploadedFileController needs a local disk; \"${options.disk}\" is not one.`,\n        );\n\n        return notFound(response);\n      }\n\n      const source = await resolveUploadPath(request.params[\"*\"], diskRoot, [\n        path.join(diskRoot, \".cache\", \"image-variants\"),\n        variantCacheDirectoryFor(diskRoot),\n      ]);\n\n      if (!source) return notFound(response);\n\n      // Inline is decided by SNIFFED bytes, never by extension: an svg (or any\n      // other non-raster file) named `.png` must still download, not render.\n      const head = await readFileHead(source.absolutePath, IMAGE_SIGNATURE_BYTES);\n      const sniffedFormat = detectImageFormat(head);\n\n      if (!isVariantSourceFormat(sniffedFormat)) {\n        return sendOriginalAsAttachment(response, source.absolutePath);\n      }\n\n      // Inline is only safe when the extension-derived type agrees with the\n      // sniffed bytes too — otherwise `sendFile` would advertise the\n      // extension's type (e.g. text/html for JPEG bytes named `.html`).\n      const inlineContentType = resolveInlineImageContentType(source.absolutePath, sniffedFormat);\n\n      if (!inlineContentType) {\n        return sendOriginalAsAttachment(response, source.absolutePath);\n      }\n\n      return sendOriginalInline(response, source.absolutePath, inlineContentType);\n    }\n\n    try {\n      const variantInput = {\n        path: request.params[\"*\"] as string,\n        variant: query.variant,\n        ...(query.format !== undefined ? { format: query.format as VariantOutputFormat } : {}),\n        ...(options.disk !== undefined ? { disk: options.disk } : {}),\n      };\n      let variant = await resolveImageVariant(variantInput);\n\n      if (!variant) return notFound(response);\n\n      // The variant hash is a strong validator: If-None-Match compares weakly,\n      // If-Match strongly (RFC 9110 §13.1).\n      const precondition = evaluateConditionalRequest({\n        method: request.method,\n        etag: `\"${variant.hash}\"`,\n        ifMatch: request.header(\"if-match\"),\n        ifNoneMatch: request.header(\"if-none-match\"),\n      });\n\n      if (precondition === \"not-modified\") {\n        return response.baseResponse.status(304).send();\n      }\n\n      if (precondition === \"precondition-failed\") {\n        return response.baseResponse.status(412).send();\n      }\n\n      let body: Buffer;\n\n      try {\n        body = await fs.readFile(variant.absolutePath);\n      } catch (readError) {\n        if (!isMissingFileError(readError)) throw readError;\n\n        // Pruned between the existence check and the read: the source was\n        // rewritten in place and a request for the new version cleared the\n        // old generation. Resolve (and render) once more.\n        variant = await resolveImageVariant(variantInput);\n\n        if (!variant) return notFound(response);\n\n        body = await fs.readFile(variant.absolutePath);\n      }\n\n      return sendVariant(response, body, variant.hash, variant.format);\n    } catch (error) {\n      if (error instanceof HttpError) {\n        return response.send({ error: error.message }, error.status);\n      }\n\n      log.error(\n        \"uploads\",\n        \"variant\",\n        `Could not generate variant \"${query.variant}\" of ${String(request.params[\"*\"])}: ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n\n      return response.serverError({ error: \"Could not generate the image variant.\" });\n    }\n  };\n}\n\n/**\n * Serves the default disk's uploads; see {@link createUploadedFileController}\n */\nexport const uploadedFileController: RequestHandler = createUploadedFileController();\n"],"mappings":"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"}

package/esm/http/uploads/variant-cache-key.mjs

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { createHash } from "node:crypto";
+import path from "node:path";
 
 //#region ../../packages/core/src/http/uploads/variant-cache-key.ts
 /**

package/esm/http/uploads-types.d.mts

@@ -296,11 +296,15 @@ type UploadsImagesConfigurations = {
    */
   maxSourcePixels?: number;
   /**
-   * Absolute directory the generated variants are cached in
+   * Absolute directory dedicated to generated variants. Keep originals and
+   * other application files elsewhere; purge removes recognized cache files
+   * without deleting this directory.
    *
    * @default storage.root(".cache/image-variants")
    */
-  cacheDirectory?: string;
+  cacheDirectory?: string; /** Maximum total cached derivative bytes. Default 512 MiB. */
+  maxCacheBytes?: number; /** Maximum derivative age in seconds, measured from generation. Default 7 days. */
+  maxCacheAge?: number;
 };
 /**
  * High-level image options that can be chained on UploadedFile

package/esm/http/uploads-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"uploads-types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/uploads-types.ts"],"mappings":";;;;;;;;;AAyBA;;;;;;;;AAiCI;AAWJ;;;;AAA2D;AAS3D;;;KArDY,aAAA;EAqDkB;AAoB9B;;;;;;;;;;;;EA3DE,MAAA;EAyFA;;;;;AAOgC;AAQlC;;EA9FE,YAAA;EA8F0B;AAAgB;AAiB5C;;;;;EAtGE,EAAA;AAAA;;AAsGwD;AAS1D;;;;AAAiF;AAgBjF;KApHY,YAAA,sBAAkC,aAAa;;;;;;;;KAS/C,kBAAA;;;AAsJ0B;AAMtC;;;;AAAoC;AAKpC;;;;AAA2B;AAU3B;;;;;KAvJY,WAAA;EAuKV;;;;;AAcO;AAkBT;;;EA7LE,IAAA,GAAO,kBAAA;EAiMY;;;;;;;;;EAtLnB,MAAA,GAAS,YAAA;EA6LU;;;;;AAqBL;AAQhB;EAjNE,MAAA,GAAS,iBAAA;;;;;;EAOT,QAAA,GAAW,qBAAA;AAAA;;;;;;KAQD,aAAA,GAAgB,IAAI,CAAC,WAAA;;;;;;;;;;;;;;;;KAiBrB,sBAAA,IAA0B,GAAA,EAAK,KAAA,KAAU,KAAK;;;;;;;;KAS9C,oBAAA,GAAuB,qBAAA,GAAwB,sBAAsB;;;;;;;;;;;;;;;KAgBrE,qBAAA;;;;;;EAMV,IAAA;;;;;;EAOA,YAAA;;;;;;;;;EAUA,MAAA,GAAS,YAAA;;;;;;EAOT,mBAAA;;;;;;;;;;;;EAaA,MAAA,GAAS,2BAA2B;AAAA;;;;KAM1B,wBAAA;;;;KAKA,eAAA;;;;;;;;;KAUA,sBAAA;;;;EAIV,KAAA;;;;EAKA,MAAA;;;;;;EAOA,GAAA,GAAM,eAAe;;;;EAKrB,OAAA;;;;;;;;EASA,OAAA;AAAA;;;;;;;;;;;;;;;;KAkBU,2BAAA;;;;EAIV,QAAA,EAAU,QAAA,CAAS,MAAA,SAAe,sBAAA;;;;;;EAOlC,OAAA,YAAmB,wBAAA;;;;;;EAOnB,cAAA;;;;;;EAOA,eAAA;;;;;;EAOA,cAAA;AAAA;;;;;;KAQU,wBAAA;;;;EAIV,MAAA;IAAW,KAAA;IAAe,MAAA;EAAA;;;;EAK1B,OAAA;;;;EAKA,MAAA,GAAS,WAAW;;;;EAKpB,MAAA;;;;EAKA,IAAA;;;;EAKA,SAAA;AAAA"}
+{"version":3,"file":"uploads-types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/uploads-types.ts"],"mappings":";;;;;;;;;AAyBA;;;;;;;;AAiCI;AAWJ;;;;AAA2D;AAS3D;;;KArDY,aAAA;EAqDkB;AAoB9B;;;;;;;;;;;;EA3DE,MAAA;EAyFA;;;;;AAOgC;AAQlC;;EA9FE,YAAA;EA8F0B;AAAgB;AAiB5C;;;;;EAtGE,EAAA;AAAA;;AAsGwD;AAS1D;;;;AAAiF;AAgBjF;KApHY,YAAA,sBAAkC,aAAa;;;;;;;;KAS/C,kBAAA;;;AAsJ0B;AAMtC;;;;AAAoC;AAKpC;;;;AAA2B;AAU3B;;;;;KAvJY,WAAA;EAuKV;;;;;AAcO;AAkBT;;;EA7LE,IAAA,GAAO,kBAAA;EAiMY;;;;;;;;;EAtLnB,MAAA,GAAS,YAAA;EA6LU;;;;;;;EApLnB,MAAA,GAAS,iBAAA;EAyNC;;;;;EAlNV,QAAA,GAAW,qBAAA;AAAA;;;;;;KAQD,aAAA,GAAgB,IAAI,CAAC,WAAA;;AAuOtB;;;;;;;;;;;;;;KAtNC,sBAAA,IAA0B,GAAA,EAAK,KAAA,KAAU,KAAK;;;;;;;;KAS9C,oBAAA,GAAuB,qBAAA,GAAwB,sBAAsB;;;;;;;;;;;;;;;KAgBrE,qBAAA;;;;;;EAMV,IAAA;;;;;;EAOA,YAAA;;;;;;;;;EAUA,MAAA,GAAS,YAAA;;;;;;EAOT,mBAAA;;;;;;;;;;;;EAaA,MAAA,GAAS,2BAA2B;AAAA;;;;KAM1B,wBAAA;;;;KAKA,eAAA;;;;;;;;;KAUA,sBAAA;;;;EAIV,KAAA;;;;EAKA,MAAA;;;;;;EAOA,GAAA,GAAM,eAAe;;;;EAKrB,OAAA;;;;;;;;EASA,OAAA;AAAA;;;;;;;;;;;;;;;;KAkBU,2BAAA;;;;EAIV,QAAA,EAAU,QAAA,CAAS,MAAA,SAAe,sBAAA;;;;;;EAOlC,OAAA,YAAmB,wBAAA;;;;;;EAOnB,cAAA;;;;;;EAOA,eAAA;;;;;;;;EASA,cAAA;EAGA,aAAA;EAGA,WAAA;AAAA;;;;;;KAQU,wBAAA;;;;EAIV,MAAA;IAAW,KAAA;IAAe,MAAA;EAAA;;;;EAK1B,OAAA;;;;EAKA,MAAA,GAAS,WAAW;;;;EAKpB,MAAA;;;;EAKA,IAAA;;;;EAKA,SAAA;AAAA"}

package/esm/index.d.mts

@@ -1,7 +1,10 @@
 import { BadRequestError, ConflictError, CookieJarUnavailableError, ForbiddenError, HttpError, NotAcceptableError, NotAllowedError, ResourceNotFoundError, ServerError, UnAuthorizedError } from "./http/errors/errors.mjs";
+import { ERROR_CODES, ERROR_CODES_DOCS_URL, ErrorCodeArea, ErrorCodeCategory, ErrorCodeDefinition, WarlockErrorCode, errorCodeDocsUrl, errorCodeOf, explainErrorCode, isWarlockErrorCode } from "./errors/error-codes.mjs";
+import { WarlockError } from "./errors/warlock-error.mjs";
 import { normalizeRoutePath } from "./router/normalize-route-path.mjs";
 import { normalizeRequestPath } from "./router/normalize-request-path.mjs";
-import { HttpLoggingConfig, RequestLogSnapshot, RequestLogSource, RequestLoggingOptions, URL_CREDENTIAL_PARAMS, buildRequestLogSnapshot, redactQueryCredentials, redactUrlCredentials, resolveRequestLoggingOptions } from "./http/request-log-snapshot.mjs";
+import { ConditionalRequestInput, ConditionalRequestOutcome, EntityTag, evaluateConditionalRequest, matchesIfMatch, matchesIfNoneMatch, parseEntityTag, parseEntityTagList, strongEntityTagMatch, weakEntityTagMatch } from "./http/conditional-request.mjs";
+import { HttpLoggingConfig, PrivateRequestLoggingRule, RequestLogSnapshot, RequestLogSource, RequestLoggingOptions, URL_CREDENTIAL_PARAMS, buildRequestLogSnapshot, redactQueryCredentials, redactUrlCredentials, resolveRequestLoggingOptions } from "./http/request-log-snapshot.mjs";
 import { StorageFile } from "./storage/storage-file.mjs";
 import { ScopedStorage } from "./storage/scoped-storage.mjs";
 import { CloudStorageDriverContract, CloudStorageDriverOptions, CloudStorageFileData, DeleteManyResult, EventSubscription, FileVisibility, ListOptions, LocalStorageDriverOptions, PresignedOptions, PresignedUploadOptions, PutDirectoryOptions, PutDirectoryResult, PutFromUrlOptions, PutOptions, R2StorageDriverOptions, ScopedStorageContract, StorageConfigurations, StorageCopyEventPayload, StorageDriverConfig, StorageDriverContract, StorageDriverName, StorageDriverRegistry, StorageDriverType, StorageEventHandler, StorageEventPayload, StorageEventType, StorageFileData, StorageFileInfo, StorageManagerContract, StoragePutEventPayload, TemporaryTokenError, TemporaryTokenPayload, TemporaryTokenValidation } from "./storage/types.mjs";
@@ -30,7 +33,7 @@ import { Request, RequestTranslator } from "./http/request.mjs";
 import { CspConfig, DEFAULT_CSP_DIRECTIVES, InvalidCspDirectiveError, applyCspHeader, buildCspHeaderValue, mergeCspDirectives, resolveCspConfig, serializeCspDirectives, validateCspConfigAtBoot, validateCspDirectives } from "./http/csp.mjs";
 import { HttpErrorMapper, HttpErrorMapping } from "./http/error-mapper.mjs";
 import { HttpTracingConfig, TracingContext, TracingHooks, TracingPhaseInfo, TracingRequestEndInfo } from "./http/tracing/tracing.type.mjs";
-import { DecodedAccessToken, HttpConfigurations, HttpServerOptions, PartialMiddleware, RequestEvent, RequestLocals, ResponseEvent, ResponseSSEController, ResponseSSEOptions, ResponseStreamController, ResponseStreamOptions, ReturnedResponse } from "./http/types.mjs";
+import { DecodedAccessToken, HttpConfigurations, HttpServerOptions, PartialMiddleware, RequestEvent, RequestLocals, ResponseEvent, ResponseSSEController, ResponseSSEMessageOptions, ResponseSSEOptions, ResponseStreamController, ResponseStreamOptions, ReturnedResponse } from "./http/types.mjs";
 import { defaultHttpConfigurations, httpConfig } from "./http/config.mjs";
 import { createHttpApplication, stopHttpApplication } from "./http/createHttpApplication.mjs";
 import { requiresDefaultCsrfGuard, runDefaultCsrfGuard } from "./http/csrf-default-guard.mjs";
@@ -64,6 +67,8 @@ import { assertConfiguredHttpPortIsFree, preflightConfiguredHttpPort, remedyLine
 import { PortInUseError, assertPortIsAvailable, isPortAvailable } from "./http/port-preflight.mjs";
 import { HttpReadyReport, getHttpReadyReport, resetHttpReadyReport, setHttpReadyReport } from "./http/ready-report.mjs";
 import { HttpServerRebuiltListener, notifyHttpServerRebuilt, onHttpServerRebuilt } from "./http/server-rebuilt.mjs";
+import { escapeHeaderValue } from "./http/escape-header-value.mjs";
+import { SafeRedirectOptions, isSafeRedirect, safeRedirect } from "./http/safe-redirect.mjs";
 import { deriveTraceId, parseTraceparentTraceId } from "./http/tracing/trace-id.mjs";
 import { TracingContextSource, buildTracingContext, dispatchPhase, dispatchRequestEnd, dispatchRequestStart, isTracingEnabled, registerTracingHooks, resetTracingConfigForTests, resolveTracingConfig } from "./http/tracing/tracing-dispatcher.mjs";
 import { RequestContextStore, requestContext, useCurrentUser, useRequest, useRequestStore } from "./http/context/request-context.mjs";
@@ -74,11 +79,13 @@ import { ResourceFieldBuilder } from "./resource/resource-field-builder.mjs";
 import { Resource, ResourceConstructor, ResourceContract } from "./resource/resource.mjs";
 import { NULLABLE_RESOURCE, NullableResource, NullableResourceTarget, isNullableResource, nullable } from "./resource/nullable-resource.mjs";
 import { BaseCastOutput, CastOutput, FieldOutput, ResourceArraySchema, ResourceCastType, ResourceFieldBuilderDateOutputOptions, ResourceFieldConfig, ResourceOutput, ResourceOutputOf, ResourceOutputValueCastType, ResourceSchema, ResourceSelfReference, ResponseBodyOutput, ResponseBodyValue, ResponseSchema, ResponseSchemaOutput } from "./resource/types.mjs";
-import { GroupedRoutesOptions, HttpContext, Middleware, MiddlewareResponse, NamedApiRoute, NamedApiRoutesOptions, PartialPick, RequestControllerContract, RequestHandler, RequestHandlerType, RequestHandlerValidation, RequestMethod, ResourceMethod, RestfulMiddleware, Route, RouteOptions, RouteResource, RouterGroupCallback, RouterStacks } from "./router/types.mjs";
+import { GroupedRoutesOptions, HttpContext, Middleware, MiddlewareResponse, NamedApiRoute, NamedApiRoutesOptions, PartialPick, RequestControllerContract, RequestHandler, RequestHandlerType, RequestHandlerValidation, RequestMethod, ResourceMethod, RestfulMiddleware, Route, RouteOptions, RouteRateLimitOptions, RouteResource, RouterGroupCallback, RouterStacks, StaticMountOptions, ValidationFailureContext, ValidationFailureHandler, ValidationFailureResponse } from "./router/types.mjs";
 import { PositionalHandlerSuspect, clearPositionalHandlerSuspects, describePositionalHandlerSuspect, forgetPositionalHandlerSuspects, inspectHandlerSignature, listPositionalHandlerSuspects, looksLikePositionalHandler, reportPositionalHandlerSuspects } from "./router/positional-handler-diagnostics.mjs";
 import { matchesDerivedRouteName, routeNameMethodSuffix } from "./router/route-name-method-suffix.mjs";
+import { RouteNameTakenError } from "./router/route-name-taken-error.mjs";
 import { RouteRegistry } from "./router/route-registry.mjs";
 import { Router, router } from "./router/router.mjs";
+import { AUTH_GUARD_MARKER, isAuthGuardMiddleware, isUnguardedMutatingRoute, markAuthGuard, reportUnguardedMutatingRoutes, resetUnguardedRouteReports } from "./router/unguarded-route-diagnostics.mjs";
 import { app } from "./application/app.mjs";
 import { Environment, RuntimeStrategy, environment, setEnvironment } from "./utils/environment.mjs";
 import { APP_ROLES, AppRole, assertSitesRequireWebRole, getRoles, getSites, hasRole, parseRoles, parseSites, resetRolesCacheForTests, servesHttp } from "./application/roles.mjs";
@@ -98,6 +105,7 @@ import { DatabaseCacheDriver, DatabaseCacheOptions } from "./cache/database-cach
 import { ConfigKey, ConfigKeyRegistry, ConfigName, ConfigRegistry } from "./config/types.mjs";
 import { config } from "./config/config-getter.mjs";
 import { registerAppConfig } from "./config/config-handlers.mjs";
+import { ConfigIssue, ConfigModuleEntry, ConfigOf, ConfigSchema, ConfigSchemaOptions, InvalidConfigError, assertValidConfigModules, defineConfigSchema, formatConfigIssues, isConfigSchema, validateConfigValue } from "./config/config-schema.mjs";
 import { setConfig } from "./config/config-setter.mjs";
 import { ConfigSpecialHandlers, configSpecialHandlers } from "./config/config-special-handlers.mjs";
 import { WarlockConfig } from "./warlock-config/types.mjs";
@@ -138,7 +146,7 @@ import { setLogConfigurations } from "./logger/logger.mjs";
 import { LocaleDictionaryEntries, LocaleDictionaryError, ParsedLocaleDictionary, parseLocaleDictionary } from "./localization/parse-locale-dictionary.mjs";
 import { registerGroupedTranslationKeys, registerLocaleDictionary, unregisterLocaleDictionary } from "./localization/register-locale-dictionary.mjs";
 import { CapturedMail, MailAddress, MailAttachment, MailConfigurations, MailError, MailErrorCode, MailEvents, MailMode, MailOptions, MailPriority, MailResult, MailersConfig, NormalizedMail, SESConfigurations, SMTPConfigurations } from "./mail/types.mjs";
-import { getDefaultMailConfig, getMailMode, getMailerConfig, isDevelopmentMode, isProductionMode, isTestMode, resetMailConfig, resolveMailConfig, setMailConfigurations, setMailMode } from "./mail/config.mjs";
+import { getDefaultMailConfig, getExplicitMailMode, getMailMode, getMailerConfig, isDevelopmentMode, isProductionMode, isTestMode, resetMailConfig, resetMailMode, resolveMailConfig, setMailConfigurations, setMailMode } from "./mail/config.mjs";
 import { MAIL_EVENTS, generateMailId, getMailEventName, mailEvents } from "./mail/events.mjs";
 import { closeAllMailers, closeMailer, getMailer, getPoolStats, verifyMailer } from "./mail/mailer-pool.mjs";
 import { renderReactMail } from "./mail/react-mail.mjs";
@@ -171,12 +179,15 @@ import { PipelineOptions, runPipeline } from "./use-cases/use-case-pipeline.mjs"
 import { BadSchemaUseCaseError } from "./use-cases/use-case.errors.mjs";
 import { $registerUseCase, $unregisterUseCase, addUseCaseHistory, getUseCase, getUseCaseHistory, getUseCases, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls } from "./use-cases/use-cases-registry.mjs";
 import { appLog } from "./utils/app-log.mjs";
+import { ClockSource, clock, setClockSource } from "./utils/clock.mjs";
 import { DatabaseLog, DatabaseLogOptions } from "./utils/database-log.mjs";
+import { IdsSource, ids, setIdsSource } from "./utils/ids.mjs";
 import { Path } from "./utils/normalized-path.mjs";
 import { fetchLatestVersion } from "./utils/npm-registry.mjs";
 import { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath } from "./utils/paths.mjs";
 import { promiseAllObject } from "./utils/promise-all-object.mjs";
 import { Queue } from "./utils/queue.mjs";
+import { JavaScriptRuntime, JavaScriptRuntimeName, SUPPORTED_RUNTIMES_DOCS_URL, assertNodeOnlyCommand, describeJavaScriptRuntime, detectJavaScriptRuntime, nodeOnlyCommandError, unverifiedBuildRuntimeNotice } from "./utils/runtime.mjs";
 import { sleep } from "./utils/sleep.mjs";
 import { sluggable } from "./utils/sluggable.mjs";
 import { toJson } from "./utils/to-json.mjs";
@@ -188,14 +199,14 @@ import { ExistsExceptCurrentIdRuleOptions, ExistsExceptCurrentUserRuleOptions, U
 import { uniqueExceptCurrentIdRule } from "./validation/database/unique-except-current-id.mjs";
 import { uniqueExceptCurrentUserRule } from "./validation/database/unique-except-current-user.mjs";
 import { FileValidator, uploadedFileMetadataSchema } from "./validation/validators/file-validator.mjs";
-import { ValidationConfiguration } from "./validation/types.mjs";
+import { ValidationConfiguration, ValidationResponseConfiguration } from "./validation/types.mjs";
 import { fileExtensionRule, fileRule, fileTypeRule, imageRule } from "./validation/file/file.mjs";
 import { defineConfig } from "./warlock-config/define-config.mjs";
 import { WarlockConfigManager, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, warlockConfigManager } from "./warlock-config/warlock-config.manager.mjs";
 import { env } from "@mongez/dotenv";
 import { colors } from "@mongez/copper";
 export * from "@mongez/localization";
-export { $registerUseCase, $unregisterUseCase, APP_ROLES, AccessConnector, AggregateExpressionInput, AggregateExpressions, AiConnector, AllRepositoryOptions, AppConfigurations, AppRole, Application, AuthDescriptor, BOOT_SIGNAL_ENV_KEY, BOOT_SIGNAL_VERSION, BadRequestError, BadSchemaUseCaseError, BaseCastOutput, BaseConnector, type BenchmarkChannel, type BenchmarkConfigurations, type BenchmarkErrorResult, type BenchmarkOptions, BenchmarkProfiler, type BenchmarkProfilerOptions, type BenchmarkResult, BenchmarkSnapshots, type BenchmarkSnapshotsOptions, type BenchmarkStats, type BenchmarkSuccessResult, BootContext, BootListener, BootSignal, BootSignalType, BootValidator, CLICommand, type CLICommandAction, type CLICommandOption, type CLICommandOptions, type CLICommandPreload, type CLICommandSource, CacheConnector, type CacheMiddlewareOptions, CachedRepositoryOptions, type CapturedMail, CascadeAdapter, CascadeQueryBuilder, CastOutput, ChunkCallback, ClosableServer, CloudDriver, CloudStorageDriverContract, CloudStorageDriverOptions, CloudStorageFileData, type CommandActionData, type ConcurrencyLimitOptions, ConfigKey, ConfigKeyRegistry, ConfigName, ConfigRegistry, ConfigSpecialHandlers, ConflictError, Connector, ConnectorBuildContext, ConnectorBuildContribution, ConnectorBuildGenerateResult, ConnectorEsbuildPatch, ConnectorLifecyclePhase, ConnectorName, ConnectorPriority, ConnectorsManager, ConsoleChannel, ContainerTypes, CookieJarUnavailableError, CookieOptions, CspConfig, CsrfOriginCheckReason, CsrfOriginVerdict, CursorPaginationOptions, CursorPaginationResult, DEFAULT_CSP_DIRECTIVES, DEFAULT_POSTMAN_BASE_URL, DOSpacesDriver, DatabaseCacheDriver, type DatabaseCacheOptions, DatabaseConnector, DatabaseLog, DatabaseLogModel, DatabaseLogOptions, DecodedAccessToken, DefineResourceOptions, DeleteManyResult, DetectedImageFormat, type DevelopmentAppModuleEntry, type DevelopmentAppModules, type DevelopmentModelModuleEntry, type DevelopmentModelModuleState, type DevelopmentModelModules, DevelopmentPostmanResult, EncryptionConfigurations, EncryptionPasswordConfigurations, Environment, EventSubscription, ExistsExceptCurrentIdRuleOptions, ExistsExceptCurrentUserRuleOptions, FastifyInstance, FieldOutput, FileNamingStrategy, FileValidationOptions, FileValidator, FileVisibility, FilterFunction, FilterOperator, FilterOptions, FilterRule, FilterRules, ForbiddenError, GenerateImageVariantsOptions, GeneratedImageDescriptor, GeneratedImageVariant, GroupByFields, GroupedRoutesOptions, HealthCheck, HealthStatus, HeraldConnector, HttpConfigurations, HttpConnector, HttpContext, HttpError, HttpErrorCodes, type HttpErrorMapper, type HttpErrorMapping, HttpLoggingConfig, HttpReadyReport, HttpServerOptions, HttpServerRebuiltListener, HttpTracingConfig, type IdempotencyOptions, Image, ImageFormat, ImageInput, ImageTransformCallback, ImageTransformConfig, ImageTransformOptions, ImageVariantDefinition, ImageVariantFit, ImageVariantOutputFormat, ImageVariantsConfigError, InvalidCspDirectiveError, type IpFilterOptions, ListOptions, LocalDriver, LocalStorageDriverOptions, LocaleDictionaryEntries, LocaleDictionaryError, LocalizedObject, LogConfigurations, LoggerConnector, MAIL_EVENTS, Mail, type MailAddress, type MailAttachment, type MailConfigurations, MailError, type MailErrorCode, type MailEvents, type MailMode, type MailOptions, type MailPriority, type MailResult, MailerConnector, type MailersConfig, type MaintenanceOptions, Middleware, MiddlewareResponse, MimeTypes, ModelResourceRegistry, NULLABLE_RESOURCE, NamedApiRoute, NamedApiRoutesOptions, NoopChannel, type NormalizedMail, NotAcceptableError, NotAllowedError, NotificationsConnector, NullableResource, NullableResourceTarget, OPENAPI_JSON_SCHEMA_DIALECT, OpenApiBuildResult, OpenApiComponents, OpenApiContext, OpenApiDocument, OpenApiOperation, OpenApiParameter, OpenApiRequestBody, OpenApiResponse, OpenApiRouteInput, OpenApiSchema, OpenApiSecurityRequirement, OpenApiSecurityScheme, OpenApiValidationResponseConfig, POSTMAN_COLLECTION_SCHEMA, PaginationMode, PaginationResult, ParsedLocaleDictionary, PartialMiddleware, PartialPick, Path, PipeableReactStream, PipelineOptions, PortInUseError, PositionalHandlerSuspect, PostmanAuth, PostmanAuthEntry, PostmanBody, PostmanCollection, PostmanCollectionOptions, PostmanFolder, PostmanFormParam, PostmanHeader, PostmanItem, PostmanOriginalRequest, PostmanQueryParam, PostmanRequest, PostmanRequestItem, PostmanResponse, PostmanUrl, PostmanVariable, PrefixConfig, PrefixOptions, PresignedOptions, PresignedUploadOptions, PurgeImageVariantsOptions, PutDirectoryOptions, PutDirectoryResult, PutFromUrlOptions, PutOptions, QueryBuilderContract, Queue, R2Driver, R2StorageDriverOptions, type RateLimitOptions, RegisterConfiguredConnectorsOptions, RegisterResource, RegisteredUseCase, RepositoryAdapterContract, RepositoryConfigurations, RepositoryEvent, RepositoryManager, RepositoryOptions, RepositoryOptionsWithCursor, RepositoryOptionsWithPages, Request, RequestContextStore, RequestController, RequestControllerContract, RequestEvent, RequestHandler, RequestHandlerType, RequestHandlerValidation, RequestLocals, RequestLog, RequestLogSnapshot, RequestLogSource, RequestLoggingOptions, RequestMethod, RequestTranslator, ResolveImageVariantInput, type ResolvedCLICommandOption, ResolvedImageVariant, ResolvedImageVariantsConfig, Resource, ResourceArraySchema, ResourceCastType, ResourceConstructor, ResourceContract, ResourceFieldBuilder, ResourceFieldBuilderDateOutputOptions, ResourceFieldConfig, ResourceMethod, ResourceNotFoundError, ResourceOutput, ResourceOutputOf, ResourceOutputValueCastType, ResourceSchema, ResourceSelfReference, Response, ResponseBodyOutput, ResponseBodyValue, ResponseEvent, ResponseSSEController, ResponseSSEOptions, ResponseSchema, ResponseSchemaOutput, ResponseStatus, ResponseStreamController, ResponseStreamOptions, Restful, RestfulMiddleware, ReturnedResponse, Route, RouteOptions, RouteRegistry, RouteResource, Router, RouterGroupCallback, RouterStacks, RuntimeStrategy, S3Driver, type SESConfigurations, type SMTPConfigurations, SafeFetchOptions, SafeFetchResult, SaveAsOptions, SaveMode, SaveOptions, ScopedStorage, ScopedStorageContract, SeedClock, SeedContext, SeedRecordRef, SeedResult, Seeder, SeederDependencyCycleError, SeederMetadata, SendBufferOptions, SendFileOptions, Serialized, SerializedWire, ServerError, ShutdownListener, SocketAdapterFactory, SocketConnector, SocketOptions, Storage, StorageCapabilityError, StorageConfigurations, StorageConnector, StorageCopyEventPayload, StorageDriverConfig, StorageDriverContextStore, StorageDriverContract, StorageDriverName, StorageDriverRegistry, StorageDriverType, StorageError, StorageErrorOptions, StorageEventHandler, StorageEventPayload, StorageEventType, StorageFile, StorageFileData, StorageFileInfo, StorageManagerContract, StorageNotInitializedError, StoragePutEventPayload, StreamReactResponseOptions, TemporaryTokenError, TemporaryTokenPayload, TemporaryTokenValidation, TracingContext, TracingContextSource, TracingHooks, TracingPhaseInfo, TracingRequestEndInfo, Track, TrackableModel, TypedAllRepositoryOptions, TypedRepositoryOptions, TypedRepositoryOptionsWithCursor, TypedRepositoryOptionsWithPages, UPDATE_MANY_BATCH_SIZE, UPLOADS_DEFAULTS, URL_CREDENTIAL_PARAMS, UnAuthorizedError, UniqueExceptCurrentIdRuleOptions, UniqueExceptCurrentUserRuleOptions, UnknownSeederDependencyError, UploadedFile, UploadedFileControllerOptions, UploadedFileImageOptions, UploadedFileJson, UploadedFileQuery, UploadsConfigurations, UploadsImagesConfigurations, UseCase, UseCaseAfterMiddleware, UseCaseBeforeMiddleware, UseCaseBroadcastChannel, UseCaseBroadcastEvent, UseCaseBroadcastOption, UseCaseConfigurations, UseCaseContext, UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseGuard, UseCaseHandler, UseCaseOnExecutingContext, UseCaseResult, UseCaseRuntimeOptions, UseCaseWithSchema, ValidationConfiguration, VariantOutputFormat, VariantSourceFormat, WarlockConfig, WarlockConfigManager, WarningSink, WatermarkConfig, WhereOperator, XMLable, addUseCaseHistory, anyMatch, app, appLog, appPath, applyCspHeader, assertConfiguredHttpPortIsFree, assertMailCount, assertMailSent, assertNoReservedConnectorNames, assertPortIsAvailable, assertSitesRequireWebRole, assertUniqueConnectorNames, assetsUrl, beginHttpDrain, bootstrap, broadcastUseCaseResult, buildCspHeaderValue, buildIdempotencyCacheKey, buildOpenApiDocument, buildRequestLogSnapshot, buildTracingContext, cachePath, captureMail, clearPositionalHandlerSuspects, clearTestMailbox, closeAllMailers, closeMailer, closeServerWithTimeout, colors, command, config, configPath, configSpecialHandlers, connectorsManager, container, createHttpApplication, createRequestStore, createUploadedFileController, decrypt, defaultHttpConfigurations, defineConfig, defineResource, deriveTraceId, describePositionalHandlerSuspect, dispatchPhase, dispatchRequestEnd, dispatchRequestStart, displayEnvironmentMode, encrypt, ensureFatalIsVisible, env, environment, exampleFromSchema, existsExceptCurrentIdRule, existsExceptCurrentUserRule, fetchLatestVersion, fileExtensionRule, fileRule, fileTypeRule, findMailsBySubject, findMailsTo, fireLifecycleEvent, forgetPositionalHandlerSuspects, generateImageVariants, generateMailId, getDefaultMailConfig, getDevelopmentOpenApiDocument, getDevelopmentPostmanCollection, getHttpReadyReport, getHttpServer, getLastMail, getLocalized, getMailEventName, getMailMode, getMailboxSize, getMailer, getMailerConfig, getMimeType, getPoolStats, getPublicUrl, getRoles, getSites, getSocketServer, getTestMailbox, getUseCase, getUseCaseHistory, getUseCases, globalEventsCallbacksMap, globalUseCasesEvents, hasRole, hashBody, hashPassword, health, hmacHash, httpConfig, imageRule, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls, inspectHandlerSignature, ipMatches, isAllowedCsrfOrigin, isBootSignal, isDevelopmentMode, isNewerVersion, isNullableResource, isPortAvailable, isPrivateOrReservedIp, isProductionMode, isTestMode, isTracingEnabled, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, isValidIdempotencyKey, listPositionalHandlerSuspects, loadS3, logResponse, logsPath, looksLikePositionalHandler, mailEvents, matchesDerivedRouteName, measure, mergeCspDirectives, middleware, normalizeOrigin, normalizeRequestPath, normalizeRoutePath, notifyHttpServerRebuilt, nullable, onHttpServerRebuilt, openApiToPostmanCollection, originOf, ownOrigin, parseLocaleDictionary, parseRoles, parseSites, parseSize, parseTraceparentTraceId, paths, preflightConfiguredHttpPort, promiseAllObject, publicPath, publicUrl, purgeImageVariants, redactQueryCredentials, redactUrlCredentials, registerAppConfig, registerConfiguredConnectors, registerDevelopmentOpenApiProvider, registerGroupedTranslationKeys, registerHttpPlugins, registerLocaleDictionary, registerTracingHooks, remedyLines, renderReact, renderReactMail, reportPositionalHandlerSuspects, requestContext, requestMemo, requiresDefaultCsrfGuard, resetHttpReadyReport, resetMailConfig, resetRolesCacheForTests, resetTracingConfigForTests, resolveCspConfig, resolveCsrfOriginVerdict, resolveImageVariant, resolveMailConfig, resolvePublicRoot, resolveRequestLoggingOptions, resolveTracingConfig, resolveWithinRoot, rootPath, routeNameMethodSuffix, router, runDefaultCsrfGuard, runPipeline, safeFetchToBuffer, sanitizePath, seeder, sendBootSignal, sendMail, serializeCspDirectives, servesHttp, setBaseUrl, setConfig, setEnvironment, setHttpReadyReport, setLogConfigurations, setMailConfigurations, setMailMode, shouldPreflightHttpPort, sleep, sluggable, srcPath, startHttpServer, stopHttpApplication, storage, storageConfig, storageConfigurations, storageDriverContext, storagePath, streamReactResponse, t, tempPath, toJson, toSingleLineSseField, trackConnectionsForDrain, uniqueExceptCurrentIdRule, uniqueExceptCurrentUserRule, unregisterLocaleDictionary, uploadedFileController, uploadedFileMetadataSchema, uploadsConfig, uploadsPath, uploadsUrl, url, useCase, useComputedModel, useComputedSlug, useCurrentUser, useHashedPassword, useRequest, useRequestStore, validateCspConfigAtBoot, validateCspDirectives, verifyMailer, verifyPassword, warlockConfigManager, warlockPath, wasMailSentTo, wasMailSentWithSubject, wrapResponseInDataKey };
+export { $registerUseCase, $unregisterUseCase, APP_ROLES, AUTH_GUARD_MARKER, AccessConnector, AggregateExpressionInput, AggregateExpressions, AiConnector, AllRepositoryOptions, AppConfigurations, AppRole, Application, AuthDescriptor, BOOT_SIGNAL_ENV_KEY, BOOT_SIGNAL_VERSION, BadRequestError, BadSchemaUseCaseError, BaseCastOutput, BaseConnector, type BenchmarkChannel, type BenchmarkConfigurations, type BenchmarkErrorResult, type BenchmarkOptions, BenchmarkProfiler, type BenchmarkProfilerOptions, type BenchmarkResult, BenchmarkSnapshots, type BenchmarkSnapshotsOptions, type BenchmarkStats, type BenchmarkSuccessResult, BootContext, BootListener, BootSignal, BootSignalType, BootValidator, CLICommand, type CLICommandAction, type CLICommandOption, type CLICommandOptions, type CLICommandPreload, type CLICommandSource, CacheConnector, type CacheMiddlewareOptions, CachedRepositoryOptions, type CapturedMail, CascadeAdapter, CascadeQueryBuilder, CastOutput, ChunkCallback, ClockSource, ClosableServer, CloudDriver, CloudStorageDriverContract, CloudStorageDriverOptions, CloudStorageFileData, type CommandActionData, type ConcurrencyLimitOptions, ConditionalRequestInput, ConditionalRequestOutcome, ConfigIssue, ConfigKey, ConfigKeyRegistry, ConfigModuleEntry, ConfigName, ConfigOf, ConfigRegistry, ConfigSchema, ConfigSchemaOptions, ConfigSpecialHandlers, ConflictError, Connector, ConnectorBuildContext, ConnectorBuildContribution, ConnectorBuildGenerateResult, ConnectorEsbuildPatch, ConnectorLifecyclePhase, ConnectorName, ConnectorPriority, ConnectorsManager, ConsoleChannel, ContainerTypes, CookieJarUnavailableError, CookieOptions, CspConfig, CsrfOriginCheckReason, CsrfOriginVerdict, CursorPaginationOptions, CursorPaginationResult, DEFAULT_CSP_DIRECTIVES, DEFAULT_POSTMAN_BASE_URL, DOSpacesDriver, DatabaseCacheDriver, type DatabaseCacheOptions, DatabaseConnector, DatabaseLog, DatabaseLogModel, DatabaseLogOptions, DecodedAccessToken, DefineResourceOptions, DeleteManyResult, DetectedImageFormat, type DevelopmentAppModuleEntry, type DevelopmentAppModules, type DevelopmentModelModuleEntry, type DevelopmentModelModuleState, type DevelopmentModelModules, DevelopmentPostmanResult, ERROR_CODES, ERROR_CODES_DOCS_URL, EncryptionConfigurations, EncryptionPasswordConfigurations, EntityTag, Environment, ErrorCodeArea, ErrorCodeCategory, ErrorCodeDefinition, EventSubscription, ExistsExceptCurrentIdRuleOptions, ExistsExceptCurrentUserRuleOptions, FastifyInstance, FieldOutput, FileNamingStrategy, FileValidationOptions, FileValidator, FileVisibility, FilterFunction, FilterOperator, FilterOptions, FilterRule, FilterRules, ForbiddenError, GenerateImageVariantsOptions, GeneratedImageDescriptor, GeneratedImageVariant, GroupByFields, GroupedRoutesOptions, HealthCheck, HealthStatus, HeraldConnector, HttpConfigurations, HttpConnector, HttpContext, HttpError, HttpErrorCodes, type HttpErrorMapper, type HttpErrorMapping, HttpLoggingConfig, HttpReadyReport, HttpServerOptions, HttpServerRebuiltListener, HttpTracingConfig, type IdempotencyOptions, IdsSource, Image, ImageFormat, ImageInput, ImageTransformCallback, ImageTransformConfig, ImageTransformOptions, ImageVariantDefinition, ImageVariantFit, ImageVariantOutputFormat, ImageVariantsConfigError, InvalidConfigError, InvalidCspDirectiveError, type IpFilterOptions, JavaScriptRuntime, JavaScriptRuntimeName, ListOptions, LocalDriver, LocalStorageDriverOptions, LocaleDictionaryEntries, LocaleDictionaryError, LocalizedObject, LogConfigurations, LoggerConnector, MAIL_EVENTS, Mail, type MailAddress, type MailAttachment, type MailConfigurations, MailError, type MailErrorCode, type MailEvents, type MailMode, type MailOptions, type MailPriority, type MailResult, MailerConnector, type MailersConfig, type MaintenanceOptions, Middleware, MiddlewareResponse, MimeTypes, ModelResourceRegistry, NULLABLE_RESOURCE, NamedApiRoute, NamedApiRoutesOptions, NoopChannel, type NormalizedMail, NotAcceptableError, NotAllowedError, NotificationsConnector, NullableResource, NullableResourceTarget, OPENAPI_JSON_SCHEMA_DIALECT, OpenApiBuildResult, OpenApiComponents, OpenApiContext, OpenApiDocument, OpenApiOperation, OpenApiParameter, OpenApiRequestBody, OpenApiResponse, OpenApiRouteInput, OpenApiSchema, OpenApiSecurityRequirement, OpenApiSecurityScheme, OpenApiValidationResponseConfig, POSTMAN_COLLECTION_SCHEMA, PaginationMode, PaginationResult, ParsedLocaleDictionary, PartialMiddleware, PartialPick, Path, PipeableReactStream, PipelineOptions, PortInUseError, PositionalHandlerSuspect, PostmanAuth, PostmanAuthEntry, PostmanBody, PostmanCollection, PostmanCollectionOptions, PostmanFolder, PostmanFormParam, PostmanHeader, PostmanItem, PostmanOriginalRequest, PostmanQueryParam, PostmanRequest, PostmanRequestItem, PostmanResponse, PostmanUrl, PostmanVariable, PrefixConfig, PrefixOptions, PresignedOptions, PresignedUploadOptions, PrivateRequestLoggingRule, PurgeImageVariantsOptions, PutDirectoryOptions, PutDirectoryResult, PutFromUrlOptions, PutOptions, QueryBuilderContract, Queue, R2Driver, R2StorageDriverOptions, type RateLimitOptions, RegisterConfiguredConnectorsOptions, RegisterResource, RegisteredUseCase, RepositoryAdapterContract, RepositoryConfigurations, RepositoryEvent, RepositoryManager, RepositoryOptions, RepositoryOptionsWithCursor, RepositoryOptionsWithPages, Request, RequestContextStore, RequestController, RequestControllerContract, RequestEvent, RequestHandler, RequestHandlerType, RequestHandlerValidation, RequestLocals, RequestLog, RequestLogSnapshot, RequestLogSource, RequestLoggingOptions, RequestMethod, RequestTranslator, ResolveImageVariantInput, type ResolvedCLICommandOption, ResolvedImageVariant, ResolvedImageVariantsConfig, Resource, ResourceArraySchema, ResourceCastType, ResourceConstructor, ResourceContract, ResourceFieldBuilder, ResourceFieldBuilderDateOutputOptions, ResourceFieldConfig, ResourceMethod, ResourceNotFoundError, ResourceOutput, ResourceOutputOf, ResourceOutputValueCastType, ResourceSchema, ResourceSelfReference, Response, ResponseBodyOutput, ResponseBodyValue, ResponseEvent, ResponseSSEController, ResponseSSEMessageOptions, ResponseSSEOptions, ResponseSchema, ResponseSchemaOutput, ResponseStatus, ResponseStreamController, ResponseStreamOptions, Restful, RestfulMiddleware, ReturnedResponse, Route, RouteNameTakenError, RouteOptions, RouteRateLimitOptions, RouteRegistry, RouteResource, Router, RouterGroupCallback, RouterStacks, RuntimeStrategy, S3Driver, type SESConfigurations, type SMTPConfigurations, SUPPORTED_RUNTIMES_DOCS_URL, SafeFetchOptions, SafeFetchResult, SafeRedirectOptions, SaveAsOptions, SaveMode, SaveOptions, ScopedStorage, ScopedStorageContract, SeedClock, SeedContext, SeedRecordRef, SeedResult, Seeder, SeederDependencyCycleError, SeederMetadata, SendBufferOptions, SendFileOptions, Serialized, SerializedWire, ServerError, ShutdownListener, SocketAdapterFactory, SocketConnector, SocketOptions, StaticMountOptions, Storage, StorageCapabilityError, StorageConfigurations, StorageConnector, StorageCopyEventPayload, StorageDriverConfig, StorageDriverContextStore, StorageDriverContract, StorageDriverName, StorageDriverRegistry, StorageDriverType, StorageError, StorageErrorOptions, StorageEventHandler, StorageEventPayload, StorageEventType, StorageFile, StorageFileData, StorageFileInfo, StorageManagerContract, StorageNotInitializedError, StoragePutEventPayload, StreamReactResponseOptions, TemporaryTokenError, TemporaryTokenPayload, TemporaryTokenValidation, TracingContext, TracingContextSource, TracingHooks, TracingPhaseInfo, TracingRequestEndInfo, Track, TrackableModel, TypedAllRepositoryOptions, TypedRepositoryOptions, TypedRepositoryOptionsWithCursor, TypedRepositoryOptionsWithPages, UPDATE_MANY_BATCH_SIZE, UPLOADS_DEFAULTS, URL_CREDENTIAL_PARAMS, UnAuthorizedError, UniqueExceptCurrentIdRuleOptions, UniqueExceptCurrentUserRuleOptions, UnknownSeederDependencyError, UploadedFile, UploadedFileControllerOptions, UploadedFileImageOptions, UploadedFileJson, UploadedFileQuery, UploadsConfigurations, UploadsImagesConfigurations, UseCase, UseCaseAfterMiddleware, UseCaseBeforeMiddleware, UseCaseBroadcastChannel, UseCaseBroadcastEvent, UseCaseBroadcastOption, UseCaseConfigurations, UseCaseContext, UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseGuard, UseCaseHandler, UseCaseOnExecutingContext, UseCaseResult, UseCaseRuntimeOptions, UseCaseWithSchema, ValidationConfiguration, ValidationFailureContext, ValidationFailureHandler, ValidationFailureResponse, ValidationResponseConfiguration, VariantOutputFormat, VariantSourceFormat, WarlockConfig, WarlockConfigManager, WarlockError, WarlockErrorCode, WarningSink, WatermarkConfig, WhereOperator, XMLable, addUseCaseHistory, anyMatch, app, appLog, appPath, applyCspHeader, assertConfiguredHttpPortIsFree, assertMailCount, assertMailSent, assertNoReservedConnectorNames, assertNodeOnlyCommand, assertPortIsAvailable, assertSitesRequireWebRole, assertUniqueConnectorNames, assertValidConfigModules, assetsUrl, beginHttpDrain, bootstrap, broadcastUseCaseResult, buildCspHeaderValue, buildIdempotencyCacheKey, buildOpenApiDocument, buildRequestLogSnapshot, buildTracingContext, cachePath, captureMail, clearPositionalHandlerSuspects, clearTestMailbox, clock, closeAllMailers, closeMailer, closeServerWithTimeout, colors, command, config, configPath, configSpecialHandlers, connectorsManager, container, createHttpApplication, createRequestStore, createUploadedFileController, decrypt, defaultHttpConfigurations, defineConfig, defineConfigSchema, defineResource, deriveTraceId, describeJavaScriptRuntime, describePositionalHandlerSuspect, detectJavaScriptRuntime, dispatchPhase, dispatchRequestEnd, dispatchRequestStart, displayEnvironmentMode, encrypt, ensureFatalIsVisible, env, environment, errorCodeDocsUrl, errorCodeOf, escapeHeaderValue, evaluateConditionalRequest, exampleFromSchema, existsExceptCurrentIdRule, existsExceptCurrentUserRule, explainErrorCode, fetchLatestVersion, fileExtensionRule, fileRule, fileTypeRule, findMailsBySubject, findMailsTo, fireLifecycleEvent, forgetPositionalHandlerSuspects, formatConfigIssues, generateImageVariants, generateMailId, getDefaultMailConfig, getDevelopmentOpenApiDocument, getDevelopmentPostmanCollection, getExplicitMailMode, getHttpReadyReport, getHttpServer, getLastMail, getLocalized, getMailEventName, getMailMode, getMailboxSize, getMailer, getMailerConfig, getMimeType, getPoolStats, getPublicUrl, getRoles, getSites, getSocketServer, getTestMailbox, getUseCase, getUseCaseHistory, getUseCases, globalEventsCallbacksMap, globalUseCasesEvents, hasRole, hashBody, hashPassword, health, hmacHash, httpConfig, ids, imageRule, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls, inspectHandlerSignature, ipMatches, isAllowedCsrfOrigin, isAuthGuardMiddleware, isBootSignal, isConfigSchema, isDevelopmentMode, isNewerVersion, isNullableResource, isPortAvailable, isPrivateOrReservedIp, isProductionMode, isSafeRedirect, isTestMode, isTracingEnabled, isUnguardedMutatingRoute, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, isValidIdempotencyKey, isWarlockErrorCode, listPositionalHandlerSuspects, loadS3, logResponse, logsPath, looksLikePositionalHandler, mailEvents, markAuthGuard, matchesDerivedRouteName, matchesIfMatch, matchesIfNoneMatch, measure, mergeCspDirectives, middleware, nodeOnlyCommandError, normalizeOrigin, normalizeRequestPath, normalizeRoutePath, notifyHttpServerRebuilt, nullable, onHttpServerRebuilt, openApiToPostmanCollection, originOf, ownOrigin, parseEntityTag, parseEntityTagList, parseLocaleDictionary, parseRoles, parseSites, parseSize, parseTraceparentTraceId, paths, preflightConfiguredHttpPort, promiseAllObject, publicPath, publicUrl, purgeImageVariants, redactQueryCredentials, redactUrlCredentials, registerAppConfig, registerConfiguredConnectors, registerDevelopmentOpenApiProvider, registerGroupedTranslationKeys, registerHttpPlugins, registerLocaleDictionary, registerTracingHooks, remedyLines, renderReact, renderReactMail, reportPositionalHandlerSuspects, reportUnguardedMutatingRoutes, requestContext, requestMemo, requiresDefaultCsrfGuard, resetHttpReadyReport, resetMailConfig, resetMailMode, resetRolesCacheForTests, resetTracingConfigForTests, resetUnguardedRouteReports, resolveCspConfig, resolveCsrfOriginVerdict, resolveImageVariant, resolveMailConfig, resolvePublicRoot, resolveRequestLoggingOptions, resolveTracingConfig, resolveWithinRoot, rootPath, routeNameMethodSuffix, router, runDefaultCsrfGuard, runPipeline, safeFetchToBuffer, safeRedirect, sanitizePath, seeder, sendBootSignal, sendMail, serializeCspDirectives, servesHttp, setBaseUrl, setClockSource, setConfig, setEnvironment, setHttpReadyReport, setIdsSource, setLogConfigurations, setMailConfigurations, setMailMode, shouldPreflightHttpPort, sleep, sluggable, srcPath, startHttpServer, stopHttpApplication, storage, storageConfig, storageConfigurations, storageDriverContext, storagePath, streamReactResponse, strongEntityTagMatch, t, tempPath, toJson, toSingleLineSseField, trackConnectionsForDrain, uniqueExceptCurrentIdRule, uniqueExceptCurrentUserRule, unregisterLocaleDictionary, unverifiedBuildRuntimeNotice, uploadedFileController, uploadedFileMetadataSchema, uploadsConfig, uploadsPath, uploadsUrl, url, useCase, useComputedModel, useComputedSlug, useCurrentUser, useHashedPassword, useRequest, useRequestStore, validateConfigValue, validateCspConfigAtBoot, validateCspDirectives, verifyMailer, verifyPassword, warlockConfigManager, warlockPath, wasMailSentTo, wasMailSentWithSubject, weakEntityTagMatch, wrapResponseInDataKey };
 import "./config/types.mjs";
 import "./http/request.mjs";
 import "./http/serialized.mjs";

package/esm/index.mjs

@@ -1,19 +1,23 @@
 import { config } from "./config/config-getter.mjs";
 import { ConfigSpecialHandlers, configSpecialHandlers } from "./config/config-special-handlers.mjs";
 import { registerAppConfig } from "./config/config-handlers.mjs";
+import { InvalidConfigError, assertValidConfigModules, defineConfigSchema, formatConfigIssues, isConfigSchema, validateConfigValue } from "./config/config-schema.mjs";
 import { setConfig } from "./config/config-setter.mjs";
 import "./config/index.mjs";
 import { appLog } from "./utils/app-log.mjs";
+import { clock, setClockSource } from "./utils/clock.mjs";
 import { DatabaseLogModel } from "./database/models/database-log/database-log.mjs";
 import { DatabaseLog } from "./utils/database-log.mjs";
 import { environment, setEnvironment } from "./utils/environment.mjs";
 import { requestContext, useCurrentUser, useRequest, useRequestStore } from "./http/context/request-context.mjs";
 import { getLocalized } from "./utils/get-localized.mjs";
+import { ids, setIdsSource } from "./utils/ids.mjs";
 import { Path } from "./utils/normalized-path.mjs";
 import { fetchLatestVersion } from "./utils/npm-registry.mjs";
 import { appPath, cachePath, configPath, logsPath, paths, publicPath, rootPath, sanitizePath, srcPath, storagePath, tempPath, uploadsPath, warlockPath } from "./utils/paths.mjs";
 import { promiseAllObject } from "./utils/promise-all-object.mjs";
 import { Queue } from "./utils/queue.mjs";
+import { SUPPORTED_RUNTIMES_DOCS_URL, assertNodeOnlyCommand, describeJavaScriptRuntime, detectJavaScriptRuntime, nodeOnlyCommandError, unverifiedBuildRuntimeNotice } from "./utils/runtime.mjs";
 import { sleep } from "./utils/sleep.mjs";
 import { sluggable } from "./utils/sluggable.mjs";
 import { toJson } from "./utils/to-json.mjs";
@@ -28,11 +32,14 @@ import { BadRequestError, ConflictError, CookieJarUnavailableError, ForbiddenErr
 import { deriveTraceId, parseTraceparentTraceId } from "./http/tracing/trace-id.mjs";
 import { buildTracingContext, dispatchPhase, dispatchRequestEnd, dispatchRequestStart, isTracingEnabled, registerTracingHooks, resetTracingConfigForTests, resolveTracingConfig } from "./http/tracing/tracing-dispatcher.mjs";
 import { createRequestStore, t } from "./http/middleware/inject-request-context.mjs";
+import { evaluateConditionalRequest, matchesIfMatch, matchesIfNoneMatch, parseEntityTag, parseEntityTagList, strongEntityTagMatch, weakEntityTagMatch } from "./http/conditional-request.mjs";
 import { defaultHttpConfigurations, httpConfig } from "./http/config.mjs";
 import { normalizeRoutePath } from "./router/normalize-route-path.mjs";
 import { normalizeRequestPath } from "./router/normalize-request-path.mjs";
 import { clearPositionalHandlerSuspects, describePositionalHandlerSuspect, forgetPositionalHandlerSuspects, inspectHandlerSignature, listPositionalHandlerSuspects, looksLikePositionalHandler, reportPositionalHandlerSuspects } from "./router/positional-handler-diagnostics.mjs";
 import { matchesDerivedRouteName, routeNameMethodSuffix } from "./router/route-name-method-suffix.mjs";
+import { WarlockError } from "./errors/warlock-error.mjs";
+import { RouteNameTakenError } from "./router/route-name-taken-error.mjs";
 import { RouteRegistry } from "./router/route-registry.mjs";
 import { container } from "./container/index.mjs";
 import { BOOT_SIGNAL_ENV_KEY, BOOT_SIGNAL_VERSION, isBootSignal, sendBootSignal } from "./application/boot-signal.mjs";
@@ -50,6 +57,7 @@ import { storageDriverContext } from "./storage/context/storage-driver-context.m
 import { MimeTypes, getMimeType } from "./storage/utils/mime.mjs";
 import { CloudDriver, loadS3 } from "./storage/drivers/cloud-driver.mjs";
 import { DOSpacesDriver } from "./storage/drivers/do-spaces-driver.mjs";
+import { ImageVariantsConfigError } from "./http/uploads/image-variants-config-error.mjs";
 import { UPLOADS_DEFAULTS, uploadsConfig } from "./http/uploads-config.mjs";
 import { resolveWithinRoot } from "./storage/utils/contain-path.mjs";
 import { LocalDriver } from "./storage/drivers/local-driver.mjs";
@@ -65,6 +73,7 @@ import "./image/index.mjs";
 import { UploadedFile } from "./http/uploaded-file.mjs";
 import { URL_CREDENTIAL_PARAMS, buildRequestLogSnapshot, redactQueryCredentials, redactUrlCredentials, resolveRequestLoggingOptions } from "./http/request-log-snapshot.mjs";
 import { Request } from "./http/request.mjs";
+import { AUTH_GUARD_MARKER, isAuthGuardMiddleware, isUnguardedMutatingRoute, markAuthGuard, reportUnguardedMutatingRoutes, resetUnguardedRouteReports } from "./router/unguarded-route-diagnostics.mjs";
 import { Router, router } from "./router/router.mjs";
 import "./router/index.mjs";
 import { registerHttpPlugins, resolvePublicRoot } from "./http/plugins.mjs";
@@ -77,7 +86,6 @@ import { getPublicUrl } from "./application/public-url.mjs";
 import "./application/index.mjs";
 import { health } from "./http/health.mjs";
 import { RequestController } from "./http/request-controller.mjs";
-import { ImageVariantsConfigError } from "./http/uploads/image-variants-config-error.mjs";
 import { generateImageVariants } from "./http/uploads/generate-image-variants.mjs";
 import { purgeImageVariants } from "./http/uploads/purge-image-variants.mjs";
 import { resolveImageVariant } from "./http/uploads/resolve-image-variant.mjs";
@@ -90,6 +98,8 @@ import { PortInUseError, assertPortIsAvailable, isPortAvailable } from "./http/p
 import { assertConfiguredHttpPortIsFree, preflightConfiguredHttpPort, remedyLines, shouldPreflightHttpPort } from "./http/boot-port-preflight.mjs";
 import { getHttpReadyReport, resetHttpReadyReport, setHttpReadyReport } from "./http/ready-report.mjs";
 import { notifyHttpServerRebuilt, onHttpServerRebuilt } from "./http/server-rebuilt.mjs";
+import { escapeHeaderValue } from "./http/escape-header-value.mjs";
+import { isSafeRedirect, safeRedirect } from "./http/safe-redirect.mjs";
 import { requestMemo } from "./http/context/request-memo.mjs";
 import "./http/index.mjs";
 import { existsExceptCurrentIdRule } from "./validation/database/exists-except-current-id.mjs";
@@ -123,7 +133,7 @@ import { HttpConnector } from "./connectors/http-connector.mjs";
 import { setLogConfigurations } from "./logger/logger.mjs";
 import "./logger/index.mjs";
 import { LoggerConnector } from "./connectors/logger-connector.mjs";
-import { getDefaultMailConfig, getMailMode, getMailerConfig, isDevelopmentMode, isProductionMode, isTestMode, resetMailConfig, resolveMailConfig, setMailConfigurations, setMailMode } from "./mail/config.mjs";
+import { getDefaultMailConfig, getExplicitMailMode, getMailMode, getMailerConfig, isDevelopmentMode, isProductionMode, isTestMode, resetMailConfig, resetMailMode, resolveMailConfig, setMailConfigurations, setMailMode } from "./mail/config.mjs";
 import { MAIL_EVENTS, generateMailId, getMailEventName, mailEvents } from "./mail/events.mjs";
 import { closeAllMailers, closeMailer, getMailer, getPoolStats, verifyMailer } from "./mail/mailer-pool.mjs";
 import { renderReactMail } from "./mail/react-mail.mjs";
@@ -150,6 +160,7 @@ import "./database/index.mjs";
 import { decrypt, encrypt } from "./encryption/encrypt.mjs";
 import { hmacHash } from "./encryption/hash.mjs";
 import "./encryption/index.mjs";
+import { ERROR_CODES, ERROR_CODES_DOCS_URL, errorCodeDocsUrl, errorCodeOf, explainErrorCode, isWarlockErrorCode } from "./errors/error-codes.mjs";
 import { LocaleDictionaryError, parseLocaleDictionary } from "./localization/parse-locale-dictionary.mjs";
 import { registerGroupedTranslationKeys, registerLocaleDictionary, unregisterLocaleDictionary } from "./localization/register-locale-dictionary.mjs";
 import "./localization/index.mjs";
@@ -187,4 +198,4 @@ import { colors } from "@mongez/copper";
 
 export * from "@mongez/localization"
 
-export { $registerUseCase, $unregisterUseCase, APP_ROLES, AccessConnector, AiConnector, Application, BOOT_SIGNAL_ENV_KEY, BOOT_SIGNAL_VERSION, BadRequestError, BadSchemaUseCaseError, BaseConnector, BenchmarkProfiler, BenchmarkSnapshots, CLICommand, CacheConnector, CascadeAdapter, CascadeQueryBuilder, CloudDriver, ConfigSpecialHandlers, ConflictError, ConnectorLifecyclePhase, ConnectorPriority, ConnectorsManager, ConsoleChannel, CookieJarUnavailableError, DEFAULT_CSP_DIRECTIVES, DEFAULT_POSTMAN_BASE_URL, DOSpacesDriver, DatabaseCacheDriver, DatabaseConnector, DatabaseLog, DatabaseLogModel, FileValidator, ForbiddenError, HeraldConnector, HttpConnector, HttpError, HttpErrorCodes, Image, ImageVariantsConfigError, InvalidCspDirectiveError, LocalDriver, LocaleDictionaryError, LoggerConnector, MAIL_EVENTS, Mail, MailError, MailerConnector, MimeTypes, NULLABLE_RESOURCE, NoopChannel, NotAcceptableError, NotAllowedError, NotificationsConnector, OPENAPI_JSON_SCHEMA_DIALECT, POSTMAN_COLLECTION_SCHEMA, Path, PortInUseError, Queue, R2Driver, RegisterResource, RepositoryManager, Request, RequestController, RequestLog, Resource, ResourceFieldBuilder, ResourceNotFoundError, Response, ResponseStatus, Restful, RouteRegistry, Router, S3Driver, ScopedStorage, SeederDependencyCycleError, ServerError, SocketConnector, Storage, StorageCapabilityError, StorageConnector, StorageError, StorageFile, StorageNotInitializedError, UPDATE_MANY_BATCH_SIZE, UPLOADS_DEFAULTS, URL_CREDENTIAL_PARAMS, UnAuthorizedError, UnknownSeederDependencyError, UploadedFile, WarlockConfigManager, addUseCaseHistory, anyMatch, app, appLog, appPath, applyCspHeader, assertConfiguredHttpPortIsFree, assertMailCount, assertMailSent, assertNoReservedConnectorNames, assertPortIsAvailable, assertSitesRequireWebRole, assertUniqueConnectorNames, assetsUrl, beginHttpDrain, bootstrap, broadcastUseCaseResult, buildCspHeaderValue, buildIdempotencyCacheKey, buildOpenApiDocument, buildRequestLogSnapshot, buildTracingContext, cachePath, captureMail, clearPositionalHandlerSuspects, clearTestMailbox, closeAllMailers, closeMailer, closeServerWithTimeout, colors, command, config, configPath, configSpecialHandlers, connectorsManager, container, createHttpApplication, createRequestStore, createUploadedFileController, decrypt, defaultHttpConfigurations, defineConfig, defineResource, deriveTraceId, describePositionalHandlerSuspect, dispatchPhase, dispatchRequestEnd, dispatchRequestStart, displayEnvironmentMode, encrypt, ensureFatalIsVisible, env, environment, exampleFromSchema, existsExceptCurrentIdRule, existsExceptCurrentUserRule, fetchLatestVersion, fileExtensionRule, fileRule, fileTypeRule, findMailsBySubject, findMailsTo, fireLifecycleEvent, forgetPositionalHandlerSuspects, generateImageVariants, generateMailId, getDefaultMailConfig, getDevelopmentOpenApiDocument, getDevelopmentPostmanCollection, getHttpReadyReport, getHttpServer, getLastMail, getLocalized, getMailEventName, getMailMode, getMailboxSize, getMailer, getMailerConfig, getMimeType, getPoolStats, getPublicUrl, getRoles, getSites, getSocketServer, getTestMailbox, getUseCase, getUseCaseHistory, getUseCases, globalEventsCallbacksMap, globalUseCasesEvents, hasRole, hashBody, hashPassword, health, hmacHash, httpConfig, imageRule, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls, inspectHandlerSignature, ipMatches, isAllowedCsrfOrigin, isBootSignal, isDevelopmentMode, isNewerVersion, isNullableResource, isPortAvailable, isPrivateOrReservedIp, isProductionMode, isTestMode, isTracingEnabled, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, isValidIdempotencyKey, listPositionalHandlerSuspects, loadS3, logResponse, logsPath, looksLikePositionalHandler, mailEvents, matchesDerivedRouteName, measure, mergeCspDirectives, middleware, normalizeOrigin, normalizeRequestPath, normalizeRoutePath, notifyHttpServerRebuilt, nullable, onHttpServerRebuilt, openApiToPostmanCollection, originOf, ownOrigin, parseLocaleDictionary, parseRoles, parseSites, parseSize, parseTraceparentTraceId, paths, preflightConfiguredHttpPort, promiseAllObject, publicPath, publicUrl, purgeImageVariants, redactQueryCredentials, redactUrlCredentials, registerAppConfig, registerConfiguredConnectors, registerDevelopmentOpenApiProvider, registerGroupedTranslationKeys, registerHttpPlugins, registerLocaleDictionary, registerTracingHooks, remedyLines, renderReact, renderReactMail, reportPositionalHandlerSuspects, requestContext, requestMemo, requiresDefaultCsrfGuard, resetHttpReadyReport, resetMailConfig, resetRolesCacheForTests, resetTracingConfigForTests, resolveCspConfig, resolveCsrfOriginVerdict, resolveImageVariant, resolveMailConfig, resolvePublicRoot, resolveRequestLoggingOptions, resolveTracingConfig, resolveWithinRoot, rootPath, routeNameMethodSuffix, router, runDefaultCsrfGuard, runPipeline, safeFetchToBuffer, sanitizePath, seeder, sendBootSignal, sendMail, serializeCspDirectives, servesHttp, setBaseUrl, setConfig, setEnvironment, setHttpReadyReport, setLogConfigurations, setMailConfigurations, setMailMode, shouldPreflightHttpPort, sleep, sluggable, srcPath, startHttpServer, stopHttpApplication, storage, storageConfig, storageConfigurations, storageDriverContext, storagePath, streamReactResponse, t, tempPath, toJson, toSingleLineSseField, trackConnectionsForDrain, uniqueExceptCurrentIdRule, uniqueExceptCurrentUserRule, unregisterLocaleDictionary, uploadedFileController, uploadedFileMetadataSchema, uploadsConfig, uploadsPath, uploadsUrl, url, useCase, useComputedModel, useComputedSlug, useCurrentUser, useHashedPassword, useRequest, useRequestStore, validateCspConfigAtBoot, validateCspDirectives, verifyMailer, verifyPassword, warlockConfigManager, warlockPath, wasMailSentTo, wasMailSentWithSubject, wrapResponseInDataKey };
+export { $registerUseCase, $unregisterUseCase, APP_ROLES, AUTH_GUARD_MARKER, AccessConnector, AiConnector, Application, BOOT_SIGNAL_ENV_KEY, BOOT_SIGNAL_VERSION, BadRequestError, BadSchemaUseCaseError, BaseConnector, BenchmarkProfiler, BenchmarkSnapshots, CLICommand, CacheConnector, CascadeAdapter, CascadeQueryBuilder, CloudDriver, ConfigSpecialHandlers, ConflictError, ConnectorLifecyclePhase, ConnectorPriority, ConnectorsManager, ConsoleChannel, CookieJarUnavailableError, DEFAULT_CSP_DIRECTIVES, DEFAULT_POSTMAN_BASE_URL, DOSpacesDriver, DatabaseCacheDriver, DatabaseConnector, DatabaseLog, DatabaseLogModel, ERROR_CODES, ERROR_CODES_DOCS_URL, FileValidator, ForbiddenError, HeraldConnector, HttpConnector, HttpError, HttpErrorCodes, Image, ImageVariantsConfigError, InvalidConfigError, InvalidCspDirectiveError, LocalDriver, LocaleDictionaryError, LoggerConnector, MAIL_EVENTS, Mail, MailError, MailerConnector, MimeTypes, NULLABLE_RESOURCE, NoopChannel, NotAcceptableError, NotAllowedError, NotificationsConnector, OPENAPI_JSON_SCHEMA_DIALECT, POSTMAN_COLLECTION_SCHEMA, Path, PortInUseError, Queue, R2Driver, RegisterResource, RepositoryManager, Request, RequestController, RequestLog, Resource, ResourceFieldBuilder, ResourceNotFoundError, Response, ResponseStatus, Restful, RouteNameTakenError, RouteRegistry, Router, S3Driver, SUPPORTED_RUNTIMES_DOCS_URL, ScopedStorage, SeederDependencyCycleError, ServerError, SocketConnector, Storage, StorageCapabilityError, StorageConnector, StorageError, StorageFile, StorageNotInitializedError, UPDATE_MANY_BATCH_SIZE, UPLOADS_DEFAULTS, URL_CREDENTIAL_PARAMS, UnAuthorizedError, UnknownSeederDependencyError, UploadedFile, WarlockConfigManager, WarlockError, addUseCaseHistory, anyMatch, app, appLog, appPath, applyCspHeader, assertConfiguredHttpPortIsFree, assertMailCount, assertMailSent, assertNoReservedConnectorNames, assertNodeOnlyCommand, assertPortIsAvailable, assertSitesRequireWebRole, assertUniqueConnectorNames, assertValidConfigModules, assetsUrl, beginHttpDrain, bootstrap, broadcastUseCaseResult, buildCspHeaderValue, buildIdempotencyCacheKey, buildOpenApiDocument, buildRequestLogSnapshot, buildTracingContext, cachePath, captureMail, clearPositionalHandlerSuspects, clearTestMailbox, clock, closeAllMailers, closeMailer, closeServerWithTimeout, colors, command, config, configPath, configSpecialHandlers, connectorsManager, container, createHttpApplication, createRequestStore, createUploadedFileController, decrypt, defaultHttpConfigurations, defineConfig, defineConfigSchema, defineResource, deriveTraceId, describeJavaScriptRuntime, describePositionalHandlerSuspect, detectJavaScriptRuntime, dispatchPhase, dispatchRequestEnd, dispatchRequestStart, displayEnvironmentMode, encrypt, ensureFatalIsVisible, env, environment, errorCodeDocsUrl, errorCodeOf, escapeHeaderValue, evaluateConditionalRequest, exampleFromSchema, existsExceptCurrentIdRule, existsExceptCurrentUserRule, explainErrorCode, fetchLatestVersion, fileExtensionRule, fileRule, fileTypeRule, findMailsBySubject, findMailsTo, fireLifecycleEvent, forgetPositionalHandlerSuspects, formatConfigIssues, generateImageVariants, generateMailId, getDefaultMailConfig, getDevelopmentOpenApiDocument, getDevelopmentPostmanCollection, getExplicitMailMode, getHttpReadyReport, getHttpServer, getLastMail, getLocalized, getMailEventName, getMailMode, getMailboxSize, getMailer, getMailerConfig, getMimeType, getPoolStats, getPublicUrl, getRoles, getSites, getSocketServer, getTestMailbox, getUseCase, getUseCaseHistory, getUseCases, globalEventsCallbacksMap, globalUseCasesEvents, hasRole, hashBody, hashPassword, health, hmacHash, httpConfig, ids, imageRule, increaseUseCaseFailedCalls, increaseUseCaseSuccessCalls, inspectHandlerSignature, ipMatches, isAllowedCsrfOrigin, isAuthGuardMiddleware, isBootSignal, isConfigSchema, isDevelopmentMode, isNewerVersion, isNullableResource, isPortAvailable, isPrivateOrReservedIp, isProductionMode, isSafeRedirect, isTestMode, isTracingEnabled, isUnguardedMutatingRoute, isUnknownTsExtensionError, isUnresolvedConfigImportError, isUnsupportedTypeStrippingError, isValidIdempotencyKey, isWarlockErrorCode, listPositionalHandlerSuspects, loadS3, logResponse, logsPath, looksLikePositionalHandler, mailEvents, markAuthGuard, matchesDerivedRouteName, matchesIfMatch, matchesIfNoneMatch, measure, mergeCspDirectives, middleware, nodeOnlyCommandError, normalizeOrigin, normalizeRequestPath, normalizeRoutePath, notifyHttpServerRebuilt, nullable, onHttpServerRebuilt, openApiToPostmanCollection, originOf, ownOrigin, parseEntityTag, parseEntityTagList, parseLocaleDictionary, parseRoles, parseSites, parseSize, parseTraceparentTraceId, paths, preflightConfiguredHttpPort, promiseAllObject, publicPath, publicUrl, purgeImageVariants, redactQueryCredentials, redactUrlCredentials, registerAppConfig, registerConfiguredConnectors, registerDevelopmentOpenApiProvider, registerGroupedTranslationKeys, registerHttpPlugins, registerLocaleDictionary, registerTracingHooks, remedyLines, renderReact, renderReactMail, reportPositionalHandlerSuspects, reportUnguardedMutatingRoutes, requestContext, requestMemo, requiresDefaultCsrfGuard, resetHttpReadyReport, resetMailConfig, resetMailMode, resetRolesCacheForTests, resetTracingConfigForTests, resetUnguardedRouteReports, resolveCspConfig, resolveCsrfOriginVerdict, resolveImageVariant, resolveMailConfig, resolvePublicRoot, resolveRequestLoggingOptions, resolveTracingConfig, resolveWithinRoot, rootPath, routeNameMethodSuffix, router, runDefaultCsrfGuard, runPipeline, safeFetchToBuffer, safeRedirect, sanitizePath, seeder, sendBootSignal, sendMail, serializeCspDirectives, servesHttp, setBaseUrl, setClockSource, setConfig, setEnvironment, setHttpReadyReport, setIdsSource, setLogConfigurations, setMailConfigurations, setMailMode, shouldPreflightHttpPort, sleep, sluggable, srcPath, startHttpServer, stopHttpApplication, storage, storageConfig, storageConfigurations, storageDriverContext, storagePath, streamReactResponse, strongEntityTagMatch, t, tempPath, toJson, toSingleLineSseField, trackConnectionsForDrain, uniqueExceptCurrentIdRule, uniqueExceptCurrentUserRule, unregisterLocaleDictionary, unverifiedBuildRuntimeNotice, uploadedFileController, uploadedFileMetadataSchema, uploadsConfig, uploadsPath, uploadsUrl, url, useCase, useComputedModel, useComputedSlug, useCurrentUser, useHashedPassword, useRequest, useRequestStore, validateConfigValue, validateCspConfigAtBoot, validateCspDirectives, verifyMailer, verifyPassword, warlockConfigManager, warlockPath, wasMailSentTo, wasMailSentWithSubject, weakEntityTagMatch, wrapResponseInDataKey };

package/esm/localization/parse-locale-dictionary.d.mts

@@ -9,6 +9,8 @@ type ParsedLocaleDictionary = {
 declare class LocaleDictionaryError extends Error {
   readonly sourceFile: string;
   readonly key: string;
+  /** Stable Warlock error code; `warlock explain WL1007` prints the fix. */
+  readonly code = "WL1007";
   constructor(sourceFile: string, key: string, detail: string);
 }
 /** Parses one locale dictionary source without reading the filesystem or loading application code. */

package/esm/localization/parse-locale-dictionary.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-locale-dictionary.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/localization/parse-locale-dictionary.ts"],"mappings":";KAAY,uBAAA,GAA0B,MAAM,SAAS,MAAA;AAAA,KAEzC,sBAAA;EACV,UAAA;EACA,KAAA;EACA,OAAA,EAAS,uBAAuB;AAAA;AAHlC;AAAA,cAca,qBAAA,SAA8B,KAAK;EAAA,SAE5B,UAAA;EAAA,SACA,GAAA;cADA,UAAA,UACA,GAAA,UAChB,MAAA;AAAA;;iBAsOY,qBAAA,CAAsB,KAAA;EACpC,UAAA;EACA,MAAA;EA5OW;;;;;EAkPX,gBAAA;EACA,WAAA;AAAA,IACE,sBAAsB"}
+{"version":3,"file":"parse-locale-dictionary.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/localization/parse-locale-dictionary.ts"],"mappings":";KAAY,uBAAA,GAA0B,MAAM,SAAS,MAAA;AAAA,KAEzC,sBAAA;EACV,UAAA;EACA,KAAA;EACA,OAAA,EAAS,uBAAuB;AAAA;AAHlC;AAAA,cAca,qBAAA,SAA8B,KAAK;EAAA,SAK5B,UAAA;EAAA,SACA,GAAA;EAnBlB;EAAA,SAegB,IAAA;cAGE,UAAA,UACA,GAAA,UAChB,MAAA;AAAA;;iBAsOY,qBAAA,CAAsB,KAAA;EACpC,UAAA;EACA,MAAA;;;;;;EAMA,gBAAA;EACA,WAAA;AAAA,IACE,sBAAsB"}

package/esm/localization/parse-locale-dictionary.mjs

@@ -12,6 +12,7 @@ var LocaleDictionaryError = class extends Error {
 		super(`Cannot parse route locales in "${sourceFile}" at "${key}": ${detail}.`);
 		this.sourceFile = sourceFile;
 		this.key = key;
+		this.code = "WL1007";
 		this.name = "LocaleDictionaryError";
 	}
 };

package/esm/localization/parse-locale-dictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"parse-locale-dictionary.mjs","names":[],"sources":["../../../../../../../../packages/core/src/localization/parse-locale-dictionary.ts"],"sourcesContent":["export type LocaleDictionaryEntries = Record<string, Record<string, string>>;\n\nexport type ParsedLocaleDictionary = {\n  sourceFile: string;\n  group: string;\n  entries: LocaleDictionaryEntries;\n};\n\ntype JsonValue = string | number | boolean | null | JsonObject | JsonValue[];\ntype JsonObject = Map<string, JsonValue>;\n\nconst SEGMENT = /^[A-Za-z_][A-Za-z0-9_-]*$/;\nconst LOCALE_CODE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*$/;\nconst FORBIDDEN_SEGMENTS = new Set([\"__proto__\", \"prototype\", \"constructor\"]);\n\n/** A source error that always names both the locale file and the offending JSON key. */\nexport class LocaleDictionaryError extends Error {\n  public constructor(\n    public readonly sourceFile: string,\n    public readonly key: string,\n    detail: string,\n  ) {\n    super(`Cannot parse route locales in \"${sourceFile}\" at \"${key}\": ${detail}.`);\n    this.name = \"LocaleDictionaryError\";\n  }\n}\n\nfunction fail(sourceFile: string, key: string, detail: string): never {\n  throw new LocaleDictionaryError(sourceFile, key, detail);\n}\n\n/** A deliberately small JSON parser: unlike JSON.parse, it preserves duplicate property names. */\nclass StrictJsonParser {\n  private offset = 0;\n\n  public constructor(\n    private readonly sourceFile: string,\n    private readonly source: string,\n  ) {}\n\n  public parse(): JsonValue {\n    if (this.source.charCodeAt(0) === 0xfeff) this.offset = 1;\n    const value = this.value(\"$\");\n    this.whitespace();\n    if (this.offset !== this.source.length) this.invalid(\"$\", \"unexpected trailing JSON\");\n    return value;\n  }\n\n  private value(key: string): JsonValue {\n    this.whitespace();\n    const character = this.source[this.offset];\n    if (character === \"{\") return this.object(key);\n    if (character === \"[\") return this.array(key);\n    if (character === '\"') return this.string(key);\n    if (this.source.startsWith(\"true\", this.offset)) return this.literal(\"true\", true);\n    if (this.source.startsWith(\"false\", this.offset)) return this.literal(\"false\", false);\n    if (this.source.startsWith(\"null\", this.offset)) return this.literal(\"null\", null);\n    if (character === \"-\" || (character !== undefined && /[0-9]/.test(character)))\n      return this.number(key);\n    this.invalid(key, \"invalid JSON value\");\n  }\n\n  private object(key: string): JsonObject {\n    this.offset++;\n    this.whitespace();\n    const object = new Map<string, JsonValue>();\n    if (this.source[this.offset] === \"}\") {\n      this.offset++;\n      return object;\n    }\n    while (true) {\n      this.whitespace();\n      if (this.source[this.offset] !== '\"') this.invalid(key, \"object keys must be JSON strings\");\n      const property = this.string(key);\n      const propertyKey = `${key}.${property}`;\n      if (object.has(property)) this.invalid(propertyKey, \"duplicate JSON property\");\n      this.whitespace();\n      if (this.source[this.offset] !== \":\")\n        this.invalid(propertyKey, \"expected ':' after object key\");\n      this.offset++;\n      object.set(property, this.value(propertyKey));\n      this.whitespace();\n      const separator = this.source[this.offset];\n      if (separator === \"}\") {\n        this.offset++;\n        return object;\n      }\n      if (separator !== \",\") this.invalid(key, \"expected ',' or '}' in object\");\n      this.offset++;\n    }\n  }\n\n  private array(key: string): JsonValue[] {\n    this.offset++;\n    this.whitespace();\n    const values: JsonValue[] = [];\n    if (this.source[this.offset] === \"]\") {\n      this.offset++;\n      return values;\n    }\n    while (true) {\n      values.push(this.value(key));\n      this.whitespace();\n      const separator = this.source[this.offset];\n      if (separator === \"]\") {\n        this.offset++;\n        return values;\n      }\n      if (separator !== \",\") this.invalid(key, \"expected ',' or ']' in array\");\n      this.offset++;\n    }\n  }\n\n  private string(key: string): string {\n    const start = this.offset++;\n    let escaped = false;\n    while (this.offset < this.source.length) {\n      const character = this.source[this.offset++];\n      if (escaped) {\n        escaped = false;\n        continue;\n      }\n      if (character === \"\\\\\") {\n        escaped = true;\n        continue;\n      }\n      if (character === '\"') {\n        try {\n          return JSON.parse(this.source.slice(start, this.offset)) as string;\n        } catch {\n          this.invalid(key, \"invalid JSON string\");\n        }\n      }\n      if (character !== undefined && character.charCodeAt(0) < 0x20)\n        this.invalid(key, \"unescaped control character in JSON string\");\n    }\n    this.invalid(key, \"unterminated JSON string\");\n  }\n\n  private number(key: string): number {\n    const match = /-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;\n    match.lastIndex = this.offset;\n    const token = match.exec(this.source)?.[0];\n    if (token === undefined) this.invalid(key, \"invalid JSON number\");\n    this.offset += token.length;\n    return Number(token);\n  }\n\n  private literal<T extends boolean | null>(written: string, value: T): T {\n    this.offset += written.length;\n    return value;\n  }\n\n  private whitespace(): void {\n    while (this.offset < this.source.length) {\n      const character = this.source[this.offset];\n      if (character === undefined || !\" \\t\\n\\r\".includes(character)) return;\n      this.offset++;\n    }\n  }\n\n  private invalid(key: string, detail: string): never {\n    fail(this.sourceFile, key, detail);\n  }\n}\n\nfunction assertNamespaceSegment(sourceFile: string, segment: string, key: string): void {\n  if (!SEGMENT.test(segment)) fail(sourceFile, key, \"segments must match [A-Za-z_][A-Za-z0-9_-]*\");\n  if (FORBIDDEN_SEGMENTS.has(segment)) fail(sourceFile, key, \"segments cannot be reserved\");\n}\n\nfunction assertSegment(sourceFile: string, segment: string, key: string): void {\n  if (segment.includes(\".\")) fail(sourceFile, key, \"JSON keys cannot contain '.'\");\n  assertNamespaceSegment(sourceFile, segment, key);\n}\n\nfunction explicitGroup(sourceFile: string, value: string): string {\n  if (value === \"\") fail(sourceFile, \"$group\", \"'$group' cannot be empty\");\n  for (const segment of value.split(\".\")) {\n    if (segment === \"\") fail(sourceFile, \"$group\", \"'$group' cannot contain empty segments\");\n    assertNamespaceSegment(sourceFile, segment, \"$group\");\n  }\n  return value;\n}\n\nfunction defaultGroup(sourceFile: string, defaultNamespace: string | (() => string)): string {\n  const namespace = typeof defaultNamespace === \"function\" ? defaultNamespace() : defaultNamespace;\n\n  return namespace === \"\" ? \"\" : explicitGroup(sourceFile, namespace);\n}\n\nfunction isObject(value: JsonValue): value is JsonObject {\n  return value instanceof Map;\n}\n\nfunction readLeaf(\n  sourceFile: string,\n  key: string,\n  value: JsonObject,\n  localeCodes: readonly string[] | undefined,\n): Record<string, string> {\n  const locales = localeCodes === undefined ? undefined : new Set(localeCodes);\n  const entry: Record<string, string> = Object.create(null) as Record<string, string>;\n  for (const [locale, translation] of value) {\n    if (!LOCALE_CODE.test(locale)) fail(sourceFile, `${key}.${locale}`, \"invalid locale code\");\n    if (typeof translation !== \"string\")\n      fail(sourceFile, `${key}.${locale}`, \"locale values must be strings\");\n    if (locales !== undefined && !locales.has(locale))\n      fail(sourceFile, `${key}.${locale}`, \"unknown locale code\");\n    entry[locale] = translation;\n  }\n  if (localeCodes !== undefined)\n    for (const locale of localeCodes)\n      if (!(locale in entry)) fail(sourceFile, key, `missing locale code \"${locale}\"`);\n  return entry;\n}\n\nfunction collectEntries(\n  sourceFile: string,\n  object: JsonObject,\n  group: string,\n  localeCodes: readonly string[] | undefined,\n  entries: LocaleDictionaryEntries,\n  nested: boolean,\n): void {\n  if (nested && object.size === 0) fail(sourceFile, group, \"nested objects cannot be empty\");\n  for (const [segment, value] of object) {\n    const key = group === \"\" ? segment : `${group}.${segment}`;\n    if (segment === \"$group\") fail(sourceFile, key, \"'$group' is only allowed at the root\");\n    assertSegment(sourceFile, segment, key);\n    if (!isObject(value)) fail(sourceFile, key, \"entries must be locale objects or nested objects\");\n    if (value.has(\"$group\"))\n      fail(sourceFile, `${key}.$group`, \"'$group' is only allowed at the root\");\n    const values = [...value.values()];\n    const hasString = values.some((item) => typeof item === \"string\");\n    const allObjects = values.every(isObject);\n    if (hasString) {\n      if (!values.every((item) => typeof item === \"string\"))\n        fail(sourceFile, key, \"cannot mix locale values with nested entries\");\n      entries[key] = readLeaf(sourceFile, key, value, localeCodes);\n      continue;\n    }\n    if (!allObjects) fail(sourceFile, key, \"cannot mix locale values with nested entries\");\n    if (localeCodes !== undefined && [...value.keys()].some((child) => localeCodes.includes(child)))\n      fail(sourceFile, key, \"cannot mix locale codes with nested entries\");\n    collectEntries(sourceFile, value, key, localeCodes, entries, true);\n  }\n}\n\n/** Parses one locale dictionary source without reading the filesystem or loading application code. */\nexport function parseLocaleDictionary(input: {\n  sourceFile: string;\n  source: string;\n  /**\n   * The group used when the file declares no `$group`. A function is called\n   * only in that case, so a namespace that cannot be derived (e.g. from a\n   * folder name) never fails a file that names its own `$group`.\n   */\n  defaultNamespace: string | (() => string);\n  localeCodes?: readonly string[];\n}): ParsedLocaleDictionary {\n  const { sourceFile, source, defaultNamespace, localeCodes } = input;\n  const parsed = new StrictJsonParser(sourceFile, source).parse();\n  if (!isObject(parsed)) fail(sourceFile, \"$\", \"root JSON value must be an object\");\n  const groupValue = parsed.get(\"$group\");\n  if (groupValue !== undefined && typeof groupValue !== \"string\")\n    fail(sourceFile, \"$group\", \"'$group' must be a string\");\n  const group =\n    groupValue === undefined\n      ? defaultGroup(sourceFile, defaultNamespace)\n      : explicitGroup(sourceFile, groupValue);\n  const entries: LocaleDictionaryEntries = Object.create(null) as LocaleDictionaryEntries;\n  const rootEntries = new Map(parsed);\n  rootEntries.delete(\"$group\");\n  collectEntries(sourceFile, rootEntries, group, localeCodes, entries, false);\n  return { sourceFile, group, entries };\n}\n"],"mappings":"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"}
+{"version":3,"file":"parse-locale-dictionary.mjs","names":[],"sources":["../../../../../../../../packages/core/src/localization/parse-locale-dictionary.ts"],"sourcesContent":["export type LocaleDictionaryEntries = Record<string, Record<string, string>>;\n\nexport type ParsedLocaleDictionary = {\n  sourceFile: string;\n  group: string;\n  entries: LocaleDictionaryEntries;\n};\n\ntype JsonValue = string | number | boolean | null | JsonObject | JsonValue[];\ntype JsonObject = Map<string, JsonValue>;\n\nconst SEGMENT = /^[A-Za-z_][A-Za-z0-9_-]*$/;\nconst LOCALE_CODE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*$/;\nconst FORBIDDEN_SEGMENTS = new Set([\"__proto__\", \"prototype\", \"constructor\"]);\n\n/** A source error that always names both the locale file and the offending JSON key. */\nexport class LocaleDictionaryError extends Error {\n  /** Stable Warlock error code; `warlock explain WL1007` prints the fix. */\n  public readonly code = \"WL1007\";\n\n  public constructor(\n    public readonly sourceFile: string,\n    public readonly key: string,\n    detail: string,\n  ) {\n    super(`Cannot parse route locales in \"${sourceFile}\" at \"${key}\": ${detail}.`);\n    this.name = \"LocaleDictionaryError\";\n  }\n}\n\nfunction fail(sourceFile: string, key: string, detail: string): never {\n  throw new LocaleDictionaryError(sourceFile, key, detail);\n}\n\n/** A deliberately small JSON parser: unlike JSON.parse, it preserves duplicate property names. */\nclass StrictJsonParser {\n  private offset = 0;\n\n  public constructor(\n    private readonly sourceFile: string,\n    private readonly source: string,\n  ) {}\n\n  public parse(): JsonValue {\n    if (this.source.charCodeAt(0) === 0xfeff) this.offset = 1;\n    const value = this.value(\"$\");\n    this.whitespace();\n    if (this.offset !== this.source.length) this.invalid(\"$\", \"unexpected trailing JSON\");\n    return value;\n  }\n\n  private value(key: string): JsonValue {\n    this.whitespace();\n    const character = this.source[this.offset];\n    if (character === \"{\") return this.object(key);\n    if (character === \"[\") return this.array(key);\n    if (character === '\"') return this.string(key);\n    if (this.source.startsWith(\"true\", this.offset)) return this.literal(\"true\", true);\n    if (this.source.startsWith(\"false\", this.offset)) return this.literal(\"false\", false);\n    if (this.source.startsWith(\"null\", this.offset)) return this.literal(\"null\", null);\n    if (character === \"-\" || (character !== undefined && /[0-9]/.test(character)))\n      return this.number(key);\n    this.invalid(key, \"invalid JSON value\");\n  }\n\n  private object(key: string): JsonObject {\n    this.offset++;\n    this.whitespace();\n    const object = new Map<string, JsonValue>();\n    if (this.source[this.offset] === \"}\") {\n      this.offset++;\n      return object;\n    }\n    while (true) {\n      this.whitespace();\n      if (this.source[this.offset] !== '\"') this.invalid(key, \"object keys must be JSON strings\");\n      const property = this.string(key);\n      const propertyKey = `${key}.${property}`;\n      if (object.has(property)) this.invalid(propertyKey, \"duplicate JSON property\");\n      this.whitespace();\n      if (this.source[this.offset] !== \":\")\n        this.invalid(propertyKey, \"expected ':' after object key\");\n      this.offset++;\n      object.set(property, this.value(propertyKey));\n      this.whitespace();\n      const separator = this.source[this.offset];\n      if (separator === \"}\") {\n        this.offset++;\n        return object;\n      }\n      if (separator !== \",\") this.invalid(key, \"expected ',' or '}' in object\");\n      this.offset++;\n    }\n  }\n\n  private array(key: string): JsonValue[] {\n    this.offset++;\n    this.whitespace();\n    const values: JsonValue[] = [];\n    if (this.source[this.offset] === \"]\") {\n      this.offset++;\n      return values;\n    }\n    while (true) {\n      values.push(this.value(key));\n      this.whitespace();\n      const separator = this.source[this.offset];\n      if (separator === \"]\") {\n        this.offset++;\n        return values;\n      }\n      if (separator !== \",\") this.invalid(key, \"expected ',' or ']' in array\");\n      this.offset++;\n    }\n  }\n\n  private string(key: string): string {\n    const start = this.offset++;\n    let escaped = false;\n    while (this.offset < this.source.length) {\n      const character = this.source[this.offset++];\n      if (escaped) {\n        escaped = false;\n        continue;\n      }\n      if (character === \"\\\\\") {\n        escaped = true;\n        continue;\n      }\n      if (character === '\"') {\n        try {\n          return JSON.parse(this.source.slice(start, this.offset)) as string;\n        } catch {\n          this.invalid(key, \"invalid JSON string\");\n        }\n      }\n      if (character !== undefined && character.charCodeAt(0) < 0x20)\n        this.invalid(key, \"unescaped control character in JSON string\");\n    }\n    this.invalid(key, \"unterminated JSON string\");\n  }\n\n  private number(key: string): number {\n    const match = /-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;\n    match.lastIndex = this.offset;\n    const token = match.exec(this.source)?.[0];\n    if (token === undefined) this.invalid(key, \"invalid JSON number\");\n    this.offset += token.length;\n    return Number(token);\n  }\n\n  private literal<T extends boolean | null>(written: string, value: T): T {\n    this.offset += written.length;\n    return value;\n  }\n\n  private whitespace(): void {\n    while (this.offset < this.source.length) {\n      const character = this.source[this.offset];\n      if (character === undefined || !\" \\t\\n\\r\".includes(character)) return;\n      this.offset++;\n    }\n  }\n\n  private invalid(key: string, detail: string): never {\n    fail(this.sourceFile, key, detail);\n  }\n}\n\nfunction assertNamespaceSegment(sourceFile: string, segment: string, key: string): void {\n  if (!SEGMENT.test(segment)) fail(sourceFile, key, \"segments must match [A-Za-z_][A-Za-z0-9_-]*\");\n  if (FORBIDDEN_SEGMENTS.has(segment)) fail(sourceFile, key, \"segments cannot be reserved\");\n}\n\nfunction assertSegment(sourceFile: string, segment: string, key: string): void {\n  if (segment.includes(\".\")) fail(sourceFile, key, \"JSON keys cannot contain '.'\");\n  assertNamespaceSegment(sourceFile, segment, key);\n}\n\nfunction explicitGroup(sourceFile: string, value: string): string {\n  if (value === \"\") fail(sourceFile, \"$group\", \"'$group' cannot be empty\");\n  for (const segment of value.split(\".\")) {\n    if (segment === \"\") fail(sourceFile, \"$group\", \"'$group' cannot contain empty segments\");\n    assertNamespaceSegment(sourceFile, segment, \"$group\");\n  }\n  return value;\n}\n\nfunction defaultGroup(sourceFile: string, defaultNamespace: string | (() => string)): string {\n  const namespace = typeof defaultNamespace === \"function\" ? defaultNamespace() : defaultNamespace;\n\n  return namespace === \"\" ? \"\" : explicitGroup(sourceFile, namespace);\n}\n\nfunction isObject(value: JsonValue): value is JsonObject {\n  return value instanceof Map;\n}\n\nfunction readLeaf(\n  sourceFile: string,\n  key: string,\n  value: JsonObject,\n  localeCodes: readonly string[] | undefined,\n): Record<string, string> {\n  const locales = localeCodes === undefined ? undefined : new Set(localeCodes);\n  const entry: Record<string, string> = Object.create(null) as Record<string, string>;\n  for (const [locale, translation] of value) {\n    if (!LOCALE_CODE.test(locale)) fail(sourceFile, `${key}.${locale}`, \"invalid locale code\");\n    if (typeof translation !== \"string\")\n      fail(sourceFile, `${key}.${locale}`, \"locale values must be strings\");\n    if (locales !== undefined && !locales.has(locale))\n      fail(sourceFile, `${key}.${locale}`, \"unknown locale code\");\n    entry[locale] = translation;\n  }\n  if (localeCodes !== undefined)\n    for (const locale of localeCodes)\n      if (!(locale in entry)) fail(sourceFile, key, `missing locale code \"${locale}\"`);\n  return entry;\n}\n\nfunction collectEntries(\n  sourceFile: string,\n  object: JsonObject,\n  group: string,\n  localeCodes: readonly string[] | undefined,\n  entries: LocaleDictionaryEntries,\n  nested: boolean,\n): void {\n  if (nested && object.size === 0) fail(sourceFile, group, \"nested objects cannot be empty\");\n  for (const [segment, value] of object) {\n    const key = group === \"\" ? segment : `${group}.${segment}`;\n    if (segment === \"$group\") fail(sourceFile, key, \"'$group' is only allowed at the root\");\n    assertSegment(sourceFile, segment, key);\n    if (!isObject(value)) fail(sourceFile, key, \"entries must be locale objects or nested objects\");\n    if (value.has(\"$group\"))\n      fail(sourceFile, `${key}.$group`, \"'$group' is only allowed at the root\");\n    const values = [...value.values()];\n    const hasString = values.some((item) => typeof item === \"string\");\n    const allObjects = values.every(isObject);\n    if (hasString) {\n      if (!values.every((item) => typeof item === \"string\"))\n        fail(sourceFile, key, \"cannot mix locale values with nested entries\");\n      entries[key] = readLeaf(sourceFile, key, value, localeCodes);\n      continue;\n    }\n    if (!allObjects) fail(sourceFile, key, \"cannot mix locale values with nested entries\");\n    if (localeCodes !== undefined && [...value.keys()].some((child) => localeCodes.includes(child)))\n      fail(sourceFile, key, \"cannot mix locale codes with nested entries\");\n    collectEntries(sourceFile, value, key, localeCodes, entries, true);\n  }\n}\n\n/** Parses one locale dictionary source without reading the filesystem or loading application code. */\nexport function parseLocaleDictionary(input: {\n  sourceFile: string;\n  source: string;\n  /**\n   * The group used when the file declares no `$group`. A function is called\n   * only in that case, so a namespace that cannot be derived (e.g. from a\n   * folder name) never fails a file that names its own `$group`.\n   */\n  defaultNamespace: string | (() => string);\n  localeCodes?: readonly string[];\n}): ParsedLocaleDictionary {\n  const { sourceFile, source, defaultNamespace, localeCodes } = input;\n  const parsed = new StrictJsonParser(sourceFile, source).parse();\n  if (!isObject(parsed)) fail(sourceFile, \"$\", \"root JSON value must be an object\");\n  const groupValue = parsed.get(\"$group\");\n  if (groupValue !== undefined && typeof groupValue !== \"string\")\n    fail(sourceFile, \"$group\", \"'$group' must be a string\");\n  const group =\n    groupValue === undefined\n      ? defaultGroup(sourceFile, defaultNamespace)\n      : explicitGroup(sourceFile, groupValue);\n  const entries: LocaleDictionaryEntries = Object.create(null) as LocaleDictionaryEntries;\n  const rootEntries = new Map(parsed);\n  rootEntries.delete(\"$group\");\n  collectEntries(sourceFile, rootEntries, group, localeCodes, entries, false);\n  return { sourceFile, group, entries };\n}\n"],"mappings":"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"}

package/esm/mail/config.d.mts

@@ -20,6 +20,17 @@ import { MailConfigurations, MailMode, MailersConfig } from "./types.mjs";
  * ```
  */
 declare function setMailMode(mode: MailMode): void;
+/**
+ * The mode set with {@link setMailMode}, or `undefined` when the mode is
+ * derived from the environment.
+ */
+declare function getExplicitMailMode(): MailMode | undefined;
+/**
+ * Forget a mode set with {@link setMailMode}, so the mode is derived from the
+ * environment again. Unlike {@link resetMailConfig}, the configured mailers
+ * are kept.
+ */
+declare function resetMailMode(): void;
 /**
  * Get the current mail mode
  */
@@ -80,5 +91,5 @@ declare function resolveMailConfig(options: {
  */
 declare function resetMailConfig(): void;
 //#endregion
-export { getDefaultMailConfig, getMailMode, getMailerConfig, isDevelopmentMode, isProductionMode, isTestMode, resetMailConfig, resolveMailConfig, setMailConfigurations, setMailMode };
+export { getDefaultMailConfig, getExplicitMailMode, getMailMode, getMailerConfig, isDevelopmentMode, isProductionMode, isTestMode, resetMailConfig, resetMailMode, resolveMailConfig, setMailConfigurations, setMailMode };
 //# sourceMappingURL=config.d.mts.map

package/esm/mail/config.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/mail/config.ts"],"mappings":";;;;;AAwDA;;;;AAA0C;AAO1C;;;;AAAuC;AAcvC;;;;AAAgC;AAOhC;iBA5BgB,WAAA,CAAY,IAAc,EAAR,QAAQ;;;AA4BT;iBArBjB,WAAA,IAAe,QAAQ;;;;iBAcvB,gBAAA;AA2ChB;;;AAAA,iBApCgB,iBAAA;;;;iBAOA,UAAA;AA6BgE;AAYhF;;;;AAA0D;AAW1D;;;;AAAiE;AAmBjE;;;;;;;;;;AAGsB;AAwBtB;;;AArEgF,iBAAhE,qBAAA,CAAsB,MAAA,EAAQ,kBAAA,GAAqB,aAAa;AAAA,iBAYhE,oBAAA,IAAwB,kBAAkB;;;;iBAW1C,eAAA,CAAgB,IAAA,WAAe,kBAAkB;;;;;iBAmBjD,iBAAA,CAAkB,OAAA;EAChC,MAAA,GAAS,kBAAA;EACT,MAAA;AAAA,IACE,kBAAkB;;;;iBAwBN,eAAA"}
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/mail/config.ts"],"mappings":";;;;;AAwDA;;;;AAA0C;AAQ1C;;;;AAA+C;AAS/C;;;;AAA6B;AAO7B;iBAxBgB,WAAA,CAAY,IAAc,EAAR,QAAQ;;;AAwBH;AAcvC;iBA9BgB,mBAAA,IAAuB,QAAQ;;;AA8Bf;AAOhC;;iBA5BgB,aAAA;;AA4BiB;AAOjC;iBA5BgB,WAAA,IAAe,QAAQ;;;AA4Bb;iBAdV,gBAAA;;;;iBAOA,iBAAA;;;;iBAOA,UAAA;AAyChB;;;;AAA0D;AAW1D;;;;AAAiE;AAmBjE;;;;;;;;;;AAGsB;AAwBtB;;;;AAzDA,iBAZgB,qBAAA,CAAsB,MAAA,EAAQ,kBAAA,GAAqB,aAAa;AAAA,iBAYhE,oBAAA,IAAwB,kBAAkB;;;;iBAW1C,eAAA,CAAgB,IAAA,WAAe,kBAAkB;;;;;iBAmBjD,iBAAA,CAAkB,OAAA;EAChC,MAAA,GAAS,kBAAA;EACT,MAAA;AAAA,IACE,kBAAkB;;;;iBAwBN,eAAA"}