@warlock.js/core 5.28.0 → 5.30.0

package/esm/http/uploads/uploaded-file.controller.d.mts

@@ -1,10 +1,24 @@
+import { StorageDriverName } from "../../storage/types.mjs";
 import { RequestHandler } from "../../router/types.mjs";
-//#region ../core/src/http/uploads/uploaded-file.controller.d.ts
+//#region ../../packages/core/src/http/uploads/uploaded-file.controller.d.ts
+/**
+ * Options for {@link createUploadedFileController}
+ */
+type UploadedFileControllerOptions = {
+  /**
+   * Local disk to serve from; the default disk when omitted. A private disk
+   * should be served from a route that checks access first.
+   */
+  disk?: StorageDriverName;
+};
 /**
  * Serves local uploads, and bounded on-demand variants of the images among them.
  *
  * ```ts
  * router.get("/uploads/*", uploadedFileController);
+ * router.get("/invoices/*", createUploadedFileController({ disk: "private" }), {
+ *   middleware: [authMiddleware()],
+ * });
  * ```
  *
  * - `GET /uploads/<path>` sends the original file with a one-year cache.
@@ -12,13 +26,17 @@ import { RequestHandler } from "../../router/types.mjs";
  *   rendered from a variant named in `uploads.images.variants`. No other query
  *   key is accepted, so a client can never ask for an arbitrary size.
  *
- * The path must stay inside the storage root (after symlinks are resolved) and
+ * The path must stay inside the disk root (after symlinks are resolved) and
  * outside the variant cache; anything else is a 404, the same answer a missing
- * file gets. Derivatives are cached on disk under a sha256 of the source path,
- * size, mtime, variant and format, written atomically, generated once per key
- * even under concurrent requests, and sent with an immutable cache and an ETag.
+ * file gets. Derivatives are cached on disk under a directory per source
+ * (see `resolveImageVariant`), written atomically, generated once per key even
+ * under concurrent requests, and sent with an immutable cache and an ETag.
+ */
+declare function createUploadedFileController(options?: UploadedFileControllerOptions): RequestHandler;
+/**
+ * Serves the default disk's uploads; see {@link createUploadedFileController}
  */
 declare const uploadedFileController: RequestHandler;
 //#endregion
-export { uploadedFileController };
+export { UploadedFileControllerOptions, createUploadedFileController, uploadedFileController };
 //# sourceMappingURL=uploaded-file.controller.d.mts.map

package/esm/http/uploads/uploaded-file.controller.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"uploaded-file.controller.d.mts","names":[],"sources":["../../../../../../../../core/src/http/uploads/uploaded-file.controller.ts"],"mappings":";;;;;AA0HA;;;;AAsIC;;;;;;;;;;;cAtIY,sBAAA,EAAwB,cAsIpC"}
+{"version":3,"file":"uploaded-file.controller.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/uploaded-file.controller.ts"],"mappings":";;;;;;KA6FY,6BAAA;EAA6B;;;AAKf;EAAxB,IAAA,GAAO,iBAAiB;AAAA;;;;;;;AA0BT;AA8GjB;;;;AAAoF;;;;;;;;;;iBAhHpE,4BAAA,CACd,OAAA,GAAS,6BAAA,GACR,cAAc;;;;cA8GJ,sBAAA,EAAwB,cAA+C"}

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

@@ -1,17 +1,11 @@
 import { HttpError } from "../errors/errors.mjs";
-import { storage } from "../../storage/storage.mjs";
-import "../../storage/index.mjs";
+import { isMissingFileError, variantCacheDirectoryFor } from "./image-variant-cache.mjs";
 import { matchesIfNoneMatch } from "./matches-if-none-match.mjs";
-import { uploadsConfig } from "../uploads-config.mjs";
-import { generateImageVariant } from "./generate-image-variant.mjs";
 import { detectImageFormat, isVariantSourceFormat } from "./detect-image-format.mjs";
-import { loadVariantSource } from "./load-variant-source.mjs";
-import { resolveImageVariantsConfig } from "./resolve-image-variants-config.mjs";
 import { readFileHead } from "./read-file-head.mjs";
 import { resolveUploadPath } from "./resolve-upload-path.mjs";
-import { resolveVariantCandidate } from "./resolve-variant-candidate.mjs";
-import { variantCacheKey, variantCachePath } from "./variant-cache-key.mjs";
-import { variantGenerations } from "./variant-generations.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";
 import { resolveOriginalContentType } from "./resolve-original-content-type.mjs";
@@ -19,7 +13,7 @@ import { log } from "@warlock.js/logger";
 import path from "node:path";
 import fs from "node:fs/promises";
 
-//#region ../core/src/http/uploads/uploaded-file.controller.ts
+//#region ../../packages/core/src/http/uploads/uploaded-file.controller.ts
 /**
 * One year, in seconds: originals and derivatives are both long-lived
 */
@@ -30,19 +24,11 @@ const CONTENT_TYPES = {
 	webp: "image/webp",
 	avif: "image/avif"
 };
-async function exists(target) {
-	try {
-		await fs.access(target);
-		return true;
-	} catch {
-		return false;
-	}
-}
 function notFound(response) {
 	return response.notFound({ error: "File Not Found" });
 }
-async function sendVariant(response, target, hash, format) {
-	return response.sendBuffer(await fs.readFile(target), {
+async function sendVariant(response, body, hash, format) {
+	return response.sendBuffer(body, {
 		contentType: CONTENT_TYPES[format],
 		cacheTime: ONE_YEAR,
 		immutable: true,
@@ -88,6 +74,9 @@ async function sendOriginalInline(response, absolutePath, contentType) {
 *
 * ```ts
 * router.get("/uploads/*", uploadedFileController);
+* router.get("/invoices/*", createUploadedFileController({ disk: "private" }), {
+*   middleware: [authMiddleware()],
+* });
 * ```
 *
 * - `GET /uploads/<path>` sends the original file with a one-year cache.
@@ -95,80 +84,63 @@ async function sendOriginalInline(response, absolutePath, contentType) {
 *   rendered from a variant named in `uploads.images.variants`. No other query
 *   key is accepted, so a client can never ask for an arbitrary size.
 *
-* The path must stay inside the storage root (after symlinks are resolved) and
+* The path must stay inside the disk root (after symlinks are resolved) and
 * outside the variant cache; anything else is a 404, the same answer a missing
-* file gets. Derivatives are cached on disk under a sha256 of the source path,
-* size, mtime, variant and format, written atomically, generated once per key
-* even under concurrent requests, and sent with an immutable cache and an ETag.
+* file gets. Derivatives are cached on disk under a directory per source
+* (see `resolveImageVariant`), written atomically, generated once per key even
+* under concurrent requests, and sent with an immutable cache and an ETag.
 */
-const uploadedFileController = async ({ request, response }) => {
-	const storageRoot = storage.root();
-	if (!storageRoot || storageRoot === ".") {
-		log.error("uploads", "serve", "uploadedFileController needs a local storage driver with a root.");
-		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") {
-		const images = uploadsConfig("images");
-		const cacheDirectory = images?.cacheDirectory ? [images.cacheDirectory] : [];
-		const source = await resolveUploadPath(request.params["*"], storageRoot, [storage.root(".cache/image-variants"), ...cacheDirectory]);
-		if (!source) return notFound(response);
-		const sniffedFormat = detectImageFormat(await readFileHead(source.absolutePath, 512));
-		if (!isVariantSourceFormat(sniffedFormat)) return sendOriginalAsAttachment(response, source.absolutePath);
-		const inlineContentType = resolveInlineImageContentType(source.absolutePath, sniffedFormat);
-		if (!inlineContentType) return sendOriginalAsAttachment(response, source.absolutePath);
-		return sendOriginalInline(response, source.absolutePath, inlineContentType);
-	}
-	const images = resolveImageVariantsConfig(uploadsConfig("images"), storageRoot);
-	if (!images) return response.badRequest({ error: "Image variants are not configured." });
-	if (!Object.prototype.hasOwnProperty.call(images.variants, query.variant)) return response.badRequest({ error: `Unknown variant "${query.variant}".` });
-	const requestedFormat = query.format;
-	if (requestedFormat !== void 0 && !images.formats.includes(requestedFormat)) return response.badRequest({ error: `Format "${query.format}" is not allowed.` });
-	const variant = images.variants[query.variant];
-	if (variant === void 0) return response.badRequest({ error: `Unknown variant "${query.variant}".` });
-	let source;
-	try {
-		const candidate = await resolveVariantCandidate(request.params["*"], storageRoot, images);
-		if (!candidate) return notFound(response);
-		const resolvedSource = candidate.source;
-		source = resolvedSource;
-		const { stats, sourceFormat } = candidate;
-		const format = requestedFormat ?? sourceFormat;
-		const hash = variantCacheKey({
-			relativePath: resolvedSource.relativePath,
-			sourceSize: stats.size,
-			sourceMtimeMs: stats.mtimeMs,
-			variant,
-			format
-		});
-		const target = variantCachePath(images.cacheDirectory, hash, format);
-		if (await exists(target)) {
-			if (matchesIfNoneMatch(request.header("if-none-match"), `"${hash}"`)) return response.baseResponse.status(304).send();
-			return sendVariant(response, target, hash, format);
+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);
 		}
-		await variantGenerations.run(hash, async () => {
-			if (await exists(target)) return;
-			await generateImageVariant({
-				image: await loadVariantSource(resolvedSource.absolutePath, {
-					maxSourceBytes: images.maxSourceBytes,
-					maxSourcePixels: images.maxSourcePixels,
-					expectedFormat: sourceFormat
-				}),
-				variant,
-				format,
-				targetPath: target
-			});
-		});
-		return sendVariant(response, target, hash, format);
-	} catch (error) {
-		if (error instanceof HttpError) return response.send({ error: error.message }, error.status);
-		log.error("uploads", "variant", `Could not generate variant "${query.variant}" of ${source?.relativePath ?? request.params["*"]}: ${error instanceof Error ? error.message : String(error)}`);
-		return response.serverError({ error: "Could not generate the image variant." });
-	}
-};
+		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") {
+			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));
+			if (!isVariantSourceFormat(sniffedFormat)) return sendOriginalAsAttachment(response, source.absolutePath);
+			const inlineContentType = resolveInlineImageContentType(source.absolutePath, sniffedFormat);
+			if (!inlineContentType) return sendOriginalAsAttachment(response, source.absolutePath);
+			return sendOriginalInline(response, source.absolutePath, inlineContentType);
+		}
+		try {
+			const variantInput = {
+				path: request.params["*"],
+				variant: query.variant,
+				...query.format !== void 0 ? { format: query.format } : {},
+				...options.disk !== void 0 ? { disk: options.disk } : {}
+			};
+			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();
+			let body;
+			try {
+				body = await fs.readFile(variant.absolutePath);
+			} catch (readError) {
+				if (!isMissingFileError(readError)) throw readError;
+				variant = await resolveImageVariant(variantInput);
+				if (!variant) return notFound(response);
+				body = await fs.readFile(variant.absolutePath);
+			}
+			return sendVariant(response, body, variant.hash, variant.format);
+		} catch (error) {
+			if (error instanceof HttpError) return response.send({ error: error.message }, error.status);
+			log.error("uploads", "variant", `Could not generate variant "${query.variant}" of ${String(request.params["*"])}: ${error instanceof Error ? error.message : String(error)}`);
+			return response.serverError({ error: "Could not generate the image variant." });
+		}
+	};
+}
+/**
+* Serves the default disk's uploads; see {@link createUploadedFileController}
+*/
+const uploadedFileController = createUploadedFileController();
 
 //#endregion
-export { uploadedFileController };
+export { createUploadedFileController, uploadedFileController };
 //# sourceMappingURL=uploaded-file.controller.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"uploaded-file.controller.mjs","names":[],"sources":["../../../../../../../../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 { storage } from \"../../storage\";\nimport { HttpError } from \"../errors\";\nimport type { Response } from \"../response\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport {\n  detectImageFormat,\n  IMAGE_SIGNATURE_BYTES,\n  isVariantSourceFormat,\n} from \"./detect-image-format\";\nimport { generateImageVariant } from \"./generate-image-variant\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\nimport { loadVariantSource } from \"./load-variant-source\";\nimport { matchesIfNoneMatch } from \"./matches-if-none-match\";\nimport { parseUploadedFileQuery } from \"./parse-uploaded-file-query\";\nimport { readFileHead } from \"./read-file-head\";\nimport { resolveImageVariantsConfig } from \"./resolve-image-variants-config\";\nimport { resolveInlineImageContentType } from \"./resolve-inline-image-content-type\";\nimport { resolveOriginalContentType } from \"./resolve-original-content-type\";\nimport { resolveUploadPath, type ResolvedUploadPath } from \"./resolve-upload-path\";\nimport { resolveVariantCandidate } from \"./resolve-variant-candidate\";\nimport { variantCacheKey, variantCachePath } from \"./variant-cache-key\";\nimport { variantGenerations } from \"./variant-generations\";\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\nasync function exists(target: string): Promise<boolean> {\n  try {\n    await fs.access(target);\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction notFound(response: Response) {\n  return response.notFound({ error: \"File Not Found\" });\n}\n\nasync function sendVariant(\n  response: Response,\n  target: string,\n  hash: string,\n  format: VariantOutputFormat,\n) {\n  return response.sendBuffer(await fs.readFile(target), {\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 * Serves local uploads, and bounded on-demand variants of the images among them.\n *\n * ```ts\n * router.get(\"/uploads/*\", uploadedFileController);\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 storage 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 sha256 of the source path,\n * size, mtime, variant and format, written atomically, generated once per key\n * even under concurrent requests, and sent with an immutable cache and an ETag.\n */\nexport const uploadedFileController: RequestHandler = async ({ request, response }) => {\n  const storageRoot = storage.root();\n\n  if (!storageRoot || storageRoot === \".\") {\n    log.error(\n      \"uploads\",\n      \"serve\",\n      \"uploadedFileController needs a local storage driver with a root.\",\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 images = uploadsConfig(\"images\");\n    const cacheDirectory = images?.cacheDirectory ? [images.cacheDirectory] : [];\n    const source = await resolveUploadPath(request.params[\"*\"], storageRoot, [\n      storage.root(\".cache/image-variants\"),\n      ...cacheDirectory,\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  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), storageRoot);\n\n  if (!images) {\n    return response.badRequest({ error: \"Image variants are not configured.\" });\n  }\n\n  if (!Object.prototype.hasOwnProperty.call(images.variants, query.variant)) {\n    return response.badRequest({ error: `Unknown variant \"${query.variant}\".` });\n  }\n\n  const requestedFormat = query.format as VariantOutputFormat | undefined;\n\n  if (requestedFormat !== undefined && !images.formats.includes(requestedFormat as never)) {\n    return response.badRequest({ error: `Format \"${query.format}\" is not allowed.` });\n  }\n\n  const variant = images.variants[query.variant];\n  if (variant === undefined) {\n    return response.badRequest({ error: `Unknown variant \"${query.variant}\".` });\n  }\n\n  let source: ResolvedUploadPath | undefined;\n\n  try {\n    const candidate = await resolveVariantCandidate(request.params[\"*\"], storageRoot, images);\n\n    if (!candidate) return notFound(response);\n\n    const resolvedSource = candidate.source;\n\n    source = resolvedSource;\n\n    const { stats, sourceFormat } = candidate;\n    const format: VariantOutputFormat = requestedFormat ?? sourceFormat;\n    const hash = variantCacheKey({\n      relativePath: resolvedSource.relativePath,\n      sourceSize: stats.size,\n      sourceMtimeMs: stats.mtimeMs,\n      variant,\n      format,\n    });\n    const target = variantCachePath(images.cacheDirectory, hash, format);\n\n    if (await exists(target)) {\n      if (matchesIfNoneMatch(request.header(\"if-none-match\"), `\"${hash}\"`)) {\n        return response.baseResponse.status(304).send();\n      }\n\n      return sendVariant(response, target, hash, format);\n    }\n\n    await variantGenerations.run(hash, async () => {\n      if (await exists(target)) return;\n\n      const image = await loadVariantSource(resolvedSource.absolutePath, {\n        maxSourceBytes: images.maxSourceBytes,\n        maxSourcePixels: images.maxSourcePixels,\n        expectedFormat: sourceFormat,\n      });\n\n      await generateImageVariant({ image, variant, format, targetPath: target });\n    });\n\n    return sendVariant(response, target, hash, 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 ${source?.relativePath ?? 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"],"mappings":"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"}
+{"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":"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"}

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

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
 
-//#region ../core/src/http/uploads/variant-cache-key.ts
+//#region ../../packages/core/src/http/uploads/variant-cache-key.ts
 /**
 * JSON of the variant with its keys sorted, so key order in the app config
 * never changes the hash
@@ -34,12 +34,37 @@ function variantExtension(format) {
 	return format === "jpeg" ? "jpg" : format;
 }
 /**
-* Where a derivative lives: `<cacheDirectory>/<first 2 hex>/<hash>.<ext>`
+* The sha256 of the source a derivative belongs to: the real (symlink-free)
+* disk root and the `/`-separated path relative to it. Every derivative of
+* one source lives under the directory this names, so deleting the source
+* can remove them all at once, whichever cache directory several disks share.
 */
-function variantCachePath(cacheDirectory, hash, format) {
-	return path.join(cacheDirectory, hash.slice(0, 2), `${hash}.${variantExtension(format)}`);
+function variantSourceKey(realRoot, relativePath) {
+	return createHash("sha256").update(JSON.stringify([realRoot, relativePath])).digest("hex");
+}
+/**
+* The directory holding every derivative of one source:
+* `<cacheDirectory>/<first 2 hex>/<sourceKey>`
+*/
+function variantSourceDirectory(cacheDirectory, sourceKey) {
+	return path.join(cacheDirectory, sourceKey.slice(0, 2), sourceKey);
+}
+/**
+* Names one version of a source (its size and whole-millisecond mtime).
+* Derivatives of an older version sit in a sibling directory, which is
+* pruned once a derivative of the current version has been written.
+*/
+function variantGenerationTag(sourceSize, sourceMtimeMs) {
+	return `${sourceSize}-${Math.trunc(sourceMtimeMs)}`;
+}
+/**
+* Where a derivative lives:
+* `<cacheDirectory>/<first 2 hex>/<sourceKey>/<generation>/<hash>.<ext>`
+*/
+function variantCachePath(cacheDirectory, source, hash, format) {
+	return path.join(variantSourceDirectory(cacheDirectory, source.sourceKey), source.generation, `${hash}.${variantExtension(format)}`);
 }
 
 //#endregion
-export { variantCacheKey, variantCachePath };
+export { variantCacheKey, variantCachePath, variantGenerationTag, variantSourceDirectory, variantSourceKey };
 //# sourceMappingURL=variant-cache-key.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"variant-cache-key.mjs","names":[],"sources":["../../../../../../../../core/src/http/uploads/variant-cache-key.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport type { ImageVariantDefinition } from \"../uploads-types\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\n\n/**\n * Everything a derivative depends on\n */\nexport type VariantCacheKeyInput = {\n  relativePath: string;\n  sourceSize: number;\n  sourceMtimeMs: number;\n  variant: ImageVariantDefinition;\n  format: VariantOutputFormat;\n};\n\n/**\n * JSON of the variant with its keys sorted, so key order in the app config\n * never changes the hash\n */\nfunction normalizedVariantJson(variant: ImageVariantDefinition): string {\n  const sorted = Object.fromEntries(\n    Object.entries(variant)\n      .filter(([, value]) => value !== undefined)\n      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),\n  );\n\n  return JSON.stringify(sorted);\n}\n\n/**\n * The sha256 cache key of a derivative.\n *\n * The source size and mtime are part of the key, so rewriting the source moves\n * every request to a new key and a fresh derivative. The parts are hashed as a\n * JSON array, so no two different inputs can concatenate to the same string.\n */\nexport function variantCacheKey(input: VariantCacheKeyInput): string {\n  const material = JSON.stringify([\n    input.relativePath,\n    input.sourceSize,\n    input.sourceMtimeMs,\n    normalizedVariantJson(input.variant),\n    input.format,\n  ]);\n\n  return createHash(\"sha256\").update(material).digest(\"hex\");\n}\n\n/**\n * File extension of a derivative\n */\nexport function variantExtension(format: VariantOutputFormat): string {\n  return format === \"jpeg\" ? \"jpg\" : format;\n}\n\n/**\n * Where a derivative lives: `<cacheDirectory>/<first 2 hex>/<hash>.<ext>`\n */\nexport function variantCachePath(\n  cacheDirectory: string,\n  hash: string,\n  format: VariantOutputFormat,\n): string {\n  return path.join(cacheDirectory, hash.slice(0, 2), `${hash}.${variantExtension(format)}`);\n}\n"],"mappings":";;;;;;;;AAoBA,SAAS,sBAAsB,SAAyC;CACtE,MAAM,SAAS,OAAO,YACpB,OAAO,QAAQ,OAAO,CAAC,CACpB,QAAQ,GAAG,WAAW,UAAU,MAAS,CAAC,CAC1C,MAAM,CAAC,IAAI,CAAC,OAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAE,CACpD;CAEA,OAAO,KAAK,UAAU,MAAM;AAC9B;;;;;;;;AASA,SAAgB,gBAAgB,OAAqC;CACnE,MAAM,WAAW,KAAK,UAAU;EAC9B,MAAM;EACN,MAAM;EACN,MAAM;EACN,sBAAsB,MAAM,OAAO;EACnC,MAAM;CACR,CAAC;CAED,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,QAAQ,CAAC,CAAC,OAAO,KAAK;AAC3D;;;;AAKA,SAAgB,iBAAiB,QAAqC;CACpE,OAAO,WAAW,SAAS,QAAQ;AACrC;;;;AAKA,SAAgB,iBACd,gBACA,MACA,QACQ;CACR,OAAO,KAAK,KAAK,gBAAgB,KAAK,MAAM,GAAG,CAAC,GAAG,GAAG,KAAK,GAAG,iBAAiB,MAAM,GAAG;AAC1F"}
+{"version":3,"file":"variant-cache-key.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/variant-cache-key.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport type { ImageVariantDefinition } from \"../uploads-types\";\nimport type { VariantOutputFormat } from \"./image-variant-types\";\n\n/**\n * Everything a derivative depends on\n */\nexport type VariantCacheKeyInput = {\n  relativePath: string;\n  sourceSize: number;\n  sourceMtimeMs: number;\n  variant: ImageVariantDefinition;\n  format: VariantOutputFormat;\n};\n\n/**\n * JSON of the variant with its keys sorted, so key order in the app config\n * never changes the hash\n */\nfunction normalizedVariantJson(variant: ImageVariantDefinition): string {\n  const sorted = Object.fromEntries(\n    Object.entries(variant)\n      .filter(([, value]) => value !== undefined)\n      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),\n  );\n\n  return JSON.stringify(sorted);\n}\n\n/**\n * The sha256 cache key of a derivative.\n *\n * The source size and mtime are part of the key, so rewriting the source moves\n * every request to a new key and a fresh derivative. The parts are hashed as a\n * JSON array, so no two different inputs can concatenate to the same string.\n */\nexport function variantCacheKey(input: VariantCacheKeyInput): string {\n  const material = JSON.stringify([\n    input.relativePath,\n    input.sourceSize,\n    input.sourceMtimeMs,\n    normalizedVariantJson(input.variant),\n    input.format,\n  ]);\n\n  return createHash(\"sha256\").update(material).digest(\"hex\");\n}\n\n/**\n * File extension of a derivative\n */\nexport function variantExtension(format: VariantOutputFormat): string {\n  return format === \"jpeg\" ? \"jpg\" : format;\n}\n\n/**\n * The sha256 of the source a derivative belongs to: the real (symlink-free)\n * disk root and the `/`-separated path relative to it. Every derivative of\n * one source lives under the directory this names, so deleting the source\n * can remove them all at once, whichever cache directory several disks share.\n */\nexport function variantSourceKey(realRoot: string, relativePath: string): string {\n  return createHash(\"sha256\")\n    .update(JSON.stringify([realRoot, relativePath]))\n    .digest(\"hex\");\n}\n\n/**\n * The directory holding every derivative of one source:\n * `<cacheDirectory>/<first 2 hex>/<sourceKey>`\n */\nexport function variantSourceDirectory(cacheDirectory: string, sourceKey: string): string {\n  return path.join(cacheDirectory, sourceKey.slice(0, 2), sourceKey);\n}\n\n/**\n * Names one version of a source (its size and whole-millisecond mtime).\n * Derivatives of an older version sit in a sibling directory, which is\n * pruned once a derivative of the current version has been written.\n */\nexport function variantGenerationTag(sourceSize: number, sourceMtimeMs: number): string {\n  return `${sourceSize}-${Math.trunc(sourceMtimeMs)}`;\n}\n\n/**\n * Where a derivative lives:\n * `<cacheDirectory>/<first 2 hex>/<sourceKey>/<generation>/<hash>.<ext>`\n */\nexport function variantCachePath(\n  cacheDirectory: string,\n  source: { sourceKey: string; generation: string },\n  hash: string,\n  format: VariantOutputFormat,\n): string {\n  return path.join(\n    variantSourceDirectory(cacheDirectory, source.sourceKey),\n    source.generation,\n    `${hash}.${variantExtension(format)}`,\n  );\n}\n"],"mappings":";;;;;;;;AAoBA,SAAS,sBAAsB,SAAyC;CACtE,MAAM,SAAS,OAAO,YACpB,OAAO,QAAQ,OAAO,CAAC,CACpB,QAAQ,GAAG,WAAW,UAAU,MAAS,CAAC,CAC1C,MAAM,CAAC,IAAI,CAAC,OAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAE,CACpD;CAEA,OAAO,KAAK,UAAU,MAAM;AAC9B;;;;;;;;AASA,SAAgB,gBAAgB,OAAqC;CACnE,MAAM,WAAW,KAAK,UAAU;EAC9B,MAAM;EACN,MAAM;EACN,MAAM;EACN,sBAAsB,MAAM,OAAO;EACnC,MAAM;CACR,CAAC;CAED,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,QAAQ,CAAC,CAAC,OAAO,KAAK;AAC3D;;;;AAKA,SAAgB,iBAAiB,QAAqC;CACpE,OAAO,WAAW,SAAS,QAAQ;AACrC;;;;;;;AAQA,SAAgB,iBAAiB,UAAkB,cAA8B;CAC/E,OAAO,WAAW,QAAQ,CAAC,CACxB,OAAO,KAAK,UAAU,CAAC,UAAU,YAAY,CAAC,CAAC,CAAC,CAChD,OAAO,KAAK;AACjB;;;;;AAMA,SAAgB,uBAAuB,gBAAwB,WAA2B;CACxF,OAAO,KAAK,KAAK,gBAAgB,UAAU,MAAM,GAAG,CAAC,GAAG,SAAS;AACnE;;;;;;AAOA,SAAgB,qBAAqB,YAAoB,eAA+B;CACtF,OAAO,GAAG,WAAW,GAAG,KAAK,MAAM,aAAa;AAClD;;;;;AAMA,SAAgB,iBACd,gBACA,QACA,MACA,QACQ;CACR,OAAO,KAAK,KACV,uBAAuB,gBAAgB,OAAO,SAAS,GACvD,OAAO,YACP,GAAG,KAAK,GAAG,iBAAiB,MAAM,GACpC;AACF"}

package/esm/http/uploads/variant-generations.mjs

@@ -1,6 +1,6 @@
 import { SingleFlight } from "./single-flight.mjs";
 
-//#region ../core/src/http/uploads/variant-generations.ts
+//#region ../../packages/core/src/http/uploads/variant-generations.ts
 /**
 * Shared in-process single-flight for derivative generation.
 *

package/esm/http/uploads/variant-generations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"variant-generations.mjs","names":[],"sources":["../../../../../../../../core/src/http/uploads/variant-generations.ts"],"sourcesContent":["import { SingleFlight } from \"./single-flight\";\n\n/**\n * Shared in-process single-flight for derivative generation.\n *\n * Both `uploadedFileController` and `generateImageVariants` run generations\n * through this one instance, so concurrent misses for the same cache key —\n * whether they arrive from the on-demand route or from an ingest call —\n * render the derivative once.\n */\nexport const variantGenerations = new SingleFlight<void>();\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,qBAAqB,IAAI,aAAmB"}
+{"version":3,"file":"variant-generations.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/variant-generations.ts"],"sourcesContent":["import { SingleFlight } from \"./single-flight\";\n\n/**\n * Shared in-process single-flight for derivative generation.\n *\n * Both `uploadedFileController` and `generateImageVariants` run generations\n * through this one instance, so concurrent misses for the same cache key —\n * whether they arrive from the on-demand route or from an ingest call —\n * render the derivative once.\n */\nexport const variantGenerations = new SingleFlight<void>();\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,qBAAqB,IAAI,aAAmB"}

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

@@ -1,6 +1,6 @@
 import { UploadsConfigurations } from "./uploads-types.mjs";
 
-//#region ../core/src/http/uploads-config.d.ts
+//#region ../../packages/core/src/http/uploads-config.d.ts
 /**
  * Default uploads configuration values
  *

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

@@ -1 +1 @@
-{"version":3,"file":"uploads-config.d.mts","names":[],"sources":["../../../../../../../core/src/http/uploads-config.ts"],"mappings":";;;;;AASA;;;;cAAa,gBAAA,EAAkB,qBAQ9B;AAkBD;;;;;;;;;;;;;;;;AAAA,iBAAgB,aAAA,iBAA8B,qBAAA,EAC5C,GAAA,EAAK,CAAA,EACL,YAAA,GAAe,qBAAA,CAAsB,CAAA,IACpC,qBAAA,CAAsB,CAAA"}
+{"version":3,"file":"uploads-config.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/uploads-config.ts"],"mappings":";;;;;AASA;;;;cAAa,gBAAA,EAAkB,qBAQ9B;AAkBD;;;;;;;;;;;;;;;;AAAA,iBAAgB,aAAA,iBAA8B,qBAAA,EAC5C,GAAA,EAAK,CAAA,EACL,YAAA,GAAe,qBAAA,CAAsB,CAAA,IACpC,qBAAA,CAAsB,CAAA"}

package/esm/http/uploads-config.mjs

@@ -1,7 +1,7 @@
 import { config } from "../config/config-getter.mjs";
 import "../config/index.mjs";
 
-//#region ../core/src/http/uploads-config.ts
+//#region ../../packages/core/src/http/uploads-config.ts
 /**
 * Default uploads configuration values
 *

package/esm/http/uploads-config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"uploads-config.mjs","names":[],"sources":["../../../../../../../core/src/http/uploads-config.ts"],"sourcesContent":["import { config } from \"../config\";\nimport type { UploadsConfigurations } from \"./uploads-types\";\n\n/**\n * Default uploads configuration values\n *\n * These defaults are used when no configuration is provided\n * or when specific keys are missing from the app config.\n */\nexport const UPLOADS_DEFAULTS: UploadsConfigurations = {\n  name: \"random\",\n  randomLength: 32,\n  prefix: {\n    as: \"directory\",\n    format: \"DD-MM-YYYY\",\n  },\n  defaultPrefixFormat: \"DD-MM-YYYY-HH-mm-ss\",\n};\n\n/**\n * Get uploads configuration value\n *\n * Retrieves a configuration value from the `uploads` section of app config,\n * falling back to the provided default or the built-in default.\n *\n * @param key - Configuration key to retrieve\n * @param defaultValue - Optional default value if not found\n * @returns The configuration value\n *\n * @example\n * ```typescript\n * const naming = uploadsConfig(\"name\"); // \"random\" or \"original\"\n * const length = uploadsConfig(\"randomLength\", 32);\n * ```\n */\nexport function uploadsConfig<K extends keyof UploadsConfigurations>(\n  key: K,\n  defaultValue?: UploadsConfigurations[K],\n): UploadsConfigurations[K] {\n  const fallback = defaultValue ?? UPLOADS_DEFAULTS[key];\n  return config.key(`uploads.${key}`, fallback);\n}\n"],"mappings":";;;;;;;;;;AASA,MAAa,mBAA0C;CACrD,MAAM;CACN,cAAc;CACd,QAAQ;EACN,IAAI;EACJ,QAAQ;CACV;CACA,qBAAqB;AACvB;;;;;;;;;;;;;;;;;AAkBA,SAAgB,cACd,KACA,cAC0B;CAC1B,MAAM,WAAW,gBAAgB,iBAAiB;CAClD,OAAO,OAAO,IAAI,WAAW,OAAO,QAAQ;AAC9C"}
+{"version":3,"file":"uploads-config.mjs","names":[],"sources":["../../../../../../../../packages/core/src/http/uploads-config.ts"],"sourcesContent":["import { config } from \"../config\";\nimport type { UploadsConfigurations } from \"./uploads-types\";\n\n/**\n * Default uploads configuration values\n *\n * These defaults are used when no configuration is provided\n * or when specific keys are missing from the app config.\n */\nexport const UPLOADS_DEFAULTS: UploadsConfigurations = {\n  name: \"random\",\n  randomLength: 32,\n  prefix: {\n    as: \"directory\",\n    format: \"DD-MM-YYYY\",\n  },\n  defaultPrefixFormat: \"DD-MM-YYYY-HH-mm-ss\",\n};\n\n/**\n * Get uploads configuration value\n *\n * Retrieves a configuration value from the `uploads` section of app config,\n * falling back to the provided default or the built-in default.\n *\n * @param key - Configuration key to retrieve\n * @param defaultValue - Optional default value if not found\n * @returns The configuration value\n *\n * @example\n * ```typescript\n * const naming = uploadsConfig(\"name\"); // \"random\" or \"original\"\n * const length = uploadsConfig(\"randomLength\", 32);\n * ```\n */\nexport function uploadsConfig<K extends keyof UploadsConfigurations>(\n  key: K,\n  defaultValue?: UploadsConfigurations[K],\n): UploadsConfigurations[K] {\n  const fallback = defaultValue ?? UPLOADS_DEFAULTS[key];\n  return config.key(`uploads.${key}`, fallback);\n}\n"],"mappings":";;;;;;;;;;AASA,MAAa,mBAA0C;CACrD,MAAM;CACN,cAAc;CACd,QAAQ;EACN,IAAI;EACJ,QAAQ;CACV;CACA,qBAAqB;AACvB;;;;;;;;;;;;;;;;;AAkBA,SAAgB,cACd,KACA,cAC0B;CAC1B,MAAM,WAAW,gBAAgB,iBAAiB;CAClD,OAAO,OAAO,IAAI,WAAW,OAAO,QAAQ;AAC9C"}

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

@@ -2,7 +2,7 @@ import { StorageDriverName } from "../storage/types.mjs";
 import { Image, ImageFormat, ImageTransformOptions } from "../image/image.mjs";
 import { FileValidationOptions } from "./uploaded-file.mjs";
 
-//#region ../core/src/http/uploads-types.d.ts
+//#region ../../packages/core/src/http/uploads-types.d.ts
 /**
  * Prefix options for file path generation
  *

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

@@ -1 +1 @@
-{"version":3,"file":"uploads-types.d.mts","names":[],"sources":["../../../../../../../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;;;;;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"}

package/esm/http/xmlable.d.mts

@@ -1,4 +1,4 @@
-//#region ../core/src/http/xmlable.d.ts
+//#region ../../packages/core/src/http/xmlable.d.ts
 /**
  * A class contract for anything `response.xml()` can serialize.
  *

package/esm/http/xmlable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"xmlable.d.mts","names":[],"sources":["../../../../../../../core/src/http/xmlable.ts"],"mappings":";;AAOA;;;;AACO;;UADU,OAAA;EACf,KAAK;AAAA"}
+{"version":3,"file":"xmlable.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/xmlable.ts"],"mappings":";;AAOA;;;;AACO;;UADU,OAAA;EACf,KAAK;AAAA"}

package/esm/image/image.d.mts

@@ -1,6 +1,6 @@
 import sharp, { FormatEnum } from "sharp";
 
-//#region ../core/src/image/image.d.ts
+//#region ../../packages/core/src/image/image.d.ts
 type ImageFormat = keyof FormatEnum;
 type ImageInput = string | Buffer | Uint8Array | ArrayBuffer;
 /**

package/esm/image/image.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.mts","names":[],"sources":["../../../../../../../core/src/image/image.ts"],"mappings":"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"}
+{"version":3,"file":"image.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/image/image.ts"],"mappings":"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"}

package/esm/image/image.mjs

@@ -1,7 +1,7 @@
 import { safeFetchToBuffer } from "../storage/utils/safe-fetch.mjs";
 import { createRequire } from "node:module";
 
-//#region ../core/src/image/image.ts
+//#region ../../packages/core/src/image/image.ts
 /**
 * Installation instructions for sharp
 */