@aglyn/tenant-data-admin 1.0.0-beta.143

package/src/lib/server/media-variants.js

@@ -0,0 +1,428 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { MEDIA_POSTER_OBJECT_SUFFIX, mediaPosterObjectPath, readImageDimensions } from "@aglyn/aglyn/server";
+import { MEDIA_CDN_VARIANT_WIDTHS } from "./serve-media-cdn.js";
+/**
+ * Formats a WebP copy at the SOURCE'S OWN width beats.
+ *
+ * A renderer's srcSet offers every width in `MEDIA_CDN_VARIANT_WIDTHS`, and
+ * `serveMediaCdn` answers a width an asset has no variant for with the
+ * original. For a JPEG or PNG no wider than a candidate, that original is what
+ * every request at or above its width downloads — the `1280w` a phone asks
+ * for, the `1920w` a desktop asks for. Measured on aglyn.com's hero poster, a
+ * 1920x1080 JPEG: 166,756 B served for `?w=1920`, where a WebP of the same
+ * 1920 pixels at the generator's quality is 40,598 B.
+ *
+ * So these formats also get the widths AT and ABOVE their own, each encoded at
+ * the source width (`withoutEnlargement`): a re-encode, never an upscale, and
+ * the same pixels the original answer served. Not GIF, whose animation a WebP
+ * frame would drop; not WebP or AVIF, which a re-encode could make larger.
+ */ const SOURCE_WIDTH_WEBP_TYPES = new Set([
+    'image/jpeg',
+    'image/jpg',
+    'image/png'
+]);
+/**
+ * `image/*` types that produce no variants, for two different reasons.
+ *
+ * SVG is a vector: there is nothing to downscale, and rasterizing it would be
+ * a different asset rather than a variant of this one.
+ *
+ * ICO carries no `sharp` decoder at all, so attempting it raises an
+ * unsupported-format error from `toBuffer` — an ERROR on the media document,
+ * which is the signal reserved for generation that was attempted and broke. An
+ * icon having no variants is neither attempted nor broken; it is the ordinary
+ * outcome, and it has to read as one or the fault counter measures the favicon
+ * instead of a fault (AGL-3121).
+ *
+ * Exported because the backfill script has to skip exactly this set. It kept a
+ * second copy of the SVG half, which is how ICO came to be missing from one
+ * and not the other.
+ */ export const MEDIA_TYPES_WITHOUT_VARIANTS = new Set([
+    'image/svg+xml',
+    'image/x-icon',
+    'image/vnd.microsoft.icon'
+]);
+/**
+ * Which widths this source should produce.
+ *
+ * Split out and exported because it is the predicate that decides whether an
+ * empty result is NORMAL, and both the routes and the health probe have to
+ * agree on it. Inlined, the skip rule was a `continue` buried in the loop that
+ * a reader had to reconstruct in order to know whether `[]` was a bug.
+ *
+ * Widths narrower than the source always; for {@link SOURCE_WIDTH_WEBP_TYPES}
+ * the rest as well, provided the source is wider than the narrowest width — a
+ * source smaller than every candidate is an icon, and it is served as it is.
+ */ export function mediaVariantWidthsFor(options) {
+    var _options_sourceWidth;
+    if (!options.contentType.startsWith('image/')) return [];
+    if (MEDIA_TYPES_WITHOUT_VARIANTS.has(options.contentType)) return [];
+    const sourceWidth = (_options_sourceWidth = options.sourceWidth) != null ? _options_sourceWidth : 0;
+    // No known width means generate and let `withoutEnlargement` decide, which
+    // is the same call the loop made before: an unreadable header must not
+    // silently opt an asset out of the CDN.
+    if (!sourceWidth) return [
+        ...MEDIA_CDN_VARIANT_WIDTHS
+    ];
+    const narrower = MEDIA_CDN_VARIANT_WIDTHS.filter((width)=>width < sourceWidth);
+    if (!narrower.length || !SOURCE_WIDTH_WEBP_TYPES.has(options.contentType)) {
+        return narrower;
+    }
+    return [
+        ...MEDIA_CDN_VARIANT_WIDTHS
+    ];
+}
+/**
+ * Resolve `sharp`'s callable through either module shape.
+ *
+ * `(await import('sharp')).default` is correct under Node ESM and under a
+ * bundler that synthesises the CJS namespace. It is `undefined` under one that
+ * hands back `module.exports` directly — and `undefined(buffer)` is a
+ * `TypeError` raised INSIDE the same `try` that catches a genuine load
+ * failure, so from outside the two are the same event: no variants, no
+ * message, a 200. This normalises the shape and, when neither shape yields a
+ * function, throws something that NAMES the problem instead of a bare
+ * `is not a function` from three frames away.
+ */ export async function loadSharp() {
+    const imported = await import("sharp");
+    const candidate = typeof imported === 'function' ? imported : imported == null ? void 0 : imported.default;
+    if (typeof candidate !== 'function') {
+        throw new Error(`sharp did not resolve to a function (module was ${typeof imported}, ` + `default was ${typeof candidate})`);
+    }
+    return candidate;
+}
+/**
+ * A short, PUBLISHABLE name for why the encoder is unavailable (AGL-1471).
+ *
+ * The first thing the probe said on production was `sharp-unavailable`, and
+ * that answered less than it looked like it did: it is the fallback for "the
+ * error carried no `code`", and BOTH interesting failures land there. `sharp`
+ * catches every `require` of its prebuilt binaries and rethrows one composed
+ * `Error` with no `code` at all; `loadSharp` throws a plain `Error` too when
+ * the module resolves to something that is not callable. One means the native
+ * library did not load, the other means the bundler handed back the wrong
+ * shape, and they have nothing in common except the remedy being different.
+ *
+ * Matching on `sharp`'s own help text is the only signal available — the
+ * distinction is not in a field, only in the prose. It is matched loosely and
+ * it degrades to the old fallback, so a reworded upstream message costs a
+ * detail rather than the answer.
+ *
+ * The MESSAGE still never leaves the process. A native loader failure names
+ * every path it tried, the health endpoint is public, and the point of a code
+ * is that it is a fixed vocabulary the caller can branch on.
+ */ export function classifyLoadFailure(error) {
+    const code = error == null ? void 0 : error.code;
+    if (code) return String(code);
+    const message = error instanceof Error ? error.message : '';
+    if (/Could not load the "?sharp"? module/i.test(message)) {
+        return 'sharp-native-missing';
+    }
+    if (/did not resolve to a function/i.test(message)) {
+        return 'sharp-not-a-function';
+    }
+    return 'sharp-unavailable';
+}
+/** Error text kept short — it is stored on a document, not in a log. */ function describe(error) {
+    const text = error instanceof Error ? `${error.name}: ${error.message}` : String(error != null ? error : 'unknown');
+    return text.slice(0, 300);
+}
+/**
+ * Generate the WebP variants for one asset and report the outcome.
+ *
+ * `saveVariant` is a callback rather than a `Bucket` so this stays free of a
+ * storage dependency and so a spec can assert on the BYTES it produces —
+ * which is the only assertion that distinguishes a working variant from the
+ * original served back under a `?w=` that selects nothing.
+ */ export async function generateMediaVariants(options) {
+    const widths = mediaVariantWidthsFor(options);
+    if (!widths.length) return {
+        variants: []
+    };
+    const variants = [];
+    try {
+        const sharp = await loadSharp();
+        for (const width of widths){
+            const webp = await sharp(options.buffer).resize({
+                width,
+                withoutEnlargement: true
+            }).webp({
+                quality: 80
+            }).toBuffer();
+            await options.saveVariant(`${options.objectPath}__w${width}.webp`, webp);
+            variants.push(width);
+        }
+    } catch (error) {
+        // Still never fails the upload — but no longer only whispers.
+        console.error('media variant generation failed', options.objectPath, error);
+        return {
+            variants,
+            error: describe(error)
+        };
+    }
+    return {
+        variants
+    };
+}
+/**
+ * The largest object this will pull back OUT of storage in order to generate.
+ *
+ * Deliberately equal to `IMAGE_MAX_BYTES`, the console's per-type ceiling for
+ * an image (`apps/console/utils/media-upload-limits.ts`), rather than derived
+ * from it: this library cannot import that file, and the two numbers answer
+ * different questions. That one asks "may this be uploaded at all"; this one
+ * asks "may a serverless function afford to fetch it back and decode it". They
+ * agree today, which is the point — every image the DAM accepts gets variants.
+ * If the upload ceiling is ever raised for a format where 15 MB is small (a
+ * camera RAW, a TIFF), the download stops there instead of silently following
+ * it into a timeout, and says so.
+ */ export const MEDIA_VARIANT_SOURCE_MAX_BYTES = 15 * 1024 * 1024;
+/**
+ * Generate variants for an object whose bytes are in STORAGE, not in hand
+ * (AGL-1476).
+ *
+ * `/api/media/upload` has the buffer — the client base64'd it into the request
+ * body. `/api/media/upload-url` never sees it: the browser PUTs straight to GCS
+ * with a signed URL, and finalize is handed a path. Since AGL-1465 gave images
+ * a signed-path ceiling, every image between 3 MB and 15 MB takes that route,
+ * so the assets that most need a 320px WebP became precisely the ones that got
+ * none. Measured on production 2026-08-13: a 6,606,921 B PNG landed with
+ * `variants` **absent**, and `?w=320` served back all 6,606,921 B of
+ * `image/png`; a 2,168,376 B PNG on the base64 route landed with
+ * `variants: [320, 640]` and answered `?w=320` in 31,566 B of `image/webp`.
+ *
+ * So the bytes have to come back. `readSource` is a callback, for the same
+ * reason `saveVariant` is one: this stays free of a storage dependency, and a
+ * spec can hand it a real PNG and count what comes out.
+ *
+ * **The read is the last thing that happens, not the first.** Widths are
+ * decided from the header dimensions the caller already has, so a source
+ * narrower than every target width — and every non-image — costs nothing at
+ * all. That ordering is what keeps this from pulling a 200 MB video back out
+ * of the bucket to discover it has no variants.
+ *
+ * The size refusal is reported as an ERROR rather than as an empty success,
+ * and the distinction is AGL-1468's: `variants: []` with no error means
+ * nothing was ELIGIBLE, and an image the platform accepted and then declined
+ * to optimize is not that. It is eligible work that did not happen, so it
+ * belongs on the document and in `variantFailures` where it can be counted.
+ */ export async function generateStoredMediaVariants(options) {
+    var _options_maxSourceBytes;
+    const widths = mediaVariantWidthsFor(options);
+    if (!widths.length) return {
+        variants: []
+    };
+    const maxSourceBytes = (_options_maxSourceBytes = options.maxSourceBytes) != null ? _options_maxSourceBytes : MEDIA_VARIANT_SOURCE_MAX_BYTES;
+    if (options.sizeBytes > maxSourceBytes) {
+        return {
+            variants: [],
+            error: `source too large to fetch for variants (${options.sizeBytes} > ${maxSourceBytes} bytes)`
+        };
+    }
+    let buffer;
+    try {
+        buffer = await options.readSource();
+    } catch (error) {
+        // A download failure is a genuine fault on an eligible asset, and it is
+        // NOT the same event as `sharp` being unavailable — so it is described
+        // here rather than left to be inferred from a message three frames away.
+        console.error('media variant source download failed', options.objectPath, error);
+        return {
+            variants: [],
+            error: `source download failed — ${describe(error)}`
+        };
+    }
+    return generateMediaVariants(_extends({}, options, {
+        buffer
+    }));
+}
+/**
+ * Can this deployment produce a variant at all?
+ *
+ * Synthesises a small image in memory, downscales it, and asserts the result
+ * is both a WebP and SMALLER than the source. No Storage, no Firestore, no
+ * upload — so it can run from a health endpoint on a schedule instead of
+ * waiting for a customer to notice their thumbnails are full-size originals.
+ *
+ * The size comparison is the point. A resize that silently returns its input
+ * is exactly the failure this issue is about: `?w=640` answering 200 with the
+ * original is indistinguishable from success unless something counts bytes.
+ */ export async function probeMediaVariantSupport() {
+    try {
+        const sharp = await loadSharp();
+        // A smooth gradient, not a flat fill and not noise. A flat fill
+        // compresses to a handful of bytes at every width, so the size
+        // comparison below would pass on a resize that did nothing; noise
+        // re-expands under lossy WebP, so it would FAIL on a perfectly healthy
+        // encoder. Real images sit between the two, and so does this.
+        const width = 640;
+        const height = 128;
+        const pixels = Buffer.alloc(width * height * 3);
+        for(let y = 0; y < height; y += 1){
+            for(let x = 0; x < width; x += 1){
+                const index = (y * width + x) * 3;
+                pixels[index] = Math.round(x * 255 / width);
+                pixels[index + 1] = Math.round(y * 255 / height);
+                pixels[index + 2] = Math.round((x + y) % 300 * 255 / 300);
+            }
+        }
+        const source = await sharp(pixels, {
+            raw: {
+                width,
+                height,
+                channels: 3
+            }
+        }).png().toBuffer();
+        const resized = await sharp(source).resize({
+            width: 320,
+            withoutEnlargement: true
+        }).webp({
+            quality: 80
+        }).toBuffer();
+        // `RIFF....WEBP` — a WebP, not the PNG handed back.
+        const isWebp = resized.length > 12 && resized.toString('ascii', 0, 4) === 'RIFF' && resized.toString('ascii', 8, 12) === 'WEBP';
+        if (!isWebp) return {
+            ok: false,
+            code: 'not-webp'
+        };
+        if (resized.length >= source.length) return {
+            ok: false,
+            code: 'not-smaller'
+        };
+        return {
+            ok: true
+        };
+    } catch (error) {
+        // A CODE, never the message: the health endpoint is public and an error
+        // from a native module can carry filesystem paths.
+        return {
+            ok: false,
+            code: classifyLoadFailure(error)
+        };
+    }
+}
+/**
+ * The largest poster this will accept from a client (AGL-2742).
+ *
+ * The browser encodes the still it captured as WebP at quality ~0.72, and a
+ * 1920-wide frame of real video lands between 40 KB and 250 KB. 4 MB is
+ * therefore ~16x the worst realistic case and is not a quality knob: it is
+ * the point past which the bytes stopped being a poster. It has to sit well
+ * under the platform's 4.5 MB request-body wall, because the poster rides
+ * base64 in the finalize call and a ceiling that admits a body the platform
+ * will reject turns a refusal we can explain into a 413 we cannot.
+ */ export const MEDIA_POSTER_MAX_BYTES = 4 * 1024 * 1024;
+/**
+ * The widest poster stored. Above this a still is being kept at a resolution
+ * no `<video poster>` paints — the element scales it to the player box, and
+ * the largest realistic player box is the 1920 the variant widths already
+ * top out at.
+ */ export const MEDIA_POSTER_MAX_WIDTH = 1920;
+/** WebP quality for the poster. Higher than a variant's 80 would not show. */ const POSTER_QUALITY = 72;
+/**
+ * Turn a client-supplied still into the asset's poster (AGL-2742).
+ *
+ * ## The re-encode is a security control, not a compression pass
+ *
+ * These bytes come from a browser, over the wire, and land in the shared
+ * media bucket under an org's own prefix, where `serveMediaCdn` will stream
+ * them `inline` from the console's origin and from every tenant site's. That
+ * is precisely the shape of AGL-1474, where an uploaded `image/svg+xml`
+ * turned out to be a scripted document served from `app.aglyn.com`.
+ *
+ * Nothing here trusts the declared type, the magic bytes, or the extension.
+ * The buffer is decoded by `sharp` and **re-encoded** to WebP, so what gets
+ * stored is bytes this process produced. A polyglot, an SVG, an HTML file
+ * with a PNG header — each either fails to decode (reported, no object
+ * written) or becomes a real raster WebP with whatever it was smuggling
+ * discarded. That is a stronger guarantee than any sniffing gate, and it is
+ * why the poster is allowed to be client-generated at all.
+ *
+ * ## Why it reuses `generateMediaVariants` rather than looping itself
+ *
+ * A poster IS an image, and the width set a poster should offer is the width
+ * set every other image offers — the srcSet the renderer already knows how
+ * to write. Handing the generator `{objectPath}__poster` as its object path
+ * makes it emit `{objectPath}__poster__w{n}.webp` with no knowledge that
+ * video exists, and inherits its skip rule, its partial-run reporting and
+ * its refusal to fail an upload. A private loop here would be a second set
+ * of widths to keep in step, which is the defect AGL-175's widths list was
+ * moved into `@aglyn/aglyn` to prevent.
+ *
+ * The dimensions returned are read back from the ENCODED bytes rather than
+ * taken from the caller. The browser's report is what sized the capture, and
+ * the resize below may have changed it; a document that records what was
+ * asked for instead of what was written is how an `aspect-ratio` drifts off
+ * by the cap.
+ */ export async function generateMediaPoster(options) {
+    const posterPath = mediaPosterObjectPath(options.objectPath);
+    let webp;
+    try {
+        var _options_maxWidth;
+        const sharp = await loadSharp();
+        webp = await sharp(options.buffer).resize({
+            width: (_options_maxWidth = options.maxWidth) != null ? _options_maxWidth : MEDIA_POSTER_MAX_WIDTH,
+            withoutEnlargement: true
+        }).webp({
+            quality: POSTER_QUALITY
+        }).toBuffer();
+    } catch (error) {
+        console.error('media poster encode failed', options.objectPath, error);
+        return {
+            error: `poster encode failed — ${describe(error)}`
+        };
+    }
+    // Read the WRITTEN bytes. `readImageDimensions` parses the WebP chunk
+    // headers this encoder just emitted, so this is a measurement of the
+    // stored object and not a restatement of the request.
+    const dimensions = readImageDimensions(new Uint8Array(webp));
+    if (!dimensions) {
+        return {
+            error: 'poster encoded but its dimensions were unreadable'
+        };
+    }
+    try {
+        await options.saveVariant(posterPath, webp);
+    } catch (error) {
+        console.error('media poster save failed', posterPath, error);
+        return {
+            error: `poster save failed — ${describe(error)}`
+        };
+    }
+    // Widths for the poster, generated from the poster's own bytes. A failure
+    // past this point still leaves a usable full-size poster on the document,
+    // which is the whole reason the object above is written first.
+    const outcome = await generateMediaVariants({
+        buffer: webp,
+        contentType: 'image/webp',
+        sourceWidth: dimensions.width,
+        objectPath: `${options.objectPath}${MEDIA_POSTER_OBJECT_SUFFIX}`,
+        saveVariant: options.saveVariant
+    });
+    return _extends({
+        poster: {
+            width: dimensions.width,
+            height: dimensions.height,
+            variants: outcome.variants
+        }
+    }, outcome.error ? {
+        error: outcome.error
+    } : {});
+}
+
+//# sourceMappingURL=media-variants.js.map

package/src/lib/server/media-variants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/tenant/data/admin/src/lib/server/media-variants.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  MEDIA_POSTER_OBJECT_SUFFIX,\n  mediaPosterObjectPath,\n  readImageDimensions,\n} from '@aglyn/aglyn/server'\n\nimport { MEDIA_CDN_VARIANT_WIDTHS } from './serve-media-cdn'\n\n/**\n * WebP variant generation for a media asset (AGL-175), and the record of\n * whether it worked (AGL-1468).\n *\n * ## Why this is a library function and not two copies of a `try`\n *\n * `/api/media/upload` and `/api/media/replace` each carried the same eleven\n * lines, wrapped in a `catch` whose comment read *\"Variants are an\n * optimization — never fail the upload for them.\"* That judgement is right and\n * it survives here. What did not survive is its consequence: the catch wrote\n * `console.error` and nothing else, so a **total** failure and a **healthy**\n * asset produced byte-identical documents — `variants: []` either way.\n *\n * Measured 2026-08-13 on production: **1 of 180 media documents has a\n * non-empty `variants` array.** The last successful generation was\n * 2026-07-19; every image uploaded since has an empty one. Nothing surfaced\n * that for three weeks, because the only trace was a serverless log line\n * whose retention is about an hour.\n *\n * So the contract of this function is not \"generate variants\". It is\n * **generate variants and say what happened**, and the two failure classes\n * are kept apart on purpose:\n *\n * - `variants: []` with **no** `error` — nothing was ELIGIBLE. A type in\n *   {@link MEDIA_TYPES_WITHOUT_VARIANTS}, a non-image, or a source already\n *   narrower than every target width. This is the correct, common,\n *   uninteresting outcome and must never look like a fault or the fault signal\n *   is worthless.\n * - `variants: []` with an `error` — generation was attempted and did not\n *   complete. That string goes onto the media document and bumps a counter,\n *   which is what makes \"how many assets failed?\" a query instead of an\n *   archaeology project.\n *\n * A partial run reports both: the widths that landed AND the error, because\n * the widths that landed are real files that the CDN route can serve.\n */\n\n/** The shape of `sharp`'s default export, narrowed to what is used here. */\ntype SharpFactory = (input: Buffer) => {\n  resize(options: { width: number; withoutEnlargement: boolean }): {\n    webp(options: { quality: number }): { toBuffer(): Promise<Buffer> }\n  }\n}\n\nexport interface MediaVariantOutcome {\n  /** Widths actually written. Safe to store — every entry is a real object. */\n  variants: number[]\n  /**\n   * Present ONLY when generation was attempted and did not complete.\n   * `undefined` means nothing went wrong, which includes \"nothing to do\".\n   */\n  error?: string\n}\n\n/**\n * Formats a WebP copy at the SOURCE'S OWN width beats.\n *\n * A renderer's srcSet offers every width in `MEDIA_CDN_VARIANT_WIDTHS`, and\n * `serveMediaCdn` answers a width an asset has no variant for with the\n * original. For a JPEG or PNG no wider than a candidate, that original is what\n * every request at or above its width downloads — the `1280w` a phone asks\n * for, the `1920w` a desktop asks for. Measured on aglyn.com's hero poster, a\n * 1920x1080 JPEG: 166,756 B served for `?w=1920`, where a WebP of the same\n * 1920 pixels at the generator's quality is 40,598 B.\n *\n * So these formats also get the widths AT and ABOVE their own, each encoded at\n * the source width (`withoutEnlargement`): a re-encode, never an upscale, and\n * the same pixels the original answer served. Not GIF, whose animation a WebP\n * frame would drop; not WebP or AVIF, which a re-encode could make larger.\n */\nconst SOURCE_WIDTH_WEBP_TYPES: ReadonlySet<string> = new Set([\n  'image/jpeg',\n  'image/jpg',\n  'image/png',\n])\n\n/**\n * `image/*` types that produce no variants, for two different reasons.\n *\n * SVG is a vector: there is nothing to downscale, and rasterizing it would be\n * a different asset rather than a variant of this one.\n *\n * ICO carries no `sharp` decoder at all, so attempting it raises an\n * unsupported-format error from `toBuffer` — an ERROR on the media document,\n * which is the signal reserved for generation that was attempted and broke. An\n * icon having no variants is neither attempted nor broken; it is the ordinary\n * outcome, and it has to read as one or the fault counter measures the favicon\n * instead of a fault (AGL-3121).\n *\n * Exported because the backfill script has to skip exactly this set. It kept a\n * second copy of the SVG half, which is how ICO came to be missing from one\n * and not the other.\n */\nexport const MEDIA_TYPES_WITHOUT_VARIANTS: ReadonlySet<string> = new Set([\n  'image/svg+xml',\n  'image/x-icon',\n  'image/vnd.microsoft.icon',\n])\n\n/**\n * Which widths this source should produce.\n *\n * Split out and exported because it is the predicate that decides whether an\n * empty result is NORMAL, and both the routes and the health probe have to\n * agree on it. Inlined, the skip rule was a `continue` buried in the loop that\n * a reader had to reconstruct in order to know whether `[]` was a bug.\n *\n * Widths narrower than the source always; for {@link SOURCE_WIDTH_WEBP_TYPES}\n * the rest as well, provided the source is wider than the narrowest width — a\n * source smaller than every candidate is an icon, and it is served as it is.\n */\nexport function mediaVariantWidthsFor(options: {\n  contentType: string\n  /** Source pixel width, when it could be read from the header. */\n  sourceWidth?: number | null\n}): number[] {\n  if (!options.contentType.startsWith('image/')) return []\n  if (MEDIA_TYPES_WITHOUT_VARIANTS.has(options.contentType)) return []\n  const sourceWidth = options.sourceWidth ?? 0\n  // No known width means generate and let `withoutEnlargement` decide, which\n  // is the same call the loop made before: an unreadable header must not\n  // silently opt an asset out of the CDN.\n  if (!sourceWidth) return [...MEDIA_CDN_VARIANT_WIDTHS]\n  const narrower = MEDIA_CDN_VARIANT_WIDTHS.filter((width) => width < sourceWidth)\n  if (!narrower.length || !SOURCE_WIDTH_WEBP_TYPES.has(options.contentType)) {\n    return narrower\n  }\n  return [...MEDIA_CDN_VARIANT_WIDTHS]\n}\n\n/**\n * Resolve `sharp`'s callable through either module shape.\n *\n * `(await import('sharp')).default` is correct under Node ESM and under a\n * bundler that synthesises the CJS namespace. It is `undefined` under one that\n * hands back `module.exports` directly — and `undefined(buffer)` is a\n * `TypeError` raised INSIDE the same `try` that catches a genuine load\n * failure, so from outside the two are the same event: no variants, no\n * message, a 200. This normalises the shape and, when neither shape yields a\n * function, throws something that NAMES the problem instead of a bare\n * `is not a function` from three frames away.\n */\nexport async function loadSharp(): Promise<SharpFactory> {\n  const imported: unknown = await import('sharp')\n  const candidate =\n    typeof imported === 'function'\n      ? imported\n      : (imported as { default?: unknown } | null)?.default\n  if (typeof candidate !== 'function') {\n    throw new Error(\n      `sharp did not resolve to a function (module was ${typeof imported}, ` +\n        `default was ${typeof candidate})`,\n    )\n  }\n  return candidate as SharpFactory\n}\n\n/**\n * A short, PUBLISHABLE name for why the encoder is unavailable (AGL-1471).\n *\n * The first thing the probe said on production was `sharp-unavailable`, and\n * that answered less than it looked like it did: it is the fallback for \"the\n * error carried no `code`\", and BOTH interesting failures land there. `sharp`\n * catches every `require` of its prebuilt binaries and rethrows one composed\n * `Error` with no `code` at all; `loadSharp` throws a plain `Error` too when\n * the module resolves to something that is not callable. One means the native\n * library did not load, the other means the bundler handed back the wrong\n * shape, and they have nothing in common except the remedy being different.\n *\n * Matching on `sharp`'s own help text is the only signal available — the\n * distinction is not in a field, only in the prose. It is matched loosely and\n * it degrades to the old fallback, so a reworded upstream message costs a\n * detail rather than the answer.\n *\n * The MESSAGE still never leaves the process. A native loader failure names\n * every path it tried, the health endpoint is public, and the point of a code\n * is that it is a fixed vocabulary the caller can branch on.\n */\nexport function classifyLoadFailure(error: unknown): string {\n  const code = (error as { code?: string })?.code\n  if (code) return String(code)\n  const message = error instanceof Error ? error.message : ''\n  if (/Could not load the \"?sharp\"? module/i.test(message)) {\n    return 'sharp-native-missing'\n  }\n  if (/did not resolve to a function/i.test(message)) {\n    return 'sharp-not-a-function'\n  }\n  return 'sharp-unavailable'\n}\n\n/** Error text kept short — it is stored on a document, not in a log. */\nfunction describe(error: unknown): string {\n  const text =\n    error instanceof Error\n      ? `${error.name}: ${error.message}`\n      : String(error ?? 'unknown')\n  return text.slice(0, 300)\n}\n\n/**\n * Generate the WebP variants for one asset and report the outcome.\n *\n * `saveVariant` is a callback rather than a `Bucket` so this stays free of a\n * storage dependency and so a spec can assert on the BYTES it produces —\n * which is the only assertion that distinguishes a working variant from the\n * original served back under a `?w=` that selects nothing.\n */\nexport async function generateMediaVariants(options: {\n  buffer: Buffer\n  contentType: string\n  sourceWidth?: number | null\n  /** Object path of the ORIGINAL; variants are `${objectPath}__w{n}.webp`. */\n  objectPath: string\n  saveVariant: (path: string, webp: Buffer) => Promise<void>\n}): Promise<MediaVariantOutcome> {\n  const widths = mediaVariantWidthsFor(options)\n  if (!widths.length) return { variants: [] }\n\n  const variants: number[] = []\n  try {\n    const sharp = await loadSharp()\n    for (const width of widths) {\n      const webp = await sharp(options.buffer)\n        .resize({ width, withoutEnlargement: true })\n        .webp({ quality: 80 })\n        .toBuffer()\n      await options.saveVariant(`${options.objectPath}__w${width}.webp`, webp)\n      variants.push(width)\n    }\n  } catch (error) {\n    // Still never fails the upload — but no longer only whispers.\n    console.error('media variant generation failed', options.objectPath, error)\n    return { variants, error: describe(error) }\n  }\n  return { variants }\n}\n\n/**\n * The largest object this will pull back OUT of storage in order to generate.\n *\n * Deliberately equal to `IMAGE_MAX_BYTES`, the console's per-type ceiling for\n * an image (`apps/console/utils/media-upload-limits.ts`), rather than derived\n * from it: this library cannot import that file, and the two numbers answer\n * different questions. That one asks \"may this be uploaded at all\"; this one\n * asks \"may a serverless function afford to fetch it back and decode it\". They\n * agree today, which is the point — every image the DAM accepts gets variants.\n * If the upload ceiling is ever raised for a format where 15 MB is small (a\n * camera RAW, a TIFF), the download stops there instead of silently following\n * it into a timeout, and says so.\n */\nexport const MEDIA_VARIANT_SOURCE_MAX_BYTES = 15 * 1024 * 1024\n\n/**\n * Generate variants for an object whose bytes are in STORAGE, not in hand\n * (AGL-1476).\n *\n * `/api/media/upload` has the buffer — the client base64'd it into the request\n * body. `/api/media/upload-url` never sees it: the browser PUTs straight to GCS\n * with a signed URL, and finalize is handed a path. Since AGL-1465 gave images\n * a signed-path ceiling, every image between 3 MB and 15 MB takes that route,\n * so the assets that most need a 320px WebP became precisely the ones that got\n * none. Measured on production 2026-08-13: a 6,606,921 B PNG landed with\n * `variants` **absent**, and `?w=320` served back all 6,606,921 B of\n * `image/png`; a 2,168,376 B PNG on the base64 route landed with\n * `variants: [320, 640]` and answered `?w=320` in 31,566 B of `image/webp`.\n *\n * So the bytes have to come back. `readSource` is a callback, for the same\n * reason `saveVariant` is one: this stays free of a storage dependency, and a\n * spec can hand it a real PNG and count what comes out.\n *\n * **The read is the last thing that happens, not the first.** Widths are\n * decided from the header dimensions the caller already has, so a source\n * narrower than every target width — and every non-image — costs nothing at\n * all. That ordering is what keeps this from pulling a 200 MB video back out\n * of the bucket to discover it has no variants.\n *\n * The size refusal is reported as an ERROR rather than as an empty success,\n * and the distinction is AGL-1468's: `variants: []` with no error means\n * nothing was ELIGIBLE, and an image the platform accepted and then declined\n * to optimize is not that. It is eligible work that did not happen, so it\n * belongs on the document and in `variantFailures` where it can be counted.\n */\nexport async function generateStoredMediaVariants(options: {\n  contentType: string\n  /** The object's REAL size, as storage reports it. */\n  sizeBytes: number\n  sourceWidth?: number | null\n  objectPath: string\n  /** Fetches the whole object. Only ever called when there is work to do. */\n  readSource: () => Promise<Buffer>\n  saveVariant: (path: string, webp: Buffer) => Promise<void>\n  maxSourceBytes?: number\n}): Promise<MediaVariantOutcome> {\n  const widths = mediaVariantWidthsFor(options)\n  if (!widths.length) return { variants: [] }\n\n  const maxSourceBytes = options.maxSourceBytes ?? MEDIA_VARIANT_SOURCE_MAX_BYTES\n  if (options.sizeBytes > maxSourceBytes) {\n    return {\n      variants: [],\n      error: `source too large to fetch for variants (${options.sizeBytes} > ${maxSourceBytes} bytes)`,\n    }\n  }\n\n  let buffer: Buffer\n  try {\n    buffer = await options.readSource()\n  } catch (error) {\n    // A download failure is a genuine fault on an eligible asset, and it is\n    // NOT the same event as `sharp` being unavailable — so it is described\n    // here rather than left to be inferred from a message three frames away.\n    console.error('media variant source download failed', options.objectPath, error)\n    return { variants: [], error: `source download failed — ${describe(error)}` }\n  }\n\n  return generateMediaVariants({ ...options, buffer })\n}\n\n/**\n * Can this deployment produce a variant at all?\n *\n * Synthesises a small image in memory, downscales it, and asserts the result\n * is both a WebP and SMALLER than the source. No Storage, no Firestore, no\n * upload — so it can run from a health endpoint on a schedule instead of\n * waiting for a customer to notice their thumbnails are full-size originals.\n *\n * The size comparison is the point. A resize that silently returns its input\n * is exactly the failure this issue is about: `?w=640` answering 200 with the\n * original is indistinguishable from success unless something counts bytes.\n */\nexport async function probeMediaVariantSupport(): Promise<{\n  ok: boolean\n  code?: string\n}> {\n  try {\n    const sharp = await loadSharp()\n    // A smooth gradient, not a flat fill and not noise. A flat fill\n    // compresses to a handful of bytes at every width, so the size\n    // comparison below would pass on a resize that did nothing; noise\n    // re-expands under lossy WebP, so it would FAIL on a perfectly healthy\n    // encoder. Real images sit between the two, and so does this.\n    const width = 640\n    const height = 128\n    const pixels = Buffer.alloc(width * height * 3)\n    for (let y = 0; y < height; y += 1) {\n      for (let x = 0; x < width; x += 1) {\n        const index = (y * width + x) * 3\n        pixels[index] = Math.round((x * 255) / width)\n        pixels[index + 1] = Math.round((y * 255) / height)\n        pixels[index + 2] = Math.round((((x + y) % 300) * 255) / 300)\n      }\n    }\n    const source = await (\n      sharp as unknown as (\n        input: Buffer,\n        options: unknown,\n      ) => { png(): { toBuffer(): Promise<Buffer> } }\n    )(pixels, { raw: { width, height, channels: 3 } })\n      .png()\n      .toBuffer()\n    const resized = await sharp(source)\n      .resize({ width: 320, withoutEnlargement: true })\n      .webp({ quality: 80 })\n      .toBuffer()\n    // `RIFF....WEBP` — a WebP, not the PNG handed back.\n    const isWebp =\n      resized.length > 12 &&\n      resized.toString('ascii', 0, 4) === 'RIFF' &&\n      resized.toString('ascii', 8, 12) === 'WEBP'\n    if (!isWebp) return { ok: false, code: 'not-webp' }\n    if (resized.length >= source.length) return { ok: false, code: 'not-smaller' }\n    return { ok: true }\n  } catch (error) {\n    // A CODE, never the message: the health endpoint is public and an error\n    // from a native module can carry filesystem paths.\n    return { ok: false, code: classifyLoadFailure(error) }\n  }\n}\n\n/**\n * The largest poster this will accept from a client (AGL-2742).\n *\n * The browser encodes the still it captured as WebP at quality ~0.72, and a\n * 1920-wide frame of real video lands between 40 KB and 250 KB. 4 MB is\n * therefore ~16x the worst realistic case and is not a quality knob: it is\n * the point past which the bytes stopped being a poster. It has to sit well\n * under the platform's 4.5 MB request-body wall, because the poster rides\n * base64 in the finalize call and a ceiling that admits a body the platform\n * will reject turns a refusal we can explain into a 413 we cannot.\n */\nexport const MEDIA_POSTER_MAX_BYTES = 4 * 1024 * 1024\n\n/**\n * The widest poster stored. Above this a still is being kept at a resolution\n * no `<video poster>` paints — the element scales it to the player box, and\n * the largest realistic player box is the 1920 the variant widths already\n * top out at.\n */\nexport const MEDIA_POSTER_MAX_WIDTH = 1920\n\n/** WebP quality for the poster. Higher than a variant's 80 would not show. */\nconst POSTER_QUALITY = 72\n\nexport interface MediaPosterOutcome {\n  /** Set only when a poster object was actually written. */\n  poster?: { width: number; height: number; variants: number[] }\n  /**\n   * Present ONLY when a poster was offered and could not be produced —\n   * the same two-failure-class contract {@link MediaVariantOutcome} keeps.\n   * An upload with no poster offered returns an empty object, not an error.\n   */\n  error?: string\n}\n\n/**\n * Turn a client-supplied still into the asset's poster (AGL-2742).\n *\n * ## The re-encode is a security control, not a compression pass\n *\n * These bytes come from a browser, over the wire, and land in the shared\n * media bucket under an org's own prefix, where `serveMediaCdn` will stream\n * them `inline` from the console's origin and from every tenant site's. That\n * is precisely the shape of AGL-1474, where an uploaded `image/svg+xml`\n * turned out to be a scripted document served from `app.aglyn.com`.\n *\n * Nothing here trusts the declared type, the magic bytes, or the extension.\n * The buffer is decoded by `sharp` and **re-encoded** to WebP, so what gets\n * stored is bytes this process produced. A polyglot, an SVG, an HTML file\n * with a PNG header — each either fails to decode (reported, no object\n * written) or becomes a real raster WebP with whatever it was smuggling\n * discarded. That is a stronger guarantee than any sniffing gate, and it is\n * why the poster is allowed to be client-generated at all.\n *\n * ## Why it reuses `generateMediaVariants` rather than looping itself\n *\n * A poster IS an image, and the width set a poster should offer is the width\n * set every other image offers — the srcSet the renderer already knows how\n * to write. Handing the generator `{objectPath}__poster` as its object path\n * makes it emit `{objectPath}__poster__w{n}.webp` with no knowledge that\n * video exists, and inherits its skip rule, its partial-run reporting and\n * its refusal to fail an upload. A private loop here would be a second set\n * of widths to keep in step, which is the defect AGL-175's widths list was\n * moved into `@aglyn/aglyn` to prevent.\n *\n * The dimensions returned are read back from the ENCODED bytes rather than\n * taken from the caller. The browser's report is what sized the capture, and\n * the resize below may have changed it; a document that records what was\n * asked for instead of what was written is how an `aspect-ratio` drifts off\n * by the cap.\n */\nexport async function generateMediaPoster(options: {\n  /** Raw bytes as received. Never assumed to be an image of any kind. */\n  buffer: Buffer\n  /** Object path of the ORIGINAL video, without the poster suffix. */\n  objectPath: string\n  saveVariant: (path: string, bytes: Buffer) => Promise<void>\n  maxWidth?: number\n}): Promise<MediaPosterOutcome> {\n  const posterPath = mediaPosterObjectPath(options.objectPath)\n  let webp: Buffer\n  try {\n    const sharp = await loadSharp()\n    webp = await sharp(options.buffer)\n      .resize({\n        width: options.maxWidth ?? MEDIA_POSTER_MAX_WIDTH,\n        withoutEnlargement: true,\n      })\n      .webp({ quality: POSTER_QUALITY })\n      .toBuffer()\n  } catch (error) {\n    console.error('media poster encode failed', options.objectPath, error)\n    return { error: `poster encode failed — ${describe(error)}` }\n  }\n\n  // Read the WRITTEN bytes. `readImageDimensions` parses the WebP chunk\n  // headers this encoder just emitted, so this is a measurement of the\n  // stored object and not a restatement of the request.\n  const dimensions = readImageDimensions(new Uint8Array(webp))\n  if (!dimensions) {\n    return { error: 'poster encoded but its dimensions were unreadable' }\n  }\n\n  try {\n    await options.saveVariant(posterPath, webp)\n  } catch (error) {\n    console.error('media poster save failed', posterPath, error)\n    return { error: `poster save failed — ${describe(error)}` }\n  }\n\n  // Widths for the poster, generated from the poster's own bytes. A failure\n  // past this point still leaves a usable full-size poster on the document,\n  // which is the whole reason the object above is written first.\n  const outcome = await generateMediaVariants({\n    buffer: webp,\n    contentType: 'image/webp',\n    sourceWidth: dimensions.width,\n    objectPath: `${options.objectPath}${MEDIA_POSTER_OBJECT_SUFFIX}`,\n    saveVariant: options.saveVariant,\n  })\n\n  return {\n    poster: {\n      width: dimensions.width,\n      height: dimensions.height,\n      variants: outcome.variants,\n    },\n    ...(outcome.error ? { error: outcome.error } : {}),\n  }\n}\n"],"names":["MEDIA_POSTER_OBJECT_SUFFIX","mediaPosterObjectPath","readImageDimensions","MEDIA_CDN_VARIANT_WIDTHS","SOURCE_WIDTH_WEBP_TYPES","Set","MEDIA_TYPES_WITHOUT_VARIANTS","mediaVariantWidthsFor","options","contentType","startsWith","has","sourceWidth","narrower","filter","width","length","loadSharp","imported","candidate","default","Error","classifyLoadFailure","error","code","String","message","test","describe","text","name","slice","generateMediaVariants","widths","variants","sharp","webp","buffer","resize","withoutEnlargement","quality","toBuffer","saveVariant","objectPath","push","console","MEDIA_VARIANT_SOURCE_MAX_BYTES","generateStoredMediaVariants","maxSourceBytes","sizeBytes","readSource","probeMediaVariantSupport","height","pixels","Buffer","alloc","y","x","index","Math","round","source","raw","channels","png","resized","isWebp","toString","ok","MEDIA_POSTER_MAX_BYTES","MEDIA_POSTER_MAX_WIDTH","POSTER_QUALITY","generateMediaPoster","posterPath","maxWidth","dimensions","Uint8Array","outcome","poster"],"mappings":"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"}