gazetta 0.6.0 → 0.8.0

package/dist/runtime/capability-gap-warnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-gap-warnings.d.ts","sourceRoot":"","sources":["../../src/runtime/capability-gap-warnings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,aAAa,CAAA;AAG7D;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAenE"}

package/dist/runtime/capability-gap-warnings.js

@@ -0,0 +1,28 @@
+import { inspectTarget } from './runtime-capabilities.js';
+/**
+ * Walk the site's targets at boot; emit a warning per target that
+ * has any capability gap. Logs are operator-facing — once
+ * `design-logging.md`'s structured logger ships, replace `console.warn`
+ * with `log.warn({ module: 'admin-api.capability-gap', ... })`.
+ *
+ * Idempotent: calling twice produces the same warnings. The caller
+ * (admin-api boot path) calls once.
+ *
+ * @returns the count of targets with gaps — useful for tests.
+ */
+export function warnOnCapabilityGaps(manifest) {
+    const targets = (manifest.targets ?? {});
+    let count = 0;
+    for (const [name, target] of Object.entries(targets)) {
+        const inspection = inspectTarget(target);
+        if (inspection.gaps.length === 0)
+            continue;
+        count++;
+        const reasons = inspection.gaps.map(g => `${g.capability}: ${g.reason}`).join('; ');
+        console.warn(`  Warning: target "${name}" has runtime capability gaps. ${reasons}. ` +
+            'Archive operations on this target may not emit 301/410 redirects. ' +
+            'See https://gazetta.studio/docs/runtime-capabilities for resolution paths.');
+    }
+    return count;
+}
+//# sourceMappingURL=capability-gap-warnings.js.map

package/dist/runtime/capability-gap-warnings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-gap-warnings.js","sourceRoot":"","sources":["../../src/runtime/capability-gap-warnings.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAEzD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAsB;IACzD,MAAM,OAAO,GAAG,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAiC,CAAA;IACxE,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrD,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CAAA;QACxC,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,SAAQ;QAC1C,KAAK,EAAE,CAAA;QACP,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACnF,OAAO,CAAC,IAAI,CACV,sBAAsB,IAAI,kCAAkC,OAAO,IAAI;YACrE,oEAAoE;YACpE,4EAA4E,CAC/E,CAAA;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/runtime/redirects-emit.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Host-format redirect manifest emit per design-soft-delete.md Q10.
+ *
+ * Plain-static targets (no worker) can't read the per-page HTML
+ * marker. They get a `_redirects` (or equivalent) file at the target
+ * root that the host runtime reads. Cloudflare Pages and Netlify
+ * both honor this convention; their syntax is identical for the
+ * patterns we emit.
+ *
+ * Worker-served target types DON'T need this — the worker reads the
+ * HTML marker directly per request.
+ *
+ * Pure functions: takes the archive summary list, returns the file
+ * content as a string. Caller (publish.ts) writes to storage.
+ *
+ * SRP: this module owns the wire format. Walking the source for
+ * archived pages is the caller's job. Adding a new host format
+ * (e.g., a future Vercel-specific dialect) extends the file with a
+ * new emit function and the type union — existing emitters
+ * untouched.
+ */
+import type { RedirectsFormat } from '../types.js';
+/**
+ * Summary of one archived page contributing to the redirects file.
+ *
+ * `from`: source route (e.g. `/landing`). Includes leading slash;
+ * empty path is the homepage `/`.
+ * `to`: alias target route — only present when the archive has
+ * `aliasOf` set. When absent, this entry is a 410 Gone.
+ */
+export interface ArchiveSummary {
+    from: string;
+    to?: string;
+}
+/**
+ * Emit the `_redirects` file body. Cloudflare and Netlify share the
+ * same syntax for the patterns we emit:
+ *
+ *   /from  /to  301        — permanent alias redirect
+ *   /from  /    410        — soft-delete (gone)
+ *
+ * Cloudflare and Netlify both default to 301 when status is omitted,
+ * but we emit it explicitly for forensic clarity. The `410` row uses
+ * `/` as the destination because both hosts require a destination
+ * column even for status-only rules; both will apply the status
+ * regardless of where the destination points.
+ *
+ * Sorted by `from` so the output is deterministic across publishes.
+ * Determinism matters because the file is content-addressed
+ * downstream (host's CDN may cache it; same input = same output =
+ * cache hit on republish without changes).
+ */
+export declare function emitCloudflareRedirects(archives: ReadonlyArray<ArchiveSummary>): string;
+/**
+ * Netlify uses the same `_redirects` grammar as Cloudflare for the
+ * patterns we emit. Kept as a separate function so that future
+ * Netlify-specific extensions (e.g., country-aware redirects via
+ * `Country` headers) land here without forking Cloudflare.
+ */
+export declare function emitNetlifyRedirects(archives: ReadonlyArray<ArchiveSummary>): string;
+/**
+ * Structured JSON for custom host integrations. Operators with
+ * non-Cloudflare/Netlify hosting wire their own glue (Caddy
+ * `redir` directives, nginx rules, AWS CloudFront functions,
+ * etc.) and consume this file at deploy time.
+ *
+ * Shape:
+ *   {
+ *     redirects: [{ from, to, status: 301 }, ...],
+ *     gone:      [{ path, status: 410 }, ...]
+ *   }
+ *
+ * Same sort order as Cloudflare/Netlify emit (alphabetical by
+ * source path) so output is deterministic.
+ */
+export declare function emitJsonRedirects(archives: ReadonlyArray<ArchiveSummary>): string;
+/**
+ * The destination filename per format. Cloudflare and Netlify both
+ * use `_redirects` at the site root; the JSON form lives at
+ * `redirects.json`.
+ */
+export declare function redirectsFilename(format: Exclude<RedirectsFormat, 'none'>): string;
+/**
+ * Emit the file body for the given format. Returns null when the
+ * format is `'none'` — callers skip writing entirely. Returns empty
+ * string when there are no archives — caller decides whether to
+ * write an empty file or skip.
+ */
+export declare function emitRedirects(format: RedirectsFormat, archives: ReadonlyArray<ArchiveSummary>): {
+    filename: string;
+    body: string;
+} | null;
+//# sourceMappingURL=redirects-emit.d.ts.map

package/dist/runtime/redirects-emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirects-emit.d.ts","sourceRoot":"","sources":["../../src/runtime/redirects-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,MAAM,CAKvF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,MAAM,CAEpF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,MAAM,CAKjF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,MAAM,CAQlF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,GACtC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAW3C"}

package/dist/runtime/redirects-emit.js

@@ -0,0 +1,89 @@
+/**
+ * Emit the `_redirects` file body. Cloudflare and Netlify share the
+ * same syntax for the patterns we emit:
+ *
+ *   /from  /to  301        — permanent alias redirect
+ *   /from  /    410        — soft-delete (gone)
+ *
+ * Cloudflare and Netlify both default to 301 when status is omitted,
+ * but we emit it explicitly for forensic clarity. The `410` row uses
+ * `/` as the destination because both hosts require a destination
+ * column even for status-only rules; both will apply the status
+ * regardless of where the destination points.
+ *
+ * Sorted by `from` so the output is deterministic across publishes.
+ * Determinism matters because the file is content-addressed
+ * downstream (host's CDN may cache it; same input = same output =
+ * cache hit on republish without changes).
+ */
+export function emitCloudflareRedirects(archives) {
+    if (archives.length === 0)
+        return '';
+    const sorted = [...archives].sort((a, b) => a.from.localeCompare(b.from));
+    const lines = sorted.map(a => (a.to ? `${a.from}  ${a.to}  301` : `${a.from}  /  410`));
+    return lines.join('\n') + '\n';
+}
+/**
+ * Netlify uses the same `_redirects` grammar as Cloudflare for the
+ * patterns we emit. Kept as a separate function so that future
+ * Netlify-specific extensions (e.g., country-aware redirects via
+ * `Country` headers) land here without forking Cloudflare.
+ */
+export function emitNetlifyRedirects(archives) {
+    return emitCloudflareRedirects(archives);
+}
+/**
+ * Structured JSON for custom host integrations. Operators with
+ * non-Cloudflare/Netlify hosting wire their own glue (Caddy
+ * `redir` directives, nginx rules, AWS CloudFront functions,
+ * etc.) and consume this file at deploy time.
+ *
+ * Shape:
+ *   {
+ *     redirects: [{ from, to, status: 301 }, ...],
+ *     gone:      [{ path, status: 410 }, ...]
+ *   }
+ *
+ * Same sort order as Cloudflare/Netlify emit (alphabetical by
+ * source path) so output is deterministic.
+ */
+export function emitJsonRedirects(archives) {
+    const sorted = [...archives].sort((a, b) => a.from.localeCompare(b.from));
+    const redirects = sorted.filter(a => a.to !== undefined).map(a => ({ from: a.from, to: a.to, status: 301 }));
+    const gone = sorted.filter(a => a.to === undefined).map(a => ({ path: a.from, status: 410 }));
+    return JSON.stringify({ redirects, gone }, null, 2) + '\n';
+}
+/**
+ * The destination filename per format. Cloudflare and Netlify both
+ * use `_redirects` at the site root; the JSON form lives at
+ * `redirects.json`.
+ */
+export function redirectsFilename(format) {
+    switch (format) {
+        case 'cloudflare':
+        case 'netlify':
+            return '_redirects';
+        case 'json':
+            return 'redirects.json';
+    }
+}
+/**
+ * Emit the file body for the given format. Returns null when the
+ * format is `'none'` — callers skip writing entirely. Returns empty
+ * string when there are no archives — caller decides whether to
+ * write an empty file or skip.
+ */
+export function emitRedirects(format, archives) {
+    if (format === 'none')
+        return null;
+    const filename = redirectsFilename(format);
+    switch (format) {
+        case 'cloudflare':
+            return { filename, body: emitCloudflareRedirects(archives) };
+        case 'netlify':
+            return { filename, body: emitNetlifyRedirects(archives) };
+        case 'json':
+            return { filename, body: emitJsonRedirects(archives) };
+    }
+}
+//# sourceMappingURL=redirects-emit.js.map

package/dist/runtime/redirects-emit.js.map

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

package/dist/runtime/runtime-capabilities.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Runtime capability inspection for a configured target.
+ *
+ * Per `feature-design-process.md` non-foundational disciplines
+ * ("Capability-gap UX surfaced at four points") and
+ * `design-soft-delete.md` Q10 capability-gap principle: when a feature
+ * needs a runtime capability that some configured targets can't
+ * provide (archive needing redirects on a worker; future presence
+ * needing a persistent connection; future RBAC content filtering
+ * needing per-request rendering), the gap surfaces at four uniform
+ * places: (1) boot config validate, (2) author-time modal,
+ * (3) validator scanner, (4) pre-publish gate.
+ *
+ * This module is the shared primitive — pure predicates over a
+ * `TargetConfig`. Each of the four surfaces consumes the same answer
+ * so authors and operators see consistent gap reporting regardless
+ * of which surface they're looking at.
+ *
+ * # The capability vocabulary (closed enum)
+ *
+ * Future capabilities (presence, RBAC content filtering, dynamic
+ * fragments) extend the enum. Each new entry pairs with one or more
+ * features that need it; the inspector grows additively without
+ * existing call-sites changing.
+ *
+ * # SOLID
+ *
+ *   - SRP: one file, pure predicates. No I/O, no side effects.
+ *   - OCP: capability enum extends; existing call sites stay unchanged
+ *     (they ask "do you have X?" not "are you platform Y?").
+ *   - DIP: callers depend on the abstract `RuntimeCapability` enum +
+ *     `inspectTarget()` function, not on platform discrimination.
+ */
+import type { TargetConfig } from '../types.js';
+/**
+ * Closed enum of runtime capabilities. Extend for new features that
+ * need capability-gap UX (presence, RBAC content filtering, dynamic
+ * fragments, etc.).
+ */
+export type RuntimeCapability = 
+/** Worker reads HTML markers and emits `301 → aliasOf` for archived items. */
+'redirects'
+/** Worker emits `410 Gone` for archived-no-alias items. */
+ | 'gone-status';
+/** Reason a capability is missing — surfaces in audit + author UI. */
+export interface CapabilityGap {
+    capability: RuntimeCapability;
+    /** Human-readable reason; surfaces in author modals + audit logs. */
+    reason: string;
+}
+export interface TargetCapabilities {
+    /** Capabilities the target supports. */
+    has: ReadonlySet<RuntimeCapability>;
+    /** Per-missing-capability reasons for the four surfaces. */
+    gaps: readonly CapabilityGap[];
+}
+/**
+ * Inspect a target's runtime capabilities. Plain-static targets
+ * (no worker, no `_redirects` host glue) lack `redirects` and
+ * `gone-status`; everything else has both.
+ *
+ * The plain-static heuristic matches the existing P4 validator
+ * (`archive-not-supported-on-target`): `type === 'static'` AND no
+ * `redirects.format` configured (or `'none'`) means the host has
+ * no mechanism to emit 301/410 for archived URLs.
+ *
+ * Worker-served target types (`dynamic` + `static-with-worker`)
+ * support both capabilities natively. Static targets WITH
+ * `redirects.format` ('cloudflare' | 'netlify' | 'json') support
+ * `redirects` via the host's `_redirects` file, but plain-static
+ * with no host config can't emit `Gone` status — the host's
+ * natural 404 is the floor.
+ */
+export declare function inspectTarget(target: TargetConfig): TargetCapabilities;
+/** Convenience predicate — boolean answer to "can this target serve 301 redirects?" */
+export declare function canServeRedirects(target: TargetConfig): boolean;
+/** Convenience predicate — boolean answer to "can this target serve 410 Gone?" */
+export declare function canServeGoneStatus(target: TargetConfig): boolean;
+//# sourceMappingURL=runtime-capabilities.d.ts.map

package/dist/runtime/runtime-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-capabilities.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;GAIG;AACH,MAAM,MAAM,iBAAiB;AAC3B,8EAA8E;AAC5E,WAAW;AACb,2DAA2D;GACzD,aAAa,CAAA;AAEjB,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,iBAAiB,CAAA;IAC7B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,GAAG,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAA;IACnC,4DAA4D;IAC5D,IAAI,EAAE,SAAS,aAAa,EAAE,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB,CAoCtE;AAED,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAE/D;AAED,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAEhE"}

package/dist/runtime/runtime-capabilities.js

@@ -0,0 +1,60 @@
+/**
+ * Inspect a target's runtime capabilities. Plain-static targets
+ * (no worker, no `_redirects` host glue) lack `redirects` and
+ * `gone-status`; everything else has both.
+ *
+ * The plain-static heuristic matches the existing P4 validator
+ * (`archive-not-supported-on-target`): `type === 'static'` AND no
+ * `redirects.format` configured (or `'none'`) means the host has
+ * no mechanism to emit 301/410 for archived URLs.
+ *
+ * Worker-served target types (`dynamic` + `static-with-worker`)
+ * support both capabilities natively. Static targets WITH
+ * `redirects.format` ('cloudflare' | 'netlify' | 'json') support
+ * `redirects` via the host's `_redirects` file, but plain-static
+ * with no host config can't emit `Gone` status — the host's
+ * natural 404 is the floor.
+ */
+export function inspectTarget(target) {
+    const has = new Set();
+    const gaps = [];
+    const redirectsFormat = target.redirects?.format;
+    const isPlainStatic = target.type === 'static' && (redirectsFormat === undefined || redirectsFormat === 'none');
+    // Worker presence detected via:
+    //   - `type: 'dynamic'` (ESI mode runs on a worker), OR
+    //   - a WorkerCapableDeployAdapter (e.g., cloudflareWorkersDeploy)
+    // Pure-static deploy adapters (GitHub Pages, S3 static, etc.) don't
+    // bundle a worker and don't implement workerRuntimeConfig().
+    const hasWorker = target.type === 'dynamic' || (target.deploy !== undefined && 'workerRuntimeConfig' in target.deploy);
+    const hasHostRedirects = redirectsFormat !== undefined && redirectsFormat !== 'none';
+    if (hasWorker || hasHostRedirects) {
+        has.add('redirects');
+    }
+    else {
+        gaps.push({
+            capability: 'redirects',
+            reason: isPlainStatic
+                ? "plain-static target has no worker and no `redirects.format` configured; archived URLs return the host's natural 404 instead of a 301 redirect"
+                : 'target lacks a runtime that can emit 301 redirects',
+        });
+    }
+    if (hasWorker) {
+        has.add('gone-status');
+    }
+    else {
+        gaps.push({
+            capability: 'gone-status',
+            reason: "no worker runtime available to emit `410 Gone` for archived-no-alias items; falls back to the host's natural 404",
+        });
+    }
+    return { has, gaps };
+}
+/** Convenience predicate — boolean answer to "can this target serve 301 redirects?" */
+export function canServeRedirects(target) {
+    return inspectTarget(target).has.has('redirects');
+}
+/** Convenience predicate — boolean answer to "can this target serve 410 Gone?" */
+export function canServeGoneStatus(target) {
+    return inspectTarget(target).has.has('gone-status');
+}
+//# sourceMappingURL=runtime-capabilities.js.map

package/dist/runtime/runtime-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-capabilities.js","sourceRoot":"","sources":["../../src/runtime/runtime-capabilities.ts"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,aAAa,CAAC,MAAoB;IAChD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAqB,CAAA;IACxC,MAAM,IAAI,GAAoB,EAAE,CAAA;IAEhC,MAAM,eAAe,GAAG,MAAM,CAAC,SAAS,EAAE,MAAM,CAAA;IAChD,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,MAAM,CAAC,CAAA;IAC/G,gCAAgC;IAChC,wDAAwD;IACxD,mEAAmE;IACnE,oEAAoE;IACpE,6DAA6D;IAC7D,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,qBAAqB,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IACtH,MAAM,gBAAgB,GAAG,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,MAAM,CAAA;IAEpF,IAAI,SAAS,IAAI,gBAAgB,EAAE,CAAC;QAClC,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;IACtB,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,IAAI,CAAC;YACR,UAAU,EAAE,WAAW;YACvB,MAAM,EAAE,aAAa;gBACnB,CAAC,CAAC,+IAA+I;gBACjJ,CAAC,CAAC,oDAAoD;SACzD,CAAC,CAAA;IACJ,CAAC;IAED,IAAI,SAAS,EAAE,CAAC;QACd,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;IACxB,CAAC;SAAM,CAAC;QACN,IAAI,CAAC,IAAI,CAAC;YACR,UAAU,EAAE,aAAa;YACzB,MAAM,EACJ,kHAAkH;SACrH,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,CAAA;AACtB,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,iBAAiB,CAAC,MAAoB;IACpD,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AACnD,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,kBAAkB,CAAC,MAAoB;IACrD,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;AACrD,CAAC"}

package/dist/save-etag.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Save-concurrency etag — a content hash used by the save endpoints
+ * to detect stale writes. Different from the publish-state hash in
+ * `hash.ts`:
+ *
+ *   `.{8hex}.hash` (publish-state, MD5)
+ *     - Substitutes template + fragment hashes into the manifest
+ *     - Drives sidecars, compare, cache invalidation
+ *     - Server-only: requires `templateHashes` and `fragmentHashes`
+ *       maps that the client doesn't have
+ *
+ *   save etag (this module, SHA-256, 16 hex)
+ *     - Pure manifest content; no template/fragment substitution
+ *     - Drives `If-Match` save concurrency per `design-offline.md` Q3
+ *     - Computable identically by client + server (same canonicalization,
+ *       same Web Crypto API)
+ *
+ * # Why two etags
+ *
+ * Save concurrency asks: "did THIS page's manifest change between
+ * my read and my write?" A template change doesn't dirty individual
+ * pages from the author's perspective — the author edits page X;
+ * if a colleague separately edits the template, that's a render
+ * concern, not a save-conflict concern. Mixing the two would force
+ * 409 STALE on every author after a template edit, which is wrong UX.
+ *
+ * The `.{8hex}.hash` etag legitimately includes template/fragment
+ * dependencies because IT drives publish + cache invalidation, where
+ * the question IS "did anything in the dep tree change."
+ *
+ * Two etags, two semantics, two consumers. Locked per `design-offline.md`
+ * Cut 9 grilling.
+ *
+ * # Why SHA-256 truncated to 16 hex (not MD5 truncated to 8)
+ *
+ * Save etags collide more often than publish hashes — every save is
+ * a new etag candidate; many saves per page over a long offline
+ * session. A collision = silent stale-write (false negative on
+ * conflict). 8 hex MD5 = 4B keyspace; tens of thousands of saves
+ * across thousands of pages would hit the birthday bound. 16 hex
+ * SHA-256 = 18.4 quintillion keyspace; collisions are not a
+ * realistic concern. Cost: 8 extra characters in the ETag header.
+ *
+ * # Client + server parity contract
+ *
+ * Both call `computeSaveEtag(manifest)` and MUST produce identical
+ * output. Canonicalization rules:
+ *
+ *   1. Pick fields: `template`, `content`, `components`, `metadata`,
+ *      `route`. Other fields ignored (sidecars, derived state, etc.).
+ *   2. JSON.stringify with sorted keys via the existing
+ *      `sortedReplacer` (deep recursive object-key sort).
+ *   3. SHA-256 via `globalThis.crypto.subtle.digest('SHA-256', bytes)`
+ *      (Web Crypto; works in Node 18+ and all browsers).
+ *   4. Take first 8 bytes (16 hex characters).
+ */
+/**
+ * Compute the save etag for a page or fragment manifest. Returns 16
+ * lowercase hex characters (first 8 bytes of SHA-256).
+ *
+ * Both client and server call this with the same manifest object;
+ * both produce the same etag. Used for `ETag` response header on
+ * GET and `If-Match` request header on PUT.
+ *
+ * Async because Web Crypto's `digest` is async. Callers in hot paths
+ * (save handlers, contract tests) await once per save.
+ */
+export declare function computeSaveEtag(manifest: Record<string, unknown>): Promise<string>;
+//# sourceMappingURL=save-etag.d.ts.map

package/dist/save-etag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-etag.d.ts","sourceRoot":"","sources":["../src/save-etag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAqCH;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAexF"}

package/dist/save-etag.js

@@ -0,0 +1,118 @@
+/**
+ * Save-concurrency etag — a content hash used by the save endpoints
+ * to detect stale writes. Different from the publish-state hash in
+ * `hash.ts`:
+ *
+ *   `.{8hex}.hash` (publish-state, MD5)
+ *     - Substitutes template + fragment hashes into the manifest
+ *     - Drives sidecars, compare, cache invalidation
+ *     - Server-only: requires `templateHashes` and `fragmentHashes`
+ *       maps that the client doesn't have
+ *
+ *   save etag (this module, SHA-256, 16 hex)
+ *     - Pure manifest content; no template/fragment substitution
+ *     - Drives `If-Match` save concurrency per `design-offline.md` Q3
+ *     - Computable identically by client + server (same canonicalization,
+ *       same Web Crypto API)
+ *
+ * # Why two etags
+ *
+ * Save concurrency asks: "did THIS page's manifest change between
+ * my read and my write?" A template change doesn't dirty individual
+ * pages from the author's perspective — the author edits page X;
+ * if a colleague separately edits the template, that's a render
+ * concern, not a save-conflict concern. Mixing the two would force
+ * 409 STALE on every author after a template edit, which is wrong UX.
+ *
+ * The `.{8hex}.hash` etag legitimately includes template/fragment
+ * dependencies because IT drives publish + cache invalidation, where
+ * the question IS "did anything in the dep tree change."
+ *
+ * Two etags, two semantics, two consumers. Locked per `design-offline.md`
+ * Cut 9 grilling.
+ *
+ * # Why SHA-256 truncated to 16 hex (not MD5 truncated to 8)
+ *
+ * Save etags collide more often than publish hashes — every save is
+ * a new etag candidate; many saves per page over a long offline
+ * session. A collision = silent stale-write (false negative on
+ * conflict). 8 hex MD5 = 4B keyspace; tens of thousands of saves
+ * across thousands of pages would hit the birthday bound. 16 hex
+ * SHA-256 = 18.4 quintillion keyspace; collisions are not a
+ * realistic concern. Cost: 8 extra characters in the ETag header.
+ *
+ * # Client + server parity contract
+ *
+ * Both call `computeSaveEtag(manifest)` and MUST produce identical
+ * output. Canonicalization rules:
+ *
+ *   1. Pick fields: `template`, `content`, `components`, `metadata`,
+ *      `route`. Other fields ignored (sidecars, derived state, etc.).
+ *   2. JSON.stringify with sorted keys via the existing
+ *      `sortedReplacer` (deep recursive object-key sort).
+ *   3. SHA-256 via `globalThis.crypto.subtle.digest('SHA-256', bytes)`
+ *      (Web Crypto; works in Node 18+ and all browsers).
+ *   4. Take first 8 bytes (16 hex characters).
+ */
+/**
+ * Manifest fields that participate in the save etag.
+ *
+ * Archive fields (per `design-soft-delete.md` Q1) are part of the etag
+ * because archive transitions are saves the concurrency model must
+ * detect: if author A archives page X while author B is editing it,
+ * B's next save must 409-STALE rather than silently overwrite A's
+ * archive. Same logic for `aliasOf` flatten cascades and unarchive.
+ */
+const SAVE_ETAG_FIELDS = [
+    'template',
+    'content',
+    'components',
+    'metadata',
+    'route',
+    'archived',
+    'archivedAt',
+    'archivedBy',
+    'aliasOf',
+];
+/** Canonical JSON via sorted-key recursion. Same shape as the
+ *  publish-hash module's sortedReplacer; duplicated here so this
+ *  module is self-contained (see SRP note in the file header). */
+function sortedReplacer(_key, value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const out = {};
+        for (const k of Object.keys(value).sort()) {
+            out[k] = value[k];
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Compute the save etag for a page or fragment manifest. Returns 16
+ * lowercase hex characters (first 8 bytes of SHA-256).
+ *
+ * Both client and server call this with the same manifest object;
+ * both produce the same etag. Used for `ETag` response header on
+ * GET and `If-Match` request header on PUT.
+ *
+ * Async because Web Crypto's `digest` is async. Callers in hot paths
+ * (save handlers, contract tests) await once per save.
+ */
+export async function computeSaveEtag(manifest) {
+    const picked = {};
+    for (const field of SAVE_ETAG_FIELDS) {
+        if (field in manifest)
+            picked[field] = manifest[field];
+    }
+    const json = JSON.stringify(picked, sortedReplacer);
+    const bytes = new TextEncoder().encode(json);
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+    // First 8 bytes = 16 hex characters.
+    const view = new Uint8Array(digest, 0, 8);
+    let out = '';
+    for (let i = 0; i < view.length; i++) {
+        out += view[i].toString(16).padStart(2, '0');
+    }
+    return out;
+}
+//# sourceMappingURL=save-etag.js.map

package/dist/save-etag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-etag.js","sourceRoot":"","sources":["../src/save-etag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH;;;;;;;;GAQG;AACH,MAAM,gBAAgB,GAAG;IACvB,UAAU;IACV,SAAS;IACT,YAAY;IACZ,UAAU;IACV,OAAO;IACP,UAAU;IACV,YAAY;IACZ,YAAY;IACZ,SAAS;CACD,CAAA;AAEV;;kEAEkE;AAClE,SAAS,cAAc,CAAC,IAAY,EAAE,KAAc;IAClD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,MAAM,GAAG,GAA4B,EAAE,CAAA;QACvC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAgC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;YACrE,GAAG,CAAC,CAAC,CAAC,GAAI,KAAiC,CAAC,CAAC,CAAC,CAAA;QAChD,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,QAAiC;IACrE,MAAM,MAAM,GAA4B,EAAE,CAAA;IAC1C,KAAK,MAAM,KAAK,IAAI,gBAAgB,EAAE,CAAC;QACrC,IAAI,KAAK,IAAI,QAAQ;YAAE,MAAM,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACxD,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IACnD,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC5C,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACtE,qCAAqC;IACrC,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACzC,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAA;IAC9C,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/schema/dimensions.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Asset override dimensions — the axes along which an asset's bytes,
+ * variants, and metadata can vary from its default.
+ *
+ * v1 ships two first-class dimensions:
+ *   - `locale` — content-level (e.g. text baked into image varies by language)
+ *   - `theme`  — presentation-level (e.g. logo with light/dark variants)
+ *
+ * Both are peer dimensions in the abstract model. Each asset can opt into
+ * any combination — a logo might have `(en, dark)`, `(fr, dark)`, `(de, dark)`
+ * variants but no light-mode variants because the default works for light.
+ *
+ * # Why a closed dimension set
+ *
+ * A user-defined dimension model (arbitrary axes per site) was rejected
+ * during foundation design. 90% of value is locale + theme; arbitrary
+ * dimensions complicate the picker UI, fallback chain semantics, and
+ * filename composition with no concrete demand. Adding a third dimension
+ * later means extending this union and `DIMENSION_ORDER` — mechanical.
+ *
+ * # Filename composition
+ *
+ * `DIMENSION_ORDER` fixes the order in which dimensions appear in
+ * filenames. `{name}.asset.{locale}.{theme}.json` (locale before theme).
+ * Changing the order would re-key every existing locale-only manifest, so
+ * it's locked: locale always first.
+ *
+ * # Selector semantics
+ *
+ * A `Selector` represents a specific combination of dimension values.
+ * `null` selector = "default-default" (no overrides; the canonical asset).
+ * Empty `Selector` Map is structurally invalid — callers must use `null`
+ * to express "no dimensions selected." Validators enforce.
+ */
+/** The set of override dimensions an asset can vary along. */
+export type DimensionName = 'locale' | 'theme';
+/**
+ * Order in which dimensions appear in composed filenames. Locked: locale
+ * before theme. Adding a new dimension extends this constant; existing
+ * filenames stay valid because they have no value for the new dimension.
+ */
+export declare const DIMENSION_ORDER: readonly DimensionName[];
+/**
+ * A specific combination of dimension values that addresses one asset
+ * variant (or the default, when null).
+ *
+ * Examples:
+ *   `null` — the default asset
+ *   `Map { 'locale' → 'fr' }` — French (default theme)
+ *   `Map { 'locale' → 'fr', 'theme' → 'dark' }` — French + dark
+ *   `Map { 'theme' → 'dark' }` — dark (default locale)
+ */
+export type Selector = ReadonlyMap<DimensionName, string>;
+/** True when `selector` has at least one dimension set. */
+export declare function isNonEmptySelector(selector: Selector | null): selector is Selector;
+/**
+ * Build a Selector from individual dimension values, omitting unset ones.
+ * Returns `null` when all dimensions are absent — semantically equivalent
+ * to "the default asset."
+ */
+export declare function buildSelector(values: Partial<Record<DimensionName, string>>): Selector | null;
+/**
+ * Compose the path-suffix portion of a filename for a selector. Walks
+ * `DIMENSION_ORDER` so the order is deterministic regardless of insertion
+ * order in the underlying Map.
+ *
+ *   null                           → ''           (no suffix)
+ *   { locale: 'fr' }               → '.fr'
+ *   { theme: 'dark' }              → '.dark'
+ *   { locale: 'fr', theme: 'dark'} → '.fr.dark'
+ */
+export declare function selectorSuffix(selector: Selector | null): string;
+/**
+ * Two selectors are equivalent when they have the same dimensions set
+ * to the same values, ignoring iteration order.
+ */
+export declare function selectorsEqual(a: Selector | null, b: Selector | null): boolean;
+//# sourceMappingURL=dimensions.d.ts.map

package/dist/schema/dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../src/schema/dimensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAAwB,CAAA;AAE5E;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,aAAa,EAAE,MAAM,CAAC,CAAA;AAEzD,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,IAAI,QAAQ,CAElF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,GAAG,QAAQ,GAAG,IAAI,CAO7F;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAQhE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAQ9E"}