@squeditor/squeditor-framework 1.0.0

package/scripts/copy-static.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const projectRoot = process.cwd();
+const config = require(path.join(projectRoot, 'squeditor.config.js'));
+const micromatch = require(path.join(projectRoot, 'node_modules/micromatch'));
+
+let sharp;
+try {
+    sharp = require(path.join(projectRoot, 'node_modules/sharp'));
+} catch (e) {
+    console.warn('[Squeditor] ⚠️ sharp not found. Image optimization will be skipped.');
+}
+
+let ffmpeg;
+try {
+    ffmpeg = require(path.join(projectRoot, 'node_modules/fluent-ffmpeg'));
+} catch (e) {
+    console.warn('[Squeditor] ⚠️ fluent-ffmpeg not found. Video optimization will be skipped.');
+}
+
+const srcDir = path.join(projectRoot, 'src/assets/static');
+const destDir = path.join(projectRoot, config.snapshot.outputDir, 'assets/static');
+
+const mediaConfig = config.media || {};
+const optConfig = mediaConfig.optimize || { enabled: false };
+
+async function processFile(src, dest, relPath) {
+    const isOptimizeEnabled = optConfig.enabled;
+    const isMatched = isOptimizeEnabled && micromatch.isMatch(relPath, optConfig.include || [], { ignore: optConfig.exclude || [] });
+
+    const ext = path.extname(src).toLowerCase();
+    const isImage = ['.jpg', '.jpeg', '.png', '.webp', '.gif'].includes(ext);
+    const isVideo = ['.mp4', '.webm'].includes(ext);
+
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+    if (isMatched) {
+        if (isImage && sharp) {
+            try {
+                console.log(`   - Optimizing image: ${relPath}`);
+                let pipeline = sharp(src);
+
+                const quality = optConfig.imageQuality || 80;
+
+                if (ext === '.jpg' || ext === '.jpeg') {
+                    pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+                } else if (ext === '.png') {
+                    pipeline = pipeline.png({ quality, compressionLevel: 9, palette: true });
+                } else if (ext === '.webp') {
+                    pipeline = pipeline.webp({ quality, effort: 6 });
+                } else if (ext === '.gif') {
+                    pipeline = pipeline.gif(); // Standard gif optimization
+                }
+
+                await pipeline.toFile(dest);
+
+                // --- Regression Check ---
+                // If optimized file is somehow larger than original, fallback to original
+                const originalSize = fs.statSync(src).size;
+                const optimizedSize = fs.statSync(dest).size;
+
+                if (optimizedSize > originalSize) {
+                    // console.log(`     - ℹ️ Optimized size (${optimizedSize}) > original (${originalSize}). Falling back to original.`);
+                    fs.copyFileSync(src, dest);
+                }
+
+                return;
+            } catch (err) {
+                console.error(`   - ❌ Failed to optimize image ${relPath}:`, err.message);
+            }
+        } else if (isVideo && ffmpeg) {
+            try {
+                console.log(`   - Optimizing video: ${relPath} (This may take a while...)`);
+                return new Promise((resolve, reject) => {
+                    ffmpeg(src)
+                        .outputOptions([
+                            '-c:v libx264',
+                            `-crf ${optConfig.videoQuality || 28}`,
+                            '-preset slower',
+                            '-c:a aac',
+                            '-b:a 128k',
+                            '-movflags +faststart'
+                        ])
+                        .save(dest)
+                        .on('end', () => {
+                            // Video regression check
+                            const originalSize = fs.statSync(src).size;
+                            const optimizedSize = fs.statSync(dest).size;
+                            if (optimizedSize > originalSize) {
+                                fs.copyFileSync(src, dest);
+                            }
+                            resolve();
+                        })
+                        .on('error', (err) => {
+                            console.error(`   - ❌ Failed to optimize video ${relPath}:`, err.message);
+                            fs.copyFileSync(src, dest);
+                            resolve();
+                        });
+                });
+            } catch (err) {
+                console.error(`   - ❌ Video optimization error for ${relPath}:`, err.message);
+            }
+        }
+    }
+
+    // Default: Just copy
+    fs.copyFileSync(src, dest);
+}
+
+async function walkAndProcess(currentSrc, currentDest, baseDir) {
+    const files = fs.readdirSync(currentSrc);
+    for (const file of files) {
+        if (file === '.DS_Store') continue;
+
+        const srcPath = path.join(currentSrc, file);
+        const destPath = path.join(currentDest, file);
+        const relPath = path.relative(baseDir, srcPath);
+        const stat = fs.statSync(srcPath);
+
+        if (stat.isDirectory()) {
+            await walkAndProcess(srcPath, destPath, baseDir);
+        } else {
+            await processFile(srcPath, destPath, relPath);
+        }
+    }
+}
+
+async function run() {
+    if (fs.existsSync(srcDir)) {
+        console.log(`[Squeditor] 📂 Processing static assets from src/assets/static to dist/assets/static...`);
+        fs.mkdirSync(destDir, { recursive: true });
+
+        await walkAndProcess(srcDir, destDir, srcDir);
+
+        console.log(`[Squeditor] ✅ Static assets processed.`);
+
+        const uikitJs = path.join(projectRoot, 'src/assets/js/uikit-components.js');
+        const uikitDest = path.join(projectRoot, config.snapshot.outputDir, 'assets/js/uikit-components.js');
+        if (fs.existsSync(uikitJs)) {
+            fs.mkdirSync(path.dirname(uikitDest), { recursive: true });
+            fs.copyFileSync(uikitJs, uikitDest);
+        }
+    } else {
+        console.warn(`[Squeditor] ⚠️ Source directory for static assets not found: ${srcDir}`);
+    }
+}
+
+run();

package/scripts/dev-router.php

@@ -0,0 +1,23 @@
+<?php
+// scripts/dev-router.php
+// Custom router for PHP built-in development server (npm run dev)
+
+$uri = urldecode(parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH));
+$doc_root = $_SERVER['DOCUMENT_ROOT'];
+
+// 1. If it's a direct file request that exists, serve it natively
+if ($uri !== '/' && file_exists($doc_root . $uri)) {
+    return false;
+}
+
+// 2. If it is an HTML file request, route it to the equivalent PHP file
+if (preg_match('/\.html$/', $uri)) {
+    $php_file = preg_replace('/\.html$/', '.php', $uri);
+    if (file_exists($doc_root . $php_file)) {
+        require $doc_root . $php_file;
+        return true;
+    }
+}
+
+// 3. Let PHP's core handle index.php fallback for directories or 404s
+return false;

package/scripts/dev.js

@@ -0,0 +1,55 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const getAvailablePort = require('./get-port');
+
+async function startDev() {
+    const projectRoot = process.cwd();
+
+    // Find available ports
+    const phpPort = await getAvailablePort(3001);
+    const vitePort = await getAvailablePort(5173);
+
+    console.log(`[Squeditor] 🚀 Starting Dev Servers...`);
+    console.log(`   - PHP Server: http://127.0.0.1:${phpPort}`);
+    console.log(`   - Vite Server: http://127.0.0.1:${vitePort}`);
+
+    // Read config to resolve framework path dynamically
+    const configPath = path.join(projectRoot, 'squeditor.config.js');
+    let fwRoot = '..';
+    if (fs.existsSync(configPath)) {
+        const config = require(configPath);
+        if (config.framework) {
+            fwRoot = config.framework;
+        }
+    }
+    const devRouterPath = path.join(fwRoot, 'scripts/dev-router.php');
+
+    // Start PHP Server
+    const php = spawn('php', [
+        '-S', `127.0.0.1:${phpPort}`,
+        '-t', 'src',
+        devRouterPath
+    ], {
+        stdio: 'inherit',
+        env: { ...process.env, SQUEDITOR_PHP_PORT: phpPort, SQUEDITOR_VITE_PORT: vitePort }
+    });
+
+    // Start Vite
+    const vite = spawn('npx', [
+        'vite',
+        '--port', vitePort.toString(),
+        '--strictPort', 'false'
+    ], {
+        stdio: 'inherit',
+        env: { ...process.env, SQUEDITOR_PHP_PORT: phpPort, SQUEDITOR_VITE_PORT: vitePort }
+    });
+
+    process.on('SIGINT', () => {
+        php.kill();
+        vite.kill();
+        process.exit();
+    });
+}
+
+startDev();

package/scripts/get-port.js

@@ -0,0 +1,27 @@
+const net = require('net');
+
+/**
+ * Finds an available port starting from the given port.
+ * @param {number} startPort 
+ * @returns {Promise<number>}
+ */
+function getAvailablePort(startPort) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(startPort, '127.0.0.1', () => {
+            const { port } = server.address();
+            server.close(() => resolve(port));
+        });
+        server.on('error', () => {
+            resolve(getAvailablePort(startPort + 1));
+        });
+    });
+}
+
+// If run directly, output the port for shell scripts to capture
+if (require.main === module) {
+    const basePort = parseInt(process.argv[2]) || 3000;
+    getAvailablePort(basePort).then(port => process.stdout.write(port.toString()));
+}
+
+module.exports = getAvailablePort;

package/scripts/package-customer.js

@@ -0,0 +1,278 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const projectRoot = process.cwd();
+const config = require(path.join(projectRoot, 'squeditor.config.js'));
+const micromatch = require(path.join(projectRoot, 'node_modules/micromatch'));
+
+let sharp;
+try {
+    sharp = require(path.join(projectRoot, 'node_modules/sharp'));
+} catch (e) { }
+
+let ffmpeg;
+try {
+    ffmpeg = require(path.join(projectRoot, 'node_modules/fluent-ffmpeg'));
+} catch (e) { }
+
+const customerBuildDir = path.join(projectRoot, 'build-customer-package');
+const distDir = path.join(projectRoot, 'dist');
+const srcDir = path.join(projectRoot, 'src');
+const zipName = config.dist.zipName ? config.dist.zipName.replace('.zip', '-customer.zip') : 'customer-package.zip';
+const zipPath = path.join(projectRoot, zipName);
+
+const mediaConfig = config.media || {};
+const blurConfig = mediaConfig.blur || { enabled: false };
+const optConfig = mediaConfig.optimize || { enabled: false };
+
+async function processMediaFile(src, dest, relPath) {
+    const isBlurEnabled = blurConfig.enabled;
+    const isMatched = isBlurEnabled && micromatch.isMatch(relPath, blurConfig.include || [], { ignore: blurConfig.exclude || [] });
+
+    const ext = path.extname(src).toLowerCase();
+    const isImage = ['.jpg', '.jpeg', '.png', '.webp', '.gif'].includes(ext);
+    const isVideo = ['.mp4', '.webm'].includes(ext);
+
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+    if (isMatched) {
+        if (isImage && sharp) {
+            try {
+                console.log(`   - Blurring image: ${relPath}`);
+                let pipeline = sharp(src).blur(blurConfig.amount || 20);
+
+                // Re-apply optimization settings to the blurred output to prevent size bloat
+                const quality = optConfig.imageQuality || 80;
+                if (ext === '.jpg' || ext === '.jpeg') {
+                    pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+                } else if (ext === '.png') {
+                    pipeline = pipeline.png({ quality, compressionLevel: 9, palette: true });
+                } else if (ext === '.webp') {
+                    pipeline = pipeline.webp({ quality, effort: 6 });
+                }
+
+                await pipeline.toFile(dest);
+                return;
+            } catch (err) {
+                console.error(`   - ❌ Failed to blur image ${relPath}:`, err.message);
+            }
+        } else if (isVideo && ffmpeg) {
+            try {
+                console.log(`   - Blurring video: ${relPath} (This may take a while...)`);
+                return new Promise((resolve, reject) => {
+                    ffmpeg(src)
+                        .videoFilters(`boxblur=${blurConfig.amount || 20}:1`)
+                        .outputOptions([
+                            `-crf ${optConfig.videoQuality || 28}`,
+                            '-preset slower',
+                            '-c:a aac',
+                            '-b:a 128k'
+                        ])
+                        .save(dest)
+                        .on('end', () => {
+                            // Video regression check
+                            const originalSize = fs.statSync(src).size;
+                            const optimizedSize = fs.statSync(dest).size;
+                            if (optimizedSize > originalSize) {
+                                fs.copyFileSync(src, dest);
+                            }
+                            resolve();
+                        })
+                        .on('error', (err) => {
+                            console.error(`   - ❌ Failed to blur video ${relPath}:`, err.message);
+                            fs.copyFileSync(src, dest);
+                            resolve();
+                        });
+                });
+            } catch (err) {
+                console.error(`   - ❌ Video blur error for ${relPath}:`, err.message);
+            }
+        }
+    }
+
+    // Default: Just copy
+    fs.copyFileSync(src, dest);
+}
+
+async function walkAndProcessMedia(currentSrc, currentDest, baseDir) {
+    const files = fs.readdirSync(currentSrc);
+    for (const file of files) {
+        if (file === '.DS_Store') continue;
+
+        const srcPath = path.join(currentSrc, file);
+        const destPath = path.join(currentDest, file);
+        const relPath = path.relative(baseDir, srcPath);
+        const stat = fs.statSync(srcPath);
+
+        if (stat.isDirectory()) {
+            await walkAndProcessMedia(srcPath, destPath, baseDir);
+        } else {
+            await processMediaFile(srcPath, destPath, relPath);
+        }
+    }
+}
+
+async function createCustomerPackage() {
+    console.log('[Squeditor] 📦 Assembling Customer Package...');
+
+    if (fs.existsSync(customerBuildDir)) {
+        try {
+            execSync(`rm -rf "${customerBuildDir}"`);
+        } catch (e) {
+            console.warn(`   - ⚠️  Warning: Could not fully clean ${customerBuildDir}. You may need to run 'sudo rm -rf' on it manually.`);
+        }
+    }
+    if (fs.existsSync(zipPath)) {
+        fs.unlinkSync(zipPath);
+    }
+
+    fs.mkdirSync(path.join(customerBuildDir, 'src/assets'), { recursive: true });
+
+    console.log('   - Copying compiled HTML to src/');
+    const distHtmlFiles = fs.readdirSync(distDir).filter(file => file.endsWith('.html'));
+
+    distHtmlFiles.forEach(file => {
+        let htmlContent = fs.readFileSync(path.join(distDir, file), 'utf8');
+        htmlContent = htmlContent.replace(
+            /<link rel="stylesheet" href="assets\/css\/main_css\.css">/g,
+            '<link rel="stylesheet" href="assets/scss/main.scss">'
+        );
+        htmlContent = htmlContent.replace(
+            /<script src="assets\/js\/uikit-components\.js"><\/script>/g,
+            '<script type="module" src="assets/js/uikit-components.js"></script>'
+        );
+        fs.writeFileSync(path.join(customerBuildDir, 'src', file), htmlContent);
+    });
+
+    console.log('   - Copying necessary assets to src/assets');
+    fs.mkdirSync(path.join(customerBuildDir, 'src/assets/css'), { recursive: true });
+    fs.copyFileSync(path.join(distDir, 'assets/css/tailwind.css'), path.join(customerBuildDir, 'src/assets/css/tailwind.css'));
+    if (fs.existsSync(path.join(distDir, 'assets/css/squeditor-icons.css'))) {
+        fs.copyFileSync(path.join(distDir, 'assets/css/squeditor-icons.css'), path.join(customerBuildDir, 'src/assets/css/squeditor-icons.css'));
+    }
+
+    fs.cpSync(path.join(srcDir, 'assets/scss'), path.join(customerBuildDir, 'src/assets/scss'), { recursive: true });
+
+    const customerScssDir = path.join(customerBuildDir, 'src/assets/scss');
+    const mainScssPath = path.join(customerScssDir, 'main.scss');
+    if (fs.existsSync(mainScssPath)) {
+        let mainScssContent = fs.readFileSync(mainScssPath, 'utf8');
+        mainScssContent = mainScssContent.replace(/@import\s+['"]custom['"];\n?/g, '');
+        mainScssContent += `\n// --- CUSTOM SCRIPTS --- (These run last to override themes block cleanly)\n@import 'custom-config';\n@import 'custom';\n`;
+        fs.writeFileSync(mainScssPath, mainScssContent);
+
+        const customConfigContent = `// custom-config.scss\n// Define your theme variable overrides here.\n:root, [class*="theme-"] {\n    // --sq-color-primary: #ff0000;\n}\n`;
+        fs.writeFileSync(path.join(customerScssDir, 'custom-config.scss'), customConfigContent);
+    }
+
+    fs.mkdirSync(path.join(customerBuildDir, 'src/assets/js'), { recursive: true });
+    fs.copyFileSync(path.join(distDir, 'assets/js/uikit-components.js'), path.join(customerBuildDir, 'src/assets/js/uikit-components.js'));
+    fs.copyFileSync(path.join(distDir, 'assets/js/main.js'), path.join(customerBuildDir, 'src/assets/js/main.js'));
+
+    const staticDistPath = path.join(distDir, 'assets/static');
+    const staticCustomerPath = path.join(customerBuildDir, 'src/assets/static');
+    if (fs.existsSync(staticDistPath)) {
+        await walkAndProcessMedia(staticDistPath, staticCustomerPath, staticDistPath);
+    }
+
+    console.log('   - Generating lean package.json and vite.config.js');
+    const originalPkg = require(path.join(projectRoot, 'package.json'));
+    const customerPkg = {
+        name: originalPkg.name,
+        private: true,
+        scripts: {
+            "dev": "vite",
+            "build": "vite build",
+            "preview": "vite preview",
+            "format": "prettier --write \"src/**/*.html\""
+        },
+        dependencies: {
+            "uikit": originalPkg.dependencies.uikit
+        },
+        devDependencies: {
+            "sass": originalPkg.devDependencies.sass,
+            "vite": originalPkg.devDependencies.vite,
+            "tailwindcss": originalPkg.devDependencies.tailwindcss,
+            "autoprefixer": originalPkg.devDependencies.autoprefixer,
+            "prettier": originalPkg.devDependencies.prettier || "^3.0.0"
+        }
+    };
+    fs.writeFileSync(path.join(customerBuildDir, 'package.json'), JSON.stringify(customerPkg, null, 2));
+
+    const prettierrcContent = `{\n  "printWidth": 10000,\n  "tabWidth": 4,\n  "useTabs": false,\n  "semi": true,\n  "singleQuote": true,\n  "trailingComma": "es5",\n  "bracketSpacing": true,\n  "htmlWhitespaceSensitivity": "ignore"\n}`;
+    fs.writeFileSync(path.join(customerBuildDir, '.prettierrc'), prettierrcContent);
+
+    let rollupInputs = '';
+    distHtmlFiles.forEach(file => {
+        const name = file.replace('.html', '');
+        rollupInputs += `                '${name}': path.resolve(__dirname, 'src/${file}'),\n`;
+    });
+
+    const viteConfigContent = `import { defineConfig } from 'vite';
+import path from 'path';
+
+export default defineConfig({
+    root: 'src',
+    base: './',
+    publicDir: false,
+    server: {
+        host: '127.0.0.1',
+        port: 5173,
+        strictPort: false,
+    },
+    build: {
+        outDir: path.resolve(__dirname, 'dist'),
+        emptyOutDir: true,
+        rollupOptions: {
+            input: {
+${rollupInputs}            },
+            output: {
+                entryFileNames: 'assets/js/[name]-[hash].js',
+                assetFileNames: (assetInfo) => {
+                    const name = assetInfo.names ? assetInfo.names[0] : assetInfo.name;
+                    if (name.endsWith('.css')) return 'assets/css/[name]-[hash][extname]';
+                    return 'assets/[name]-[hash][extname]';
+                },
+            },
+        },
+    },
+    css: {
+        preprocessorOptions: {
+            scss: {
+                api: 'modern-compiler',
+                silenceDeprecations: ['import', 'legacy-js-api'],
+                additionalData: '@import "/assets/scss/_tokens.scss";',
+            },
+        },
+    },
+});
+`;
+    fs.writeFileSync(path.join(customerBuildDir, 'vite.config.js'), viteConfigContent);
+
+    const tailwindConfig = `/** @type {import('tailwindcss').Config} */\nmodule.exports = {\n    darkMode: ['selector', '.sq-theme-dark'],\n    content: [ './src/**/*.html' ],\n    theme: {\n        extend: {\n            colors: {\n                primary: 'var(--sq-color-primary)',\n                secondary: 'var(--sq-color-secondary)',\n                accent: 'var(--sq-color-accent)',\n            },\n            fontFamily: {\n                sans: ['var(--sq-font-sans)'],\n                serif: ['var(--sq-font-serif)'],\n                mono: ['var(--sq-font-mono)'],\n            },\n        },\n    },\n    plugins: [],\n}`;
+    fs.writeFileSync(path.join(customerBuildDir, 'tailwind.config.js'), tailwindConfig);
+
+    const postcssConfig = `module.exports = {\n  plugins: {\n    tailwindcss: {},\n    autoprefixer: {},\n  },\n}`;
+    fs.writeFileSync(path.join(customerBuildDir, 'postcss.config.js'), postcssConfig);
+
+    const readmeContent = `# ${config.name} - Customer Package\n\nThis package contains everything you need to use, customize, and deploy your template.\n\n## Directory Structure\n- \`src/\`: Source HTML files.\n- \`src/assets/\`: Source files for customization (SCSS, JS, Images).\n\n## How to Customize Styles\n1. Install dependencies: \`npm install\`\n2. Run live development server: \`npm run dev\`\n3. Build production assets: \`npm run build\`\n`;
+    fs.writeFileSync(path.join(customerBuildDir, 'README.md'), readmeContent);
+
+    try {
+        console.log('   - Formatting customer HTML files with Prettier...');
+        execSync('npx prettier --write "src/**/*.html" --print-width 10000 --tab-width 4', { cwd: customerBuildDir, stdio: 'ignore' });
+    } catch (e) { }
+
+    console.log(`[Squeditor] 📦 Zipping Customer Package to ${zipName}...`);
+    try {
+        // Explicitly clean up any .DS_Store files that might have been created by the OS
+        execSync(`find "${customerBuildDir}" -name ".DS_Store" -delete`, { stdio: 'ignore' });
+        execSync(`cd "${customerBuildDir}" && zip -r -9 "${zipPath}" . -x "*.DS_Store" -x "*/.DS_Store"`, { stdio: 'ignore' });
+        console.log(`[Squeditor] ✅ ZIP created: ${zipName}`);
+    } catch (e) {
+        console.error(`[Squeditor] ❌ Failed to create ZIP archive.`, e.message);
+    }
+}
+
+createCustomerPackage();

package/scripts/package-dist.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const projectRoot = process.cwd();
+const config = require(path.join(projectRoot, 'squeditor.config.js'));
+
+const distDir = path.join(projectRoot, 'dist');
+const zipName = config.dist.zipName || 'squeditor-dist.zip';
+const zipPath = path.join(projectRoot, zipName);
+
+// Clean up existing ZIP
+if (fs.existsSync(zipPath)) {
+    fs.unlinkSync(zipPath);
+}
+
+// 1. Create ZIP using system zip command
+console.log('[Squeditor] 📦 Creating ZIP archive...');
+try {
+    // Explicitly clean up any .DS_Store files that might have been created by the OS
+    execSync(`find "${distDir}" -name ".DS_Store" -delete`, { stdio: 'inherit' });
+    execSync(`cd "${distDir}" && zip -r -9 "${zipPath}" . -x "*.DS_Store" -x "*/.DS_Store"`, { stdio: 'inherit' });
+    console.log(`[Squeditor] ✅ Customer Ready: ${zipName}`);
+} catch (e) {
+    console.error(`[Squeditor] ❌ Failed to create ZIP archive using system zip.`, e);
+}
+
+const requiredDirs = ['assets/css', 'assets/js', 'assets/static/images'];
+requiredDirs.forEach(dir => {
+    if (!fs.existsSync(path.join(distDir, dir))) {
+        console.warn(`[Squeditor] ⚠️  Missing in dist: ${dir} — please verify build integrity.`);
+    }
+});
+
+// 2. Deploy preview
+function deployPreview() {
+    const platform = config.dist.previewPlatform;
+    if (!platform) return; // Skip deployment if none configured
+    console.log(`[Squeditor] 🚀 Deploying preview to ${platform}...`);
+
+    if (platform === 'netlify') {
+        try {
+            execSync('netlify deploy --dir=dist', { stdio: 'inherit', cwd: projectRoot });  // removed --open for headless
+        } catch (e) { console.error("[Squeditor] Failed to deploy netlify (you may need to login or install CLI)", e.message); }
+    } else if (platform === 'vercel') {
+        try {
+            execSync('vercel dist --yes', { stdio: 'inherit', cwd: projectRoot });
+        } catch (e) { console.error("[Squeditor] Failed to deploy vercel", e); }
+    } else {
+        console.log('[Squeditor] ⚠️  Unknown preview platform. Set config.dist.previewPlatform to "netlify" or "vercel".');
+    }
+}
+
+deployPreview();

package/scripts/scaffold.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+// scripts/scaffold.js
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const projectName = args[0];
+
+if (!projectName) {
+    console.error("Usage: node scripts/scaffold.js <project-name> --dest <optional-dest>");
+    process.exit(1);
+}
+
+let destIndex = args.indexOf('--dest');
+let destPath = destIndex !== -1 ? args[destIndex + 1] : projectName;
+const sourceDir = path.join(__dirname, '..', 'project-template');
+const targetDir = path.resolve(process.cwd(), destPath);
+
+if (!fs.existsSync(sourceDir)) {
+    console.error(`Source template directory does not exist: ${sourceDir}`);
+    process.exit(1);
+}
+
+if (fs.existsSync(targetDir)) {
+    console.error(`Target directory already exists: ${targetDir}`);
+    process.exit(1);
+}
+
+function copyDirectory(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+        if (entry.name === '.DS_Store') continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            copyDirectory(srcPath, destPath);
+        } else {
+            // Must use copyFileSync to preserve binary data (fonts, images)
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+console.log(`[Squeditor] Scaffolding new project: ${projectName}...`);
+copyDirectory(sourceDir, targetDir);
+
+// Update package.json name
+const pkgJsonPath = path.join(targetDir, 'package.json');
+if (fs.existsSync(pkgJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+    pkg.name = projectName;
+    fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
+}
+
+// Update squeditor.config.js properties
+const configPath = path.join(targetDir, 'squeditor.config.js');
+if (fs.existsSync(configPath)) {
+    let configContent = fs.readFileSync(configPath, 'utf8');
+    configContent = configContent.replace(/name:\s*['"][^'"]+['"]/, `name: '${projectName}'`);
+    configContent = configContent.replace(/zipName:\s*['"][^'"]+['"]/, `zipName: '${projectName}.zip'`);
+    fs.writeFileSync(configPath, configContent);
+}
+
+console.log(`[Squeditor] ✅ Scaffolded ${projectName} successfully at ${targetDir}`);
+console.log(`Next steps:`);
+console.log(`  cd ${destPath}`);
+console.log(`  npm install`);
+console.log(`  npm run dev`);
+console.log(`  Note: For mac, use sudo if you get permission errors!`);