@glw907/cairn-cms 0.55.0 → 0.56.0

package/dist/content/types.d.ts

@@ -92,6 +92,8 @@ export interface ConceptConfig<S extends ConceptSchema = ConceptSchema> {
     dir: string;
     /** Sidebar label; defaults from the concept id when omitted. */
     label?: string;
+    /** The singular noun for the create affordances ("New post"); defaults to `label` when omitted. */
+    singular?: 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
@@ -221,6 +223,9 @@ export interface ConceptDescriptor {
     /** Concept id, the key under `content`, e.g. "posts". */
     id: string;
     label: string;
+    /** The singular noun for the create affordances ("New post"); resolved from `ConceptConfig.singular`,
+     *  defaulting to `label` when the config omits it. */
+    singular: string;
     dir: string;
     routing: RoutingRule;
     /** The resolved permalink pattern, defaulted by `normalizeConcepts`. */

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

@@ -52,6 +52,9 @@ export interface EntrySummary {
 export interface ListData {
     conceptId: string;
     label: string;
+    /** The singular noun for the create affordances ("New post"); from the descriptor, which defaults
+     *  it to `label`. */
+    singular: string;
     /** Posts carry a date in the new-entry form; pages do not (concept routing, spec §7.2). */
     dated: boolean;
     entries: EntrySummary[];

package/dist/sveltekit/content-routes.js

@@ -154,7 +154,7 @@ export function createContentRoutes(runtime, deps = {}) {
         const formError = event.url.searchParams.get('error');
         const publishedAllRaw = event.url.searchParams.get('publishedAll');
         const publishedAll = publishedAllRaw !== null && /^\d+$/.test(publishedAllRaw) ? Number(publishedAllRaw) : null;
-        const base = { conceptId: concept.id, label: concept.label, dated: concept.routing.dated, formError, publishedAll };
+        const base = { conceptId: concept.id, label: concept.label, singular: concept.singular, dated: concept.routing.dated, formError, publishedAll };
         let token;
         try {
             token = await mintToken(event.platform?.env ?? {});

package/dist/sveltekit/index.d.ts

@@ -10,3 +10,4 @@ export { createCairnAdmin, type CairnAdminDeps, type AdminData } from './cairn-a
 export { healthLoad, type HealthData } from './health.js';
 export type { RequestContext, CookieJar, HandleInput } from './types.js';
 export type { GithubKeyEnv } from '../github/credentials.js';
+export type { AuthEnv } from '../auth/types.js';

package/dist/vite/index.d.ts

@@ -25,10 +25,12 @@ export declare function buildManifestFromVite(opts: CairnManifestOptions, root:
  *  buildStart, evaluates it through a nested Vite SSR load so a manifest drift fails the build. */
 export declare function cairnManifest(opts: CairnManifestOptions): 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. */
+ *  manifestPath. It searches for the consumer's Vite config from `cwd`, derives the authoritative
+ *  Vite root from the loaded config (so a configured `root` or a non-root cwd resolves correctly),
+ *  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 under the Vite
+ *  root. The cairn-manifest bin calls this; it is exported so the write logic is testable apart
+ *  from the CLI shell. */
 export declare function writeManifest(cwd?: string): Promise<void>;
 /** The repo and sender facts cairn-doctor derives off the consumer's adapter. */
 export interface AdapterFacts {

package/dist/vite/index.js

@@ -1,5 +1,6 @@
 import { writeFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { resolveViteRoot } from './resolve-root.js';
 /** 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');
@@ -121,10 +122,12 @@ export function cairnManifest(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. */
+ *  manifestPath. It searches for the consumer's Vite config from `cwd`, derives the authoritative
+ *  Vite root from the loaded config (so a configured `root` or a non-root cwd resolves correctly),
+ *  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 under the Vite
+ *  root. 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);
@@ -135,11 +138,12 @@ export async function writeManifest(cwd = process.cwd()) {
     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 root = resolveViteRoot(loaded, cwd);
+    const serialized = await buildManifestFromVite(opts, root);
     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(/^\//, ''));
+    // against the Vite root, not the filesystem root or the config-search cwd.
+    const outPath = join(root, manifestPath.replace(/^\//, ''));
     await mkdir(dirname(outPath), { recursive: true });
     await writeFile(outPath, serialized);
 }

package/dist/vite/resolve-root.d.ts

@@ -0,0 +1,16 @@
+/** The shape of `loadConfigFromFile`'s result that the root derivation reads: the config file's own
+ *  path and its `root` field. Typed structurally so the helper is testable without a real load. */
+export interface LoadedViteConfig {
+    /** The resolved path of the config file Vite loaded. */
+    path: string;
+    /** The user config, of which only `root` is read here. */
+    config: {
+        root?: string;
+    };
+}
+/** The authoritative Vite root for the manifest bin, derived from the loaded config the way Vite
+ *  resolves a relative `root`: against the config file's own directory, not cwd. An absolute `root`
+ *  stands as given, and no `root` falls back to `cwd` (the directory the bin was run from). This
+ *  separates the config-search dir (cwd) from the Vite root, so a non-root cwd or a config that
+ *  sets `root` reads and writes the manifest under the real app root. */
+export declare function resolveViteRoot(loaded: LoadedViteConfig, cwd: string): string;

package/dist/vite/resolve-root.js

@@ -0,0 +1,16 @@
+// The manifest bin's root derivation, split out so it is unit-testable without widening the public
+// /vite surface (only src/lib/vite/index.ts is the package subpath; this sibling is internal).
+import { dirname, isAbsolute, resolve } from 'node:path';
+/** The authoritative Vite root for the manifest bin, derived from the loaded config the way Vite
+ *  resolves a relative `root`: against the config file's own directory, not cwd. An absolute `root`
+ *  stands as given, and no `root` falls back to `cwd` (the directory the bin was run from). This
+ *  separates the config-search dir (cwd) from the Vite root, so a non-root cwd or a config that
+ *  sets `root` reads and writes the manifest under the real app root. */
+export function resolveViteRoot(loaded, cwd) {
+    const root = loaded.config.root;
+    if (!root)
+        return cwd;
+    if (isAbsolute(root))
+        return root;
+    return resolve(dirname(loaded.path), root);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glw907/cairn-cms",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "description": "Embedded, magic-link, GitHub-committing CMS for SvelteKit/Cloudflare sites.",
   "type": "module",
   "sideEffects": [
@@ -29,6 +29,7 @@
     "package": "svelte-package && node scripts/build-admin-css.mjs && chmod +x dist/vite/bin.js dist/doctor/bin.js",
     "check:package": "npm run package && publint --strict && attw --pack . --ignore-rules no-resolution cjs-resolves-to-esm internal-resolution-error",
     "check:reference": "npm run package && node scripts/reference-coverage.mjs",
+    "check:reference:signatures": "npm run package && node scripts/check-reference-signatures.mjs",
     "check:readiness": "npm run package && node scripts/check-readiness.mjs",
     "check:docs": "node scripts/docs-links.mjs",
     "check:prose": "node scripts/check-admin-prose.mjs",

package/src/lib/components/ConceptList.svelte

@@ -183,6 +183,10 @@ header button. Filtering, sorting, and paging run over the loaded entries in com
   });
   const derivedSlug = $derived(slugEdited ? slug : slugify(title));
   const slugPlaceholder = $derived(data.dated ? 'my-entry' : 'about-us');
+  // The create affordances name one new item, so they read in the singular ("New post"). The
+  // descriptor resolves `singular` (defaulting it to the label), so the fallback here only guards an
+  // older caller that ships no `singular` on its ListData.
+  const createNoun = $derived(data.singular ?? data.label);
 
   // Shared column-header typography: small uppercase muted labels. The sort buttons add their own
   // flex layout and a hover affordance on top of this.
@@ -212,7 +216,7 @@ header button. Filtering, sorting, and paging run over the loaded entries in com
       <input type="search" aria-label="Search {data.label}" bind:value={query} placeholder="Search {data.label.toLowerCase()}" oninput={() => (page = 1)} />
     </label>
     <button type="button" class="btn btn-primary btn-sm shrink-0" aria-haspopup="dialog" onclick={() => createDialog?.showModal()}>
-      <PlusIcon class="h-4 w-4" /> New {data.label}
+      <PlusIcon class="h-4 w-4" /> New {createNoun}
     </button>
   </div>
 </header>
@@ -280,7 +284,7 @@ header button. Filtering, sorting, and paging run over the loaded entries in com
       <p class="text-sm text-[var(--color-muted)]">Stack your first one and it will show up here.</p>
     </div>
     <button type="button" class="btn btn-primary btn-sm" aria-haspopup="dialog" onclick={() => createDialog?.showModal()}>
-      <PlusIcon class="h-4 w-4" /> New {data.label}
+      <PlusIcon class="h-4 w-4" /> New {createNoun}
     </button>
   </div>
 {:else}
@@ -367,7 +371,7 @@ header button. Filtering, sorting, and paging run over the loaded entries in com
            short list always shows its next step rather than just stopping. Same action as the
            header New button. -->
       <button type="button" class="flex w-full items-center gap-2 border-t border-[var(--cairn-card-border)] px-6 py-3 text-sm font-medium text-primary hover:bg-primary/[0.06]" aria-haspopup="dialog" onclick={() => createDialog?.showModal()}>
-        <PlusIcon class="h-4 w-4" /> New {data.label}
+        <PlusIcon class="h-4 w-4" /> New {createNoun}
       </button>
     {/if}
   </div>
@@ -399,7 +403,7 @@ header button. Filtering, sorting, and paging run over the loaded entries in com
 <dialog class="modal" aria-labelledby="cairn-create-dialog-title" bind:this={createDialog}>
   <div class="modal-box">
     <div class="mb-3 flex items-center justify-between">
-      <h2 id="cairn-create-dialog-title" class="text-base font-semibold">New {data.label}</h2>
+      <h2 id="cairn-create-dialog-title" class="text-base font-semibold">New {createNoun}</h2>
       <button type="button" class="btn btn-ghost btn-sm" aria-label="Close" onclick={() => createDialog?.close()}>✕</button>
     </div>
     <form method="POST" action="?/create" onsubmit={() => (creating = true)} class="flex flex-col gap-3">

package/src/lib/components/MarkdownEditor.svelte

@@ -100,23 +100,20 @@ through the adapter's render. Swapping the editor stays a one-file change.
       `color-mix(in oklab, var(--color-accent) var(--cairn-directive-rail-${step}, ${fallback}), transparent)`;
     // With `active`, the row's own (deepest) bar takes the full-strength -active mix at the same
     // 2px width. The emphasis is strength only: a rail column carrying both an active and a
-    // quiet segment (two sibling containers at one depth) keeps one weight top to bottom.
-    // With `dropInnermost`, the row's own deepest bar is omitted: a fold chevron replaces it on a
-    // paired opener row, so the bar would double the chevron's positional cue. The outer bars and
-    // their spacers stay, so the nesting still reads.
-    const rails = (depth: number, active = false, dropInnermost = false): string => {
+    // quiet segment (two sibling containers at one depth) keeps one weight top to bottom. A paired
+    // opener row paints its full rail like any other fence row; the fold chevron lives in the gutter
+    // column left of the rails, so the opener no longer drops its innermost bar.
+    const rails = (depth: number, active = false): string => {
       const layers: string[] = [];
       for (let d = 1; d <= depth; d++) {
         const edge = 8 * d - 6;
         if (d > 1) layers.push(`inset ${edge - 2}px 0 0 0 var(--color-base-100, oklch(99% 0.004 75))`);
-        if (dropInnermost && d === depth) continue;
         const own = active && d === depth;
         layers.push(
           `inset ${edge}px 0 0 0 ${own ? railColor('active', '100%') : railColor(d, railFallbacks[d - 1] ?? '92%')}`,
         );
       }
-      // A depth-1 opener drops its only bar, so the row paints no rail at all.
-      return layers.length ? layers.join(', ') : 'none';
+      return layers.join(', ');
     };
     const directiveInk = {
       backgroundColor: 'color-mix(in oklab, var(--color-accent) 8%, transparent)',
@@ -132,14 +129,6 @@ through the adapter's render. Swapping the editor stays a one-file change.
         `${prefix}.cm-cairn-directive-fence.cm-cairn-depth-${depth}, ${prefix}.cm-cairn-directive-content.cm-cairn-depth-${depth}`;
       railRules[row('')] = { boxShadow: rails(depth) };
       railRules[row('.cm-cairn-caret-block')] = { boxShadow: rails(depth, true) };
-      // A paired opener row drops its own innermost bar (the fold chevron stands in its place),
-      // both quiet and caret-active. The extra opener class outranks the base fence rule above.
-      railRules[`.cm-cairn-directive-fence.cm-cairn-directive-opener.cm-cairn-depth-${depth}`] = {
-        boxShadow: rails(depth, false, true),
-      };
-      railRules[`.cm-cairn-caret-block.cm-cairn-directive-opener.cm-cairn-depth-${depth}`] = {
-        boxShadow: rails(depth, true, true),
-      };
     }
     const theme = EditorView.theme(
       {
@@ -199,39 +188,67 @@ through the adapter's render. Swapping the editor stays a one-file change.
         },
         '.cm-cairn-directive-leaf': directiveInk,
         '.cm-cairn-directive-inline': directiveInk,
-        // Container folding. The fold band is the 28px gutter click target on an opener row; the
-        // line is the positioning context so the chevron sits over the container's own bar x. The
-        // band is laid over the gutter (a zero-width inline widget at line start, expanded by the
-        // absolute children), so only the gutter shows the pointer cursor, never the opener text.
-        '.cm-line:has(.cm-cairn-fold-band)': { position: 'relative' },
-        '.cm-cairn-fold-band': {
-          position: 'absolute',
-          left: '0',
-          top: '0',
-          width: '28px',
-          height: '100%',
+        // Container folding lives in a real gutter column now, not an in-text band. The gutter is a
+        // fixed-x column left of the content; the chevron is empty at rest and reveals on hovering
+        // the gutter cell (the VS Code / Zed / Obsidian standard), forced on when folded or when the
+        // caret is inside the container. One rotating chevron in the directive ink; the rails carry
+        // depth, so the ink does not restep. The lone gutter's wrapper loses its default background
+        // and border so the column blends into the quiet surface.
+        // Neutralize the gutter wrapper so the column blends in. This assumes the fold gutter is the
+        // only gutter (it is today: no lineNumbers or foldGutter in the build); a future line-number
+        // or lint gutter would need its own chrome and a narrower selector here.
+        '.cm-gutters': { backgroundColor: 'transparent', border: '0', color: 'inherit' },
+        // 24px wide so the cell clears the WCAG 2.5.8 target-size floor unconditionally.
+        '.cm-cairn-fold-gutter': { width: '24px' },
+        '.cm-cairn-fold-gutter .cm-gutterElement': { display: 'flex', alignItems: 'stretch', padding: '0' },
+        '.cm-cairn-fold-btn': {
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          width: '100%',
+          padding: '0',
+          background: 'transparent',
+          border: '0',
           cursor: 'pointer',
-          zIndex: '1',
+          color: 'var(--cairn-directive-ink-2, oklch(50% 0.16 300))',
         },
-        '.cm-cairn-fold-band svg': {
-          position: 'absolute',
-          top: '50%',
-          transform: 'translateY(-50%)',
+        '.cm-cairn-fold-btn svg': {
           width: '11px',
           height: '11px',
-          // The chevron fades in on rail-band hover; folded and caret-inside states force it on.
+          // Empty at rest; the gutter-cell hover, the folded state, and the caret-active state each
+          // force it on. A 120ms fade in and out, and a 120ms rotate for the folded turn.
           opacity: '0',
-          transition: 'opacity 120ms ease',
-          color: 'var(--cairn-directive-ink-2, oklch(50% 0.16 300))',
+          transition: 'opacity 120ms ease, transform 120ms ease',
+        },
+        // Reveal on gutter-cell hover, on the folded and caret-active states, and on keyboard focus
+        // so a focused control shows its glyph, not just the ring.
+        '.cm-cairn-fold-gutter .cm-gutterElement:hover .cm-cairn-fold-btn svg, .cm-cairn-fold-btn:focus-visible svg, .cm-cairn-fold-folded svg, .cm-cairn-fold-active svg':
+          { opacity: '1' },
+        // Folded rotates the single chevron to point right; caret-active takes the stronger ink.
+        '.cm-cairn-fold-folded svg': { transform: 'rotate(-90deg)' },
+        '.cm-cairn-fold-active': { color: 'var(--cairn-directive-ink-active, oklch(46% 0.16 300))' },
+        // A visible focus ring for keyboard users landing on the gutter button or the pill, reusing
+        // the surface hairline's 70% primary mix (3:1+ non-text contrast on both themes).
+        '.cm-cairn-fold-btn:focus-visible': {
+          outline: '2px solid color-mix(in oklab, var(--color-primary) 70%, transparent)',
+          outlineOffset: '-2px',
+          borderRadius: '4px',
+        },
+        '.cm-cairn-fold-pill:focus-visible': {
+          outline: '2px solid color-mix(in oklab, var(--color-primary) 70%, transparent)',
+          outlineOffset: '1px',
+        },
+        // No-hover pointers (touch) cannot reveal on hover, so the rest-state chevron is persistent
+        // and legible. Scoped to the rest state (not folded, not caret-active) so those forced-on
+        // states still read at full strength on touch rather than this rule clamping them to 0.65.
+        '@media (hover: none)': {
+          '.cm-cairn-fold-btn:not(.cm-cairn-fold-folded):not(.cm-cairn-fold-active) svg': { opacity: '0.65' },
         },
-        '.cm-cairn-fold-band:hover svg, .cm-cairn-fold-folded svg, .cm-cairn-fold-active svg': {
-          opacity: '1',
+        // Respect a reduced-motion preference: drop the chevron fade/rotate and the unfold flash.
+        '@media (prefers-reduced-motion: reduce)': {
+          '.cm-cairn-fold-btn svg': { transition: 'none' },
+          '.cm-cairn-fold-flash': { transition: 'none' },
         },
-        // The chevron steps its ink with the container's depth, matching the label inks; the
-        // caret-inside state takes the strongest ink.
-        '.cm-cairn-fold-depth-1 svg': { color: 'var(--color-accent)' },
-        '.cm-cairn-fold-depth-3 svg': { color: 'var(--cairn-directive-ink-3, oklch(48% 0.16 300))' },
-        '.cm-cairn-fold-active svg': { color: 'var(--cairn-directive-ink-active, oklch(46% 0.16 300))' },
         // The folded-row wash: a soft accent tint, square and full-row, returning as a STATE signal
         // so folded spots read in a scan. The rails are inset box-shadows on the same line element
         // and render above this background, so the rail column runs through the wash unbroken.
@@ -274,9 +291,11 @@ through the adapter's render. Swapping the editor stays a one-file change.
           color: 'var(--cairn-focus-dim-ink, oklch(66% 0.01 75))',
           backgroundColor: 'transparent',
         },
-        // The fold machinery dims with its row: a folded opener row under focus mode drops its
-        // chevron, pill, and wash to the dim tone like any other machinery line.
-        '.cm-cairn-focus-dim .cm-cairn-fold-band svg, .cm-cairn-focus-dim .cm-cairn-fold-pill': {
+        // The fold pill dims with its folded opener row like any machinery line (the pill is a
+        // widget inside the line). The gutter chevron lives in a separate DOM column that focus-dim
+        // cannot reach by descendant selector, and it is already hidden at rest and forced visible
+        // only when folded or caret-active, so a folded chevron stays findable without a dim rule.
+        '.cm-cairn-focus-dim .cm-cairn-fold-pill': {
           color: 'var(--cairn-focus-dim-ink, oklch(66% 0.01 75))',
         },
         '.cm-cairn-focus-dim.cm-cairn-folded-row': { backgroundColor: 'transparent' },