@nitida/asset-client 0.14.2

package/AGENTS.md

@@ -0,0 +1,25 @@
+# @nitida/asset-client — for coding agents
+
+**Read `README.md` in this package, then `src/`.** This package publishes its TypeScript sources
+(`files: ["dist/**", "src/**"]`), so the source is the reference — every public function carries
+TSDoc, and the ones worth copying carry `@example` blocks. Read the source for the canonical,
+version-pinned answer rather than recalling an API from training data.
+
+This package **builds URLs**. It makes no network calls and takes no API key. If the task involves
+uploading, that is `@nitida/sdk` — and its `skills/nitida-sdk/SKILL.md` is the deeper guide.
+
+## The three that are wrong most often
+
+1. **Image widths must be on `TRANSFORM_WIDTHS`.** Any other width is **HTTP 400** at the edge.
+   Import the `TransformWidth` type so an off-ladder number fails at compile time instead.
+2. **Video URLs use a base36 tenant segment.** `setTenantId(12)` → `/c/v/…`; a decimal `/12/v/`
+   **404s**. Never hand-roll the path — call `getAssetUrl(asset, "video")`.
+3. **`getAssetUrl(asset, "original")` needs the asset's `mime`**, or it emits the `-o.bin`
+   sentinel and 404s forever. Even then the stored extension comes from the *uploaded filename*, so
+   `image/jpeg` can be `-o.jpg` rather than `-o.jpeg` — verify with a HEAD when it must be right.
+
+## Existence checks
+
+Use `hasPreset(asset, preset)` against `dto.presets` (the compact code string). Do **not** read the
+`variants` array: measured 2026-08-15 it comes back empty even on admin responses while the row
+holds the variants.

package/README.md

@@ -0,0 +1,100 @@
+# @nitida/asset-client
+
+URL builders for assets stored on the aquienpz platform and served from **`https://8ok.uk`**.
+
+No network calls, no API key, no side effects — it turns a stored `sha` into a URL. If you also need
+to **upload**, that is `@nitida/sdk` (which re-exports everything here).
+
+```bash
+bun add @nitida/asset-client
+```
+
+## Configure once, at module load
+
+The builders read **process-global** config, so pin it where your helpers live — every Server and
+Client Component that imports a builder is then configured.
+
+```ts
+import { setCdnBase, setTenantId } from "@nitida/asset-client";
+
+setCdnBase("https://8ok.uk");   // already the default
+setTenantId(12);                // REQUIRED for video/variant URLs — see below
+```
+
+## Images — on-the-fly transforms
+
+```ts
+import { getTransformSrcSet, getTransformUrl, type TransformWidth } from "@nitida/asset-client";
+
+getTransformUrl({ sha }, { format: "webp", width: 640 });
+// → https://8ok.uk/t/format=webp,width=640/<sha16>.webp
+
+getTransformSrcSet({ sha }, [640, 960, 1280], { format: "webp" });
+```
+
+⚠️ **Widths must be on the unsigned ladder** `TRANSFORM_WIDTHS`
+(`160,240,256,320,400,480,600,640,800,960,1080,1200,1280,1440,1600,1920,2560,3840`). Anything else
+is **HTTP 400** at the edge — it is a DoS guard, not a bug. Import the `TransformWidth` type and an
+off-ladder number becomes a compile error instead of a runtime 400.
+
+## Video — the stored variant, not a transform
+
+```ts
+import { getAssetUrl, setTenantId } from "@nitida/asset-client";
+
+setTenantId(tenantId);
+getAssetUrl({ sha }, "video");   // → https://8ok.uk/<tenantId base36>/v/<sha16>-v.mp4
+```
+
+⚠️ **The tenant segment is base36**, not decimal. Tenant 10 is `/a/`, tenant 12 is `/c/`; `/12/v/`
+**404s**. This is invisible for tenants ≤ 9 and bit a real migration exactly once — so always let
+`getAssetUrl` build the path.
+
+⚠️ **Never `getVideoTransformUrl` for a stored video.** That builds a `/t/…` transform URL, which
+**410s** for a stored video sha. It is for on-the-fly re-encodes, a different feature.
+
+## The `original` variant
+
+Pass the asset's `mime` or you get the `"bin"` sentinel:
+
+```ts
+getAssetUrl({ sha }, "original");              // → …-o.bin  ❌ 404, always
+getAssetUrl({ sha, mime }, "original");        // → …-o.webp ✓
+```
+
+⚠️ And the extension the SERVER stored comes from the **uploaded filename**, not the mime. For JPEG
+those disagree (`image/jpeg` → `jpeg`, but a camera writes `.jpg`) — measured, `-o.jpeg` **404s**
+while `-o.jpg` is 200. If the URL must be right, **verify it with a HEAD** before relying on it.
+
+## Which presets exist
+
+Read `dto.presets` — the compact code string (`"oq"` = original + thumb, `"pv"` = poster + video) —
+via `hasPreset`, not the `variants` array:
+
+```ts
+import { hasPreset } from "@nitida/asset-client";
+if (hasPreset(asset, "thumb")) { /* … */ }
+```
+
+The full `variants` array is documented as present on admin responses and, measured 2026-08-15, comes
+back **empty** even with an admin key while the row holds the variants. `presets` is always populated.
+
+| preset | code | ext | max dim |
+|---|---|---|---|
+| `thumb` | `q` | webp | 256 (square cover) |
+| `sm` / `md` / `lg` / `xl` | `s` `m` `l` `x` | webp | 640 / 1280 / 1920 / 3840 |
+| `original` | `o` | source ext | — |
+| `poster` / `video` / `aiproxy` | `p` `v` `a` | webp / mp4 / mp4 | — |
+| `mp3` | — | mp3 | — |
+
+## Troubleshooting
+
+| Symptom | Cause |
+|---|---|
+| **400** on an image URL | width not on `TRANSFORM_WIDTHS` |
+| **410** on a video URL | used `/t/` (transform) for a stored video |
+| **404** on a video URL | decimal tenant prefix instead of base36 |
+| `original` 404s | no `mime` passed, or the stored ext came from the filename (`-o.jpg` vs `-o.jpeg`), or it was never written |
+
+Deeper guidance — including uploads, tenant onboarding and the CORS boundary — lives in
+`@nitida/sdk`'s `skills/nitida-sdk/SKILL.md`, which ships inside that package.

package/dist/index.cjs

@@ -0,0 +1,513 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PRESET_EXT: () => PRESET_EXT,
+  PRESET_LONG: () => PRESET_LONG,
+  PRESET_MAX_DIM: () => PRESET_MAX_DIM,
+  PRESET_SHORT: () => PRESET_SHORT,
+  TRANSFORM_WIDTHS: () => TRANSFORM_WIDTHS,
+  computeVariantDimensions: () => computeVariantDimensions,
+  configureSlotResolver: () => configureSlotResolver,
+  extractAssetSha: () => extractAssetSha,
+  getAmbientGradient: () => getAmbientGradient,
+  getAssetDimensions: () => getAssetDimensions,
+  getAssetSrcSet: () => getAssetSrcSet,
+  getAssetUrl: () => getAssetUrl,
+  getCdnBase: () => getCdnBase,
+  getHlsStreamingUrl: () => getHlsStreamingUrl,
+  getPaletteBlurBackground: () => getPaletteBlurBackground,
+  getPaletteCssVars: () => getPaletteCssVars,
+  getSignedTransformUrl: () => getSignedTransformUrl,
+  getTenantId: () => getTenantId,
+  getTextColorForBackground: () => getTextColorForBackground,
+  getTransformSrcSet: () => getTransformSrcSet,
+  getTransformUrl: () => getTransformUrl,
+  getVideoTransformUrl: () => getVideoTransformUrl,
+  hasPreset: () => hasPreset,
+  invalidateSlotCache: () => invalidateSlotCache,
+  iteratePaletteSwatches: () => iteratePaletteSwatches,
+  pickAmbientBackground: () => pickAmbientBackground,
+  resolveSlot: () => resolveSlot,
+  resolveSlots: () => resolveSlots,
+  serializeTransform: () => serializeTransform,
+  setCdnBase: () => setCdnBase,
+  setTenantId: () => setTenantId,
+  signTransformUrl: () => signTransformUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/palette.ts
+function resolveSwatch(palette, ...keys) {
+  if (!palette) return null;
+  for (const k of keys) {
+    const v = palette[k];
+    if (v) return v;
+  }
+  return null;
+}
+function pickAmbientBackground(palette) {
+  const hex = resolveSwatch(palette, "lm", "m", "lv", "d");
+  if (!hex) return null;
+  return { hex, textColor: textColorForHex(hex) };
+}
+function getAmbientGradient(palette, opts = {}) {
+  if (!palette) return void 0;
+  const fromHex = palette[opts.from ?? "lm"] ?? palette.m ?? palette.d;
+  const toHex = palette[opts.to ?? "m"] ?? palette.dm ?? palette.d;
+  if (!fromHex || !toHex) return void 0;
+  return `linear-gradient(${opts.angle ?? "135deg"}, ${fromHex}, ${toHex})`;
+}
+function getTextColorForBackground(swatch) {
+  if (!swatch) return "#000000";
+  const hex = typeof swatch === "string" ? swatch : swatch.hex;
+  return textColorForHex(hex);
+}
+function textColorForHex(hex) {
+  const h = hex.replace("#", "");
+  const r = Number.parseInt(h.slice(0, 2), 16) / 255;
+  const g = Number.parseInt(h.slice(2, 4), 16) / 255;
+  const b = Number.parseInt(h.slice(4, 6), 16) / 255;
+  const lin = (c) => c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  const L = 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+  return L > 0.5 ? "#000000" : "#FFFFFF";
+}
+function getPaletteCssVars(palette) {
+  if (!palette) return {};
+  const bg = pickAmbientBackground(palette);
+  return {
+    "--asset-bg": bg?.hex ?? "transparent",
+    "--asset-fg": bg ? bg.textColor : "#000000",
+    "--asset-dominant": palette.d,
+    ...palette.v && { "--asset-vibrant": palette.v },
+    ...palette.m && { "--asset-muted": palette.m },
+    ...palette.lv && { "--asset-light-vibrant": palette.lv },
+    ...palette.dv && { "--asset-dark-vibrant": palette.dv },
+    ...palette.lm && { "--asset-light-muted": palette.lm },
+    ...palette.dm && { "--asset-dark-muted": palette.dm }
+  };
+}
+function iteratePaletteSwatches(palette) {
+  if (!palette) return [];
+  const order = [
+    { key: "d", label: "dominant" },
+    { key: "v", label: "vibrant" },
+    { key: "lv", label: "lightVibrant" },
+    { key: "dv", label: "darkVibrant" },
+    { key: "m", label: "muted" },
+    { key: "lm", label: "lightMuted" },
+    { key: "dm", label: "darkMuted" }
+  ];
+  return order.map(({ key, label }) => {
+    const hex = palette[key];
+    return hex ? { key, label, hex } : null;
+  }).filter(
+    (s) => s != null
+  );
+}
+function getPaletteBlurBackground(palette) {
+  if (!palette) return void 0;
+  const corners = [
+    { pos: "20% 20%", key: "lv" },
+    { pos: "80% 25%", key: "v" },
+    { pos: "25% 80%", key: "lm" },
+    { pos: "80% 80%", key: "dv" }
+  ];
+  const layers = corners.map(({ pos, key }) => {
+    const hex = palette[key];
+    if (!hex) return null;
+    return `radial-gradient(circle at ${pos}, ${hex} 0%, transparent 55%)`;
+  }).filter(Boolean);
+  const base = palette.d ?? palette.m ?? "#888";
+  return layers.length > 0 ? `${layers.join(", ")}, ${base}` : base;
+}
+
+// src/slots.ts
+var DEFAULT_TTL_MS = 6e4;
+var cache = /* @__PURE__ */ new Map();
+var endpoint = "https://aquienpz-asset-manager-nlchzy26qa-uc.a.run.app";
+var apiKey = null;
+var tenantCode = null;
+function configureSlotResolver(opts) {
+  if (opts.endpoint) endpoint = opts.endpoint.replace(/\/+$/, "");
+  if (opts.apiKey !== void 0) apiKey = opts.apiKey;
+  if (opts.tenantCode !== void 0) tenantCode = opts.tenantCode;
+}
+function invalidateSlotCache(slotKey) {
+  if (slotKey === void 0) cache.clear();
+  else
+    for (const k of cache.keys())
+      if (k.endsWith(`:${slotKey}`)) cache.delete(k);
+}
+var baseHeaders = () => {
+  const h = {};
+  if (apiKey) h.Authorization = `Bearer ${apiKey}`;
+  if (tenantCode) h["X-Tenant-Code"] = tenantCode;
+  return h;
+};
+async function fetchSlot(slotKey) {
+  const r = await fetch(`${endpoint}/slots/${encodeURIComponent(slotKey)}`, {
+    headers: baseHeaders()
+  });
+  if (r.status === 404) return null;
+  if (!r.ok) throw new Error(`slot fetch ${r.status}: ${await r.text()}`);
+  return await r.json();
+}
+async function fetchSlotsBulk(slotKeys) {
+  if (slotKeys.length === 0) return {};
+  const r = await fetch(`${endpoint}/slots/resolve`, {
+    method: "POST",
+    headers: { ...baseHeaders(), "Content-Type": "application/json" },
+    body: JSON.stringify({ keys: slotKeys })
+  });
+  if (!r.ok) throw new Error(`slots resolve ${r.status}: ${await r.text()}`);
+  const body = await r.json();
+  return body.resolved;
+}
+async function resolveSlot(slotKey, opts = {}) {
+  const ttl = opts.ttlMs ?? DEFAULT_TTL_MS;
+  const cacheKey = `${tenantCode ?? "_"}:${slotKey}`;
+  const now = Date.now();
+  let dto;
+  const hit = cache.get(cacheKey);
+  if (hit && now - hit.fetchedAt < ttl) {
+    dto = hit.value;
+  } else {
+    dto = await fetchSlot(slotKey);
+    cache.set(cacheKey, { fetchedAt: now, value: dto });
+  }
+  return materializeResolution(dto, opts.preset);
+}
+async function resolveSlots(slotKeys, opts = {}) {
+  if (slotKeys.length === 0) return {};
+  const ttl = opts.ttlMs ?? DEFAULT_TTL_MS;
+  const now = Date.now();
+  const missing = [];
+  const out = {};
+  for (const k of slotKeys) {
+    const cacheKey = `${tenantCode ?? "_"}:${k}`;
+    const hit = cache.get(cacheKey);
+    if (hit && now - hit.fetchedAt < ttl) {
+      out[k] = materializeResolution(hit.value, opts.preset);
+    } else {
+      missing.push(k);
+    }
+  }
+  if (missing.length > 0) {
+    const resolved = await fetchSlotsBulk(missing);
+    for (const k of missing) {
+      const dto = resolved[k] ?? null;
+      cache.set(`${tenantCode ?? "_"}:${k}`, { fetchedAt: now, value: dto });
+      out[k] = materializeResolution(dto, opts.preset);
+    }
+  }
+  return out;
+}
+function defaultPresetFor(asset) {
+  if (!asset) return "lg";
+  return asset.kind === "video" ? "video" : "lg";
+}
+function materializeResolution(dto, overridePreset) {
+  if (!dto) return { slot: null, preset: overridePreset ?? "lg", url: null };
+  const effective = overridePreset ?? dto.preset ?? defaultPresetFor(dto.asset);
+  const finalPreset = hasPreset(dto.asset, effective) ? effective : defaultPresetFor(dto.asset);
+  return {
+    slot: dto,
+    preset: finalPreset,
+    url: getAssetUrl(dto.asset, finalPreset)
+  };
+}
+
+// src/transform.ts
+var TRANSFORM_WIDTHS = [
+  96,
+  128,
+  160,
+  240,
+  256,
+  320,
+  400,
+  480,
+  600,
+  640,
+  800,
+  960,
+  1080,
+  1200,
+  1280,
+  1440,
+  1600,
+  1920,
+  2560,
+  3840
+];
+function extractAssetSha(url) {
+  if (!url) return null;
+  const m = url.match(/\/([0-9a-f]{16})(?:[-.]|$)/);
+  return m ? m[1] : null;
+}
+function serializeTransform(opts) {
+  const entries = [];
+  const keys = Object.keys(opts).sort();
+  for (const k of keys) {
+    const v = opts[k];
+    if (v == null) continue;
+    const serialized = typeof v === "string" ? v.toLowerCase() : String(v);
+    entries.push([k, serialized]);
+  }
+  return entries.map(([k, v]) => `${k}=${v}`).join(",");
+}
+function extForOptions(opts) {
+  if (opts.effect === "removebg") return "png";
+  if (opts.effect === "genfill") {
+    switch (opts.format) {
+      case "png":
+        return "png";
+      case "avif":
+        return "avif";
+      case "jpeg":
+        return "jpg";
+      default:
+        return "webp";
+    }
+  }
+  switch (opts.format) {
+    case "avif":
+      return "avif";
+    case "jpeg":
+      return "jpg";
+    case "png":
+      return "png";
+    case "mp4":
+      return "mp4";
+    case "webm":
+      return "webm";
+    case "hls":
+      return "m3u8";
+    default:
+      return "webp";
+  }
+}
+function getVideoTransformUrl(asset, opts) {
+  const dsl = serializeTransform(opts);
+  if (!dsl) return null;
+  const ext = opts.format === "webm" ? "webm" : "mp4";
+  return `${getCdnBase()}/t/${dsl}/${asset.sha}.${ext}`;
+}
+function getHlsStreamingUrl(asset, opts = {}) {
+  const merged = { ...opts, format: "hls" };
+  const dsl = serializeTransform(merged);
+  return `${getCdnBase()}/t/${dsl}/${asset.sha}.m3u8`;
+}
+function buildTransformUrl(asset, opts) {
+  const dsl = serializeTransform(opts);
+  if (!dsl) return null;
+  const ext = extForOptions(opts);
+  return `${getCdnBase()}/t/${dsl}/${asset.sha}.${ext}`;
+}
+function getTransformUrl(asset, opts) {
+  return buildTransformUrl(asset, opts);
+}
+function getSignedTransformUrl(asset, opts, signingKey) {
+  const url = buildTransformUrl(asset, opts);
+  if (!url) return null;
+  return signTransformUrl(url, signingKey);
+}
+async function signTransformUrl(unsignedUrl, signingKey) {
+  const u = new URL(unsignedUrl);
+  const parts = u.pathname.split("/").filter(Boolean);
+  if (parts[0] !== "t" || parts.length < 3) {
+    throw new Error(`signTransformUrl: unexpected URL shape ${unsignedUrl}`);
+  }
+  const filename = parts[parts.length - 1];
+  const dsl = parts.slice(1, -1).join("/");
+  const message = `${dsl}/${filename}`;
+  const sig = await hmacSha256Hex(signingKey, message);
+  u.searchParams.set("sig", sig);
+  return u.toString();
+}
+async function hmacSha256Hex(key, message) {
+  const enc = new TextEncoder();
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const buf = await crypto.subtle.sign("HMAC", cryptoKey, enc.encode(message));
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function getTransformSrcSet(asset, widths, extraOpts = {}) {
+  return widths.map((w) => {
+    const url = buildTransformUrl(asset, { ...extraOpts, width: w });
+    return url ? `${url} ${w}w` : null;
+  }).filter((s) => s != null).join(", ");
+}
+
+// src/index.ts
+var PRESET_SHORT = {
+  thumb: "q",
+  sm: "s",
+  md: "m",
+  lg: "l",
+  xl: "x",
+  original: "o",
+  poster: "p",
+  video: "v",
+  aiproxy: "a",
+  // 3 chars, NOT a 1-char alias: the asset-manager has no short-form for
+  // audio so its `shortPreset("mp3")` falls through to the literal token,
+  // and the deployed server already writes the `-mp3.mp3` variant + emits
+  // the bare `mp3` token in the wire `presets` string. Must stay in lockstep.
+  mp3: "mp3"
+};
+var PRESET_LONG = Object.fromEntries(
+  Object.entries(PRESET_SHORT).map(([k, v]) => [v, k])
+);
+var PRESET_EXT = {
+  thumb: "webp",
+  sm: "webp",
+  md: "webp",
+  lg: "webp",
+  xl: "webp",
+  original: "bin",
+  // overridden per-asset via mime when needed
+  poster: "webp",
+  video: "mp4",
+  aiproxy: "mp4",
+  mp3: "mp3"
+};
+var PRESET_MAX_DIM = {
+  thumb: 256,
+  sm: 640,
+  md: 1280,
+  lg: 1920,
+  xl: 3840,
+  original: null,
+  poster: null,
+  video: null,
+  aiproxy: null,
+  // audio has no pixel dimensions; `null` keeps mp3 out of the
+  // dimension-based `getAssetSrcSet` / `computeVariantDimensions` logic.
+  mp3: null
+};
+var cdnBaseUrl = "https://8ok.uk";
+function setCdnBase(url) {
+  cdnBaseUrl = url.replace(/\/$/, "");
+}
+function getCdnBase() {
+  return cdnBaseUrl;
+}
+var tenantId = null;
+function setTenantId(id) {
+  tenantId = typeof id === "number" && Number.isFinite(id) && id > 0 ? id : null;
+}
+function getTenantId() {
+  return tenantId;
+}
+function variantPrefix() {
+  return tenantId != null ? `${tenantId.toString(36)}/v/` : "";
+}
+var ORIGINAL_EXT_BY_MIME = {
+  "image/png": "png",
+  "image/jpeg": "jpeg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/avif": "avif",
+  "image/svg+xml": "svg",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "image/bmp": "bmp",
+  "image/tiff": "tiff",
+  "application/pdf": "pdf",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "video/quicktime": "mov"
+};
+function originalExtForMime(mime) {
+  return (mime ? ORIGINAL_EXT_BY_MIME[mime] : void 0) ?? PRESET_EXT.original;
+}
+function getAssetUrl(asset, preset) {
+  const ext = preset === "original" ? originalExtForMime(asset.mime) : PRESET_EXT[preset];
+  return `${cdnBaseUrl}/${variantPrefix()}${asset.sha}-${PRESET_SHORT[preset]}.${ext}`;
+}
+function hasPreset(asset, preset) {
+  if (preset === "mp3") return asset.presets.includes("mp3");
+  return asset.presets.replace(/mp3/g, "").includes(PRESET_SHORT[preset]);
+}
+var IMAGE_PRESETS = ["thumb", "sm", "md", "lg", "xl"];
+function getAssetSrcSet(asset) {
+  return IMAGE_PRESETS.filter(
+    (p) => hasPreset(asset, p) && PRESET_MAX_DIM[p] != null
+  ).map((p) => `${getAssetUrl(asset, p)} ${PRESET_MAX_DIM[p]}w`).join(", ");
+}
+function computeVariantDimensions(asset, preset) {
+  const cap = PRESET_MAX_DIM[preset];
+  if (cap == null) return null;
+  if (preset === "thumb") return { width: cap, height: cap };
+  if (!asset.w || !asset.h) return null;
+  const scale = Math.min(cap / asset.w, cap / asset.h, 1);
+  return {
+    width: Math.round(asset.w * scale),
+    height: Math.round(asset.h * scale)
+  };
+}
+function getAssetDimensions(asset) {
+  if (asset.w && asset.h) return { width: asset.w, height: asset.h };
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRESET_EXT,
+  PRESET_LONG,
+  PRESET_MAX_DIM,
+  PRESET_SHORT,
+  TRANSFORM_WIDTHS,
+  computeVariantDimensions,
+  configureSlotResolver,
+  extractAssetSha,
+  getAmbientGradient,
+  getAssetDimensions,
+  getAssetSrcSet,
+  getAssetUrl,
+  getCdnBase,
+  getHlsStreamingUrl,
+  getPaletteBlurBackground,
+  getPaletteCssVars,
+  getSignedTransformUrl,
+  getTenantId,
+  getTextColorForBackground,
+  getTransformSrcSet,
+  getTransformUrl,
+  getVideoTransformUrl,
+  hasPreset,
+  invalidateSlotCache,
+  iteratePaletteSwatches,
+  pickAmbientBackground,
+  resolveSlot,
+  resolveSlots,
+  serializeTransform,
+  setCdnBase,
+  setTenantId,
+  signTransformUrl
+});
+//# sourceMappingURL=index.cjs.map