@warlock.js/core 5.31.0 → 5.32.0

package/esm/http/types.d.mts

@@ -6,15 +6,15 @@ import { CspConfig } from "./csp.mjs";
 import { HttpErrorMapper } from "./error-mapper.mjs";
 import { HttpTracingConfig } from "./tracing/tracing.type.mjs";
 import { Middleware } from "../router/types.mjs";
+import "../router/index.mjs";
 import { FastifyHttpOptions } from "fastify";
 import { CookieSerializeOptions } from "@fastify/cookie";
 import { FastifyCorsOptions } from "@fastify/cors";
 import { Server } from "node:http";
 import { SecureServerOptions } from "node:http2";
 import React from "react";
-
 //#region ../../packages/core/src/http/types.d.ts
-type RequestEvent = "executingMiddleware" | "executedMiddleware" | "executingAction" | "executedAction";
+export type RequestEvent = "executingMiddleware" | "executedMiddleware" | "executingAction" | "executedAction";
 /**
  * Private, server-only, per-request data bag — `request.locals`.
  *
@@ -38,7 +38,7 @@ type RequestEvent = "executingMiddleware" | "executedMiddleware" | "executingAct
  * }
  * ```
  */
-interface RequestLocals {
+export interface RequestLocals {
   /**
    * Whether this request has, at any point, been assigned a
    * `decodedAccessToken` — set by its accessor in `request.ts`, never by
@@ -66,105 +66,105 @@ interface RequestLocals {
  * `interface`, because nothing in core augments it — auth's own richer
  * shape is simply assignable here.
  */
-type DecodedAccessToken = {
+export type DecodedAccessToken = {
   userType?: string;
 };
 /**
  * Allowed response type
  */
-type ReturnedResponse =
+export type ReturnedResponse =
 /**
  * Can be a response object
  */
-Response
+Response |
 /**
  * Or a promise returning a response object
  */
-| Promise<Response>
+Promise<Response> |
 /**
  * Or an object
  */
-| Record<string, any>
+Record<string, any> |
 /**
  * Or a promise returning an object
  */
-| Promise<Record<string, any>>
+Promise<Record<string, any>> |
 /**
  * Or an array
  */
-| any[]
+any[] |
 /**
  * Or a promise returning an array
  */
-| Promise<any[]>;
+Promise<any[]>;
 /**
  * Response Event Types
  */
-type ResponseEvent =
+export type ResponseEvent =
 /**
  * Triggered before sending the response
  */
-"sending"
+"sending" |
 /**
  * Triggered before sending json response
  */
-| "sendingJson"
+"sendingJson" |
 /**
  * Triggered after sending success json response
  */
-| "sendingSuccessJson"
+"sendingSuccessJson" |
 /**
  * Triggered after sending bad request json response
  */
-| "sendingBadRequestJson"
+"sendingBadRequestJson" |
 /**
  * Triggered after sending the response regardless of the response status code
  */
-| "sent"
+"sent" |
 /**
  * Triggered after sending the response if the response status code is 2xx
  */
-| "success"
+"success" |
 /**
  * Triggered after sending the response if the response status code is 201
  */
-| "successCreate"
+"successCreate" |
 /**
  * Triggered after sending the response if the response status code is 400
  */
-| "badRequest"
+"badRequest" |
 /**
  * Triggered after sending the response if the response status code is 401
  */
-| "unauthorized"
+"unauthorized" |
 /**
  * Triggered after sending the response if the response status code is 403
  */
-| "forbidden"
+"forbidden" |
 /**
  * Triggered after sending the response if the response status code is 404
  */
-| "notFound"
+"notFound" |
 /**
  * Triggered after sending the response if the response status code is 413
  */
-| "contentTooLarge"
+"contentTooLarge" |
 /**
  * Triggered after sending the response if the response status code is 429
  */
-| "throttled"
+"throttled" |
 /**
  * Triggered after sending the response if the response status code is 500
  */
-| "serverError"
+"serverError" |
 /**
  * Triggered after sending the response if the response status code is 4xx or 5xx
  */
-| "error";
+"error";
 /**
  * Partial Middleware
  */
-interface PartialMiddleware {
+export interface PartialMiddleware {
   /**
    * Routes list
    * @example routes: ["/users", "/posts"]
@@ -190,15 +190,16 @@ interface PartialMiddleware {
  * `gracefulShutdown.forceCloseConnections`) have their own `http.*` keys;
  * setting them here as well overrides those keys.
  */
-type HttpServerOptions = Omit<FastifyHttpOptions<Server>, "http2"> & {
-  /** Enable HTTP/2 while retaining the framework's HTTP-compatible reply API. */http2?: boolean;
+export type HttpServerOptions = Omit<FastifyHttpOptions<Server>, "http2"> & {
+  /** Enable HTTP/2 while retaining the framework's HTTP-compatible reply API. */
+  http2?: boolean;
   https?: SecureServerOptions;
   http2SessionTimeout?: number;
 };
 /**
  * Http Configurations list
  */
-interface HttpConfigurations {
+export interface HttpConfigurations {
   /**
    * Options for the underlying Fastify server, applied when it is created.
    *
@@ -506,8 +507,9 @@ interface HttpConfigurations {
 /**
  * Options for `response.stream()`.
  */
-type ResponseStreamOptions = StreamQueueOptions & {
-  /** Application/cache headers override defaults before flushing; framing and connection headers are ignored. */headers?: Record<string, string>;
+export type ResponseStreamOptions = StreamQueueOptions & {
+  /** Application/cache headers override defaults before flushing; framing and connection headers are ignored. */
+  headers?: Record<string, string>;
   /**
    * How many of the most recent chunks (from `send()`, `write()` and
    * `render()`) to keep on `response.body` after `end()`, for logging and
@@ -518,14 +520,15 @@ type ResponseStreamOptions = StreamQueueOptions & {
    */
   retainChunks?: number;
 };
-type ResponseStreamController = {
+export type ResponseStreamController = {
   /**
    * Send data to the client. Does not wait for the client; for long-lived or
    * high-volume streams use `write()` (or `drain()`) so the producer slows
    * down to the client's pace instead of buffering. A silent no-op after the
    * client disconnected; throws after `end()`.
    */
-  send: (data: string | Uint8Array) => void; /** Bounded synchronous write; false when closed or overflow rejects this chunk. */
+  send: (data: string | Uint8Array) => void;
+  /** Bounded synchronous write; false when closed or overflow rejects this chunk. */
   enqueue: (data: string | Uint8Array) => boolean;
   /**
    * Send data and wait until the transport can take more. Resolves `true`
@@ -560,7 +563,8 @@ type ResponseStreamController = {
   /**
    * Whether the transport is currently holding more than its high-water mark.
    */
-  backpressured: boolean; /** Chunks/events/comments rejected by onOverflow: "drop", including send/write/render paths. */
+  backpressured: boolean;
+  /** Chunks/events/comments rejected by onOverflow: "drop", including send/write/render paths. */
   readonly dropped: number;
   /**
    * Detect whether stream is ended (by `end()` or a client disconnect)
@@ -570,8 +574,9 @@ type ResponseStreamController = {
 /**
  * Options for `response.sse()`.
  */
-type ResponseSSEOptions = StreamQueueOptions & {
-  /** Application/cache headers override defaults before flushing; framing and connection headers are ignored. */headers?: Record<string, string>;
+export type ResponseSSEOptions = StreamQueueOptions & {
+  /** Application/cache headers override defaults before flushing; framing and connection headers are ignored. */
+  headers?: Record<string, string>;
   /**
    * How many of the most recent events to keep on `response.body` after
    * `end()`, for logging and debugging. Sent events are otherwise not kept,
@@ -582,10 +587,10 @@ type ResponseSSEOptions = StreamQueueOptions & {
   retainEvents?: number;
 };
 /** Wire serialization for one SSE event. Raw strings are split into safe data lines. */
-type ResponseSSEMessageOptions = {
+export type ResponseSSEMessageOptions = {
   raw?: boolean;
 };
-type ResponseSSEController = {
+export type ResponseSSEController = {
   /**
    * Send an SSE event to the client. Does not wait for the client; for
    * long-lived or high-volume streams use `write()` (or `drain()`) so the
@@ -594,7 +599,8 @@ type ResponseSSEController = {
    * @param data - Event data (will be JSON stringified)
    * @param id - Optional event ID for client-side Last-Event-ID tracking
    */
-  send: (event: string | undefined, data: any, id?: string, options?: ResponseSSEMessageOptions) => ResponseSSEController; /** Bounded synchronous event; undefined event omits the event field. */
+  send: (event: string | undefined, data: any, id?: string, options?: ResponseSSEMessageOptions) => ResponseSSEController;
+  /** Bounded synchronous event; undefined event omits the event field. */
   enqueue: (event: string | undefined, data: unknown, id?: string, options?: ResponseSSEMessageOptions) => boolean;
   /**
    * Send an SSE event and wait until the transport can take more.
@@ -617,7 +623,8 @@ type ResponseSSEController = {
   /**
    * Whether the transport is currently holding more than its high-water mark.
    */
-  backpressured: boolean; /** Chunks/events/comments rejected by onOverflow: "drop", including send/write/render paths. */
+  backpressured: boolean;
+  /** Chunks/events/comments rejected by onOverflow: "drop", including send/write/render paths. */
   readonly dropped: number;
   /**
    * Send a comment to keep the connection alive (invisible to client)
@@ -638,5 +645,4 @@ type ResponseSSEController = {
   ended: boolean;
 };
 //#endregion
-export { DecodedAccessToken, HttpConfigurations, HttpServerOptions, PartialMiddleware, RequestEvent, RequestLocals, ResponseEvent, ResponseSSEController, ResponseSSEMessageOptions, ResponseSSEOptions, ResponseStreamController, ResponseStreamOptions, ReturnedResponse };
 //# sourceMappingURL=types.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.mts","names":["NodeHttpServer","Http2SecureOptions"],"sources":["../../../../../../../../packages/core/src/http/types.ts"],"mappings":";;;;;;;;;;;;;;;;YAeY;;;;;;;;;;;;;;;;;;;;;;;;iBA6BK;;;;;;;;;;;;;;EAcf;;;;;;;;;;;;;;YAeU;EACV;;;;;YAMU;;;;AAIR;;;;AAIA,QAAQ;;;;AAIR;;;;AAIA,QAAQ;;;;;;;;AAQR;;;;YAKQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEK;;;;;EAKf;;;;;;EAMA;;;;EAIA,YAAY;;;;;;;;;;;YAYF,oBAAoB,KAAK,mBAAmBA;;EAEtD;EACA,QAAQC;EACR;;;;;iBAMe;;;;;;;;;;;;;;;;;;;EAmBf,gBAAgB;;;;;;;;;EAShB;;;;;;;EAOA,cAAc;;;;;;;;EAQd;;;;EAIA;;;;EAIA;;;;;;;EAOA,UAAU;;;;EAIV,OAAO;;;;;;EAMP;;;;;EAKA;;;;;;IAME;;;;;;IAMA;;;;;;IAMA;;;;;;;;;;;EAWF;;;;;;;;;;;;;;;;;;;;EAoBA,6CAA6C,iBAAiB;EAC9D;;;;IAIE;;;;IAIA,UAAU;;;;;;;;;;;EAWZ,MAAM;;;;EAIN,YAAY;;;;;;;;EAQZ;;;;;;IAME;;;;IAIA;;;;;;;IAOA;;;;;EAKF;;;;;;IAME;;;;;;IAMA;;;;;;;IAOA;;;;IAIA;;;;;EAKF;;;;;;;IAOE;;;;;;IAMA;;;;;;IAMA;;;;;EAKF;;;;;;;IAOE;;;;;;;;IAQA;;;;;EAKF;;;;;;IAME;;;;;;;IAOA;;;;;;;IAOA;;;;;;;IAOA;;;;;EAKF;;;;EAIA;;;;IAIE,MAAM;;;;IAIN,OAAO;;;;IAIP,SAAS;;;;;;;EAOX,UAAU;;;;;YAMA,wBAAwB;;EAElC,UAAU;;;;;;;;;EASV;;YAGU;;;;;;;EAOV,OAAO,eAAe;;EAEtB,UAAU,eAAe;;;;;;;EAOzB,QAAQ,eAAe,eAAe;;;;EAItC,SAAS,MAAM,MAAM;;;;;;EAMrB,aAAa;;;;EAIb;;;;EAIA,eAAe,wBAAwB;;;;;EAKvC,QAAQ;;;;EAIR;;WAES;;;;EAIT;;;;;YAMU,qBAAqB;;EAE/B,UAAU;;;;;;;;EAQV;;;YAIU;EAA8B;;YAE9B;;;;;;;;;EASV,OACE,2BACA,WACA,aACA,UAAU,8BACP;;EAEL,UACE,2BACA,eACA,aACA,UAAU;;;;;;;EAQZ,QACE,2BACA,WACA,aACA,UAAU,8BACP;;;;;;EAML,aAAa;;;;;EAKb,QAAQ;;;;EAIR;;WAES;;;;EAIT,UAAU,oBAAoB;;;;EAI9B,WAAW;;;;;EAKX,eAAe,wBAAwB;;;;EAIvC"}

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

@@ -2,10 +2,11 @@ import { StorageFile } from "../storage/storage-file.mjs";
 import { ScopedStorage } from "../storage/scoped-storage.mjs";
 import { StorageDriverName } from "../storage/types.mjs";
 import { storage } from "../storage/storage.mjs";
+import "../storage/index.mjs";
 import { Image, ImageFormat, ImageTransformOptions } from "../image/image.mjs";
+import "../image/index.mjs";
 import { ImageTransformCallback, PrefixConfig, SaveAsOptions, SaveOptions, UploadedFileImageOptions } from "./uploads-types.mjs";
 import { MultipartFile } from "@fastify/multipart";
-
 //#region ../../packages/core/src/http/uploaded-file.d.ts
 type UploadedFileMetadata = {
   name: string;
@@ -23,7 +24,7 @@ type UploadedFileMetadata = {
  * the one exception and it is optional for exactly that reason: present when
  * the file has already been buffered, absent otherwise, never guessed.
  */
-type UploadedFileJson = {
+export type UploadedFileJson = {
   name: string;
   mimeType: string;
   extension: string;
@@ -35,7 +36,7 @@ type UploadedFileJson = {
 /**
  * Options for validating file before saving
  */
-type FileValidationOptions = {
+export type FileValidationOptions = {
   /**
    * List of allowed MIME types
    *
@@ -83,7 +84,7 @@ type FileValidationOptions = {
  * const file = await uploadedFile.use("s3").save("avatars");
  * ```
  */
-declare class UploadedFile {
+export declare class UploadedFile {
   protected readonly fileData: MultipartFile;
   /**
    * File buffered content
@@ -492,5 +493,5 @@ declare class UploadedFile {
   toBase64(): Promise<string>;
 }
 //#endregion
-export { FileValidationOptions, UploadedFile, UploadedFileJson };
+export {};
 //# sourceMappingURL=uploaded-file.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"uploaded-file.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/uploaded-file.ts"],"mappings":"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"}
+{"version":3,"file":"uploaded-file.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/http/uploaded-file.ts"],"mappings":";;;;;;;;;;KAiBK;EACH;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;YAWU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;;;YAMU;;;;;;EAMV;;;;;;EAOA;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+BW;qBA4C2B,UAAU;;;;;YAvCtC,sBAAsB;;;;;;EAOzB;;;;;YAMG,UAAU;;;;;YAMV,eAAe;;;;;YAMf,eAAe;;;;;YAMf,mBAAmB,wBAAwB;;;;;;;EAQrD,YAAsC,UAAU;;;;;;MAerC;;;;;;MASA;;;;;;MASA;;;;EAOE,YAAY,QAAQ;;;;;;EAsBpB,QAAQ;;;;;;EAUR,UAAU,QAAQ;;;;MAgBpB;;;;MAOA;;;;MAOA;;;;;;;;;;;;;;;;EAuBJ,IAAI,QAAQ;;;;;;;;;;;;;;;;EAwBZ,OAAO,eAAe;;;;;;;;;;;;;;;EAmBtB,QAAQ;;;;;;;;;;;;;;;EAsBR,OAAO,QAAQ;;;;;;;;;;;;EAgBf,OAAO;;;;;;;;;;;;EAgBP,KAAK;;;;;;;;;;;EAkBL;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCA,UAAU,QAAQ,wBAAwB;;;;;;;;;;;;;;;;;;EAsBpC,WAAW,QAAQ;;;;;;EAanB,cAAc;IAAU;IAAgB;;;;;;;;;;;;;;;;EA0BxC,SAAS,SAAS,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2D1C,KAAK,mBAAmB,UAAU,cAAc,QAAQ;;;;;;;;;;;;;;;;;EA8BxD,OAAO,kBAAkB,UAAU,gBAAgB,QAAQ;;;;;;MAc7D,eAAe;;;;;YAYV,eACd,kBACA,SAAS,oBACR,QAAQ;;;;;YA0BK,uBAAuB,QAAQ;;;;;YA4BrC,kBAAkB,KAAK,QAAQ;;;;;YAkC/B;;;;;YAQA,eAAe,SAAS,oBAAoB,uBAAuB;;;;;YAYnE,gBAAgB,UAAU;;;;;YAwB1B,cAAc,SAAS;;;;;YAiDvB,iBAAiB,gBAAgB;;;;;YASjC,WAAW;;;;;YAQX,cAAc,mBAAmB,gBAAgB;;;;;YAiBjD;;;;;YAiBA;;;;;YAgBA,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6C3B,UAAU;;;;;;;EAkBJ,YAAY"}

package/esm/http/uploads/generate-image-variants.d.mts

@@ -1,17 +1,18 @@
 import { StorageDriverName } from "../../storage/types.mjs";
 import { GeneratedImageDescriptor } from "./image-variant-types.mjs";
-
 //#region ../../packages/core/src/http/uploads/generate-image-variants.d.ts
 /**
  * Options for `generateImageVariants`
  */
-type GenerateImageVariantsOptions = {
+export type GenerateImageVariantsOptions = {
   /**
    * Limit generation to these variant names, instead of every variant in
    * `uploads.images.variants`.
    */
-  variants?: readonly string[]; /** Disk holding the source; defaults to the active disk. */
-  disk?: StorageDriverName; /** Route prefix serving variants of this disk (and originals for local disks). Default /uploads. */
+  variants?: readonly string[];
+  /** Disk holding the source; defaults to the active disk. */
+  disk?: StorageDriverName;
+  /** Route prefix serving variants of this disk (and originals for local disks). Default /uploads. */
   urlPrefix?: string;
 };
 /**
@@ -46,7 +47,6 @@ type GenerateImageVariantsOptions = {
  * `maxSourcePixels`
  * @throws HttpError(415) when the source is not jpeg, png, webp or avif
  */
-declare function generateImageVariants(relativePath: string, options?: GenerateImageVariantsOptions): Promise<GeneratedImageDescriptor>;
+export declare function generateImageVariants(relativePath: string, options?: GenerateImageVariantsOptions): Promise<GeneratedImageDescriptor>;
 //#endregion
-export { GenerateImageVariantsOptions, generateImageVariants };
 //# sourceMappingURL=generate-image-variants.d.mts.map

package/esm/http/uploads/generate-image-variants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-image-variants.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/generate-image-variants.ts"],"mappings":";;;;;;AAqCA;KAAY,4BAAA;;;;;EAKV,QAAA,sBAMA;EAHA,IAAA,GAAO,iBAAiB,EAGf;EAAT,SAAA;AAAA;;;;;;;;;;;;;AAuEiC;;;;;;;;;;;;;;;;;;;;iBAHb,qBAAA,CACpB,YAAA,UACA,OAAA,GAAS,4BAAA,GACR,OAAA,CAAQ,wBAAA"}
+{"version":3,"file":"generate-image-variants.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/generate-image-variants.ts"],"mappings":";;;;;;YAqCY;;;;;EAKV;;EAGA,OAAO;;EAGP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoEoB,sBACpB,sBACA,UAAS,+BACR,QAAQ"}

package/esm/http/uploads/generate-image-variants.mjs

@@ -36,7 +36,7 @@ async function readDerivativeDimensions(target) {
 * that is both the source format and an allowed format is generated once.
 */
 function outputFormatsFor(sourceFormat, configuredFormats) {
-	return [...new Set([sourceFormat, ...configuredFormats])];
+	return [.../* @__PURE__ */ new Set([sourceFormat, ...configuredFormats])];
 }
 /**
 * Render every configured variant of one uploaded image, right after it is

package/esm/http/uploads/generate-image-variants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"generate-image-variants.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/generate-image-variants.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport { Image } from \"../../image\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport { remoteVariantDisk, remoteVariantSource } from \"./remote-variant-source\";\nimport { renderRemoteImageVariant } from \"./resolve-remote-image-variant\";\nimport { HttpError } from \"../errors\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport type { ImageVariantOutputFormat } from \"../uploads-types\";\nimport { generateImageVariant } from \"./generate-image-variant\";\nimport {\n  pruneStaleVariantGenerationsIfCurrent,\n  retryOnVanishedDirectory,\n  warnIfVariantCacheIsPublic,\n} from \"./image-variant-cache\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport type {\n  GeneratedImageDescriptor,\n  GeneratedImageVariant,\n  VariantOutputFormat,\n} from \"./image-variant-types\";\nimport { loadVariantSource } from \"./load-variant-source\";\nimport { resolveImageVariantsConfig } from \"./resolve-image-variants-config\";\nimport { resolveVariantCandidate } from \"./resolve-variant-candidate\";\nimport {\n  variantCacheKey,\n  variantCachePath,\n  variantGenerationTag,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\nimport { freshImageVariant, scheduleImageVariantCacheTrim } from \"./trim-image-variant-cache\";\nimport { variantGenerations } from \"./variant-generations\";\n\n/**\n * Options for `generateImageVariants`\n */\nexport type GenerateImageVariantsOptions = {\n  /**\n   * Limit generation to these variant names, instead of every variant in\n   * `uploads.images.variants`.\n   */\n  variants?: readonly string[];\n\n  /** Disk holding the source; defaults to the active disk. */\n  disk?: StorageDriverName;\n\n  /** Route prefix serving variants of this disk (and originals for local disks). Default /uploads. */\n  urlPrefix?: string;\n};\n\nfunction encodeUploadsPath(relativePath: string): string {\n  return relativePath.split(\"/\").map(encodeURIComponent).join(\"/\");\n}\n\nfunction variantUrl(src: string, name: string, format?: VariantOutputFormat): string {\n  const query = format\n    ? `variant=${encodeURIComponent(name)}&format=${format}`\n    : `variant=${encodeURIComponent(name)}`;\n\n  return `${src}?${query}`;\n}\n\nasync function readDerivativeDimensions(\n  target: string,\n): Promise<{ width: number; height: number }> {\n  const derivative = new Image(await fs.readFile(target));\n  const { width, height } = await derivative.metadata();\n\n  return { width: width ?? 0, height: height ?? 0 };\n}\n\n/**\n * Every distinct format a variant is rendered in: the source format plus\n * whatever `uploads.images.formats` adds, with duplicates dropped so a format\n * that is both the source format and an allowed format is generated once.\n */\nfunction outputFormatsFor(\n  sourceFormat: VariantOutputFormat,\n  configuredFormats: readonly ImageVariantOutputFormat[],\n): VariantOutputFormat[] {\n  return [...new Set<VariantOutputFormat>([sourceFormat, ...configuredFormats])];\n}\n\n/**\n * Render every configured variant of one uploaded image, right after it is\n * saved.\n *\n * Uses the exact same normalized config (`uploads.images`), cache key and\n * derivative path as `uploadedFileController`, so a variant generated here is\n * already on disk the first time `GET /uploads/<path>?variant=<name>` is\n * requested — no second render. `variantGenerations` (the single-flight used\n * by the route) is reused, so a concurrent request for a variant this call is\n * still generating joins the same run instead of starting a second one.\n *\n * The returned descriptor is plain JSON, safe to store next to the record\n * that owns the image, or to carry through loader data. On local storage the\n * `url`/`urls` already point at `uploadedFileController`; an app serving\n * uploads from object storage use the driver URL for the original, and\n * `options.urlPrefix` for the route serving locally cached derivatives.\n * Ingest downloads a remote source once for all variants and formats.\n * On-demand cache hits use ETag metadata; sources without ETags are hashed.\n *\n * @param relativePath - path of the saved upload, relative to the storage root\n * @param options.variants - limit generation to these variant names\n * @throws ImageVariantsConfigError when `uploads.images` is not\n * configured — this is server misconfiguration, not\n * a bad request\n * @throws HttpError(400) when a name in `options.variants` is not declared in\n * `uploads.images.variants`\n * @throws HttpError(404) when `relativePath` does not resolve to a file\n * inside the storage root\n * @throws HttpError(413) when the source is over `maxSourceBytes` or\n * `maxSourcePixels`\n * @throws HttpError(415) when the source is not jpeg, png, webp or avif\n */\nexport async function generateImageVariants(\n  relativePath: string,\n  options: GenerateImageVariantsOptions = {},\n): Promise<GeneratedImageDescriptor> {\n  const storageRoot = localDiskRoot(options.disk);\n\n  if (!storageRoot) return generateRemoteImageVariants(relativePath, options);\n\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), storageRoot);\n\n  if (!images) {\n    throw new ImageVariantsConfigError(\"uploads.images is not configured.\");\n  }\n\n  const names = options.variants ?? Object.keys(images.variants);\n\n  for (const name of names) {\n    if (!Object.prototype.hasOwnProperty.call(images.variants, name)) {\n      throw new HttpError(400, `Unknown variant \"${name}\".`);\n    }\n  }\n\n  const candidate = await resolveVariantCandidate(relativePath, storageRoot, images);\n\n  if (!candidate) {\n    throw new HttpError(404, \"File Not Found\");\n  }\n\n  const { source, stats, sourceFormat } = candidate;\n\n  const image = await loadVariantSource(source.absolutePath, {\n    maxSourceBytes: images.maxSourceBytes,\n    maxSourcePixels: images.maxSourcePixels,\n    expectedFormat: sourceFormat,\n  });\n\n  const { width: sourceWidth, height: sourceHeight } = await image.metadata();\n  warnIfVariantCacheIsPublic(images.cacheDirectory);\n\n  const src = `${(options.urlPrefix ?? \"/uploads\").replace(/\\/$/, \"\")}/${encodeUploadsPath(source.relativePath)}`;\n  const variants: Record<string, GeneratedImageVariant> = {};\n\n  for (const name of names) {\n    const variant = images.variants[name];\n    if (variant === undefined) {\n      throw new HttpError(400, `Unknown variant \"${name}\".`);\n    }\n    const formats = outputFormatsFor(sourceFormat, images.formats);\n    let dimensions: { width: number; height: number } | undefined;\n\n    for (const format of formats) {\n      const hash = variantCacheKey({\n        relativePath: source.relativePath,\n        sourceSize: stats.size,\n        sourceMtimeMs: stats.mtimeMs,\n        variant,\n        format,\n      });\n      const sourceKey = variantSourceKey(source.root, source.relativePath);\n      const generation = variantGenerationTag(stats.size, stats.mtimeMs);\n      const target = variantCachePath(\n        images.cacheDirectory,\n        { sourceKey, generation },\n        hash,\n        format,\n      );\n\n      if (!(await freshImageVariant(target, images.maxCacheAge))) {\n        // keyed on the target, which includes the disk root (see resolveImageVariant)\n        await variantGenerations.run(target, async () => {\n          if (await freshImageVariant(target, images.maxCacheAge)) return;\n\n          await retryOnVanishedDirectory(() =>\n            generateImageVariant({ image: image.clone(), variant, format, targetPath: target }),\n          );\n          scheduleImageVariantCacheTrim(images, target);\n          await pruneStaleVariantGenerationsIfCurrent(\n            source.absolutePath,\n            variantSourceDirectory(images.cacheDirectory, sourceKey),\n            generation,\n          );\n        });\n      }\n\n      if (dimensions === undefined) {\n        dimensions = await readDerivativeDimensions(target);\n      }\n    }\n\n    const urls: Partial<Record<ImageVariantOutputFormat, string>> = {};\n\n    for (const format of images.formats) {\n      urls[format] = variantUrl(src, name, format);\n    }\n\n    variants[name] = {\n      width: dimensions?.width ?? variant.width,\n      height:\n        dimensions?.height ??\n        variant.height ??\n        Math.round(variant.width * ((sourceHeight ?? 1) / (sourceWidth ?? 1))),\n      url: variantUrl(src, name),\n      ...(Object.keys(urls).length > 0 ? { urls } : {}),\n    };\n  }\n\n  return {\n    src,\n    width: sourceWidth ?? 0,\n    height: sourceHeight ?? 0,\n    variants,\n    ...(images.formats.length > 0 ? { formats: images.formats } : {}),\n  };\n}\n\nasync function generateRemoteImageVariants(\n  relativePath: string,\n  options: GenerateImageVariantsOptions,\n): Promise<GeneratedImageDescriptor> {\n  const disk = remoteVariantDisk(options.disk);\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), disk.cacheRoot);\n  if (!images) throw new ImageVariantsConfigError(\"uploads.images is not configured.\");\n  const names = options.variants ?? Object.keys(images.variants);\n  for (const name of names) {\n    if (!Object.prototype.hasOwnProperty.call(images.variants, name))\n      throw new HttpError(400, `Unknown variant \"${name}\".`);\n  }\n  const source = await remoteVariantSource(relativePath, disk, images);\n  if (!source) throw new HttpError(404, \"File Not Found\");\n  try {\n    const { image, sourceFormat } = await source.load();\n    const { width, height } = await image.metadata();\n    const variantSrc = `${(options.urlPrefix ?? \"/uploads\").replace(/\\/$/, \"\")}/${encodeUploadsPath(source.relativePath)}`;\n    const variants: Record<string, GeneratedImageVariant> = {};\n    for (const name of names) {\n      let dimensions: { width: number; height: number } | undefined;\n      for (const format of outputFormatsFor(sourceFormat, images.formats)) {\n        const resolved = await renderRemoteImageVariant(\n          {\n            path: relativePath,\n            variant: name,\n            ...(format === sourceFormat ? {} : { format }),\n          },\n          disk,\n          images,\n          source,\n        );\n        if (!resolved) throw new HttpError(404, \"File Not Found\");\n        dimensions ??= await readDerivativeDimensions(resolved.absolutePath);\n      }\n      variants[name] = {\n        width: dimensions?.width ?? 0,\n        height: dimensions?.height ?? 0,\n        url: variantUrl(variantSrc, name),\n        ...(images.formats.length\n          ? {\n              urls: Object.fromEntries(\n                images.formats.map((format) => [format, variantUrl(variantSrc, name, format)]),\n              ),\n            }\n          : {}),\n      };\n    }\n    return {\n      src: disk.driver.url(source.relativePath),\n      width: width ?? 0,\n      height: height ?? 0,\n      variants,\n      ...(images.formats.length ? { formats: images.formats } : {}),\n    };\n  } finally {\n    source.release();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmDA,SAAS,kBAAkB,cAA8B;CACvD,OAAO,aAAa,MAAM,GAAG,CAAC,CAAC,IAAI,kBAAkB,CAAC,CAAC,KAAK,GAAG;AACjE;AAEA,SAAS,WAAW,KAAa,MAAc,QAAsC;CAKnF,OAAO,GAAG,IAAI,GAJA,SACV,WAAW,mBAAmB,IAAI,EAAE,UAAU,WAC9C,WAAW,mBAAmB,IAAI;AAGxC;AAEA,eAAe,yBACb,QAC4C;CAE5C,MAAM,EAAE,OAAO,WAAW,MAAM,IADT,MAAM,MAAM,GAAG,SAAS,MAAM,CACZ,CAAC,CAAC,SAAS;CAEpD,OAAO;EAAE,OAAO,SAAS;EAAG,QAAQ,UAAU;CAAE;AAClD;;;;;;AAOA,SAAS,iBACP,cACA,mBACuB;CACvB,OAAO,CAAC,GAAG,IAAI,IAAyB,CAAC,cAAc,GAAG,iBAAiB,CAAC,CAAC;AAC/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,eAAsB,sBACpB,cACA,UAAwC,CAAC,GACN;CACnC,MAAM,cAAc,cAAc,QAAQ,IAAI;CAE9C,IAAI,CAAC,aAAa,OAAO,4BAA4B,cAAc,OAAO;CAE1E,MAAM,SAAS,2BAA2B,cAAc,QAAQ,GAAG,WAAW;CAE9E,IAAI,CAAC,QACH,MAAM,IAAI,yBAAyB,mCAAmC;CAGxE,MAAM,QAAQ,QAAQ,YAAY,OAAO,KAAK,OAAO,QAAQ;CAE7D,KAAK,MAAM,QAAQ,OACjB,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,UAAU,IAAI,GAC7D,MAAM,IAAI,UAAU,KAAK,oBAAoB,KAAK,GAAG;CAIzD,MAAM,YAAY,MAAM,wBAAwB,cAAc,aAAa,MAAM;CAEjF,IAAI,CAAC,WACH,MAAM,IAAI,UAAU,KAAK,gBAAgB;CAG3C,MAAM,EAAE,QAAQ,OAAO,iBAAiB;CAExC,MAAM,QAAQ,MAAM,kBAAkB,OAAO,cAAc;EACzD,gBAAgB,OAAO;EACvB,iBAAiB,OAAO;EACxB,gBAAgB;CAClB,CAAC;CAED,MAAM,EAAE,OAAO,aAAa,QAAQ,iBAAiB,MAAM,MAAM,SAAS;CAC1E,2BAA2B,OAAO,cAAc;CAEhD,MAAM,MAAM,IAAI,QAAQ,aAAa,WAAU,CAAE,QAAQ,OAAO,EAAE,EAAE,GAAG,kBAAkB,OAAO,YAAY;CAC5G,MAAM,WAAkD,CAAC;CAEzD,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,UAAU,OAAO,SAAS;EAChC,IAAI,YAAY,QACd,MAAM,IAAI,UAAU,KAAK,oBAAoB,KAAK,GAAG;EAEvD,MAAM,UAAU,iBAAiB,cAAc,OAAO,OAAO;EAC7D,IAAI;EAEJ,KAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,OAAO,gBAAgB;IAC3B,cAAc,OAAO;IACrB,YAAY,MAAM;IAClB,eAAe,MAAM;IACrB;IACA;GACF,CAAC;GACD,MAAM,YAAY,iBAAiB,OAAO,MAAM,OAAO,YAAY;GACnE,MAAM,aAAa,qBAAqB,MAAM,MAAM,MAAM,OAAO;GACjE,MAAM,SAAS,iBACb,OAAO,gBACP;IAAE;IAAW;GAAW,GACxB,MACA,MACF;GAEA,IAAI,CAAE,MAAM,kBAAkB,QAAQ,OAAO,WAAW,GAEtD,MAAM,mBAAmB,IAAI,QAAQ,YAAY;IAC/C,IAAI,MAAM,kBAAkB,QAAQ,OAAO,WAAW,GAAG;IAEzD,MAAM,+BACJ,qBAAqB;KAAE,OAAO,MAAM,MAAM;KAAG;KAAS;KAAQ,YAAY;IAAO,CAAC,CACpF;IACA,8BAA8B,QAAQ,MAAM;IAC5C,MAAM,sCACJ,OAAO,cACP,uBAAuB,OAAO,gBAAgB,SAAS,GACvD,UACF;GACF,CAAC;GAGH,IAAI,eAAe,QACjB,aAAa,MAAM,yBAAyB,MAAM;EAEtD;EAEA,MAAM,OAA0D,CAAC;EAEjE,KAAK,MAAM,UAAU,OAAO,SAC1B,KAAK,UAAU,WAAW,KAAK,MAAM,MAAM;EAG7C,SAAS,QAAQ;GACf,OAAO,YAAY,SAAS,QAAQ;GACpC,QACE,YAAY,UACZ,QAAQ,UACR,KAAK,MAAM,QAAQ,UAAU,gBAAgB,MAAM,eAAe,GAAG;GACvE,KAAK,WAAW,KAAK,IAAI;GACzB,GAAI,OAAO,KAAK,IAAI,CAAC,CAAC,SAAS,IAAI,EAAE,KAAK,IAAI,CAAC;EACjD;CACF;CAEA,OAAO;EACL;EACA,OAAO,eAAe;EACtB,QAAQ,gBAAgB;EACxB;EACA,GAAI,OAAO,QAAQ,SAAS,IAAI,EAAE,SAAS,OAAO,QAAQ,IAAI,CAAC;CACjE;AACF;AAEA,eAAe,4BACb,cACA,SACmC;CACnC,MAAM,OAAO,kBAAkB,QAAQ,IAAI;CAC3C,MAAM,SAAS,2BAA2B,cAAc,QAAQ,GAAG,KAAK,SAAS;CACjF,IAAI,CAAC,QAAQ,MAAM,IAAI,yBAAyB,mCAAmC;CACnF,MAAM,QAAQ,QAAQ,YAAY,OAAO,KAAK,OAAO,QAAQ;CAC7D,KAAK,MAAM,QAAQ,OACjB,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,UAAU,IAAI,GAC7D,MAAM,IAAI,UAAU,KAAK,oBAAoB,KAAK,GAAG;CAEzD,MAAM,SAAS,MAAM,oBAAoB,cAAc,MAAM,MAAM;CACnE,IAAI,CAAC,QAAQ,MAAM,IAAI,UAAU,KAAK,gBAAgB;CACtD,IAAI;EACF,MAAM,EAAE,OAAO,iBAAiB,MAAM,OAAO,KAAK;EAClD,MAAM,EAAE,OAAO,WAAW,MAAM,MAAM,SAAS;EAC/C,MAAM,aAAa,IAAI,QAAQ,aAAa,WAAU,CAAE,QAAQ,OAAO,EAAE,EAAE,GAAG,kBAAkB,OAAO,YAAY;EACnH,MAAM,WAAkD,CAAC;EACzD,KAAK,MAAM,QAAQ,OAAO;GACxB,IAAI;GACJ,KAAK,MAAM,UAAU,iBAAiB,cAAc,OAAO,OAAO,GAAG;IACnE,MAAM,WAAW,MAAM,yBACrB;KACE,MAAM;KACN,SAAS;KACT,GAAI,WAAW,eAAe,CAAC,IAAI,EAAE,OAAO;IAC9C,GACA,MACA,QACA,MACF;IACA,IAAI,CAAC,UAAU,MAAM,IAAI,UAAU,KAAK,gBAAgB;IACxD,eAAe,MAAM,yBAAyB,SAAS,YAAY;GACrE;GACA,SAAS,QAAQ;IACf,OAAO,YAAY,SAAS;IAC5B,QAAQ,YAAY,UAAU;IAC9B,KAAK,WAAW,YAAY,IAAI;IAChC,GAAI,OAAO,QAAQ,SACf,EACE,MAAM,OAAO,YACX,OAAO,QAAQ,KAAK,WAAW,CAAC,QAAQ,WAAW,YAAY,MAAM,MAAM,CAAC,CAAC,CAC/E,EACF,IACA,CAAC;GACP;EACF;EACA,OAAO;GACL,KAAK,KAAK,OAAO,IAAI,OAAO,YAAY;GACxC,OAAO,SAAS;GAChB,QAAQ,UAAU;GAClB;GACA,GAAI,OAAO,QAAQ,SAAS,EAAE,SAAS,OAAO,QAAQ,IAAI,CAAC;EAC7D;CACF,UAAU;EACR,OAAO,QAAQ;CACjB;AACF"}
+{"version":3,"file":"generate-image-variants.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/http/uploads/generate-image-variants.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport { Image } from \"../../image\";\nimport type { StorageDriverName } from \"../../storage/types\";\nimport { localDiskRoot } from \"./local-disk-root\";\nimport { remoteVariantDisk, remoteVariantSource } from \"./remote-variant-source\";\nimport { renderRemoteImageVariant } from \"./resolve-remote-image-variant\";\nimport { HttpError } from \"../errors\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport type { ImageVariantOutputFormat } from \"../uploads-types\";\nimport { generateImageVariant } from \"./generate-image-variant\";\nimport {\n  pruneStaleVariantGenerationsIfCurrent,\n  retryOnVanishedDirectory,\n  warnIfVariantCacheIsPublic,\n} from \"./image-variant-cache\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport type {\n  GeneratedImageDescriptor,\n  GeneratedImageVariant,\n  VariantOutputFormat,\n} from \"./image-variant-types\";\nimport { loadVariantSource } from \"./load-variant-source\";\nimport { resolveImageVariantsConfig } from \"./resolve-image-variants-config\";\nimport { resolveVariantCandidate } from \"./resolve-variant-candidate\";\nimport {\n  variantCacheKey,\n  variantCachePath,\n  variantGenerationTag,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\nimport { freshImageVariant, scheduleImageVariantCacheTrim } from \"./trim-image-variant-cache\";\nimport { variantGenerations } from \"./variant-generations\";\n\n/**\n * Options for `generateImageVariants`\n */\nexport type GenerateImageVariantsOptions = {\n  /**\n   * Limit generation to these variant names, instead of every variant in\n   * `uploads.images.variants`.\n   */\n  variants?: readonly string[];\n\n  /** Disk holding the source; defaults to the active disk. */\n  disk?: StorageDriverName;\n\n  /** Route prefix serving variants of this disk (and originals for local disks). Default /uploads. */\n  urlPrefix?: string;\n};\n\nfunction encodeUploadsPath(relativePath: string): string {\n  return relativePath.split(\"/\").map(encodeURIComponent).join(\"/\");\n}\n\nfunction variantUrl(src: string, name: string, format?: VariantOutputFormat): string {\n  const query = format\n    ? `variant=${encodeURIComponent(name)}&format=${format}`\n    : `variant=${encodeURIComponent(name)}`;\n\n  return `${src}?${query}`;\n}\n\nasync function readDerivativeDimensions(\n  target: string,\n): Promise<{ width: number; height: number }> {\n  const derivative = new Image(await fs.readFile(target));\n  const { width, height } = await derivative.metadata();\n\n  return { width: width ?? 0, height: height ?? 0 };\n}\n\n/**\n * Every distinct format a variant is rendered in: the source format plus\n * whatever `uploads.images.formats` adds, with duplicates dropped so a format\n * that is both the source format and an allowed format is generated once.\n */\nfunction outputFormatsFor(\n  sourceFormat: VariantOutputFormat,\n  configuredFormats: readonly ImageVariantOutputFormat[],\n): VariantOutputFormat[] {\n  return [...new Set<VariantOutputFormat>([sourceFormat, ...configuredFormats])];\n}\n\n/**\n * Render every configured variant of one uploaded image, right after it is\n * saved.\n *\n * Uses the exact same normalized config (`uploads.images`), cache key and\n * derivative path as `uploadedFileController`, so a variant generated here is\n * already on disk the first time `GET /uploads/<path>?variant=<name>` is\n * requested — no second render. `variantGenerations` (the single-flight used\n * by the route) is reused, so a concurrent request for a variant this call is\n * still generating joins the same run instead of starting a second one.\n *\n * The returned descriptor is plain JSON, safe to store next to the record\n * that owns the image, or to carry through loader data. On local storage the\n * `url`/`urls` already point at `uploadedFileController`; an app serving\n * uploads from object storage use the driver URL for the original, and\n * `options.urlPrefix` for the route serving locally cached derivatives.\n * Ingest downloads a remote source once for all variants and formats.\n * On-demand cache hits use ETag metadata; sources without ETags are hashed.\n *\n * @param relativePath - path of the saved upload, relative to the storage root\n * @param options.variants - limit generation to these variant names\n * @throws ImageVariantsConfigError when `uploads.images` is not\n * configured — this is server misconfiguration, not\n * a bad request\n * @throws HttpError(400) when a name in `options.variants` is not declared in\n * `uploads.images.variants`\n * @throws HttpError(404) when `relativePath` does not resolve to a file\n * inside the storage root\n * @throws HttpError(413) when the source is over `maxSourceBytes` or\n * `maxSourcePixels`\n * @throws HttpError(415) when the source is not jpeg, png, webp or avif\n */\nexport async function generateImageVariants(\n  relativePath: string,\n  options: GenerateImageVariantsOptions = {},\n): Promise<GeneratedImageDescriptor> {\n  const storageRoot = localDiskRoot(options.disk);\n\n  if (!storageRoot) return generateRemoteImageVariants(relativePath, options);\n\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), storageRoot);\n\n  if (!images) {\n    throw new ImageVariantsConfigError(\"uploads.images is not configured.\");\n  }\n\n  const names = options.variants ?? Object.keys(images.variants);\n\n  for (const name of names) {\n    if (!Object.prototype.hasOwnProperty.call(images.variants, name)) {\n      throw new HttpError(400, `Unknown variant \"${name}\".`);\n    }\n  }\n\n  const candidate = await resolveVariantCandidate(relativePath, storageRoot, images);\n\n  if (!candidate) {\n    throw new HttpError(404, \"File Not Found\");\n  }\n\n  const { source, stats, sourceFormat } = candidate;\n\n  const image = await loadVariantSource(source.absolutePath, {\n    maxSourceBytes: images.maxSourceBytes,\n    maxSourcePixels: images.maxSourcePixels,\n    expectedFormat: sourceFormat,\n  });\n\n  const { width: sourceWidth, height: sourceHeight } = await image.metadata();\n  warnIfVariantCacheIsPublic(images.cacheDirectory);\n\n  const src = `${(options.urlPrefix ?? \"/uploads\").replace(/\\/$/, \"\")}/${encodeUploadsPath(source.relativePath)}`;\n  const variants: Record<string, GeneratedImageVariant> = {};\n\n  for (const name of names) {\n    const variant = images.variants[name];\n    if (variant === undefined) {\n      throw new HttpError(400, `Unknown variant \"${name}\".`);\n    }\n    const formats = outputFormatsFor(sourceFormat, images.formats);\n    let dimensions: { width: number; height: number } | undefined;\n\n    for (const format of formats) {\n      const hash = variantCacheKey({\n        relativePath: source.relativePath,\n        sourceSize: stats.size,\n        sourceMtimeMs: stats.mtimeMs,\n        variant,\n        format,\n      });\n      const sourceKey = variantSourceKey(source.root, source.relativePath);\n      const generation = variantGenerationTag(stats.size, stats.mtimeMs);\n      const target = variantCachePath(\n        images.cacheDirectory,\n        { sourceKey, generation },\n        hash,\n        format,\n      );\n\n      if (!(await freshImageVariant(target, images.maxCacheAge))) {\n        // keyed on the target, which includes the disk root (see resolveImageVariant)\n        await variantGenerations.run(target, async () => {\n          if (await freshImageVariant(target, images.maxCacheAge)) return;\n\n          await retryOnVanishedDirectory(() =>\n            generateImageVariant({ image: image.clone(), variant, format, targetPath: target }),\n          );\n          scheduleImageVariantCacheTrim(images, target);\n          await pruneStaleVariantGenerationsIfCurrent(\n            source.absolutePath,\n            variantSourceDirectory(images.cacheDirectory, sourceKey),\n            generation,\n          );\n        });\n      }\n\n      if (dimensions === undefined) {\n        dimensions = await readDerivativeDimensions(target);\n      }\n    }\n\n    const urls: Partial<Record<ImageVariantOutputFormat, string>> = {};\n\n    for (const format of images.formats) {\n      urls[format] = variantUrl(src, name, format);\n    }\n\n    variants[name] = {\n      width: dimensions?.width ?? variant.width,\n      height:\n        dimensions?.height ??\n        variant.height ??\n        Math.round(variant.width * ((sourceHeight ?? 1) / (sourceWidth ?? 1))),\n      url: variantUrl(src, name),\n      ...(Object.keys(urls).length > 0 ? { urls } : {}),\n    };\n  }\n\n  return {\n    src,\n    width: sourceWidth ?? 0,\n    height: sourceHeight ?? 0,\n    variants,\n    ...(images.formats.length > 0 ? { formats: images.formats } : {}),\n  };\n}\n\nasync function generateRemoteImageVariants(\n  relativePath: string,\n  options: GenerateImageVariantsOptions,\n): Promise<GeneratedImageDescriptor> {\n  const disk = remoteVariantDisk(options.disk);\n  const images = resolveImageVariantsConfig(uploadsConfig(\"images\"), disk.cacheRoot);\n  if (!images) throw new ImageVariantsConfigError(\"uploads.images is not configured.\");\n  const names = options.variants ?? Object.keys(images.variants);\n  for (const name of names) {\n    if (!Object.prototype.hasOwnProperty.call(images.variants, name))\n      throw new HttpError(400, `Unknown variant \"${name}\".`);\n  }\n  const source = await remoteVariantSource(relativePath, disk, images);\n  if (!source) throw new HttpError(404, \"File Not Found\");\n  try {\n    const { image, sourceFormat } = await source.load();\n    const { width, height } = await image.metadata();\n    const variantSrc = `${(options.urlPrefix ?? \"/uploads\").replace(/\\/$/, \"\")}/${encodeUploadsPath(source.relativePath)}`;\n    const variants: Record<string, GeneratedImageVariant> = {};\n    for (const name of names) {\n      let dimensions: { width: number; height: number } | undefined;\n      for (const format of outputFormatsFor(sourceFormat, images.formats)) {\n        const resolved = await renderRemoteImageVariant(\n          {\n            path: relativePath,\n            variant: name,\n            ...(format === sourceFormat ? {} : { format }),\n          },\n          disk,\n          images,\n          source,\n        );\n        if (!resolved) throw new HttpError(404, \"File Not Found\");\n        dimensions ??= await readDerivativeDimensions(resolved.absolutePath);\n      }\n      variants[name] = {\n        width: dimensions?.width ?? 0,\n        height: dimensions?.height ?? 0,\n        url: variantUrl(variantSrc, name),\n        ...(images.formats.length\n          ? {\n              urls: Object.fromEntries(\n                images.formats.map((format) => [format, variantUrl(variantSrc, name, format)]),\n              ),\n            }\n          : {}),\n      };\n    }\n    return {\n      src: disk.driver.url(source.relativePath),\n      width: width ?? 0,\n      height: height ?? 0,\n      variants,\n      ...(images.formats.length ? { formats: images.formats } : {}),\n    };\n  } finally {\n    source.release();\n  }\n}\n"],"mappings":"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"}

package/esm/http/uploads/image-variant-cache-entries.mjs

@@ -74,5 +74,5 @@ async function purgeVariantCacheEntries(entries) {
 }
 
 //#endregion
-export { purgeVariantCacheEntries, variantCacheEntries, variantCacheGenerations, variantSourceCacheEntries };
+export { purgeVariantCacheEntries, variantCacheEntries, variantCacheGenerations, variantSourceCacheEntries, variantSourceCacheGenerations };
 //# sourceMappingURL=image-variant-cache-entries.mjs.map

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

@@ -5,16 +5,16 @@ import { purgeVariantCacheEntries, variantSourceCacheEntries } from "./image-var
 import { uploadsConfig } from "../uploads-config.mjs";
 import { isPathInside, isPathWithin } from "./is-path-inside.mjs";
 import { variantGenerationTag, variantSourceDirectory, variantSourceKey } from "./variant-cache-key.mjs";
-import config from "@mongez/config";
+import baseConfig from "@mongez/config";
 import { log } from "@warlock.js/logger";
 import path from "node:path";
-import fs from "node:fs";
-import fs$1 from "node:fs/promises";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
 
 //#region ../../packages/core/src/http/uploads/image-variant-cache.ts
 async function realpathOrSelf(target) {
 	try {
-		return await fs$1.realpath(target);
+		return await fs.realpath(target);
 	} catch {
 		return target;
 	}
@@ -22,7 +22,7 @@ async function realpathOrSelf(target) {
 function canonicalDirectory(target) {
 	const resolved = path.resolve(target);
 	try {
-		return fs.realpathSync(resolved);
+		return fsSync.realpathSync(resolved);
 	} catch (error) {
 		const code = error.code;
 		if (code !== "ENOENT") throw new ImageVariantsConfigError(`uploads.images.cacheDirectory (or a local disk root) could not be resolved: ${resolved} (${code ?? "unknown error"})`, { cause: error });
@@ -132,7 +132,7 @@ async function pruneStaleVariantGenerations(sourceDirectory, keep) {
 async function pruneStaleVariantGenerationsIfCurrent(sourceAbsolutePath, sourceDirectory, keep) {
 	let current;
 	try {
-		const stats = await fs$1.stat(sourceAbsolutePath);
+		const stats = await fs.stat(sourceAbsolutePath);
 		current = variantGenerationTag(stats.size, stats.mtimeMs);
 	} catch {
 		return;
@@ -172,7 +172,7 @@ let warnedPublicCache = false;
 */
 function warnIfVariantCacheIsPublic(cacheDirectory) {
 	if (warnedPublicCache) return;
-	const configured = config.get("storage.publicRoot", rootPath("public"));
+	const configured = baseConfig.get("storage.publicRoot", rootPath("public"));
 	const publicRoots = (Array.isArray(configured) ? configured : [configured]).filter((root) => typeof root === "string" && root.length > 0).map((root) => path.resolve(root));
 	const resolved = path.resolve(cacheDirectory);
 	if (!publicRoots.some((root) => resolved === root || isPathInside(resolved, root))) return;
@@ -181,5 +181,5 @@ function warnIfVariantCacheIsPublic(cacheDirectory) {
 }
 
 //#endregion
-export { isMissingFileError, pruneStaleVariantGenerationsIfCurrent, purgeImageVariantsOfFile, retryOnVanishedDirectory, variantCacheDirectoryFor, warnIfVariantCacheIsPublic };
+export { isMissingFileError, pruneStaleVariantGenerations, pruneStaleVariantGenerationsIfCurrent, purgeImageVariantsOfFile, retryOnVanishedDirectory, variantCacheDirectoryFor, variantSourceDirectoryForFile, warnIfVariantCacheIsPublic };
 //# sourceMappingURL=image-variant-cache.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"image-variant-cache.mjs","names":["fs","fsSync"],"sources":["../../../../../../../../../packages/core/src/http/uploads/image-variant-cache.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { log } from \"@warlock.js/logger\";\nimport fs from \"node:fs/promises\";\nimport fsSync from \"node:fs\";\nimport { configuredLocalDiskRoots } from \"../../storage/local-disk-roots\";\nimport type { UploadsImagesConfigurations } from \"../uploads-types\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport { purgeVariantCacheEntries, variantSourceCacheEntries } from \"./image-variant-cache-entries\";\nimport path from \"node:path\";\nimport { rootPath } from \"../../utils/paths\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport { isPathInside, isPathWithin } from \"./is-path-inside\";\nimport {\n  variantGenerationTag,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\n\n/*\n * Cache housekeeping for image derivatives. Deliberately free of any\n * import of the storage manager or drivers: the local driver calls into this module when it\n * deletes or moves a file, and storage must not import back into the HTTP\n * layer that already imports storage.\n */\n\nasync function realpathOrSelf(target: string): Promise<string> {\n  try {\n    return await fs.realpath(target);\n  } catch {\n    return target;\n  }\n}\n\nfunction canonicalDirectory(target: string): string {\n  const resolved = path.resolve(target);\n  try {\n    return fsSync.realpathSync(resolved);\n  } catch (error) {\n    const code = (error as NodeJS.ErrnoException).code;\n    if (code !== \"ENOENT\") {\n      // ENOTDIR, EACCES, ELOOP, ...: a configuration problem, reported as one.\n      throw new ImageVariantsConfigError(\n        `uploads.images.cacheDirectory (or a local disk root) could not be resolved: ${resolved} (${code ?? \"unknown error\"})`,\n        { cause: error },\n      );\n    }\n    const parent = path.dirname(resolved);\n    if (parent === resolved) throw error;\n    // Resolve the nearest existing ancestor too, so a symlink followed by a\n    // not-yet-created directory cannot hide an overlap with a future disk root.\n    return path.join(canonicalDirectory(parent), path.basename(resolved));\n  }\n}\n\n/** Most distinct cache/disk-root combinations whose overlap check is remembered. */\nconst OVERLAP_CHECKS_LIMIT = 64;\n\n/**\n * Overlap check outcomes, keyed by the cache directory, the disk root and\n * every configured local root. A disk registered later changes the key, so\n * it is checked again; the stored error is rethrown for a refused layout.\n */\nconst overlapChecks = new Map<string, ImageVariantsConfigError | undefined>();\n\nfunction checkCacheOverlap(directory: string, diskRoot: string): void {\n  const roots = [diskRoot, ...configuredLocalDiskRoots()];\n  const key = [directory, ...roots].join(\"\\0\");\n  if (overlapChecks.has(key)) {\n    const failure = overlapChecks.get(key);\n    if (failure) throw failure;\n    return;\n  }\n  let failure: ImageVariantsConfigError | undefined;\n  try {\n    const realCache = canonicalDirectory(directory);\n    for (const root of roots) {\n      if (isPathWithin(canonicalDirectory(root), realCache)) {\n        failure = new ImageVariantsConfigError(\n          \"uploads.images.cacheDirectory must not equal or contain the storage root of any local disk (including symlinks).\",\n        );\n        break;\n      }\n    }\n  } catch (error) {\n    // Only configuration errors are remembered; anything else is retried next time.\n    if (!(error instanceof ImageVariantsConfigError)) throw error;\n    failure = error;\n  }\n  if (overlapChecks.size >= OVERLAP_CHECKS_LIMIT) {\n    const oldest = overlapChecks.keys().next();\n    if (!oldest.done) overlapChecks.delete(oldest.value);\n  }\n  overlapChecks.set(key, failure);\n  if (failure) throw failure;\n}\n\n/**\n * Forget remembered cache overlap checks, so the next check resolves every\n * path again (tests). Changes to the configured disks are detected without it;\n * a directory replaced by a symlink at runtime is not.\n */\nexport function resetVariantCacheOverlapChecks(): void {\n  overlapChecks.clear();\n}\n\n/**\n * The derivative cache directory for a local disk: `uploads.images.cacheDirectory`\n * when the app sets one (shared by every disk; derivatives are keyed by the\n * disk's real root, so they never collide), otherwise\n * `<diskRoot>/.cache/image-variants`. The same rule as\n * `resolveImageVariantsConfig`. Refuses any cache that equals or contains\n * any configured local root, resolving symlinks before comparison. The\n * outcome is remembered per cache, disk root and configured local roots, so\n * repeated requests do not resolve the same paths again.\n *\n * @throws ImageVariantsConfigError when a cache overlaps a local disk root, or\n * when the cache or a root cannot be resolved (for example `ENOTDIR`, `EACCES`)\n */\nexport function variantCacheDirectoryFor(\n  diskRoot: string,\n  images: Pick<UploadsImagesConfigurations, \"cacheDirectory\"> | undefined = uploadsConfig(\"images\"),\n): string {\n  const configured = images?.cacheDirectory;\n  const directory = configured\n    ? path.resolve(configured)\n    : path.join(path.resolve(diskRoot), \".cache\", \"image-variants\");\n  checkCacheOverlap(directory, diskRoot);\n  return directory;\n}\n\n/**\n * The directory holding every derivative of one file on a local disk, or\n * `undefined` when the file is not inside the disk root. The file does not\n * need to exist any more: only its parent directory is resolved through\n * symlinks, exactly as `resolveUploadPath` resolved it when the derivative\n * was made.\n */\nexport async function variantSourceDirectoryForFile(\n  diskRoot: string,\n  absolutePath: string,\n): Promise<string | undefined> {\n  const realRoot = await realpathOrSelf(path.resolve(diskRoot));\n  const realParent = await realpathOrSelf(path.dirname(path.resolve(absolutePath)));\n  const realPath = path.join(realParent, path.basename(absolutePath));\n\n  if (!isPathInside(realPath, realRoot)) return undefined;\n\n  const relativePath = path.relative(realRoot, realPath).split(path.sep).join(\"/\");\n\n  return variantSourceDirectory(\n    variantCacheDirectoryFor(diskRoot),\n    variantSourceKey(realRoot, relativePath),\n  );\n}\n\n/**\n * Remove every cached derivative of one file on a local disk.\n *\n * @returns `true` when recognized cache files were removed\n */\nexport async function purgeImageVariantsOfFile(\n  diskRoot: string,\n  absolutePath: string,\n): Promise<boolean> {\n  const directory = await variantSourceDirectoryForFile(diskRoot, absolutePath);\n\n  if (!directory) return false;\n\n  return purgeVariantCacheEntries(variantSourceCacheEntries(directory));\n}\n\n/**\n * Remove derivatives made from older versions of a source (a different size\n * or mtime), keeping only the `keep` generation. Called after a derivative of\n * the current version has been written, so a source rewritten in place does\n * not leave its old derivatives behind. Only recognized cache files in\n * generation-shaped directories are removed; unrelated entries and all\n * directories and symlinks stay in place.\n */\nexport async function pruneStaleVariantGenerations(\n  sourceDirectory: string,\n  keep: string,\n): Promise<void> {\n  await purgeVariantCacheEntries(variantSourceCacheEntries(sourceDirectory, keep));\n}\n\n/**\n * {@link pruneStaleVariantGenerations}, but only while `keep` is still the\n * source's current generation.\n *\n * A request that read the source before it was rewritten renders an old\n * generation; if it pruned afterwards it would delete the derivatives of the\n * newer version another request had just written. Re-reading the source's\n * size and mtime right before pruning keeps a stale request from doing that.\n */\nexport async function pruneStaleVariantGenerationsIfCurrent(\n  sourceAbsolutePath: string,\n  sourceDirectory: string,\n  keep: string,\n): Promise<void> {\n  let current: string;\n\n  try {\n    const stats = await fs.stat(sourceAbsolutePath);\n    current = variantGenerationTag(stats.size, stats.mtimeMs);\n  } catch {\n    // the source is gone; its derivatives are purged by the delete itself\n    return;\n  }\n\n  if (current !== keep) return;\n\n  await pruneStaleVariantGenerations(sourceDirectory, keep);\n}\n\n/**\n * True for \"no such file or directory\"\n */\nexport function isMissingFileError(error: unknown): boolean {\n  return (error as NodeJS.ErrnoException | undefined)?.code === \"ENOENT\";\n}\n\n/**\n * Run a derivative write, once more if it fails because its directory\n * vanished: a concurrent request for a newer version of the source may prune\n * the generation directory between `mkdir` and the atomic rename.\n */\nexport async function retryOnVanishedDirectory(write: () => Promise<void>): Promise<void> {\n  try {\n    await write();\n  } catch (error) {\n    if (!isMissingFileError(error)) throw error;\n\n    await write();\n  }\n}\n\nlet warnedPublicCache = false;\n\n/**\n * Warn once when the derivative cache sits inside the public folder.\n *\n * A configured `uploads.images.cacheDirectory` is shared by every local disk,\n * so derivatives of a private disk land beside public ones. Inside\n * `public/` (or `storage.publicRoot`) they are served to anyone, bypassing\n * whatever guards the private disk's own route. The paths are hashes, but\n * they are derived from the disk root and the file path, which are not\n * secret.\n */\nexport function warnIfVariantCacheIsPublic(cacheDirectory: string): void {\n  if (warnedPublicCache) return;\n\n  const configured = config.get(\"storage.publicRoot\", rootPath(\"public\")) as unknown;\n  const publicRoots = (Array.isArray(configured) ? configured : [configured])\n    .filter((root): root is string => typeof root === \"string\" && root.length > 0)\n    .map((root) => path.resolve(root));\n  const resolved = path.resolve(cacheDirectory);\n\n  if (!publicRoots.some((root) => resolved === root || isPathInside(resolved, root))) return;\n\n  warnedPublicCache = true;\n  log.warn(\n    \"uploads\",\n    \"image-variants\",\n    `The image variant cache (${resolved}) is inside the public folder, so every cached derivative, private disks included, is publicly served. Move uploads.images.cacheDirectory outside public/.`,\n  );\n}\n\n/**\n * Forget that the public-cache warning was shown (tests).\n */\nexport function resetVariantCacheWarnings(): void {\n  warnedPublicCache = false;\n}\n"],"mappings":"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"}
+{"version":3,"file":"image-variant-cache.mjs","names":["config"],"sources":["../../../../../../../../../packages/core/src/http/uploads/image-variant-cache.ts"],"sourcesContent":["import config from \"@mongez/config\";\nimport { log } from \"@warlock.js/logger\";\nimport fs from \"node:fs/promises\";\nimport fsSync from \"node:fs\";\nimport { configuredLocalDiskRoots } from \"../../storage/local-disk-roots\";\nimport type { UploadsImagesConfigurations } from \"../uploads-types\";\nimport { ImageVariantsConfigError } from \"./image-variants-config-error\";\nimport { purgeVariantCacheEntries, variantSourceCacheEntries } from \"./image-variant-cache-entries\";\nimport path from \"node:path\";\nimport { rootPath } from \"../../utils/paths\";\nimport { uploadsConfig } from \"../uploads-config\";\nimport { isPathInside, isPathWithin } from \"./is-path-inside\";\nimport {\n  variantGenerationTag,\n  variantSourceDirectory,\n  variantSourceKey,\n} from \"./variant-cache-key\";\n\n/*\n * Cache housekeeping for image derivatives. Deliberately free of any\n * import of the storage manager or drivers: the local driver calls into this module when it\n * deletes or moves a file, and storage must not import back into the HTTP\n * layer that already imports storage.\n */\n\nasync function realpathOrSelf(target: string): Promise<string> {\n  try {\n    return await fs.realpath(target);\n  } catch {\n    return target;\n  }\n}\n\nfunction canonicalDirectory(target: string): string {\n  const resolved = path.resolve(target);\n  try {\n    return fsSync.realpathSync(resolved);\n  } catch (error) {\n    const code = (error as NodeJS.ErrnoException).code;\n    if (code !== \"ENOENT\") {\n      // ENOTDIR, EACCES, ELOOP, ...: a configuration problem, reported as one.\n      throw new ImageVariantsConfigError(\n        `uploads.images.cacheDirectory (or a local disk root) could not be resolved: ${resolved} (${code ?? \"unknown error\"})`,\n        { cause: error },\n      );\n    }\n    const parent = path.dirname(resolved);\n    if (parent === resolved) throw error;\n    // Resolve the nearest existing ancestor too, so a symlink followed by a\n    // not-yet-created directory cannot hide an overlap with a future disk root.\n    return path.join(canonicalDirectory(parent), path.basename(resolved));\n  }\n}\n\n/** Most distinct cache/disk-root combinations whose overlap check is remembered. */\nconst OVERLAP_CHECKS_LIMIT = 64;\n\n/**\n * Overlap check outcomes, keyed by the cache directory, the disk root and\n * every configured local root. A disk registered later changes the key, so\n * it is checked again; the stored error is rethrown for a refused layout.\n */\nconst overlapChecks = new Map<string, ImageVariantsConfigError | undefined>();\n\nfunction checkCacheOverlap(directory: string, diskRoot: string): void {\n  const roots = [diskRoot, ...configuredLocalDiskRoots()];\n  const key = [directory, ...roots].join(\"\\0\");\n  if (overlapChecks.has(key)) {\n    const failure = overlapChecks.get(key);\n    if (failure) throw failure;\n    return;\n  }\n  let failure: ImageVariantsConfigError | undefined;\n  try {\n    const realCache = canonicalDirectory(directory);\n    for (const root of roots) {\n      if (isPathWithin(canonicalDirectory(root), realCache)) {\n        failure = new ImageVariantsConfigError(\n          \"uploads.images.cacheDirectory must not equal or contain the storage root of any local disk (including symlinks).\",\n        );\n        break;\n      }\n    }\n  } catch (error) {\n    // Only configuration errors are remembered; anything else is retried next time.\n    if (!(error instanceof ImageVariantsConfigError)) throw error;\n    failure = error;\n  }\n  if (overlapChecks.size >= OVERLAP_CHECKS_LIMIT) {\n    const oldest = overlapChecks.keys().next();\n    if (!oldest.done) overlapChecks.delete(oldest.value);\n  }\n  overlapChecks.set(key, failure);\n  if (failure) throw failure;\n}\n\n/**\n * Forget remembered cache overlap checks, so the next check resolves every\n * path again (tests). Changes to the configured disks are detected without it;\n * a directory replaced by a symlink at runtime is not.\n */\nexport function resetVariantCacheOverlapChecks(): void {\n  overlapChecks.clear();\n}\n\n/**\n * The derivative cache directory for a local disk: `uploads.images.cacheDirectory`\n * when the app sets one (shared by every disk; derivatives are keyed by the\n * disk's real root, so they never collide), otherwise\n * `<diskRoot>/.cache/image-variants`. The same rule as\n * `resolveImageVariantsConfig`. Refuses any cache that equals or contains\n * any configured local root, resolving symlinks before comparison. The\n * outcome is remembered per cache, disk root and configured local roots, so\n * repeated requests do not resolve the same paths again.\n *\n * @throws ImageVariantsConfigError when a cache overlaps a local disk root, or\n * when the cache or a root cannot be resolved (for example `ENOTDIR`, `EACCES`)\n */\nexport function variantCacheDirectoryFor(\n  diskRoot: string,\n  images: Pick<UploadsImagesConfigurations, \"cacheDirectory\"> | undefined = uploadsConfig(\"images\"),\n): string {\n  const configured = images?.cacheDirectory;\n  const directory = configured\n    ? path.resolve(configured)\n    : path.join(path.resolve(diskRoot), \".cache\", \"image-variants\");\n  checkCacheOverlap(directory, diskRoot);\n  return directory;\n}\n\n/**\n * The directory holding every derivative of one file on a local disk, or\n * `undefined` when the file is not inside the disk root. The file does not\n * need to exist any more: only its parent directory is resolved through\n * symlinks, exactly as `resolveUploadPath` resolved it when the derivative\n * was made.\n */\nexport async function variantSourceDirectoryForFile(\n  diskRoot: string,\n  absolutePath: string,\n): Promise<string | undefined> {\n  const realRoot = await realpathOrSelf(path.resolve(diskRoot));\n  const realParent = await realpathOrSelf(path.dirname(path.resolve(absolutePath)));\n  const realPath = path.join(realParent, path.basename(absolutePath));\n\n  if (!isPathInside(realPath, realRoot)) return undefined;\n\n  const relativePath = path.relative(realRoot, realPath).split(path.sep).join(\"/\");\n\n  return variantSourceDirectory(\n    variantCacheDirectoryFor(diskRoot),\n    variantSourceKey(realRoot, relativePath),\n  );\n}\n\n/**\n * Remove every cached derivative of one file on a local disk.\n *\n * @returns `true` when recognized cache files were removed\n */\nexport async function purgeImageVariantsOfFile(\n  diskRoot: string,\n  absolutePath: string,\n): Promise<boolean> {\n  const directory = await variantSourceDirectoryForFile(diskRoot, absolutePath);\n\n  if (!directory) return false;\n\n  return purgeVariantCacheEntries(variantSourceCacheEntries(directory));\n}\n\n/**\n * Remove derivatives made from older versions of a source (a different size\n * or mtime), keeping only the `keep` generation. Called after a derivative of\n * the current version has been written, so a source rewritten in place does\n * not leave its old derivatives behind. Only recognized cache files in\n * generation-shaped directories are removed; unrelated entries and all\n * directories and symlinks stay in place.\n */\nexport async function pruneStaleVariantGenerations(\n  sourceDirectory: string,\n  keep: string,\n): Promise<void> {\n  await purgeVariantCacheEntries(variantSourceCacheEntries(sourceDirectory, keep));\n}\n\n/**\n * {@link pruneStaleVariantGenerations}, but only while `keep` is still the\n * source's current generation.\n *\n * A request that read the source before it was rewritten renders an old\n * generation; if it pruned afterwards it would delete the derivatives of the\n * newer version another request had just written. Re-reading the source's\n * size and mtime right before pruning keeps a stale request from doing that.\n */\nexport async function pruneStaleVariantGenerationsIfCurrent(\n  sourceAbsolutePath: string,\n  sourceDirectory: string,\n  keep: string,\n): Promise<void> {\n  let current: string;\n\n  try {\n    const stats = await fs.stat(sourceAbsolutePath);\n    current = variantGenerationTag(stats.size, stats.mtimeMs);\n  } catch {\n    // the source is gone; its derivatives are purged by the delete itself\n    return;\n  }\n\n  if (current !== keep) return;\n\n  await pruneStaleVariantGenerations(sourceDirectory, keep);\n}\n\n/**\n * True for \"no such file or directory\"\n */\nexport function isMissingFileError(error: unknown): boolean {\n  return (error as NodeJS.ErrnoException | undefined)?.code === \"ENOENT\";\n}\n\n/**\n * Run a derivative write, once more if it fails because its directory\n * vanished: a concurrent request for a newer version of the source may prune\n * the generation directory between `mkdir` and the atomic rename.\n */\nexport async function retryOnVanishedDirectory(write: () => Promise<void>): Promise<void> {\n  try {\n    await write();\n  } catch (error) {\n    if (!isMissingFileError(error)) throw error;\n\n    await write();\n  }\n}\n\nlet warnedPublicCache = false;\n\n/**\n * Warn once when the derivative cache sits inside the public folder.\n *\n * A configured `uploads.images.cacheDirectory` is shared by every local disk,\n * so derivatives of a private disk land beside public ones. Inside\n * `public/` (or `storage.publicRoot`) they are served to anyone, bypassing\n * whatever guards the private disk's own route. The paths are hashes, but\n * they are derived from the disk root and the file path, which are not\n * secret.\n */\nexport function warnIfVariantCacheIsPublic(cacheDirectory: string): void {\n  if (warnedPublicCache) return;\n\n  const configured = config.get(\"storage.publicRoot\", rootPath(\"public\")) as unknown;\n  const publicRoots = (Array.isArray(configured) ? configured : [configured])\n    .filter((root): root is string => typeof root === \"string\" && root.length > 0)\n    .map((root) => path.resolve(root));\n  const resolved = path.resolve(cacheDirectory);\n\n  if (!publicRoots.some((root) => resolved === root || isPathInside(resolved, root))) return;\n\n  warnedPublicCache = true;\n  log.warn(\n    \"uploads\",\n    \"image-variants\",\n    `The image variant cache (${resolved}) is inside the public folder, so every cached derivative, private disks included, is publicly served. Move uploads.images.cacheDirectory outside public/.`,\n  );\n}\n\n/**\n * Forget that the public-cache warning was shown (tests).\n */\nexport function resetVariantCacheWarnings(): void {\n  warnedPublicCache = false;\n}\n"],"mappings":"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"}