@glw907/cairn-cms 0.21.0 → 0.26.0

package/dist/vite/index.js

@@ -0,0 +1,178 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/** The key the cairnManifest plugin stashes its options under, so the write path can read them off the
+ *  plugin instance in the consumer's loaded config without re-parsing the config file. */
+const CAIRN_OPTIONS = Symbol.for('cairn-cms.manifest-options');
+const VIRTUAL_ID = 'virtual:cairn-manifest';
+const RESOLVED_ID = '\0' + VIRTUAL_ID;
+/** The default committed manifest path, app-root-absolute. */
+const DEFAULT_MANIFEST_PATH = '/src/content/.cairn/index.json';
+/** Build the virtual module source. In verify mode it throws on drift; in write mode it exports the
+ *  serialized manifest as `result`. The module runs in the app graph, so its `import.meta.glob`,
+ *  package, and `?raw` resolution is the build's own. */
+function virtualSource(opts, mode) {
+    const manifestPath = opts.manifestPath ?? DEFAULT_MANIFEST_PATH;
+    const globEntries = Object.entries(opts.content)
+        .map(([id, pattern]) => `  ${JSON.stringify(id)}: import.meta.glob(${JSON.stringify(pattern)}, { query: '?raw', import: 'default', eager: true }),`)
+        .join('\n');
+    // In write mode the committed file may not exist yet, so do not import it.
+    const committedImport = mode === 'verify' ? `import committed from ${JSON.stringify(manifestPath + '?raw')};` : '';
+    const resultExpr = mode === 'write' ? 'serializeManifest(built)' : '(verifyManifest(built, committed), "ok")';
+    return `
+import { buildSiteManifest } from '@glw907/cairn-cms/delivery/data';
+import { serializeManifest, verifyManifest } from '@glw907/cairn-cms';
+import { cairn, siteConfig } from ${JSON.stringify(opts.configModule)};
+${committedImport}
+const globs = {
+${globEntries}
+};
+const built = buildSiteManifest(cairn, siteConfig, globs);
+export const result = ${resultExpr};
+`;
+}
+/** Evaluate the virtual module in the given mode inside the consumer's own Vite resolution, then
+ *  return the module's `result`. It reuses the consumer's loaded config (so `$lib`, the config
+ *  module, `import.meta.glob`, and `?raw` resolve exactly as the build does) and strips the
+ *  cairnManifest plugin from the nested server's plugin list, so its buildStart never recurses.
+ *  This runs at build time and in the bin, never in the request lifecycle. */
+async function evalVirtual(opts, mode, root) {
+    const { createServer, loadConfigFromFile } = await import('vite');
+    // Load the consumer's real Vite config so the nested server inherits SvelteKit's resolution
+    // (the $lib alias, the app root, the ?raw and import.meta.glob handling). Drop cairnManifest from
+    // it so the nested server's buildStart does not recurse, and add a plugin that serves only the
+    // virtual module in the requested mode.
+    const loaded = await loadConfigFromFile({ command: 'build', mode: 'production' }, undefined, root);
+    const inlineConfig = loaded?.config ?? {};
+    const server = await createServer({
+        ...inlineConfig,
+        root,
+        configFile: false,
+        logLevel: 'silent',
+        server: { middlewareMode: true, hmr: false, watch: null },
+        plugins: [...stripCairnManifest(inlineConfig.plugins ?? []), cairnVirtualOnly(opts, mode)],
+    });
+    try {
+        const mod = (await server.ssrLoadModule(VIRTUAL_ID));
+        return mod.result;
+    }
+    finally {
+        await server.close();
+    }
+}
+/** True for any plugin object whose name is the cairnManifest plugin, so the nested server drops it
+ *  and cannot recurse into another buildStart. The consumer's plugin list may nest arrays and hold
+ *  falsy slots, so guard the shape. */
+function isCairnManifestPlugin(p) {
+    return !!p && typeof p === 'object' && 'name' in p && p.name === 'cairn-manifest';
+}
+/** Flatten the consumer's plugins option and drop the cairnManifest plugin at any nesting depth, so
+ *  the nested verify server can never re-enter its buildStart. Vite supports (and flattens) nested
+ *  plugin arrays, and findCairnOptions recurses into them, so a flat single-level filter would miss a
+ *  cairnManifest nested inside a shared preset's sub-array and let it survive into the nested server.
+ *  This mirrors findCairnOptions's recursion. Falsy slots pass through, which Vite tolerates. */
+export function stripCairnManifest(plugins) {
+    if (Array.isArray(plugins))
+        return plugins.flatMap(stripCairnManifest);
+    if (isCairnManifestPlugin(plugins))
+        return [];
+    return [plugins];
+}
+/** Verify the committed manifest against the corpus from a Vite context, throwing on drift. The bin
+ *  and the plugin share this; the spike proved it runs cleanly inside the consumer's config. */
+export async function verifyManifestFromVite(opts, root) {
+    await evalVirtual(opts, 'verify', root);
+}
+/** Regenerate the serialized manifest from the corpus in a Vite context, sharing the build's
+ *  resolution. The cairn-manifest bin (a later task) will call this and write the result. */
+export async function buildManifestFromVite(opts, root) {
+    return evalVirtual(opts, 'write', root);
+}
+/** The cairnManifest plugin. It serves the verify virtual module to the app graph and, in
+ *  buildStart, evaluates it through a nested Vite SSR load so a manifest drift fails the build. */
+export function cairnManifest(opts) {
+    let root = process.cwd();
+    const plugin = {
+        name: 'cairn-manifest',
+        configResolved(config) {
+            // Capture the resolved app root so the nested server loads the same config the build did.
+            root = config.root;
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_ID)
+                return RESOLVED_ID;
+        },
+        load(id) {
+            if (id === RESOLVED_ID)
+                return virtualSource(opts, 'verify');
+        },
+        async buildStart() {
+            try {
+                await verifyManifestFromVite(opts, root);
+            }
+            catch (err) {
+                this.error(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    // Stash the options on the instance so the cairn-manifest bin's writeManifest can read the content
+    // globs, config module, and manifest path off the plugin in the consumer's loaded config, sharing
+    // exactly the options the build verifies with.
+    plugin[CAIRN_OPTIONS] = opts;
+    return plugin;
+}
+/** Regenerate the committed manifest from the consumer's corpus and write it to the configured
+ *  manifestPath. It loads the consumer's Vite config from `cwd`, reads the cairnManifest plugin's
+ *  options off the instance, evaluates the write-mode virtual module through the build's own
+ *  resolution, and writes the serialized manifest. The cairn-manifest bin calls this; it is exported
+ *  so the write logic is testable apart from the CLI shell. */
+export async function writeManifest(cwd = process.cwd()) {
+    const { loadConfigFromFile } = await import('vite');
+    const loaded = await loadConfigFromFile({ command: 'build', mode: 'production' }, undefined, cwd);
+    if (!loaded) {
+        throw new Error(`cairn-manifest: no Vite config found in ${cwd}`);
+    }
+    const opts = findCairnOptions(loaded.config.plugins);
+    if (!opts) {
+        throw new Error('cairn-manifest: the Vite config has no cairnManifest() plugin. Add it so the bin shares the build options.');
+    }
+    const serialized = await buildManifestFromVite(opts, cwd);
+    const manifestPath = opts.manifestPath ?? DEFAULT_MANIFEST_PATH;
+    // The manifest path is app-root-absolute (a leading slash relative to the project), so resolve it
+    // against cwd, not the filesystem root.
+    const outPath = join(cwd, manifestPath.replace(/^\//, ''));
+    await mkdir(dirname(outPath), { recursive: true });
+    await writeFile(outPath, serialized);
+}
+/** Walk a Vite plugins option (which may nest arrays, hold falsy slots, or be a thenable) and return
+ *  the stashed cairnManifest options from the first matching plugin, or null if there is none. */
+function findCairnOptions(plugins) {
+    if (!plugins)
+        return null;
+    if (Array.isArray(plugins)) {
+        for (const p of plugins) {
+            const found = findCairnOptions(p);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    if (typeof plugins === 'object' && CAIRN_OPTIONS in plugins) {
+        return plugins[CAIRN_OPTIONS] ?? null;
+    }
+    return null;
+}
+/** A minimal plugin that serves only the virtual module in one mode, for the nested SSR load. It
+ *  carries no buildStart, so the nested server never recurses into the verify. */
+function cairnVirtualOnly(opts, mode) {
+    return {
+        name: 'cairn-manifest-virtual',
+        resolveId(id) {
+            if (id === VIRTUAL_ID)
+                return RESOLVED_ID;
+        },
+        load(id) {
+            if (id === RESOLVED_ID)
+                return virtualSource(opts, mode);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glw907/cairn-cms",
-  "version": "0.21.0",
+  "version": "0.26.0",
   "description": "Embedded, magic-link, GitHub-committing CMS for SvelteKit/Cloudflare sites.",
   "type": "module",
   "sideEffects": [
@@ -13,6 +13,10 @@
     "type": "git",
     "url": "git+https://github.com/glw907/cairn-cms.git"
   },
+  "homepage": "https://github.com/glw907/cairn-cms#readme",
+  "bugs": {
+    "url": "https://github.com/glw907/cairn-cms/issues"
+  },
   "keywords": [
     "cms",
     "sveltekit",
@@ -22,9 +26,9 @@
     "markdown"
   ],
   "scripts": {
-    "package": "svelte-package",
+    "package": "svelte-package && chmod +x dist/vite/bin.js",
     "check:package": "npm run package && publint --strict && attw --pack . --ignore-rules no-resolution cjs-resolves-to-esm internal-resolution-error",
-    "prepare": "svelte-package",
+    "prepare": "npm run package",
     "check": "svelte-check --tsconfig ./tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -53,11 +57,29 @@
       "svelte": "./dist/delivery/index.js",
       "default": "./dist/delivery/index.js"
     },
+    "./delivery/head": {
+      "types": "./dist/delivery/head.d.ts",
+      "svelte": "./dist/delivery/head.js",
+      "default": "./dist/delivery/head.js"
+    },
+    "./delivery/data": {
+      "types": "./dist/delivery/data.d.ts",
+      "svelte": "./dist/delivery/data.js",
+      "default": "./dist/delivery/data.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "default": "./dist/vite/index.js"
+    },
     "./package.json": "./package.json"
   },
+  "bin": {
+    "cairn-manifest": "./dist/vite/bin.js"
+  },
   "files": [
     "dist",
-    "src/lib"
+    "src/lib",
+    "CHANGELOG.md"
   ],
   "peerDependencies": {
     "@sveltejs/kit": "^2",

package/src/lib/content/compose.ts

@@ -3,18 +3,27 @@
 // the same way and contributes the same kinds of things: nav entries, route logic,
 // concepts, components, field types, and save hooks. Shaped now so the extension contract
 // is additive later.
-import type { AdminPanel, CairnAdapter, CairnExtension, CairnRuntime, ConceptConfig, ConceptUrlPolicy, FieldTypeDef } from './types.js';
+import type { AdminPanel, CairnAdapter, CairnExtension, CairnRuntime, ConceptConfig, FieldTypeDef } from './types.js';
 import { normalizeConcepts } from './concepts.js';
+import { urlPolicyFrom, type SiteConfig } from '../nav/site-config.js';
+
+/** The input to {@link composeRuntime}. `siteConfig` is required so the per-concept URL policy is
+ *  always derived from one source and can never be silently dropped. `extensions` fold in after the
+ *  adapter's concepts. */
+export interface ComposeInput {
+  adapter: CairnAdapter;
+  siteConfig: SiteConfig;
+  extensions?: CairnExtension[];
+}
 
 /**
- * Fold an adapter and any extensions into the composed runtime (seam 2). Extension concepts
- * merge after the adapter's. The asset slot (seam 4) passes through untouched.
+ * Fold an adapter and any extensions into the composed runtime (seam 2). The per-concept URL policy
+ * is derived from the site config, the same source the delivery path uses, so the runtime and
+ * delivery permalinks cannot diverge. Extension concepts merge after the adapter's. The asset slot
+ * (seam 4) passes through untouched.
  */
-export function composeRuntime(
-  adapter: CairnAdapter,
-  extensions: CairnExtension[] = [],
-  urlPolicy: Record<string, ConceptUrlPolicy | undefined> = {},
-): CairnRuntime {
+export function composeRuntime({ adapter, siteConfig, extensions = [] }: ComposeInput): CairnRuntime {
+  if (!siteConfig) throw new Error('composeRuntime needs a site config to derive the URL policy');
   const content: Record<string, ConceptConfig | undefined> = { ...adapter.content };
   const adminPanels: AdminPanel[] = [];
   const fieldTypes: FieldTypeDef[] = [];
@@ -27,7 +36,7 @@ export function composeRuntime(
   }
   return {
     siteName: adapter.siteName,
-    concepts: normalizeConcepts(content, urlPolicy),
+    concepts: normalizeConcepts(content, urlPolicyFrom(siteConfig)),
     backend: adapter.backend,
     sender: adapter.sender,
     render: adapter.render,

package/src/lib/content/concepts.ts

@@ -43,6 +43,14 @@ export function normalizeConcepts(
   const descriptors: ConceptDescriptor[] = [];
   for (const [id, config] of Object.entries(content)) {
     if (!config) continue;
+    const summaryFields = config.summaryFields ?? [];
+    const declared = new Set(config.schema.fields.map((field) => field.name));
+    const undeclared = summaryFields.find((key) => !declared.has(key));
+    if (undeclared !== undefined) {
+      throw new Error(
+        `cairn: concept "${id}" summaryFields key "${undeclared}" is not a declared field`,
+      );
+    }
     const policy = urlPolicy[id] ?? {};
     descriptors.push({
       id,
@@ -52,6 +60,7 @@ export function normalizeConcepts(
       permalink: policy.permalink ?? defaultPermalink(id),
       datePrefix: policy.datePrefix ?? 'day',
       fields: config.schema.fields,
+      summaryFields,
       validate: config.schema.validate,
     });
   }

package/src/lib/content/frontmatter.ts

@@ -56,6 +56,27 @@ export function dateInputValue(value: unknown): string {
   return '';
 }
 
+/**
+ * True when `s` is a canonical zero-padded `YYYY-MM-DD` string naming a real calendar date.
+ * Rejects a wrong format, an impossible month or day, and a JS date-rollover such as
+ * `2026-02-30` (which `Date` would silently roll forward to March 2). The committed form a
+ * date field carries is exactly this canonical shape, which is what the form and
+ * `dateInputValue` emit, so a value outside it is a hand-edit or odd-YAML error.
+ */
+export function isCalendarDate(s: string): boolean {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return (
+    date.getUTCFullYear() === year &&
+    date.getUTCMonth() === month - 1 &&
+    date.getUTCDate() === day
+  );
+}
+
 /** Reassemble a markdown file from frontmatter and body for committing. */
 export function serializeMarkdown(frontmatter: object, body: string): string {
   return matter.stringify(body, frontmatter);

package/src/lib/content/manifest.ts

@@ -140,15 +140,71 @@ export function parseManifest(raw: string): Manifest {
   return { version: 1, entries: obj.entries as ManifestEntry[] };
 }
 
-/** Throw if the committed manifest drifts from what the corpus says. Both sides are compared in the
- *  canonical serialized form, so semantic equality never spuriously fails. The build calls this so a
- *  raw-git content edit, which leaves the committed manifest stale, fails the build loudly. */
-export function verifyManifest(built: Manifest, committedRaw: string): void {
-  if (committedRaw !== serializeManifest(built)) {
-    throw new Error(
-      'content manifest is stale: the committed file does not match the corpus. Regenerate it (npm run cairn:manifest) and commit the result.',
+/** A changed entry and the fields that differ between the built and committed manifests. */
+export interface ManifestEntryDiff {
+  concept: string;
+  id: string;
+  fields: string[];
+}
+
+/** The drift between a freshly built manifest and the committed one, keyed by concept+id. */
+export interface ManifestDiff {
+  added: ManifestEntry[];
+  removed: ManifestEntry[];
+  changed: ManifestEntryDiff[];
+}
+
+const keyOf = (e: ManifestEntry) => `${e.concept}/${e.id}`;
+
+/** Compare a built manifest against a committed one, keyed by concept+id (the same identity
+ *  upsertEntry and removeEntry use). A changed entry names the fields that differ. Pure, so it is
+ *  unit-tested apart from any build. */
+export function diffManifests(built: Manifest, committed: Manifest): ManifestDiff {
+  const builtByKey = new Map(built.entries.map((e) => [keyOf(e), e]));
+  const committedByKey = new Map(committed.entries.map((e) => [keyOf(e), e]));
+  const added = built.entries.filter((e) => !committedByKey.has(keyOf(e)));
+  const removed = committed.entries.filter((e) => !builtByKey.has(keyOf(e)));
+  const changed: ManifestEntryDiff[] = [];
+  for (const b of built.entries) {
+    const c = committedByKey.get(keyOf(b));
+    if (!c) continue;
+    // ManifestEntry has no index signature, so read its keys through an unknown-cast record.
+    const br = b as unknown as Record<string, unknown>;
+    const cr = c as unknown as Record<string, unknown>;
+    const fields = [...new Set([...Object.keys(b), ...Object.keys(c)])].filter(
+      (k) => JSON.stringify(br[k]) !== JSON.stringify(cr[k]),
     );
+    if (fields.length > 0) changed.push({ concept: b.concept, id: b.id, fields });
   }
+  return { added, removed, changed };
+}
+
+/** Format a diff into a short human-readable block for a build error. */
+function formatDiff(d: ManifestDiff): string {
+  const lines: string[] = [];
+  for (const e of d.added) lines.push(`  + ${keyOf(e)}`);
+  for (const e of d.removed) lines.push(`  - ${keyOf(e)}`);
+  for (const e of d.changed) lines.push(`  ~ ${e.concept}/${e.id} (${e.fields.join(', ')})`);
+  return lines.join('\n');
+}
+
+/** Throw if the committed manifest drifts from what the corpus says. The canonical serialized form
+ *  is the fast-path equality guard, so semantic equality never spuriously fails. On a mismatch the
+ *  error names the added, removed, and changed entries, so a raw-git content edit that leaves the
+ *  committed manifest stale fails the build loudly with what drifted. */
+export function verifyManifest(built: Manifest, committedRaw: string): void {
+  const builtRaw = serializeManifest(built);
+  if (committedRaw === builtRaw) return;
+  // Diff the canonical built form, not the raw one. serializeManifest sorts each entry's links, so a
+  // build whose links are in extraction order would otherwise report a false (links) drift for an
+  // entry whose link set is identical and only the order differs. Reuse the serialized form so both
+  // sides are canonical.
+  const diff = diffManifests(parseManifest(builtRaw), parseManifest(committedRaw));
+  throw new Error(
+    'content manifest is stale: the committed file does not match the corpus.\n' +
+      formatDiff(diff) +
+      '\nRegenerate it (npm run cairn:manifest) and commit the result.',
+  );
 }
 
 /** Replace the entry with the same concept and id, or add it. Order does not matter, since

package/src/lib/content/types.ts

@@ -110,6 +110,9 @@ export interface ConceptConfig<S extends ConceptSchema = ConceptSchema> {
   label?: string;
   /** The concept's schema: the form projection, the generated validator, and the inferred type. */
   schema: S;
+  /** Frontmatter keys to surface on each `ContentSummary.fields`, so a list card reads an authored
+   *  field without a per-entry detail read. Each key should also be declared in `schema`. */
+  summaryFields?: string[];
 }
 
 /**
@@ -215,6 +218,9 @@ export interface ConceptDescriptor {
   /** Filename date-prefix granularity for a dated concept; resolved by `normalizeConcepts`. */
   datePrefix: DatePrefix;
   fields: FrontmatterField[];
+  /** Frontmatter keys the index copies onto each summary's `fields` record. `normalizeConcepts`
+   *  resolves it to `[]` when a concept omits `summaryFields`. */
+  summaryFields: string[];
   validate(frontmatter: Record<string, unknown>, body: string): ValidationResult;
 }
 

package/src/lib/content/validate.ts

@@ -3,13 +3,16 @@
 // validator stays thin (engine-fat rule). Saving runs the concept's validator on the
 // server before any commit; invalid input bounces to the form (spec §7.4).
 import type { FrontmatterField, ValidationResult } from './types.js';
-import { dateInputValue } from './frontmatter.js';
+import { dateInputValue, isCalendarDate } from './frontmatter.js';
 
 /**
  * Validate raw frontmatter against a field list. Required text and date fields must be
  * non-empty; required tag fields must be non-empty lists. A present boolean coerces to `true`
  * and an unchecked one is omitted; a present tag field coerces to a string array and an empty
- * one is omitted; an empty optional text or date field is omitted, so the normalized data
+ * one is omitted, so validated data carries no key for an absent tag field (`tags` or `freetags`).
+ * The delivery read model
+ * (`ContentSummary.tags`) fills that case with an empty array; the two layers differ on purpose.
+ * An empty optional text or date field is omitted, so the normalized data
  * carries only meaningful values and committed frontmatter stays minimal. Returns the
  * normalized data, or field-keyed errors when any required field is empty.
  *
@@ -34,12 +37,17 @@ export function validateFields(
       case 'freetags': {
         const list = Array.isArray(value) ? value.map(String) : [];
         if (field.required && list.length === 0) errors[field.name] = `${field.label} is required`;
+        else if (field.type === 'tags') {
+          const unknown = list.find((tag) => !field.options.includes(tag));
+          if (unknown !== undefined) errors[field.name] = `${field.label} contains an unknown value: ${unknown}`;
+        }
         if (list.length > 0) data[field.name] = list;
         break;
       }
       case 'date': {
         const text = value instanceof Date ? dateInputValue(value) : typeof value === 'string' ? value.trim() : '';
         if (field.required && text === '') errors[field.name] = `${field.label} is required`;
+        else if (text !== '' && !isCalendarDate(text)) errors[field.name] = `${field.label} must be a valid date (YYYY-MM-DD)`;
         if (text !== '') data[field.name] = text;
         break;
       }

package/src/lib/delivery/content-index.ts

@@ -16,16 +16,27 @@ export interface RawFile {
 
 /** The cheap, plain-data view of one entry, for lists, feeds, and the sitemap. */
 export interface ContentSummary {
+  /** The descriptor id this entry belongs to, e.g. "posts". Lets a list or page branch per
+   *  concept without re-deriving it from a proxy like `entry.date`. */
+  concept: string;
   id: string;
   slug: string;
   permalink: string;
   title: string;
   date?: string;
   updated?: string;
+  /** The entry's tags, always present as an array and empty when the file declares none. This is the
+   *  read-model normalization. It differs on purpose from the validated `frontmatter.tags`, which the
+   *  validator omits when empty, so a published file carries no `tags: []` noise. Read `tags` here for
+   *  a list; read `frontmatter.tags` only when you need the validated, possibly-absent value. */
   tags: string[];
   excerpt: string;
   wordCount: number;
   draft: boolean;
+  /** The frontmatter keys the descriptor nominated via `summaryFields`, read off the validated,
+   *  normalized frontmatter. Held in a separate record so a nominated key cannot collide with a
+   *  typed summary field. Empty when the concept declares no `summaryFields`. */
+  fields: Record<string, unknown>;
 }
 
 /** The detail view: a summary plus the frontmatter and the body to render. The frontmatter
@@ -98,7 +109,12 @@ export function createContentIndex<F = Record<string, unknown>>(
       problems.push({ id, draft, errors: result.errors });
       continue;
     }
+    const summaryFieldValues: Record<string, unknown> = {};
+    for (const key of descriptor.summaryFields) {
+      if (key in result.data) summaryFieldValues[key] = result.data[key];
+    }
     entries.push({
+      concept: descriptor.id,
       id,
       slug,
       permalink: permalink(descriptor, { id, slug, date }),
@@ -109,6 +125,7 @@ export function createContentIndex<F = Record<string, unknown>>(
       excerpt: deriveExcerpt(body, { description: asString(raw.description) }),
       wordCount: wordCount(body),
       draft,
+      fields: summaryFieldValues,
       frontmatter: result.data as F,
       body,
     });

package/src/lib/delivery/data.ts

@@ -0,0 +1,26 @@
+// cairn-cms: the node-safe delivery data surface (@glw907/cairn-cms/delivery/data). The pure corpus
+// projections a SvelteKit site or a plain-Node tool reads, with no @sveltejs/kit and no .svelte in
+// the graph. The full ./delivery barrel re-exports this and adds the route loaders.
+export { createContentIndex, fromGlob } from './content-index.js';
+export type { RawFile, ContentSummary, ContentEntry, ContentIndex, ContentProblem } from './content-index.js';
+export { createSiteIndex } from './site-index.js';
+export type { SiteIndex, ConceptIndex } from './site-index.js';
+export { createSiteIndexes } from './site-indexes.js';
+export type { SiteIndexes, SiteGlobs } from './site-indexes.js';
+export { siteDescriptors } from './site-descriptors.js';
+export { deriveExcerpt, wordCount } from './excerpt.js';
+export { buildRssFeed, buildJsonFeed } from './feeds.js';
+export type { FeedChannel, FeedItem } from './feeds.js';
+export { buildSitemap } from './sitemap.js';
+export type { SitemapUrl } from './sitemap.js';
+export { buildRobots } from './robots.js';
+export { buildSeoMeta } from './seo.js';
+export type { SeoInput, SeoMeta } from './seo.js';
+export { readSeoFields, resolveImageUrl } from './seo-fields.js';
+export type { SeoFields } from './seo-fields.js';
+export { paginate } from './paginate.js';
+export type { Page } from './paginate.js';
+export { rssResponse, jsonFeedResponse, sitemapResponse, robotsResponse } from './responses.js';
+export { jsonLdScript } from './json-ld.js';
+export { permalink } from '../content/permalink.js';
+export { buildSiteManifest, buildLinkResolver } from './manifest.js';

package/src/lib/delivery/head.ts

@@ -0,0 +1,4 @@
+// cairn-cms: the delivery head component entry (@glw907/cairn-cms/delivery/head). CairnHead lives
+// behind its own export so importing a delivery data helper from /delivery never pulls a .svelte
+// module into the graph. A node-environment data import then needs no Svelte plugin.
+export { default as CairnHead } from './CairnHead.svelte';

package/src/lib/delivery/index.ts

@@ -1,31 +1,8 @@
-// cairn-cms: the public delivery entry (@glw907/cairn-cms/delivery). The complete, canonical,
-// backend-free toolkit a SvelteKit site wires its public pages with: the content index and the
-// site resolver, the descriptor helper, the syndication and SEO builders, the endpoint response
-// helpers, the catch-all route loaders, and the head component. It imports nothing from auth,
-// github, or email, so importing it does not pull the server backend into a public bundle.
-export { createContentIndex, fromGlob } from './content-index.js';
-export type { RawFile, ContentSummary, ContentEntry, ContentIndex, ContentProblem } from './content-index.js';
-export { createSiteIndex } from './site-index.js';
-export type { SiteIndex, ConceptIndex } from './site-index.js';
-export { createSiteIndexes } from './site-indexes.js';
-export type { SiteIndexes, SiteGlobs } from './site-indexes.js';
-export { siteDescriptors } from './site-descriptors.js';
-export { deriveExcerpt, wordCount } from './excerpt.js';
-export { buildRssFeed, buildJsonFeed } from './feeds.js';
-export type { FeedChannel, FeedItem } from './feeds.js';
-export { buildSitemap } from './sitemap.js';
-export type { SitemapUrl } from './sitemap.js';
-export { buildRobots } from './robots.js';
-export { buildSeoMeta } from './seo.js';
-export type { SeoInput, SeoMeta } from './seo.js';
-export { readSeoFields, resolveImageUrl } from './seo-fields.js';
-export type { SeoFields } from './seo-fields.js';
-export { paginate } from './paginate.js';
-export type { Page } from './paginate.js';
-export { rssResponse, jsonFeedResponse, sitemapResponse, robotsResponse } from './responses.js';
-export { jsonLdScript } from './json-ld.js';
-export { permalink } from '../content/permalink.js';
-export { buildSiteManifest, buildLinkResolver } from './manifest.js';
+// cairn-cms: the public delivery entry (@glw907/cairn-cms/delivery). The node-safe data surface
+// (re-exported from ./delivery/data) plus the SvelteKit catch-all route loaders. The head component
+// lives at ./delivery/head. Importing this pulls @sveltejs/kit through the route loaders, so a
+// plain-Node tool imports from ./delivery/data instead.
+export * from './data.js';
 export { createPublicRoutes } from '../sveltekit/public-routes.js';
 export type {
   PublicRoutesDeps,
@@ -34,4 +11,3 @@ export type {
   TagIndexData,
   EntryData,
 } from '../sveltekit/public-routes.js';
-export { default as CairnHead } from './CairnHead.svelte';

package/src/lib/index.ts

@@ -31,6 +31,7 @@ export type {
 } from './content/types.js';
 export { CONCEPT_ROUTING, normalizeConcepts, findConcept } from './content/concepts.js';
 export { composeRuntime } from './content/compose.js';
+export type { ComposeInput } from './content/compose.js';
 export {
   frontmatterFromForm,
   dateInputValue,
@@ -59,13 +60,14 @@ export {
   parseManifest,
   emptyManifest,
   verifyManifest,
+  diffManifests,
   upsertEntry,
   removeEntry,
   manifestEntryFromFile,
   manifestLinkResolver,
   inboundLinks,
 } from './content/manifest.js';
-export type { Manifest, ManifestEntry, LinkTarget, InboundLink } from './content/manifest.js';
+export type { Manifest, ManifestEntry, ManifestDiff, ManifestEntryDiff, LinkTarget, InboundLink } from './content/manifest.js';
 // Render engine (Plan 04): generic directive pipeline; sites own the component registry.
 export { defineRegistry, emptyValues } from './render/registry.js';
 export type {
@@ -92,6 +94,7 @@ export {
   strProp,
   iconSpan,
   cardShell,
+  headRow,
   markFirstList,
 } from './render/rehype-dispatch.js';
 export type { MakeIcon } from './render/rehype-dispatch.js';
@@ -155,3 +158,9 @@ export { readSeoFields, resolveImageUrl } from './delivery/seo-fields.js';
 export type { SeoFields } from './delivery/seo-fields.js';
 export { paginate } from './delivery/paginate.js';
 export type { Page } from './delivery/paginate.js';
+// Root superset of the delivery route surface: a wrong guess from root for a route loader or a
+// response helper now resolves. The CairnHead component stays out of root so the root barrel stays
+// node-importable for the unit suite; it resolves from @glw907/cairn-cms/delivery/head.
+export { rssResponse, jsonFeedResponse, sitemapResponse, robotsResponse } from './delivery/responses.js';
+export { createPublicRoutes } from './sveltekit/public-routes.js';
+export type { PublicRoutesDeps, ListData, TagData, TagIndexData, EntryData } from './sveltekit/public-routes.js';