foundrycms 0.1.0

package/dist/__tests__/foundry.test.js

@@ -0,0 +1,1013 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { z } from 'zod';
+import { 
+// Plugin system
+PluginRegistry, 
+// Hook system
+HookEngine, 
+// Config manager
+ConfigManager, 
+// Element registry
+ElementRegistry, 
+// Template studio
+TemplateStudio, registerDefaultTemplates, 
+// Page serializer
+serializePage, deserializePage, validatePageData, 
+// Page renderer
+renderPage, renderRow, renderColumn, renderElement, escapeHtml, escapeAttr, registerDefaultElements, 
+// Factory functions
+createFoundry, createFoundryWithDefaults, } from '../index.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makePlugin(overrides = {}) {
+    return {
+        id: overrides.id ?? 'test-plugin',
+        name: overrides.name ?? 'Test Plugin',
+        version: overrides.version ?? '1.0.0',
+        description: overrides.description ?? 'A test plugin',
+        ...overrides,
+    };
+}
+function makeElement(overrides = {}) {
+    return {
+        type: overrides.type ?? 'test-element',
+        name: overrides.name ?? 'Test Element',
+        category: overrides.category ?? 'content',
+        icon: overrides.icon ?? 'T',
+        description: overrides.description ?? 'A test element',
+        defaultSettings: overrides.defaultSettings ?? { text: 'hello' },
+        settingsSchema: overrides.settingsSchema ?? z.object({ text: z.string() }),
+        render: overrides.render ?? ((s) => `<p>${s.text}</p>`),
+        keywords: overrides.keywords,
+    };
+}
+function makeMinimalPageData(overrides = {}) {
+    return {
+        id: 'page-1',
+        title: 'Test Page',
+        slug: 'test-page',
+        status: 'draft',
+        template: 'default',
+        content: [],
+        meta: {},
+        createdAt: new Date('2025-01-01'),
+        updatedAt: new Date('2025-01-02'),
+        ...overrides,
+    };
+}
+function makeTemplate(overrides = {}) {
+    return {
+        id: overrides.id ?? 'test-template',
+        name: overrides.name ?? 'Test Template',
+        category: overrides.category ?? 'hero',
+        description: overrides.description ?? 'A test section template',
+        content: overrides.content ?? [
+            {
+                id: 'row-1',
+                type: 'row',
+                settings: { layout: 'boxed' },
+                columns: [],
+            },
+        ],
+    };
+}
+// ===========================================================================
+// 1. Plugin System
+// ===========================================================================
+describe('PluginRegistry', () => {
+    let hooks;
+    let config;
+    let plugins;
+    beforeEach(() => {
+        hooks = new HookEngine();
+        config = new ConfigManager(hooks);
+        plugins = new PluginRegistry(hooks, config);
+    });
+    describe('register', () => {
+        it('registers a plugin and reports it via has/get', () => {
+            const p = makePlugin();
+            plugins.register(p);
+            expect(plugins.has('test-plugin')).toBe(true);
+            expect(plugins.get('test-plugin')).toBe(p);
+            expect(plugins.getState('test-plugin')).toBe('registered');
+        });
+        it('throws when registering a duplicate plugin id', () => {
+            plugins.register(makePlugin({ id: 'dup' }));
+            expect(() => plugins.register(makePlugin({ id: 'dup' }))).toThrowError(/already registered/);
+        });
+        it('calls onRegister lifecycle hook during registration', () => {
+            const onRegister = vi.fn();
+            plugins.register(makePlugin({ onRegister }));
+            expect(onRegister).toHaveBeenCalledOnce();
+            expect(onRegister).toHaveBeenCalledWith(expect.objectContaining({ hooks, config, plugins }));
+        });
+        it('registers plugin hook handlers on the hook engine', () => {
+            const handler = vi.fn();
+            plugins.register(makePlugin({
+                hooks: [{ hook: 'page:before_save', handler, priority: 5 }],
+            }));
+            expect(hooks.listenerCount('page:before_save')).toBe(1);
+        });
+        it('registers a config section when settingsSchema is provided', () => {
+            const schema = z.object({ apiKey: z.string() });
+            plugins.register(makePlugin({ id: 'with-settings', settingsSchema: schema }));
+            expect(config.has('plugins.with-settings')).toBe(true);
+        });
+        it('emits plugin:registered hook', async () => {
+            const handler = vi.fn();
+            hooks.on('plugin:registered', handler);
+            plugins.register(makePlugin());
+            // emit is async, give it a tick
+            await new Promise((r) => setTimeout(r, 0));
+            expect(handler).toHaveBeenCalledWith(expect.objectContaining({ plugin: expect.objectContaining({ id: 'test-plugin' }) }));
+        });
+    });
+    describe('activate / deactivate', () => {
+        it('activates a registered plugin', async () => {
+            const onActivate = vi.fn();
+            plugins.register(makePlugin({ onActivate }));
+            await plugins.activate('test-plugin');
+            expect(plugins.getState('test-plugin')).toBe('active');
+            expect(plugins.isActive('test-plugin')).toBe(true);
+            expect(onActivate).toHaveBeenCalledOnce();
+        });
+        it('throws when activating an unregistered plugin', async () => {
+            await expect(plugins.activate('nope')).rejects.toThrowError(/not registered/);
+        });
+        it('is a no-op if already active', async () => {
+            const onActivate = vi.fn();
+            plugins.register(makePlugin({ onActivate }));
+            await plugins.activate('test-plugin');
+            await plugins.activate('test-plugin'); // second call
+            expect(onActivate).toHaveBeenCalledOnce();
+        });
+        it('deactivates an active plugin', async () => {
+            const onDeactivate = vi.fn();
+            plugins.register(makePlugin({ onDeactivate }));
+            await plugins.activate('test-plugin');
+            await plugins.deactivate('test-plugin');
+            expect(plugins.getState('test-plugin')).toBe('inactive');
+            expect(plugins.isActive('test-plugin')).toBe(false);
+            expect(onDeactivate).toHaveBeenCalledOnce();
+        });
+        it('throws when deactivating an unregistered plugin', async () => {
+            await expect(plugins.deactivate('nope')).rejects.toThrowError(/not registered/);
+        });
+        it('prevents deactivation when other active plugins depend on it', async () => {
+            plugins.register(makePlugin({ id: 'base' }));
+            plugins.register(makePlugin({ id: 'child', requires: ['base'] }));
+            await plugins.activate('base');
+            await plugins.activate('child');
+            await expect(plugins.deactivate('base')).rejects.toThrowError(/depend on it/);
+        });
+        it('sets state to error when onActivate throws', async () => {
+            plugins.register(makePlugin({
+                onActivate: async () => {
+                    throw new Error('boom');
+                },
+            }));
+            await expect(plugins.activate('test-plugin')).rejects.toThrowError(/boom/);
+            expect(plugins.getState('test-plugin')).toBe('error');
+        });
+    });
+    describe('dependency resolution', () => {
+        it('activates dependencies before the dependent plugin', async () => {
+            const order = [];
+            plugins.register(makePlugin({
+                id: 'dep',
+                onActivate: async () => {
+                    order.push('dep');
+                },
+            }));
+            plugins.register(makePlugin({
+                id: 'main',
+                requires: ['dep'],
+                onActivate: async () => {
+                    order.push('main');
+                },
+            }));
+            await plugins.activate('main');
+            expect(order).toEqual(['dep', 'main']);
+        });
+        it('throws when a required dependency is not registered', async () => {
+            plugins.register(makePlugin({ id: 'orphan', requires: ['missing'] }));
+            await expect(plugins.activate('orphan')).rejects.toThrowError(/not registered/);
+        });
+    });
+    describe('circular dependency detection', () => {
+        it('detects circular deps during activateAll', async () => {
+            plugins.register(makePlugin({ id: 'a', requires: ['b'] }));
+            plugins.register(makePlugin({ id: 'b', requires: ['a'] }));
+            await expect(plugins.activateAll()).rejects.toThrowError(/Circular dependency/);
+        });
+        it('detects transitive circular deps', async () => {
+            plugins.register(makePlugin({ id: 'x', requires: ['z'] }));
+            plugins.register(makePlugin({ id: 'y', requires: ['x'] }));
+            plugins.register(makePlugin({ id: 'z', requires: ['y'] }));
+            await expect(plugins.activateAll()).rejects.toThrowError(/Circular dependency/);
+        });
+    });
+    describe('activateAll', () => {
+        it('activates all plugins in dependency order and returns results', async () => {
+            plugins.register(makePlugin({ id: 'core' }));
+            plugins.register(makePlugin({ id: 'addon', requires: ['core'] }));
+            const result = await plugins.activateAll();
+            expect(result.activated).toContain('core');
+            expect(result.activated).toContain('addon');
+            expect(result.failed).toHaveLength(0);
+            expect(result.activated.indexOf('core')).toBeLessThan(result.activated.indexOf('addon'));
+        });
+    });
+    describe('list / listActive / getByCapability', () => {
+        it('lists all registered plugins', () => {
+            plugins.register(makePlugin({ id: 'a' }));
+            plugins.register(makePlugin({ id: 'b' }));
+            expect(plugins.list()).toHaveLength(2);
+        });
+        it('listActive returns only active plugins', async () => {
+            plugins.register(makePlugin({ id: 'a' }));
+            plugins.register(makePlugin({ id: 'b' }));
+            await plugins.activate('a');
+            expect(plugins.listActive()).toHaveLength(1);
+            expect(plugins.listActive()[0].id).toBe('a');
+        });
+        it('getByCapability finds plugins with adminPages', async () => {
+            plugins.register(makePlugin({
+                id: 'admin-plugin',
+                adminPages: [{ path: 'settings', label: 'Settings', component: 'SettingsPage' }],
+            }));
+            await plugins.activate('admin-plugin');
+            expect(plugins.getByCapability('adminPages')).toHaveLength(1);
+            expect(plugins.getAllAdminPages()).toHaveLength(1);
+        });
+    });
+});
+// ===========================================================================
+// 2. Hook System
+// ===========================================================================
+describe('HookEngine', () => {
+    let hooks;
+    beforeEach(() => {
+        hooks = new HookEngine();
+    });
+    describe('on / emit', () => {
+        it('calls the handler when the hook is emitted', async () => {
+            const handler = vi.fn();
+            hooks.on('page:before_save', handler);
+            await hooks.emit('page:before_save', { content: { foo: 'bar' } });
+            expect(handler).toHaveBeenCalledWith({ content: { foo: 'bar' } });
+        });
+        it('supports multiple handlers on the same hook', async () => {
+            const h1 = vi.fn();
+            const h2 = vi.fn();
+            hooks.on('page:before_save', h1);
+            hooks.on('page:before_save', h2);
+            await hooks.emit('page:before_save', { content: {} });
+            expect(h1).toHaveBeenCalledOnce();
+            expect(h2).toHaveBeenCalledOnce();
+        });
+        it('does nothing when emitting a hook with no handlers', async () => {
+            // Should not throw
+            await hooks.emit('page:before_save', { content: {} });
+        });
+    });
+    describe('once', () => {
+        it('fires the handler only once', async () => {
+            const handler = vi.fn();
+            hooks.once('plugin:activated', handler);
+            await hooks.emit('plugin:activated', { plugin: {} });
+            await hooks.emit('plugin:activated', { plugin: {} });
+            expect(handler).toHaveBeenCalledOnce();
+        });
+        it('removes itself after first invocation (listenerCount drops)', async () => {
+            const handler = vi.fn();
+            hooks.once('plugin:activated', handler);
+            expect(hooks.listenerCount('plugin:activated')).toBe(1);
+            await hooks.emit('plugin:activated', { plugin: {} });
+            expect(hooks.listenerCount('plugin:activated')).toBe(0);
+        });
+    });
+    describe('off', () => {
+        it('removes a specific handler', async () => {
+            const handler = vi.fn();
+            hooks.on('config:changed', handler);
+            hooks.off('config:changed', handler);
+            await hooks.emit('config:changed', { key: 'a', value: 1, previous: 0 });
+            expect(handler).not.toHaveBeenCalled();
+        });
+        it('does nothing when removing a handler that was not registered', () => {
+            // Should not throw
+            hooks.off('config:changed', vi.fn());
+        });
+    });
+    describe('unsubscribe function', () => {
+        it('the return value of on() unsubscribes the handler', async () => {
+            const handler = vi.fn();
+            const unsub = hooks.on('config:changed', handler);
+            unsub();
+            await hooks.emit('config:changed', { key: 'x', value: 1, previous: 0 });
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+    describe('filter', () => {
+        it('passes the payload through each handler which can transform it', async () => {
+            hooks.on('page:after_render', ((payload) => {
+                return { ...payload, html: payload.html + ' [modified]' };
+            }));
+            const result = await hooks.filter('page:after_render', {
+                page: {},
+                html: '<p>Hello</p>',
+            });
+            expect(result.html).toBe('<p>Hello</p> [modified]');
+        });
+        it('chains multiple filter handlers', async () => {
+            hooks.on('page:after_render', ((p) => ({ ...p, html: p.html + ' A' })));
+            hooks.on('page:after_render', ((p) => ({ ...p, html: p.html + ' B' })));
+            const result = await hooks.filter('page:after_render', {
+                page: {},
+                html: 'start',
+            });
+            expect(result.html).toBe('start A B');
+        });
+        it('returns payload unchanged if no handlers are registered', async () => {
+            const payload = { page: {}, html: '<p>hi</p>' };
+            const result = await hooks.filter('page:after_render', payload);
+            expect(result).toBe(payload);
+        });
+    });
+    describe('priority ordering', () => {
+        it('runs lower-priority handlers first', async () => {
+            const order = [];
+            hooks.on('page:before_save', () => { order.push(20); }, { priority: 20 });
+            hooks.on('page:before_save', () => { order.push(5); }, { priority: 5 });
+            hooks.on('page:before_save', () => { order.push(10); }, { priority: 10 });
+            await hooks.emit('page:before_save', { content: {} });
+            expect(order).toEqual([5, 10, 20]);
+        });
+    });
+    describe('removeAll', () => {
+        it('removes all handlers for a specific hook', () => {
+            hooks.on('config:changed', vi.fn());
+            hooks.on('config:changed', vi.fn());
+            hooks.removeAll('config:changed');
+            expect(hooks.listenerCount('config:changed')).toBe(0);
+        });
+        it('removes all handlers for all hooks when called without args', () => {
+            hooks.on('config:changed', vi.fn());
+            hooks.on('page:before_save', vi.fn());
+            hooks.removeAll();
+            expect(hooks.listenerCount('config:changed')).toBe(0);
+            expect(hooks.listenerCount('page:before_save')).toBe(0);
+        });
+    });
+    describe('listenerCount', () => {
+        it('returns 0 for hooks with no listeners', () => {
+            expect(hooks.listenerCount('config:changed')).toBe(0);
+        });
+        it('returns the correct count', () => {
+            hooks.on('config:changed', vi.fn());
+            hooks.on('config:changed', vi.fn());
+            expect(hooks.listenerCount('config:changed')).toBe(2);
+        });
+    });
+});
+// ===========================================================================
+// 3. Config Manager
+// ===========================================================================
+describe('ConfigManager', () => {
+    let config;
+    let hooks;
+    beforeEach(() => {
+        hooks = new HookEngine();
+        config = new ConfigManager(hooks);
+    });
+    describe('get / set with dot notation', () => {
+        it('sets and gets a simple value', () => {
+            config.set('site.name', 'My Site');
+            expect(config.get('site.name')).toBe('My Site');
+        });
+        it('sets and gets deeply nested values', () => {
+            config.set('a.b.c.d', 42);
+            expect(config.get('a.b.c.d')).toBe(42);
+        });
+        it('returns undefined for missing paths', () => {
+            expect(config.get('nonexistent.path')).toBeUndefined();
+        });
+        it('has() returns true for existing paths and false for missing', () => {
+            config.set('x.y', 'value');
+            expect(config.has('x.y')).toBe(true);
+            expect(config.has('x.z')).toBe(false);
+        });
+    });
+    describe('Zod validation', () => {
+        it('allows setting valid data for a registered section', () => {
+            const schema = z.object({ name: z.string(), port: z.number() });
+            config.registerSection({ key: 'server', schema, defaults: { name: 'localhost', port: 3000 } });
+            // Setting a sub-key should not throw (validation runs on the section root)
+            config.set('server.name', 'prod-host');
+            expect(config.get('server.name')).toBe('prod-host');
+        });
+        it('throws when setSection is called with invalid data', () => {
+            const schema = z.object({ name: z.string(), port: z.number() });
+            config.registerSection({ key: 'server', schema, defaults: { name: 'localhost', port: 3000 } });
+            expect(() => config.setSection('server', { name: 123, port: 'bad' })).toThrowError(/validation failed/i);
+        });
+        it('populates defaults on registerSection', () => {
+            const schema = z.object({ theme: z.string() });
+            config.registerSection({ key: 'ui', schema, defaults: { theme: 'dark' } });
+            expect(config.get('ui.theme')).toBe('dark');
+        });
+        it('does not overwrite existing values when registering a section', () => {
+            config.set('ui', { theme: 'light' });
+            const schema = z.object({ theme: z.string() });
+            config.registerSection({ key: 'ui', schema, defaults: { theme: 'dark' } });
+            expect(config.get('ui.theme')).toBe('light');
+        });
+    });
+    describe('deep merge loading', () => {
+        it('merges loaded data into existing config', () => {
+            config.set('a.x', 1);
+            config.set('a.y', 2);
+            config.load({ a: { y: 99, z: 3 } });
+            expect(config.get('a.x')).toBe(1);
+            expect(config.get('a.y')).toBe(99);
+            expect(config.get('a.z')).toBe(3);
+        });
+        it('replaces arrays rather than merging them', () => {
+            config.set('tags', ['a', 'b']);
+            config.load({ tags: ['c'] });
+            expect(config.get('tags')).toEqual(['c']);
+        });
+    });
+    describe('delete', () => {
+        it('removes a value and returns true', () => {
+            config.set('foo.bar', 'baz');
+            expect(config.delete('foo.bar')).toBe(true);
+            expect(config.get('foo.bar')).toBeUndefined();
+        });
+        it('returns false when the path does not exist', () => {
+            expect(config.delete('no.such.path')).toBe(false);
+        });
+    });
+    describe('toJSON', () => {
+        it('returns a deep clone of the store', () => {
+            config.set('data', { nested: true });
+            const json = config.toJSON();
+            json.data = 'modified';
+            // original should not be affected
+            expect(config.get('data')).toEqual({ nested: true });
+        });
+    });
+    describe('config:changed hook', () => {
+        it('emits config:changed on set', async () => {
+            const handler = vi.fn();
+            hooks.on('config:changed', handler);
+            config.set('site.title', 'New Title');
+            // emit is async, let microtask run
+            await new Promise((r) => setTimeout(r, 0));
+            expect(handler).toHaveBeenCalledWith(expect.objectContaining({ key: 'site.title', value: 'New Title' }));
+        });
+    });
+});
+// ===========================================================================
+// 4. Element Registry
+// ===========================================================================
+describe('ElementRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        registry = new ElementRegistry();
+    });
+    describe('register / get', () => {
+        it('registers an element and retrieves it by type', () => {
+            const el = makeElement();
+            registry.register(el);
+            expect(registry.get('test-element')).toBe(el);
+            expect(registry.has('test-element')).toBe(true);
+        });
+        it('throws on duplicate type registration', () => {
+            registry.register(makeElement());
+            expect(() => registry.register(makeElement())).toThrowError(/already registered/);
+        });
+        it('returns undefined for unregistered types', () => {
+            expect(registry.get('nope')).toBeUndefined();
+        });
+    });
+    describe('list', () => {
+        it('returns all registered elements', () => {
+            registry.register(makeElement({ type: 'a', name: 'A' }));
+            registry.register(makeElement({ type: 'b', name: 'B' }));
+            expect(registry.list()).toHaveLength(2);
+            expect(registry.count).toBe(2);
+        });
+    });
+    describe('listByCategory', () => {
+        it('groups elements by category', () => {
+            registry.register(makeElement({ type: 'h1', category: 'content' }));
+            registry.register(makeElement({ type: 'img', category: 'media' }));
+            registry.register(makeElement({ type: 'p', category: 'content' }));
+            const grouped = registry.listByCategory();
+            expect(grouped.get('content')).toHaveLength(2);
+            expect(grouped.get('media')).toHaveLength(1);
+        });
+    });
+    describe('search', () => {
+        it('finds elements by name', () => {
+            registry.register(makeElement({ type: 'heading', name: 'Heading' }));
+            registry.register(makeElement({ type: 'button', name: 'Button' }));
+            const results = registry.search('head');
+            expect(results).toHaveLength(1);
+            expect(results[0].type).toBe('heading');
+        });
+        it('finds elements by type', () => {
+            registry.register(makeElement({ type: 'text-block', name: 'Text Block' }));
+            const results = registry.search('text-block');
+            expect(results).toHaveLength(1);
+        });
+        it('finds elements by keywords', () => {
+            registry.register(makeElement({ type: 'cta', name: 'CTA', keywords: ['call-to-action', 'banner'] }));
+            const results = registry.search('banner');
+            expect(results).toHaveLength(1);
+            expect(results[0].type).toBe('cta');
+        });
+        it('returns empty array for no matches', () => {
+            registry.register(makeElement({ type: 'a' }));
+            expect(registry.search('zzzzz')).toHaveLength(0);
+        });
+    });
+    describe('validateSettings', () => {
+        it('returns success for valid settings', () => {
+            registry.register(makeElement());
+            const result = registry.validateSettings('test-element', { text: 'hello' });
+            expect(result.success).toBe(true);
+        });
+        it('returns error for invalid settings', () => {
+            registry.register(makeElement());
+            const result = registry.validateSettings('test-element', { text: 123 });
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('returns error for unknown element type', () => {
+            const result = registry.validateSettings('unknown', {});
+            expect(result.success).toBe(false);
+            expect(result.error).toMatch(/Unknown element type/);
+        });
+    });
+    describe('unregister', () => {
+        it('removes a registered element', () => {
+            registry.register(makeElement());
+            expect(registry.unregister('test-element')).toBe(true);
+            expect(registry.has('test-element')).toBe(false);
+        });
+        it('returns false for non-existent elements', () => {
+            expect(registry.unregister('nope')).toBe(false);
+        });
+    });
+    describe('getDefaultSettings', () => {
+        it('returns a copy of default settings', () => {
+            const el = makeElement({ defaultSettings: { text: 'default', size: 16 } });
+            registry.register(el);
+            const settings = registry.getDefaultSettings('test-element');
+            expect(settings).toEqual({ text: 'default', size: 16 });
+            // Should be a copy, not the same reference
+            settings.text = 'changed';
+            expect(registry.getDefaultSettings('test-element').text).toBe('default');
+        });
+        it('returns undefined for unknown types', () => {
+            expect(registry.getDefaultSettings('nope')).toBeUndefined();
+        });
+    });
+    describe('default elements', () => {
+        it('registerDefaultElements populates the registry with 15 elements', () => {
+            registerDefaultElements(registry);
+            expect(registry.count).toBe(15);
+        });
+        it('all default elements have a working render function', () => {
+            registerDefaultElements(registry);
+            for (const el of registry.list()) {
+                const html = el.render(el.defaultSettings);
+                expect(typeof html).toBe('string');
+                expect(html.length).toBeGreaterThan(0);
+            }
+        });
+    });
+});
+// ===========================================================================
+// 5. Template Studio
+// ===========================================================================
+describe('TemplateStudio', () => {
+    let studio;
+    beforeEach(() => {
+        studio = new TemplateStudio();
+    });
+    describe('register / get', () => {
+        it('registers and retrieves a template', () => {
+            const t = makeTemplate();
+            studio.register(t);
+            expect(studio.get('test-template')).toBe(t);
+            expect(studio.has('test-template')).toBe(true);
+        });
+        it('throws on duplicate id', () => {
+            studio.register(makeTemplate());
+            expect(() => studio.register(makeTemplate())).toThrowError(/already registered/);
+        });
+    });
+    describe('list', () => {
+        it('returns all templates', () => {
+            studio.register(makeTemplate({ id: 'a' }));
+            studio.register(makeTemplate({ id: 'b' }));
+            expect(studio.list()).toHaveLength(2);
+            expect(studio.count).toBe(2);
+        });
+    });
+    describe('listByCategory', () => {
+        it('filters templates by category', () => {
+            studio.register(makeTemplate({ id: 'hero1', category: 'hero' }));
+            studio.register(makeTemplate({ id: 'about1', category: 'about' }));
+            studio.register(makeTemplate({ id: 'hero2', category: 'hero' }));
+            expect(studio.listByCategory('hero')).toHaveLength(2);
+            expect(studio.listByCategory('about')).toHaveLength(1);
+            expect(studio.listByCategory('pricing')).toHaveLength(0);
+        });
+    });
+    describe('search', () => {
+        it('searches by name', () => {
+            studio.register(makeTemplate({ id: 'h1', name: 'Hero Banner', category: 'hero' }));
+            studio.register(makeTemplate({ id: 'a1', name: 'About Section', category: 'about' }));
+            const results = studio.search('banner');
+            expect(results).toHaveLength(1);
+            expect(results[0].id).toBe('h1');
+        });
+        it('searches by description', () => {
+            studio.register(makeTemplate({ id: 't1', description: 'A beautiful pricing table' }));
+            const results = studio.search('pricing');
+            expect(results).toHaveLength(1);
+        });
+        it('searches by category', () => {
+            studio.register(makeTemplate({ id: 'g1', category: 'gallery', name: 'Photos' }));
+            const results = studio.search('gallery');
+            expect(results).toHaveLength(1);
+        });
+        it('searches by id', () => {
+            studio.register(makeTemplate({ id: 'cta-banner', name: 'Banner' }));
+            const results = studio.search('cta-banner');
+            expect(results).toHaveLength(1);
+        });
+    });
+    describe('unregister', () => {
+        it('removes a registered template', () => {
+            studio.register(makeTemplate());
+            expect(studio.unregister('test-template')).toBe(true);
+            expect(studio.has('test-template')).toBe(false);
+        });
+    });
+    describe('default templates', () => {
+        it('registerDefaultTemplates populates the studio with 10 templates', () => {
+            registerDefaultTemplates(studio);
+            expect(studio.count).toBe(10);
+        });
+        it('default templates cover multiple categories', () => {
+            registerDefaultTemplates(studio);
+            const categories = new Set(studio.list().map((t) => t.category));
+            expect(categories.size).toBeGreaterThanOrEqual(5);
+        });
+        it('each default template has non-empty content', () => {
+            registerDefaultTemplates(studio);
+            for (const template of studio.list()) {
+                expect(template.content.length).toBeGreaterThan(0);
+                expect(template.content[0].type).toBe('row');
+            }
+        });
+    });
+});
+// ===========================================================================
+// 6. Page Serializer
+// ===========================================================================
+describe('Page Serializer', () => {
+    const samplePage = {
+        id: 'page-123',
+        title: 'Home Page',
+        slug: 'home',
+        status: 'published',
+        template: 'default',
+        content: [
+            {
+                id: 'row-1',
+                type: 'row',
+                settings: { layout: 'boxed' },
+                columns: [
+                    {
+                        id: 'col-1',
+                        width: '1/1',
+                        settings: {},
+                        elements: [
+                            { id: 'el-1', type: 'heading', settings: { text: 'Hello' } },
+                        ],
+                    },
+                ],
+            },
+        ],
+        meta: { description: 'Welcome to our site' },
+        createdAt: new Date('2025-06-01T00:00:00.000Z'),
+        updatedAt: new Date('2025-06-02T00:00:00.000Z'),
+    };
+    describe('serializePage', () => {
+        it('returns a valid JSON string', () => {
+            const json = serializePage(samplePage);
+            expect(() => JSON.parse(json)).not.toThrow();
+        });
+        it('converts Date objects to ISO strings', () => {
+            const json = serializePage(samplePage);
+            const parsed = JSON.parse(json);
+            expect(parsed.createdAt).toBe('2025-06-01T00:00:00.000Z');
+            expect(parsed.updatedAt).toBe('2025-06-02T00:00:00.000Z');
+        });
+        it('preserves page structure', () => {
+            const json = serializePage(samplePage);
+            const parsed = JSON.parse(json);
+            expect(parsed.id).toBe('page-123');
+            expect(parsed.content).toHaveLength(1);
+            expect(parsed.content[0].columns[0].elements[0].settings.text).toBe('Hello');
+        });
+    });
+    describe('deserializePage', () => {
+        it('round-trips through serialize/deserialize', () => {
+            const json = serializePage(samplePage);
+            const restored = deserializePage(json);
+            expect(restored.id).toBe(samplePage.id);
+            expect(restored.title).toBe(samplePage.title);
+            expect(restored.slug).toBe(samplePage.slug);
+            expect(restored.status).toBe(samplePage.status);
+            expect(restored.createdAt).toBeInstanceOf(Date);
+            expect(restored.content).toHaveLength(1);
+        });
+        it('parses ISO date strings back to Date objects', () => {
+            const json = serializePage(samplePage);
+            const restored = deserializePage(json);
+            expect(restored.createdAt).toBeInstanceOf(Date);
+            expect(restored.createdAt.toISOString()).toBe('2025-06-01T00:00:00.000Z');
+        });
+        it('throws on invalid JSON', () => {
+            expect(() => deserializePage('not json')).toThrow();
+        });
+        it('throws on valid JSON but invalid page structure', () => {
+            expect(() => deserializePage('{"foo": "bar"}')).toThrow();
+        });
+    });
+    describe('validatePageData', () => {
+        it('validates correct page data', () => {
+            const data = {
+                id: 'p1',
+                title: 'T',
+                slug: 's',
+                status: 'draft',
+                template: 'default',
+                content: [],
+                meta: {},
+                createdAt: '2025-01-01T00:00:00.000Z',
+                updatedAt: '2025-01-01T00:00:00.000Z',
+            };
+            const result = validatePageData(data);
+            expect(result.id).toBe('p1');
+            expect(result.createdAt).toBeInstanceOf(Date);
+        });
+        it('throws on missing required fields', () => {
+            expect(() => validatePageData({})).toThrow();
+        });
+        it('throws on invalid status', () => {
+            expect(() => validatePageData({
+                id: 'p',
+                title: 'T',
+                slug: 's',
+                status: 'deleted',
+                template: 'default',
+                content: [],
+                meta: {},
+                createdAt: '2025-01-01',
+                updatedAt: '2025-01-01',
+            })).toThrow();
+        });
+    });
+});
+// ===========================================================================
+// 7. Factory Functions
+// ===========================================================================
+describe('Factory Functions', () => {
+    describe('createFoundry', () => {
+        it('returns an instance with all subsystems', () => {
+            const foundry = createFoundry();
+            expect(foundry.hooks).toBeInstanceOf(HookEngine);
+            expect(foundry.config).toBeInstanceOf(ConfigManager);
+            expect(foundry.plugins).toBeInstanceOf(PluginRegistry);
+            expect(foundry.elements).toBeInstanceOf(ElementRegistry);
+            expect(foundry.templates).toBeInstanceOf(TemplateStudio);
+        });
+        it('loads initial config when provided', () => {
+            const foundry = createFoundry({ config: { site: { title: 'My CMS' } } });
+            expect(foundry.config.get('site.title')).toBe('My CMS');
+        });
+        it('starts with empty registries', () => {
+            const foundry = createFoundry();
+            expect(foundry.elements.count).toBe(0);
+            expect(foundry.templates.count).toBe(0);
+            expect(foundry.plugins.list()).toHaveLength(0);
+        });
+        it('allows registering and activating plugins', async () => {
+            const foundry = createFoundry();
+            foundry.plugins.register(makePlugin());
+            await foundry.plugins.activate('test-plugin');
+            expect(foundry.plugins.isActive('test-plugin')).toBe(true);
+        });
+    });
+    describe('createFoundryWithDefaults', () => {
+        it('pre-registers 15 default elements', () => {
+            const foundry = createFoundryWithDefaults();
+            expect(foundry.elements.count).toBe(15);
+        });
+        it('pre-registers 10 default templates', () => {
+            const foundry = createFoundryWithDefaults();
+            expect(foundry.templates.count).toBe(10);
+        });
+        it('includes heading, text-block, and button elements', () => {
+            const foundry = createFoundryWithDefaults();
+            expect(foundry.elements.has('heading')).toBe(true);
+            expect(foundry.elements.has('text-block')).toBe(true);
+            expect(foundry.elements.has('button')).toBe(true);
+        });
+        it('accepts initial config just like createFoundry', () => {
+            const foundry = createFoundryWithDefaults({
+                config: { app: { debug: true } },
+            });
+            expect(foundry.config.get('app.debug')).toBe(true);
+        });
+    });
+});
+// ===========================================================================
+// 8. Page Renderer
+// ===========================================================================
+describe('Page Renderer', () => {
+    let registry;
+    beforeEach(() => {
+        registry = new ElementRegistry();
+        registerDefaultElements(registry);
+    });
+    describe('escapeHtml', () => {
+        it('escapes ampersands', () => {
+            expect(escapeHtml('a & b')).toBe('a &amp; b');
+        });
+        it('escapes angle brackets', () => {
+            expect(escapeHtml('<script>alert("xss")</script>')).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
+        });
+        it('escapes quotes', () => {
+            expect(escapeHtml('"hello" \'world\'')).toBe('&quot;hello&quot; &#39;world&#39;');
+        });
+        it('leaves safe strings unchanged', () => {
+            expect(escapeHtml('Hello World')).toBe('Hello World');
+        });
+    });
+    describe('escapeAttr', () => {
+        it('escapes double quotes for attribute values', () => {
+            expect(escapeAttr('he said "hi"')).toBe('he said &quot;hi&quot;');
+        });
+        it('escapes single quotes', () => {
+            expect(escapeAttr("it's")).toBe('it&#39;s');
+        });
+    });
+    describe('renderElement', () => {
+        it('renders a known element type', () => {
+            const html = renderElement({ id: 'el-1', type: 'heading', settings: { text: 'Hello', level: 'h1' } }, registry);
+            expect(html).toContain('foundry-element');
+            expect(html).toContain('data-element-id="el-1"');
+            expect(html).toContain('data-element-type="heading"');
+        });
+        it('renders an HTML comment for unknown element types', () => {
+            const html = renderElement({ id: 'el-x', type: 'nonexistent', settings: {} }, registry);
+            expect(html).toContain('Unknown element type');
+            expect(html).toContain('nonexistent');
+        });
+    });
+    describe('renderColumn', () => {
+        it('renders a column with child elements', () => {
+            const html = renderColumn({
+                id: 'col-1',
+                width: '1/2',
+                settings: {},
+                elements: [
+                    { id: 'el-1', type: 'heading', settings: { text: 'Test' } },
+                ],
+            }, registry);
+            expect(html).toContain('foundry-column');
+            expect(html).toContain('w-1/2');
+            expect(html).toContain('foundry-element');
+        });
+    });
+    describe('renderRow', () => {
+        it('renders a row with columns', () => {
+            const html = renderRow({
+                id: 'row-1',
+                type: 'row',
+                settings: { layout: 'boxed' },
+                columns: [
+                    {
+                        id: 'col-1',
+                        width: '1/1',
+                        settings: {},
+                        elements: [],
+                    },
+                ],
+            }, registry);
+            expect(html).toContain('foundry-row');
+            expect(html).toContain('<section');
+            expect(html).toContain('max-w-7xl');
+        });
+        it('applies full_width layout class', () => {
+            const html = renderRow({
+                id: 'row-1',
+                type: 'row',
+                settings: { layout: 'full_width' },
+                columns: [],
+            }, registry);
+            expect(html).toContain('w-full');
+        });
+        it('applies narrow layout class', () => {
+            const html = renderRow({
+                id: 'row-1',
+                type: 'row',
+                settings: { layout: 'narrow' },
+                columns: [],
+            }, registry);
+            expect(html).toContain('max-w-3xl');
+        });
+        it('renders anchor id when provided', () => {
+            const html = renderRow({
+                id: 'row-1',
+                type: 'row',
+                settings: { layout: 'boxed', anchorId: 'about-us' },
+                columns: [],
+            }, registry);
+            expect(html).toContain('id="about-us"');
+        });
+    });
+    describe('renderPage', () => {
+        it('produces valid HTML with page wrapper', () => {
+            const page = makeMinimalPageData();
+            const html = renderPage(page, registry);
+            expect(html).toContain('foundry-page');
+            expect(html).toContain('data-page-id="page-1"');
+            expect(html).toContain('data-page-slug="test-page"');
+        });
+        it('renders rows and their elements', () => {
+            const page = makeMinimalPageData({
+                content: [
+                    {
+                        id: 'row-1',
+                        type: 'row',
+                        settings: { layout: 'boxed' },
+                        columns: [
+                            {
+                                id: 'col-1',
+                                width: '1/1',
+                                settings: {},
+                                elements: [
+                                    {
+                                        id: 'el-1',
+                                        type: 'heading',
+                                        settings: { text: 'Welcome', level: 'h1' },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const html = renderPage(page, registry);
+            expect(html).toContain('foundry-row');
+            expect(html).toContain('foundry-column');
+            expect(html).toContain('foundry-element--heading');
+            expect(html).toContain('Welcome');
+        });
+        it('renders an empty page without errors', () => {
+            const page = makeMinimalPageData({ content: [] });
+            const html = renderPage(page, registry);
+            expect(html).toContain('foundry-page');
+        });
+        it('handles background styles on rows', () => {
+            const page = makeMinimalPageData({
+                content: [
+                    {
+                        id: 'row-bg',
+                        type: 'row',
+                        settings: {
+                            layout: 'boxed',
+                            background: { type: 'color', color: '#ff0000' },
+                        },
+                        columns: [],
+                    },
+                ],
+            });
+            const html = renderPage(page, registry);
+            expect(html).toContain('background-color: #ff0000');
+        });
+    });
+});
+//# sourceMappingURL=foundry.test.js.map