meno-core 1.0.48 → 1.0.49

package/lib/client/styles/StyleInjector.ts

@@ -12,7 +12,7 @@ import type { ComponentRegistry } from '../componentRegistry';
 import type { ElementRegistry } from '../elementRegistry';
 import { hasTemplates, processCodeTemplates } from '../templateEngine';
 import { generateAllInteractiveCSS } from '../../shared/cssGeneration';
-import { getCachedBreakpointConfig, getCachedRemConversionConfig } from '../responsiveStyleResolver';
+import { getCachedBreakpointConfig, getCachedRemConversionConfig, getCachedResponsiveScalesConfig } from '../responsiveStyleResolver';
 import { DEFAULT_BREAKPOINTS } from '../../shared/breakpoints';
 import { InteractiveStylesRegistry } from '../InteractiveStylesRegistry';
 import { UtilityClassCollector } from './UtilityClassCollector';
@@ -153,7 +153,8 @@ export class StyleInjector {
 
       const breakpointConfig = getCachedBreakpointConfig() || DEFAULT_BREAKPOINTS;
       const remConversionConfig = getCachedRemConversionConfig() || undefined;
-      const interactiveCSS = generateAllInteractiveCSS(interactiveStylesMap, breakpointConfig, remConversionConfig);
+      const responsiveScalesConfig = getCachedResponsiveScalesConfig() || undefined;
+      const interactiveCSS = generateAllInteractiveCSS(interactiveStylesMap, breakpointConfig, remConversionConfig, responsiveScalesConfig);
       if (!interactiveCSS) return;
 
       if (document.head) {

package/lib/client/theme.ts

@@ -77,9 +77,9 @@ const lightThemeColors: ThemeColors = {
     backgroundTertiary: '#eaeef2',
     border: '#d0d7de',
     borderSecondary: '#d1d5da',
-    text: '#24292e',
+    text: '#1a1a1a',
     textSecondary: '#586069',
-    textMuted: '#6a737d',
+    textMuted: '#525a63',
     codeString: '#032f62',
     codeNumber: '#005cc5',
     codeKey: '#005cc5',
@@ -125,9 +125,9 @@ const darkThemeColors: ThemeColors = {
     backgroundTertiary: '#252525',
     border: '#333333',
     borderSecondary: '#444444',
-    text: '#cccccc',
+    text: '#ebebeb',
     textSecondary: '#cccccc',
-    textMuted: '#888888',
+    textMuted: '#b0b0b0',
     codeString: '#ffffff',
     codeNumber: '#b5cea8',
     codeKey: '#9cdcfe',

package/lib/server/cssGenerator.test.ts

@@ -1,6 +1,8 @@
 import { describe, test, expect } from 'bun:test';
-import { generateColorVariablesCSS, generateThemeColorVariablesCSS } from './cssGenerator';
+import { generateColorVariablesCSS, generateThemeColorVariablesCSS, generateVariablesCSS } from './cssGenerator';
 import type { ColorVariables, ThemeConfig } from '../shared/types/colors';
+import type { ResponsiveScales } from '../shared/responsiveScaling';
+import { DEFAULT_BREAKPOINTS } from '../shared/breakpoints';
 
 describe('cssGenerator', () => {
   describe('generateColorVariablesCSS', () => {
@@ -169,4 +171,65 @@ describe('cssGenerator', () => {
       expect(css).toContain('\n\n');
     });
   });
+
+  describe('generateVariablesCSS — fluid mode', () => {
+    const fluidScales: ResponsiveScales = {
+      enabled: true,
+      mode: 'fluid',
+      baseReference: 16,
+      fluidRange: { min: 320, max: 1440 },
+      siteMargin: { min: 16, max: 32 },
+      fontSize: { tablet: 0.88, mobile: 0.75 },
+    };
+
+    test('emits --site-margin clamp on :root when fluid mode is enabled (no user vars)', () => {
+      const css = generateVariablesCSS(
+        { variables: [] },
+        DEFAULT_BREAKPOINTS,
+        fluidScales
+      );
+      expect(css).toContain('--site-margin: clamp(16px,');
+      expect(css).toContain(', 32px)');
+      expect(css).not.toContain('@media');
+    });
+
+
+    test('emits user variables with clamp() in fluid mode (no @media)', () => {
+      const css = generateVariablesCSS(
+        {
+          variables: [
+            { name: 'h1-fs', cssVar: '--h1-fs', value: '32px', type: 'fontSize' },
+          ],
+        },
+        DEFAULT_BREAKPOINTS,
+        fluidScales
+      );
+      // mobile fontSize scale=0.75 → MIN=28
+      expect(css).toContain('--h1-fs: clamp(28px,');
+      expect(css).toContain(', 32px)');
+      expect(css).not.toContain('@media');
+      // and the site-margin var still emitted
+      expect(css).toContain('--site-margin: clamp(16px,');
+    });
+
+    test('breakpoints mode (default) keeps @media blocks for vars and DOES NOT emit --site-margin', () => {
+      const css = generateVariablesCSS(
+        {
+          variables: [
+            { name: 'h1-fs', cssVar: '--h1-fs', value: '32px', type: 'fontSize' },
+          ],
+        },
+        DEFAULT_BREAKPOINTS,
+        { ...fluidScales, mode: 'breakpoints' }
+      );
+      expect(css).not.toContain('--site-margin');
+      expect(css).toContain('@media (max-width: 1024px)');
+      expect(css).not.toContain('clamp(');
+    });
+
+    test('returns empty string when no user vars AND fluid disabled', () => {
+      const css = generateVariablesCSS({ variables: [] }, DEFAULT_BREAKPOINTS);
+      expect(css).toBe('');
+    });
+  });
 });

package/lib/server/cssGenerator.ts

@@ -9,7 +9,14 @@ import { resolvePaletteColor } from '../shared/types/colors';
 import type { VariablesConfig, CSSVariable } from '../shared/types/variables';
 import type { BreakpointConfig } from '../shared/breakpoints';
 import type { ResponsiveScales, BreakpointScales } from '../shared/responsiveScaling';
-import { scalePropertyValue } from '../shared/responsiveScaling';
+import {
+  scalePropertyValue,
+  buildSiteMarginClamp,
+  buildFluidPropertyValue,
+  getSmallestBreakpointName,
+  DEFAULT_FLUID_RANGE,
+  DEFAULT_SITE_MARGIN,
+} from '../shared/responsiveScaling';
 
 /**
  * Generate CSS color variable declarations from color variables
@@ -75,18 +82,50 @@ export function generateVariablesCSS(
   breakpoints?: BreakpointConfig,
   responsiveScales?: ResponsiveScales
 ): string {
-  if (!config.variables || config.variables.length === 0) {
-    return '';
+  const cssBlocks: string[] = [];
+  const fluidActive =
+    responsiveScales?.enabled === true && responsiveScales?.mode === 'fluid';
+
+  // Build base :root block: user-defined variables + (in fluid mode) --site-margin.
+  // In fluid mode user variables get clamp() values directly on :root rather
+  // than @media overrides — so we run them through buildFluidPropertyValue here.
+  const fluidRange = responsiveScales?.fluidRange ?? DEFAULT_FLUID_RANGE;
+  const fluidBaseRef = responsiveScales?.baseReference || 16;
+  const smallestBp = fluidActive ? getSmallestBreakpointName(breakpoints) : null;
+
+  const baseVars: string[] = (config.variables ?? []).map(v => {
+    if (fluidActive && smallestBp && v.type !== 'none') {
+      const categoryScales = responsiveScales?.[v.type] as BreakpointScales | undefined;
+      const scale = categoryScales?.[smallestBp];
+      if (scale != null && scale !== 1) {
+        const fluid = buildFluidPropertyValue(
+          v.value,
+          scale,
+          fluidRange.min,
+          fluidRange.max,
+          fluidBaseRef
+        );
+        if (fluid) return `  ${v.cssVar}: ${fluid};`;
+      }
+    }
+    return `  ${v.cssVar}: ${v.value};`;
+  });
+
+  if (fluidActive) {
+    const siteMargin = responsiveScales?.siteMargin ?? DEFAULT_SITE_MARGIN;
+    baseVars.push(`  --site-margin: ${buildSiteMarginClamp(siteMargin, fluidRange)};`);
   }
 
-  const cssBlocks: string[] = [];
+  if (baseVars.length === 0) {
+    return '';
+  }
 
-  // Base :root block with all variables
-  const baseVars = config.variables.map(v => `  ${v.cssVar}: ${v.value};`);
   cssBlocks.push(`:root {\n${baseVars.join('\n')}\n}`);
 
-  // Generate @media blocks for responsive scaling
-  if (breakpoints && responsiveScales?.enabled) {
+  // Generate @media blocks for responsive scaling — only in breakpoints mode.
+  // In fluid mode all scaling is encoded in clamp() on the base :root block.
+  const userVariables = config.variables ?? [];
+  if (breakpoints && responsiveScales?.enabled && !fluidActive && userVariables.length > 0) {
     const baseRef = responsiveScales.baseReference || 16;
 
     // Sort breakpoints by value descending (largest first)
@@ -96,7 +135,7 @@ export function generateVariablesCSS(
     for (const [bpName, bpEntry] of sortedBreakpoints) {
       const scaledVars: string[] = [];
 
-      for (const variable of config.variables) {
+      for (const variable of userVariables) {
         // Per-variable override takes priority — stored string is the CSS value
         if (variable.scales && variable.scales[bpName]) {
           const overrideValue = variable.scales[bpName];

package/lib/server/providers/fileSystemCMSProvider.test.ts

@@ -341,5 +341,168 @@ describe('FileSystemCMSProvider', () => {
       const items = await provider.getItems('valid-collection');
       expect(items).toEqual([]);
     });
+
+    it('should reject filenames ending in reserved .draft suffix', async () => {
+      const item = { _id: '99', _filename: 'foo.draft', title: 'Sneaky', slug: 'foo' };
+      await expect(provider.saveItem('blog-posts', item))
+        .rejects.toThrow(/\.draft.*reserved/);
+      await expect(provider.deleteItem('blog-posts', 'foo.draft'))
+        .rejects.toThrow(/\.draft.*reserved/);
+      await expect(provider.getItemByFilename('blog-posts', 'foo.draft'))
+        .rejects.toThrow(/\.draft.*reserved/);
+    });
   });
+
+  describe('drafts', () => {
+    it('saveDraft writes a sibling .draft.json file and getDraft reads it back', async () => {
+      const draft = {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Hello World — WIP edits',
+        slug: 'hello-world',
+        content: 'Updated content (not yet published)',
+      };
+
+      await provider.saveDraft('blog-posts', draft);
+
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(true);
+
+      const read = await provider.getDraft('blog-posts', 'hello-world');
+      expect(read?.title).toBe('Hello World — WIP edits');
+      expect(read?._isDraft).toBe(true);
+    });
+
+    it('drafts do not appear in published-only queries (getItems, getItemByFilename)', async () => {
+      // Pre-existing item: hello-world (published). Add a draft for it.
+      await provider.saveDraft('blog-posts', {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Draft title',
+        slug: 'hello-world',
+      });
+
+      // Add a draft-only item (no published file)
+      await provider.saveDraft('blog-posts', {
+        _id: 'new-1',
+        _filename: 'brand-new',
+        title: 'Brand new draft',
+        slug: 'brand-new',
+      });
+
+      const items = await provider.getItems('blog-posts');
+      // Still only the two original published items
+      expect(items).toHaveLength(2);
+      expect(items.find(i => i._filename === 'brand-new')).toBeUndefined();
+      // hello-world's published title is unchanged
+      expect(items.find(i => i._filename === 'hello-world')?.title).toBe('Hello World');
+
+      const single = await provider.getItemByFilename('blog-posts', 'brand-new');
+      expect(single).toBeNull();
+    });
+
+    it('getAllDrafts returns drafts with _isDraft transient flag', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+      await provider.saveDraft('blog-posts', {
+        _id: 'new', _filename: 'brand-new', title: 'New', slug: 'brand-new',
+      });
+
+      const drafts = await provider.getAllDrafts('blog-posts');
+      expect(drafts).toHaveLength(2);
+      expect(drafts.every(d => d._isDraft === true)).toBe(true);
+      expect(drafts.map(d => d._filename).sort()).toEqual(['brand-new', 'hello-world']);
+    });
+
+    it('hasDraft reflects whether a draft file exists', async () => {
+      expect(await provider.hasDraft('blog-posts', 'hello-world')).toBe(false);
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+      expect(await provider.hasDraft('blog-posts', 'hello-world')).toBe(true);
+    });
+
+    it('discardDraft removes the draft file and is a no-op when none exists', async () => {
+      await expect(provider.discardDraft('blog-posts', 'hello-world')).resolves.toBeUndefined();
+
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(true);
+
+      await provider.discardDraft('blog-posts', 'hello-world');
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(false);
+      // Published file is untouched
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.json'))).toBe(true);
+    });
+
+    it('publishDraft promotes draft to published and removes the draft file', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Updated Title',
+        slug: 'hello-world',
+        content: 'New content',
+      });
+
+      const result = await provider.publishDraft('blog-posts', 'hello-world');
+      expect(result.title).toBe('Updated Title');
+
+      // Published file now has the new content
+      const item = await provider.getItemByFilename('blog-posts', 'hello-world');
+      expect(item?.title).toBe('Updated Title');
+      expect(item?.content).toBe('New content');
+
+      // Draft file is gone
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(false);
+    });
+
+    it('publishDraft of a draft-only item creates the published file', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: 'new', _filename: 'brand-new', title: 'New post', slug: 'brand-new',
+      });
+
+      const result = await provider.publishDraft('blog-posts', 'brand-new');
+      expect(result._filename).toBe('brand-new');
+
+      const items = await provider.getItems('blog-posts');
+      expect(items.find(i => i._filename === 'brand-new')?.title).toBe('New post');
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'brand-new.draft.json'))).toBe(false);
+    });
+
+    it('publishDraft throws when no draft exists', async () => {
+      await expect(provider.publishDraft('blog-posts', 'hello-world'))
+        .rejects.toThrow(/No draft to publish/);
+    });
+
+    it('deleteItem removes both published and draft files', async () => {
+      await provider.saveDraft('blog-posts', {
+        _id: '1', _filename: 'hello-world', title: 'WIP', slug: 'hello-world',
+      });
+
+      await provider.deleteItem('blog-posts', 'hello-world');
+
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.json'))).toBe(false);
+      expect(existsSync(join(CMS_DIR, 'blog-posts', 'hello-world.draft.json'))).toBe(false);
+    });
+
+    it('saveItem strips transient _isDraft / _hasDraft fields before writing', async () => {
+      const item = {
+        _id: '1',
+        _filename: 'hello-world',
+        title: 'Hello',
+        slug: 'hello-world',
+        _isDraft: true,
+        _hasDraft: true,
+      };
+      await provider.saveItem('blog-posts', item as any);
+
+      const { readFile } = await import('fs/promises');
+      const raw = await readFile(join(CMS_DIR, 'blog-posts', 'hello-world.json'), 'utf-8');
+      const parsed = JSON.parse(raw);
+      expect(parsed._isDraft).toBeUndefined();
+      expect(parsed._hasDraft).toBeUndefined();
+    });
+  });
+
 });

package/lib/server/providers/fileSystemCMSProvider.ts

@@ -7,10 +7,12 @@ import { existsSync, readdirSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import type { CMSProvider, CMSSchemaInfo } from '../../shared/interfaces/contentProvider';
 import type { CMSSchema, CMSItem } from '../../shared/types';
-import { validateCMSItem } from '../../shared/validation/validators';
-import { isSafePathSegment, isValidIdentifier } from '../../shared/pathSecurity';
+import { validateCMSItem, validateCMSDraftItem } from '../../shared/validation/validators';
+import { isSafePathSegment, isValidIdentifier, isReservedDraftFilename, CMS_DRAFT_SUFFIX } from '../../shared/pathSecurity';
 import { readJsonFile, fileExists } from '../runtime';
 
+const DRAFT_FILE_SUFFIX = `${CMS_DRAFT_SUFFIX}.json`;
+
 /**
  * Load JSON file content from disk
  * Logs a warning if JSON parsing fails (helps debug malformed files)
@@ -28,14 +30,25 @@ async function loadJSONFile(filePath: string): Promise<unknown | null> {
 }
 
 /**
- * Normalize a raw CMS item by adding _slug and _filename fields
+ * Normalize a raw CMS item by adding _slug and _filename fields.
+ * If `isDraft` is true, also sets the transient `_isDraft` flag.
  */
-function normalizeItem(content: unknown, filename: string): CMSItem {
-  return {
+function normalizeItem(content: unknown, filename: string, isDraft = false): CMSItem {
+  const base: CMSItem = {
     ...content as CMSItem,
     _slug: filename,
     _filename: filename,
   };
+  if (isDraft) base._isDraft = true;
+  return base;
+}
+
+/**
+ * Strip transient fields that must never be persisted to disk.
+ */
+function stripTransient<T extends Record<string, unknown>>(item: T): Omit<T, '_slug' | '_isDraft' | '_hasDraft' | '_url'> {
+  const { _slug, _isDraft, _hasDraft, _url, ...rest } = item;
+  return rest;
 }
 
 /**
@@ -61,13 +74,16 @@ export class FileSystemCMSProvider implements CMSProvider {
   }
 
   /**
-   * Validate filename to prevent path traversal attacks
+   * Validate filename to prevent path traversal attacks and reserved-suffix collisions.
    * @throws Error if filename is invalid
    */
   private validateFilename(filename: string): void {
     if (!isSafePathSegment(filename)) {
       throw new Error(`Invalid filename: "${filename}". Filenames cannot contain path separators or traversal sequences.`);
     }
+    if (isReservedDraftFilename(filename)) {
+      throw new Error(`Invalid filename: "${filename}". The "${CMS_DRAFT_SUFFIX}" suffix is reserved for draft files.`);
+    }
   }
 
   /**
@@ -131,7 +147,8 @@ export class FileSystemCMSProvider implements CMSProvider {
     }
 
     const files = readdirSync(collectionDir);
-    const jsonFiles = files.filter(f => f.endsWith('.json'));
+    // Published items only — exclude `*.draft.json` files (draft-version siblings)
+    const jsonFiles = files.filter(f => f.endsWith('.json') && !f.endsWith(DRAFT_FILE_SUFFIX));
 
     const results = await Promise.all(
       jsonFiles.map(async file => {
@@ -241,27 +258,199 @@ export class FileSystemCMSProvider implements CMSProvider {
       mkdirSync(collectionDir, { recursive: true });
     }
 
-    // Remove internal _slug field before saving (keep _filename in file for persistence)
-    const { _slug, ...itemData } = item;
+    // Strip transient fields (_slug, _isDraft, _hasDraft, _url) before persisting
+    const itemData = stripTransient(item as Record<string, unknown>);
 
     const filePath = join(collectionDir, `${filename}.json`);
     await writeFile(filePath, JSON.stringify(itemData, null, 2), 'utf-8');
   }
 
   /**
-   * Delete item by filename (or slug for backward compat)
+   * Delete item by filename. Removes the published file AND any draft sibling.
    */
   async deleteItem(collection: string, filename: string): Promise<void> {
     this.validateCollection(collection);
     this.validateFilename(filename);
     const { unlink } = await import('fs/promises');
-    const filePath = join(this.cmsDir, collection, `${filename}.json`);
 
+    const publishedPath = join(this.cmsDir, collection, `${filename}.json`);
+    if (existsSync(publishedPath)) {
+      await unlink(publishedPath);
+    }
+
+    const draftPath = this.draftPath(collection, filename);
+    if (existsSync(draftPath)) {
+      await unlink(draftPath);
+    }
+  }
+
+  // ---- Draft helpers ----------------------------------------------------
+
+  private draftPath(collection: string, filename: string): string {
+    return join(this.cmsDir, collection, `${filename}${DRAFT_FILE_SUFFIX}`);
+  }
+
+  /**
+   * Get the draft version of an item, or null if no draft file exists.
+   * Drafts skip strict validation — they may be partial / WIP.
+   */
+  async getDraft(collection: string, filename: string): Promise<CMSItem | null> {
+    this.validateCollection(collection);
+    this.validateFilename(filename);
+    const filePath = this.draftPath(collection, filename);
+    const content = await loadJSONFile(filePath);
+
+    if (!content || typeof content !== 'object') {
+      return null;
+    }
+
+    return normalizeItem(content, filename, /*isDraft*/ true);
+  }
+
+  /**
+   * List all drafts in a collection. Used by the Studio item list to mark
+   * items that have an outstanding draft sibling (or are draft-only).
+   */
+  async getAllDrafts(collection: string): Promise<CMSItem[]> {
+    this.validateCollection(collection);
+    const collectionDir = join(this.cmsDir, collection);
+    if (!existsSync(collectionDir)) return [];
+
+    const files = readdirSync(collectionDir).filter(f => f.endsWith(DRAFT_FILE_SUFFIX));
+
+    const results = await Promise.all(
+      files.map(async file => {
+        const filePath = join(collectionDir, file);
+        const content = await loadJSONFile(filePath);
+        return { file, content };
+      })
+    );
+
+    const drafts: CMSItem[] = [];
+    for (const { file, content } of results) {
+      if (content && typeof content === 'object') {
+        const filename = file.slice(0, -DRAFT_FILE_SUFFIX.length);
+        drafts.push(normalizeItem(content, filename, /*isDraft*/ true));
+      }
+    }
+    return drafts;
+  }
+
+  async hasDraft(collection: string, filename: string): Promise<boolean> {
+    this.validateCollection(collection);
+    this.validateFilename(filename);
+    return existsSync(this.draftPath(collection, filename));
+  }
+
+  /**
+   * Save the draft version of an item. Loose validation — drafts may have
+   * missing required fields or partial data. Strict validation only runs at
+   * publish time. The item's `_filename` determines the target file.
+   */
+  async saveDraft(collection: string, item: CMSItem): Promise<void> {
+    this.validateCollection(collection);
+    const { writeFile } = await import('fs/promises');
+
+    const schemas = await this.getAllSchemas();
+    const schemaInfo = schemas.get(collection);
+    if (!schemaInfo) {
+      throw new Error(`Unknown collection: ${collection}`);
+    }
+
+    let filename: string;
+    if (item._filename) {
+      filename = item._filename;
+    } else {
+      const slugField = schemaInfo.schema.slugField;
+      const slugValue = item[slugField];
+      filename = typeof slugValue === 'string' ? slugValue : String(slugValue);
+    }
+
+    if (!filename || filename === '[object Object]') {
+      throw new Error('Missing _filename field. Drafts must have _filename set on creation.');
+    }
+
+    this.validateFilename(filename);
+
+    const collectionDir = join(this.cmsDir, collection);
+    if (!existsSync(collectionDir)) {
+      mkdirSync(collectionDir, { recursive: true });
+    }
+
+    const itemData = stripTransient(item as Record<string, unknown>);
+
+    // Loose validation — drafts may be partial WIP. Strict validation
+    // (validateCMSItem) runs on Publish.
+    const validation = validateCMSDraftItem(itemData);
+    if (!validation.valid) {
+      const messages = validation.errors.map(e => `${e.path}: ${e.message}`).join(', ');
+      throw new Error(`Invalid draft: ${messages}`);
+    }
+
+    const filePath = this.draftPath(collection, filename);
+    await writeFile(filePath, JSON.stringify(itemData, null, 2), 'utf-8');
+  }
+
+  /**
+   * Discard the draft version of an item. No-op if no draft exists.
+   */
+  async discardDraft(collection: string, filename: string): Promise<void> {
+    this.validateCollection(collection);
+    this.validateFilename(filename);
+    const { unlink } = await import('fs/promises');
+    const filePath = this.draftPath(collection, filename);
     if (existsSync(filePath)) {
       await unlink(filePath);
     }
   }
 
+  /**
+   * Promote a draft to published. Reads `{filename}.draft.json`, writes the
+   * content to `{filename}.json`, then unlinks the draft. The published write
+   * happens first so a crash mid-operation leaves a valid published file plus
+   * an orphan draft (recoverable via the editor's Discard button) — never a
+   * gap with no published content.
+   *
+   * Throws if no draft exists.
+   */
+  async publishDraft(collection: string, filename: string): Promise<CMSItem> {
+    this.validateCollection(collection);
+    this.validateFilename(filename);
+    const { writeFile, unlink } = await import('fs/promises');
+
+    const draftFilePath = this.draftPath(collection, filename);
+    const content = await loadJSONFile(draftFilePath);
+    if (!content || typeof content !== 'object') {
+      throw new Error(`No draft to publish for ${collection}/${filename}`);
+    }
+
+    // Strict validation when going live
+    const item = normalizeItem(content, filename);
+    const validation = validateCMSItem(item);
+    if (!validation.valid) {
+      const messages = validation.errors.map(e => `${e.path}: ${e.message}`).join(', ');
+      throw new Error(`Cannot publish invalid draft: ${messages}`);
+    }
+
+    const collectionDir = join(this.cmsDir, collection);
+    if (!existsSync(collectionDir)) {
+      mkdirSync(collectionDir, { recursive: true });
+    }
+
+    const itemData = stripTransient(validation.data as unknown as Record<string, unknown>);
+    const publishedPath = join(collectionDir, `${filename}.json`);
+    await writeFile(publishedPath, JSON.stringify(itemData, null, 2), 'utf-8');
+
+    // Published written successfully — now retire the draft. If unlink fails,
+    // the published copy is already in place; an orphan draft can be cleared
+    // via the editor's Discard action.
+    if (existsSync(draftFilePath)) {
+      await unlink(draftFilePath);
+    }
+
+    return normalizeItem(itemData, filename);
+  }
+
   /**
    * Clear schema cache (useful when pages are modified)
    */

package/lib/server/routes/index.ts

@@ -141,7 +141,7 @@ export async function handleRoutes(
 
     // Page routes (SSR)
     if (url.pathname === '/' || (url.pathname.startsWith('/') && !url.pathname.includes('.'))) {
-      const response = await handlePageRoute(url, context);
+      const response = await handlePageRoute(url, context, req);
       logResponseTime(startTime, req);
       return response;
     }