gazetta 0.5.0 → 0.7.0

package/dist/assets/manifest-merge.js

@@ -0,0 +1,82 @@
+/**
+ * Manifest field-merge primitives. Pure functions; no I/O.
+ *
+ * Two operations:
+ *   - `applyLocaleOverrides` — shallow spread of one override on top of a
+ *     base manifest. The override's non-undefined fields win; everything
+ *     else falls through to the base.
+ *   - `foldLocaleChain` — multi-overlay fold: read each chain entry and
+ *     spread it on the previous, most-specific-LAST so most-specific
+ *     wins per field.
+ *
+ * # Why a separate module
+ *
+ * The merge is the one piece of logic shared between embedded and
+ * downloadable kind resolvers (per Q3 lock). Font resolver does NOT
+ * use override-merge — it composes a variant union, structurally
+ * different. So the merge primitive lives separately and the kinds
+ * that share semantics compose it; the one that doesn't, doesn't.
+ *
+ * # Shallow vs deep
+ *
+ * The merge is SHALLOW. `focalPoint`, `variants`, `width`, `height` are
+ * atomic values from the override's perspective — partial focal-point
+ * overrides aren't a concept. If a locale variant carries `focalPoint`,
+ * its full {x, y} pair replaces the default's; you don't mix x from one
+ * with y from another.
+ *
+ * # Why use spread of `Partial<M>` instead of typed `LocaleOverrideManifest`
+ *
+ * Generic over manifest type so the same primitive can serve embedded
+ * and downloadable (and any future kind that wants override-wins
+ * semantics) without re-implementing per kind.
+ */
+/**
+ * Spread `override`'s non-undefined fields onto `base`. Returns a new
+ * object — `base` is not mutated.
+ *
+ * Fields that are `undefined` in `override` do NOT shadow `base`'s value.
+ * That's the whole point: a locale manifest with only `alt` set should
+ * keep the default's everything-else.
+ *
+ * `null` is treated as a value, not "absent". `alt: null` on the override
+ * explicitly clears the default's alt — useful for "this locale's image
+ * is decorative even though the default has alt text."
+ */
+export function applyLocaleOverrides(base, override) {
+    if (override === null)
+        return base;
+    const out = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * Fold a chain of overrides onto a base. Chain order is
+ * most-specific-LAST so the final fold step replaces fields from
+ * less-specific entries.
+ *
+ * Example for active `pt-BR` with fallback `pt`:
+ *
+ *   chain = [pt-manifest, pt-BR-manifest]   // least-specific FIRST
+ *   foldLocaleChain(default, chain)
+ *
+ * Step 1: apply pt overrides onto default → pt-effective
+ * Step 2: apply pt-BR overrides onto pt-effective → pt-BR-effective
+ *
+ * Most-specific (pt-BR) wins per field. Entries that are `null` (locale
+ * manifest didn't exist) are skipped — same effect as no overrides.
+ *
+ * Caller responsibility: order the chain correctly. Most-specific LAST.
+ */
+export function foldLocaleChain(base, chain) {
+    let current = base;
+    for (const overrides of chain) {
+        current = applyLocaleOverrides(current, overrides);
+    }
+    return current;
+}
+//# sourceMappingURL=manifest-merge.js.map

package/dist/assets/manifest-merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-merge.js","sourceRoot":"","sources":["../../src/assets/manifest-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAmB,IAAO,EAAE,QAA2B;IACzF,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAClC,MAAM,GAAG,GAAG,EAAE,GAAG,IAAI,EAAE,CAAA;IACvB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpD,IAAI,KAAK,KAAK,SAAS;YAAE,SACxB;QAAC,GAA+B,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;IAChD,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,eAAe,CAAmB,IAAO,EAAE,KAAqC;IAC9F,IAAI,OAAO,GAAG,IAAI,CAAA;IAClB,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;QAC9B,OAAO,GAAG,oBAAoB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;IACpD,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/assets/manifest.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Asset manifest I/O — reading and writing `{name}.asset.json` via a
+ * `StorageProvider`. Pure delegation to the storage layer plus JSON
+ * (de)serialization; no validation of the manifest itself (that's the
+ * writer's job at creation time) and no dependency on the upload pipeline.
+ *
+ * Separation from the type:
+ * - `schema/types.ts` owns the `AssetManifest` type (data shape)
+ * - this file owns the I/O primitives (behavior)
+ *
+ * Separation from `ingest.ts`:
+ * - ingest composes hash + manifest + storage during upload
+ * - this module is used by ingest, the resolver, the library-list endpoint,
+ *   and future delete/rename operations. It sits below all of them.
+ */
+import type { StorageProvider } from '../types.js';
+import type { AssetManifest } from '../schema/types.js';
+import { type Selector } from '../schema/dimensions.js';
+import { readDefaultManifest } from './manifest-default.js';
+/**
+ * Where asset manifests live, relative to an `assets/` root.
+ *
+ * Default manifest:    `{name}.asset.json`
+ * Locale variant:       `{name}.asset.{locale}.json`
+ * Theme variant:        `{name}.asset.{theme}.json`
+ * Locale + theme:       `{name}.asset.{locale}.{theme}.json`
+ *
+ * Selector ordering follows `DIMENSION_ORDER` from `schema/dimensions.ts`.
+ * Pass `null` (or omit) for the default manifest.
+ */
+export declare function manifestPath(assetName: string, selector?: Selector | null): string;
+/**
+ * Where internal asset bytes live, given a name + 8-char hash + extension.
+ *
+ * Default bytes:        `{name}-{hash}.{ext}`
+ * Locale bytes:          `{name}-{hash}.{locale}.{ext}`
+ * Locale + theme bytes:  `{name}-{hash}.{locale}.{theme}.{ext}`
+ *
+ * The hash always describes the bytes at THIS path — locale-bytes overrides
+ * have their own hash, distinct from the default's hash.
+ */
+export declare function assetBytesPath(assetName: string, hash: string, ext: string, selector?: Selector | null): string;
+/**
+ * Where a variant's bytes live, given name + hash + ext + target width
+ * (and optional selector for locale/theme variants).
+ *
+ * Default variant:        `{name}-{hash}-{width}w.{ext}`
+ * Locale variant:          `{name}-{hash}.{locale}-{width}w.{ext}`
+ * Locale + theme variant:  `{name}-{hash}.{locale}.{theme}-{width}w.{ext}`
+ *
+ * Width suffix comes AFTER the selector suffix — the selector segments are
+ * part of the file's identity (which override is this), the width is part
+ * of the variant ladder for THAT identity. Owned here so the write side
+ * (ingest) and read side (asset-paths, URL construction) can't drift —
+ * change the scheme in one place.
+ */
+export declare function assetVariantBytesPath(assetName: string, hash: string, ext: string, width: number, selector?: Selector | null): string;
+/**
+ * Read an asset's default manifest. Thin alias for `readDefaultManifest`
+ * — kept for callers that haven't migrated yet. New code should prefer
+ * `readDefaultManifest` from `manifest-default.ts` directly so the
+ * default-vs-locale distinction is explicit at the call site.
+ */
+export declare const readManifest: typeof readDefaultManifest;
+/**
+ * Write an asset manifest to storage. The storage provider's `writeFile` is
+ * already atomic (see providers/_atomic-write.ts) — this function adds no
+ * atomicity of its own, just serialization.
+ */
+export declare function writeManifest(storage: StorageProvider, assetsRoot: string, manifest: AssetManifest): Promise<void>;
+/**
+ * Write a locale-override manifest at `{name}.asset.{...selector}.json`.
+ * Same atomicity contract as `writeManifest` (storage provider handles
+ * write-then-rename atomicity); this function only serializes + dispatches.
+ *
+ * The locale manifest type isn't bound here — callers pass any
+ * JSON-serializable shape that conforms to `LocaleOverrideManifest` or
+ * `FontLocaleAdditiveManifest`. The validators in `manifest-locale.ts`
+ * are responsible for read-side shape enforcement; the writer trusts
+ * its caller.
+ */
+export declare function writeLocaleManifest(storage: StorageProvider, assetsRoot: string, assetName: string, selector: Selector, manifest: object): Promise<void>;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/assets/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/assets/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,yBAAyB,CAAA;AAEvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAElF;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAG/G;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,GACzB,MAAM,CAGR;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,4BAAsB,CAAA;AAE/C;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/assets/manifest.js

@@ -0,0 +1,93 @@
+import { selectorSuffix } from '../schema/dimensions.js';
+import { AssetStorageError } from './errors.js';
+import { readDefaultManifest } from './manifest-default.js';
+/**
+ * Where asset manifests live, relative to an `assets/` root.
+ *
+ * Default manifest:    `{name}.asset.json`
+ * Locale variant:       `{name}.asset.{locale}.json`
+ * Theme variant:        `{name}.asset.{theme}.json`
+ * Locale + theme:       `{name}.asset.{locale}.{theme}.json`
+ *
+ * Selector ordering follows `DIMENSION_ORDER` from `schema/dimensions.ts`.
+ * Pass `null` (or omit) for the default manifest.
+ */
+export function manifestPath(assetName, selector) {
+    return `${assetName}.asset${selectorSuffix(selector ?? null)}.json`;
+}
+/**
+ * Where internal asset bytes live, given a name + 8-char hash + extension.
+ *
+ * Default bytes:        `{name}-{hash}.{ext}`
+ * Locale bytes:          `{name}-{hash}.{locale}.{ext}`
+ * Locale + theme bytes:  `{name}-{hash}.{locale}.{theme}.{ext}`
+ *
+ * The hash always describes the bytes at THIS path — locale-bytes overrides
+ * have their own hash, distinct from the default's hash.
+ */
+export function assetBytesPath(assetName, hash, ext, selector) {
+    const extPart = ext.startsWith('.') ? ext : `.${ext}`;
+    return `${assetName}-${hash}${selectorSuffix(selector ?? null)}${extPart}`;
+}
+/**
+ * Where a variant's bytes live, given name + hash + ext + target width
+ * (and optional selector for locale/theme variants).
+ *
+ * Default variant:        `{name}-{hash}-{width}w.{ext}`
+ * Locale variant:          `{name}-{hash}.{locale}-{width}w.{ext}`
+ * Locale + theme variant:  `{name}-{hash}.{locale}.{theme}-{width}w.{ext}`
+ *
+ * Width suffix comes AFTER the selector suffix — the selector segments are
+ * part of the file's identity (which override is this), the width is part
+ * of the variant ladder for THAT identity. Owned here so the write side
+ * (ingest) and read side (asset-paths, URL construction) can't drift —
+ * change the scheme in one place.
+ */
+export function assetVariantBytesPath(assetName, hash, ext, width, selector) {
+    const extPart = ext.startsWith('.') ? ext : `.${ext}`;
+    return `${assetName}-${hash}${selectorSuffix(selector ?? null)}-${width}w${extPart}`;
+}
+/**
+ * Read an asset's default manifest. Thin alias for `readDefaultManifest`
+ * — kept for callers that haven't migrated yet. New code should prefer
+ * `readDefaultManifest` from `manifest-default.ts` directly so the
+ * default-vs-locale distinction is explicit at the call site.
+ */
+export const readManifest = readDefaultManifest;
+/**
+ * Write an asset manifest to storage. The storage provider's `writeFile` is
+ * already atomic (see providers/_atomic-write.ts) — this function adds no
+ * atomicity of its own, just serialization.
+ */
+export async function writeManifest(storage, assetsRoot, manifest) {
+    const path = `${assetsRoot}/${manifestPath(manifest.name)}`;
+    const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+    try {
+        await storage.writeFile(path, serialized);
+    }
+    catch (err) {
+        throw new AssetStorageError('write', path, err);
+    }
+}
+/**
+ * Write a locale-override manifest at `{name}.asset.{...selector}.json`.
+ * Same atomicity contract as `writeManifest` (storage provider handles
+ * write-then-rename atomicity); this function only serializes + dispatches.
+ *
+ * The locale manifest type isn't bound here — callers pass any
+ * JSON-serializable shape that conforms to `LocaleOverrideManifest` or
+ * `FontLocaleAdditiveManifest`. The validators in `manifest-locale.ts`
+ * are responsible for read-side shape enforcement; the writer trusts
+ * its caller.
+ */
+export async function writeLocaleManifest(storage, assetsRoot, assetName, selector, manifest) {
+    const path = `${assetsRoot}/${manifestPath(assetName, selector)}`;
+    const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+    try {
+        await storage.writeFile(path, serialized);
+    }
+    catch (err) {
+        throw new AssetStorageError('write', path, err);
+    }
+}
+//# sourceMappingURL=manifest.js.map

package/dist/assets/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/assets/manifest.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAiB,cAAc,EAAE,MAAM,yBAAyB,CAAA;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAE3D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,SAAiB,EAAE,QAA0B;IACxE,OAAO,GAAG,SAAS,SAAS,cAAc,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,CAAA;AACrE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,SAAiB,EAAE,IAAY,EAAE,GAAW,EAAE,QAA0B;IACrG,MAAM,OAAO,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAA;IACrD,OAAO,GAAG,SAAS,IAAI,IAAI,GAAG,cAAc,CAAC,QAAQ,IAAI,IAAI,CAAC,GAAG,OAAO,EAAE,CAAA;AAC5E,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CACnC,SAAiB,EACjB,IAAY,EACZ,GAAW,EACX,KAAa,EACb,QAA0B;IAE1B,MAAM,OAAO,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAA;IACrD,OAAO,GAAG,SAAS,IAAI,IAAI,GAAG,cAAc,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,OAAO,EAAE,CAAA;AACtF,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,mBAAmB,CAAA;AAE/C;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,OAAwB,EACxB,UAAkB,EAClB,QAAuB;IAEvB,MAAM,IAAI,GAAG,GAAG,UAAU,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IAC3D,MAAM,UAAU,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAA;IAC3D,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;IAC3C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,iBAAiB,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,OAAwB,EACxB,UAAkB,EAClB,SAAiB,EACjB,QAAkB,EAClB,QAAgB;IAEhB,MAAM,IAAI,GAAG,GAAG,UAAU,IAAI,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAA;IACjE,MAAM,UAAU,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAA;IAC3D,IAAI,CAAC;QACH,MAAM,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;IAC3C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,iBAAiB,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;AACH,CAAC"}

package/dist/assets/mime-sniff.d.ts

@@ -0,0 +1,18 @@
+export interface MimeSniffResult {
+    /** The stream, replaying all original bytes. */
+    stream: ReadableStream<Uint8Array>;
+    /** Detected MIME (e.g. `"image/jpeg"`) or null when no magic-byte match. */
+    mime: string | null;
+    /** Detected canonical extension (e.g. `"jpg"`) or null when no match. */
+    ext: string | null;
+}
+/**
+ * Sniff the MIME type from the head of a stream, returning a pass-through
+ * stream that carries the full byte sequence downstream.
+ *
+ * Returns `{ mime: null, ext: null }` on unknown magic bytes, empty streams,
+ * or plain text that doesn't match any format. Callers handle the null
+ * case — this module doesn't throw.
+ */
+export declare function sniffMimeFromStream(input: ReadableStream<Uint8Array>): Promise<MimeSniffResult>;
+//# sourceMappingURL=mime-sniff.d.ts.map

package/dist/assets/mime-sniff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mime-sniff.d.ts","sourceRoot":"","sources":["../../src/assets/mime-sniff.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAA;IAClC,4EAA4E;IAC5E,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,yEAAyE;IACzE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CACnB;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAmBrG"}

package/dist/assets/mime-sniff.js

@@ -0,0 +1,84 @@
+/**
+ * MIME sniffing from a byte stream — detect the type from magic bytes without
+ * consuming the stream. The returned stream replays every byte of the input
+ * (including the sample bytes used for detection); the detected MIME is
+ * attached once sniffing completes.
+ *
+ * Wraps `file-type`'s `fileTypeStream`, which builds an internal sample
+ * buffer (default 4100 bytes) without losing the originals.
+ *
+ * SVG handling: `file-type` v22+ detects SVG as `application/xml` (not the
+ * semantic `image/svg+xml`) because SVG is XML by syntax — magic bytes
+ * alone can't distinguish "SVG" from "any XML." This module promotes
+ * detected XML to `image/svg+xml` when the root element is `<svg>`. The
+ * promotion is conservative: malformed input that happens to start with
+ * `<svg` but isn't valid SVG will fail later sanitization, not here.
+ */
+import { fileTypeStream } from 'file-type';
+/**
+ * Sniff the MIME type from the head of a stream, returning a pass-through
+ * stream that carries the full byte sequence downstream.
+ *
+ * Returns `{ mime: null, ext: null }` on unknown magic bytes, empty streams,
+ * or plain text that doesn't match any format. Callers handle the null
+ * case — this module doesn't throw.
+ */
+export async function sniffMimeFromStream(input) {
+    const sniffed = await fileTypeStream(input);
+    let mime = sniffed.fileType?.mime ?? null;
+    let ext = sniffed.fileType?.ext ?? null;
+    // SVG promotion. file-type returns `application/xml` for any XML;
+    // peek the head of the stream and check for `<svg` near the start.
+    if (mime === 'application/xml' || mime === null) {
+        const promoted = await tryPromoteSvg(sniffed);
+        if (promoted) {
+            return { stream: promoted, mime: 'image/svg+xml', ext: 'svg' };
+        }
+    }
+    return {
+        stream: sniffed,
+        mime,
+        ext,
+    };
+}
+/**
+ * Drain a stream into chunks, check if the head looks like SVG
+ * (`<svg` near the start, optionally preceded by an XML prolog and/or
+ * whitespace), and return a fresh replay stream when so. Returns
+ * `null` when the input doesn't start with an `<svg>` root.
+ */
+async function tryPromoteSvg(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    let head = '';
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        if (value) {
+            chunks.push(value);
+            total += value.byteLength;
+            if (head.length < 512) {
+                head += new TextDecoder('utf-8', { fatal: false }).decode(value).slice(0, 512 - head.length);
+            }
+        }
+    }
+    const looksSvg = /^\s*(?:<\?xml[^>]*\?>\s*)?(?:<!--[\s\S]*?-->\s*)?<svg[\s>]/i.test(head);
+    if (!looksSvg)
+        return null;
+    // Replay every byte we drained as a fresh stream.
+    const flat = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        flat.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(flat);
+            controller.close();
+        },
+    });
+}
+//# sourceMappingURL=mime-sniff.js.map

package/dist/assets/mime-sniff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mime-sniff.js","sourceRoot":"","sources":["../../src/assets/mime-sniff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAW1C;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,KAAiC;IACzE,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,KAAK,CAAC,CAAA;IAC3C,IAAI,IAAI,GAAG,OAAO,CAAC,QAAQ,EAAE,IAAI,IAAI,IAAI,CAAA;IACzC,IAAI,GAAG,GAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,IAAI,IAAI,CAAA;IAEvC,kEAAkE;IAClE,mEAAmE;IACnE,IAAI,IAAI,KAAK,iBAAiB,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAChD,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,OAAqC,CAAC,CAAA;QAC3E,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,EAAE,CAAA;QAChE,CAAC;IACH,CAAC;IAED,OAAO;QACL,MAAM,EAAE,OAAqC;QAC7C,IAAI;QACJ,GAAG;KACJ,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,aAAa,CAAC,MAAkC;IAC7D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAA;IACjC,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,IAAI,IAAI,GAAG,EAAE,CAAA;IACb,SAAS,CAAC;QACR,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAA;QAC3C,IAAI,IAAI;YAAE,MAAK;QACf,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClB,KAAK,IAAI,KAAK,CAAC,UAAU,CAAA;YACzB,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;gBACtB,IAAI,IAAI,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAA;YAC9F,CAAC;QACH,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,6DAA6D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACzF,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAA;IAE1B,kDAAkD;IAClD,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAA;IAClC,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QACvB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAA;IAC5B,CAAC;IACD,OAAO,IAAI,cAAc,CAAa;QACpC,KAAK,CAAC,UAAU;YACd,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YACxB,UAAU,CAAC,KAAK,EAAE,CAAA;QACpB,CAAC;KACF,CAAC,CAAA;AACJ,CAAC"}

package/dist/assets/preprocess-svg.d.ts

@@ -0,0 +1,3 @@
+import type { UploadPreprocessor } from './preprocess.js';
+export declare const svgPreprocessor: UploadPreprocessor;
+//# sourceMappingURL=preprocess-svg.d.ts.map

package/dist/assets/preprocess-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess-svg.d.ts","sourceRoot":"","sources":["../../src/assets/preprocess-svg.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAuC,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAG9F,eAAO,MAAM,eAAe,EAAE,kBAqB7B,CAAA"}

package/dist/assets/preprocess-svg.js

@@ -0,0 +1,49 @@
+/**
+ * SVG upload preprocessor — adapts `sanitizeSvg` to the
+ * `UploadPreprocessor` contract.
+ *
+ * SRP: this module owns the SVG-specific decisions for the preprocess
+ * pipeline (which MIMEs trigger it, how to wrap warnings, how to
+ * translate sanitization errors). The actual sanitization rules
+ * (DOMPurify config, base64 thresholds) live in `svg-sanitize.ts`
+ * — that's the format-specific policy module.
+ *
+ * Adding a new preprocessor follows this exact shape: one module per
+ * format, one matcher, one wrapper around the format's pure logic.
+ */
+import { AssetPreprocessError } from './errors.js';
+import { sanitizeSvg, SvgSanitizeError, SVG_MIME_TYPE } from './svg-sanitize.js';
+export const svgPreprocessor = {
+    name: 'svg',
+    matches(mime) {
+        return mime === SVG_MIME_TYPE;
+    },
+    preprocess(bytes) {
+        try {
+            const result = sanitizeSvg(bytes);
+            return {
+                bytes: result.bytes,
+                warnings: result.warnings.map(toPreprocessWarning),
+            };
+        }
+        catch (err) {
+            if (err instanceof SvgSanitizeError) {
+                throw new AssetPreprocessError('svg', err.code, err);
+            }
+            // Other errors surface as-is; the registry wraps them into
+            // AssetPreprocessError with reason='unexpected'.
+            throw err;
+        }
+    },
+};
+function toPreprocessWarning(w) {
+    switch (w.code) {
+        case 'large-base64':
+            return { code: 'svg-large-base64', sizeBytes: w.sizeBytes, threshold: w.threshold };
+        case 'stripped-element':
+            return { code: 'svg-stripped-element', tag: w.tag };
+        case 'stripped-attribute':
+            return { code: 'svg-stripped-attribute', attr: w.attr, on: w.on };
+    }
+}
+//# sourceMappingURL=preprocess-svg.js.map

package/dist/assets/preprocess-svg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess-svg.js","sourceRoot":"","sources":["../../src/assets/preprocess-svg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAElD,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEhF,MAAM,CAAC,MAAM,eAAe,GAAuB;IACjD,IAAI,EAAE,KAAK;IACX,OAAO,CAAC,IAAmB;QACzB,OAAO,IAAI,KAAK,aAAa,CAAA;IAC/B,CAAC;IACD,UAAU,CAAC,KAAiB;QAC1B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,CAAA;YACjC,OAAO;gBACL,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC;aACnD,CAAA;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,GAAG,YAAY,gBAAgB,EAAE,CAAC;gBACpC,MAAM,IAAI,oBAAoB,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;YACtD,CAAC;YACD,2DAA2D;YAC3D,iDAAiD;YACjD,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;CACF,CAAA;AAED,SAAS,mBAAmB,CAAC,CAAqD;IAChF,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,cAAc;YACjB,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAA;QACrF,KAAK,kBAAkB;YACrB,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAA;QACrD,KAAK,oBAAoB;YACvB,OAAO,EAAE,IAAI,EAAE,wBAAwB,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAA;IACrE,CAAC;AACH,CAAC"}

package/dist/assets/preprocess.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Non-fatal observations about how the bytes were transformed. Today
+ * SVG can warn about large embedded base64; future preprocessors may
+ * surface "EXIF orientation applied", "metadata stripped", etc.
+ *
+ * Open shape — preprocessors define their own warning codes via the
+ * union of all registered preprocessors. Today only SVG warnings.
+ */
+export type PreprocessWarning = {
+    code: 'svg-stripped-element';
+    tag: string;
+} | {
+    code: 'svg-stripped-attribute';
+    attr: string;
+    on: string;
+} | {
+    code: 'svg-large-base64';
+    sizeBytes: number;
+    threshold: number;
+};
+export interface PreprocessResult {
+    /** Bytes after preprocessing — may be the same reference when no transform applied. */
+    bytes: Uint8Array;
+    /** Format-specific non-fatal warnings. Empty when nothing to flag. */
+    warnings: readonly PreprocessWarning[];
+}
+/**
+ * One format's preprocessing contract. Implementations are pure
+ * (no I/O, no storage, no history) so they're trivially testable.
+ */
+export interface UploadPreprocessor {
+    /** Stable identifier for diagnostics (`'svg'`, `'heic'`, etc.). */
+    readonly name: string;
+    /** Whether this preprocessor applies to the given MIME. */
+    matches(mime: string | null): boolean;
+    /**
+     * Transform the bytes. Return new bytes (may be the same reference
+     * if no transformation is needed) plus any warnings. Throw
+     * `AssetPreprocessError` for unrecoverable input problems.
+     */
+    preprocess(bytes: Uint8Array): PreprocessResult | Promise<PreprocessResult>;
+}
+/**
+ * The default registry — what ingest uses out of the box. Order
+ * matters when more than one preprocessor matches; today only one
+ * preprocessor matches any given MIME.
+ *
+ * Adding a new format-specific preprocessor: implement
+ * `UploadPreprocessor`, append it here. Ingest needs no edits.
+ */
+export declare const defaultPreprocessors: readonly UploadPreprocessor[];
+/**
+ * Run the matching preprocessor for the given MIME. Returns the
+ * (possibly-transformed) bytes + any warnings; pass through unchanged
+ * when no preprocessor matches.
+ *
+ * Thrown errors propagate. Preprocessors throw `AssetPreprocessError`
+ * for client-correctable input problems; other thrown errors (e.g.
+ * out-of-memory during a large transform) bubble as-is.
+ */
+export declare function runPreprocessors(bytes: Uint8Array, mime: string | null, preprocessors?: readonly UploadPreprocessor[]): Promise<PreprocessResult>;
+//# sourceMappingURL=preprocess.d.ts.map

package/dist/assets/preprocess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess.d.ts","sourceRoot":"","sources":["../../src/assets/preprocess.ts"],"names":[],"mappings":"AAmDA;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,wBAAwB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtE,MAAM,WAAW,gBAAgB;IAC/B,uFAAuF;IACvF,KAAK,EAAE,UAAU,CAAA;IACjB,sEAAsE;IACtE,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAA;CACvC;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,2DAA2D;IAC3D,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;IACrC;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAC5E;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,kBAAkB,EAAsB,CAAA;AAEpF;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,aAAa,GAAE,SAAS,kBAAkB,EAAyB,GAClE,OAAO,CAAC,gBAAgB,CAAC,CAc3B"}

package/dist/assets/preprocess.js

@@ -0,0 +1,86 @@
+/**
+ * Format-specific upload preprocessing — the seam where formats register
+ * "transform these bytes before storage."
+ *
+ * # Why
+ *
+ * Some formats need work between MIME-sniff and storage write:
+ *
+ *   - SVG: strip script tags, event handlers, external hrefs, and
+ *     oversized embedded base64 (security + bloat — see svg-sanitize.ts)
+ *   - HEIC: transcode to JPEG (browsers can't display HEIC) — future
+ *   - Animated GIF: extract first frame as poster, set `animated`
+ *     manifest flag — future
+ *   - JPEG with EXIF: apply orientation, strip personal metadata — future
+ *
+ * Without an abstraction, every new format adds an `if (mime === '...')`
+ * branch to `ingestAsset`. The hot path grows with each format; format-
+ * specific code lives in the wrong place; tests for one format have
+ * to stand up the whole ingest pipeline.
+ *
+ * # Contract
+ *
+ * `UploadPreprocessor` is the open extension seam:
+ *   - `matches(mime)` → does this preprocessor apply?
+ *   - `preprocess(bytes)` → return new bytes (and optional warnings)
+ *
+ * Each registered preprocessor handles one MIME (or a small family —
+ * a future "EXIF" preprocessor might handle both `image/jpeg` and
+ * `image/heic`). The registry is checked in order; the first matching
+ * preprocessor runs and its output replaces the buffer.
+ *
+ * # SOLID lenses
+ *
+ *   - SRP: each preprocessor module owns one format's preprocessing
+ *   - OCP: adding a format = new module + register; ingest unchanged
+ *   - LSP: every preprocessor honors the same contract — return bytes
+ *     or throw `AssetPreprocessError`
+ *   - ISP: callers (ingest) depend on `runPreprocessors`, not on the
+ *     individual format modules
+ *   - DIP: ingest depends on the abstraction; format modules implement
+ *     it. SVG-specific knowledge lives in `preprocess-svg.ts`.
+ *
+ * # v1 scope
+ *
+ * Today's only registered preprocessor is SVG. The default registry
+ * (`defaultPreprocessors`) is what `ingestAsset` uses out of the box;
+ * tests can construct an empty registry to bypass preprocessing.
+ */
+import { AssetPreprocessError } from './errors.js';
+import { svgPreprocessor } from './preprocess-svg.js';
+/**
+ * The default registry — what ingest uses out of the box. Order
+ * matters when more than one preprocessor matches; today only one
+ * preprocessor matches any given MIME.
+ *
+ * Adding a new format-specific preprocessor: implement
+ * `UploadPreprocessor`, append it here. Ingest needs no edits.
+ */
+export const defaultPreprocessors = [svgPreprocessor];
+/**
+ * Run the matching preprocessor for the given MIME. Returns the
+ * (possibly-transformed) bytes + any warnings; pass through unchanged
+ * when no preprocessor matches.
+ *
+ * Thrown errors propagate. Preprocessors throw `AssetPreprocessError`
+ * for client-correctable input problems; other thrown errors (e.g.
+ * out-of-memory during a large transform) bubble as-is.
+ */
+export async function runPreprocessors(bytes, mime, preprocessors = defaultPreprocessors) {
+    for (const p of preprocessors) {
+        if (p.matches(mime)) {
+            try {
+                return await p.preprocess(bytes);
+            }
+            catch (err) {
+                if (err instanceof AssetPreprocessError)
+                    throw err;
+                // Wrap unexpected errors so the caller always sees a typed
+                // surface for preprocessing failures.
+                throw new AssetPreprocessError(p.name, 'unexpected', err);
+            }
+        }
+    }
+    return { bytes, warnings: [] };
+}
+//# sourceMappingURL=preprocess.js.map

package/dist/assets/preprocess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess.js","sourceRoot":"","sources":["../../src/assets/preprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAuCrD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAkC,CAAC,eAAe,CAAC,CAAA;AAEpF;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAAiB,EACjB,IAAmB,EACnB,gBAA+C,oBAAoB;IAEnE,KAAK,MAAM,CAAC,IAAI,aAAa,EAAE,CAAC;QAC9B,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC;gBACH,OAAO,MAAM,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;YAClC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,GAAG,YAAY,oBAAoB;oBAAE,MAAM,GAAG,CAAA;gBAClD,2DAA2D;gBAC3D,sCAAsC;gBACtC,MAAM,IAAI,oBAAoB,CAAC,CAAC,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,CAAC,CAAA;YAC3D,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;AAChC,CAAC"}

package/dist/assets/publish-plan.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Publish-plan — figures out *what* to publish before any bytes move.
+ *
+ * Single responsibility: turn a set of items being published into either
+ * a `Plan` (the asset names to copy + the items that referenced them) or
+ * a structured `missing-on-source` failure. No I/O on the destination —
+ * actually copying bytes is `publish.ts`'s job.
+ *
+ * Splitting the planner from the executor lets the validation failure
+ * short-circuit before a single stream is opened. It also lets the
+ * orchestrator wire publish-assets into the broader publish flow with
+ * full knowledge of what's about to happen — useful for ordering writes
+ * (assets before pages) and for surfacing per-asset progress.
+ */
+import type { ContentRoot } from '../content-root.js';
+export interface PlanInput {
+    /** Source content root (where pages/, fragments/, and assets/ live on the source side). */
+    readonly sourceRoot: ContentRoot;
+    /** Target content root (where pages/, fragments/, and assets/ will land on the target side). */
+    readonly targetRoot: ContentRoot;
+    /** Items being published — e.g., `['pages/home', 'fragments/header']`. */
+    readonly itemNames: readonly string[];
+}
+export type Plan = {
+    readonly ok: true;
+    readonly assets: readonly string[];
+    readonly itemsWithRefs: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: 'missing-on-source';
+    readonly missing: readonly string[];
+};
+/**
+ * Compute the set of assets to publish given the items being published,
+ * after running the source-existence pre-flight check.
+ *
+ * Empty refs short-circuit to `ok: true` with no assets — sites without
+ * media still publish fine.
+ */
+export declare function planAssetCopy(input: PlanInput): Promise<Plan>;
+//# sourceMappingURL=publish-plan.d.ts.map

package/dist/assets/publish-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-plan.d.ts","sourceRoot":"","sources":["../../src/assets/publish-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAIrD,MAAM,WAAW,SAAS;IACxB,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAA;IAChC,gGAAgG;IAChG,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAA;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC;AAED,MAAM,MAAM,IAAI,GACZ;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACpG;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAA;AAErG;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAenE"}