gazetta 0.6.0 → 0.8.0

package/dist/archive-aliases.js

@@ -0,0 +1,60 @@
+import { applyDepDiff, rebuildItemDeps, readDepsFor, } from './dep-sidecars.js';
+/**
+ * The archive-aliases relation.
+ *
+ * Extracts the alias target from a manifest. The set is at most
+ * one element — Q3 flatten guarantees one-hop aliases. A live
+ * manifest (or an archived-without-alias manifest) yields the
+ * empty set, which means no sidecars are written for it.
+ */
+export const ARCHIVE_ALIASES = {
+    rootName: 'alias-targets',
+    extract: (manifest) => {
+        // Cast: ComponentManifest is the full shape; ManifestLike is
+        // the dep-sidecars module's loose type. The `archived` and
+        // `aliasOf` fields aren't part of `ManifestLike`'s declaration,
+        // so the cast names what we're looking at.
+        const m = manifest;
+        if (m.archived !== true)
+            return new Set();
+        if (typeof m.aliasOf !== 'string' || m.aliasOf.length === 0)
+            return new Set();
+        return new Set([m.aliasOf]);
+    },
+};
+/**
+ * Read every archived item that aliases this target. Returns
+ * `ItemRef[]`; the caller maps to `(kind, name)` for error bodies
+ * (e.g. the purge-blocked 409 response from `design-soft-delete.md`
+ * Q4).
+ */
+export function readArchivesAliasing(contentRoot, targetName) {
+    return readDepsFor(ARCHIVE_ALIASES, contentRoot, targetName);
+}
+/**
+ * Apply the alias-targets diff for one item's manifest change.
+ *
+ * Pass the pre-save manifest as `oldManifest` and the post-save
+ * manifest as `newManifest`. The diff drops sidecars for any
+ * removed alias targets and writes sidecars for any added targets.
+ *
+ * Cases:
+ *   - Live → archive(aliasOf=X)         : write `.gazetta/alias-targets/X/{item}`
+ *   - Live → archive(no aliasOf)         : no I/O
+ *   - Archive(X) → archive(Y)            : remove X's sidecar, write Y's
+ *   - Archive(X) → archive(no aliasOf)   : remove X's sidecar
+ *   - Archive(X) → live                  : remove X's sidecar
+ *   - Archive(X) → null (purge)          : remove X's sidecar
+ *   - Live → null (purge)                : no I/O
+ */
+export function rebuildArchiveAliases(contentRoot, item, oldManifest, newManifest) {
+    return rebuildItemDeps(ARCHIVE_ALIASES, contentRoot, item, oldManifest, newManifest);
+}
+/**
+ * Apply a pre-computed diff (used in tests + cases where the
+ * caller has the alias names already).
+ */
+export function applyArchiveAliasesDiff(contentRoot, item, oldTargets, newTargets) {
+    return applyDepDiff(ARCHIVE_ALIASES, contentRoot, item, oldTargets, newTargets);
+}
+//# sourceMappingURL=archive-aliases.js.map

package/dist/archive-aliases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-aliases.js","sourceRoot":"","sources":["../src/archive-aliases.ts"],"names":[],"mappings":"AAwCA,OAAO,EAIL,YAAY,EACZ,eAAe,EACf,WAAW,GACZ,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,QAAQ,EAAE,eAAe;IACzB,OAAO,EAAE,CAAC,QAAsB,EAAE,EAAE;QAClC,6DAA6D;QAC7D,2DAA2D;QAC3D,gEAAgE;QAChE,2CAA2C;QAC3C,MAAM,CAAC,GAAG,QAAsC,CAAA;QAChD,IAAI,CAAC,CAAC,QAAQ,KAAK,IAAI;YAAE,OAAO,IAAI,GAAG,EAAU,CAAA;QACjD,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,GAAG,EAAU,CAAA;QACrF,OAAO,IAAI,GAAG,CAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAA;IACrC,CAAC;CACF,CAAA;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,WAAwB,EAAE,UAAkB;IAC/E,OAAO,WAAW,CAAC,eAAe,EAAE,WAAW,EAAE,UAAU,CAAC,CAAA;AAC9D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,qBAAqB,CACnC,WAAwB,EACxB,IAAa,EACb,WAAgC,EAChC,WAAgC;IAEhC,OAAO,eAAe,CAAC,eAAe,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,CAAC,CAAA;AACtF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,WAAwB,EACxB,IAAa,EACb,UAA+B,EAC/B,UAA+B;IAE/B,OAAO,YAAY,CAAC,eAAe,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,CAAA;AACjF,CAAC"}

package/dist/archive-helpers.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Archive predicates + alias resolution helpers per design-soft-delete.md.
+ *
+ * Pure functions over manifest data. No I/O. The render pipeline + admin
+ * routes consume these instead of inlining `manifest.archived === true`
+ * checks (SRP — archive semantics in one place).
+ *
+ * Archive state lives on the manifest itself (Q1 lock — manifest field,
+ * not sidecar). Aliasing is a runtime concern — the resolver follows
+ * `aliasOf` for archived items with the field set; throws ARCHIVED_NO_ALIAS
+ * for archived items without (Q2 F1 split).
+ *
+ * Q3 flatten-on-rename guarantees aliases never point at other archives —
+ * one-hop only. The recursion limit + cycle detection in
+ * `resolveFragmentArchiveAlias` are defensive: if external manifest
+ * mutation produces a chain (git pull, hand edit), we still terminate.
+ */
+import type { ComponentManifest } from './types.js';
+/** True when the manifest is archived (and not a non-archived archived: false). */
+export declare function isArchived(manifest: {
+    archived?: boolean;
+}): boolean;
+/**
+ * Returns the alias target name when the manifest is archived AND has
+ * `aliasOf` set; null in any other case (live manifest, or archived
+ * without alias).
+ *
+ * The caller distinguishes "live" from "archived without alias" via
+ * `isArchived(manifest)` — both states return null here, but the runtime
+ * behavior differs (live = render normally; archived-no-alias = throw).
+ */
+export declare function aliasTarget(manifest: {
+    archived?: boolean;
+    aliasOf?: string;
+}): string | null;
+/**
+ * Error thrown by `resolveFragmentArchiveAlias` when an archived fragment
+ * has no `aliasOf` field. Caller (renderer / worker) decides UX:
+ *
+ *   - Renderer: surface as render-time error (per Q2 F1 split)
+ *   - Validator (P1): warn at save / background / pre-publish
+ *   - Worker: emit 410 Gone on the page that referenced this fragment
+ *
+ * Distinct error class so callers can `instanceof`-check without
+ * pattern-matching messages.
+ */
+export declare class ArchivedNoAliasError extends Error {
+    readonly fragmentName: string;
+    constructor(fragmentName: string, contextPath?: string);
+}
+/**
+ * Resolve a fragment ref through the alias chain. Returns the live
+ * fragment name to use for the actual lookup.
+ *
+ * - Live fragment → returns the original name unchanged
+ * - Archived fragment with `aliasOf: X` → recurses to resolve X
+ * - Archived fragment without `aliasOf` → throws ArchivedNoAliasError
+ * - Alias chain longer than MAX_ALIAS_HOPS → throws (data-corruption guard)
+ * - Cycle (A → B → A) → throws (data-corruption guard)
+ *
+ * The `lookupFragment` callback decouples this helper from the
+ * `Site.fragments` / `Site.fragmentLocales` map shape — the resolver
+ * passes whichever lookup strategy applies for the active locale.
+ *
+ * Returns null when the resolved name doesn't exist as a fragment
+ * (the caller's lookup returned null at some point in the chain) —
+ * caller surfaces "fragment not found" with their own context.
+ */
+export declare function resolveFragmentArchiveAlias(fragmentName: string, lookupFragment: (name: string) => ComponentManifest | null, contextPath?: string): {
+    resolvedName: string;
+    manifest: ComponentManifest;
+} | null;
+//# sourceMappingURL=archive-helpers.d.ts.map

package/dist/archive-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-helpers.d.ts","sourceRoot":"","sources":["../src/archive-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,QAAQ,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAEpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAG7F;AAED;;;;;;;;;;GAUG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;gBAEjB,YAAY,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;CASvD;AASD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,IAAI,EAC1D,WAAW,CAAC,EAAE,MAAM,GACnB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAA;CAAE,GAAG,IAAI,CAkC9D"}

package/dist/archive-helpers.js

@@ -0,0 +1,94 @@
+/** True when the manifest is archived (and not a non-archived archived: false). */
+export function isArchived(manifest) {
+    return manifest.archived === true;
+}
+/**
+ * Returns the alias target name when the manifest is archived AND has
+ * `aliasOf` set; null in any other case (live manifest, or archived
+ * without alias).
+ *
+ * The caller distinguishes "live" from "archived without alias" via
+ * `isArchived(manifest)` — both states return null here, but the runtime
+ * behavior differs (live = render normally; archived-no-alias = throw).
+ */
+export function aliasTarget(manifest) {
+    if (!isArchived(manifest))
+        return null;
+    return manifest.aliasOf ?? null;
+}
+/**
+ * Error thrown by `resolveFragmentArchiveAlias` when an archived fragment
+ * has no `aliasOf` field. Caller (renderer / worker) decides UX:
+ *
+ *   - Renderer: surface as render-time error (per Q2 F1 split)
+ *   - Validator (P1): warn at save / background / pre-publish
+ *   - Worker: emit 410 Gone on the page that referenced this fragment
+ *
+ * Distinct error class so callers can `instanceof`-check without
+ * pattern-matching messages.
+ */
+export class ArchivedNoAliasError extends Error {
+    fragmentName;
+    constructor(fragmentName, contextPath) {
+        const where = contextPath ? `\n  Resolution path: ${contextPath}` : '';
+        super(`Fragment "@${fragmentName}" is archived without an alias. References to it cannot resolve.${where}\n` +
+            `  Restore the fragment, set its aliasOf, or remove the reference.`);
+        this.name = 'ArchivedNoAliasError';
+        this.fragmentName = fragmentName;
+    }
+}
+/**
+ * Maximum hops the alias chain may follow. Q3 flatten guarantees one,
+ * so we tolerate 5 to absorb data corruption (git pull, hand edit) and
+ * still surface a clear error if someone constructs a real chain by hand.
+ */
+const MAX_ALIAS_HOPS = 5;
+/**
+ * Resolve a fragment ref through the alias chain. Returns the live
+ * fragment name to use for the actual lookup.
+ *
+ * - Live fragment → returns the original name unchanged
+ * - Archived fragment with `aliasOf: X` → recurses to resolve X
+ * - Archived fragment without `aliasOf` → throws ArchivedNoAliasError
+ * - Alias chain longer than MAX_ALIAS_HOPS → throws (data-corruption guard)
+ * - Cycle (A → B → A) → throws (data-corruption guard)
+ *
+ * The `lookupFragment` callback decouples this helper from the
+ * `Site.fragments` / `Site.fragmentLocales` map shape — the resolver
+ * passes whichever lookup strategy applies for the active locale.
+ *
+ * Returns null when the resolved name doesn't exist as a fragment
+ * (the caller's lookup returned null at some point in the chain) —
+ * caller surfaces "fragment not found" with their own context.
+ */
+export function resolveFragmentArchiveAlias(fragmentName, lookupFragment, contextPath) {
+    const visited = new Set();
+    let currentName = fragmentName;
+    for (let hop = 0; hop <= MAX_ALIAS_HOPS; hop++) {
+        if (visited.has(currentName)) {
+            const where = contextPath ? `\n  Resolution path: ${contextPath}` : '';
+            throw new Error(`Circular fragment alias chain detected at "@${currentName}".\n` +
+                `  Chain: ${[...visited, currentName].map(n => `@${n}`).join(' → ')}${where}\n` +
+                `  Q3 flatten-on-rename should make this impossible; check for hand-edited manifests.`);
+        }
+        visited.add(currentName);
+        const manifest = lookupFragment(currentName);
+        if (!manifest)
+            return null;
+        if (!isArchived(manifest)) {
+            return { resolvedName: currentName, manifest };
+        }
+        // Archived; check for alias
+        const next = aliasTarget(manifest);
+        if (next === null) {
+            throw new ArchivedNoAliasError(currentName, contextPath);
+        }
+        currentName = next;
+    }
+    // Hop budget exhausted without landing on a live fragment.
+    const where = contextPath ? `\n  Resolution path: ${contextPath}` : '';
+    throw new Error(`Fragment alias chain exceeded ${MAX_ALIAS_HOPS} hops starting from "@${fragmentName}".\n` +
+        `  Chain: ${[...visited].map(n => `@${n}`).join(' → ')}${where}\n` +
+        `  Q3 flatten-on-rename should make chains > 1 hop impossible; check for hand-edited manifests.`);
+}
+//# sourceMappingURL=archive-helpers.js.map

package/dist/archive-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-helpers.js","sourceRoot":"","sources":["../src/archive-helpers.ts"],"names":[],"mappings":"AAmBA,mFAAmF;AACnF,MAAM,UAAU,UAAU,CAAC,QAAgC;IACzD,OAAO,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAA;AACnC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,QAAkD;IAC5E,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAA;IACtC,OAAO,QAAQ,CAAC,OAAO,IAAI,IAAI,CAAA;AACjC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IACpC,YAAY,CAAQ;IAE7B,YAAY,YAAoB,EAAE,WAAoB;QACpD,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,wBAAwB,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;QACtE,KAAK,CACH,cAAc,YAAY,mEAAmE,KAAK,IAAI;YACpG,mEAAmE,CACtE,CAAA;QACD,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAA;QAClC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,cAAc,GAAG,CAAC,CAAA;AAExB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,2BAA2B,CACzC,YAAoB,EACpB,cAA0D,EAC1D,WAAoB;IAEpB,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAA;IACjC,IAAI,WAAW,GAAG,YAAY,CAAA;IAC9B,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,cAAc,EAAE,GAAG,EAAE,EAAE,CAAC;QAC/C,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,wBAAwB,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;YACtE,MAAM,IAAI,KAAK,CACb,+CAA+C,WAAW,MAAM;gBAC9D,YAAY,CAAC,GAAG,OAAO,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,IAAI;gBAC/E,sFAAsF,CACzF,CAAA;QACH,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;QAExB,MAAM,QAAQ,GAAG,cAAc,CAAC,WAAW,CAAC,CAAA;QAC5C,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAA;QAE1B,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC1B,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAA;QAChD,CAAC;QACD,4BAA4B;QAC5B,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;QAClC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,MAAM,IAAI,oBAAoB,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;QAC1D,CAAC;QACD,WAAW,GAAG,IAAI,CAAA;IACpB,CAAC;IACD,2DAA2D;IAC3D,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,wBAAwB,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IACtE,MAAM,IAAI,KAAK,CACb,iCAAiC,cAAc,yBAAyB,YAAY,MAAM;QACxF,YAAY,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,IAAI;QAClE,gGAAgG,CACnG,CAAA;AACH,CAAC"}

package/dist/assets/analyze-audio.d.ts

@@ -0,0 +1,3 @@
+import type { UploadAnalyzer } from './analyze.js';
+export declare const audioAnalyzer: UploadAnalyzer;
+//# sourceMappingURL=analyze-audio.d.ts.map

package/dist/assets/analyze-audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-audio.d.ts","sourceRoot":"","sources":["../../src/assets/analyze-audio.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAiC,cAAc,EAAE,MAAM,cAAc,CAAA;AAoBjF,eAAO,MAAM,aAAa,EAAE,cAuC3B,CAAA"}

package/dist/assets/analyze-audio.js

@@ -0,0 +1,80 @@
+/**
+ * Audio analyzer — extracts duration via the `music-metadata` library.
+ *
+ * Single responsibility: read audio bytes, return manifest enrichment
+ * (`duration` in milliseconds; null when the format technically
+ * supports duration but the value couldn't be derived from headers).
+ *
+ * Design notes (per design-media.md):
+ *   - Personal-metadata stripping is documented as the default for
+ *     audio, with opt-in preservation. The analyzer reads metadata
+ *     non-destructively here; stripping is a *byte-transform* concern
+ *     (preprocessor surface, not analyzer). Wiring an
+ *     `audioMetadataPreprocessor` is a v1.5 follow-up — the analyzer
+ *     reading duration doesn't preclude future stripping.
+ *   - No supplementary files in v1. Future waveform-image extraction
+ *     would slot in here (`supplementaryFiles: [{ path: ...waveform.svg }]`).
+ *   - Format-specific MIME match: MP3, WAV, FLAC, Opus, AAC, M4A, OGG.
+ *     `music-metadata` v11+ handles all of these natively.
+ *
+ * SOLID lenses:
+ *   - SRP: this module owns "audio bytes → duration"
+ *   - OCP: adding waveform extraction = same module gains a
+ *     supplementary-file output; no other module changes
+ *   - LSP: honors the `UploadAnalyzer` contract — match + analyze
+ *   - ISP / DIP: ingest depends on `runAnalyzers`, not on this module
+ */
+import { parseBuffer } from 'music-metadata';
+/**
+ * MIMEs the audio analyzer matches. Mirrors the v1 audio allowlist
+ * documented in design-media.md. Adding a new audio MIME here +
+ * `ALLOWED_MIMES` admits it; no other code changes.
+ */
+const AUDIO_MIMES = new Set([
+    'audio/mpeg', // MP3
+    'audio/wav',
+    'audio/x-wav',
+    'audio/flac',
+    'audio/x-flac',
+    'audio/ogg',
+    'audio/opus',
+    'audio/aac',
+    'audio/mp4', // M4A
+    'audio/x-m4a',
+]);
+export const audioAnalyzer = {
+    name: 'audio',
+    matches(mime) {
+        return !!mime && AUDIO_MIMES.has(mime);
+    },
+    async analyze(input) {
+        let durationSec;
+        try {
+            // music-metadata accepts a Buffer or Uint8Array; we already have
+            // the bytes from the preprocess pass.
+            const meta = await parseBuffer(input.bytes, { mimeType: input.mime, size: input.bytes.byteLength }, {
+                skipPostHeaders: true,
+            });
+            durationSec = typeof meta.format.duration === 'number' ? meta.format.duration : undefined;
+        }
+        catch {
+            // Malformed audio header — bail out with no enrichment. The
+            // upload still succeeds (the user's bytes are valid as far as
+            // MIME sniffing was concerned); we just couldn't extract a
+            // duration. A future stricter mode could throw here.
+            return {};
+        }
+        if (durationSec === undefined) {
+            // Format supports duration in principle but we couldn't extract.
+            // null distinguishes "not applicable" (static image, document)
+            // from "applicable but unknown" (corrupt header, streaming OGG
+            // without a length).
+            return { manifestPatch: { duration: null } };
+        }
+        // music-metadata returns seconds; manifest stores milliseconds
+        // (matching animated-image duration units, where sharp returns ms).
+        const durationMs = Math.round(durationSec * 1000);
+        return { manifestPatch: { duration: durationMs } };
+    },
+};
+//# sourceMappingURL=analyze-audio.js.map

package/dist/assets/analyze-audio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-audio.js","sourceRoot":"","sources":["../../src/assets/analyze-audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAG5C;;;;GAIG;AACH,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC;IAC1B,YAAY,EAAE,MAAM;IACpB,WAAW;IACX,aAAa;IACb,YAAY;IACZ,cAAc;IACd,WAAW;IACX,YAAY;IACZ,WAAW;IACX,WAAW,EAAE,MAAM;IACnB,aAAa;CACd,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,aAAa,GAAmB;IAC3C,IAAI,EAAE,OAAO;IACb,OAAO,CAAC,IAAI;QACV,OAAO,CAAC,CAAC,IAAI,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IACxC,CAAC;IACD,KAAK,CAAC,OAAO,CAAC,KAAoB;QAChC,IAAI,WAA+B,CAAA;QACnC,IAAI,CAAC;YACH,iEAAiE;YACjE,sCAAsC;YACtC,MAAM,IAAI,GAAG,MAAM,WAAW,CAC5B,KAAK,CAAC,KAAK,EACX,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,EACtD;gBACE,eAAe,EAAE,IAAI;aACtB,CACF,CAAA;YACD,WAAW,GAAG,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAA;QAC3F,CAAC;QAAC,MAAM,CAAC;YACP,4DAA4D;YAC5D,8DAA8D;YAC9D,2DAA2D;YAC3D,qDAAqD;YACrD,OAAO,EAAE,CAAA;QACX,CAAC;QAED,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,iEAAiE;YACjE,+DAA+D;YAC/D,+DAA+D;YAC/D,qBAAqB;YACrB,OAAO,EAAE,aAAa,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAA;QAC9C,CAAC;QAED,+DAA+D;QAC/D,oEAAoE;QACpE,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;QACjD,OAAO,EAAE,aAAa,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,CAAA;IACpD,CAAC;CACF,CAAA"}

package/dist/assets/analyze-image.d.ts

@@ -0,0 +1,19 @@
+import type { UploadAnalyzer } from './analyze.js';
+/**
+ * Static-image analyzer — width + height. Runs for any `image/*`
+ * MIME except SVG (which has its own dimension path; libvips
+ * sometimes mis-reports vector content).
+ */
+export declare const staticImageAnalyzer: UploadAnalyzer;
+/**
+ * Animated-image analyzer — `pages > 1` detection, frame count,
+ * duration sum, and first-frame poster extraction.
+ *
+ * Per design-media.md: animated images render as `<img>` in v1
+ * (no `<video>` transcoding — that requires ffmpeg). The poster
+ * is provided so future UI layers (lazy-load, video-style poster
+ * fallback) can use it; v1 templates can also render the poster
+ * for reduced-motion preferences.
+ */
+export declare const animatedImageAnalyzer: UploadAnalyzer;
+//# sourceMappingURL=analyze-image.d.ts.map

package/dist/assets/analyze-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-image.d.ts","sourceRoot":"","sources":["../../src/assets/analyze-image.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAiC,cAAc,EAAE,MAAM,cAAc,CAAA;AASjF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAkBjC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,cA4DnC,CAAA"}

package/dist/assets/analyze-image.js

@@ -0,0 +1,123 @@
+/**
+ * Image analyzers — read final bytes, contribute manifest fields
+ * (and a poster file for animated content). Two analyzers behind
+ * the abstraction:
+ *
+ *   - `staticImageAnalyzer` — extracts width + height for any image
+ *     MIME. Always runs. Animated images also produce dimensions
+ *     (the canvas size); they get the same width/height treatment.
+ *   - `animatedImageAnalyzer` — runs for formats that can carry
+ *     animation (GIF, APNG, animated WebP, animated AVIF). Reads
+ *     `pages` + `delay[]` from sharp's metadata, sets
+ *     `animated/frames/duration`, extracts the first frame as a
+ *     poster PNG.
+ *
+ * Both analyzers are sharp-backed. SVG bypasses (no analyzer matches
+ * `image/svg+xml`) — sharp can metadata SVG via libvips, but the
+ * sanitizer-modified bytes are what we want characterized, and the
+ * existing inline `extractImageDimensions` already handles SVG dims
+ * correctly inside ingest. Kept separate for now; SVG could move into
+ * an analyzer when the dimension-extraction call site changes.
+ */
+import sharp from 'sharp';
+const ANIMATED_MIMES = new Set([
+    'image/gif',
+    'image/png', // APNG; sharp surfaces pages > 1 when animated
+    'image/webp', // animated WebP
+    'image/avif', // animated AVIF
+]);
+/**
+ * Static-image analyzer — width + height. Runs for any `image/*`
+ * MIME except SVG (which has its own dimension path; libvips
+ * sometimes mis-reports vector content).
+ */
+export const staticImageAnalyzer = {
+    name: 'static-image',
+    matches(mime) {
+        return !!mime && mime.startsWith('image/') && mime !== 'image/svg+xml';
+    },
+    async analyze(input) {
+        try {
+            const meta = await sharp(input.bytes).metadata();
+            const width = typeof meta.width === 'number' ? meta.width : null;
+            const height = typeof meta.height === 'number' ? meta.height : null;
+            return { manifestPatch: { width, height } };
+        }
+        catch {
+            // sharp couldn't decode — return null dims so downstream code
+            // doesn't break. This isn't a hard error: a bad image will fail
+            // variant generation later with a more specific message.
+            return { manifestPatch: { width: null, height: null } };
+        }
+    },
+};
+/**
+ * Animated-image analyzer — `pages > 1` detection, frame count,
+ * duration sum, and first-frame poster extraction.
+ *
+ * Per design-media.md: animated images render as `<img>` in v1
+ * (no `<video>` transcoding — that requires ffmpeg). The poster
+ * is provided so future UI layers (lazy-load, video-style poster
+ * fallback) can use it; v1 templates can also render the poster
+ * for reduced-motion preferences.
+ */
+export const animatedImageAnalyzer = {
+    name: 'animated-image',
+    matches(mime) {
+        return !!mime && ANIMATED_MIMES.has(mime);
+    },
+    async analyze(input) {
+        let pages;
+        let delays;
+        try {
+            const meta = await sharp(input.bytes).metadata();
+            pages = typeof meta.pages === 'number' ? meta.pages : undefined;
+            // sharp returns delay as `number[]` per frame in milliseconds when
+            // animated (some encoders use 0 for "use default" — tolerate).
+            delays = Array.isArray(meta.delay) ? meta.delay : undefined;
+        }
+        catch {
+            // sharp couldn't decode — bail out. Static-image analyzer will
+            // also fail and we'll fall through with no manifest patch.
+            return {};
+        }
+        // Static (single-frame) — nothing to contribute. The static
+        // analyzer already sets width/height; this analyzer skips when
+        // there's no animation to describe.
+        if (!pages || pages <= 1)
+            return {};
+        // Animated. Compute total duration (sum of frame delays).
+        const duration = delays ? delays.reduce((sum, d) => sum + d, 0) : null;
+        const frames = pages;
+        // Extract first frame as a PNG poster. PNG keeps alpha lossless;
+        // for solid-frame GIFs the size penalty over JPEG is worth the
+        // simplicity (no quality knob to tune at this layer).
+        let posterBytes;
+        try {
+            const buf = await sharp(input.bytes, { page: 0 }).png().toBuffer();
+            posterBytes = new Uint8Array(buf);
+        }
+        catch {
+            // Poster extraction failed — return manifest fields without
+            // poster. Better partial enrichment than zero enrichment.
+            return {
+                manifestPatch: { animated: true, frames, duration, poster: null },
+            };
+        }
+        // Path is content-addressed alongside the source asset:
+        // {name}-{hash}-poster.png. Same-pattern as the variant ladder so
+        // delete/rename/path-enumeration logic finds them via filename
+        // glob without special-casing.
+        const posterPath = `${input.assetName}-${input.hash}-poster.png`;
+        return {
+            manifestPatch: {
+                animated: true,
+                frames,
+                duration,
+                poster: posterPath,
+            },
+            supplementaryFiles: [{ path: posterPath, bytes: posterBytes }],
+        };
+    },
+};
+//# sourceMappingURL=analyze-image.js.map

package/dist/assets/analyze-image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-image.js","sourceRoot":"","sources":["../../src/assets/analyze-image.ts"],"names":[],"mappings":"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"}

package/dist/assets/analyze.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Manifest fields an analyzer is allowed to set. Subset of
+ * `AssetManifest` — analyzers can't change identity (`name`, `kind`,
+ * `source`, `mime`, `hash`, `size`) or audit (`uploadedAt`,
+ * `uploadedBy`). They contribute *characterization* fields:
+ * dimensions, animation flags, duration, poster URL, focal point if
+ * extractable from EXIF, etc.
+ *
+ * Listed explicitly (rather than `Partial<AssetManifest>`) so the
+ * type system catches an analyzer that tries to override identity
+ * fields by accident.
+ */
+export interface ManifestEnrichment {
+    /** Width in pixels — null for non-image formats. */
+    width?: number | null;
+    /** Height in pixels — null for non-image formats. */
+    height?: number | null;
+    /** Multi-frame indicator (GIF, APNG, animated WebP/AVIF). */
+    animated?: boolean;
+    /** Frame count for animated content (≥ 1). */
+    frames?: number;
+    /** Duration in milliseconds — animated images, video, audio. */
+    duration?: number | null;
+    /** Relative path to the poster bytes (under assetsRoot). */
+    poster?: string | null;
+}
+/**
+ * A supplementary file the analyzer wants written alongside the
+ * primary asset bytes (and in the manifest's enrichment, where
+ * relevant via `poster`/etc. paths). The runner adds these to the
+ * write plan so they participate in atomic-rollback.
+ */
+export interface SupplementaryFile {
+    /** Path relative to `assetsRoot` — e.g. `hero-{hash}-poster.png`. */
+    path: string;
+    /** Bytes to write. */
+    bytes: Uint8Array;
+}
+export interface AnalysisResult {
+    /**
+     * Fields to merge into the manifest. The runner validates that no
+     * forbidden field is set; analyzers that try to set identity
+     * fields are rejected at the type level (the interface excludes
+     * them).
+     */
+    manifestPatch?: ManifestEnrichment;
+    /** Supplementary byte files to write. */
+    supplementaryFiles?: readonly SupplementaryFile[];
+}
+/**
+ * One format's analysis contract. Implementations are async (sharp
+ * I/O is async) but otherwise pure — no storage access, no manifest
+ * writing, no logging. The runner orchestrates side effects.
+ *
+ * `assetName` and `hash` are passed in so analyzers that produce
+ * supplementary files can name them deterministically (e.g.
+ * `{name}-{hash}-poster.png`).
+ */
+export interface UploadAnalyzer {
+    /** Stable identifier for diagnostics (`'animated-image'`, `'audio'`). */
+    readonly name: string;
+    /** Whether this analyzer applies to the given MIME. */
+    matches(mime: string | null): boolean;
+    /**
+     * Read the bytes; return manifest enrichment + supplementary files.
+     * Throw on malformed input — runner wraps in a typed error.
+     */
+    analyze(input: AnalyzerInput): Promise<AnalysisResult>;
+}
+export interface AnalyzerInput {
+    /** Final, post-preprocess bytes. */
+    bytes: Uint8Array;
+    /** Asset name (canonical, no extension). For supplementary file paths. */
+    assetName: string;
+    /** Asset hash. For supplementary file paths. */
+    hash: string;
+    /** Source extension (`jpg`, `png`, `gif`, ...). For format-specific decisions. */
+    ext: string;
+    /** Sniffed MIME — analyzers don't need to re-sniff. */
+    mime: string;
+}
+export declare const defaultAnalyzers: readonly UploadAnalyzer[];
+/**
+ * Run the matching analyzer(s) for the given MIME. Returns the
+ * merged enrichment + flattened supplementary files. Pass-through
+ * (no enrichment, no extras) when no analyzer matches.
+ *
+ * Multiple analyzers matching the same MIME is allowed — results
+ * are merged (later wins on field conflicts; supplementary files
+ * concatenate). v1 exercises this for animated images: both static
+ * and animated analyzers run.
+ */
+export declare function runAnalyzers(input: AnalyzerInput, analyzers?: readonly UploadAnalyzer[]): Promise<AnalysisResult>;
+//# sourceMappingURL=analyze.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/assets/analyze.ts"],"names":[],"mappings":"AA0CA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAA;IACZ,sBAAsB;IACtB,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,kBAAkB,CAAA;IAClC,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAClD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,uDAAuD;IACvD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;IACrC;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CACvD;AAED,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,KAAK,EAAE,UAAU,CAAA;IACjB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;IACjB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAA;IACX,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAA;CACb;AAiBD,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAAgE,CAAA;AAEtH;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,aAAa,EACpB,SAAS,GAAE,SAAS,cAAc,EAAqB,GACtD,OAAO,CAAC,cAAc,CAAC,CAmBzB"}

package/dist/assets/analyze.js

@@ -0,0 +1,45 @@
+/**
+ * Default analyzer registry — what ingest uses out of the box.
+ * Order matters when more than one matches; analyzer results
+ * later in the list win on field conflicts. Today's order:
+ *   1. `staticImageAnalyzer` — width/height for all images except SVG
+ *   2. `animatedImageAnalyzer` — multi-frame detection + poster
+ *   3. `audioAnalyzer` — duration via music-metadata
+ *
+ * Both image analyzers run for animated images (static contributes
+ * canvas dimensions, animated contributes animation flags + poster).
+ * Audio MIMEs trigger only the audio analyzer.
+ */
+import { animatedImageAnalyzer, staticImageAnalyzer } from './analyze-image.js';
+import { audioAnalyzer } from './analyze-audio.js';
+export const defaultAnalyzers = [staticImageAnalyzer, animatedImageAnalyzer, audioAnalyzer];
+/**
+ * Run the matching analyzer(s) for the given MIME. Returns the
+ * merged enrichment + flattened supplementary files. Pass-through
+ * (no enrichment, no extras) when no analyzer matches.
+ *
+ * Multiple analyzers matching the same MIME is allowed — results
+ * are merged (later wins on field conflicts; supplementary files
+ * concatenate). v1 exercises this for animated images: both static
+ * and animated analyzers run.
+ */
+export async function runAnalyzers(input, analyzers = defaultAnalyzers) {
+    let manifestPatch;
+    const supplementaryFiles = [];
+    for (const analyzer of analyzers) {
+        if (!analyzer.matches(input.mime))
+            continue;
+        const result = await analyzer.analyze(input);
+        if (result.manifestPatch) {
+            manifestPatch = { ...manifestPatch, ...result.manifestPatch };
+        }
+        if (result.supplementaryFiles) {
+            supplementaryFiles.push(...result.supplementaryFiles);
+        }
+    }
+    return {
+        manifestPatch,
+        supplementaryFiles: supplementaryFiles.length > 0 ? supplementaryFiles : undefined,
+    };
+}
+//# sourceMappingURL=analyze.js.map

package/dist/assets/analyze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.js","sourceRoot":"","sources":["../../src/assets/analyze.ts"],"names":[],"mappings":"AAgIA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAElD,MAAM,CAAC,MAAM,gBAAgB,GAA8B,CAAC,mBAAmB,EAAE,qBAAqB,EAAE,aAAa,CAAC,CAAA;AAEtH;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,KAAoB,EACpB,YAAuC,gBAAgB;IAEvD,IAAI,aAA6C,CAAA;IACjD,MAAM,kBAAkB,GAAwB,EAAE,CAAA;IAElD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;YAAE,SAAQ;QAC3C,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC5C,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;YACzB,aAAa,GAAG,EAAE,GAAG,aAAa,EAAE,GAAG,MAAM,CAAC,aAAa,EAAE,CAAA;QAC/D,CAAC;QACD,IAAI,MAAM,CAAC,kBAAkB,EAAE,CAAC;YAC9B,kBAAkB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAA;QACvD,CAAC;IACH,CAAC;IAED,OAAO;QACL,aAAa;QACb,kBAAkB,EAAE,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS;KACnF,CAAA;AACH,CAAC"}