@glw907/cairn-cms 0.60.1 → 0.62.1

package/dist/media/naming.js

@@ -5,12 +5,16 @@
 // trips through the media: token unchanged.
 // slugifyFilename output always satisfies parseMediaToken's grammar (lowercase alphanumerics joined
 // by single internal hyphens, no leading or trailing hyphen), or is the literal `file`.
-/** Combining marks (Unicode block U+0300 to U+036F), left over after an NFD decompose, stripped to
+/**
+ * Combining marks (Unicode block U+0300 to U+036F), left over after an NFD decompose, stripped to
  *  fold an accented letter down to its ASCII base. Written as escapes because the literal marks are
- *  invisible in source. */
+ *  invisible in source.
+ */
 const COMBINING_MARKS = /[\u0300-\u036f]/g;
-/** Windows reserved device names. A bare match (case-insensitive) cannot survive as the slug, since
- *  it names a device rather than a file on that platform. */
+/**
+ * Windows reserved device names. A bare match (case-insensitive) cannot survive as the slug, since
+ *  it names a device rather than a file on that platform.
+ */
 const RESERVED = new Set([
     'con',
     'prn',
@@ -37,8 +41,10 @@ const RESERVED = new Set([
 ]);
 /** The maximum slug length, applied before the reserved-name and empty fallbacks. */
 const MAX_SLUG = 80;
-/** A 16-character lowercase hex content-hash prefix, the bare-hash reference form. A slug that
- *  matches this shape would collide with `media:<hash>`, so slugifyFilename screens it. */
+/**
+ * A 16-character lowercase hex content-hash prefix, the bare-hash reference form. A slug that
+ *  matches this shape would collide with `media:<hash>`, so slugifyFilename screens it.
+ */
 const HASH_RE = /^[0-9a-f]{16}$/;
 /** A short alphanumeric extension (no dot), the only shape r2Key accepts, for example `webp`. */
 const R2_EXT_RE = /^[a-z0-9]{1,5}$/;
@@ -59,10 +65,12 @@ export async function hashBytes(bytes) {
 export function shortHash(full) {
     return full.slice(0, 16);
 }
-/** The strict ingest transform from a raw filename to a slug that satisfies the media: slug grammar,
+/**
+ * The strict ingest transform from a raw filename to a slug that satisfies the media: slug grammar,
  *  or the literal `file`. Drops the extension, lowercases, transliterates accents, collapses non-alphanumeric runs
  *  to a single hyphen, trims, caps at 80 chars, screens Windows reserved names, and falls back to
- *  `file` when nothing usable is left. */
+ *  `file` when nothing usable is left.
+ */
 export function slugifyFilename(name) {
     const dot = name.lastIndexOf('.');
     const stem = dot === -1 ? name : name.slice(0, dot);
@@ -86,9 +94,11 @@ export function slugifyFilename(name) {
         return `${slug}-img`;
     return slug;
 }
-/** The content-addressed R2 object key `media/<aa>/<shortHash>.<ext>`, fanned out on the first two
+/**
+ * The content-addressed R2 object key `media/<aa>/<shortHash>.<ext>`, fanned out on the first two
  *  hex chars of the short hash. No leading slash: this is an object key, not a URL. `ext` is bare
- *  (no dot), for example `webp`. */
+ *  (no dot), for example `webp`.
+ */
 export function r2Key(shortHash, ext) {
     if (!HASH_RE.test(shortHash)) {
         throw new Error(`r2Key: hash must be 16 lowercase hex chars, got "${shortHash}"`);
@@ -98,10 +108,12 @@ export function r2Key(shortHash, ext) {
     }
     return `media/${shortHash.slice(0, 2)}/${shortHash}.${ext}`;
 }
-/** The public delivery URL path, with a leading slash, under the delivery base (`publicBase`,
+/**
+ * The public delivery URL path, with a leading slash, under the delivery base (`publicBase`,
  *  default `/media`). The `slug` form is human-readable (`<base>/<slug>.<shortHash>.<ext>`, or
  *  `<base>/<shortHash>.<ext>` when the slug is null); the `opaque` form mirrors the R2 fan-out
- *  (`<base>/<aa>/<shortHash>.<ext>`) and ignores the slug. */
+ *  (`<base>/<aa>/<shortHash>.<ext>`) and ignores the slug.
+ */
 export function publicPath(slug, shortHash, ext, urlForm, publicBase = '/media') {
     if (urlForm === 'opaque') {
         return `${publicBase}/${shortHash.slice(0, 2)}/${shortHash}.${ext}`;

package/dist/media/orphan-scan.d.ts

@@ -8,8 +8,10 @@ export interface OrphanByteRow {
     /** The 16-hex content hash parsed from the key. */
     hash: string;
 }
-/** A broken reference: a manifest row whose bytes are gone. Read-only, since purging it would drop a
- *  still-referenced asset's record; the screen shows where it is used so an operator can re-ingest. */
+/**
+ * A broken reference: a manifest row whose bytes are gone. Read-only, since purging it would drop a
+ *  still-referenced asset's record; the screen shows where it is used so an operator can re-ingest.
+ */
 export interface BrokenRefRow {
     /** The 16-hex content hash of the manifest row whose bytes are missing. */
     hash: string;

package/dist/media/reconcile.d.ts

@@ -1,18 +1,24 @@
 import type { MediaManifest } from './manifest.js';
-/** A stored media object key parses to its short hash via `media/<aa>/<shortHash>.<ext>`. Exported so
- *  the orphan-scan projection derives the same hash from an orphaned key without a second grammar. */
+/**
+ * A stored media object key parses to its short hash via `media/<aa>/<shortHash>.<ext>`. Exported so
+ *  the orphan-scan projection derives the same hash from an orphaned key without a second grammar.
+ */
 export declare const MEDIA_KEY_RE: RegExp;
-/** What a reconcile read found in either direction. `orphanedObjects` are stored R2 keys whose hash
- *  has no manifest row; `missingObjects` are manifest hashes with no stored object. */
+/**
+ * What a reconcile read found in either direction. `orphanedObjects` are stored R2 keys whose hash
+ *  has no manifest row; `missingObjects` are manifest hashes with no stored object.
+ */
 export interface ReconcileResult {
     /** Stored keys (full R2 keys) whose content hash is absent from the manifest. */
     orphanedObjects: string[];
     /** Manifest content-hash keys with no matching stored object. */
     missingObjects: string[];
 }
-/** The pure core: compare the stored R2 keys against the manifest's content-hash keys and report
+/**
+ * The pure core: compare the stored R2 keys against the manifest's content-hash keys and report
  *  both orphan directions. A stored key that does not match the media-key grammar is ignored, since
- *  it is not a content-addressed media object this reconcile owns. */
+ *  it is not a content-addressed media object this reconcile owns.
+ */
 export declare function reconcileMedia(storedKeys: string[], manifest: MediaManifest): ReconcileResult;
 /** One page of an R2 list, the narrow subset the reconcile read consumes. */
 interface ReconcileListPage {
@@ -22,18 +28,22 @@ interface ReconcileListPage {
     truncated: boolean;
     cursor?: string;
 }
-/** The R2 bucket surface the reconcile read needs: a single prefixed, paginated list. A local
- *  structural interface so no @cloudflare/workers-types name is imported (the module is internal and
- *  on no public subpath, but the narrow seam keeps the build self-contained either way). */
+/**
+ * The R2 bucket surface the reconcile read needs: a single prefixed, paginated list. A local
+ *  structural interface so no `@cloudflare/workers-types` name is imported (the module is internal and
+ *  on no public subpath, but the narrow seam keeps the build self-contained either way).
+ */
 export interface ReconcileBucket {
     list(opts?: {
         prefix?: string;
         cursor?: string;
     }): Promise<ReconcileListPage>;
 }
-/** The glue runner: list every stored key under the media/ prefix (paginating through R2's
+/**
+ * The glue runner: list every stored key under the media/ prefix (paginating through R2's
  *  cursor/truncated), reconcile against the manifest, log the count summary, and return the result.
  *  The log record carries counts only, never bytes or a key list; the keys are content hashes and so
- *  carry no PII, but the count summary is all an operator needs to size the orphan state. */
+ *  carry no PII, but the count summary is all an operator needs to size the orphan state.
+ */
 export declare function runReconcile(bucket: ReconcileBucket, manifest: MediaManifest): Promise<ReconcileResult>;
 export {};

package/dist/media/reconcile.js

@@ -1,10 +1,14 @@
 import { log } from '../log/index.js';
-/** A stored media object key parses to its short hash via `media/<aa>/<shortHash>.<ext>`. Exported so
- *  the orphan-scan projection derives the same hash from an orphaned key without a second grammar. */
+/**
+ * A stored media object key parses to its short hash via `media/<aa>/<shortHash>.<ext>`. Exported so
+ *  the orphan-scan projection derives the same hash from an orphaned key without a second grammar.
+ */
 export const MEDIA_KEY_RE = /^media\/[0-9a-f]{2}\/([0-9a-f]{16})\.[a-z0-9]{1,5}$/;
-/** The pure core: compare the stored R2 keys against the manifest's content-hash keys and report
+/**
+ * The pure core: compare the stored R2 keys against the manifest's content-hash keys and report
  *  both orphan directions. A stored key that does not match the media-key grammar is ignored, since
- *  it is not a content-addressed media object this reconcile owns. */
+ *  it is not a content-addressed media object this reconcile owns.
+ */
 export function reconcileMedia(storedKeys, manifest) {
     const manifestHashes = new Set(Object.keys(manifest));
     const storedHashes = new Set();
@@ -24,10 +28,12 @@ export function reconcileMedia(storedKeys, manifest) {
     }
     return { orphanedObjects, missingObjects };
 }
-/** The glue runner: list every stored key under the media/ prefix (paginating through R2's
+/**
+ * The glue runner: list every stored key under the media/ prefix (paginating through R2's
  *  cursor/truncated), reconcile against the manifest, log the count summary, and return the result.
  *  The log record carries counts only, never bytes or a key list; the keys are content hashes and so
- *  carry no PII, but the count summary is all an operator needs to size the orphan state. */
+ *  carry no PII, but the count summary is all an operator needs to size the orphan state.
+ */
 export async function runReconcile(bucket, manifest) {
     const storedKeys = [];
     let cursor;

package/dist/media/reference.d.ts

@@ -3,10 +3,14 @@ export interface MediaRef {
     slug: string | null;
     hash: string;
 }
-/** Parse a `media:<slug>.<hash>` href (or the bare `media:<hash>` form), or null for any other
+/**
+ * Parse a `media:<slug>.<hash>` href (or the bare `media:<hash>` form), or null for any other
  *  href or a malformed token. Splits on the last dot, so a slug that illegally contains a dot fails
- *  the slug grammar and returns null. */
+ *  the slug grammar and returns null.
+ */
 export declare function parseMediaToken(href: string): MediaRef | null;
-/** Write the canonical media: token for a ref. The inverse of parseMediaToken, so a parse then
- *  write round trip is stable: `media:<slug>.<hash>` when the slug is present, else `media:<hash>`. */
+/**
+ * Write the canonical media: token for a ref. The inverse of parseMediaToken, so a parse then
+ *  write round trip is stable: `media:<slug>.<hash>` when the slug is present, else `media:<hash>`.
+ */
 export declare function mediaToken(ref: MediaRef): string;

package/dist/media/reference.js

@@ -6,13 +6,17 @@
 // the grammar; it mirrors the cairn: link codec in ../content/links.ts.
 /** A 16-character lowercase hex content-hash prefix. */
 const HASH_RE = /^[0-9a-f]{16}$/;
-/** The slug grammar from the Task 2 slugify transform: lowercase alphanumerics joined by single
+/**
+ * The slug grammar from the Task 2 slugify transform: lowercase alphanumerics joined by single
  *  internal hyphens, with no leading or trailing hyphen and no dot (the dot is the slug/hash
- *  separator). */
+ *  separator).
+ */
 const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-/** Parse a `media:<slug>.<hash>` href (or the bare `media:<hash>` form), or null for any other
+/**
+ * Parse a `media:<slug>.<hash>` href (or the bare `media:<hash>` form), or null for any other
  *  href or a malformed token. Splits on the last dot, so a slug that illegally contains a dot fails
- *  the slug grammar and returns null. */
+ *  the slug grammar and returns null.
+ */
 export function parseMediaToken(href) {
     if (!href.startsWith('media:'))
         return null;
@@ -26,8 +30,10 @@ export function parseMediaToken(href) {
         return null;
     return { slug, hash };
 }
-/** Write the canonical media: token for a ref. The inverse of parseMediaToken, so a parse then
- *  write round trip is stable: `media:<slug>.<hash>` when the slug is present, else `media:<hash>`. */
+/**
+ * Write the canonical media: token for a ref. The inverse of parseMediaToken, so a parse then
+ *  write round trip is stable: `media:<slug>.<hash>` when the slug is present, else `media:<hash>`.
+ */
 export function mediaToken(ref) {
     return ref.slug === null ? `media:${ref.hash}` : `media:${ref.slug}.${ref.hash}`;
 }

package/dist/media/rewrite-plan.d.ts

@@ -1,9 +1,11 @@
 import type { ConceptDescriptor } from '../content/types.js';
 import type { RepoRef } from '../github/types.js';
 import type { Manifest } from '../content/manifest.js';
-/** One main entry the rewrite will touch: its identity, its file path, the transform's per-placement
+/**
+ * One main entry the rewrite will touch: its identity, its file path, the transform's per-placement
  *  diff, and the rewritten markdown a later apply commits. `P` is the transform's placement type
- *  (a RepointPlacement for replace, an AltPlacement for fill-alt). */
+ *  (a RepointPlacement for replace, an AltPlacement for fill-alt).
+ */
 export interface PlannedEntry<P = unknown> {
     /** The concept id, e.g. "posts". */
     concept: string;
@@ -16,9 +18,11 @@ export interface PlannedEntry<P = unknown> {
     /** The entry's markdown after the transform, byte-identical to the source apart from the rewrite. */
     newMarkdown: string;
 }
-/** One open edit branch that also references the asset, with the entries on it. Report-only: an apply
+/**
+ * One open edit branch that also references the asset, with the entries on it. Report-only: an apply
  *  rewrites main, never a branch, so the screen surfaces these as a delta the editor handles by
- *  republishing the draft. */
+ *  republishing the draft.
+ */
 export interface BranchRef {
     /** The cairn/* branch name. */
     branch: string;
@@ -28,8 +32,10 @@ export interface BranchRef {
         id: string;
     }[];
 }
-/** The preview plan: the main entries to rewrite, the report-only branch delta, and the distinct
- *  count of affected main entries (the entries the transform actually changed). */
+/**
+ * The preview plan: the main entries to rewrite, the report-only branch delta, and the distinct
+ *  count of affected main entries (the entries the transform actually changed).
+ */
 export interface RewritePlan<P = unknown> {
     entries: PlannedEntry<P>[];
     branchDelta: BranchRef[];

package/dist/media/sniff.d.ts

@@ -5,8 +5,10 @@
  * advisory. Recognizes JPEG, PNG, GIF, WebP, and the AVIF/HEIC ISO-BMFF brands.
  */
 export declare function sniffMediaType(bytes: Uint8Array): string | null;
-/** The storage extension for a sniffed media type, or null for a type the upload path does not store
- *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned. */
+/**
+ * The storage extension for a sniffed media type, or null for a type the upload path does not store
+ *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned.
+ */
 export declare function extForMediaType(type: string): string | null;
 /**
  * The engine-level upload deny predicate. Returns true (reject) when the upload is markup a site can

package/dist/media/sniff.js

@@ -7,21 +7,29 @@
 // and this byte check sees only the magic. The delivery route's response headers (X-Content-Type-Options:
 // nosniff, Content-Disposition: inline, a restrictive Content-Security-Policy) are the real XSS control
 // for the served bytes; sniffing here is the ingest gate, not the served-bytes defense.
-/** The leading ASCII whitespace bytes skipped before the deny-list's first-byte-is-`<` check:
- *  tab (0x09), newline (0x0A), carriage return (0x0D), and space (0x20). */
+/**
+ * The leading ASCII whitespace bytes skipped before the deny-list's first-byte-is-`<` check:
+ *  tab (0x09), newline (0x0A), carriage return (0x0D), and space (0x20).
+ */
 const WHITESPACE = new Set([0x09, 0x0a, 0x0d, 0x20]);
-/** The single byte `<` (0x3C). A payload whose first non-whitespace byte is `<` is markup (SVG, HTML,
- *  XML) and is denied regardless of its declared type or any site `allowedTypes`. */
+/**
+ * The single byte `<` (0x3C). A payload whose first non-whitespace byte is `<` is markup (SVG, HTML,
+ *  XML) and is denied regardless of its declared type or any site `allowedTypes`.
+ */
 const LT = 0x3c;
-/** Declared content types denied at the engine level, independent of any site `allowedTypes`. SVG and
- *  the markup types carry active content (script, foreignObject), so they never ingest as media. */
+/**
+ * Declared content types denied at the engine level, independent of any site `allowedTypes`. SVG and
+ *  the markup types carry active content (script, foreignObject), so they never ingest as media.
+ */
 const DENIED_TYPES = new Set(['image/svg+xml', 'image/svg', 'text/html', 'application/xml']);
 /** The ISO-BMFF major-brand codes (at bytes 8..11 of an `ftyp` box) that mean an AVIF image. */
 const AVIF_BRANDS = new Set(['avif', 'avis']);
 /** The ISO-BMFF major-brand codes that mean a HEIF/HEIC image. */
 const HEIC_BRANDS = new Set(['heic', 'heix', 'heif', 'hevc', 'hevx', 'mif1', 'msf1']);
-/** True when every byte of `magic` matches `bytes` starting at `offset`. False if `bytes` is too
- *  short to hold the whole magic. */
+/**
+ * True when every byte of `magic` matches `bytes` starting at `offset`. False if `bytes` is too
+ *  short to hold the whole magic.
+ */
 function matches(bytes, offset, magic) {
     if (bytes.length < offset + magic.length)
         return false;
@@ -31,8 +39,10 @@ function matches(bytes, offset, magic) {
     }
     return true;
 }
-/** The four ASCII characters at bytes `offset..offset+3`, or null when the input is too short. Used to
- *  read an ISO-BMFF brand code as a string. */
+/**
+ * The four ASCII characters at bytes `offset..offset+3`, or null when the input is too short. Used to
+ *  read an ISO-BMFF brand code as a string.
+ */
 function ascii4(bytes, offset) {
     if (bytes.length < offset + 4)
         return null;
@@ -71,9 +81,11 @@ export function sniffMediaType(bytes) {
     }
     return null;
 }
-/** The bare file extension (no dot) for each sniffed media type the upload path stores. The ext is
+/**
+ * The bare file extension (no dot) for each sniffed media type the upload path stores. The ext is
  *  derived from the server-sniffed type, never the client filename, so the stored key and the
- *  delivery extension allow-list always agree. An unmappable type returns null (the upload 415s). */
+ *  delivery extension allow-list always agree. An unmappable type returns null (the upload 415s).
+ */
 const EXT_BY_TYPE = {
     'image/jpeg': 'jpg',
     'image/png': 'png',
@@ -81,8 +93,10 @@ const EXT_BY_TYPE = {
     'image/webp': 'webp',
     'image/avif': 'avif',
 };
-/** The storage extension for a sniffed media type, or null for a type the upload path does not store
- *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned. */
+/**
+ * The storage extension for a sniffed media type, or null for a type the upload path does not store
+ *  (HEIC, an unknown type). Driven by the sniffed type, so the key's ext is server-owned.
+ */
 export function extForMediaType(type) {
     return EXT_BY_TYPE[type] ?? null;
 }

package/dist/media/store.d.ts

@@ -1,17 +1,23 @@
 import type { R2Bucket, R2Conditional, R2HTTPMetadata, R2Object, R2ObjectBody, R2Range } from '@cloudflare/workers-types';
-/** The narrow R2 surface the media pipeline uses. The engine depends on this, not on R2Bucket, so the
- *  multipart, list, and conditional-read surface R2 also carries never leaks into the media code. */
+/**
+ * The narrow R2 surface the media pipeline uses. The engine depends on this, not on R2Bucket, so the
+ *  multipart, list, and conditional-read surface R2 also carries never leaks into the media code.
+ */
 export interface MediaStore {
-    /** Store bytes under a content-addressed key, with the response HTTP metadata (the content type)
+    /**
+     * Store bytes under a content-addressed key, with the response HTTP metadata (the content type)
      *  and optional custom metadata (the upload stores the full sha256 here, so a short-hash collision
-     *  is detectable on a later dedup probe). */
+     *  is detectable on a later dedup probe).
+     */
     put(key: string, bytes: ArrayBuffer | Uint8Array, httpMetadata?: R2HTTPMetadata, customMetadata?: Record<string, string>): Promise<void>;
     /** The object's metadata, or null when no object lives at the key (the dedup probe). */
     head(key: string): Promise<R2Object | null>;
-    /** The object body for streaming to a delivery response, or null when the key is absent. The
+    /**
+     * The object body for streaming to a delivery response, or null when the key is absent. The
      *  delivery route passes `onlyIf` and `range` through for conditional and partial reads: an
      *  `onlyIf` etag match returns a body-less R2Object (the 304 shape), so the return widens to
-     *  `R2Object` alongside `R2ObjectBody`. */
+     *  `R2Object` alongside `R2ObjectBody`.
+     */
     get(key: string, opts?: {
         range?: R2Range;
         onlyIf?: R2Conditional;
@@ -19,7 +25,9 @@ export interface MediaStore {
     /** Remove the object at the key. A delete of an absent key is a no-op, the R2 contract. */
     delete(key: string): Promise<void>;
 }
-/** Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
+/**
+ * Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
  *  HTTP and custom metadata into R2's options shape and drops the returned R2Object the pipeline does
- *  not read. */
+ *  not read.
+ */
 export declare function r2Store(bucket: R2Bucket): MediaStore;

package/dist/media/store.js

@@ -1,6 +1,8 @@
-/** Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
+/**
+ * Wrap an R2 bucket binding as a MediaStore. Each method delegates to the binding; put folds the
  *  HTTP and custom metadata into R2's options shape and drops the returned R2Object the pipeline does
- *  not read. */
+ *  not read.
+ */
 export function r2Store(bucket) {
     return {
         async put(key, bytes, httpMetadata, customMetadata) {

package/dist/media/transform-url.d.ts

@@ -1,6 +1,8 @@
-/** A single image variant: the resize and format directives Cloudflare Images applies to the
+/**
+ * A single image variant: the resize and format directives Cloudflare Images applies to the
  *  original bytes. Every field is optional. width, height, quality, and fit are emitted only when
- *  set; format and gravity always appear, defaulting to auto. */
+ *  set; format and gravity always appear, defaulting to auto.
+ */
 export interface VariantSpec {
     /** Target width in pixels. */
     width?: number;
@@ -15,12 +17,16 @@ export interface VariantSpec {
     /** Output format, `auto` to let Cloudflare negotiate, or a forced codec. */
     format?: 'auto' | 'webp' | 'avif' | string;
 }
-/** Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
+/**
+ * Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
  *  comma-joined in the stable order width, height, quality, fit, format, gravity, with width through
  *  fit emitted only when the spec sets them and format and gravity always present (defaulting to
- *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`. */
+ *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`.
+ */
 export declare function variantUrl(publicPath: string, spec: VariantSpec): string;
-/** Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
+/**
+ * Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
  *  variantUrl. Throws a cairn:-prefixed error naming the unknown preset when the name is absent, so a
- *  typo in a preset name fails loudly rather than silently rendering an unsized image. */
+ *  typo in a preset name fails loudly rather than silently rendering an unsized image.
+ */
 export declare function presetUrl(publicPath: string, presetName: string, variants: Record<string, VariantSpec>): string;

package/dist/media/transform-url.js

@@ -4,10 +4,12 @@
 // the option encoding and the stable option order, so the same spec always builds the same URL and
 // a CDN cache keys on it cleanly. The delivery path is appended unaltered, since it already carries
 // its own leading slash.
-/** Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
+/**
+ * Build the on-demand Cloudflare Images transform URL for a delivery path. The options are
  *  comma-joined in the stable order width, height, quality, fit, format, gravity, with width through
  *  fit emitted only when the spec sets them and format and gravity always present (defaulting to
- *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`. */
+ *  auto). The publicPath is appended unaltered, so the result is `/cdn-cgi/image/<options><publicPath>`.
+ */
 export function variantUrl(publicPath, spec) {
     const options = [];
     if (spec.width !== undefined)
@@ -26,9 +28,11 @@ export function variantUrl(publicPath, spec) {
     const source = publicPath.startsWith('/') ? publicPath : `/${publicPath}`;
     return `/cdn-cgi/image/${options.join(',')}${source}`;
 }
-/** Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
+/**
+ * Build a variant URL from a named preset. Looks up presetName in variants and builds its spec with
  *  variantUrl. Throws a cairn:-prefixed error naming the unknown preset when the name is absent, so a
- *  typo in a preset name fails loudly rather than silently rendering an unsized image. */
+ *  typo in a preset name fails loudly rather than silently rendering an unsized image.
+ */
 export function presetUrl(publicPath, presetName, variants) {
     const spec = variants[presetName];
     if (spec === undefined) {

package/dist/media/usage.d.ts

@@ -21,13 +21,17 @@ export interface UsageEntry {
     /** Published vs the cairn/* branch the edit lives on. */
     origin: UsageOrigin;
 }
-/** Content hash to the distinct entries that reference it. A hash with no row is "no references
- *  found" (see the raw-HTML caveat above), never a proven orphan. */
+/**
+ * Content hash to the distinct entries that reference it. A hash with no row is "no references
+ *  found" (see the raw-HTML caveat above), never a proven orphan.
+ */
 export type UsageIndex = Map<string, UsageEntry[]>;
-/** Build options. `branches` lets a caller that already listed the open cairn/* branches pass them
+/**
+ * Build options. `branches` lets a caller that already listed the open cairn/* branches pass them
  *  in so the index does not list them a second time (the load path lists once for the media-union).
  *  `strict` flips the per-branch read from degrade-and-skip to fail-closed: a delete gate must not
- *  treat a transient branch-read failure as an absent reference, so it rethrows instead. */
+ *  treat a transient branch-read failure as an absent reference, so it rethrows instead.
+ */
 export interface BuildUsageOptions {
     /** The open cairn/* branch names, already listed. When present the index skips its own listing. */
     branches?: string[];

package/dist/nav/site-config.d.ts

@@ -34,16 +34,20 @@ export interface SiteConfig {
     menus?: Record<string, unknown>;
     /** Per-concept URL policy: the permalink pattern and date-prefix granularity, keyed by concept id. */
     content?: Record<string, ConceptUrlPolicy>;
-    /** The editor spellcheck settings. The dialect is declared once per site (spec 1.2), so a British
+    /**
+     * The editor spellcheck settings. The dialect is declared once per site (spec 1.2), so a British
      *  site loads the British word list and "colour" reads as correct. Today only US English ships, so an
-     *  unset or unknown dialect resolves to it. */
+     *  unset or unknown dialect resolves to it.
+     */
     spellcheck?: {
         dialect?: string;
     };
-    /** The editor tidy (LLM copy-edit) settings. Opt-in at the site level (spec 2.8): tidy is a remote,
+    /**
+     * The editor tidy (LLM copy-edit) settings. Opt-in at the site level (spec 2.8): tidy is a remote,
      *  costly model call, so the whole block is optional and `enabled` defaults false. The model is a
      *  developer-tier fact; the `conventions` block is the editor-tier per-convention config that builds
-     *  the prompt's CONVENTIONS section. The Anthropic API key is a Worker secret, never config. */
+     *  the prompt's CONVENTIONS section. The Anthropic API key is a Worker secret, never config.
+     */
     tidy?: TidyConfig;
     [key: string]: unknown;
 }
@@ -69,14 +73,18 @@ export declare const DEFAULT_TIDY_MODEL = "claude-sonnet-4-6";
  * Sentence spacing is dropped on purpose and regional spelling is `spellcheck.dialect`, not a toggle.
  */
 export interface TidyConventions {
-    /** The objective Fixes group (spelling, grammar, doubled words, whitespace, capitals, terminal
+    /**
+     * The objective Fixes group (spelling, grammar, doubled words, whitespace, capitals, terminal
      *  punctuation). Default on. The always-on core governs it; this toggle lets the screen turn the
-     *  group off. */
+     *  group off.
+     */
     fixes: boolean;
     /** Oxford comma position. Off when undefined; `always` | `complex-only` (AP) | `never`. */
     oxfordComma?: 'always' | 'complex-only' | 'never';
-    /** Number style threshold. Off when undefined; the always-numeral exception sets (ages, dates,
-     *  measurements, percentages) apply at any threshold. */
+    /**
+     * Number style threshold. Off when undefined; the always-numeral exception sets (ages, dates,
+     *  measurements, percentages) apply at any threshold.
+     */
     numberStyle?: 'under-ten' | 'under-hundred' | 'always-numerals';
     /** Measurement notation only (never the system, never the number). Off when undefined. */
     measurements?: 'abbreviate' | 'spell-out';

package/dist/render/component-grammar.d.ts

@@ -1,21 +1,31 @@
 import type { ComponentDef, ComponentValues } from './registry.js';
+/**
+ *
+ */
 export declare function serializeComponent(def: ComponentDef, values: ComponentValues): string;
-/** Parse a serialized component directive back into guided-form values, the inverse of
+/**
+ * Parse a serialized component directive back into guided-form values, the inverse of
  *  {@link serializeComponent}. The grammar is reversible, so the editor can round-trip a
- *  saved directive through the form. */
+ *  saved directive through the form.
+ */
 export declare function parseComponent(markdown: string, def: ComponentDef): Promise<ComponentValues>;
-/** The raw attribute keys present on the component's opening directive, read from the parsed tree
- *  (quote-aware, unlike a regex over the source). Used by validation to flag unknown keys. */
+/**
+ * The raw attribute keys present on the component's opening directive, read from the parsed tree
+ *  (quote-aware, unlike a regex over the source). Used by validation to flag unknown keys.
+ */
 export declare function parseRawAttributeKeys(markdown: string, def: ComponentDef): string[];
-/** The result of {@link componentRoundTripSafety}: whether re-opening a placed block into the
- *  guided form and re-serializing it is provably lossless. */
+/**
+ * The result of {@link componentRoundTripSafety}: whether re-opening a placed block into the
+ *  guided form and re-serializing it is provably lossless.
+ */
 export type RoundTripSafety = {
     safe: true;
 } | {
     safe: false;
     reason: 'unknown-attribute' | 'undeclared-child' | 'not-idempotent' | 'not-a-component';
 };
-/** Decide whether guided edit of this placed block is provably lossless. A block a person typed by
+/**
+ * Decide whether guided edit of this placed block is provably lossless. A block a person typed by
  *  hand can carry more than the schema models (an attribute the def does not list, a child container
  *  the def does not declare, slot content the form cannot represent stably), and parsing such a block
  *  into the form then re-serializing would silently drop it. The edit affordance is offered only when
@@ -25,11 +35,14 @@ export type RoundTripSafety = {
  *  2. `unknown-attribute`: the block carries an attribute key the def does not declare.
  *  3. `undeclared-child`: the root has a direct child container directive that is not a declared
  *     nested slot. Such a child would otherwise fold into the body slot and move on re-serialize.
- *  4. `not-idempotent`: `parse -> serialize -> parse` does not recover the same values. */
+ *  4. `not-idempotent`: `parse -> serialize -> parse` does not recover the same values.
+ */
 export declare function componentRoundTripSafety(markdown: string, def: ComponentDef): Promise<RoundTripSafety>;
-/** Parse the component once and derive both the guided-form values and the raw attribute keys.
+/**
+ * Parse the component once and derive both the guided-form values and the raw attribute keys.
  *  Validation needs both, so this seam spares it the double parse that calling
- *  {@link parseComponent} and {@link parseRawAttributeKeys} separately would cost. */
+ *  {@link parseComponent} and {@link parseRawAttributeKeys} separately would cost.
+ */
 export declare function parseComponentWithRawKeys(markdown: string, def: ComponentDef): Promise<{
     values: ComponentValues;
     rawKeys: string[];