primo-cli 0.1.3 → 0.1.5

package/dist/commands/build.js

@@ -3,81 +3,91 @@ import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 import { load as load_yaml } from 'js-yaml';
+import { compile } from 'svelte/compiler';
+import * as esbuild from 'esbuild';
+import { fileURLToPath } from 'url';
+import { read_site_config, SITE_CONFIG_FILE } from '../utils/site-config.js';
+import { validate_head_svelte_content } from '../utils/head-svelte.js';
+// CSS reset applied to all sites by default
+const CSS_RESET = `*, *::before, *::after { box-sizing: border-box; }
+* { margin: 0; }
+body { line-height: 1.5; -webkit-font-smoothing: antialiased; }
+img, picture, video, canvas, svg { display: block; max-width: 100%; }
+input, button, textarea, select { font: inherit; }
+p, h1, h2, h3, h4, h5, h6 { overflow-wrap: break-word; }`;
 export async function build_site(options) {
     const spinner = ora('Building site...').start();
     try {
         const site_dir = path.resolve(options.dir);
         const output_dir = path.resolve(options.output);
+        const temp_dir = path.join(site_dir, '.primo', 'build-temp');
         // Read site config
-        const config_path = path.join(site_dir, 'primo.json');
         let config;
         try {
-            const config_data = await fs.readFile(config_path, 'utf-8');
-            config = JSON.parse(config_data);
+            config = await read_site_config(site_dir);
         }
         catch {
-            spinner.fail('No primo.json found. Run `primo new` first.');
+            spinner.fail(`No ${SITE_CONFIG_FILE} found. Run \`primo new\` first.`);
             process.exit(1);
         }
-        // Clean and create output directory
+        // Clean and create directories
         await fs.rm(output_dir, { recursive: true, force: true });
         await fs.mkdir(output_dir, { recursive: true });
-        // Read head.svelte for global styles
+        await fs.rm(temp_dir, { recursive: true, force: true });
+        await fs.mkdir(temp_dir, { recursive: true });
+        // Read head.svelte for global head content
         let head_content = '';
         try {
             const head_path = path.join(site_dir, 'site', 'head.svelte');
             head_content = await fs.readFile(head_path, 'utf-8');
+            validate_head_svelte_content(head_content, 'site/head.svelte');
         }
-        catch {
-            // No head.svelte, that's fine
-        }
-        // Extract CSS from head.svelte
-        let global_css = '';
-        if (head_content) {
-            const style_match = head_content.match(/<style[^>]*>([\s\S]*?)<\/style>/i);
-            if (style_match) {
-                global_css = style_match[1];
+        catch (error) {
+            if (error?.code !== 'ENOENT') {
+                throw error;
             }
+            // No head.svelte, that's fine
         }
         // Find all pages
         const pages_dir = path.join(site_dir, 'pages');
-        const pages = await find_pages(pages_dir);
-        spinner.text = `Building ${pages.length} page${pages.length !== 1 ? 's' : ''}...`;
-        // Collect all CSS from blocks
-        const block_css_cache = new Map();
-        const all_css = [global_css];
+        const page_files = await find_pages(pages_dir);
+        spinner.text = `Building ${page_files.length} page${page_files.length !== 1 ? 's' : ''}...`;
+        // Compile all blocks once and cache them
+        const block_cache = new Map();
+        // Cache layouts per page type
+        const layout_cache = new Map();
+        // Cache per-page-type head fragments (mirrors site head behavior; empty
+        // string = no head.svelte for that page type).
+        const page_type_head_cache = new Map();
+        // Load site data (fields and content)
+        const site_data = await load_site_data(site_dir);
         // Build each page
-        for (const page_file of pages) {
+        for (const page_file of page_files) {
             const page_content = await fs.readFile(page_file, 'utf-8');
             const page = load_yaml(page_content);
-            // Render page sections
-            let page_html = '';
-            for (const section of page.sections || []) {
-                const block_name = section.block;
-                const content = normalize_content(section.content);
-                // Get or compile block
-                let block_css = block_css_cache.get(block_name);
-                if (block_css === undefined) {
-                    const result = await compile_block(site_dir, block_name);
-                    block_css = result.css;
-                    block_css_cache.set(block_name, block_css);
-                    if (block_css) {
-                        all_css.push(block_css);
-                    }
-                }
-                // Render block HTML
-                const block_html = await render_block(site_dir, block_name, content);
-                page_html += block_html;
+            const page_path = get_page_path_from_file(site_dir, page_file);
+            spinner.text = `Building ${page.name || page_path || 'home'}...`;
+            const result = await build_page({
+                page,
+                page_path,
+                site_dir,
+                temp_dir,
+                head_content,
+                site_name: config.name,
+                block_cache,
+                layout_cache,
+                page_type_head_cache,
+                site_data
+            });
+            if (result.error) {
+                console.log(chalk.yellow(`  Warning: ${page.name}: ${result.error}`));
             }
-            // Generate full HTML document
-            const html = generate_html(config.name, page.name, page_html, all_css.join('\n'));
-            // Determine output path
-            const slug = page.slug || path.basename(page_file, '.yaml');
-            const out_path = slug === '' || slug === 'index'
+            // Determine output path from the page file path.
+            const out_path = page_path === ''
                 ? path.join(output_dir, 'index.html')
-                : path.join(output_dir, slug, 'index.html');
+                : path.join(output_dir, page_path, 'index.html');
             await fs.mkdir(path.dirname(out_path), { recursive: true });
-            await fs.writeFile(out_path, html);
+            await fs.writeFile(out_path, result.html);
         }
         // Copy uploads directory
         const uploads_src = path.join(site_dir, 'uploads');
@@ -88,14 +98,17 @@ export async function build_site(options) {
         catch {
             // No uploads directory, that's fine
         }
-        spinner.succeed(`Built ${pages.length} page${pages.length !== 1 ? 's' : ''} to ${chalk.cyan(output_dir)}`);
+        // Clean up temp directory
+        await fs.rm(temp_dir, { recursive: true, force: true });
+        spinner.succeed(`Built ${page_files.length} page${page_files.length !== 1 ? 's' : ''} to ${chalk.cyan(output_dir)}`);
         console.log('');
         console.log(chalk.dim('  Preview locally:'));
         console.log(chalk.dim(`    npx serve ${options.output}`));
         console.log('');
         console.log(chalk.dim('  Deploy:'));
-        console.log(chalk.dim('    npx netlify deploy --prod --dir=' + options.output));
-        console.log(chalk.dim('    npx vercel ' + options.output));
+        console.log(chalk.dim(`    npx vercel deploy ${options.output} --prod`));
+        console.log(chalk.dim(`    npx netlify deploy --prod --dir=${options.output}`));
+        console.log(chalk.dim(`    npx wrangler pages deploy ${options.output}`));
         console.log('');
     }
     catch (error) {
@@ -106,224 +119,298 @@ export async function build_site(options) {
         process.exit(1);
     }
 }
-async function find_pages(pages_dir) {
-    const pages = [];
-    async function scan(dir) {
-        let entries;
-        try {
-            entries = await fs.readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full_path = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                await scan(full_path);
-            }
-            else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
-                pages.push(full_path);
-            }
-        }
-    }
-    await scan(pages_dir);
-    return pages;
-}
-async function compile_block(site_dir, block_name) {
-    const component_path = path.join(site_dir, 'blocks', block_name, 'component.svelte');
+// Lazily load and validate a page type's head.svelte. Cached value is the raw
+// fragment (may include <style>); empty string means "no head file present".
+async function load_page_type_head(site_dir, page_type, cache) {
+    const cached = cache.get(page_type);
+    if (cached !== undefined)
+        return cached;
+    const head_path = path.join(site_dir, 'page-types', page_type, 'head.svelte');
+    let content = '';
     try {
-        const source = await fs.readFile(component_path, 'utf-8');
-        // Extract CSS from the component
-        const style_match = source.match(/<style[^>]*>([\s\S]*?)<\/style>/i);
-        const css = style_match ? style_match[1] : '';
-        return { css };
+        content = await fs.readFile(head_path, 'utf-8');
+        validate_head_svelte_content(content, `page-types/${page_type}/head.svelte`);
     }
-    catch {
-        return { css: '' };
+    catch (error) {
+        if (error?.code !== 'ENOENT')
+            throw error;
+        content = '';
     }
+    cache.set(page_type, content);
+    return content;
 }
-async function render_block(site_dir, block_name, content) {
-    const component_path = path.join(site_dir, 'blocks', block_name, 'component.svelte');
+async function build_page(options) {
+    const { page, page_path, site_dir, temp_dir, head_content, site_name, block_cache, layout_cache, page_type_head_cache, site_data } = options;
     try {
-        let source = await fs.readFile(component_path, 'utf-8');
-        // Remove script tags for static render
-        source = source.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
-        // Remove style tags (CSS is collected separately)
-        source = source.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
-        // Simple template rendering - replace {variable} with content values
-        let html = source.trim();
-        // Handle {#if condition}...{/if} blocks
-        html = process_if_blocks(html, content);
-        // Handle {#each items as item}...{/each} blocks
-        html = process_each_blocks(html, content);
-        // Replace simple variable interpolations {variable}
-        html = html.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (match, varName) => {
-            const value = content[varName];
-            if (value === undefined || value === null)
-                return '';
-            return escape_html(String(value));
-        });
-        // Replace property access {obj.prop} or {obj?.prop}
-        html = html.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\??\.([\w.?]+)\}/g, (match, objName, propPath) => {
-            const obj = content[objName];
-            if (!obj || typeof obj !== 'object')
-                return '';
-            const value = get_nested_value(obj, propPath.replace(/\?/g, ''));
-            if (value === undefined || value === null)
-                return '';
-            return escape_html(String(value));
-        });
-        // Replace {obj && obj.prop} patterns
-        html = html.replace(/\{[^}]+&&\s*([^}]+)\}/g, (match, expr) => {
-            // Try to evaluate simple property access
-            const prop_match = expr.trim().match(/([a-zA-Z_][a-zA-Z0-9_]*)\.(\w+)/);
-            if (prop_match) {
-                const obj = content[prop_match[1]];
-                if (obj && typeof obj === 'object') {
-                    const value = obj[prop_match[2]];
-                    if (value !== undefined && value !== null) {
-                        return escape_html(String(value));
-                    }
-                }
+        const page_build_id = safe_temp_id(page._id || page.id || page_path || page.name || 'page');
+        // Load layout for this page type
+        const page_type = page.page_type || 'default';
+        let layout = layout_cache.get(page_type);
+        if (layout === undefined) {
+            layout = await load_layout(site_dir, page_type);
+            layout_cache.set(page_type, layout);
+        }
+        // Page-type head is concatenated after the site head, mirroring server
+        // publish behavior (site.head + page_type.head).
+        const page_type_head = await load_page_type_head(site_dir, page_type, page_type_head_cache);
+        const combined_head_content = page_type_head ? `${head_content}\n${page_type_head}` : head_content;
+        // Combine header + page sections + footer
+        const header_sections = await resolve_layout_sections(layout.header || [], site_dir, site_data);
+        const footer_sections = await resolve_layout_sections(layout.footer || [], site_dir, site_data);
+        const page_sections = await resolve_page_sections(page.sections || [], site_dir, site_data);
+        const all_sections = [...header_sections, ...page_sections, ...footer_sections];
+        if (all_sections.length === 0) {
+            return { html: generate_empty_page(site_name, page.name, combined_head_content) };
+        }
+        const sections = all_sections;
+        // Compile each block and collect CSS
+        const all_css = [];
+        const section_components = [];
+        for (let i = 0; i < sections.length; i++) {
+            const section = sections[i];
+            const block_name = section.block;
+            // Check cache first
+            let compiled = block_cache.get(block_name);
+            if (!compiled) {
+                compiled = await compile_block(site_dir, block_name, temp_dir);
+                block_cache.set(block_name, compiled);
+            }
+            if (compiled.css) {
+                all_css.push(compiled.css);
             }
-            return '';
+            // Create import and usage for this section
+            const component_name = `Section_${i}_${block_name.replace(/-/g, '_')}`;
+            section_components.push({
+                name: component_name,
+                block_name,
+                props: section.content || {}
+            });
+        }
+        // Create a page component that renders all sections
+        const page_component = generate_page_component(section_components, sections);
+        const page_component_path = path.join(temp_dir, `page_${page_build_id}.svelte`);
+        await fs.writeFile(page_component_path, page_component);
+        // Compile the page component
+        const page_source = await fs.readFile(page_component_path, 'utf-8');
+        const page_compiled = compile(page_source, {
+            generate: 'server',
+            filename: page_component_path,
+            css: 'external'
         });
-        // Replace (obj && obj.prop) || 'default' patterns
-        html = html.replace(/\{[^}]*\|\|\s*['"]([^'"]+)['"]\}/g, (match, defaultVal) => {
-            // Check if the first part evaluates to something
-            const var_match = match.match(/\{([a-zA-Z_][a-zA-Z0-9_]*)/);
-            if (var_match) {
-                const value = content[var_match[1]];
-                if (value !== undefined && value !== null && value !== '') {
-                    return escape_html(String(value));
+        if (page_compiled.warnings.length > 0) {
+            for (const warning of page_compiled.warnings) {
+                if (!warning.message.includes('unused')) {
+                    console.log(chalk.yellow(`  Svelte warning: ${warning.message}`));
                 }
             }
-            return escape_html(defaultVal);
+        }
+        // Write compiled JS and bundle with esbuild
+        const compiled_path = path.join(temp_dir, `page_${page_build_id}.js`);
+        await fs.writeFile(compiled_path, page_compiled.js.code);
+        // Copy all block compiled JS files to temp for bundling
+        for (const section of sections) {
+            const block_js_path = path.join(temp_dir, `${section.block}.compiled.js`);
+            const cached = block_cache.get(section.block);
+            if (cached?.js) {
+                await fs.writeFile(block_js_path, cached.js);
+            }
+        }
+        // Bundle with esbuild - include svelte runtime
+        const bundle_path = path.join(temp_dir, `bundle_${page_build_id}.mjs`);
+        // Find where svelte is installed (could be in primo-cli's node_modules or globally)
+        const svelte_base = await find_svelte_path();
+        await esbuild.build({
+            entryPoints: [compiled_path],
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            outfile: bundle_path,
+            logLevel: 'silent',
+            alias: {
+                'svelte/internal/server': path.join(svelte_base, 'src/internal/server/index.js'),
+                'svelte/internal/shared': path.join(svelte_base, 'src/internal/shared/index.js'),
+                'svelte/internal/client': path.join(svelte_base, 'src/internal/client/index.js'),
+                'svelte': path.join(svelte_base, 'src/index.js')
+            }
         });
-        // Handle {@html content} - render raw HTML
-        html = html.replace(/\{@html\s+([^}]+)\}/g, (match, expr) => {
-            const var_name = expr.trim();
-            const value = content[var_name];
-            if (value === undefined || value === null)
-                return '';
-            return String(value); // Don't escape - it's raw HTML
+        // Import and render
+        const bundle_url = `file://${bundle_path}`;
+        const { default: PageComponent } = await import(bundle_url);
+        // Import render from svelte/server
+        const { render } = await import('svelte/server');
+        // Build props for all sections
+        const props = {};
+        sections.forEach((section, i) => {
+            props[`section_${i}_props`] = section.content || {};
         });
-        // Clean up any remaining unresolved template expressions
-        html = html.replace(/\{[^}]+\}/g, '');
-        return html;
+        const rendered = render(PageComponent, { props });
+        // Extract CSS from combined head fragments (site + page-type).
+        let head_css = '';
+        let head_html = combined_head_content;
+        const style_matches = combined_head_content.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/gi);
+        const head_css_parts = [];
+        for (const m of style_matches) {
+            head_css_parts.push(m[1]);
+        }
+        if (head_css_parts.length > 0) {
+            head_css = head_css_parts.join('\n');
+            head_html = combined_head_content.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+        }
+        // Combine all CSS (reset first, then head, then blocks)
+        const combined_css = [CSS_RESET, head_css, ...all_css].filter(Boolean).join('\n');
+        // Generate final HTML
+        const title = page.name === 'Home' ? site_name : `${page.name} | ${site_name}`;
+        const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${escape_html(title)}</title>
+${head_html}
+	<style>
+${combined_css}
+	</style>
+	${rendered.head || ''}
+</head>
+<body>
+${rendered.body || ''}
+</body>
+</html>`;
+        return { html };
     }
     catch (error) {
-        console.log(chalk.yellow(`  Warning: Could not render block "${block_name}": ${error}`));
-        return `<!-- Block "${block_name}" could not be rendered -->`;
+        const error_msg = error instanceof Error ? error.message : String(error);
+        return {
+            html: generate_error_page(site_name, page.name, error_msg, head_content),
+            error: error_msg,
+        };
     }
 }
-function process_if_blocks(html, content) {
-    // Handle {#if condition}...{:else}...{/if} and {#if condition}...{/if}
-    const if_regex = /\{#if\s+([^}]+)\}([\s\S]*?)\{\/if\}/g;
-    return html.replace(if_regex, (match, condition, inner) => {
-        // Split by {:else} if present
-        const parts = inner.split(/\{:else\}/);
-        const if_content = parts[0];
-        const else_content = parts[1] || '';
-        // Evaluate condition
-        const is_truthy = evaluate_condition(condition.trim(), content);
-        return is_truthy ? if_content : else_content;
-    });
-}
-function evaluate_condition(condition, content) {
-    // Handle obj?.prop patterns
-    const optional_match = condition.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\?\.(\w+)$/);
-    if (optional_match) {
-        const obj = content[optional_match[1]];
-        if (!obj || typeof obj !== 'object')
-            return false;
-        return !!obj[optional_match[2]];
-    }
-    // Handle simple variable check
-    const simple_match = condition.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
-    if (simple_match) {
-        const value = content[simple_match[1]];
-        return !!value;
-    }
-    // Handle obj.prop patterns
-    const prop_match = condition.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\.(\w+)$/);
-    if (prop_match) {
-        const obj = content[prop_match[1]];
-        if (!obj || typeof obj !== 'object')
-            return false;
-        return !!obj[prop_match[2]];
+async function compile_block(site_dir, block_name, temp_dir) {
+    const component_path = path.join(site_dir, 'blocks', block_name, 'component.svelte');
+    try {
+        const source = await fs.readFile(component_path, 'utf-8');
+        // Compile with Svelte
+        const compiled = compile(source, {
+            generate: 'server',
+            filename: component_path,
+            css: 'external',
+            name: block_name.replace(/-/g, '_')
+        });
+        // Extract CSS
+        const css = compiled.css?.code || '';
+        // Write compiled JS for importing
+        const output_path = path.join(temp_dir, `${block_name}.compiled.js`);
+        await fs.writeFile(output_path, compiled.js.code);
+        return { js: compiled.js.code, css };
     }
-    // Default to checking if any referenced variable is truthy
-    const var_match = condition.match(/([a-zA-Z_][a-zA-Z0-9_]*)/);
-    if (var_match) {
-        return !!content[var_match[1]];
+    catch (error) {
+        console.log(chalk.yellow(`  Warning: Could not compile block "${block_name}": ${error}`));
+        return { js: '', css: '' };
     }
-    return false;
 }
-function process_each_blocks(html, content) {
-    // Handle {#each items as item}...{/each}
-    const each_regex = /\{#each\s+([^\s]+)\s+as\s+([^}]+)\}([\s\S]*?)\{\/each\}/g;
-    return html.replace(each_regex, (match, arrayName, itemName, inner) => {
-        const array = content[arrayName.trim()];
-        if (!Array.isArray(array))
-            return '';
-        // Handle "item, index" pattern
-        const [item_var, index_var] = itemName.split(',').map((s) => s.trim());
-        return array.map((item, index) => {
-            let result = inner;
-            // Replace {item.prop} patterns
-            if (typeof item === 'object' && item !== null) {
-                result = result.replace(new RegExp(`\\{${item_var}\\.(\\w+)\\}`, 'g'), (_, prop) => {
-                    const value = item[prop];
-                    if (value === undefined || value === null)
-                        return '';
-                    return escape_html(String(value));
-                });
-                // Replace {@html item.prop} patterns
-                result = result.replace(new RegExp(`\\{@html\\s+${item_var}\\.(\\w+)\\}`, 'g'), (_, prop) => {
-                    const value = item[prop];
-                    if (value === undefined || value === null)
-                        return '';
-                    return String(value);
-                });
-            }
-            // Replace {item} if item is a primitive
-            if (typeof item !== 'object') {
-                result = result.replace(new RegExp(`\\{${item_var}\\}`, 'g'), escape_html(String(item)));
-            }
-            // Replace index variable if present
-            if (index_var) {
-                result = result.replace(new RegExp(`\\{${index_var}\\}`, 'g'), String(index));
-            }
-            return result;
-        }).join('');
-    });
+function generate_page_component(components, sections) {
+    const imports = sections.map((section, i) => {
+        const safe_name = section.block.replace(/-/g, '_');
+        return `import Section_${i} from './${section.block}.compiled.js'`;
+    }).join('\n');
+    const props_declarations = sections.map((_, i) => {
+        return `section_${i}_props = {}`;
+    }).join(',\n\t');
+    const section_renders = sections.map((_, i) => {
+        return `<Section_${i} {...section_${i}_props} />`;
+    }).join('\n\t\t');
+    return `<script module>
+${imports}
+</script>
+
+<script>
+let {
+	${props_declarations}
+} = $props()
+</script>
+
+<main>
+	${section_renders}
+</main>`;
 }
-function get_nested_value(obj, path) {
-    const parts = path.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (typeof current !== 'object')
-            return undefined;
-        current = current[part];
+function generate_empty_page(site_name, page_name, head_content) {
+    const title = page_name === 'Home' ? site_name : `${page_name} | ${site_name}`;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${escape_html(title)}</title>
+	<style>${CSS_RESET}</style>
+${head_content}
+</head>
+<body>
+</body>
+</html>`;
+}
+function generate_error_page(site_name, page_name, error, head_content) {
+    const title = page_name === 'Home' ? site_name : `${page_name} | ${site_name}`;
+    // Extract just the CSS from head_content
+    let head_css = '';
+    const style_match = head_content.match(/<style[^>]*>([\s\S]*?)<\/style>/i);
+    if (style_match) {
+        head_css = style_match[1];
     }
-    return current;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${escape_html(title)}</title>
+	<style>
+${CSS_RESET}
+${head_css}
+	</style>
+</head>
+<body>
+	<div style="padding: 2rem; text-align: center;">
+		<h1>Build Error</h1>
+		<p style="color: #888;">${escape_html(error)}</p>
+	</div>
+</body>
+</html>`;
 }
-function normalize_content(content) {
-    // Some content values come as arrays (from CMS), normalize to single values
-    const normalized = {};
-    for (const [key, value] of Object.entries(content)) {
-        if (Array.isArray(value) && value.length > 0) {
-            // Use first item if it's an array of primitives or objects
-            normalized[key] = value[0];
+async function find_pages(pages_dir) {
+    const pages = [];
+    async function scan(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
         }
-        else {
-            normalized[key] = value;
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full_path = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await scan(full_path);
+            }
+            else if (entry.name.endsWith('.yaml')) {
+                pages.push(full_path);
+            }
         }
     }
-    return normalized;
+    await scan(pages_dir);
+    return pages;
+}
+function get_page_path_from_file(site_dir, page_file) {
+    const pages_dir = path.join(site_dir, 'pages');
+    let relative_path = path.relative(pages_dir, page_file);
+    relative_path = relative_path.replaceAll('\\', '/');
+    relative_path = relative_path.replace(/\.yaml$/i, '');
+    if (relative_path === 'index') {
+        return '';
+    }
+    if (relative_path.endsWith('/index')) {
+        return relative_path.slice(0, -'/index'.length);
+    }
+    return relative_path;
 }
 function escape_html(str) {
     return str
@@ -333,35 +420,8 @@ function escape_html(str) {
         .replace(/"/g, '&quot;')
         .replace(/'/g, '&#039;');
 }
-function generate_html(site_name, page_name, body, css) {
-    const title = page_name === 'Home' ? site_name : `${page_name} | ${site_name}`;
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="UTF-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1.0">
-	<title>${escape_html(title)}</title>
-	<style>
-		*, *::before, *::after {
-			box-sizing: border-box;
-		}
-		body {
-			margin: 0;
-			font-family: system-ui, -apple-system, sans-serif;
-			line-height: 1.5;
-		}
-		img {
-			max-width: 100%;
-			height: auto;
-		}
-${css}
-	</style>
-</head>
-<body>
-${body}
-</body>
-</html>
-`;
+function safe_temp_id(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, '_') || 'page';
 }
 async function copy_dir(src, dest) {
     await fs.mkdir(dest, { recursive: true });
@@ -377,3 +437,159 @@ async function copy_dir(src, dest) {
         }
     }
 }
+async function load_layout(site_dir, page_type) {
+    const layout_path = path.join(site_dir, 'page-types', page_type, 'layout.yaml');
+    try {
+        const content = await fs.readFile(layout_path, 'utf-8');
+        return load_yaml(content);
+    }
+    catch {
+        // No layout file, return empty layout
+        return {};
+    }
+}
+async function resolve_layout_sections(sections, site_dir, site_data) {
+    // For layout sections without content, load from block's content.yaml
+    const resolved = [];
+    for (const section of sections) {
+        let content;
+        if (section.content && Object.keys(section.content).length > 0) {
+            content = section.content;
+        }
+        else {
+            // Try to load default content from block's content.yaml
+            content = await load_block_defaults(site_dir, section.block);
+        }
+        // Resolve any site-field references in the content
+        const resolved_content = await resolve_site_fields(site_dir, section.block, content, site_data);
+        resolved.push({ ...section, content: resolved_content });
+    }
+    return resolved;
+}
+async function resolve_page_sections(sections, site_dir, site_data) {
+    // Resolve site-field references in page sections
+    const resolved = [];
+    for (const section of sections) {
+        const content = section.content || {};
+        const resolved_content = await resolve_site_fields(site_dir, section.block, content, site_data);
+        resolved.push({ ...section, content: resolved_content });
+    }
+    return resolved;
+}
+async function load_block_defaults(site_dir, block_name) {
+    const content_path = path.join(site_dir, 'blocks', block_name, 'content.yaml');
+    try {
+        const content = await fs.readFile(content_path, 'utf-8');
+        return load_yaml(content) || {};
+    }
+    catch {
+        return {};
+    }
+}
+async function load_fields_file(file_path) {
+    const data = await fs.readFile(file_path, 'utf-8');
+    return load_yaml(data);
+}
+function extract_fields_array(data) {
+    if (Array.isArray(data)) {
+        return data;
+    }
+    if (data && typeof data === 'object' && Array.isArray(data.fields)) {
+        return data.fields;
+    }
+    return [];
+}
+function get_field_id(field) {
+    return field._id || field.id;
+}
+async function load_site_data(site_dir) {
+    const fields_path = path.join(site_dir, 'site', 'fields.yaml');
+    const content_path = path.join(site_dir, 'site', 'content.yaml');
+    let fields = [];
+    let content = {};
+    try {
+        fields = extract_fields_array(await load_fields_file(fields_path));
+    }
+    catch {
+        // No site fields defined
+    }
+    try {
+        const content_data = await fs.readFile(content_path, 'utf-8');
+        content = load_yaml(content_data) || {};
+    }
+    catch {
+        // No site content defined
+    }
+    return { fields, content };
+}
+async function load_block_fields(site_dir, block_name) {
+    const fields_path = path.join(site_dir, 'blocks', block_name, 'fields.yaml');
+    try {
+        return extract_fields_array(await load_fields_file(fields_path));
+    }
+    catch {
+        return [];
+    }
+}
+async function resolve_site_fields(site_dir, block_name, content, site_data) {
+    // Load block field definitions to check for site-field types
+    const block_fields = await load_block_fields(site_dir, block_name);
+    // Create maps for site field lookup
+    const site_field_id_map = new Map(); // ID -> name
+    const site_field_name_set = new Set(); // names that exist
+    for (const site_field of site_data.fields) {
+        const site_field_id = get_field_id(site_field);
+        if (site_field_id) {
+            site_field_id_map.set(site_field_id, site_field.name);
+        }
+        site_field_name_set.add(site_field.name);
+    }
+    // Resolve site-field references in content
+    const resolved = { ...content };
+    // For each block field that is type site-field, resolve its value
+    for (const field of block_fields) {
+        if (field.type !== 'site-field')
+            continue;
+        const field_ref = field.config?.field;
+        if (field_ref) {
+            // Field reference can be either a name or an ID
+            // Try as name first (new format)
+            if (site_field_name_set.has(field_ref) && site_data.content[field_ref] !== undefined) {
+                resolved[field.name] = site_data.content[field_ref];
+                continue;
+            }
+            // Try as ID (old format)
+            const site_field_name = site_field_id_map.get(field_ref);
+            if (site_field_name && site_data.content[site_field_name] !== undefined) {
+                resolved[field.name] = site_data.content[site_field_name];
+                continue;
+            }
+        }
+        // Fallback: if block field name matches a site field name, use that value
+        if (site_field_name_set.has(field.name) && site_data.content[field.name] !== undefined) {
+            resolved[field.name] = site_data.content[field.name];
+        }
+    }
+    return resolved;
+}
+async function find_svelte_path() {
+    // Try to find svelte in various locations
+    const possible_paths = [
+        // In primo-cli's node_modules (when npm linked or installed globally)
+        path.join(path.dirname(fileURLToPath(import.meta.url)), '../../node_modules/svelte'),
+        // In the current project's node_modules
+        path.join(process.cwd(), 'node_modules/svelte'),
+        // Try resolving from this file's location
+        path.join(path.dirname(fileURLToPath(import.meta.url)), '../../../node_modules/svelte')
+    ];
+    for (const p of possible_paths) {
+        try {
+            await fs.access(p);
+            return p;
+        }
+        catch {
+            // Continue to next path
+        }
+    }
+    throw new Error('Could not find svelte package. Make sure svelte is installed.');
+}