meno-core 1.0.47 → 1.0.49

package/lib/client/core/builders/localeListBuilder.ts

@@ -8,6 +8,7 @@ import type { ReactElement } from "react";
 import type { LocaleListNode, StyleObject, ResponsiveStyleObject, InteractiveStyles } from "../../../shared/types";
 import { extractAttributesFromNode } from "../../../shared/attributeNodeUtils";
 import { responsiveStylesToClasses } from "../../../shared/utilityClassMapper";
+import { getCachedResponsiveScalesConfig } from "../../responsiveStyleResolver";
 import { pathToString } from "../../../shared/pathArrayUtils";
 import { generateElementClassName, type ElementClassContext } from "../../../shared/elementClassName";
 import { InteractiveStylesRegistry } from "../../InteractiveStylesRegistry";
@@ -73,9 +74,16 @@ export function buildLocaleList(
   // Start building className
   let classNames: string[] = [];
 
+  // Resolve fluid mode once for all conversions in this builder
+  const scales = getCachedResponsiveScalesConfig();
+  const fluidActive = scales?.enabled === true && scales?.mode === 'fluid';
+
   // Convert container styles to utility classes
   if (node.style) {
-    const utilityClasses = responsiveStylesToClasses(node.style as StyleObject | ResponsiveStyleObject);
+    const utilityClasses = responsiveStylesToClasses(
+      node.style as StyleObject | ResponsiveStyleObject,
+      { fluidActive, responsiveScales: scales ?? undefined }
+    );
     UtilityClassCollector.collect(utilityClasses);
     classNames.push(...utilityClasses);
   }
@@ -123,7 +131,10 @@ export function buildLocaleList(
         const previewClasses: string[] = [];
         for (const rule of nodeInteractiveStyles) {
           if (rule.previewProp && ctx.componentResolvedProps[rule.previewProp] === true) {
-            const styleClasses = responsiveStylesToClasses(rule.style as StyleObject | ResponsiveStyleObject);
+            const styleClasses = responsiveStylesToClasses(
+              rule.style as StyleObject | ResponsiveStyleObject,
+              { fluidActive, responsiveScales: scales ?? undefined }
+            );
             UtilityClassCollector.collect(styleClasses);
             previewClasses.push(...styleClasses);
           }
@@ -169,10 +180,10 @@ export function buildLocaleList(
   const currentLocaleCode = locale || i18nConfig?.defaultLocale || 'en';
 
   // Convert item styles, active item styles, separator styles, and flag styles to utility classes
-  const itemClasses = node.itemStyle ? responsiveStylesToClasses(node.itemStyle as StyleObject | ResponsiveStyleObject) : [];
-  const activeItemClasses = node.activeItemStyle ? responsiveStylesToClasses(node.activeItemStyle as StyleObject | ResponsiveStyleObject) : [];
-  const separatorClasses = node.separatorStyle ? responsiveStylesToClasses(node.separatorStyle as StyleObject | ResponsiveStyleObject) : [];
-  const flagClasses = node.flagStyle ? responsiveStylesToClasses(node.flagStyle as StyleObject | ResponsiveStyleObject) : [];
+  const itemClasses = node.itemStyle ? responsiveStylesToClasses(node.itemStyle as StyleObject | ResponsiveStyleObject, { fluidActive, responsiveScales: scales ?? undefined }) : [];
+  const activeItemClasses = node.activeItemStyle ? responsiveStylesToClasses(node.activeItemStyle as StyleObject | ResponsiveStyleObject, { fluidActive, responsiveScales: scales ?? undefined }) : [];
+  const separatorClasses = node.separatorStyle ? responsiveStylesToClasses(node.separatorStyle as StyleObject | ResponsiveStyleObject, { fluidActive, responsiveScales: scales ?? undefined }) : [];
+  const flagClasses = node.flagStyle ? responsiveStylesToClasses(node.flagStyle as StyleObject | ResponsiveStyleObject, { fluidActive, responsiveScales: scales ?? undefined }) : [];
   UtilityClassCollector.collect(itemClasses);
   UtilityClassCollector.collect(activeItemClasses);
   UtilityClassCollector.collect(separatorClasses);

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/index.ts

@@ -66,7 +66,7 @@ export { buildStaticPages } from '../../build-static';
 export { buildAstroProject } from '../../build-astro';
 
 // Webflow export
-export { buildWebflowPayload } from './webflow';
+export { buildWebflowPayload, wrapInWebflowTemplate } from './webflow';
 export type {
   WebflowExportPayload,
   WebflowPage,

package/lib/server/jsonLoader.test.ts

@@ -5,13 +5,10 @@ import {
   mapPathToPageName,
   getBreakpointConfig,
   setBreakpointConfig,
-  getResponsiveScalesConfig,
-  setResponsiveScalesConfig,
   getI18nConfig,
   setI18nConfig,
 } from './jsonLoader';
 import { DEFAULT_BREAKPOINTS } from '../shared/breakpoints';
-import { DEFAULT_RESPONSIVE_SCALES } from '../shared/responsiveScaling';
 import { DEFAULT_I18N_CONFIG } from '../shared/i18n';
 
 describe('jsonLoader', () => {
@@ -76,20 +73,6 @@ describe('jsonLoader', () => {
     });
   });
 
-  describe('responsive scales config cache', () => {
-    test('returns default config initially', () => {
-      const config = getResponsiveScalesConfig();
-      expect(config.enabled).toBe(DEFAULT_RESPONSIVE_SCALES.enabled);
-    });
-
-    test('returns cached config after set', () => {
-      const customConfig = { enabled: true, baseReference: 20 };
-      setResponsiveScalesConfig(customConfig);
-      const config = getResponsiveScalesConfig();
-      expect(config.baseReference).toBe(20);
-    });
-  });
-
   describe('i18n config cache', () => {
     test('returns default config initially', () => {
       const config = getI18nConfig();

package/lib/server/jsonLoader.ts

@@ -9,8 +9,6 @@ import type { ComponentDefinition } from '../shared/types';
 import type { BreakpointConfig, BreakpointConfigInput, BreakpointEntry } from '../shared/breakpoints';
 import { readTextFile, fileExists } from './runtime';
 import { DEFAULT_BREAKPOINTS, normalizeBreakpointConfig } from '../shared/breakpoints';
-import type { ResponsiveScales, BreakpointScales } from '../shared/responsiveScaling';
-import { DEFAULT_RESPONSIVE_SCALES } from '../shared/responsiveScaling';
 import type { I18nConfig } from '../shared/types/components';
 import { DEFAULT_I18N_CONFIG, migrateI18nConfig } from '../shared/i18n';
 import type { PrefetchConfig } from '../shared/types/prefetch';
@@ -385,85 +383,6 @@ export function setBreakpointConfig(config: BreakpointConfig): void {
   cachedBreakpoints = config;
 }
 
-/**
- * Deep merge scale categories, preserving user-defined breakpoints
- * while filling in missing values from defaults
- */
-function mergeScaleCategory(
-  userScales: BreakpointScales | undefined,
-  defaultScales: BreakpointScales | undefined
-): BreakpointScales | undefined {
-  if (!userScales && !defaultScales) return undefined;
-  if (!userScales) return defaultScales ? { ...defaultScales } : undefined;
-  if (!defaultScales) return { ...userScales };
-
-  // User scales take precedence, but include defaults for breakpoints not specified
-  return {
-    ...defaultScales,
-    ...userScales,
-  };
-}
-
-/**
- * Load and validate responsive scales configuration from project.config.json
- * Supports dynamic breakpoints - scales are keyed by breakpoint name
- */
-export async function loadResponsiveScalesConfig(): Promise<ResponsiveScales> {
-  try {
-    const configContent = await loadJSONFile(projectPaths.config());
-    if (configContent) {
-      const config = parseJSON<{ responsiveScales?: Partial<ResponsiveScales> }>(configContent);
-
-      if (config.responsiveScales && typeof config.responsiveScales === 'object') {
-        // Deep merge scale categories to preserve user breakpoint definitions
-        // while filling in missing values from defaults
-        const scales: ResponsiveScales = {
-          enabled: config.responsiveScales.enabled ?? DEFAULT_RESPONSIVE_SCALES.enabled,
-          baseReference: config.responsiveScales.baseReference ?? DEFAULT_RESPONSIVE_SCALES.baseReference,
-          fontSize: mergeScaleCategory(
-            config.responsiveScales.fontSize as BreakpointScales | undefined,
-            DEFAULT_RESPONSIVE_SCALES.fontSize
-          ),
-          padding: mergeScaleCategory(
-            config.responsiveScales.padding as BreakpointScales | undefined,
-            DEFAULT_RESPONSIVE_SCALES.padding
-          ),
-          margin: mergeScaleCategory(
-            config.responsiveScales.margin as BreakpointScales | undefined,
-            DEFAULT_RESPONSIVE_SCALES.margin
-          ),
-          gap: mergeScaleCategory(
-            config.responsiveScales.gap as BreakpointScales | undefined,
-            DEFAULT_RESPONSIVE_SCALES.gap
-          ),
-        };
-
-        return scales;
-      }
-    }
-  } catch (error) {
-  }
-
-  return { ...DEFAULT_RESPONSIVE_SCALES };
-}
-
-/**
- * Get responsive scales config synchronously (for cases where async is not available)
- * Uses cached value if available, otherwise defaults
- */
-let cachedResponsiveScales: ResponsiveScales | null = null;
-
-export function getResponsiveScalesConfig(): ResponsiveScales {
-  if (cachedResponsiveScales) {
-    return cachedResponsiveScales;
-  }
-  return { ...DEFAULT_RESPONSIVE_SCALES };
-}
-
-export function setResponsiveScalesConfig(config: ResponsiveScales): void {
-  cachedResponsiveScales = config;
-}
-
 /**
  * Load and validate i18n configuration from project.config.json
  * Automatically migrates old string[] format to new LocaleConfig[] format

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();
+    });
+  });
+
 });