@kuratchi/js 0.0.15 → 0.0.16

package/README.md

@@ -16,9 +16,9 @@ cd my-app
 bun run dev
 ```
 
-## How it works
-
-`kuratchi build` (or `kuratchi watch`) scans `src/routes/` and generates framework output:
+## How it works
+
+`kuratchi build` (or `kuratchi watch`) scans `src/routes/` and generates framework output:
 
 | File | Purpose |
 |---|---|
@@ -26,11 +26,13 @@ bun run dev
 | `.kuratchi/worker.js` | Stable wrangler entry - re-exports the fetch handler plus all Durable Object and Agent classes |
 | `.kuratchi/do/*.js` | Generated Durable Object RPC proxy modules for `$durable-objects/*` imports |
 
-Point wrangler at the entry and you're done. **No `src/index.ts` needed.**
-
-```jsonc
-// wrangler.jsonc
-{
+Point wrangler at the entry and you're done. **No `src/index.ts` needed.**
+
+For the framework's internal compiler/runtime orchestration and tracked implementation roadmap, see [ARCHITECTURE.md](./ARCHITECTURE.md).
+
+```jsonc
+// wrangler.jsonc
+{
   "main": ".kuratchi/worker.js"
 }
 ```

package/dist/cli.js

@@ -6,34 +6,41 @@ import { compile } from './compiler/index.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import * as net from 'node:net';
+import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 const args = process.argv.slice(2);
 const command = args[0];
 const projectDir = process.cwd();
-switch (command) {
-    case 'build':
-        runBuild();
-        break;
-    case 'watch':
-        runWatch(false);
-        break;
-    case 'dev':
-        runWatch(true);
-        break;
-    case 'create':
-        runCreate();
-        break;
-    default:
-        console.log(`
-KuratchiJS CLI
-
-Usage:
-  kuratchi create [name]  Scaffold a new KuratchiJS project
-  kuratchi build          Compile routes once
-  kuratchi dev            Compile, watch for changes, and start wrangler dev server
-  kuratchi watch          Compile + watch only (no wrangler — for custom setups)
+void main().catch((err) => {
+    console.error(`[kuratchi] ${err?.message ?? err}`);
+    process.exit(1);
+});
+async function main() {
+    switch (command) {
+        case 'build':
+            runBuild();
+            return;
+        case 'watch':
+            await runWatch(false);
+            return;
+        case 'dev':
+            await runWatch(true);
+            return;
+        case 'create':
+            await runCreate();
+            return;
+        default:
+            console.log(`
+KuratchiJS CLI
+
+Usage:
+  kuratchi create [name]  Scaffold a new KuratchiJS project
+  kuratchi build          Compile routes once
+  kuratchi dev            Compile, watch for changes, and start wrangler dev server
+  kuratchi watch          Compile + watch only (no wrangler — for custom setups)
 `);
-        process.exit(1);
+            process.exit(1);
+    }
 }
 async function runCreate() {
     const { create } = await import('./create.js');
@@ -53,7 +60,7 @@ function runBuild(isDev = false) {
         process.exit(1);
     }
 }
-function runWatch(withWrangler = false) {
+async function runWatch(withWrangler = false) {
     runBuild(true);
     const routesDir = path.join(projectDir, 'src', 'routes');
     const serverDir = path.join(projectDir, 'src', 'server');
@@ -80,11 +87,10 @@ function runWatch(withWrangler = false) {
     // `kuratchi dev` also starts the wrangler dev server.
     // `kuratchi watch` is the compiler-only mode for custom setups.
     if (withWrangler) {
-        startWranglerDev().catch((err) => {
-            console.error(`[kuratchi] Failed to start wrangler dev: ${err?.message ?? err}`);
-            process.exit(1);
-        });
+        await startWranglerDev();
+        return;
     }
+    await new Promise(() => { });
 }
 function hasPortFlag(inputArgs) {
     for (let i = 0; i < inputArgs.length; i++) {
@@ -117,25 +123,13 @@ async function findOpenPort(start = 8787, end = 8899) {
 }
 async function startWranglerDev() {
     const passthroughArgs = args.slice(1);
-    const wranglerArgs = ['wrangler', 'dev', ...passthroughArgs];
+    const wranglerArgs = ['dev', ...passthroughArgs];
     if (!hasPortFlag(passthroughArgs)) {
         const port = await findOpenPort();
         wranglerArgs.push('--port', String(port));
         console.log(`[kuratchi] Starting wrangler dev on port ${port}`);
     }
-    // Use 'pipe' for stdin so wrangler doesn't detect stdin EOF and exit
-    // prematurely when launched via a script runner (e.g. `bun run dev`).
-    const isWin = process.platform === 'win32';
-    const wrangler = isWin
-        ? spawn('npx ' + wranglerArgs.join(' '), {
-            cwd: projectDir,
-            stdio: ['pipe', 'inherit', 'inherit'],
-            shell: true,
-        })
-        : spawn('npx', wranglerArgs, {
-            cwd: projectDir,
-            stdio: ['pipe', 'inherit', 'inherit'],
-        });
+    const wrangler = spawnWranglerProcess(wranglerArgs);
     const cleanup = () => {
         if (!wrangler.killed)
             wrangler.kill();
@@ -143,10 +137,49 @@ async function startWranglerDev() {
     process.on('exit', cleanup);
     process.on('SIGINT', () => { cleanup(); process.exit(0); });
     process.on('SIGTERM', () => { cleanup(); process.exit(0); });
-    wrangler.on('exit', (code) => {
-        if (code !== 0 && code !== null) {
-            console.error(`[kuratchi] wrangler exited with code ${code}`);
-        }
-        process.exit(code ?? 0);
+    await new Promise((resolve, reject) => {
+        wrangler.on('exit', (code) => {
+            if (code !== 0 && code !== null) {
+                reject(new Error(`wrangler exited with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+        wrangler.on('error', (err) => {
+            reject(err);
+        });
+    }).catch((err) => {
+        console.error(`[kuratchi] Failed to start wrangler dev: ${err?.message ?? err}`);
+        process.exit(1);
+    });
+}
+function resolveWranglerBin() {
+    try {
+        const projectPackageJson = path.join(projectDir, 'package.json');
+        const projectRequire = createRequire(projectPackageJson);
+        return projectRequire.resolve('wrangler/bin/wrangler.js');
+    }
+    catch {
+        return null;
+    }
+}
+function getNodeExecutable() {
+    if (!process.versions.bun)
+        return process.execPath;
+    return 'node';
+}
+function spawnWranglerProcess(wranglerArgs) {
+    const localWranglerBin = resolveWranglerBin();
+    const stdio = ['pipe', 'inherit', 'inherit'];
+    if (localWranglerBin) {
+        return spawn(getNodeExecutable(), [localWranglerBin, ...wranglerArgs], {
+            cwd: projectDir,
+            stdio,
+        });
+    }
+    const fallbackCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+    return spawn(fallbackCommand, ['wrangler', ...wranglerArgs], {
+        cwd: projectDir,
+        stdio,
     });
 }

package/dist/compiler/api-route-pipeline.d.ts

@@ -0,0 +1,8 @@
+export declare function compileApiRoute(opts: {
+    pattern: string;
+    fullPath: string;
+    projectDir: string;
+    transformModule: (entryAbsPath: string) => string;
+    allocateModuleId: () => string;
+    pushImport: (statement: string) => void;
+}): string;

package/dist/compiler/api-route-pipeline.js

@@ -0,0 +1,23 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const ALL_API_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+export function compileApiRoute(opts) {
+    const outFileDir = path.join(opts.projectDir, '.kuratchi');
+    const absRoutePath = opts.transformModule(opts.fullPath);
+    let importPath = path.relative(outFileDir, absRoutePath).replace(/\\/g, '/');
+    if (!importPath.startsWith('.'))
+        importPath = './' + importPath;
+    const moduleId = opts.allocateModuleId();
+    opts.pushImport(`import * as ${moduleId} from '${importPath}';`);
+    const apiSource = fs.readFileSync(opts.fullPath, 'utf-8');
+    const exportedMethods = ALL_API_METHODS.filter((method) => {
+        const fnPattern = new RegExp(`export\\s+(async\\s+)?function\\s+${method}\\b`);
+        const reExportPattern = new RegExp(`export\\s*\\{[^}]*\\b\\w+\\s+as\\s+${method}\\b`);
+        const namedExportPattern = new RegExp(`export\\s*\\{[^}]*\\b${method}\\b`);
+        return fnPattern.test(apiSource) || reExportPattern.test(apiSource) || namedExportPattern.test(apiSource);
+    });
+    const methodEntries = exportedMethods
+        .map((method) => `${method}: ${moduleId}.${method}`)
+        .join(', ');
+    return `{ pattern: '${opts.pattern}', __api: true, ${methodEntries} }`;
+}

package/dist/compiler/asset-pipeline.d.ts

@@ -0,0 +1,7 @@
+export interface CompiledAsset {
+    name: string;
+    content: string;
+    mime: string;
+    etag: string;
+}
+export declare function compileAssets(assetsDir: string): CompiledAsset[];

package/dist/compiler/asset-pipeline.js

@@ -0,0 +1,33 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const MIME_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.txt': 'text/plain; charset=utf-8',
+};
+export function compileAssets(assetsDir) {
+    const compiledAssets = [];
+    if (!fs.existsSync(assetsDir))
+        return compiledAssets;
+    const scanAssets = (dir, prefix) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (entry.isDirectory()) {
+                scanAssets(path.join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+                continue;
+            }
+            const ext = path.extname(entry.name).toLowerCase();
+            const mime = MIME_TYPES[ext];
+            if (!mime)
+                continue;
+            const content = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+            const etag = '"' + crypto.createHash('md5').update(content).digest('hex').slice(0, 12) + '"';
+            const name = prefix ? `${prefix}/${entry.name}` : entry.name;
+            compiledAssets.push({ name, content, mime, etag });
+        }
+    };
+    scanAssets(assetsDir, '');
+    return compiledAssets;
+}

package/dist/compiler/client-module-pipeline.d.ts

@@ -0,0 +1,25 @@
+import type { CompiledAsset } from './asset-pipeline.js';
+import { type RouteImportEntry } from './import-linking.js';
+export interface ClientEventRegistration {
+    routeId: string;
+    handlerId: string;
+    argsExpr: string | null;
+}
+export interface ClientModuleCompiler {
+    createRegistry(scopeId: string, importEntries: RouteImportEntry[]): ClientRouteRegistry;
+    createRouteRegistry(routeIndex: number, importEntries: RouteImportEntry[]): ClientRouteRegistry;
+    getCompiledAssets(): CompiledAsset[];
+}
+export interface ClientRouteRegistry {
+    hasBindings(): boolean;
+    hasBindingReference(expression: string): boolean;
+    registerEventHandler(eventName: string, expression: string): ClientEventRegistration | null;
+    buildEntryAsset(): {
+        assetName: string;
+        asset: CompiledAsset;
+    } | null;
+}
+export declare function createClientModuleCompiler(opts: {
+    projectDir: string;
+    srcDir: string;
+}): ClientModuleCompiler;

package/dist/compiler/client-module-pipeline.js

@@ -0,0 +1,257 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { collectReferencedIdentifiers, parseImportStatement } from './import-linking.js';
+import { transpileTypeScript } from './transpile.js';
+function resolveExistingModuleFile(absBase) {
+    const candidates = [
+        absBase,
+        absBase + '.ts',
+        absBase + '.js',
+        absBase + '.mjs',
+        absBase + '.cjs',
+        path.join(absBase, 'index.ts'),
+        path.join(absBase, 'index.js'),
+        path.join(absBase, 'index.mjs'),
+        path.join(absBase, 'index.cjs'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile())
+            return candidate;
+    }
+    return null;
+}
+function buildAsset(name, content) {
+    return {
+        name,
+        content,
+        mime: 'text/javascript; charset=utf-8',
+        etag: '"' + crypto.createHash('md5').update(content).digest('hex').slice(0, 12) + '"',
+    };
+}
+function toRelativeSpecifier(fromAssetName, toAssetName) {
+    let rel = path.posix.relative(path.posix.dirname(fromAssetName), toAssetName);
+    if (!rel.startsWith('.'))
+        rel = './' + rel;
+    return rel;
+}
+function rewriteImportSpecifiers(source, rewriteSpecifier) {
+    let rewritten = source.replace(/(from\s+)(['"])([^'"]+)\2/g, (_match, prefix, quote, spec) => {
+        return `${prefix}${quote}${rewriteSpecifier(spec)}${quote}`;
+    });
+    rewritten = rewritten.replace(/(import\s*\(\s*)(['"])([^'"]+)\2(\s*\))/g, (_match, prefix, quote, spec, suffix) => {
+        return `${prefix}${quote}${rewriteSpecifier(spec)}${quote}${suffix}`;
+    });
+    return rewritten;
+}
+function resolveClientImportTarget(srcDir, importerAbs, spec) {
+    if (spec.startsWith('$')) {
+        const slashIdx = spec.indexOf('/');
+        const folder = slashIdx === -1 ? spec.slice(1) : spec.slice(1, slashIdx);
+        const rest = slashIdx === -1 ? '' : spec.slice(slashIdx + 1);
+        if (folder !== 'client' && folder !== 'shared') {
+            throw new Error(`[kuratchi compiler] Unsupported browser import realm "${spec}". Only $client/* and $shared/* may be loaded in the browser.`);
+        }
+        const abs = path.join(srcDir, folder, rest);
+        const resolved = resolveExistingModuleFile(abs);
+        if (!resolved) {
+            throw new Error(`[kuratchi compiler] Browser import not found: ${spec}`);
+        }
+        return resolved;
+    }
+    if (spec.startsWith('.')) {
+        const abs = path.resolve(path.dirname(importerAbs), spec);
+        const resolved = resolveExistingModuleFile(abs);
+        if (!resolved) {
+            throw new Error(`[kuratchi compiler] Browser import not found: ${spec}`);
+        }
+        return resolved;
+    }
+    throw new Error(`[kuratchi compiler] Browser modules currently only support project-local imports ($client, $shared, or relative). Unsupported import: ${spec}`);
+}
+class CompilerBackedClientRouteRegistry {
+    compiler;
+    bindingMap = new Map();
+    clientOnlyBindings = new Set();
+    handlerByKey = new Map();
+    routeId;
+    constructor(compiler, scopeId, importEntries) {
+        this.compiler = compiler;
+        this.routeId = scopeId;
+        for (const entry of importEntries) {
+            const parsed = parseImportStatement(entry.line);
+            if (!parsed.moduleSpecifier)
+                continue;
+            const isClient = parsed.moduleSpecifier.startsWith('$client/');
+            const isShared = parsed.moduleSpecifier.startsWith('$shared/');
+            if (!isClient && !isShared)
+                continue;
+            for (const binding of parsed.bindings) {
+                this.bindingMap.set(binding.local, {
+                    importLine: entry.line,
+                    importerDir: entry.importerDir,
+                    localName: binding.local,
+                    moduleSpecifier: parsed.moduleSpecifier,
+                });
+                if (isClient)
+                    this.clientOnlyBindings.add(binding.local);
+            }
+            if (parsed.namespaceImport) {
+                this.bindingMap.set(parsed.namespaceImport, {
+                    importLine: entry.line,
+                    importerDir: entry.importerDir,
+                    localName: parsed.namespaceImport,
+                    moduleSpecifier: parsed.moduleSpecifier,
+                });
+                if (isClient)
+                    this.clientOnlyBindings.add(parsed.namespaceImport);
+            }
+        }
+    }
+    hasBindings() {
+        return this.bindingMap.size > 0;
+    }
+    hasBindingReference(expression) {
+        const refs = collectReferencedIdentifiers(expression);
+        for (const ref of refs) {
+            if (this.bindingMap.has(ref))
+                return true;
+        }
+        return false;
+    }
+    registerEventHandler(_eventName, expression) {
+        const parsed = this.parseClientExpression(expression);
+        if (!parsed)
+            return null;
+        const binding = this.bindingMap.get(parsed.rootBinding);
+        if (!binding)
+            return null;
+        if (parsed.argsExpr) {
+            const argRefs = collectReferencedIdentifiers(parsed.argsExpr);
+            const leakedClientRefs = Array.from(argRefs).filter((ref) => this.clientOnlyBindings.has(ref));
+            if (leakedClientRefs.length > 0) {
+                throw new Error(`[kuratchi compiler] Client event arguments cannot depend on $client bindings: ${leakedClientRefs.join(', ')}.\n` +
+                    `Only server/shared values can be serialized into event handler arguments.`);
+            }
+        }
+        const key = `${parsed.calleeExpr}::${parsed.argsExpr || ''}`;
+        let existing = this.handlerByKey.get(key);
+        if (!existing) {
+            existing = {
+                id: `h${this.handlerByKey.size}`,
+                calleeExpr: parsed.calleeExpr,
+                rootBinding: parsed.rootBinding,
+            };
+            this.handlerByKey.set(key, existing);
+        }
+        return {
+            routeId: this.routeId,
+            handlerId: existing.id,
+            argsExpr: parsed.argsExpr,
+        };
+    }
+    buildEntryAsset() {
+        if (this.handlerByKey.size === 0)
+            return null;
+        const usedImportLines = new Map();
+        for (const record of this.handlerByKey.values()) {
+            const binding = this.bindingMap.get(record.rootBinding);
+            if (!binding)
+                continue;
+            if (!usedImportLines.has(binding.importLine)) {
+                usedImportLines.set(binding.importLine, {
+                    line: binding.importLine,
+                    importerDir: binding.importerDir,
+                });
+            }
+        }
+        const assetName = `__kuratchi/client/routes/${this.routeId}.js`;
+        const importLines = [];
+        for (const entry of usedImportLines.values()) {
+            const parsed = parseImportStatement(entry.line);
+            if (!parsed.moduleSpecifier)
+                continue;
+            const targetAbs = resolveClientImportTarget(this.compiler.srcDir, path.join(entry.importerDir, '__route__.ts'), parsed.moduleSpecifier);
+            const targetAssetName = this.compiler.transformClientModule(targetAbs);
+            const relSpecifier = toRelativeSpecifier(assetName, targetAssetName);
+            importLines.push(entry.line.replace(parsed.moduleSpecifier, relSpecifier));
+        }
+        const registrationEntries = Array.from(this.handlerByKey.values()).map((record) => {
+            return `${JSON.stringify(record.id)}: (args, event, element) => ${record.calleeExpr}(...args, event, element)`;
+        });
+        const source = transpileTypeScript([
+            ...importLines,
+            `window.__kuratchiClient?.register(${JSON.stringify(this.routeId)}, {`,
+            registrationEntries.map((entry) => `  ${entry},`).join('\n'),
+            `});`,
+        ].join('\n'), `client-route:${this.routeId}.ts`);
+        const asset = buildAsset(assetName, source);
+        this.compiler.registerAsset(asset);
+        return { assetName, asset };
+    }
+    parseClientExpression(expression) {
+        const trimmed = expression.trim();
+        if (!trimmed)
+            return null;
+        const callMatch = trimmed.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\(([\s\S]*)\)$/);
+        if (callMatch) {
+            const calleeExpr = callMatch[1];
+            const rootBinding = calleeExpr.split('.')[0];
+            const argsExpr = (callMatch[2] || '').trim();
+            return { calleeExpr, rootBinding, argsExpr: argsExpr || null };
+        }
+        const refMatch = trimmed.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)$/);
+        if (!refMatch)
+            return null;
+        const calleeExpr = refMatch[1];
+        const rootBinding = calleeExpr.split('.')[0];
+        return { calleeExpr, rootBinding, argsExpr: null };
+    }
+}
+class CompilerBackedClientModuleCompiler {
+    projectDir;
+    srcDir;
+    compiledAssets = new Map();
+    transformedModules = new Map();
+    constructor(projectDir, srcDir) {
+        this.projectDir = projectDir;
+        this.srcDir = srcDir;
+    }
+    createRegistry(scopeId, importEntries) {
+        return new CompilerBackedClientRouteRegistry(this, scopeId, importEntries);
+    }
+    createRouteRegistry(routeIndex, importEntries) {
+        return this.createRegistry(`route_${routeIndex}`, importEntries);
+    }
+    getCompiledAssets() {
+        return Array.from(this.compiledAssets.values());
+    }
+    registerAsset(asset) {
+        this.compiledAssets.set(asset.name, asset);
+    }
+    transformClientModule(entryAbsPath) {
+        const resolved = resolveExistingModuleFile(entryAbsPath) ?? entryAbsPath;
+        const normalized = resolved.replace(/\\/g, '/');
+        const cached = this.transformedModules.get(normalized);
+        if (cached)
+            return cached;
+        const relFromSrc = path.relative(this.srcDir, resolved).replace(/\\/g, '/');
+        const assetName = `__kuratchi/client/modules/${relFromSrc.replace(/\.(ts|js|mjs|cjs)$/i, '.js')}`;
+        this.transformedModules.set(normalized, assetName);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`[kuratchi compiler] Browser module not found: ${resolved}`);
+        }
+        const source = fs.readFileSync(resolved, 'utf-8');
+        let rewritten = transpileTypeScript(source, `client-module:${relFromSrc}`);
+        rewritten = rewriteImportSpecifiers(rewritten, (spec) => {
+            const targetAbs = resolveClientImportTarget(this.srcDir, resolved, spec);
+            const targetAssetName = this.transformClientModule(targetAbs);
+            return toRelativeSpecifier(assetName, targetAssetName);
+        });
+        this.registerAsset(buildAsset(assetName, rewritten));
+        return assetName;
+    }
+}
+export function createClientModuleCompiler(opts) {
+    return new CompilerBackedClientModuleCompiler(opts.projectDir, opts.srcDir);
+}

package/dist/compiler/compiler-shared.d.ts

@@ -0,0 +1,55 @@
+export interface OrmDatabaseEntry {
+    binding: string;
+    schemaImportPath: string;
+    schemaExportName: string;
+    skipMigrations: boolean;
+    type: 'd1' | 'do';
+}
+export interface AuthConfigEntry {
+    cookieName: string;
+    secretEnvKey: string;
+    sessionEnabled: boolean;
+    hasCredentials: boolean;
+    hasActivity: boolean;
+    hasRoles: boolean;
+    hasOAuth: boolean;
+    hasGuards: boolean;
+    hasRateLimit: boolean;
+    hasTurnstile: boolean;
+    hasOrganization: boolean;
+}
+export interface DoConfigEntry {
+    binding: string;
+    className: string;
+    stubId?: string;
+    files?: string[];
+}
+export interface WorkerClassConfigEntry {
+    binding: string;
+    className: string;
+    file: string;
+    exportKind: 'named' | 'default';
+}
+export interface ConventionClassEntry {
+    className: string;
+    file: string;
+    exportKind: 'named' | 'default';
+}
+export interface DoClassMethodEntry {
+    name: string;
+    visibility: 'public' | 'private' | 'protected';
+    isStatic: boolean;
+    isAsync: boolean;
+    hasWorkerContextCalls: boolean;
+    callsThisMethods: string[];
+}
+export interface DoHandlerEntry {
+    fileName: string;
+    absPath: string;
+    binding: string;
+    mode: 'class' | 'function';
+    className?: string;
+    classMethods: DoClassMethodEntry[];
+    exportedFunctions: string[];
+}
+export declare function toSafeIdentifier(input: string): string;

package/dist/compiler/compiler-shared.js

@@ -0,0 +1,4 @@
+export function toSafeIdentifier(input) {
+    const normalized = input.replace(/[^A-Za-z0-9_$]/g, '_');
+    return /^[A-Za-z_$]/.test(normalized) ? normalized : `_${normalized}`;
+}

package/dist/compiler/component-pipeline.d.ts

@@ -0,0 +1,15 @@
+export interface ComponentCompiler {
+    ensureCompiled(fileName: string): string | null;
+    collectComponentMap(componentImports: Record<string, string>): Map<string, string>;
+    getActionPropNames(fileName: string): Set<string>;
+    collectStyles(componentNames: Map<string, string>): string[];
+    resolveActionProps(template: string, componentNames: Map<string, string>, shouldInclude?: (fnName: string) => boolean): Set<string>;
+    getCompiledComponents(): string[];
+}
+interface CreateComponentCompilerOptions {
+    projectDir: string;
+    srcDir: string;
+    isDev: boolean;
+}
+export declare function createComponentCompiler(options: CreateComponentCompilerOptions): ComponentCompiler;
+export {};