@devansharora18/tardisjs 0.0.2

package/dist/bin/create-tardis-app.js

@@ -0,0 +1,2102 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import http from 'node:http';
+import net from 'node:net';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import chokidar from 'chokidar';
+import { WebSocketServer } from 'ws';
+
+const KEYWORDS = {
+    blueprint: 'BLUEPRINT',
+    props: 'PROPS',
+    state: 'STATE',
+    computed: 'COMPUTED',
+    methods: 'METHODS',
+    events: 'EVENTS',
+    style: 'STYLE',
+    ui: 'UI',
+    script: 'SCRIPT',
+    true: 'BOOLEAN',
+    false: 'BOOLEAN',
+};
+
+function lex(source) {
+    const tokens = [];
+    let i = 0;
+    let line = 1;
+    let col = 1;
+    function peek(offset = 0) {
+        return source[i + offset] ?? '';
+    }
+    function advance() {
+        const ch = source[i++];
+        if (ch === '\n') {
+            line++;
+            col = 1;
+        }
+        else {
+            col++;
+        }
+        return ch;
+    }
+    function skipWhitespace() {
+        while (i < source.length && (peek() === ' ' || peek() === '\t' || peek() === '\r')) {
+            advance();
+        }
+    }
+    function skipComment() {
+        if (peek() === '/' && peek(1) === '/') {
+            while (i < source.length && peek() !== '\n') {
+                advance();
+            }
+        }
+    }
+    function readString() {
+        advance();
+        let value = '';
+        while (i < source.length && peek() !== '"') {
+            if (peek() === '\\' && peek(1) === '"') {
+                advance();
+                value += advance();
+            }
+            else {
+                if (peek() === '\n')
+                    line++;
+                value += advance();
+            }
+        }
+        if (peek() === '"')
+            advance();
+        return value;
+    }
+    function readIdent() {
+        let value = '';
+        while (i < source.length && /[a-zA-Z0-9_$]/.test(peek())) {
+            value += advance();
+        }
+        return value;
+    }
+    function readNumber() {
+        let value = '';
+        while (i < source.length && /[0-9.]/.test(peek())) {
+            value += advance();
+        }
+        return value;
+    }
+    function readStyleMode() {
+        advance();
+        let value = '';
+        while (i < source.length && peek() !== ')') {
+            value += advance();
+        }
+        if (peek() === ')')
+            advance();
+        return value.trim();
+    }
+    function readRawBlock() {
+        let depth = 1;
+        let value = '';
+        while (i < source.length && depth > 0) {
+            const ch = peek();
+            if (ch === '{')
+                depth++;
+            if (ch === '}') {
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+            if (ch === '\n')
+                line++;
+            value += advance();
+        }
+        if (peek() === '}')
+            advance();
+        return value.trim();
+    }
+    function readRawExpr() {
+        let value = '';
+        while (i < source.length && '*+-/><!=&%^~?'.includes(peek())) {
+            value += advance();
+        }
+        return value;
+    }
+    let lastKeyword = null;
+    while (i < source.length) {
+        skipWhitespace();
+        skipComment();
+        if (i >= source.length)
+            break;
+        const startLine = line;
+        const startCol = col;
+        const emit = (type, value) => {
+            tokens.push({ type, value, line: startLine, col: startCol });
+        };
+        const ch = peek();
+        if (ch === '\n') {
+            advance();
+            emit('NEWLINE', '\n');
+            continue;
+        }
+        if (ch === '{') {
+            advance();
+            if (lastKeyword === 'UI' || lastKeyword === 'SCRIPT' || lastKeyword === 'STYLE') {
+                const raw = readRawBlock();
+                emit('RAW_JSX', raw);
+                lastKeyword = null;
+                continue;
+            }
+            emit('LBRACE', '{');
+            continue;
+        }
+        if (ch === '}') {
+            advance();
+            emit('RBRACE', '}');
+            continue;
+        }
+        if (ch === ':') {
+            advance();
+            emit('COLON', ':');
+            continue;
+        }
+        if (ch === '|') {
+            advance();
+            emit('PIPE', '|');
+            continue;
+        }
+        if (ch === '.') {
+            advance();
+            emit('DOT', '.');
+            continue;
+        }
+        if (ch === '(') {
+            advance();
+            emit('LPAREN', '(');
+            continue;
+        }
+        if (ch === ')') {
+            advance();
+            emit('RPAREN', ')');
+            continue;
+        }
+        if (ch === ',') {
+            advance();
+            emit('COMMA', ',');
+            continue;
+        }
+        if (ch === '=') {
+            if (peek(1) === '>') {
+                advance();
+                advance();
+                emit('ARROW', '=>');
+            }
+            else {
+                advance();
+                emit('EQUALS', '=');
+            }
+            continue;
+        }
+        if ('*+-/><!=&%^~?'.includes(ch)) {
+            const raw = readRawExpr();
+            emit('RAW_EXPR', raw);
+            continue;
+        }
+        if (ch === '"') {
+            const str = readString();
+            emit('STRING', str);
+            continue;
+        }
+        if (/[0-9]/.test(ch)) {
+            const num = readNumber();
+            emit('NUMBER', num);
+            continue;
+        }
+        if (/[a-zA-Z_$]/.test(ch)) {
+            const ident = readIdent();
+            const keywordType = KEYWORDS[ident];
+            if (keywordType) {
+                emit(keywordType, ident);
+                lastKeyword = keywordType;
+                if (keywordType === 'STYLE' && peek() === '(') {
+                    const modeStartLine = line;
+                    const modeStartCol = col;
+                    const mode = readStyleMode();
+                    tokens.push({ type: 'STYLE_MODE', value: mode, line: modeStartLine, col: modeStartCol });
+                    lastKeyword = null;
+                }
+            }
+            else {
+                emit('IDENT', ident);
+            }
+            continue;
+        }
+        advance();
+    }
+    tokens.push({ type: 'EOF', value: '', line, col });
+    return tokens;
+}
+
+class TardisError extends Error {
+    constructor(message, file = 'unknown', line = 0, col = 0) {
+        super(`\nTardisError: ${file} line ${line} col ${col}\n  ${message}\n`);
+        this.file = file;
+        this.line = line;
+        this.col = col;
+        this.name = 'TardisError';
+    }
+}
+
+function parse(tokens, file = 'unknown') {
+    let cursor = 0;
+    // ── helpers ────────────────────────────────────────────────────────────
+    function peek(offset = 0) {
+        return tokens[cursor + offset] ?? { type: 'EOF', value: '', line: 0, col: 0 };
+    }
+    function advance() {
+        const token = tokens[cursor];
+        cursor++;
+        return token;
+    }
+    function expect(type) {
+        const token = peek();
+        if (token.type !== type) {
+            throw new TardisError(`Expected ${type} but got ${token.type} ("${token.value}")`, file, token.line, token.col);
+        }
+        return advance();
+    }
+    function skipNewlines() {
+        while (peek().type === 'NEWLINE')
+            advance();
+    }
+    function check(type) {
+        return peek().type === type;
+    }
+    // ── expression builder ─────────────────────────────────────────────────
+    // reads tokens until a stopping condition and builds a raw expression string
+    // preserves spaces around operators and commas
+    function buildExpr(stopAt) {
+        let expr = '';
+        while (!stopAt.includes(peek().type) && !check('EOF')) {
+            const tok = peek();
+            if (tok.type === 'RAW_EXPR') {
+                expr += ` ${tok.value} `;
+            }
+            else if (tok.type === 'COMMA') {
+                expr += ', ';
+            }
+            else {
+                expr += tok.value;
+            }
+            advance();
+        }
+        return expr.trim();
+    }
+    // reads a raw block body tracking brace depth
+    // used for method bodies and event handlers
+    function buildBody() {
+        let raw = '';
+        let depth = 0;
+        while (!check('EOF')) {
+            const tok = peek();
+            if (tok.value === '{')
+                depth++;
+            if (tok.value === '}') {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            if (tok.type === 'NEWLINE' && depth === 0)
+                break;
+            if (tok.type === 'RAW_EXPR')
+                raw += ` ${tok.value} `;
+            else if (tok.type === 'COMMA')
+                raw += ', ';
+            else
+                raw += tok.value;
+            advance();
+        }
+        return raw.trim();
+    }
+    // ── did you mean ───────────────────────────────────────────────────────
+    function didYouMean(input, options) {
+        function distance(a, b) {
+            const dp = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+            for (let i = 1; i <= a.length; i++) {
+                for (let j = 1; j <= b.length; j++) {
+                    dp[i][j] = a[i - 1] === b[j - 1]
+                        ? dp[i - 1][j - 1]
+                        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+                }
+            }
+            return dp[a.length][b.length];
+        }
+        const closest = options.reduce((best, opt) => {
+            const d = distance(input, opt);
+            return d < best.dist ? { opt, dist: d } : best;
+        }, { opt: '', dist: Infinity });
+        return closest.dist <= 2 ? closest.opt : null;
+    }
+    // ── type and default parser ────────────────────────────────────────────
+    function parsePropTypeAndDefault() {
+        // union type: "primary" | "ghost" | "danger"
+        if (check('STRING') && peek(1).type === 'PIPE') {
+            const unionValues = [];
+            while (check('STRING')) {
+                unionValues.push(advance().value);
+                if (check('PIPE'))
+                    advance();
+            }
+            let defaultVal = null;
+            if (check('EQUALS')) {
+                advance();
+                defaultVal = expect('STRING').value;
+            }
+            return { type: unionValues, defaultVal };
+        }
+        // primitive type
+        const typeTok = expect('IDENT');
+        const typeName = typeTok.value;
+        const validTypes = ['string', 'number', 'boolean', 'array', 'object', 'function'];
+        if (!validTypes.includes(typeName)) {
+            const suggestion = didYouMean(typeName, validTypes);
+            throw new TardisError(`Unknown type "${typeName}"${suggestion ? ` — did you mean "${suggestion}"?` : ''}`, file, typeTok.line, typeTok.col);
+        }
+        if (typeName === 'function') {
+            return { type: 'function', defaultVal: null };
+        }
+        let defaultVal = null;
+        if (check('EQUALS')) {
+            advance(); // consume =
+            if (check('STRING')) {
+                defaultVal = advance().value;
+            }
+            else if (check('NUMBER')) {
+                defaultVal = parseFloat(advance().value);
+            }
+            else if (check('BOOLEAN')) {
+                defaultVal = advance().value === 'true';
+            }
+            else if (check('LBRACE')) {
+                // [] or {} default
+                advance(); // consume {
+                if (check('RBRACE')) {
+                    advance(); // consume }
+                    defaultVal = typeName === 'array' ? '[]' : '{}';
+                }
+            }
+            else {
+                // expression reference like props.initial or state.count
+                defaultVal = buildExpr(['NEWLINE', 'RBRACE', 'EOF']);
+            }
+        }
+        return { type: typeName, defaultVal };
+    }
+    // ── method signature parser ────────────────────────────────────────────
+    function parseMethodSignature(raw, tok) {
+        const arrowMatch = raw.match(/^\(([^)]*)\)\s*=>\s*(.+)$/s);
+        if (!arrowMatch) {
+            throw new TardisError(`Invalid method syntax — expected "(params) => body" but got "${raw}"`, file, tok.line, tok.col);
+        }
+        const paramStr = arrowMatch[1].trim();
+        const body = arrowMatch[2].trim();
+        const params = paramStr
+            ? paramStr.split(',').map(p => p.trim()).filter(Boolean)
+            : [];
+        return { params, body };
+    }
+    // ── section parsers ────────────────────────────────────────────────────
+    function parseProps() {
+        expect('PROPS');
+        skipNewlines();
+        expect('LBRACE');
+        skipNewlines();
+        const props = [];
+        while (!check('RBRACE') && !check('EOF')) {
+            skipNewlines();
+            if (check('RBRACE'))
+                break;
+            const nameTok = expect('IDENT');
+            expect('COLON');
+            const { type, defaultVal } = parsePropTypeAndDefault();
+            props.push({
+                name: nameTok.value,
+                type,
+                default: defaultVal,
+                line: nameTok.line,
+                col: nameTok.col,
+            });
+            skipNewlines();
+        }
+        expect('RBRACE');
+        return props;
+    }
+    function parseState() {
+        expect('STATE');
+        skipNewlines();
+        expect('LBRACE');
+        skipNewlines();
+        const state = [];
+        while (!check('RBRACE') && !check('EOF')) {
+            skipNewlines();
+            if (check('RBRACE'))
+                break;
+            const nameTok = expect('IDENT');
+            expect('COLON');
+            const { type, defaultVal } = parsePropTypeAndDefault();
+            state.push({
+                name: nameTok.value,
+                type,
+                default: defaultVal,
+                line: nameTok.line,
+                col: nameTok.col,
+            });
+            skipNewlines();
+        }
+        expect('RBRACE');
+        return state;
+    }
+    function parseComputed() {
+        expect('COMPUTED');
+        skipNewlines();
+        expect('LBRACE');
+        skipNewlines();
+        const computed = [];
+        while (!check('RBRACE') && !check('EOF')) {
+            skipNewlines();
+            if (check('RBRACE'))
+                break;
+            const nameTok = expect('IDENT');
+            expect('COLON');
+            const expr = buildExpr(['NEWLINE', 'RBRACE', 'EOF']);
+            computed.push({
+                name: nameTok.value,
+                expr,
+                line: nameTok.line,
+                col: nameTok.col,
+            });
+            skipNewlines();
+        }
+        expect('RBRACE');
+        return computed;
+    }
+    function parseMethods() {
+        expect('METHODS');
+        skipNewlines();
+        expect('LBRACE');
+        skipNewlines();
+        const methods = [];
+        while (!check('RBRACE') && !check('EOF')) {
+            skipNewlines();
+            if (check('RBRACE'))
+                break;
+            const nameTok = expect('IDENT');
+            expect('COLON');
+            const raw = buildBody();
+            const { params, body } = parseMethodSignature(raw, nameTok);
+            methods.push({
+                name: nameTok.value,
+                params,
+                body,
+                line: nameTok.line,
+                col: nameTok.col,
+            });
+            skipNewlines();
+        }
+        expect('RBRACE');
+        return methods;
+    }
+    function parseEvents() {
+        expect('EVENTS');
+        skipNewlines();
+        expect('LBRACE');
+        skipNewlines();
+        const events = {
+            onMount: null,
+            onDestroy: null,
+            onUpdate: null,
+        };
+        while (!check('RBRACE') && !check('EOF')) {
+            skipNewlines();
+            if (check('RBRACE'))
+                break;
+            const nameTok = expect('IDENT');
+            expect('COLON');
+            const raw = buildBody();
+            const key = nameTok.value;
+            if (key in events) {
+                events[key] = raw;
+            }
+            else {
+                throw new TardisError(`Unknown event "${nameTok.value}" — valid events are onMount, onDestroy, onUpdate`, file, nameTok.line, nameTok.col);
+            }
+            skipNewlines();
+        }
+        expect('RBRACE');
+        return events;
+    }
+    function parseStyle() {
+        expect('STYLE');
+        // raw CSS mode: style { ... } without (mode)
+        if (check('RAW_JSX')) {
+            const rawTok = expect('RAW_JSX');
+            return { mode: 'raw', rules: [], raw: rawTok.value };
+        }
+        const modeTok = expect('STYLE_MODE');
+        const mode = modeTok.value;
+        if (mode !== 'tailwind' && mode !== 'css') {
+            throw new TardisError(`Unknown style mode "${mode}" — valid modes are tailwind and css`, file, modeTok.line, modeTok.col);
+        }
+        skipNewlines();
+        expect('LBRACE');
+        skipNewlines();
+        const rules = [];
+        while (!check('RBRACE') && !check('EOF')) {
+            skipNewlines();
+            if (check('RBRACE'))
+                break;
+            // read key — can be dotted like variant.primary or disabled.true
+            let key = '';
+            const keyTok = peek();
+            while (!check('COLON') && !check('NEWLINE') && !check('EOF')) {
+                key += peek().value;
+                advance();
+            }
+            expect('COLON');
+            const valueTok = expect('STRING');
+            rules.push({
+                key: key.trim(),
+                value: valueTok.value,
+                line: keyTok.line,
+                col: keyTok.col,
+            });
+            skipNewlines();
+        }
+        expect('RBRACE');
+        return { mode, rules };
+    }
+    function parseUI() {
+        const uiTok = expect('UI');
+        skipNewlines();
+        const rawTok = expect('RAW_JSX');
+        return {
+            raw: rawTok.value,
+            line: uiTok.line,
+            col: uiTok.col,
+        };
+    }
+    function parseScript() {
+        const scriptTok = expect('SCRIPT');
+        skipNewlines();
+        const rawTok = expect('RAW_JSX');
+        return {
+            raw: rawTok.value,
+            line: scriptTok.line,
+            col: scriptTok.col,
+        };
+    }
+    // ── main blueprint parser ──────────────────────────────────────────────
+    skipNewlines();
+    const blueprintTok = expect('BLUEPRINT');
+    const nameTok = expect('IDENT');
+    skipNewlines();
+    expect('LBRACE');
+    skipNewlines();
+    let props = [];
+    let state = [];
+    let computed = [];
+    let methods = [];
+    let events = { onMount: null, onDestroy: null, onUpdate: null };
+    let style = null;
+    let ui = null;
+    let script = null;
+    while (!check('RBRACE') && !check('EOF')) {
+        skipNewlines();
+        if (check('RBRACE'))
+            break;
+        const tok = peek();
+        if (check('PROPS')) {
+            props = parseProps();
+            skipNewlines();
+            continue;
+        }
+        if (check('STATE')) {
+            state = parseState();
+            skipNewlines();
+            continue;
+        }
+        if (check('COMPUTED')) {
+            computed = parseComputed();
+            skipNewlines();
+            continue;
+        }
+        if (check('METHODS')) {
+            methods = parseMethods();
+            skipNewlines();
+            continue;
+        }
+        if (check('EVENTS')) {
+            events = parseEvents();
+            skipNewlines();
+            continue;
+        }
+        if (check('STYLE')) {
+            style = parseStyle();
+            skipNewlines();
+            continue;
+        }
+        if (check('UI')) {
+            ui = parseUI();
+            skipNewlines();
+            continue;
+        }
+        if (check('SCRIPT')) {
+            script = parseScript();
+            skipNewlines();
+            continue;
+        }
+        throw new TardisError(`Unexpected token "${tok.value}" — expected a section keyword (props, state, computed, methods, events, style, ui, script)`, file, tok.line, tok.col);
+    }
+    expect('RBRACE');
+    if (!ui) {
+        throw new TardisError(`Blueprint "${nameTok.value}" is missing a ui block — every blueprint must have one`, file, nameTok.line, nameTok.col);
+    }
+    return {
+        name: nameTok.value,
+        props,
+        state,
+        computed,
+        methods,
+        events,
+        style,
+        ui,
+        script,
+        line: blueprintTok.line,
+        col: blueprintTok.col,
+    };
+}
+
+function compile(ast) {
+    const lines = [];
+    lines.push(`// generated from ${ast.name}.tardis — do not edit`);
+    lines.push(`// edit the .tardis source file instead`);
+    lines.push(`import { $runtime } from 'tardisjs/runtime'`);
+    lines.push(``);
+    lines.push(compilePropsType(ast.name, ast.props));
+    lines.push(``);
+    lines.push(`export function ${ast.name}(props: ${ast.name}Props = {}) {`);
+    lines.push(compilePropsDefaults(ast.props));
+    lines.push(``);
+    if (ast.state.length > 0) {
+        lines.push(compileState(ast.state));
+        lines.push(``);
+    }
+    if (ast.computed.length > 0) {
+        lines.push(compileComputed(ast.computed));
+        lines.push(``);
+    }
+    if (ast.methods.length > 0) {
+        lines.push(compileMethods(ast.methods));
+        lines.push(``);
+    }
+    if (ast.events.onMount || ast.events.onDestroy || ast.events.onUpdate) {
+        lines.push(compileEvents(ast));
+        lines.push(``);
+    }
+    if (ast.style && ast.style.mode !== 'raw') {
+        lines.push(compileStyle(ast.style));
+        lines.push(``);
+    }
+    const registrations = [];
+    if (ast.state.length > 0)
+        registrations.push("state: _state");
+    if (ast.methods.length > 0)
+        registrations.push("methods: _methods");
+    lines.push(`  $runtime.register('${ast.name}', { ${registrations.join(", ")} })`);
+    lines.push(``);
+    let scriptCode = ast.script ? compileScript(ast) : undefined;
+    if (ast.style && ast.style.mode === 'raw' && ast.style.raw) {
+        const cssInjection = compileRawStyle(ast.style.raw);
+        scriptCode = scriptCode ? `${scriptCode}\n${cssInjection}` : cssInjection;
+    }
+    lines.push(compileUI(ast.ui.raw, ast.name, scriptCode));
+    lines.push(`}`);
+    return lines.join("\n");
+}
+// ── props type ─────────────────────────────────────────────────────────────
+function compilePropsType(name, props) {
+    if (props.length === 0) {
+        return `type ${name}Props = Record<string, never>`;
+    }
+    const fields = props.map((p) => {
+        const tsType = propTypeToTS(p.type);
+        const optional = p.default !== null || p.type === "function" ? "?" : "";
+        return `  ${p.name}${optional}: ${tsType}`;
+    });
+    return `type ${name}Props = {\n${fields.join("\n")}\n}`;
+}
+function propTypeToTS(type) {
+    if (Array.isArray(type)) {
+        return type.map((v) => `"${v}"`).join(" | ");
+    }
+    switch (type) {
+        case "string":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "array":
+            return "unknown[]";
+        case "object":
+            return "Record<string, unknown>";
+        case "function":
+            return "(...args: unknown[]) => unknown";
+        default:
+            return "unknown";
+    }
+}
+// ── props defaults ─────────────────────────────────────────────────────────
+function compilePropsDefaults(props) {
+    if (props.length === 0) {
+        return `  const _props = { ...props }`;
+    }
+    const defaults = props
+        .filter((p) => p.default !== null)
+        .map((p) => `    ${p.name}: ${formatDefault(p.default, p.type)}`);
+    if (defaults.length === 0) {
+        return `  const _props = { ...props }`;
+    }
+    return [
+        `  const _props = {`,
+        defaults.join(",\n"),
+        `    ...props`,
+        `  }`,
+    ].join("\n");
+}
+function formatDefault(val, type) {
+    if (val === null)
+        return "undefined";
+    if (typeof val === "number")
+        return String(val);
+    if (typeof val === "boolean")
+        return String(val);
+    if (val === "[]")
+        return "[]";
+    if (val === "{}")
+        return "{}";
+    if (typeof val === "string" && val.startsWith("props."))
+        return val.replace("props.", "_props.");
+    if (typeof val === "string" && val.startsWith("state."))
+        return val.replace("state.", "_state.");
+    if (Array.isArray(type) || type === "string")
+        return `"${val}"`;
+    return String(val);
+}
+// ── state ──────────────────────────────────────────────────────────────────
+function compileState(state) {
+    const entries = state.map((s) => `    ${s.name}: ${formatDefault(s.default, s.type)}`);
+    return [
+        `  const _state = $runtime.state({`,
+        entries.join(",\n"),
+        `  })`,
+    ].join("\n");
+}
+// ── computed ───────────────────────────────────────────────────────────────
+function compileComputed(computed) {
+    const getters = computed.map((c) => {
+        const expr = rewriteRefs(c.expr);
+        return `    get ${c.name}() { return ${expr} }`;
+    });
+    return [`  const _computed = {`, getters.join(",\n"), `  }`].join("\n");
+}
+// ── methods ────────────────────────────────────────────────────────────────
+function compileMethods(methods) {
+    const fns = methods.map((m) => {
+        const params = m.params.join(", ");
+        const body = rewriteRefs(m.body);
+        return `    ${m.name}: (${params}) => ${body}`;
+    });
+    return [`  const _methods = {`, fns.join(",\n"), `  }`].join("\n");
+}
+// ── events ─────────────────────────────────────────────────────────────────
+function compileEvents(ast) {
+    const lines = [];
+    lines.push(`  $runtime.events({`);
+    if (ast.events.onMount)
+        lines.push(`    onMount: () => { ${rewriteRefs(ast.events.onMount)} },`);
+    if (ast.events.onDestroy)
+        lines.push(`    onDestroy: () => { ${rewriteRefs(ast.events.onDestroy)} },`);
+    if (ast.events.onUpdate)
+        lines.push(`    onUpdate: () => { ${rewriteRefs(ast.events.onUpdate)} },`);
+    lines.push(`  })`);
+    return lines.join("\n");
+}
+// ── style ──────────────────────────────────────────────────────────────────
+function compileStyle(style) {
+    const rules = style.rules.map((r) => `    "${r.key}": "${r.value}"`);
+    return [
+        `  const _styles = $runtime.styles("${style.mode}", {`,
+        rules.join(",\n"),
+        `  }, _props, _state)`,
+    ].join("\n");
+}
+function compileRawStyle(raw) {
+    const escaped = raw.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+    const lines = [];
+    lines.push(`  // raw style`);
+    lines.push(`  ;(() => {`);
+    lines.push(`    const _style = document.createElement('style')`);
+    lines.push(`    _style.textContent = \`${escaped}\``);
+    lines.push(`    document.head.appendChild(_style)`);
+    lines.push(`  })()`);
+    return lines.join('\n');
+}
+// ── ref rewriter ───────────────────────────────────────────────────────────
+function rewriteRefs(expr) {
+    const rewritten = expr
+        .replace(/(?<![_a-zA-Z])state\./g, "_state.")
+        .replace(/(?<![_a-zA-Z])props\./g, "_props.")
+        .replace(/(?<![_a-zA-Z])computed\./g, "_computed.")
+        .replace(/(?<![_a-zA-Z])methods\./g, "_methods.");
+    return rewritten
+        .replace(/\$update\(\s*_state\.([a-zA-Z_$][\w$]*)\s*,/g, "$runtime.update(_state, '$1',")
+        .replace(/\$toggle\(\s*_state\.([a-zA-Z_$][\w$]*)\s*\)/g, "$runtime.toggle(_state, '$1')");
+}
+// ── ui compiler ────────────────────────────────────────────────────────────
+function compileUI(raw, componentName, scriptCode) {
+    const lines = [];
+    lines.push(`  // ui`);
+    lines.push(`  const _root = (() => {`);
+    lines.push(compileUINode(raw.trim(), 2));
+    lines.push(`  })()`);
+    if (scriptCode) {
+        lines.push(``);
+        lines.push(scriptCode);
+    }
+    lines.push(`  return _root`);
+    return lines.join("\n");
+}
+function rewriteElementSelectors(raw) {
+    // {<tag id="x" class="y"></tag>} or {<tag id="x" class="y" />} → $el.querySelector('tag#x.y')
+    return raw.replace(/\{<(\w+)((?:\s+[\w-]+="[^"]*")*)\s*(?:\/>|>\s*<\/\1>)\}/g, (_match, tag, attrsRaw) => {
+        let selector = tag;
+        const idMatch = attrsRaw.match(/\bid="([^"]*)"/);
+        if (idMatch)
+            selector = `${tag}#${idMatch[1]}`;
+        const classMatch = attrsRaw.match(/\bclass="([^"]*)"/);
+        if (classMatch) {
+            selector += classMatch[1].split(/\s+/).map(c => `.${c}`).join('');
+        }
+        return `$el.querySelector('${selector}')`;
+    });
+}
+function compileScript(ast) {
+    const lines = [];
+    lines.push(`  // script`);
+    lines.push(`  requestAnimationFrame(() => {`);
+    lines.push(`    const $el = _root`);
+    lines.push(`    const props = _props`);
+    if (ast.state.length > 0)
+        lines.push(`    const state = _state`);
+    if (ast.methods.length > 0)
+        lines.push(`    const methods = _methods`);
+    if (ast.computed.length > 0)
+        lines.push(`    const computed = _computed`);
+    const transformed = rewriteElementSelectors(ast.script.raw);
+    for (const line of transformed.split('\n')) {
+        lines.push(`    ${line}`);
+    }
+    lines.push(`  })`);
+    return lines.join('\n');
+}
+function compileUINode(raw, depth) {
+    const indent = "  ".repeat(depth);
+    const lines = [];
+    // $if
+    const ifMatch = raw.match(/^\$if\((.+?)\)\s*\{([\s\S]*)\}/);
+    if (ifMatch) {
+        const condition = rewriteRefs(ifMatch[1].trim());
+        const inner = compileUINode(ifMatch[2].trim(), depth + 1);
+        lines.push(`${indent}return $runtime.if(() => ${condition}, () => {`);
+        lines.push(inner);
+        lines.push(`${indent}})`);
+        return lines.join("\n");
+    }
+    // $each
+    const eachMatch = raw.match(/^\$each\((.+?),\s*\((\w+)\)\s*=>\s*\{([\s\S]*)\}\s*\)/);
+    if (eachMatch) {
+        const arrayRef = rewriteRefs(eachMatch[1].trim());
+        const itemVar = eachMatch[2];
+        const inner = compileUINode(eachMatch[3].trim(), depth + 1);
+        lines.push(`${indent}return $runtime.each(() => ${arrayRef}, (${itemVar}) => {`);
+        lines.push(inner);
+        lines.push(`${indent}})`);
+        return lines.join("\n");
+    }
+    // $show
+    const showMatch = raw.match(/^\$show\((.+?)\)\s*\{([\s\S]*)\}/);
+    if (showMatch) {
+        const condition = rewriteRefs(showMatch[1].trim());
+        const inner = compileUINode(showMatch[2].trim(), depth + 1);
+        lines.push(`${indent}return $runtime.show(() => ${condition}, () => {`);
+        lines.push(inner);
+        lines.push(`${indent}})`);
+        return lines.join("\n");
+    }
+    // {} chain syntax
+    const chainMatch = raw.match(/^\{([\s\S]+?)\}((?:\s*\.\w+\([^)]*\))+)/);
+    if (chainMatch) {
+        const innerEl = chainMatch[1].trim();
+        const chainStr = chainMatch[2].trim();
+        const elCode = compileElement(innerEl, depth);
+        const chains = parseChains(chainStr);
+        lines.push(`${indent}const _chained = (() => {`);
+        lines.push(elCode);
+        lines.push(`${indent}})()`);
+        for (const chain of chains) {
+            lines.push(`${indent}$runtime.chain(_chained, '${chain.event}', ${rewriteRefs(chain.handler)})`);
+        }
+        lines.push(`${indent}return _chained`);
+        return lines.join("\n");
+    }
+    return compileElement(raw, depth);
+}
+function compileElement(raw, depth) {
+    const indent = "  ".repeat(depth);
+    const lines = [];
+    const trimmed = raw.trim();
+    // self-closing tag — find end accounting for braces
+    const selfCloseEnd = findSelfCloseEnd(trimmed);
+    if (selfCloseEnd >= 0) {
+        const tagStr = trimmed.slice(0, selfCloseEnd + 1);
+        const tagNameMatch = tagStr.match(/^<([a-zA-Z][a-zA-Z0-9]*)/);
+        if (tagNameMatch) {
+            const tag = tagNameMatch[1];
+            const attrsRaw = tagStr.slice(tag.length + 1, -2).trim(); // between name and />
+            if (/^[A-Z]/.test(tag)) {
+                lines.push(`${indent}return $runtime.component('${tag}', { ${compileComponentProps(attrsRaw)} })`);
+                return lines.join("\n");
+            }
+            lines.push(`${indent}const _el_${depth} = document.createElement('${tag}')`);
+            for (const attr of parseAttributes(attrsRaw)) {
+                lines.push(...compileAttr(attr, depth, indent));
+            }
+            lines.push(`${indent}return _el_${depth}`);
+            return lines.join("\n");
+        }
+    }
+    // opening tag — find end accounting for braces
+    const openTagEndIdx = findOpenTagEnd(trimmed);
+    if (openTagEndIdx < 0) {
+        // plain text or expression
+        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+            lines.push(`${indent}return $runtime.text(() => ${rewriteRefs(trimmed.slice(1, -1).trim())})`);
+        }
+        else {
+            lines.push(`${indent}return $runtime.text(${JSON.stringify(decodeEntities(trimmed))})`);
+        }
+        return lines.join("\n");
+    }
+    const openTagStr = trimmed.slice(0, openTagEndIdx + 1);
+    const tagNameMatch = openTagStr.match(/^<([a-zA-Z][a-zA-Z0-9]*)/);
+    if (!tagNameMatch) {
+        lines.push(`${indent}return $runtime.text(${JSON.stringify(decodeEntities(trimmed))})`);
+        return lines.join("\n");
+    }
+    const tag = tagNameMatch[1];
+    const attrsRaw = openTagStr.slice(tag.length + 1, -1).trim();
+    if (/^[A-Z]/.test(tag)) {
+        lines.push(`${indent}return $runtime.component('${tag}', { ${compileComponentProps(attrsRaw)} })`);
+        return lines.join("\n");
+    }
+    const innerContent = findInnerContent(trimmed, tag, openTagEndIdx + 1);
+    lines.push(`${indent}const _el_${depth} = document.createElement('${tag}')`);
+    for (const attr of parseAttributes(attrsRaw)) {
+        lines.push(...compileAttr(attr, depth, indent));
+    }
+    const children = splitChildren(innerContent);
+    let childIndex = 0;
+    for (let ci = 0; ci < children.length; ci++) {
+        const child = children[ci];
+        // normalize whitespace: trim first child's leading, last child's trailing
+        // but preserve boundary spaces for middle children (e.g. "text " before <span>)
+        let ct = child.replace(/\s*\n\s*/g, ' ');
+        if (ci === 0)
+            ct = ct.replace(/^\s+/, '');
+        if (ci === children.length - 1)
+            ct = ct.replace(/\s+$/, '');
+        if (!ct)
+            continue;
+        if (ct.startsWith('{') && ct.endsWith('}') && !ct.startsWith('{<')) {
+            const expr = rewriteRefs(ct.slice(1, -1).trim());
+            lines.push(`${indent}const _text_${depth} = document.createTextNode('')`);
+            lines.push(`${indent}$runtime.bind(_text_${depth}, 'textContent', () => String(${expr}))`);
+            lines.push(`${indent}_el_${depth}.appendChild(_text_${depth})`);
+        }
+        else if (ct.trim().startsWith('<') ||
+            ct.trim().startsWith('{<') ||
+            ct.trim().startsWith('$if(') ||
+            ct.trim().startsWith('$each(') ||
+            ct.trim().startsWith('$show(')) {
+            // emit leading whitespace as a text node (preserves spaces between text and inline elements)
+            const wsMatch = ct.match(/^(\s+)/);
+            if (wsMatch) {
+                lines.push(`${indent}_el_${depth}.appendChild(document.createTextNode(" "))`);
+            }
+            const childVar = `_child_${depth}_${childIndex}`;
+            lines.push(`${indent}const ${childVar} = (() => {`);
+            lines.push(compileUINode(ct, depth + 1));
+            lines.push(`${indent}})()`);
+            lines.push(`${indent}if (${childVar} instanceof Node) _el_${depth}.appendChild(${childVar})`);
+        }
+        else {
+            const interpolationRe = /\{([^{}]+)\}/g;
+            let cursor = 0;
+            let interpolationIndex = 0;
+            let hasInterpolation = false;
+            let match;
+            while ((match = interpolationRe.exec(ct)) !== null) {
+                hasInterpolation = true;
+                const textBefore = ct.slice(cursor, match.index);
+                if (textBefore) {
+                    lines.push(`${indent}_el_${depth}.appendChild(document.createTextNode(${JSON.stringify(decodeEntities(textBefore))}))`);
+                }
+                const textVar = `_text_${depth}_${childIndex}_${interpolationIndex}`;
+                const expr = rewriteRefs(match[1].trim());
+                lines.push(`${indent}const ${textVar} = document.createTextNode('')`);
+                lines.push(`${indent}$runtime.bind(${textVar}, 'textContent', () => String(${expr}))`);
+                lines.push(`${indent}_el_${depth}.appendChild(${textVar})`);
+                cursor = match.index + match[0].length;
+                interpolationIndex++;
+            }
+            if (hasInterpolation) {
+                const tail = ct.slice(cursor);
+                if (tail) {
+                    lines.push(`${indent}_el_${depth}.appendChild(document.createTextNode(${JSON.stringify(decodeEntities(tail))}))`);
+                }
+            }
+            else {
+                lines.push(`${indent}_el_${depth}.appendChild(document.createTextNode(${JSON.stringify(decodeEntities(ct))}))`);
+            }
+        }
+        childIndex++;
+    }
+    lines.push(`${indent}return _el_${depth}`);
+    return lines.join("\n");
+}
+function compileAttr(attr, depth, indent) {
+    const lines = [];
+    if (attr.name.startsWith("@")) {
+        const event = attr.name.slice(1);
+        const handler = rewriteRefs(isReactive(attr.value) ? stripBraces(attr.value) : attr.value);
+        lines.push(`${indent}_el_${depth}.addEventListener('${event}', ${handler})`);
+    }
+    else if (attr.name === "class") {
+        if (isReactive(attr.value)) {
+            const expr = rewriteRefs(stripBraces(attr.value));
+            lines.push(`${indent}$runtime.bindClass(_el_${depth}, () => _styles ? $runtime.resolveStyles(_styles, ${expr}) : ${expr})`);
+        }
+        else {
+            lines.push(`${indent}_el_${depth}.className = ${JSON.stringify(attr.value)}`);
+        }
+    }
+    else if (isReactive(attr.value)) {
+        const expr = rewriteRefs(stripBraces(attr.value));
+        lines.push(`${indent}$runtime.bindAttr(_el_${depth}, '${attr.name}', () => ${expr})`);
+    }
+    else {
+        lines.push(`${indent}_el_${depth}.setAttribute('${attr.name}', ${JSON.stringify(attr.value)})`);
+    }
+    return lines;
+}
+// ── attribute parser ───────────────────────────────────────────────────────
+function parseAttributes(raw) {
+    const attrs = [];
+    let i = 0;
+    while (i < raw.length) {
+        while (i < raw.length && /\s/.test(raw[i]))
+            i++;
+        if (i >= raw.length)
+            break;
+        let name = "";
+        while (i < raw.length && !/[\s=]/.test(raw[i]))
+            name += raw[i++];
+        if (!name) {
+            i++;
+            continue;
+        }
+        while (i < raw.length && /\s/.test(raw[i]))
+            i++;
+        if (raw[i] !== "=")
+            continue;
+        i++;
+        while (i < raw.length && /\s/.test(raw[i]))
+            i++;
+        if (raw[i] === '"') {
+            i++;
+            let value = "";
+            while (i < raw.length && raw[i] !== '"')
+                value += raw[i++];
+            i++;
+            attrs.push({ name, value });
+        }
+        else if (raw[i] === "{") {
+            let depth = 0;
+            let expr = "";
+            while (i < raw.length) {
+                const ch = raw[i];
+                if (ch === "{")
+                    depth++;
+                if (ch === "}") {
+                    depth--;
+                    if (depth === 0) {
+                        expr += ch;
+                        i++;
+                        break;
+                    }
+                }
+                expr += ch;
+                i++;
+            }
+            attrs.push({ name, value: expr });
+        }
+    }
+    return attrs;
+}
+// ── chain parser ───────────────────────────────────────────────────────────
+function parseChains(raw) {
+    const chains = [];
+    const re = /\.(\w+)\(([^)]*)\)/g;
+    let m;
+    const eventMap = {
+        click: "click",
+        hover: "mouseenter",
+        blur: "blur",
+        focus: "focus",
+        keydown: "keydown",
+        keyup: "keyup",
+        change: "change",
+        submit: "submit",
+        scroll: "scroll",
+        drag: "dragstart",
+        mount: "__mount",
+        destroy: "__destroy",
+    };
+    while ((m = re.exec(raw)) !== null) {
+        chains.push({ event: eventMap[m[1]] ?? m[1], handler: m[2].trim() });
+    }
+    return chains;
+}
+// ── component props compiler ───────────────────────────────────────────────
+function compileComponentProps(raw) {
+    return parseAttributes(raw)
+        .map((a) => {
+        if (isReactive(a.value))
+            return `${a.name}: () => ${rewriteRefs(stripBraces(a.value))}`;
+        return `${a.name}: ${JSON.stringify(a.value)}`;
+    })
+        .join(", ");
+}
+// ── helpers ────────────────────────────────────────────────────────────────
+function isReactive(value) {
+    return value.startsWith("{") && value.endsWith("}");
+}
+function stripBraces(value) {
+    return value.slice(1, -1).trim();
+}
+// find end index of opening tag > accounting for {} inside attribute values
+function findOpenTagEnd(raw) {
+    const end = findFirstTagEnd(raw);
+    if (end < 0)
+        return -1;
+    return isSelfClosingTag(raw, end) ? -1 : end;
+}
+// find end index of self-closing tag /> accounting for {} inside attribute values
+function findSelfCloseEnd(raw) {
+    const end = findFirstTagEnd(raw);
+    if (end < 0)
+        return -1;
+    return isSelfClosingTag(raw, end) ? end : -1;
+}
+function findFirstTagEnd(raw) {
+    if (!raw.startsWith("<"))
+        return -1;
+    let i = 1;
+    let bracesDepth = 0;
+    let quote = null;
+    while (i < raw.length) {
+        const ch = raw[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (ch === "{") {
+            bracesDepth++;
+        }
+        else if (ch === "}") {
+            bracesDepth--;
+        }
+        else if (ch === ">" && bracesDepth === 0) {
+            return i;
+        }
+        i++;
+    }
+    return -1;
+}
+function isSelfClosingTag(raw, end) {
+    let i = end - 1;
+    while (i >= 0 && /\s/.test(raw[i]))
+        i--;
+    return raw[i] === "/";
+}
+function findInnerContent(raw, tag, startFrom) {
+    let depth = 1;
+    let i = startFrom;
+    while (i < raw.length && depth > 0) {
+        if (raw.startsWith(`<${tag}`, i) &&
+            /[\s>/]/.test(raw[i + tag.length + 1] ?? "")) {
+            depth++;
+            i += tag.length + 2;
+        }
+        else if (raw.startsWith(`</${tag}>`, i)) {
+            depth--;
+            if (depth === 0)
+                break;
+            i += tag.length + 3;
+        }
+        else {
+            i++;
+        }
+    }
+    return raw.slice(startFrom, i).trim();
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&#(\d+);/g, (_m, code) => String.fromCharCode(Number(code)))
+        .replace(/&#x([0-9a-fA-F]+);/g, (_m, hex) => String.fromCharCode(parseInt(hex, 16)))
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, '\u00A0');
+}
+function normalizeWs(s) {
+    // collapse newlines (and surrounding whitespace) to a single space
+    // but preserve meaningful spaces at word/element boundaries
+    return s.replace(/\s*\n\s*/g, ' ');
+}
+function splitChildren(raw) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    let i = 0;
+    while (i < raw.length) {
+        const ch = raw[i];
+        if (ch === "<") {
+            if (raw[i + 1] === "/") {
+                if (depth === 0) {
+                    // closing tag for PARENT element — push current and skip tag
+                    const n = normalizeWs(current);
+                    if (n.trim())
+                        parts.push(n);
+                    current = "";
+                    while (i < raw.length && raw[i] !== ">")
+                        i++;
+                    i++;
+                    continue;
+                }
+                depth--;
+                if (depth === 0) {
+                    // just closed a CHILD element back to top level
+                    // accumulate through closing tag end, then split
+                    while (i < raw.length && raw[i] !== ">") {
+                        current += raw[i];
+                        i++;
+                    }
+                    if (i < raw.length) {
+                        current += raw[i]; // the >
+                        i++;
+                    }
+                    const n = normalizeWs(current);
+                    if (n.trim())
+                        parts.push(n);
+                    current = "";
+                    continue;
+                }
+            }
+            else if (raw[i + 1] !== "!") {
+                if (!isSelfClosingFrom(raw, i)) {
+                    depth++;
+                }
+            }
+        }
+        if (ch === "{")
+            depth++;
+        if (ch === "}")
+            depth--;
+        current += ch;
+        i++;
+        if (depth === 0 && current.trim()) {
+            const next = raw.slice(i).trimStart();
+            if (next.startsWith("<") ||
+                next.startsWith("$") ||
+                next.startsWith("{")) {
+                const n = normalizeWs(current);
+                if (n.trim())
+                    parts.push(n);
+                current = "";
+            }
+        }
+    }
+    const n = normalizeWs(current);
+    if (n.trim())
+        parts.push(n);
+    return parts.filter(p => p.trim().length > 0);
+}
+// look-ahead to determine if a tag starting at tagStart is self-closing (ends with />)
+function isSelfClosingFrom(raw, tagStart) {
+    let j = tagStart + 1;
+    let inQuote = null;
+    let braceDepth = 0;
+    while (j < raw.length) {
+        const c = raw[j];
+        if (inQuote) {
+            if (c === inQuote)
+                inQuote = null;
+        }
+        else if (c === '"' || c === "'") {
+            inQuote = c;
+        }
+        else if (c === "{") {
+            braceDepth++;
+        }
+        else if (c === "}") {
+            braceDepth--;
+        }
+        else if (c === ">" && braceDepth === 0) {
+            let k = j - 1;
+            while (k > tagStart && /\s/.test(raw[k]))
+                k--;
+            return raw[k] === "/";
+        }
+        j++;
+    }
+    return false;
+}
+
+class CLIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CLIError';
+    }
+}
+const STARTER_INDEX = `blueprint Home {
+	state {
+		count: number = 0
+	}
+	methods {
+		increment: () => $update(state.count, state.count + 1)
+		decrement: () => $update(state.count, state.count - 1)
+		reset: () => $update(state.count, 0)
+	}
+	style(tailwind) {
+	page: "min-h-screen bg-black text-zinc-100 antialiased"
+
+	container: "relative mx-auto flex min-h-screen w-full max-w-3xl items-center justify-center px-6"
+
+	bgGlow: "absolute inset-0 -z-10 bg-[radial-gradient(circle_at_center,rgba(0,255,255,0.08),transparent_60%)]"
+
+	card: "relative w-full rounded-2xl border border-white/10 bg-zinc-900/60 backdrop-blur-xl p-10 shadow-[0_0_60px_rgba(0,255,255,0.08)]"
+
+	label: "text-[10px] tracking-[0.2em] uppercase text-zinc-500"
+	title: "mt-3 text-3xl font-semibold tracking-tight"
+	subtitle: "mt-2 text-sm text-zinc-400"
+
+	valueWrap: "mt-10 rounded-xl border border-white/10 bg-black/40 px-6 py-8 text-center shadow-inner"
+	value: "text-6xl font-semibold tracking-tight"
+
+	actions: "mt-8 flex items-center justify-center gap-4"
+
+	btnPrimary: "rounded-lg bg-cyan-400 px-5 py-2 text-sm font-medium text-black transition-all duration-150 hover:bg-cyan-300 active:scale-[0.96] shadow-[0_0_20px_rgba(0,255,255,0.3)]"
+
+	btnSecondary: "rounded-lg border border-white/10 bg-white/5 px-5 py-2 text-sm font-medium text-zinc-200 transition-all duration-150 hover:bg-white/10 active:scale-[0.96]"
+
+	note: "mt-8 text-center text-xs text-zinc-600"
+}
+	ui {
+		<main class={"page"}>
+			<div class={"bgGlow"}></div>
+			<section class={"container"}>
+				<div class={"card"}>
+					<p class={"label"}>TardisJS Starter</p>
+					<h1 class={"title"}>Counter</h1>
+					<p class={"subtitle"}>A simple starting point with clean defaults.</p>
+
+					<div class={"valueWrap"}>
+						<p class={"value"}>{state.count}</p>
+					</div>
+
+					<div class={"actions"}>
+						<button class={"btnSecondary"} @click={methods.decrement}>-1</button>
+						<button class={"btnPrimary"} @click={methods.increment}>+1</button>
+						<button class={"btnSecondary"} @click={methods.reset}>Reset</button>
+					</div>
+
+					<p class={"note"}>Edit <code>pages/index.tardis</code> and build from here.</p>
+				</div>
+			</section>
+		</main>
+	}
+}
+`;
+const STARTER_BUTTON = `blueprint Button {
+	props {
+		label: string = "Action"
+		variant: "primary" | "secondary" = "primary"
+		onClick: function
+	}
+	style(tailwind) {
+		primary: "inline-flex items-center justify-center rounded-lg border border-cyan-500 bg-cyan-500 px-4 py-2 text-sm font-medium text-zinc-950 transition hover:bg-cyan-400 active:translate-y-px active:bg-cyan-500"
+		secondary: "inline-flex items-center justify-center rounded-lg border border-zinc-600 bg-zinc-900 px-4 py-2 text-sm font-medium text-zinc-200 transition hover:border-cyan-400 hover:text-cyan-300 active:translate-y-px"
+	}
+	ui {
+		<button class={props.variant === "primary" ? "primary" : "secondary"} @click={props.onClick}>{props.label}</button>
+	}
+}
+`;
+const STARTER_CONFIG = `export default {
+	pages: './pages',
+	components: './components',
+	outDir: './dist',
+	port: 3000,
+	title: 'tardis starter',
+	head: [
+		'<script src="https://cdn.tailwindcss.com"></script>',
+	],
+}
+`;
+const STARTER_PACKAGE = `{
+	"name": "my-tardis-app",
+	"version": "0.1.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "tardis dev",
+		"build": "tardis build",
+		"preview": "tardis preview"
+	},
+	"dependencies": {
+		"tardisjs": "latest"
+	}
+}
+`;
+const STARTER_GITIGNORE = `node_modules
+dist
+`;
+function toPosix(p) {
+    return p.split(path.sep).join('/');
+}
+function replaceRuntimeImport(code) {
+    return code.replace(/from\s+['"]tardisjs\/runtime['"]/g, "from '/tardis-runtime.js'");
+}
+let typescriptModulePromise = null;
+async function getTypeScriptModule() {
+    if (!typescriptModulePromise) {
+        typescriptModulePromise = import('typescript');
+    }
+    return typescriptModulePromise;
+}
+async function pathExists(targetPath) {
+    try {
+        await fsp.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDir(dirPath) {
+    await fsp.mkdir(dirPath, { recursive: true });
+}
+async function copyDirRecursive(src, dest) {
+    const entries = await fsp.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await ensureDir(destPath);
+            await copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            await fsp.copyFile(srcPath, destPath);
+        }
+    }
+}
+async function listTardisFiles(dirPath) {
+    if (!(await pathExists(dirPath)))
+        return [];
+    const entries = await fsp.readdir(dirPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listTardisFiles(fullPath)));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.tardis')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function pageFileToRoute(relativePath) {
+    const noExt = relativePath.replace(/\.tardis$/, '');
+    const segments = toPosix(noExt).split('/').filter(Boolean);
+    const mapped = segments
+        .map((segment) => {
+        if (segment === 'index')
+            return '';
+        const dynamic = segment.match(/^\[(.+)\]$/);
+        if (dynamic)
+            return `:${dynamic[1]}`;
+        return segment;
+    })
+        .filter((segment, index, arr) => !(segment === '' && index === arr.length - 1 && arr.length > 1));
+    const route = `/${mapped.filter(Boolean).join('/')}`;
+    return route === '' ? '/' : route;
+}
+async function loadConfig(cwd) {
+    const configPath = path.join(cwd, 'tardis.config.js');
+    if (!(await pathExists(configPath))) {
+        throw new CLIError('TardisError: no tardis.config.js found\n  Run "npx tardis init" to create a new project');
+    }
+    const mod = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+    const cfg = mod.default;
+    if (!cfg) {
+        throw new CLIError('TardisError: invalid tardis.config.js\n  Ensure it exports a default config object');
+    }
+    return {
+        pages: cfg.pages ?? './pages',
+        components: cfg.components ?? './components',
+        outDir: cfg.outDir ?? './dist',
+        port: cfg.port ?? 3000,
+        title: cfg.title,
+        head: cfg.head ?? [],
+        staticDir: cfg.staticDir ?? './public',
+    };
+}
+async function compileFile(source, filePath) {
+    const ast = parse(lex(source), path.basename(filePath));
+    const output = compile(ast);
+    const ts = await getTypeScriptModule();
+    const transpiled = ts.transpileModule(output, {
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2020,
+            module: ts.ModuleKind.ES2020,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+        },
+    }).outputText;
+    return {
+        code: replaceRuntimeImport(transpiled),
+        componentName: ast.name,
+    };
+}
+function buildClientIndexHtml(routes, devMode, config, componentArtifacts) {
+    const imports = ["import { createRouter } from '/tardis-runtime.js'"];
+    const componentRegs = [];
+    if (componentArtifacts && componentArtifacts.length > 0) {
+        for (const artifact of componentArtifacts) {
+            const importPath = `/${toPosix(artifact.outputPath)}`;
+            imports.push(`import { ${artifact.componentName} } from '${importPath}'`);
+            componentRegs.push(`      window.__tardis_${artifact.componentName} = ${artifact.componentName}`);
+        }
+    }
+    const routeEntries = [];
+    routes.forEach((route, idx) => {
+        const alias = `${route.exportName}_${idx}`;
+        imports.push(`import { ${route.exportName} as ${alias} } from '${route.importPath}'`);
+        routeEntries.push(`  { path: '${route.routePath}', component: ${alias} }`);
+    });
+    const hmrSnippet = devMode
+        ? `
+		const socket = new WebSocket((location.protocol === 'https:' ? 'wss://' : 'ws://') + location.host + '/ws')
+		socket.addEventListener('message', (event) => {
+			try {
+				const payload = JSON.parse(event.data)
+				if (payload.type === 'reload') location.reload()
+			} catch {
+				location.reload()
+			}
+		})
+`
+        : '';
+    const headContent = (config?.head ?? []).length > 0
+        ? '\n' + (config?.head ?? []).map(h => `\t\t${h}`).join('\n')
+        : '';
+    const componentRegBlock = componentRegs.length > 0
+        ? '\n' + componentRegs.join('\n') + '\n'
+        : '';
+    return `<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>${config?.title ?? 'tardis app'}</title>${headContent}
+	</head>
+	<body>
+		<div id="app"></div>
+		<script type="module">
+${imports.map((line) => `      ${line}`).join('\n')}
+${componentRegBlock}
+			const routes = [
+${routeEntries.join(',\n')}
+			]
+
+			const router = createRouter(routes)
+			router.start()
+${hmrSnippet}
+		</script>
+	</body>
+</html>
+`;
+}
+async function writeRuntimeModules(outDir) {
+    const cliDir = path.dirname(fileURLToPath(import.meta.url));
+    const frameworkRoot = path.resolve(cliDir, '..');
+    const runtimeSrcDir = path.join(frameworkRoot, 'src', 'runtime');
+    const runtimeOutDir = path.join(outDir, 'runtime');
+    if (await pathExists(runtimeSrcDir)) {
+        const runtimeFiles = (await fsp.readdir(runtimeSrcDir)).filter((f) => f.endsWith('.ts'));
+        await ensureDir(runtimeOutDir);
+        const ts = await getTypeScriptModule();
+        for (const file of runtimeFiles) {
+            const srcPath = path.join(runtimeSrcDir, file);
+            const raw = await fsp.readFile(srcPath, 'utf8');
+            const transpiled = ts.transpileModule(raw, {
+                compilerOptions: {
+                    target: ts.ScriptTarget.ES2020,
+                    module: ts.ModuleKind.ES2020,
+                    moduleResolution: ts.ModuleResolutionKind.Bundler,
+                },
+            }).outputText;
+            const withExt = transpiled.replace(/from\s+['"](\.\/?[^'"]+)['"]/g, (full, importPath) => {
+                if (importPath.endsWith('.js'))
+                    return full;
+                return full.replace(importPath, `${importPath}.js`);
+            });
+            const jsName = file.replace(/\.ts$/, '.js');
+            await fsp.writeFile(path.join(runtimeOutDir, jsName), withExt, 'utf8');
+        }
+        const entry = `export * from './runtime/index.js'\n`;
+        await fsp.writeFile(path.join(outDir, 'tardis-runtime.js'), entry, 'utf8');
+        await fsp.writeFile(path.join(outDir, 'runtime.js'), entry, 'utf8');
+        return;
+    }
+    const runtimeDist = path.join(frameworkRoot, 'dist', 'runtime', 'index.mjs');
+    if (await pathExists(runtimeDist)) {
+        const built = await fsp.readFile(runtimeDist, 'utf8');
+        await fsp.writeFile(path.join(outDir, 'tardis-runtime.js'), built, 'utf8');
+        await fsp.writeFile(path.join(outDir, 'runtime.js'), built, 'utf8');
+        return;
+    }
+    throw new CLIError('TardisError: runtime source not found\n  Reinstall tardisjs or run package build');
+}
+async function getDirectorySizeBytes(dirPath) {
+    if (!(await pathExists(dirPath)))
+        return 0;
+    const entries = await fsp.readdir(dirPath, { withFileTypes: true });
+    let total = 0;
+    for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            total += await getDirectorySizeBytes(fullPath);
+        }
+        else if (entry.isFile()) {
+            const stat = await fsp.stat(fullPath);
+            total += stat.size;
+        }
+    }
+    return total;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+async function collectArtifacts(cwd, config) {
+    const pagesDir = path.resolve(cwd, config.pages);
+    const componentsDir = path.resolve(cwd, config.components);
+    const pageFiles = await listTardisFiles(pagesDir);
+    const componentFiles = await listTardisFiles(componentsDir);
+    const pageArtifacts = [];
+    const componentArtifacts = [];
+    const routes = [];
+    for (const file of pageFiles) {
+        const source = await fsp.readFile(file, 'utf8');
+        const compiled = await compileFile(source, file);
+        const rel = toPosix(path.relative(pagesDir, file)).replace(/\.tardis$/, '.js');
+        const outPath = path.join('pages', rel);
+        pageArtifacts.push({
+            sourcePath: file,
+            outputPath: outPath,
+            outputCode: compiled.code,
+            componentName: compiled.componentName,
+        });
+        routes.push({
+            routePath: pageFileToRoute(toPosix(path.relative(pagesDir, file))),
+            importPath: `/${toPosix(outPath)}`,
+            exportName: compiled.componentName,
+        });
+    }
+    for (const file of componentFiles) {
+        const source = await fsp.readFile(file, 'utf8');
+        const compiled = await compileFile(source, file);
+        const rel = toPosix(path.relative(componentsDir, file)).replace(/\.tardis$/, '.js');
+        const outPath = path.join('components', rel);
+        componentArtifacts.push({
+            sourcePath: file,
+            outputPath: outPath,
+            outputCode: compiled.code,
+            componentName: compiled.componentName,
+        });
+    }
+    return { pageArtifacts, componentArtifacts, routes };
+}
+async function initProject(cwd = process.cwd()) {
+    await ensureDir(path.join(cwd, 'pages'));
+    await ensureDir(path.join(cwd, 'components'));
+    await fsp.writeFile(path.join(cwd, 'pages', 'index.tardis'), STARTER_INDEX, 'utf8');
+    await fsp.writeFile(path.join(cwd, 'components', 'Button.tardis'), STARTER_BUTTON, 'utf8');
+    await fsp.writeFile(path.join(cwd, 'tardis.config.js'), STARTER_CONFIG, 'utf8');
+    await fsp.writeFile(path.join(cwd, 'package.json'), STARTER_PACKAGE, 'utf8');
+    await fsp.writeFile(path.join(cwd, '.gitignore'), STARTER_GITIGNORE, 'utf8');
+    console.log('✨ Tardis project initialized');
+}
+async function createTardisApp(projectName, cwd = process.cwd()) {
+    const normalizedName = projectName.trim();
+    if (!normalizedName) {
+        throw new CLIError('TardisError: project name is required\n  Usage: create-tardis-app <project-name>');
+    }
+    const targetDir = path.resolve(cwd, normalizedName);
+    if (await pathExists(targetDir)) {
+        throw new CLIError(`TardisError: directory already exists\n  ${targetDir}`);
+    }
+    await ensureDir(targetDir);
+    await initProject(targetDir);
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    if (await pathExists(packageJsonPath)) {
+        const raw = await fsp.readFile(packageJsonPath, 'utf8');
+        const pkg = JSON.parse(raw);
+        pkg.name = normalizedName;
+        await fsp.writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+    }
+    console.log(`\n✅ Created ${normalizedName}`);
+    console.log(`\nNext steps:`);
+    console.log(`  cd ${normalizedName}`);
+    console.log(`  npm install`);
+    console.log(`  npm run dev`);
+}
+async function findAvailablePort(preferredPort) {
+    function check(port) {
+        return new Promise((resolve) => {
+            const tester = net.createServer();
+            tester.once('error', () => resolve(false));
+            tester.once('listening', () => {
+                tester.close(() => resolve(true));
+            });
+            tester.listen(port);
+        });
+    }
+    if (await check(preferredPort))
+        return preferredPort;
+    if (await check(preferredPort + 1))
+        return preferredPort + 1;
+    throw new CLIError(`TardisError: no open port found\n  Tried ${preferredPort} and ${preferredPort + 1}`);
+}
+async function buildProject(cwd = process.cwd()) {
+    const start = Date.now();
+    const config = await loadConfig(cwd);
+    const outDir = path.resolve(cwd, config.outDir);
+    await fsp.rm(outDir, { recursive: true, force: true });
+    await ensureDir(outDir);
+    const { pageArtifacts, componentArtifacts, routes } = await collectArtifacts(cwd, config);
+    const allArtifacts = [...pageArtifacts, ...componentArtifacts];
+    for (const artifact of allArtifacts) {
+        const absoluteOut = path.join(outDir, artifact.outputPath);
+        await ensureDir(path.dirname(absoluteOut));
+        await fsp.writeFile(absoluteOut, artifact.outputCode, 'utf8');
+    }
+    await writeRuntimeModules(outDir);
+    // Copy static files from staticDir
+    const staticSrcDir = path.resolve(cwd, config.staticDir ?? 'public');
+    if (await pathExists(staticSrcDir)) {
+        await copyDirRecursive(staticSrcDir, outDir);
+    }
+    await fsp.writeFile(path.join(outDir, 'index.html'), buildClientIndexHtml(routes, false, config, componentArtifacts), 'utf8');
+    const timeMs = Date.now() - start;
+    const outputBytes = await getDirectorySizeBytes(outDir);
+    console.log(`✅ Build complete`);
+    console.log(`- files compiled: ${allArtifacts.length}`);
+    console.log(`- time: ${timeMs}ms`);
+    console.log(`- output size: ${formatBytes(outputBytes)}`);
+    return { filesCompiled: allArtifacts.length, timeMs, outputBytes };
+}
+function contentType(filePath) {
+    if (filePath.endsWith('.html'))
+        return 'text/html; charset=utf-8';
+    if (filePath.endsWith('.js'))
+        return 'application/javascript; charset=utf-8';
+    if (filePath.endsWith('.json'))
+        return 'application/json; charset=utf-8';
+    if (filePath.endsWith('.css'))
+        return 'text/css; charset=utf-8';
+    if (filePath.endsWith('.svg'))
+        return 'image/svg+xml';
+    if (filePath.endsWith('.png'))
+        return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg'))
+        return 'image/jpeg';
+    if (filePath.endsWith('.gif'))
+        return 'image/gif';
+    if (filePath.endsWith('.ico'))
+        return 'image/x-icon';
+    if (filePath.endsWith('.woff2'))
+        return 'font/woff2';
+    if (filePath.endsWith('.woff'))
+        return 'font/woff';
+    return 'text/plain; charset=utf-8';
+}
+async function createDevAssets(cwd, config) {
+    const assets = new Map();
+    const { pageArtifacts, componentArtifacts, routes } = await collectArtifacts(cwd, config);
+    for (const artifact of [...pageArtifacts, ...componentArtifacts]) {
+        assets.set(`/${toPosix(artifact.outputPath)}`, artifact.outputCode);
+    }
+    const tempOut = path.join(cwd, '.tardis-dev-runtime');
+    await fsp.rm(tempOut, { recursive: true, force: true });
+    await ensureDir(tempOut);
+    await writeRuntimeModules(tempOut);
+    const runtimeFiles = await fsp.readdir(tempOut);
+    for (const file of runtimeFiles) {
+        const full = path.join(tempOut, file);
+        const stat = await fsp.stat(full);
+        if (stat.isDirectory()) {
+            const nested = await fsp.readdir(full);
+            for (const child of nested) {
+                const childPath = path.join(full, child);
+                const childRaw = await fsp.readFile(childPath, 'utf8');
+                assets.set(`/${toPosix(path.join(file, child))}`, childRaw);
+            }
+        }
+        else {
+            const raw = await fsp.readFile(full, 'utf8');
+            assets.set(`/${toPosix(file)}`, raw);
+        }
+    }
+    await fsp.rm(tempOut, { recursive: true, force: true });
+    assets.set('/index.html', buildClientIndexHtml(routes, true, config, componentArtifacts));
+    return assets;
+}
+async function devServer(cwd = process.cwd()) {
+    const config = await loadConfig(cwd);
+    const preferredPort = config.port ?? 3000;
+    const port = await findAvailablePort(preferredPort);
+    let assets = await createDevAssets(cwd, config);
+    const server = http.createServer(async (req, res) => {
+        const requestPath = req.url ? req.url.split('?')[0] : '/';
+        const normalizedPath = requestPath && requestPath !== '/' ? requestPath : '/index.html';
+        if (assets.has(normalizedPath)) {
+            const body = assets.get(normalizedPath);
+            res.writeHead(200, { 'Content-Type': contentType(normalizedPath) });
+            res.end(body);
+            return;
+        }
+        if (normalizedPath.startsWith('/pages/') || normalizedPath.startsWith('/components/') || normalizedPath.startsWith('/runtime/')) {
+            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('Not found');
+            return;
+        }
+        // Try static files from staticDir
+        const staticDir = path.resolve(cwd, config.staticDir ?? 'public');
+        const staticFilePath = path.join(staticDir, normalizedPath);
+        try {
+            const fileStat = await fsp.stat(staticFilePath);
+            if (fileStat.isFile()) {
+                const body = await fsp.readFile(staticFilePath);
+                res.writeHead(200, { 'Content-Type': contentType(normalizedPath) });
+                res.end(body);
+                return;
+            }
+        }
+        catch { }
+        const fallback = assets.get('/index.html') ?? '';
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(fallback);
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    server.on('upgrade', (req, socket, head) => {
+        if ((req.url ?? '').split('?')[0] !== '/ws') {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+    });
+    const pagesAbs = path.resolve(cwd, config.pages);
+    const componentsAbs = path.resolve(cwd, config.components);
+    const watcher = chokidar.watch([pagesAbs, componentsAbs], {
+        ignoreInitial: true,
+    });
+    watcher.on('all', async () => {
+        try {
+            assets = await createDevAssets(cwd, config);
+            const payload = JSON.stringify({ type: 'reload' });
+            for (const client of wss.clients) {
+                if (client.readyState === client.OPEN) {
+                    client.send(payload);
+                }
+            }
+            console.log('♻️  Recompiled');
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+        }
+    });
+    server.listen(port, () => {
+        if (port !== preferredPort) {
+            console.log(`⚠️  Port ${preferredPort} in use, using ${port} instead`);
+        }
+        console.log(`🚀 Dev server running at http://localhost:${port}`);
+    });
+    const shutdown = async () => {
+        await watcher.close();
+        wss.close();
+        server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+async function previewProject(cwd = process.cwd()) {
+    const outDir = path.join(cwd, 'dist');
+    if (!(await pathExists(outDir))) {
+        throw new CLIError('TardisError: dist directory not found\n  Run "npx tardis build" first');
+    }
+    const port = 4000;
+    const server = http.createServer(async (req, res) => {
+        const incoming = req.url ? req.url.split('?')[0] : '/';
+        const candidate = incoming === '/' ? '/index.html' : incoming;
+        const filePath = path.join(outDir, candidate);
+        try {
+            const stat = await fsp.stat(filePath);
+            if (stat.isDirectory()) {
+                const idx = path.join(filePath, 'index.html');
+                const body = await fsp.readFile(idx);
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(body);
+                return;
+            }
+            const body = await fsp.readFile(filePath);
+            res.writeHead(200, { 'Content-Type': contentType(filePath) });
+            res.end(body);
+        }
+        catch {
+            const fallback = path.join(outDir, 'index.html');
+            if (await pathExists(fallback)) {
+                const html = await fsp.readFile(fallback);
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+            }
+            else {
+                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Not found');
+            }
+        }
+    });
+    server.listen(port, () => {
+        console.log(`🔎 Preview server at http://localhost:${port}`);
+    });
+    const shutdown = () => {
+        server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+function createProgram() {
+    const program = new Command();
+    program
+        .name('tardis')
+        .description('tardisjs CLI');
+    program
+        .command('init')
+        .description('Initialize a new tardis app in current directory')
+        .action(async () => {
+        await initProject(process.cwd());
+    });
+    program
+        .command('build')
+        .description('Build tardis app for production')
+        .action(async () => {
+        await buildProject(process.cwd());
+    });
+    program
+        .command('dev')
+        .description('Run dev server with HMR')
+        .action(async () => {
+        await devServer(process.cwd());
+    });
+    program
+        .command('preview')
+        .description('Serve dist directory for preview')
+        .action(async () => {
+        await previewProject(process.cwd());
+    });
+    return program;
+}
+async function runCLI(argv = process.argv) {
+    const program = createProgram();
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(msg);
+        process.exit(1);
+    }
+}
+if (process.argv[1] && fs.existsSync(process.argv[1])) {
+    const current = pathToFileURL(process.argv[1]).href;
+    if (import.meta.url === current) {
+        runCLI();
+    }
+}
+
+async function run() {
+    const projectName = process.argv[2];
+    if (!projectName) {
+        console.error('TardisError: project name is required');
+        console.error('  Usage: create-tardis-app <project-name>');
+        process.exit(1);
+    }
+    try {
+        await createTardisApp(projectName, process.cwd());
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(msg);
+        process.exit(1);
+    }
+}
+run();
+//# sourceMappingURL=create-tardis-app.js.map