@embeddables/cli 0.1.0

package/dist/commands/dev.js

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import pc from 'picocolors';
+import prompts from 'prompts';
+import { compileAllPages } from '../compiler/index.js';
+import { startProxyServer } from '../proxy/server.js';
+import { formatError } from '../compiler/errors.js';
+async function discoverEmbeddables() {
+    const embeddablesDir = 'embeddables';
+    if (!fs.existsSync(embeddablesDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(embeddablesDir, { withFileTypes: true });
+    const embeddables = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const id = entry.name;
+        const configPath = path.join(embeddablesDir, id, 'config.json');
+        let title = null;
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                title = config.title || null;
+            }
+            catch {
+                // Ignore JSON parse errors
+            }
+        }
+        embeddables.push({ id, title });
+    }
+    // Sort by title (with title) first, then by id
+    return embeddables.sort((a, b) => {
+        if (a.title && !b.title)
+            return -1;
+        if (!a.title && b.title)
+            return 1;
+        const aLabel = a.title || a.id;
+        const bLabel = b.title || b.id;
+        return aLabel.localeCompare(bLabel);
+    });
+}
+async function promptForEmbeddable() {
+    const embeddables = await discoverEmbeddables();
+    if (embeddables.length === 0) {
+        console.error('No embeddables found in the embeddables/ directory.');
+        console.error('Run `embeddables pull --id <id>` to pull an embeddable first.');
+        return null;
+    }
+    const choices = embeddables.map((e) => ({
+        title: e.title ? `${e.title} (${e.id})` : e.id,
+        value: e.id,
+    }));
+    const response = await prompts({
+        type: 'select',
+        name: 'id',
+        message: 'Select an embeddable to run:',
+        choices,
+    }, {
+        onCancel: () => {
+            process.exit(0);
+        },
+    });
+    return response.id || null;
+}
+export async function runDev(opts) {
+    let embeddableId = opts.id;
+    if (!embeddableId) {
+        const selected = await promptForEmbeddable();
+        if (!selected) {
+            process.exit(1);
+        }
+        embeddableId = selected;
+    }
+    const pagesGlob = opts.pages || `embeddables/${embeddableId}/pages/**/*.page.tsx`;
+    const outPath = opts.out || path.join('embeddables', embeddableId, '.generated', 'embeddable.json');
+    const stylesDir = path.join('embeddables', embeddableId, 'styles');
+    const stylesGlob = `embeddables/${embeddableId}/styles/**/*.css`;
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    const globalComponentsGlob = `embeddables/${embeddableId}/global-components/**/*.location.tsx`;
+    const computedFieldsGlob = `embeddables/${embeddableId}/computed-fields/**/*.js`;
+    const actionsGlob = `embeddables/${embeddableId}/actions/**/*.js`;
+    // Initial build
+    try {
+        await compileAllPages({
+            pagesGlob,
+            outPath,
+            pageKeyFrom: opts.pageKeyFrom,
+            stylesDir,
+            embeddableId,
+            configPath,
+        });
+    }
+    catch (e) {
+        console.error(formatError(e));
+        process.exit(1);
+    }
+    // Start proxy
+    const port = Number(opts.port);
+    const proxy = await startProxyServer({
+        port,
+        engineOrigin: opts.engine,
+        overrideRoute: opts.overrideRoute,
+        generatedJsonPath: outPath,
+        embeddableId,
+        watchWorkbench: true,
+    });
+    // Watch all source files: pages, styles, config, global components, computed fields, and actions
+    const watcher = chokidar.watch([pagesGlob, stylesGlob, configPath, globalComponentsGlob, computedFieldsGlob, actionsGlob], {
+        ignoreInitial: true,
+    });
+    const rebuild = async () => {
+        try {
+            await compileAllPages({
+                pagesGlob,
+                outPath,
+                pageKeyFrom: opts.pageKeyFrom,
+                stylesDir,
+                embeddableId,
+                configPath,
+            });
+            proxy.broadcastReload();
+        }
+        catch (e) {
+            // Keep dev server running; compiler errors show in console.
+            // (Proxy will still serve the last good JSON.)
+            console.error(formatError(e));
+        }
+    };
+    let t;
+    watcher.on('all', () => {
+        clearTimeout(t);
+        t = setTimeout(rebuild, 80);
+    });
+    console.log(`Watching embeddables/${embeddableId}/ for changes...`);
+    console.log('');
+    const terminalWidth = process.stdout.columns || 80;
+    const separator = '━'.repeat(terminalWidth);
+    console.log(`${pc.bold(pc.cyan(separator))}`);
+    console.log('');
+    if (opts.remote) {
+        console.log(`${pc.bold(pc.yellow('Mode:'))} ${pc.yellow('Remote')} (using ${opts.engine})`);
+    }
+    else {
+        console.log(`${pc.bold(pc.blue('Mode:'))} ${pc.blue('Local')} (using ${opts.engine})`);
+    }
+    console.log('');
+    console.log(`${pc.bold(pc.green('Preview URL:'))} ${pc.underline(pc.cyan(`http://localhost:${port}?id=${embeddableId}&version=latest`))}`);
+    console.log('');
+    console.log(`${pc.bold(pc.cyan(separator))}`);
+    console.log('');
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+export declare function runLogin(): Promise<void>;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAUA,wBAAsB,QAAQ,kBAyH7B"}

package/dist/commands/login.js

@@ -0,0 +1,112 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { getSupabaseClient, writeAuthConfig, readAuthConfig, SUPABASE_URL, SUPABASE_ANON_KEY, } from '../auth/index.js';
+export async function runLogin() {
+    try {
+        const supabase = getSupabaseClient();
+        // Check if already logged in
+        const existingConfig = readAuthConfig();
+        if (existingConfig?.access_token) {
+            const { overwrite } = await prompts({
+                type: 'confirm',
+                name: 'overwrite',
+                message: 'You are already logged in. Do you want to log in again?',
+                initial: false,
+            });
+            if (!overwrite) {
+                console.log(pc.green('Login cancelled.'));
+                return;
+            }
+        }
+        // Prompt for email
+        const { email } = await prompts({
+            type: 'text',
+            name: 'email',
+            message: 'Enter your email address:',
+            validate: (value) => {
+                if (!value)
+                    return 'Email is required';
+                if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                    return 'Please enter a valid email address';
+                }
+                return true;
+            },
+        });
+        if (!email) {
+            console.log(pc.red('Login cancelled.'));
+            return;
+        }
+        console.log('');
+        console.log(pc.cyan('Sending verification code to your email...'));
+        // Send OTP code
+        const { error: sendError } = await supabase.auth.signInWithOtp({
+            email,
+        });
+        if (sendError) {
+            console.error(pc.red(`Error sending verification code: ${sendError.message}`));
+            process.exit(1);
+        }
+        console.log('');
+        console.log(pc.green('✓ Verification code sent!'));
+        console.log(pc.dim('Please check your email for the code.'));
+        console.log('');
+        // Prompt for OTP code
+        const { code } = await prompts({
+            type: 'text',
+            name: 'code',
+            message: 'Enter the verification code from your email:',
+            validate: (value) => {
+                if (!value)
+                    return 'Verification code is required';
+                if (!/^\d{6}$/.test(value.trim())) {
+                    return 'Please enter a valid 6-digit code';
+                }
+                return true;
+            },
+        });
+        if (!code) {
+            console.log(pc.red('Login cancelled.'));
+            return;
+        }
+        console.log('');
+        console.log(pc.cyan('Verifying code...'));
+        // Verify OTP code
+        const { data, error: verifyError } = await supabase.auth.verifyOtp({
+            email,
+            token: code.trim(),
+            type: 'email',
+        });
+        if (verifyError) {
+            console.error(pc.red(`Error verifying code: ${verifyError.message}`));
+            process.exit(1);
+        }
+        if (!data.session) {
+            console.error(pc.red('No session returned from verification'));
+            process.exit(1);
+        }
+        // Store auth config
+        const config = {
+            access_token: data.session.access_token,
+            refresh_token: data.session.refresh_token,
+            expires_at: data.session.expires_at || Math.floor(Date.now() / 1000) + 3600, // Default 1 hour if not provided
+            supabase_url: SUPABASE_URL,
+            supabase_anon_key: SUPABASE_ANON_KEY,
+        };
+        writeAuthConfig(config);
+        console.log('');
+        console.log(pc.green('✓ Successfully logged in!'));
+        console.log('');
+    }
+    catch (error) {
+        if (error.name === 'ExitPrompt') {
+            // User cancelled prompt (Ctrl+C)
+            console.log('');
+            console.log(pc.red('Login cancelled.'));
+            process.exit(0);
+        }
+        else {
+            console.error(pc.red(`Error during login: ${error.message}`));
+            process.exit(1);
+        }
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+export declare function runLogout(): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../src/commands/logout.ts"],"names":[],"mappings":"AAGA,wBAAsB,SAAS,kBAe9B"}

package/dist/commands/logout.js

@@ -0,0 +1,18 @@
+import pc from 'picocolors';
+import { deleteAuthConfig, isLoggedIn } from '../auth/index.js';
+export async function runLogout() {
+    try {
+        if (!isLoggedIn()) {
+            console.log(pc.yellow('You are not currently logged in.'));
+            return;
+        }
+        deleteAuthConfig();
+        console.log('');
+        console.log(pc.green('✓ Successfully logged out!'));
+        console.log('');
+    }
+    catch (error) {
+        console.error(pc.red(`Error during logout: ${error.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,7 @@
+export declare function runPull(opts: {
+    id: string;
+    out?: string;
+    branch?: string;
+    fix?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=pull.d.ts.map

package/dist/commands/pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/commands/pull.ts"],"names":[],"mappings":"AAOA,wBAAsB,OAAO,CAAC,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,iBA0G/F"}

package/dist/commands/pull.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { reverseCompile } from '../compiler/reverse.js';
+import { getAccessToken } from '../auth/index.js';
+export async function runPull(opts) {
+    const embeddableId = opts.id;
+    let url = `https://engine.embeddables.com/${embeddableId}?version=latest`;
+    if (opts.branch) {
+        url += `&embeddable_branch=${opts.branch}`;
+    }
+    const outPath = opts.out || path.join('embeddables', embeddableId, '.generated', 'embeddable.json');
+    console.log(`Fetching embeddable from ${url}...`);
+    try {
+        // Add authentication header if available
+        const accessToken = getAccessToken();
+        const headers = {};
+        if (accessToken) {
+            headers['Authorization'] = `Bearer ${accessToken}`;
+        }
+        const response = await fetch(url, {
+            headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch embeddable: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const flow = data.flow;
+        if (!flow) {
+            throw new Error("Response does not contain a 'flow' property");
+        }
+        // Save to embeddables/<id>/.generated/embeddable.json
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        const flowJson = JSON.stringify(flow, null, 2);
+        fs.writeFileSync(outPath, flowJson, 'utf8');
+        console.log(pc.cyan(`✓ Saved embeddable JSON to ${outPath}`));
+        // Also save version-specific file (e.g. embeddable-v135.json) when version is present in response
+        const version = data.version ?? data.embeddable_version ?? flow.version;
+        if (version != null) {
+            const versionStr = typeof version === 'string' ? version : String(version);
+            const versionLabel = versionStr.startsWith('v') ? versionStr : `v${versionStr}`;
+            const versionedBasename = `embeddable-${versionLabel}.json`;
+            const versionedPath = path.join(path.dirname(outPath), versionedBasename);
+            fs.writeFileSync(versionedPath, flowJson, 'utf8');
+            console.log(pc.cyan(`✓ Saved embeddable JSON to ${versionedPath}`));
+        }
+        // Clear existing pages, styles, computed-fields, actions, and global-components before generating new ones
+        const pagesDir = path.join('embeddables', embeddableId, 'pages');
+        const stylesDir = path.join('embeddables', embeddableId, 'styles');
+        const computedFieldsDir = path.join('embeddables', embeddableId, 'computed-fields');
+        const actionsDir = path.join('embeddables', embeddableId, 'actions');
+        const globalComponentsDir = path.join('embeddables', embeddableId, 'global-components');
+        if (fs.existsSync(pagesDir)) {
+            const existingPages = fs.readdirSync(pagesDir).filter((f) => f.endsWith('.page.tsx'));
+            for (const page of existingPages) {
+                fs.unlinkSync(path.join(pagesDir, page));
+            }
+            console.log(`${pc.gray(`Cleared ${existingPages.length} existing page(s)`)}`);
+        }
+        if (fs.existsSync(stylesDir)) {
+            const existingStyles = fs.readdirSync(stylesDir).filter((f) => f.endsWith('.css'));
+            for (const style of existingStyles) {
+                fs.unlinkSync(path.join(stylesDir, style));
+            }
+            console.log(`${pc.gray(`Cleared ${existingStyles.length} existing style file(s)`)}`);
+        }
+        if (fs.existsSync(computedFieldsDir)) {
+            const existingFields = fs.readdirSync(computedFieldsDir).filter((f) => f.endsWith('.js'));
+            for (const field of existingFields) {
+                fs.unlinkSync(path.join(computedFieldsDir, field));
+            }
+            console.log(`${pc.gray(`Cleared ${existingFields.length} existing computed field(s)`)}`);
+        }
+        if (fs.existsSync(actionsDir)) {
+            const existingActions = fs.readdirSync(actionsDir).filter((f) => f.endsWith('.js'));
+            for (const action of existingActions) {
+                fs.unlinkSync(path.join(actionsDir, action));
+            }
+            console.log(`${pc.gray(`Cleared ${existingActions.length} existing action(s)`)}`);
+        }
+        if (fs.existsSync(globalComponentsDir)) {
+            const existingGlobalComponents = fs
+                .readdirSync(globalComponentsDir)
+                .filter((f) => f.endsWith('.location.tsx'));
+            for (const component of existingGlobalComponents) {
+                fs.unlinkSync(path.join(globalComponentsDir, component));
+            }
+            console.log(`${pc.gray(`Cleared ${existingGlobalComponents.length} existing global component(s)`)}`);
+        }
+        // Run reverse compiler
+        await reverseCompile(flow, embeddableId, { fix: opts.fix });
+    }
+    catch (error) {
+        console.error('Error pulling embeddable:', error);
+        process.exit(1);
+    }
+}

package/dist/compiler/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class CompileError extends Error {
+    info?: {
+        file?: string;
+        line?: number;
+        column?: number;
+        pageKey?: string;
+        componentId?: string;
+        componentKey?: string;
+    } | undefined;
+    constructor(message: string, info?: {
+        file?: string;
+        line?: number;
+        column?: number;
+        pageKey?: string;
+        componentId?: string;
+        componentKey?: string;
+    } | undefined);
+}
+export declare function formatError(e: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/compiler/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/compiler/errors.ts"],"names":[],"mappings":"AAEA,qBAAa,YAAa,SAAQ,KAAK;IAG5B,IAAI,CAAC,EAAE;QACZ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB;gBARD,OAAO,EAAE,MAAM,EACR,IAAI,CAAC,EAAE;QACZ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB,YAAA;CAIJ;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,UAkCrC"}

package/dist/compiler/errors.js

@@ -0,0 +1,35 @@
+import pc from 'picocolors';
+export class CompileError extends Error {
+    info;
+    constructor(message, info) {
+        super(message);
+        this.info = info;
+    }
+}
+export function formatError(e) {
+    if (e instanceof CompileError) {
+        const parts = [];
+        // File location
+        if (e.info?.file && e.info?.line != null) {
+            parts.push(`${pc.cyan(e.info.file)}:${pc.yellow(String(e.info.line))}:${pc.yellow(String(e.info.column ?? 0))}`);
+        }
+        // Page context
+        if (e.info?.pageKey) {
+            parts.push(`page: ${pc.magenta(e.info.pageKey)}`);
+        }
+        // Component context
+        if (e.info?.componentId || e.info?.componentKey) {
+            const componentParts = [];
+            if (e.info.componentId) {
+                componentParts.push(`id=${pc.cyan(e.info.componentId)}`);
+            }
+            if (e.info.componentKey) {
+                componentParts.push(`key=${pc.cyan(e.info.componentKey)}`);
+            }
+            parts.push(`component (${componentParts.join(', ')})`);
+        }
+        const where = parts.length > 0 ? parts.join(' | ') : '';
+        return `${pc.red('Error')} ${where}\n${e.message}`;
+    }
+    return String(e);
+}

package/dist/compiler/evalStatic.d.ts

@@ -0,0 +1,3 @@
+import type * as t from '@babel/types';
+export declare function evalStatic(node: t.Node, constEnv: Map<string, any>, file: string): any;
+//# sourceMappingURL=evalStatic.d.ts.map

package/dist/compiler/evalStatic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evalStatic.d.ts","sourceRoot":"","sources":["../../src/compiler/evalStatic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAA;AAEtC,wBAAgB,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CA+DtF"}

package/dist/compiler/evalStatic.js

@@ -0,0 +1,57 @@
+import { CompileError } from './errors.js';
+export function evalStatic(node, constEnv, file) {
+    switch (node.type) {
+        case 'StringLiteral':
+            return node.value;
+        case 'TemplateLiteral': {
+            // Support template literals with {{variable}} syntax (templating system)
+            // These are written as {`{{variable}}`} in JSX and should be converted to plain strings
+            // Note: {{variable}} is just a string pattern, not a JavaScript expression
+            // Template literals with actual expressions (${...}) are not supported
+            if (node.expressions.length > 0) {
+                throw new CompileError('Template literals with expressions are not supported. Use plain strings only.', loc(file, node));
+            }
+            // For simple template literals (no expressions), concatenate all quasis
+            // Use cooked value if available, otherwise fall back to raw
+            // This handles {`{{first_name}}'s plan`} → "{{first_name}}'s plan"
+            return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+        }
+        case 'NumericLiteral':
+            return node.value;
+        case 'BooleanLiteral':
+            return node.value;
+        case 'NullLiteral':
+            return null;
+        case 'ArrayExpression':
+            return node.elements.map((el) => {
+                if (!el)
+                    return null;
+                return evalStatic(el, constEnv, file);
+            });
+        case 'ObjectExpression': {
+            const out = {};
+            for (const prop of node.properties) {
+                if (prop.type !== 'ObjectProperty') {
+                    throw new CompileError('Only plain object literals are supported.', loc(file, node));
+                }
+                if (prop.key.type !== 'Identifier' && prop.key.type !== 'StringLiteral') {
+                    throw new CompileError('Only identifier/string keys supported in objects.', loc(file, node));
+                }
+                const k = prop.key.type === 'Identifier' ? prop.key.name : prop.key.value;
+                out[k] = evalStatic(prop.value, constEnv, file);
+            }
+            return out;
+        }
+        case 'Identifier': {
+            if (!constEnv.has(node.name)) {
+                throw new CompileError(`Unknown identifier "${node.name}" (must be a static const).`, loc(file, node));
+            }
+            return constEnv.get(node.name);
+        }
+        default:
+            throw new CompileError(`Unsupported expression "${node.type}". Use literals/arrays/objects/static const identifiers only.`, loc(file, node));
+    }
+}
+function loc(file, node) {
+    return { file, line: node.loc?.start?.line, column: node.loc?.start?.column };
+}

package/dist/compiler/flatten.js

@@ -0,0 +1 @@
+"use strict";

package/dist/compiler/helpers/duplicateIds.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared helpers for deduplicating component/button IDs in forward and reverse compilers.
+ */
+/**
+ * Generates a new unique ID based on component/button type, e.g. plaintext_abcdefghij,
+ * button_abcdef, option_abcde. Used when deduplicating IDs in forward and reverse compilers.
+ */
+export declare function generateRandomIdByType(componentType: string, isOptionButton: boolean, existingIds: Set<string>, alsoExclude: Iterable<string>): string;
+//# sourceMappingURL=duplicateIds.d.ts.map

package/dist/compiler/helpers/duplicateIds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicateIds.d.ts","sourceRoot":"","sources":["../../../src/compiler/helpers/duplicateIds.ts"],"names":[],"mappings":"AAAA;;GAEG;AAwDH;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,OAAO,EACvB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC5B,MAAM,CAaR"}

package/dist/compiler/helpers/duplicateIds.js

@@ -0,0 +1,71 @@
+/**
+ * Shared helpers for deduplicating component/button IDs in forward and reverse compilers.
+ */
+const ID_RANDOM_CHARS = 'abcdefghijklmnopqrstuvwxyz';
+/**
+ * Returns { prefix, suffixLen } for type-based ID generation.
+ * OptionSelector buttons use prefix "option" and length 5; components use a switch over type.
+ */
+function getIdPrefixAndLength(componentType, isOptionButton) {
+    if (isOptionButton) {
+        return { prefix: 'option', suffixLen: 12 };
+    }
+    switch (componentType) {
+        case 'PlainText':
+            return { prefix: 'text', suffixLen: 12 };
+        case 'CustomButton':
+            return { prefix: 'button', suffixLen: 12 };
+        case 'Container':
+            return { prefix: 'container', suffixLen: 12 };
+        case 'RichTextMarkdown':
+            return { prefix: 'richtext', suffixLen: 12 };
+        case 'CustomHTML':
+            return { prefix: 'html', suffixLen: 12 };
+        case 'InputBox':
+            return { prefix: 'input', suffixLen: 12 };
+        case 'OptionSelector':
+            return { prefix: 'optionselector', suffixLen: 12 };
+        case 'StripeCheckout2':
+            return { prefix: 'stripe', suffixLen: 12 };
+        case 'PaypalCheckout':
+            return { prefix: 'paypal', suffixLen: 12 };
+        case 'MediaImage':
+            return { prefix: 'image', suffixLen: 12 };
+        case 'MediaEmbed':
+            return { prefix: 'embed', suffixLen: 12 };
+        case 'Lottie':
+            return { prefix: 'lottie', suffixLen: 12 };
+        case 'Rive':
+            return { prefix: 'rive', suffixLen: 12 };
+        case 'ProgressBar':
+            return { prefix: 'progressbar', suffixLen: 12 };
+        case 'FileUpload':
+            return { prefix: 'fileupload', suffixLen: 12 };
+        case 'BookMeeting':
+            return { prefix: 'bookmeeting', suffixLen: 12 };
+        case 'Chart':
+            return { prefix: 'chart', suffixLen: 12 };
+        default:
+            return { prefix: componentType.toLowerCase(), suffixLen: 12 };
+    }
+}
+/**
+ * Generates a new unique ID based on component/button type, e.g. plaintext_abcdefghij,
+ * button_abcdef, option_abcde. Used when deduplicating IDs in forward and reverse compilers.
+ */
+export function generateRandomIdByType(componentType, isOptionButton, existingIds, alsoExclude) {
+    const { prefix, suffixLen } = getIdPrefixAndLength(componentType, isOptionButton);
+    const excluded = new Set(existingIds);
+    for (const id of alsoExclude)
+        excluded.add(id);
+    for (;;) {
+        let suffix = '';
+        for (let i = 0; i < suffixLen; i++) {
+            suffix += ID_RANDOM_CHARS[Math.floor(Math.random() * ID_RANDOM_CHARS.length)];
+        }
+        const candidate = `${prefix}_${suffix}`;
+        if (!excluded.has(candidate))
+            return candidate;
+        excluded.add(candidate); // avoid retrying same value
+    }
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a copy of newVal with object key order (recursively) matching oldVal
+ * where possible. Keeps existing keys in old order; appends new keys at the end.
+ * Arrays are not reordered; we recurse into elements by index for nested objects.
+ * Used so embeddable.json diffs show only actual changes, not reordering noise.
+ */
+export declare function reorderObjectKeysToMatch(oldVal: unknown, newVal: unknown): unknown;
+export declare function compileAllPages(opts: {
+    pagesGlob: string;
+    outPath: string;
+    pageKeyFrom: 'filename' | 'export';
+    stylesDir?: string;
+    embeddableId?: string;
+    configPath?: string;
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/compiler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compiler/index.ts"],"names":[],"mappings":"AA+CA;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CA2DlF;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,UAAU,GAAG,QAAQ,CAAA;IAClC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,iBA8WA"}