@glw907/cairn-cms 0.60.0 → 0.62.1

package/dist/media/bulk-delete-plan.d.ts

@@ -1,14 +1,18 @@
 import type { UsageEntry, UsageIndex } from './usage.js';
 import type { MediaManifest } from './manifest.js';
-/** One selected hash that is not deleted, with why and (for the where-used) its usage rows. The rows
- *  are present only for 'still-referenced'; an 'uncommitted' skip carries an empty list. */
+/**
+ * One selected hash that is not deleted, with why and (for the where-used) its usage rows. The rows
+ *  are present only for 'still-referenced'; an 'uncommitted' skip carries an empty list.
+ */
 export interface BulkDeleteSkip {
     hash: string;
     reason: 'still-referenced' | 'uncommitted';
     usage: UsageEntry[];
 }
-/** The partitioned selection: the hashes safe to purge and the hashes held back. Both arrays keep the
- *  input order of `selected` so the screen reports them in the order the user picked. */
+/**
+ * The partitioned selection: the hashes safe to purge and the hashes held back. Both arrays keep the
+ *  input order of `selected` so the screen reports them in the order the user picked.
+ */
 export interface BulkDeletePlan {
     deletable: string[];
     skipped: BulkDeleteSkip[];

package/dist/media/config.d.ts

@@ -1,8 +1,10 @@
 import type { AssetConfig } from '../content/types.js';
 import type { VariantSpec } from './transform-url.js';
-/** The resolved media config the engine serves from. When a site declares no assets block, media is
+/**
+ * The resolved media config the engine serves from. When a site declares no assets block, media is
  *  off and the value is `{ enabled: false }`; otherwise every field is filled from the AssetConfig
- *  or its default. */
+ *  or its default.
+ */
 export type ResolvedAssetConfig = {
     enabled: false;
 } | {
@@ -13,12 +15,16 @@ export type ResolvedAssetConfig = {
     maxUploadBytes: number;
     allowedTypes: string[];
     variants: Record<string, VariantSpec>;
-    /** Whether Cloudflare Image Transformations are enabled for the zone. With it false, the media
-     *  resolver serves the bare full-size delivery path and ignores any preset. */
+    /**
+     * Whether Cloudflare Image Transformations are enabled for the zone. With it false, the media
+     *  resolver serves the bare full-size delivery path and ignores any preset.
+     */
     transformations: boolean;
 };
-/** Validate a site's AssetConfig and resolve it into a ResolvedAssetConfig. An undefined block leaves
+/**
+ * Validate a site's AssetConfig and resolve it into a ResolvedAssetConfig. An undefined block leaves
  *  media off and returns `{ enabled: false }` rather than throwing. A declared block must name its R2
  *  bucket and carry a known urlForm and valid variant fit and gravity values; each failure throws a
- *  cairn:-prefixed error. The named variants merge over the built-in presets. */
+ *  cairn:-prefixed error. The named variants merge over the built-in presets.
+ */
 export declare function normalizeAssets(assets: AssetConfig | undefined): ResolvedAssetConfig;

package/dist/media/config.js

@@ -4,8 +4,10 @@ const DEFAULT_PUBLIC_BASE = '/media';
 const DEFAULT_MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
 /** The default accepted upload MIME types: the common web image formats. */
 const DEFAULT_ALLOWED_TYPES = ['image/jpeg', 'image/png', 'image/webp', 'image/gif', 'image/avif'];
-/** The built-in named transform presets. A site's `variants` merge over these, so a caller preset of
- *  the same name overrides the built-in. */
+/**
+ * The built-in named transform presets. A site's `variants` merge over these, so a caller preset of
+ *  the same name overrides the built-in.
+ */
 const BUILT_IN_PRESETS = {
     thumb: { width: 320, height: 320, fit: 'cover' },
     inline: { width: 800 },
@@ -14,8 +16,10 @@ const BUILT_IN_PRESETS = {
 };
 /** The fit values Cloudflare Images accepts. A variant whose fit is set to anything else is rejected. */
 const FIT_VALUES = new Set(['scale-down', 'contain', 'cover', 'crop', 'pad']);
-/** The named gravity keywords Cloudflare Images accepts. A gravity is also valid as a coordinate
- *  string; everything else is rejected. */
+/**
+ * The named gravity keywords Cloudflare Images accepts. A gravity is also valid as a coordinate
+ *  string; everything else is rejected.
+ */
 const GRAVITY_KEYWORDS = new Set([
     'auto',
     'face',
@@ -27,9 +31,11 @@ const GRAVITY_KEYWORDS = new Set([
 ]);
 /** A gravity coordinate string, e.g. "0.5x0.5". */
 const GRAVITY_COORD_RE = /^\d+(\.\d+)?x\d+(\.\d+)?$/;
-/** Validate one variant's fit and gravity, throwing a cairn:-prefixed error naming the offending
+/**
+ * Validate one variant's fit and gravity, throwing a cairn:-prefixed error naming the offending
  *  preset and value. The type system collapses VariantSpec.gravity to string, so the gravity check
- *  is the only guard against a bogus value reaching the transform URL. */
+ *  is the only guard against a bogus value reaching the transform URL.
+ */
 function validateVariant(name, spec) {
     if (spec.fit !== undefined && !FIT_VALUES.has(spec.fit)) {
         throw new Error(`cairn: media variant "${name}" has an unknown fit "${spec.fit}"`);
@@ -40,10 +46,12 @@ function validateVariant(name, spec) {
         throw new Error(`cairn: media variant "${name}" has an unknown gravity "${spec.gravity}"`);
     }
 }
-/** Validate a site's AssetConfig and resolve it into a ResolvedAssetConfig. An undefined block leaves
+/**
+ * Validate a site's AssetConfig and resolve it into a ResolvedAssetConfig. An undefined block leaves
  *  media off and returns `{ enabled: false }` rather than throwing. A declared block must name its R2
  *  bucket and carry a known urlForm and valid variant fit and gravity values; each failure throws a
- *  cairn:-prefixed error. The named variants merge over the built-in presets. */
+ *  cairn:-prefixed error. The named variants merge over the built-in presets.
+ */
 export function normalizeAssets(assets) {
     if (assets === undefined)
         return { enabled: false };

package/dist/media/delivery-bucket.d.ts

@@ -6,9 +6,11 @@ export interface DeliveryObject {
     httpEtag: string;
     /** The full object size in bytes, the denominator of a `Content-Range`. */
     size: number;
-    /** Present only on a ranged read: the served window, used to build the `Content-Range`. R2 fills
+    /**
+     * Present only on a ranged read: the served window, used to build the `Content-Range`. R2 fills
      *  both fields for a `bytes=start-end` request; each is typed optional so the route derives the
-     *  range bounds defensively against `size`. */
+     *  range bounds defensively against `size`.
+     */
     range?: {
         offset?: number;
         length?: number;

package/dist/media/library-entry.d.ts

@@ -24,7 +24,9 @@ export interface MediaLibraryEntry {
 }
 /** The projected library keyed by the 16-hex content hash, exactly EditData's `mediaLibrary`. */
 export type MediaLibrary = Record<string, MediaLibraryEntry>;
-/** Project a stored MediaEntry to the picker's MediaLibraryEntry, copying every display field and
+/**
+ * Project a stored MediaEntry to the picker's MediaLibraryEntry, copying every display field and
  *  dropping the source-only sha256 and original filename. The single projection editLoad and
- *  mediaLibraryLoad both call, so the popover and the Library never diverge on the shared shape. */
+ *  mediaLibraryLoad both call, so the popover and the Library never diverge on the shared shape.
+ */
 export declare function mediaLibraryEntry(entry: MediaEntry): MediaLibraryEntry;

package/dist/media/library-entry.js

@@ -1,6 +1,8 @@
-/** Project a stored MediaEntry to the picker's MediaLibraryEntry, copying every display field and
+/**
+ * Project a stored MediaEntry to the picker's MediaLibraryEntry, copying every display field and
  *  dropping the source-only sha256 and original filename. The single projection editLoad and
- *  mediaLibraryLoad both call, so the popover and the Library never diverge on the shared shape. */
+ *  mediaLibraryLoad both call, so the popover and the Library never diverge on the shared shape.
+ */
 export function mediaLibraryEntry(entry) {
     return {
         hash: entry.hash,

package/dist/media/manifest.d.ts

@@ -1,7 +1,9 @@
-/** One stored asset's row: its content hash, its human layer, and its byte and pixel facts. The
+/**
+ * One stored asset's row: its content hash, its human layer, and its byte and pixel facts. The
  *  `contentType` is the stored MIME type, so the delivery route serves it verbatim rather than
  *  guessing from the extension. `width` and `height` are null when no dimensions are known (the
- *  client is the only dimension source and a Worker cannot re-derive them). */
+ *  client is the only dimension source and a Worker cannot re-derive them).
+ */
 export interface MediaEntry {
     hash: string;
     sha256: string;
@@ -18,27 +20,39 @@ export interface MediaEntry {
 }
 /** The whole stored-asset record, keyed by the 16-hex content-hash prefix. */
 export type MediaManifest = Record<string, MediaEntry>;
-/** Parse a committed media manifest. Tolerant: an empty, missing, null, or non-object input yields
- *  an empty manifest, so a first ingest into a site with no manifest file reads a clean {}. A valid
- *  object is returned as the manifest. */
+/**
+ * Parse a committed media manifest. Tolerant: an empty, missing, null, or non-object input yields
+ *  an empty manifest, so a first ingest into a site with no manifest file reads a clean `{}`. A valid
+ *  object is returned as the manifest.
+ */
 export declare function parseMediaManifest(json: unknown): MediaManifest;
-/** Parse the posted `media` field into a validated list of MediaEntry rows. The field arrives as a
+/**
+ * Parse the posted `media` field into a validated list of MediaEntry rows. The field arrives as a
  *  JSON string (the usual form-post shape), an already-parsed array, or junk. A string is JSON-parsed
  *  inside a try/catch that yields `[]` on a parse failure; a non-string array is taken directly;
  *  anything else yields `[]`. Each element is validated and a failing element is dropped, so a partly
  *  malformed post still lands its good rows. This is the trust boundary for the client's optimistic
- *  records. */
+ *  records.
+ */
 export declare function parseMediaEntries(value: unknown): MediaEntry[];
-/** The dedup lookup: the entry stored under the content-hash prefix, or undefined when no bytes with
- *  that hash are stored yet. */
+/**
+ * The dedup lookup: the entry stored under the content-hash prefix, or undefined when no bytes with
+ *  that hash are stored yet.
+ */
 export declare function findByHash(manifest: MediaManifest, hash: string): MediaEntry | undefined;
-/** Set the entry under its own hash, replacing any same-hash row. Returns a new manifest and leaves
- *  the input untouched, so a caller's prior manifest reference stays valid. The ingest path's patch. */
+/**
+ * Set the entry under its own hash, replacing any same-hash row. Returns a new manifest and leaves
+ *  the input untouched, so a caller's prior manifest reference stays valid. The ingest path's patch.
+ */
 export declare function upsertMediaEntry(manifest: MediaManifest, entry: MediaEntry): MediaManifest;
-/** Drop the entry under the given hash, returning a new manifest and leaving the input untouched.
+/**
+ * Drop the entry under the given hash, returning a new manifest and leaving the input untouched.
  *  Removing an absent hash is a no-op that still returns an equivalent new manifest. The safe-delete
- *  path's patch. */
+ *  path's patch.
+ */
 export declare function removeMediaEntry(manifest: MediaManifest, hash: string): MediaManifest;
-/** Serialize canonically: the top-level hash keys sorted ascending, two-space pretty, and a trailing
- *  newline, so the committed file diffs cleanly in a PR and a re-serialization is byte-identical. */
+/**
+ * Serialize canonically: the top-level hash keys sorted ascending, two-space pretty, and a trailing
+ *  newline, so the committed file diffs cleanly in a PR and a re-serialization is byte-identical.
+ */
 export declare function serializeMediaManifest(manifest: MediaManifest): string;

package/dist/media/manifest.js

@@ -3,19 +3,22 @@
 // the dedup lookup: an ingest checks the content-hash prefix here before storing, so the same bytes
 // are never stored twice. It mirrors the content manifest in ../content/manifest.ts, keyed by the
 // 16-hex content-hash prefix rather than concept and id.
-/** Parse a committed media manifest. Tolerant: an empty, missing, null, or non-object input yields
- *  an empty manifest, so a first ingest into a site with no manifest file reads a clean {}. A valid
- *  object is returned as the manifest. */
+/**
+ * Parse a committed media manifest. Tolerant: an empty, missing, null, or non-object input yields
+ *  an empty manifest, so a first ingest into a site with no manifest file reads a clean `{}`. A valid
+ *  object is returned as the manifest.
+ */
 export function parseMediaManifest(json) {
     if (!json || typeof json !== 'object' || Array.isArray(json))
         return {};
     return json;
 }
-/** Validate one posted value as a MediaEntry, returning it narrowed or undefined. The trust boundary
+/**
+ * Validate one posted value as a MediaEntry, returning it narrowed or undefined. The trust boundary
  *  for an optimistic record the client re-posts: the upload action server-owned each field at
  *  creation, but a re-post is untrusted, so every field is re-checked. A `hash` must be the 16-hex
- *  content-hash prefix; the string fields must be strings; `bytes` must be finite; `width`/`height`
- *  must each be a number or null; `createdAt` must be a string. */
+ *  content-hash prefix.
+ */
 function validateMediaEntry(value) {
     if (!value || typeof value !== 'object')
         return undefined;
@@ -51,12 +54,14 @@ function validateMediaEntry(value) {
         createdAt: e.createdAt,
     };
 }
-/** Parse the posted `media` field into a validated list of MediaEntry rows. The field arrives as a
+/**
+ * Parse the posted `media` field into a validated list of MediaEntry rows. The field arrives as a
  *  JSON string (the usual form-post shape), an already-parsed array, or junk. A string is JSON-parsed
  *  inside a try/catch that yields `[]` on a parse failure; a non-string array is taken directly;
  *  anything else yields `[]`. Each element is validated and a failing element is dropped, so a partly
  *  malformed post still lands its good rows. This is the trust boundary for the client's optimistic
- *  records. */
+ *  records.
+ */
 export function parseMediaEntries(value) {
     let raw = value;
     if (typeof value === 'string') {
@@ -77,25 +82,33 @@ export function parseMediaEntries(value) {
     }
     return entries;
 }
-/** The dedup lookup: the entry stored under the content-hash prefix, or undefined when no bytes with
- *  that hash are stored yet. */
+/**
+ * The dedup lookup: the entry stored under the content-hash prefix, or undefined when no bytes with
+ *  that hash are stored yet.
+ */
 export function findByHash(manifest, hash) {
     return manifest[hash];
 }
-/** Set the entry under its own hash, replacing any same-hash row. Returns a new manifest and leaves
- *  the input untouched, so a caller's prior manifest reference stays valid. The ingest path's patch. */
+/**
+ * Set the entry under its own hash, replacing any same-hash row. Returns a new manifest and leaves
+ *  the input untouched, so a caller's prior manifest reference stays valid. The ingest path's patch.
+ */
 export function upsertMediaEntry(manifest, entry) {
     return { ...manifest, [entry.hash]: entry };
 }
-/** Drop the entry under the given hash, returning a new manifest and leaving the input untouched.
+/**
+ * Drop the entry under the given hash, returning a new manifest and leaving the input untouched.
  *  Removing an absent hash is a no-op that still returns an equivalent new manifest. The safe-delete
- *  path's patch. */
+ *  path's patch.
+ */
 export function removeMediaEntry(manifest, hash) {
     const { [hash]: _removed, ...rest } = manifest;
     return rest;
 }
-/** Serialize canonically: the top-level hash keys sorted ascending, two-space pretty, and a trailing
- *  newline, so the committed file diffs cleanly in a PR and a re-serialization is byte-identical. */
+/**
+ * Serialize canonically: the top-level hash keys sorted ascending, two-space pretty, and a trailing
+ *  newline, so the committed file diffs cleanly in a PR and a re-serialization is byte-identical.
+ */
 export function serializeMediaManifest(manifest) {
     const sorted = {};
     for (const hash of Object.keys(manifest).sort()) {

package/dist/media/naming.d.ts

@@ -2,17 +2,23 @@
 export declare function hashBytes(bytes: Uint8Array): Promise<string>;
 /** The first 16 characters of a full hex digest, the content-hash prefix media references commit to. */
 export declare function shortHash(full: string): string;
-/** 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 declare function slugifyFilename(name: string): string;
-/** 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 declare function r2Key(shortHash: string, ext: string): string;
-/** 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 declare function publicPath(slug: string | null, shortHash: string, ext: string, urlForm: 'slug' | 'opaque', publicBase?: string): string;

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[];