@kuratchi/js 0.0.4 → 0.0.6

package/README.md

@@ -50,8 +50,6 @@ src/routes/layout.html        → shared layout wrapping all routes
 
 ```html
 <script>
-  // Imports and server-side logic run on every request.
-  // Exported functions become actions or RPC handlers automatically.
   import { getItems, addItem, deleteItem } from '$database/items';
 
   const items = await getItems();
@@ -472,7 +470,26 @@ import {
 } from '@kuratchi/js';
 ```
 
-Environment bindings are accessed directly via the Cloudflare Workers API — no framework wrapper needed:
+## Environment bindings
+
+Cloudflare env is server-only.
+
+- Route top-level `<script>`, route `load()` functions, server actions, API handlers, and other server modules can read env.
+- Templates, components, and client `<script>` blocks cannot read env directly.
+- If a value must reach the browser, compute it in the server route script and reference it in the template, or return it from `load()` explicitly.
+
+```html
+<script>
+  import { env } from 'cloudflare:workers';
+  const turnstileSiteKey = env.TURNSTILE_SITE_KEY || '';
+</script>
+
+if (turnstileSiteKey) {
+  <div class="cf-turnstile" data-sitekey={turnstileSiteKey}></div>
+}
+```
+
+Server modules can still access env directly:
 
 ```ts
 import { env } from 'cloudflare:workers';

package/dist/compiler/index.js

@@ -4,6 +4,7 @@
  */
 import { parseFile } from './parser.js';
 import { compileTemplate } from './template.js';
+import { transpileTypeScript } from './transpile.js';
 import { filePathToPattern } from '../runtime/router.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -31,6 +32,26 @@ function compactInlineJs(source) {
         .replace(/\s*([{}();,:])\s*/g, '$1')
         .trim();
 }
+function rewriteImportedFunctionCalls(source, fnToModule) {
+    let out = source;
+    for (const [fnName, moduleId] of Object.entries(fnToModule)) {
+        if (!/^[A-Za-z_$][\w$]*$/.test(fnName))
+            continue;
+        const callRegex = new RegExp(`\\b${fnName}\\s*\\(`, 'g');
+        out = out.replace(callRegex, `${moduleId}.${fnName}(`);
+    }
+    return out;
+}
+function rewriteWorkerEnvAliases(source, aliases) {
+    let out = source;
+    for (const alias of aliases) {
+        if (!/^[A-Za-z_$][\w$]*$/.test(alias))
+            continue;
+        const aliasRegex = new RegExp(`\\b${alias}\\b`, 'g');
+        out = out.replace(aliasRegex, '__env');
+    }
+    return out;
+}
 function parseNamedImportBindings(line) {
     const namesMatch = line.match(/import\s*\{([^}]+)\}/);
     if (!namesMatch)
@@ -113,13 +134,16 @@ export function compile(options) {
         // Use parseFile to properly split the <script> block from the template, and to
         // separate component imports (import X from '@kuratchi/ui/x.html') from regular code.
         // This prevents import lines from being inlined verbatim in the compiled function body.
-        const compParsed = parseFile(rawSource);
+        const compParsed = parseFile(rawSource, { kind: 'component', filePath });
         // propsCode = script body with all import lines stripped out
         const propsCode = compParsed.script
             ? compParsed.script
                 .replace(/^\s*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?/gm, '')
                 .trim()
             : '';
+        const transpiledPropsCode = propsCode
+            ? transpileTypeScript(propsCode, `component-script:${fileName}.ts`)
+            : '';
         // template source (parseFile already removes the <script> block)
         let source = compParsed.template;
         // Extract optional <style> block â€" CSS is scoped and injected once per route at compile time
@@ -183,7 +207,7 @@ export function compile(options) {
         // Insert scope open after 'let __html = "";' (first line of body) and scope close at end
         const bodyLines = body.split('\n');
         const scopedBody = [bodyLines[0], scopeOpen, ...bodyLines.slice(1), scopeClose].join('\n');
-        const fnBody = propsCode ? `${propsCode}\n  ${scopedBody}` : scopedBody;
+        const fnBody = transpiledPropsCode ? `${transpiledPropsCode}\n  ${scopedBody}` : scopedBody;
         const compiled = `function ${funcName}(props, __esc) {\n  ${fnBody}\n  return __html;\n}`;
         compiledComponentCache.set(fileName, compiled);
         return compiled;
@@ -595,7 +619,7 @@ export function compile(options) {
         }
         source = source.replace('</body>', actionScript + '\n</body>');
         // Parse layout for <script> block (component imports + data vars)
-        const layoutParsed = parseFile(source);
+        const layoutParsed = parseFile(source, { kind: 'layout', filePath: layoutFile });
         const hasLayoutScript = layoutParsed.script && (Object.keys(layoutParsed.componentImports).length > 0 || layoutParsed.hasLoad);
         if (hasLayoutScript) {
             // Dynamic layout â€" has component imports and/or data declarations
@@ -830,7 +854,7 @@ export function compile(options) {
     let compiledLayoutActions = null;
     if (compiledLayout && fs.existsSync(path.join(routesDir, 'layout.html'))) {
         const layoutSource = fs.readFileSync(path.join(routesDir, 'layout.html'), 'utf-8');
-        const layoutParsedForImports = parseFile(layoutSource);
+        const layoutParsedForImports = parseFile(layoutSource, { kind: 'layout', filePath: layoutFile });
         if (layoutParsedForImports.serverImports.length > 0) {
             const layoutFileDir = routesDir;
             const outFileDir = path.join(projectDir, '.kuratchi');
@@ -920,7 +944,7 @@ export function compile(options) {
         }
         // ── Page route (page.html) ──
         const source = fs.readFileSync(fullPath, 'utf-8');
-        const parsed = parseFile(source);
+        const parsed = parseFile(source, { kind: 'route', filePath: fullPath });
         // Build a mapping: functionName â†' moduleId for all imports in this route
         const fnToModule = {};
         const outFileDir = path.join(projectDir, '.kuratchi');
@@ -1357,11 +1381,23 @@ function buildRouteObject(opts) {
     let scriptBody = parsed.script
         ? parsed.script.replace(/^\s*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?/gm, '').trim()
         : '';
-    for (const [fnName, moduleId] of Object.entries(fnToModule)) {
-        if (!/^[A-Za-z_$][\w$]*$/.test(fnName))
-            continue;
-        const callRegex = new RegExp(`\\b${fnName}\\s*\\(`, 'g');
-        scriptBody = scriptBody.replace(callRegex, `${moduleId}.${fnName}(`);
+    scriptBody = rewriteImportedFunctionCalls(scriptBody, fnToModule);
+    scriptBody = rewriteWorkerEnvAliases(scriptBody, parsed.workerEnvAliases);
+    let explicitLoadFunction = parsed.loadFunction
+        ? parsed.loadFunction.replace(/^export\s+/, '').trim()
+        : '';
+    if (explicitLoadFunction) {
+        explicitLoadFunction = rewriteImportedFunctionCalls(explicitLoadFunction, fnToModule);
+        explicitLoadFunction = rewriteWorkerEnvAliases(explicitLoadFunction, parsed.workerEnvAliases);
+    }
+    if (explicitLoadFunction && /\bawait\b/.test(scriptBody)) {
+        throw new Error(`[kuratchi compiler] ${pattern}\nTop-level await cannot be mixed with export async function load(). Move async server work into load().`);
+    }
+    if (scriptBody) {
+        scriptBody = transpileTypeScript(scriptBody, `route-script:${pattern}.ts`);
+    }
+    if (explicitLoadFunction) {
+        explicitLoadFunction = transpileTypeScript(explicitLoadFunction, `route-load:${pattern}.ts`);
     }
     const scriptUsesAwait = /\bawait\b/.test(scriptBody);
     const scriptReturnVars = parsed.script
@@ -1370,7 +1406,10 @@ function buildRouteObject(opts) {
     // Load function â€" internal server prepass for async route script bodies
     // and data-get query state hydration.
     const hasDataGetQueries = Array.isArray(parsed.dataGetQueries) && parsed.dataGetQueries.length > 0;
-    if ((scriptBody && scriptUsesAwait) || hasDataGetQueries) {
+    if (explicitLoadFunction) {
+        parts.push(`    load: ${explicitLoadFunction}`);
+    }
+    else if ((scriptBody && scriptUsesAwait) || hasDataGetQueries) {
         let loadBody = '';
         if (scriptBody && scriptUsesAwait) {
             loadBody = scriptBody;

package/dist/compiler/parser.d.ts

@@ -10,6 +10,8 @@
 export interface ParsedFile {
     /** Script content (compile-time code, minus imports) */
     script: string | null;
+    /** Explicit server-side load function exported from the route script */
+    loadFunction: string | null;
     /** Template — the full HTML document with inline JS flow control */
     template: string;
     /** All imports from the script block */
@@ -34,6 +36,14 @@ export interface ParsedFile {
     }>;
     /** Imports found in a top-level client script block */
     clientImports: string[];
+    /** Top-level names returned from explicit load() */
+    loadReturnVars: string[];
+    /** Local aliases for Cloudflare Workers env imported from cloudflare:workers */
+    workerEnvAliases: string[];
+}
+interface ParseFileOptions {
+    kind?: 'route' | 'layout' | 'component';
+    filePath?: string;
 }
 /**
  * Parse a .html route file.
@@ -42,4 +52,5 @@ export interface ParsedFile {
  * If it includes reactive `$:` labels, it is preserved in template output.
  * Everything else (the HTML document) becomes the template.
  */
-export declare function parseFile(source: string): ParsedFile;
+export declare function parseFile(source: string, options?: ParseFileOptions): ParsedFile;
+export {};

package/dist/compiler/parser.js

@@ -108,6 +108,220 @@ function pushIdentifier(name, out) {
     if (!out.includes(name))
         out.push(name);
 }
+function findMatchingToken(input, openPos, openChar, closeChar) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let i = openPos; i < input.length; i++) {
+        const ch = input[i];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            quote = ch;
+            continue;
+        }
+        if (ch === openChar)
+            depth++;
+        else if (ch === closeChar) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function extractCloudflareEnvAliases(importLine) {
+    if (!/from\s+['"]cloudflare:workers['"]/.test(importLine))
+        return [];
+    const namedMatch = importLine.match(/import\s*\{([\s\S]*?)\}\s*from\s+['"]cloudflare:workers['"]/);
+    if (!namedMatch)
+        return [];
+    const aliases = [];
+    for (const rawPart of splitTopLevel(namedMatch[1], ',')) {
+        const part = rawPart.trim();
+        if (!part)
+            continue;
+        const envMatch = part.match(/^env(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+        if (envMatch)
+            aliases.push(envMatch[1] || 'env');
+    }
+    return aliases;
+}
+function extractReturnObjectKeys(body) {
+    const keys = [];
+    let i = 0;
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let quote = null;
+    let escaped = false;
+    while (i < body.length) {
+        const ch = body[i];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                i++;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                i++;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            quote = ch;
+            i++;
+            continue;
+        }
+        if (ch === '(')
+            depthParen++;
+        else if (ch === ')')
+            depthParen = Math.max(0, depthParen - 1);
+        else if (ch === '[')
+            depthBracket++;
+        else if (ch === ']')
+            depthBracket = Math.max(0, depthBracket - 1);
+        else if (ch === '{')
+            depthBrace++;
+        else if (ch === '}')
+            depthBrace = Math.max(0, depthBrace - 1);
+        if (depthParen !== 0 || depthBracket !== 0 || depthBrace !== 0) {
+            i++;
+            continue;
+        }
+        const rest = body.slice(i);
+        const returnMatch = /^return\b/.exec(rest);
+        if (!returnMatch) {
+            i++;
+            continue;
+        }
+        i += returnMatch[0].length;
+        while (i < body.length && /\s/.test(body[i]))
+            i++;
+        if (body[i] !== '{')
+            continue;
+        const closeIdx = findMatchingToken(body, i, '{', '}');
+        if (closeIdx === -1)
+            break;
+        const objectBody = body.slice(i + 1, closeIdx);
+        for (const rawProp of splitTopLevel(objectBody, ',')) {
+            const prop = rawProp.trim();
+            if (!prop || prop.startsWith('...'))
+                continue;
+            const keyMatch = prop.match(/^([A-Za-z_$][\w$]*)\s*(?::|$)/);
+            if (keyMatch)
+                pushIdentifier(keyMatch[1], keys);
+        }
+        break;
+    }
+    return keys;
+}
+function extractExplicitLoad(scriptBody) {
+    let i = 0;
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let quote = null;
+    let escaped = false;
+    while (i < scriptBody.length) {
+        const ch = scriptBody[i];
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                i++;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                i++;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            quote = ch;
+            i++;
+            continue;
+        }
+        if (ch === '(')
+            depthParen++;
+        else if (ch === ')')
+            depthParen = Math.max(0, depthParen - 1);
+        else if (ch === '[')
+            depthBracket++;
+        else if (ch === ']')
+            depthBracket = Math.max(0, depthBracket - 1);
+        else if (ch === '{')
+            depthBrace++;
+        else if (ch === '}')
+            depthBrace = Math.max(0, depthBrace - 1);
+        if (depthParen !== 0 || depthBracket !== 0 || depthBrace !== 0) {
+            i++;
+            continue;
+        }
+        const rest = scriptBody.slice(i);
+        const fnMatch = /^export\s+(async\s+)?function\s+load\s*/.exec(rest);
+        if (!fnMatch) {
+            i++;
+            continue;
+        }
+        const openParen = i + fnMatch[0].length;
+        if (scriptBody[openParen] !== '(') {
+            throw new Error('[kuratchi compiler] Could not parse exported load() declaration.');
+        }
+        const closeParen = findMatchingToken(scriptBody, openParen, '(', ')');
+        if (closeParen === -1) {
+            throw new Error('[kuratchi compiler] Could not parse exported load() parameters.');
+        }
+        let openBrace = closeParen + 1;
+        while (openBrace < scriptBody.length && /\s/.test(scriptBody[openBrace]))
+            openBrace++;
+        if (scriptBody[openBrace] !== '{') {
+            throw new Error('[kuratchi compiler] export load() must use a function body.');
+        }
+        const closeBrace = findMatchingToken(scriptBody, openBrace, '{', '}');
+        if (closeBrace === -1) {
+            throw new Error('[kuratchi compiler] Could not parse exported load() body.');
+        }
+        return {
+            loadFunction: scriptBody.slice(i, closeBrace + 1).trim(),
+            remainingScript: `${scriptBody.slice(0, i)}\n${scriptBody.slice(closeBrace + 1)}`.trim(),
+            returnVars: extractReturnObjectKeys(scriptBody.slice(openBrace + 1, closeBrace)),
+        };
+    }
+    return { loadFunction: null, remainingScript: scriptBody.trim(), returnVars: [] };
+}
+function hasFrameworkEnvEscapeHatch(source) {
+    return /\bglobalThis\.__cloudflare_env__\b/.test(source) || /\b__cloudflare_env__\b/.test(source);
+}
+function buildEnvAccessError(kind, filePath, detail) {
+    const label = filePath || kind;
+    const guidance = kind === 'route'
+        ? 'Route top-level <script> is server-side. Client/reactive scripts cannot access Cloudflare env.'
+        : kind === 'layout'
+            ? 'Layout scripts cannot access Cloudflare env directly.'
+            : 'Component scripts cannot access Cloudflare env directly.';
+    return new Error(`[kuratchi compiler] ${label}\n${detail}\n${guidance}\nRead env on the server and pass the value into the template explicitly.`);
+}
 function collectPatternNames(pattern, out) {
     const p = pattern.trim();
     if (!p)
@@ -410,7 +624,8 @@ function extractTopLevelFunctionNames(scriptBody) {
  * If it includes reactive `$:` labels, it is preserved in template output.
  * Everything else (the HTML document) becomes the template.
  */
-export function parseFile(source) {
+export function parseFile(source, options = {}) {
+    const kind = options.kind || 'route';
     let script = null;
     let clientScript = null;
     let template = source;
@@ -432,6 +647,7 @@ export function parseFile(source) {
     const serverImports = [];
     const clientImports = [];
     const componentImports = {};
+    const workerEnvAliases = [];
     if (script) {
         // Support both single-line and multiline static imports.
         const importRegex = /^\s*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?/gm;
@@ -455,31 +671,62 @@ export function parseFile(source) {
             else {
                 serverImports.push(line);
             }
+            for (const alias of extractCloudflareEnvAliases(line)) {
+                if (!workerEnvAliases.includes(alias))
+                    workerEnvAliases.push(alias);
+            }
         }
     }
     if (clientScript) {
         const importRegex = /^\s*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?/gm;
         let m;
         while ((m = importRegex.exec(clientScript)) !== null) {
-            clientImports.push(m[0].trim());
+            const line = m[0].trim();
+            clientImports.push(line);
+            if (extractCloudflareEnvAliases(line).length > 0) {
+                throw buildEnvAccessError(kind, options.filePath, 'Client <script> blocks cannot import env from cloudflare:workers.');
+            }
+        }
+        if (hasFrameworkEnvEscapeHatch(clientScript)) {
+            throw buildEnvAccessError(kind, options.filePath, 'Client <script> blocks cannot access framework env internals.');
         }
     }
     // Extract top-level variable declarations from script body (after removing imports)
     const dataVars = [];
+    const loadReturnVars = [];
     let scriptBody = '';
+    let loadFunction = null;
     if (script) {
         // Remove import lines to get the script body
-        scriptBody = script.replace(/^\s*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?/gm, '').trim();
-        const topLevelVars = extractTopLevelDataVars(scriptBody);
+        const rawScriptBody = script.replace(/^\s*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?/gm, '').trim();
+        const explicitLoad = extractExplicitLoad(rawScriptBody);
+        scriptBody = explicitLoad.remainingScript;
+        loadFunction = explicitLoad.loadFunction;
+        for (const name of explicitLoad.returnVars) {
+            if (!loadReturnVars.includes(name))
+                loadReturnVars.push(name);
+        }
+        if (hasFrameworkEnvEscapeHatch(rawScriptBody)) {
+            throw buildEnvAccessError(kind, options.filePath, 'Route/component scripts cannot access framework env internals.');
+        }
+        if (workerEnvAliases.length > 0 && kind !== 'route') {
+            throw buildEnvAccessError(kind, options.filePath, `Imported env from cloudflare:workers in a ${kind} script.`);
+        }
+        const transpiledScriptBody = transpileTypeScript(scriptBody, 'route-script.ts');
+        const topLevelVars = extractTopLevelDataVars(transpiledScriptBody);
         for (const v of topLevelVars)
             dataVars.push(v);
-        const topLevelFns = extractTopLevelFunctionNames(scriptBody);
+        const topLevelFns = extractTopLevelFunctionNames(transpiledScriptBody);
         for (const fn of topLevelFns) {
             if (!dataVars.includes(fn))
                 dataVars.push(fn);
         }
+        for (const name of loadReturnVars) {
+            if (!dataVars.includes(name))
+                dataVars.push(name);
+        }
     }
-    const hasLoad = scriptBody.length > 0;
+    const hasLoad = scriptBody.length > 0 || !!loadFunction;
     // Strip HTML comments from the template before scanning for action references.
     // This prevents commented-out code (<!-- ... -->) from being parsed as live
     // action expressions, which would cause false "Invalid action expression" errors.
@@ -552,5 +799,20 @@ export function parseFile(source) {
         if (!exists)
             dataGetQueries.push({ fnName, argsExpr, asName, key });
     }
-    return { script, template, serverImports, hasLoad, actionFunctions, dataVars, componentImports, pollFunctions, dataGetQueries, clientImports };
+    return {
+        script,
+        loadFunction,
+        template,
+        serverImports,
+        hasLoad,
+        actionFunctions,
+        dataVars,
+        componentImports,
+        pollFunctions,
+        dataGetQueries,
+        clientImports,
+        loadReturnVars,
+        workerEnvAliases,
+    };
 }
+import { transpileTypeScript } from './transpile.js';

package/dist/compiler/template.js

@@ -174,8 +174,10 @@ function transformClientScriptBlock(block) {
     const openTag = match[1];
     const body = match[2];
     const closeTag = match[3];
-    if (!/\$\s*:/.test(body))
-        return block;
+    if (!/\$\s*:/.test(body)) {
+        const transpiled = transpileTypeScript(body, 'client-script.ts');
+        return `${openTag}${transpiled}${closeTag}`;
+    }
     const out = [];
     const lines = body.split('\n');
     const reactiveVars = new Set();
@@ -270,7 +272,8 @@ function transformClientScriptBlock(block) {
         break;
     }
     out.splice(insertAt, 0, 'const __k$ = window.__kuratchiReactive;');
-    return `${openTag}${out.join('\n')}${closeTag}`;
+    const transpiled = transpileTypeScript(out.join('\n'), 'client-script.ts');
+    return `${openTag}${transpiled}${closeTag}`;
 }
 function braceDelta(line) {
     let delta = 0;
@@ -822,3 +825,4 @@ export function generateRenderFunction(template) {
   ${body}
 }`;
 }
+import { transpileTypeScript } from './transpile.js';

package/dist/compiler/transpile.d.ts

@@ -0,0 +1 @@
+export declare function transpileTypeScript(source: string, contextLabel: string, compilerOptions?: Record<string, unknown>): string;

package/dist/compiler/transpile.js

@@ -0,0 +1,61 @@
+import { createRequire } from 'node:module';
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+let tsImpl;
+let bunTranspiler;
+function transpileWithBun(source) {
+    const BunRuntime = globalThis.Bun;
+    if (!BunRuntime?.Transpiler)
+        return null;
+    if (!bunTranspiler) {
+        bunTranspiler = new BunRuntime.Transpiler({ loader: 'ts' });
+    }
+    const output = bunTranspiler.transformSync(source);
+    return typeof output === 'string' ? output.trim() : String(output).trim();
+}
+function getTypeScript() {
+    if (!tsImpl) {
+        const localTsPath = fileURLToPath(new URL('../../node_modules/typescript/lib/typescript.js', import.meta.url));
+        if (fs.existsSync(localTsPath)) {
+            tsImpl = require(localTsPath);
+        }
+        else {
+            tsImpl = require(require.resolve('typescript', { paths: [process.cwd()] }));
+        }
+    }
+    return tsImpl;
+}
+function formatDiagnostic(diag) {
+    if (!diag.file || typeof diag.start !== 'number') {
+        return getTypeScript().flattenDiagnosticMessageText(diag.messageText, '\n');
+    }
+    const pos = diag.file.getLineAndCharacterOfPosition(diag.start);
+    const message = getTypeScript().flattenDiagnosticMessageText(diag.messageText, '\n');
+    return `${diag.file.fileName}:${pos.line + 1}:${pos.character + 1} ${message}`;
+}
+export function transpileTypeScript(source, contextLabel, compilerOptions = {}) {
+    if (!source.trim())
+        return source;
+    const bunOutput = transpileWithBun(source);
+    if (bunOutput !== null)
+        return bunOutput;
+    const ts = getTypeScript();
+    const result = ts.transpileModule(source, {
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ESNext,
+            importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove,
+            verbatimModuleSyntax: false,
+            ...compilerOptions,
+        },
+        reportDiagnostics: true,
+        fileName: contextLabel,
+    });
+    const diagnostics = (result.diagnostics || []).filter((diag) => diag.category === ts.DiagnosticCategory.Error);
+    if (diagnostics.length > 0) {
+        const rendered = diagnostics.map(formatDiagnostic).join('\n');
+        throw new Error(`[kuratchi compiler] TypeScript transpile failed for ${contextLabel}\n${rendered}`);
+    }
+    return result.outputText.trim();
+}

package/package.json

@@ -1,48 +1,50 @@
-{
-    "name": "@kuratchi/js",
-    "version": "0.0.4",
-    "description": "A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax",
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "bin": {
-        "kuratchi": "./dist/cli.js"
-    },
-    "files": [
-        "dist",
-        "README.md"
-    ],
-    "scripts": {
-        "build": "tsc -p tsconfig.build.json",
-        "check": "tsc -p tsconfig.build.json --noEmit",
-        "test": "bun test",
-        "test:watch": "bun test --watch",
-        "prepublishOnly": "npm run build"
-    },
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
-        },
-        "./runtime/context.js": {
-            "types": "./dist/runtime/context.d.ts",
-            "import": "./dist/runtime/context.js"
-        },
-        "./runtime/do.js": {
-            "types": "./dist/runtime/do.d.ts",
-            "import": "./dist/runtime/do.js"
-        },
-        "./package.json": "./package.json"
-    },
-    "engines": {
-        "node": "\u003e=18"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "devDependencies": {
-        "@cloudflare/workers-types": "^4.20260223.0",
-        "@types/node": "^24.4.0",
-        "typescript": "^5.8.0"
-    }
-}
+{
+    "name": "@kuratchi/js",
+    "version": "0.0.6",
+    "description": "A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "bin": {
+        "kuratchi": "./dist/cli.js"
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json",
+        "check": "tsc -p tsconfig.build.json --noEmit",
+        "test": "bun test",
+        "test:watch": "bun test --watch",
+        "prepublishOnly": "npm run build"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./runtime/context.js": {
+            "types": "./dist/runtime/context.d.ts",
+            "import": "./dist/runtime/context.js"
+        },
+        "./runtime/do.js": {
+            "types": "./dist/runtime/do.d.ts",
+            "import": "./dist/runtime/do.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "typescript": "^5.8.0"
+    },
+    "devDependencies": {
+        "@cloudflare/workers-types": "^4.20260223.0",
+        "@types/node": "^24.4.0"
+    }
+}