@glw907/cairn-cms 0.60.1 → 0.62.2

package/dist/render/resolve-media.d.ts

@@ -4,31 +4,39 @@ import { type MediaManifest } from '../media/manifest.js';
 import type { ResolvedAssetConfig } from '../media/config.js';
 /** The VFile data key the renderer sets the per-call media resolver under. */
 export declare const MEDIA_RESOLVE = "mediaResolve";
-/** Resolve a media reference to its delivery URL. `undefined` is a preview miss (the plugin marks
+/**
+ * Resolve a media reference to its delivery URL. `undefined` is a preview miss (the plugin marks
  *  the image broken); a resolver that throws is the build backstop (the error propagates out of
- *  render and fails the build), exactly like LinkResolve. */
+ *  render and fails the build), exactly like LinkResolve.
+ */
 export type MediaResolve = (ref: MediaRef) => string | undefined;
-/** Build the per-call media resolver, closing over the manifest and the resolved config. The
+/**
+ * Build the per-call media resolver, closing over the manifest and the resolved config. The
  *  returned resolver looks a ref's content hash up in the manifest and builds the canonical delivery
  *  path from the manifest entry's slug and ext, not the token's, so a rename never breaks the
  *  reference. With a preset and zone transformations on it returns the variant URL; without a preset,
  *  or when transformations are off, it returns the bare full-size path so a fresh zone with Image
  *  Transformations disabled serves correct thumbnails rather than dead /cdn-cgi/image URLs. It returns
- *  undefined when media is off or no entry carries the hash (the preview-miss backstop). */
+ *  undefined when media is off or no entry carries the hash (the preview-miss backstop).
+ */
 export declare function makeMediaResolver(manifest: MediaManifest, resolved: ResolvedAssetConfig, opts?: {
     preset?: string;
 }): MediaResolve;
-/** A resolver backed by the lean `mediaTargets` projection, for the admin preview. It mirrors
+/**
+ * A resolver backed by the lean `mediaTargets` projection, for the admin preview. It mirrors
  *  manifestLinkResolver: a hash present in the projection builds the slug delivery path
  *  (`/media/<slug>.<hash>.<ext>`); a miss returns undefined, so the render step marks the image
  *  broken rather than throwing. Pure over the projection, with no manifest and no config, so the
- *  edit page reaches it with the data it actually has. */
+ *  edit page reaches it with the data it actually has.
+ */
 export declare function manifestMediaResolver(targets: Record<string, {
     slug: string;
     ext: string;
     contentType: string;
 }>): MediaResolve;
-/** Resolve media: image nodes against the VFile's resolver. A non-media src and a malformed token
+/**
+ * Resolve media: image nodes against the VFile's resolver. A non-media src and a malformed token
  *  pass through. A missing target is marked with the cairn-broken-media class (the resolver returns
- *  undefined) or, when the resolver throws, the error propagates and fails the build. */
+ *  undefined) or, when the resolver throws, the error propagates and fails the build.
+ */
 export declare function remarkResolveMedia(): (tree: unknown, file: VFile) => void;

package/dist/render/resolve-media.js

@@ -11,13 +11,15 @@ import { presetUrl } from '../media/transform-url.js';
 import { log } from '../log/index.js';
 /** The VFile data key the renderer sets the per-call media resolver under. */
 export const MEDIA_RESOLVE = 'mediaResolve';
-/** Build the per-call media resolver, closing over the manifest and the resolved config. The
+/**
+ * Build the per-call media resolver, closing over the manifest and the resolved config. The
  *  returned resolver looks a ref's content hash up in the manifest and builds the canonical delivery
  *  path from the manifest entry's slug and ext, not the token's, so a rename never breaks the
  *  reference. With a preset and zone transformations on it returns the variant URL; without a preset,
  *  or when transformations are off, it returns the bare full-size path so a fresh zone with Image
  *  Transformations disabled serves correct thumbnails rather than dead /cdn-cgi/image URLs. It returns
- *  undefined when media is off or no entry carries the hash (the preview-miss backstop). */
+ *  undefined when media is off or no entry carries the hash (the preview-miss backstop).
+ */
 export function makeMediaResolver(manifest, resolved, opts) {
     return (ref) => {
         if (!resolved.enabled)
@@ -36,11 +38,13 @@ export function makeMediaResolver(manifest, resolved, opts) {
         return path;
     };
 }
-/** A resolver backed by the lean `mediaTargets` projection, for the admin preview. It mirrors
+/**
+ * A resolver backed by the lean `mediaTargets` projection, for the admin preview. It mirrors
  *  manifestLinkResolver: a hash present in the projection builds the slug delivery path
  *  (`/media/<slug>.<hash>.<ext>`); a miss returns undefined, so the render step marks the image
  *  broken rather than throwing. Pure over the projection, with no manifest and no config, so the
- *  edit page reaches it with the data it actually has. */
+ *  edit page reaches it with the data it actually has.
+ */
 export function manifestMediaResolver(targets) {
     return (ref) => {
         const entry = targets[ref.hash];
@@ -49,9 +53,11 @@ export function manifestMediaResolver(targets) {
         return publicPath(entry.slug, ref.hash, entry.ext, 'slug');
     };
 }
-/** Resolve media: image nodes against the VFile's resolver. A non-media src and a malformed token
+/**
+ * Resolve media: image nodes against the VFile's resolver. A non-media src and a malformed token
  *  pass through. A missing target is marked with the cairn-broken-media class (the resolver returns
- *  undefined) or, when the resolver throws, the error propagates and fails the build. */
+ *  undefined) or, when the resolver throws, the error propagates and fails the build.
+ */
 export function remarkResolveMedia() {
     return (tree, file) => {
         const resolve = file.data[MEDIA_RESOLVE];

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

@@ -21,6 +21,8 @@ export type AdminView = {
     view: 'media';
 } | {
     view: 'settings';
+} | {
+    view: 'help';
 };
 /**
  * Parse a raw `URL.pathname` (the caller passes `event.url.pathname`, never a SvelteKit rest

package/dist/sveltekit/admin-dispatch.js

@@ -3,10 +3,12 @@ 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`, `nav`, and `media` are decided as views below,
- * so they are not in this no-view set.
+ * segment wins before concept lookup. `nav` and `media` are decided as views below, so they are
+ * not in this no-view set. `settings` and `help` are decided as views below AND kept here, so a
+ * deeper path (or a future concept claiming the segment) can never reach the two-segment edit
+ * branch through them.
  */
-const RESERVED_SEGMENTS = new Set(['login', 'auth', 'editors', 'nav', 'settings']);
+const RESERVED_SEGMENTS = new Set(['login', 'auth', 'editors', 'nav', 'settings', 'help']);
 /**
  * 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
@@ -51,6 +53,10 @@ export function parseAdminPath(pathname, concepts) {
         // (the two-segment branch never matches settings), which is the correct shape.
         if (head === 'settings')
             return { view: 'settings' };
+        // help is its own view (the Help home, editor-help Pass 2), decided here like settings. It is
+        // also in the reserved set so /admin/help/<anything> 404s and no concept can claim the segment.
+        if (head === 'help')
+            return { view: 'help' };
         if (RESERVED_SEGMENTS.has(head))
             return null;
         const concept = findConcept(concepts, head);

package/dist/sveltekit/auth-routes.d.ts

@@ -19,6 +19,9 @@ export type RequestResult = {
     status: 'throttled';
     sent: false;
 };
+/**
+ *
+ */
 export declare function createAuthRoutes(config: AuthRoutesConfig): {
     loginLoad: (event: RequestContext) => {
         siteName: string;

package/dist/sveltekit/auth-routes.js

@@ -19,6 +19,9 @@ function scrubSendError(err) {
         .replace(/([?&]token=)[^&\s"'<]+/g, '$1[redacted]')
         .slice(0, 300);
 }
+/**
+ *
+ */
 export function createAuthRoutes(config) {
     const send = config.send ?? cloudflareSend;
     /**

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

@@ -1,4 +1,4 @@
-import { type ContentRoutesDeps, type LayoutData, type ListData, type EditData, type MediaLibraryData, type SettingsData } from './content-routes.js';
+import { type ContentRoutesDeps, type LayoutData, type ListData, type EditData, type MediaLibraryData, type SettingsData, type HelpData } 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';
@@ -14,15 +14,19 @@ 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
+/**
+ * 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. */
+ *  are the same seams the underlying factories take.
+ */
 export interface CairnAdminDeps {
     branding?: AuthBranding;
     send?: SendMagicLink;
     mintToken?: ContentRoutesDeps['mintToken'];
-    /** Build the Anthropic client for the tidy action. Forwarded to the content routes; a site that
-     *  enables tidy injects a stub here to avoid a real network call. Defaults to the real SDK client. */
+    /**
+     * Build the Anthropic client for the tidy action. Forwarded to the content routes; a site that
+     *  enables tidy injects a stub here to avoid a real network call. Defaults to the real SDK client.
+     */
     anthropic?: ContentRoutesDeps['anthropic'];
     /** The tidy action's own request deadline in milliseconds. Forwarded to the content routes. */
     tidyTimeoutMs?: ContentRoutesDeps['tidyTimeoutMs'];
@@ -74,7 +78,14 @@ export type AdminData = {
     view: 'settings';
     layout: LayoutData;
     page: SettingsData;
+} | {
+    view: 'help';
+    layout: LayoutData;
+    page: HelpData;
 };
+/**
+ *
+ */
 export declare function createCairnAdmin(runtime: CairnRuntime, deps?: CairnAdminDeps): {
     load: (event: AdminEvent) => Promise<AdminData>;
     actions: {

package/dist/sveltekit/cairn-admin.js

@@ -10,6 +10,9 @@ import { createAuthRoutes } from './auth-routes.js';
 import { createContentRoutes, } from './content-routes.js';
 import { createEditorRoutes } from './editors-routes.js';
 import { createNavRoutes } from './nav-routes.js';
+/**
+ *
+ */
 export function createCairnAdmin(runtime, deps = {}) {
     // The runtime already composes the site name and the sender identity, so the magic-link
     // branding needs no second copy of either unless a site overrides it.
@@ -27,11 +30,13 @@ export function createCairnAdmin(runtime, deps = {}) {
     const editors = createEditorRoutes();
     // The nav surface exists only when the site configures a menu; without one its view is a 404.
     const nav = runtime.navMenu ? createNavRoutes(runtime, { mintToken: deps.mintToken }) : null;
-    /** Build the event a wrapped content load reads. The catch-all route carries only a rest
+    /**
+     * Build the event a wrapped content load reads. The catch-all route carries only a rest
      *  param, so `concept` and `id` are synthesized from the parsed view. The override names
      *  each field explicitly rather than spreading: a real RequestEvent's fields can sit behind
      *  getters a bare spread copies poorly, and the structural ContentEvent contract needs only
-     *  these. */
+     *  these.
+     */
     function contentEvent(event, params) {
         return {
             url: event.url,
@@ -42,9 +47,11 @@ export function createCairnAdmin(runtime, deps = {}) {
             cookies: event.cookies,
         };
     }
-    /** Serve the admin view the pathname names, or a 404 for any shape the parser refuses.
+    /**
+     * Serve the admin view the pathname names, or a 404 for any shape the parser refuses.
      *  The authed views run the layout load and the view load concurrently; both mint a GitHub
-     *  token, and the installation-token cache coalesces the mints into one signing. */
+     *  token, and the installation-token cache coalesces the mints into one signing.
+     */
     async function load(event) {
         const view = parseAdminPath(event.url.pathname, runtime.concepts);
         if (!view)
@@ -91,11 +98,18 @@ export function createCairnAdmin(runtime, deps = {}) {
                 const [layout, page] = await Promise.all([content.layoutLoad(delegated), content.settingsLoad(delegated)]);
                 return { view: 'settings', layout, page };
             }
+            case 'help': {
+                const delegated = contentEvent(event, {});
+                const [layout, page] = await Promise.all([content.layoutLoad(delegated), content.helpLoad(delegated)]);
+                return { view: 'help', layout, page };
+            }
         }
     }
-    /** Wrap a delegate in the parse-and-check every action shares: parse the pathname exactly
+    /**
+     * Wrap a delegate in the parse-and-check every action shares: parse the pathname exactly
      *  as load does, 404 on a null parse or a view outside the allowed set, then hand the
-     *  narrowed view to the delegate. */
+     *  narrowed view to the delegate.
+     */
     function viewAction(allowed, delegate) {
         return async (event) => {
             const view = parseAdminPath(event.url.pathname, runtime.concepts);
@@ -106,13 +120,15 @@ export function createCairnAdmin(runtime, deps = {}) {
         };
     }
     // The topbar posts publishAll from every authed admin page; login and confirm may not.
-    const authedViews = ['list', 'edit', 'editors', 'nav', 'media', 'settings'];
+    const authedViews = ['list', 'edit', 'editors', 'nav', 'media', 'settings', 'help'];
     // An editor signs out from wherever they are, so logout accepts any parsed view.
-    const anyView = ['index', 'login', 'confirm', 'list', 'edit', 'editors', 'nav', 'media', 'settings'];
-    /** The full admin action vocabulary, one named async function per action, so a site's
+    const anyView = ['index', 'login', 'confirm', 'list', 'edit', 'editors', 'nav', 'media', 'settings', 'help'];
+    /**
+     * The full admin action vocabulary, one named async function per action, so a site's
      *  catch-all route exports `admin.actions` directly. Each wrapper stays thin: parse,
      *  validate the view, synthesize the params the wrapped action reads, delegate. The
-     *  editor actions gate themselves with requireOwner, so no second gate is added here. */
+     *  editor actions gate themselves with requireOwner, so no second gate is added here.
+     */
     const actions = {
         request: viewAction(['login'], (event) => auth.requestAction(event)),
         confirm: viewAction(['confirm'], (event) => auth.confirmAction(event)),