@glw907/cairn-cms 0.41.0 → 0.50.0

package/dist/delivery/manifest.d.ts

@@ -1,12 +1,7 @@
 import type { Manifest } from '../content/manifest.js';
-import type { LinkResolve } from '../content/links.js';
-import type { SiteIndex } from './site-index.js';
 import type { SiteConfig } from '../nav/site-config.js';
 import type { CairnAdapter } from '../content/types.js';
 import type { SiteGlobs } from './site-indexes.js';
 /** Build the whole-corpus manifest from a site's adapter, config, and per-concept globs. Drafts are
  *  included and flagged, so the admin picker and the guards see the full graph. */
 export declare function buildSiteManifest<A extends CairnAdapter>(adapter: A, config: SiteConfig, globs: SiteGlobs<A>): Manifest;
-/** A resolver backed by the site index, for the build. A miss throws, so a dangling cairn: token
- *  fails the prerender (the build backstop). The preview uses manifestLinkResolver, which marks. */
-export declare function buildLinkResolver(site: SiteIndex): LinkResolve;

package/dist/delivery/manifest.js

@@ -1,8 +1,7 @@
-// cairn-cms: the build-side manifest builder and the build link resolver (content-graph design).
-// buildSiteManifest mirrors createSiteIndexes: it maps the site descriptors over the per-concept
-// globs and projects each file to a manifest row. buildLinkResolver reads the site index, which is
-// fresh from the files at build, and throws on a missing target so a dangling cairn: token fails
-// the build (the backstop). The admin preview uses manifestLinkResolver instead.
+// cairn-cms: the build-side manifest builder (content-graph design). buildSiteManifest mirrors
+// createSiteIndexes: it maps the site descriptors over the per-concept globs and projects each
+// file to a manifest row. The build-time cairn: link resolver lives beside the site resolver in
+// site-resolver.ts; the admin preview uses manifestLinkResolver instead.
 import { siteDescriptors } from './site-descriptors.js';
 import { fromGlob } from './content-index.js';
 import { parseMarkdown } from '../content/frontmatter.js';
@@ -15,7 +14,7 @@ export function buildSiteManifest(adapter, config, globs) {
     for (const descriptor of siteDescriptors(adapter, config)) {
         const record = globRecord[descriptor.id] ?? {};
         for (const file of fromGlob(record)) {
-            // Validate the same way createContentIndex does, so the manifest and the site index agree on
+            // Validate the same way createContentIndex does, so the manifest and the site resolver agree on
             // which entries exist. A validation failure is excluded from both; otherwise the preview would
             // resolve a link the build then rejects as a missing target.
             const { frontmatter, body } = parseMarkdown(file.raw);
@@ -26,13 +25,3 @@ export function buildSiteManifest(adapter, config, globs) {
     }
     return manifest;
 }
-/** A resolver backed by the site index, for the build. A miss throws, so a dangling cairn: token
- *  fails the prerender (the build backstop). The preview uses manifestLinkResolver, which marks. */
-export function buildLinkResolver(site) {
-    return (ref) => {
-        const url = site.concept(ref.concept)?.byId(ref.id)?.permalink;
-        if (!url)
-            throw new Error(`cairn link target not found: cairn:${ref.concept}/${ref.id}`);
-        return url;
-    };
-}

package/dist/{sveltekit → delivery}/public-routes.d.ts

@@ -1,10 +1,10 @@
-import type { ContentSummary, ContentEntry } from '../delivery/content-index.js';
-import type { SiteIndex } from '../delivery/site-index.js';
-import type { SeoMeta } from '../delivery/seo.js';
+import type { ContentSummary, ContentEntry } from './content-index.js';
+import type { SiteResolver } from './site-resolver.js';
+import type { SeoMeta } from './seo.js';
 import type { LinkResolve } from '../content/links.js';
 /** Injected dependencies for the public loaders. */
 export interface PublicRoutesDeps {
-    site: SiteIndex;
+    site: SiteResolver;
     render: (md: string, opts?: {
         stagger?: boolean;
         resolve?: LinkResolve;

package/dist/{sveltekit → delivery}/public-routes.js

@@ -1,12 +1,12 @@
-// cairn-cms: public route loaders (dated-slug design). The factory closes over the site-level
-// index, the runtime render, and the origin. entryLoad and entries are site-wide: one catch-all
+// cairn-cms: public route loaders (dated-slug design). The factory closes over the site
+// resolver, the runtime render, and the origin. entryLoad and entries are site-wide: one catch-all
 // `[...path]` route resolves any concept by request path through `byPermalink`. The archive, tag,
-// and tag-index loaders stay concept-scoped, keyed by concept id. The index is built in site code
-// from globs, so it stays in the prerender graph and out of the runtime Worker.
+// and tag-index loaders stay concept-scoped, keyed by concept id. The resolver is built in site
+// code from globs, so it stays in the prerender graph and out of the runtime Worker.
 import { error } from '@sveltejs/kit';
-import { buildSeoMeta } from '../delivery/seo.js';
-import { readSeoFields, resolveImageUrl } from '../delivery/seo-fields.js';
-import { buildLinkResolver } from '../delivery/manifest.js';
+import { buildSeoMeta } from './seo.js';
+import { readSeoFields, resolveImageUrl } from './seo-fields.js';
+import { buildLinkResolver } from './site-resolver.js';
 /** Build the public loaders for a site's unified index. */
 export function createPublicRoutes(deps) {
     const { site, render, origin, siteName, description, feeds, defaultImage } = deps;

package/dist/delivery/site-indexes.d.ts

@@ -2,7 +2,7 @@ import type { CairnAdapter, ConceptConfig } from '../content/types.js';
 import type { Infer } from '../content/schema.js';
 import type { SiteConfig } from '../nav/site-config.js';
 import type { ContentIndex } from './content-index.js';
-import type { SiteIndex } from './site-index.js';
+import type { SiteResolver } from './site-resolver.js';
 /** A per-concept raw glob record (`{ path: raw }`) keyed by concept id, from `import.meta.glob`. */
 export type SiteGlobs<A extends CairnAdapter> = {
     [K in keyof A['content']]?: Record<string, string>;
@@ -12,13 +12,13 @@ export type SiteGlobs<A extends CairnAdapter> = {
 export type SiteIndexes<A extends CairnAdapter> = {
     [K in keyof A['content']]: ContentIndex<NonNullable<A['content'][K]> extends ConceptConfig<infer S> ? Infer<S> : Record<string, unknown>>;
 } & {
-    readonly site: SiteIndex;
+    readonly site: SiteResolver;
 };
 /**
  * Build typed per-concept indexes and a site resolver from one adapter. Pass the per-concept raw
  * globs as `{ posts: import.meta.glob('...?raw', { eager: true }), ... }`; Vite needs the literal
  * glob at the call site, so the engine cannot glob on the site's behalf. `validate: false` opts out
- * of the build gate, exactly as on `createSiteIndex`.
+ * of the build gate, exactly as on `createSiteResolver`.
  */
 export declare function createSiteIndexes<const A extends CairnAdapter>(adapter: A, config: SiteConfig, globs: SiteGlobs<A>, opts?: {
     validate?: boolean;

package/dist/delivery/site-indexes.js

@@ -1,11 +1,11 @@
 import { siteDescriptors } from './site-descriptors.js';
 import { createContentIndex, fromGlob } from './content-index.js';
-import { createSiteIndex } from './site-index.js';
+import { createSiteResolver } from './site-resolver.js';
 /**
  * Build typed per-concept indexes and a site resolver from one adapter. Pass the per-concept raw
  * globs as `{ posts: import.meta.glob('...?raw', { eager: true }), ... }`; Vite needs the literal
  * glob at the call site, so the engine cannot glob on the site's behalf. `validate: false` opts out
- * of the build gate, exactly as on `createSiteIndex`.
+ * of the build gate, exactly as on `createSiteResolver`.
  */
 export function createSiteIndexes(adapter, config, globs, opts = {}) {
     const descriptors = siteDescriptors(adapter, config);
@@ -25,6 +25,6 @@ export function createSiteIndexes(adapter, config, globs, opts = {}) {
         byConcept[descriptor.id] = index;
         conceptIndexes.push({ descriptor, index });
     }
-    const site = createSiteIndex(conceptIndexes, opts);
+    const site = createSiteResolver(conceptIndexes, opts);
     return { ...byConcept, site };
 }

package/dist/delivery/{site-index.d.ts → site-resolver.d.ts}

@@ -1,12 +1,13 @@
 import type { ConceptDescriptor } from '../content/types.js';
 import type { ContentEntry, ContentIndex, ContentSummary } from './content-index.js';
+import type { LinkResolve } from '../content/links.js';
 /** One concept's descriptor paired with its built index. */
 export interface ConceptIndex {
     descriptor: ConceptDescriptor;
     index: ContentIndex;
 }
 /** The cross-concept query surface a catch-all route and the sitemap read. */
-export interface SiteIndex {
+export interface SiteResolver {
     /** Resolve a request path (with or without a trailing slash) to its entry, or undefined. */
     byPermalink(path: string): ContentEntry | undefined;
     /** Newer/older neighbors within the entry's own concept, for prev/next links. */
@@ -28,6 +29,9 @@ export interface SiteIndex {
  * unless `validate` is `false`, on any non-draft entry whose frontmatter fails its concept's
  * validator, so malformed content fails the build instead of shipping.
  */
-export declare function createSiteIndex(concepts: ConceptIndex[], opts?: {
+export declare function createSiteResolver(concepts: ConceptIndex[], opts?: {
     validate?: boolean;
-}): SiteIndex;
+}): SiteResolver;
+/** A resolver backed by the site resolver, for the build. A miss throws, so a dangling cairn: token
+ *  fails the prerender (the build backstop). The preview uses manifestLinkResolver, which marks. */
+export declare function buildLinkResolver(site: SiteResolver): LinkResolve;

package/dist/delivery/{site-index.js → site-resolver.js}

@@ -21,11 +21,11 @@ function siteProblems(concepts) {
  * unless `validate` is `false`, on any non-draft entry whose frontmatter fails its concept's
  * validator, so malformed content fails the build instead of shipping.
  */
-export function createSiteIndex(concepts, opts = {}) {
+export function createSiteResolver(concepts, opts = {}) {
     if (opts.validate !== false) {
         const problems = siteProblems(concepts);
         if (problems.length > 0) {
-            throw new Error(`site index: ${problems.length} invalid frontmatter field(s):\n  ${problems.join('\n  ')}`);
+            throw new Error(`site resolver: ${problems.length} invalid frontmatter field(s):\n  ${problems.join('\n  ')}`);
         }
     }
     const byPath = new Map();
@@ -35,7 +35,7 @@ export function createSiteIndex(concepts, opts = {}) {
         for (const summary of index.all()) {
             const existing = byPath.get(summary.permalink);
             if (existing) {
-                throw new Error(`site index: "${existing.id}" and "${summary.id}" both resolve to "${summary.permalink}"`);
+                throw new Error(`site resolver: "${existing.id}" and "${summary.id}" both resolve to "${summary.permalink}"`);
             }
             byPath.set(summary.permalink, { index, id: summary.id });
         }
@@ -60,3 +60,13 @@ export function createSiteIndex(concepts, opts = {}) {
         },
     };
 }
+/** A resolver backed by the site resolver, for the build. A miss throws, so a dangling cairn: token
+ *  fails the prerender (the build backstop). The preview uses manifestLinkResolver, which marks. */
+export function buildLinkResolver(site) {
+    return (ref) => {
+        const url = site.concept(ref.concept)?.byId(ref.id)?.permalink;
+        if (!url)
+            throw new Error(`cairn link target not found: cairn:${ref.concept}/${ref.id}`);
+        return url;
+    };
+}

package/dist/delivery/sitemap.js

@@ -1,8 +1,6 @@
 // cairn-cms: sitemap builder (public-delivery design). Pure over a URL list; the caller
 // derives the list from the content index and the routable concepts.
-function escapeXml(value) {
-    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
+import { escapeXml } from './xml.js';
 /** Build a sitemap XML document from a list of URLs. */
 export function buildSitemap(urls) {
     const entries = urls

package/dist/delivery/xml.d.ts

@@ -0,0 +1,2 @@
+/** Escape the XML-significant characters for element text and double-quoted attribute values. */
+export declare function escapeXml(value: string): string;

package/dist/delivery/xml.js

@@ -0,0 +1,11 @@
+// cairn-cms: the one XML text escape the feed and sitemap builders share. The strongest of the
+// two copies it replaced (the old sitemap copy skipped quotes), so both documents stay safe in
+// element text and double-quoted attributes.
+/** Escape the XML-significant characters for element text and double-quoted attribute values. */
+export function escapeXml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;');
+}

package/dist/email.js

@@ -1,13 +1,5 @@
 import { CairnError } from './diagnostics/index.js';
-/** Escape the five HTML-significant characters. */
-function escapeHtml(value) {
-    return value
-        .replaceAll('&', '&')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;')
-        .replaceAll("'", '&#39;');
-}
+import { escapeHtml } from './escape.js';
 /** Build the confirmation email. The link is the only action; the copy stays plain. */
 export function buildMagicLinkMessage(input) {
     const { to, branding, link } = input;
@@ -20,8 +12,9 @@ export function buildMagicLinkMessage(input) {
 }
 /** The production send: Cloudflare Email Sending through the EMAIL binding. */
 export const cloudflareSend = async (env, message) => {
-    if (!env.EMAIL)
-        throw new Error('EMAIL binding is not configured');
+    if (!env.EMAIL) {
+        throw new CairnError('config.bindings-missing', { message: 'EMAIL binding is not configured' });
+    }
     await env.EMAIL.send(message);
 };
 /**

package/dist/env.d.ts

@@ -16,7 +16,7 @@ export declare function requireOrigin(env: {
  * The handlers read D1 off `event.platform.env`; without this a misconfigured binding
  * surfaces as a raw `TypeError` deep in a store call. This gives the failure a name.
  *
- * @throws Error when `AUTH_DB` is missing.
+ * @throws CairnError (`config.bindings-missing`) when `AUTH_DB` is missing.
  */
 export declare function requireDb(env: {
     AUTH_DB?: D1Database;

package/dist/env.js

@@ -1,3 +1,4 @@
+import { CairnError } from './diagnostics/index.js';
 /**
  * Returns the site's public origin from configuration.
  *
@@ -33,11 +34,11 @@ export function requireOrigin(env) {
  * The handlers read D1 off `event.platform.env`; without this a misconfigured binding
  * surfaces as a raw `TypeError` deep in a store call. This gives the failure a name.
  *
- * @throws Error when `AUTH_DB` is missing.
+ * @throws CairnError (`config.bindings-missing`) when `AUTH_DB` is missing.
  */
 export function requireDb(env) {
     if (!env.AUTH_DB) {
-        throw new Error('AUTH_DB binding is not configured');
+        throw new CairnError('config.bindings-missing', { message: 'AUTH_DB binding is not configured' });
     }
     return env.AUTH_DB;
 }

package/dist/escape.d.ts

@@ -0,0 +1,2 @@
+/** Escape the five HTML-significant characters for text and quoted attribute values. */
+export declare function escapeHtml(value: string): string;

package/dist/escape.js

@@ -0,0 +1,11 @@
+// cairn-cms: the one HTML text escape. A leaf module with no imports, so the email builder and
+// the edge-served admin pages share it without either arm reaching into the other.
+/** Escape the five HTML-significant characters for text and quoted attribute values. */
+export function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}

package/dist/github/credentials.d.ts

@@ -6,6 +6,7 @@ export interface GithubKeyEnv {
 }
 /**
  * Assemble the `AppCredentials` the signer needs from the adapter's `backend` (app id,
- * installation) and the Worker's private-key secret. Throws when the secret is unset.
+ * installation) and the Worker's private-key secret. Throws a CairnError naming
+ * `github.app-unreachable` when the secret is unset, since the App cannot authenticate without it.
  */
 export declare function appCredentials(backend: Pick<BackendConfig, 'appId' | 'installationId'>, env: GithubKeyEnv): AppCredentials;

package/dist/github/credentials.js

@@ -1,11 +1,19 @@
+// cairn-cms: the bridge from the adapter's backend config and the Worker's secret to the
+// App signer's input. One tested place owns the join and the missing-secret failure, so the
+// save action (Plan 05) stays thin and a misconfigured Worker fails by name, not with a deep
+// TypeError. Mirrors requireDb/requireOrigin in env.ts.
+import { CairnError } from '../diagnostics/index.js';
 /**
  * Assemble the `AppCredentials` the signer needs from the adapter's `backend` (app id,
- * installation) and the Worker's private-key secret. Throws when the secret is unset.
+ * installation) and the Worker's private-key secret. Throws a CairnError naming
+ * `github.app-unreachable` when the secret is unset, since the App cannot authenticate without it.
  */
 export function appCredentials(backend, env) {
     const privateKeyB64 = env.GITHUB_APP_PRIVATE_KEY_B64;
     if (!privateKeyB64) {
-        throw new Error('GITHUB_APP_PRIVATE_KEY_B64 is not configured');
+        throw new CairnError('github.app-unreachable', {
+            message: 'GITHUB_APP_PRIVATE_KEY_B64 is not configured',
+        });
     }
     return { appId: backend.appId, installationId: backend.installationId, privateKeyB64 };
 }

package/dist/github/types.d.ts

@@ -32,3 +32,5 @@ export declare class CommitConflictError extends Error {
     readonly path: string;
     constructor(path: string);
 }
+/** Match a commit conflict by class and by name (bundling can alias the class identity). */
+export declare function isConflict(err: unknown): boolean;

package/dist/github/types.js

@@ -16,3 +16,7 @@ export class CommitConflictError extends Error {
         this.name = 'CommitConflictError';
     }
 }
+/** Match a commit conflict by class and by name (bundling can alias the class identity). */
+export function isConflict(err) {
+    return err instanceof CommitConflictError || err?.name === 'CommitConflictError';
+}

package/dist/log/events.d.ts

@@ -1 +1 @@
-export type CairnLogEvent = 'auth.link.requested' | 'auth.link.send_failed' | 'auth.token.minted' | 'auth.token.confirmed' | 'auth.session.created' | 'auth.session.destroyed' | 'commit.succeeded' | 'commit.failed' | 'entry.published' | 'entry.discarded' | 'publish.failed' | 'github.unreachable' | 'guard.rejected';
+export type CairnLogEvent = 'auth.link.requested' | 'auth.link.send_failed' | 'auth.token.minted' | 'auth.token.confirmed' | 'auth.session.created' | 'auth.session.destroyed' | 'commit.succeeded' | 'commit.failed' | 'config.invalid' | 'entry.published' | 'entry.discarded' | 'publish.failed' | 'github.unreachable' | 'guard.rejected';

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

@@ -37,6 +37,8 @@ export interface SiteConfig {
     [key: string]: unknown;
 }
 export declare class SiteConfigError extends Error {
+    /** The registered diagnostic condition a malformed site config maps to (mirrors CairnError). */
+    readonly conditionId = "config.site-config-invalid";
     constructor(message: string);
 }
 /** Parse the YAML site-config text into a typed object. Throws SiteConfigError on a malformed root. */

package/dist/nav/site-config.js

@@ -60,6 +60,8 @@ export function validateNavTree(value, maxDepth) {
     return walk(value, 1);
 }
 export class SiteConfigError extends Error {
+    /** The registered diagnostic condition a malformed site config maps to (mirrors CairnError). */
+    conditionId = 'config.site-config-invalid';
     constructor(message) {
         super(message);
         this.name = 'SiteConfigError';

package/dist/sveltekit/admin-dispatch.d.ts

@@ -0,0 +1,28 @@
+import type { ConceptDescriptor } from '../content/types.js';
+/** The views the single-mount admin can render, discriminated for the dispatcher's switch. */
+export type AdminView = {
+    view: 'index';
+} | {
+    view: 'login';
+} | {
+    view: 'confirm';
+} | {
+    view: 'list';
+    concept: ConceptDescriptor;
+} | {
+    view: 'edit';
+    concept: ConceptDescriptor;
+    id: string;
+} | {
+    view: 'editors';
+} | {
+    view: 'nav';
+};
+/**
+ * Parse a raw `URL.pathname` (the caller passes `event.url.pathname`, never a SvelteKit rest
+ * param) into the admin view it names. A single trailing slash is tolerated everywhere; empty
+ * internal segments are not. Each segment is percent-decoded individually, so an encoded slash
+ * stays inside its segment, where it can never match a concept id or pass `isValidId` and so
+ * falls through to null.
+ */
+export declare function parseAdminPath(pathname: string, concepts: ConceptDescriptor[]): AdminView | null;

package/dist/sveltekit/admin-dispatch.js

@@ -0,0 +1,62 @@
+import { findConcept } from '../content/concepts.js';
+import { isValidId } from '../content/ids.js';
+/**
+ * Fixed first segments that never resolve as concepts. The engine only allows posts and pages
+ * today, so no collision is possible, but the parser does not depend on that: a reserved
+ * segment wins before concept lookup. `settings` has no view yet; AdminLayout already links
+ * the sidebar to /admin/settings, so the URL is spoken for.
+ */
+const RESERVED_SEGMENTS = new Set(['login', 'auth', 'editors', 'nav', 'settings']);
+/**
+ * Parse a raw `URL.pathname` (the caller passes `event.url.pathname`, never a SvelteKit rest
+ * param) into the admin view it names. A single trailing slash is tolerated everywhere; empty
+ * internal segments are not. Each segment is percent-decoded individually, so an encoded slash
+ * stays inside its segment, where it can never match a concept id or pass `isValidId` and so
+ * falls through to null.
+ */
+export function parseAdminPath(pathname, concepts) {
+    if (pathname !== '/admin' && !pathname.startsWith('/admin/'))
+        return null;
+    let rest = pathname.slice('/admin'.length);
+    // Tolerate exactly one trailing slash; a doubled one leaves an empty segment behind.
+    if (rest.endsWith('/'))
+        rest = rest.slice(0, -1);
+    if (rest === '')
+        return { view: 'index' };
+    const rawSegments = rest.slice(1).split('/');
+    if (rawSegments.includes(''))
+        return null;
+    let segments;
+    try {
+        segments = rawSegments.map((segment) => decodeURIComponent(segment));
+    }
+    catch {
+        // Malformed percent encoding is an unrecognized shape, not a server error.
+        return null;
+    }
+    if (segments.length === 1) {
+        const [head] = segments;
+        if (head === 'login')
+            return { view: 'login' };
+        if (head === 'editors')
+            return { view: 'editors' };
+        if (head === 'nav')
+            return { view: 'nav' };
+        if (RESERVED_SEGMENTS.has(head))
+            return null;
+        const concept = findConcept(concepts, head);
+        return concept ? { view: 'list', concept } : null;
+    }
+    if (segments.length === 2) {
+        const [head, tail] = segments;
+        if (head === 'auth')
+            return tail === 'confirm' ? { view: 'confirm' } : null;
+        if (RESERVED_SEGMENTS.has(head))
+            return null;
+        const concept = findConcept(concepts, head);
+        if (!concept || !isValidId(tail))
+            return null;
+        return { view: 'edit', concept, id: tail };
+    }
+    return null;
+}

package/dist/sveltekit/cairn-admin.d.ts

@@ -0,0 +1,94 @@
+import { type ContentRoutesDeps, type LayoutData, type ListData, type EditData } from './content-routes.js';
+import { type NavLoadData } from './nav-routes.js';
+import type { AuthBranding, SendMagicLink } from '../email.js';
+import type { AuthEnv, Editor } from '../auth/types.js';
+import type { GithubKeyEnv } from '../github/credentials.js';
+import type { CairnRuntime } from '../content/types.js';
+import type { CookieJar, EventBase } from './types.js';
+/**
+ * The structural event the single-mount load reads: the union of what the wrapped loads need
+ * (ContentEvent minus params, which the dispatcher synthesizes, plus RequestContext's cookies
+ * and setHeaders). A real SvelteKit RequestEvent satisfies it.
+ */
+export interface AdminEvent extends EventBase<GithubKeyEnv & AuthEnv> {
+    cookies: CookieJar;
+    setHeaders(headers: Record<string, string>): void;
+}
+/** Injectable dependencies. Branding defaults from the runtime's siteName and sender, so a
+ *  site overrides it only to change the magic-link email identity; `send` and `mintToken`
+ *  are the same seams the underlying factories take. */
+export interface CairnAdminDeps {
+    branding?: AuthBranding;
+    send?: SendMagicLink;
+    mintToken?: ContentRoutesDeps['mintToken'];
+}
+/**
+ * One admin view's data, discriminated for the admin page component's switch. The public
+ * views (login, confirm) carry no layout; every authed view pairs the shared layout with its
+ * page data, the same shapes the per-surface loads have always returned.
+ */
+export type AdminData = {
+    view: 'login';
+    page: {
+        siteName: string;
+        error: string | null;
+        csrf: string;
+    };
+} | {
+    view: 'confirm';
+    page: {
+        token: string;
+        siteName: string;
+        error: string | null;
+        csrf: string;
+    };
+} | {
+    view: 'list';
+    layout: LayoutData;
+    page: ListData;
+} | {
+    view: 'edit';
+    layout: LayoutData;
+    page: EditData;
+} | {
+    view: 'editors';
+    layout: LayoutData;
+    page: {
+        editors: Editor[];
+        self: string;
+    };
+} | {
+    view: 'nav';
+    layout: LayoutData;
+    page: NavLoadData;
+};
+export declare function createCairnAdmin(runtime: CairnRuntime, deps?: CairnAdminDeps): {
+    load: (event: AdminEvent) => Promise<AdminData>;
+    actions: {
+        request: (event: AdminEvent) => Promise<import("./auth-routes.js").RequestResult>;
+        confirm: (event: AdminEvent) => Promise<never>;
+        logout: (event: AdminEvent) => Promise<never>;
+        create: (event: AdminEvent) => Promise<never>;
+        save: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        publish: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        discard: (event: AdminEvent) => Promise<never>;
+        rename: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        delete: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<unknown>>;
+        publishAll: (event: AdminEvent) => Promise<never>;
+        addEditor: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+            error: string;
+        }> | {
+            ok: true;
+        }>;
+        removeEditor: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+            error: string;
+        }> | {
+            ok: true;
+        }>;
+        setRole: (event: AdminEvent) => Promise<import("@sveltejs/kit").ActionFailure<{
+            error: string;
+        }> | {
+            ok: true;
+        }>;
+    };
+};