@kuratchi/js 0.0.20 → 0.0.22

package/dist/compiler/desktop-manifest.js

@@ -0,0 +1,175 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function buildDesktopManifest(opts) {
+    const { projectDir, workerFile, desktopConfig, ormDatabases } = opts;
+    if (!desktopConfig)
+        return null;
+    const wranglerConfig = readDesktopWranglerConfig(projectDir);
+    const projectName = path.basename(projectDir);
+    const appName = desktopConfig.appName ?? projectName;
+    const appId = desktopConfig.appId ?? `dev.kuratchi.${projectName.replace(/[^a-z0-9]+/gi, '-').toLowerCase()}`;
+    const assetsRoot = resolveAssetsRoot(projectDir);
+    const requestedRemoteBindings = desktopConfig.remoteBindings.length > 0
+        ? desktopConfig.remoteBindings
+        : ormDatabases
+            .filter((entry) => entry.type === 'd1' && entry.remote)
+            .map((entry) => ({ binding: entry.binding, type: 'd1', remote: true }));
+    const remoteBindings = requestedRemoteBindings.map((binding) => {
+        if (binding.type === 'd1') {
+            const wranglerBinding = wranglerConfig.d1Databases.find((entry) => entry.binding === binding.binding && entry.remote);
+            if (!wranglerBinding) {
+                throw new Error(`Desktop manifest could not resolve remote D1 binding "${binding.binding}" from wrangler.jsonc.`);
+            }
+            return {
+                binding: binding.binding,
+                type: 'd1',
+                remote: true,
+                databaseId: wranglerBinding.databaseId,
+                databaseName: wranglerBinding.databaseName,
+            };
+        }
+        const wranglerBinding = wranglerConfig.r2Buckets.find((entry) => entry.binding === binding.binding && entry.remote);
+        if (!wranglerBinding) {
+            throw new Error(`Desktop manifest could not resolve remote R2 binding "${binding.binding}" from wrangler.jsonc.`);
+        }
+        return {
+            binding: binding.binding,
+            type: 'r2',
+            remote: true,
+            bucketName: wranglerBinding.bucketName,
+        };
+    });
+    return {
+        formatVersion: 1,
+        generatedAt: new Date().toISOString(),
+        projectDir,
+        app: {
+            name: appName,
+            id: appId,
+            initialPath: desktopConfig.initialPath || '/',
+            window: {
+                title: desktopConfig.windowTitle ?? appName,
+                width: desktopConfig.windowWidth,
+                height: desktopConfig.windowHeight,
+            },
+        },
+        runtime: {
+            workerEntrypoint: workerFile,
+            assetsRoot,
+            compatibilityDate: wranglerConfig.compatibilityDate,
+            compatibilityFlags: wranglerConfig.compatibilityFlags,
+            cloudflareAccountId: wranglerConfig.cloudflareAccountId,
+        },
+        bindings: {
+            desktop: {
+                notifications: desktopConfig.bindings.notifications,
+                files: desktopConfig.bindings.files,
+            },
+            remote: remoteBindings,
+        },
+    };
+}
+export function writeDesktopManifest(projectDir, manifest) {
+    const outFile = path.join(projectDir, '.kuratchi', 'desktop.manifest.json');
+    const next = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (fs.existsSync(outFile)) {
+        const current = fs.readFileSync(outFile, 'utf-8');
+        if (current === next)
+            return outFile;
+    }
+    fs.writeFileSync(outFile, next, 'utf-8');
+    return outFile;
+}
+function resolveAssetsRoot(projectDir) {
+    const publicDir = path.join(projectDir, '.kuratchi', 'public');
+    if (fs.existsSync(publicDir))
+        return publicDir;
+    const srcAssets = path.join(projectDir, 'src', 'assets');
+    if (fs.existsSync(srcAssets))
+        return srcAssets;
+    return null;
+}
+function readDesktopWranglerConfig(projectDir) {
+    const configPath = ['wrangler.jsonc', 'wrangler.json']
+        .map((name) => path.join(projectDir, name))
+        .find((candidate) => fs.existsSync(candidate));
+    if (!configPath) {
+        throw new Error('Desktop runtime requires wrangler.jsonc or wrangler.json for compatibility settings and remote bindings.');
+    }
+    const rawConfig = fs.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(stripJsonComments(rawConfig));
+    if (!parsed.compatibility_date) {
+        throw new Error(`Missing compatibility_date in ${path.basename(configPath)}.`);
+    }
+    return {
+        compatibilityDate: parsed.compatibility_date,
+        compatibilityFlags: Array.isArray(parsed.compatibility_flags) ? parsed.compatibility_flags : [],
+        cloudflareAccountId: typeof parsed.account_id === 'string' && parsed.account_id.trim().length > 0
+            ? parsed.account_id.trim()
+            : null,
+        d1Databases: Array.isArray(parsed.d1_databases)
+            ? parsed.d1_databases
+                .filter((entry) => entry.binding && entry.database_id)
+                .map((entry) => ({
+                binding: entry.binding,
+                databaseId: entry.database_id,
+                databaseName: entry.database_name ?? null,
+                remote: entry.remote !== false,
+            }))
+            : [],
+        r2Buckets: Array.isArray(parsed.r2_buckets)
+            ? parsed.r2_buckets
+                .filter((entry) => entry.binding && entry.bucket_name)
+                .map((entry) => ({
+                binding: entry.binding,
+                bucketName: entry.bucket_name,
+                remote: entry.remote !== false,
+            }))
+            : [],
+    };
+}
+function stripJsonComments(content) {
+    let result = '';
+    let i = 0;
+    let inString = false;
+    let stringChar = '';
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        if (inString) {
+            result += ch;
+            if (ch === '\\' && i + 1 < content.length) {
+                result += next;
+                i += 2;
+                continue;
+            }
+            if (ch === stringChar) {
+                inString = false;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === '\'') {
+            inString = true;
+            stringChar = ch;
+            result += ch;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            while (i < content.length && content[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            i += 2;
+            while (i < content.length - 1 && !(content[i] === '*' && content[i + 1] === '/'))
+                i++;
+            i += 2;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}

package/dist/compiler/durable-object-pipeline.d.ts

@@ -1,6 +1,10 @@
-import { type DoConfigEntry, type DoHandlerEntry, type OrmDatabaseEntry } from './compiler-shared.js';
-export declare function discoverDurableObjects(srcDir: string, configDoEntries: DoConfigEntry[], ormDatabases: OrmDatabaseEntry[]): {
-    config: DoConfigEntry[];
+import { type DoHandlerEntry } from './compiler-shared.js';
+export declare function discoverDurableObjects(srcDir: string): {
+    config: {
+        binding: string;
+        className: string;
+        files?: string[];
+    }[];
     handlers: DoHandlerEntry[];
 };
 export declare function generateHandlerProxy(handler: DoHandlerEntry, opts: {

package/dist/compiler/durable-object-pipeline.js

@@ -3,27 +3,14 @@ import * as path from 'node:path';
 import * as ts from 'typescript';
 import { toSafeIdentifier, } from './compiler-shared.js';
 import { discoverFilesWithExtensions, discoverFilesWithSuffix } from './convention-discovery.js';
-export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
+export function discoverDurableObjects(srcDir) {
     const serverDir = path.join(srcDir, 'server');
     const legacyDir = path.join(srcDir, 'durable-objects');
     const serverDoFiles = discoverFilesWithSuffix(serverDir, '.do.ts');
     const legacyDoFiles = discoverFilesWithSuffix(legacyDir, '.ts');
     const discoveredFiles = Array.from(new Set([...serverDoFiles, ...legacyDoFiles]));
     if (discoveredFiles.length === 0) {
-        return { config: configDoEntries, handlers: [] };
-    }
-    const bindings = new Set(configDoEntries.map((d) => d.binding));
-    const fileToBinding = new Map();
-    for (const entry of configDoEntries) {
-        for (const rawFile of entry.files ?? []) {
-            const normalized = rawFile.trim().replace(/^\.?[\\/]/, '').replace(/\\/g, '/').toLowerCase();
-            if (!normalized)
-                continue;
-            fileToBinding.set(normalized, entry.binding);
-            const base = path.basename(normalized);
-            if (!fileToBinding.has(base))
-                fileToBinding.set(base, entry.binding);
-        }
+        return { config: [], handlers: [] };
     }
     const handlers = [];
     const handlerIdToAbsPath = new Map();
@@ -48,28 +35,17 @@ export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
             continue;
         // Binding resolution:
         // 1) explicit static binding declared in the class
-        // 2) config-mapped file name
-        // 3) if exactly one binding exists, infer it
+        // 2) derive from the handler file name
         let binding = null;
         const bindingMatch = source.match(/static\s+binding\s*=\s*['"](\w+)['"]/);
         if (bindingMatch) {
             binding = bindingMatch[1];
         }
         else {
-            const normalizedFile = file.replace(/\\/g, '/').toLowerCase();
-            const normalizedRelFromSrc = path.relative(srcDir, absPath).replace(/\\/g, '/').toLowerCase();
-            binding = className ? (configDoEntries.find((entry) => entry.className === className)?.binding ?? null) : null;
-            if (!binding) {
-                binding = fileToBinding.get(normalizedRelFromSrc) ?? fileToBinding.get(normalizedFile) ?? null;
-            }
-            if (!binding && configDoEntries.length === 1) {
-                binding = configDoEntries[0].binding;
-            }
+            binding = deriveBindingFromFile(file);
         }
         if (!binding)
             continue;
-        if (!bindings.has(binding))
-            continue;
         const classMethods = className ? extractClassMethods(absPath, source, className) : [];
         const fileName = path
             .relative(absPath.startsWith(serverDir) ? serverDir : legacyDir, absPath)
@@ -103,17 +79,14 @@ export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
         }
     }
     // Build config entries from discovered handlers (de-duped by binding).
-    // Prefer class name from the original config entry (e.g. from wrangler.jsonc).
+    // The handler source is authoritative; wrangler.jsonc is then synced from this.
     const discoveredConfigByBinding = new Map();
     for (const handler of handlers) {
-        const configEntry = configDoEntries.find((e) => e.binding === handler.binding);
         const existing = discoveredConfigByBinding.get(handler.binding);
         if (!existing) {
             discoveredConfigByBinding.set(handler.binding, {
                 binding: handler.binding,
-                // Use config class name when available (authoritative, e.g. from wrangler.jsonc).
-                className: configEntry?.className ?? handler.className ?? handler.binding,
-                stubId: configEntry?.stubId,
+                className: handler.className ?? deriveClassNameFromFile(path.basename(handler.absPath)),
                 files: [path.basename(handler.absPath)],
             });
         }
@@ -121,9 +94,32 @@ export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
             existing.files?.push(path.basename(handler.absPath));
         }
     }
-    void ormDatabases;
     return { config: [...discoveredConfigByBinding.values()], handlers };
 }
+function deriveBindingFromFile(fileName) {
+    const normalized = fileName
+        .replace(/\.(ts|tsx|js|mjs|cjs)$/i, '')
+        .replace(/\.do$/i, '')
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toUpperCase();
+    if (!normalized)
+        return 'DURABLE_OBJECT';
+    return normalized.endsWith('_DO') ? normalized : `${normalized}_DO`;
+}
+function deriveClassNameFromFile(fileName) {
+    const normalized = fileName
+        .replace(/\.(ts|tsx|js|mjs|cjs)$/i, '')
+        .replace(/\.do$/i, '');
+    const base = normalized
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+    if (!base)
+        return 'DurableObjectHandler';
+    return base.endsWith('DO') ? base : `${base}DO`;
+}
 // ---------------------------------------------------------------------------
 // TypeScript AST helpers
 // ---------------------------------------------------------------------------

package/dist/compiler/index.js

@@ -7,7 +7,7 @@ import { compileAssets } from './asset-pipeline.js';
 import { compileApiRoute } from './api-route-pipeline.js';
 import { createClientModuleCompiler } from './client-module-pipeline.js';
 import { createComponentCompiler } from './component-pipeline.js';
-import { readAssetsPrefix, readAuthConfig, readDoConfig, readOrmConfig, readSecurityConfig, readUiConfigValues, readUiTheme, } from './config-reading.js';
+import { readAssetsPrefix, readAuthConfig, readOrmConfig, readSecurityConfig, readUiConfigValues, readUiTheme, } from './config-reading.js';
 import { discoverContainerFiles, discoverConventionClassFiles, discoverWorkflowFiles, } from './convention-discovery.js';
 import { discoverDurableObjects, generateHandlerProxy } from './durable-object-pipeline.js';
 import { compileErrorPages } from './error-page-pipeline.js';
@@ -132,8 +132,7 @@ export async function compile(options) {
     // Read security config from kuratchi.config.ts
     const securityConfig = readSecurityConfig(projectDir);
     // Auto-discover Durable Objects from .do.ts files (config optional, only needed for stubId)
-    const configDoEntries = readDoConfig(projectDir);
-    const { config: doConfig, handlers: doHandlers } = discoverDurableObjects(srcDir, configDoEntries, ormDatabases);
+    const { config: doConfig, handlers: doHandlers } = discoverDurableObjects(srcDir);
     // Auto-discover convention-based worker class files (no config needed)
     const containerConfig = discoverContainerFiles(projectDir);
     const workflowConfig = discoverWorkflowFiles(projectDir);

package/dist/compiler/parser.js

@@ -1135,6 +1135,7 @@ export function parseFile(source, options = {}) {
     const actionFunctions = [];
     const pollFunctions = [];
     const dataGetQueries = [];
+    let warnedLegacyActionAttrs = false;
     for (const tag of templateTags) {
         if (tag.closing)
             continue;
@@ -1143,6 +1144,11 @@ export function parseFile(source, options = {}) {
             actionFunctions.push(actionExpr);
         }
         for (const [attrName, attrValue] of tag.attrs.entries()) {
+            if (!warnedLegacyActionAttrs && (attrName === 'data-action' || attrName === 'data-args')) {
+                warnedLegacyActionAttrs = true;
+                console.warn(`[kuratchi] ${options.filePath || kind}: authored data-action/data-args are deprecated. ` +
+                    `Use data-post={fn(...)} or action={fn} instead.`);
+            }
             if (/^on[A-Za-z]+$/i.test(attrName)) {
                 const actionCall = extractCallExpression(attrValue);
                 if (actionCall && !actionFunctions.includes(actionCall.fnName))

package/dist/compiler/routes-module-feature-blocks.js

@@ -383,7 +383,11 @@ function buildDurableObjectBlock(opts) {
             doResolverLines.push(`  });`);
         }
         else {
-            doResolverLines.push(`  // No 'stubId' config for ${doEntry.binding} - stub must be obtained manually`);
+            doResolverLines.push(`  __registerDoResolver('${doEntry.binding}', async () => {`);
+            doResolverLines.push(`    const __ns = __env['${doEntry.binding}'];`);
+            doResolverLines.push(`    if (!__ns?.idFromName || !__ns?.get) return null;`);
+            doResolverLines.push(`    return __ns.get(__ns.idFromName('global'));`);
+            doResolverLines.push(`  });`);
         }
     }
     return {

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

@@ -37,6 +37,12 @@ export function createServerModuleCompiler(options) {
         return resolveExistingModuleFile(proxyNoExt) ?? (fs.existsSync(proxyNoExt + '.ts') ? proxyNoExt + '.ts' : null);
     }
     function resolveImportTarget(importerAbs, spec) {
+        // Handle kuratchi:* virtual modules
+        if (spec.startsWith('kuratchi:')) {
+            // These are resolved at bundle time to @kuratchi/js runtime modules
+            // Return null to keep the specifier as-is for later rewriting
+            return null;
+        }
         if (spec.startsWith('$')) {
             const slashIdx = spec.indexOf('/');
             const folder = slashIdx === -1 ? spec.slice(1) : spec.slice(1, slashIdx);
@@ -70,6 +76,15 @@ export function createServerModuleCompiler(options) {
         }
         const source = fs.readFileSync(resolved, 'utf-8');
         const rewriteSpecifier = (spec) => {
+            // Rewrite kuratchi:* virtual modules to @kuratchi/js runtime paths
+            if (spec.startsWith('kuratchi:')) {
+                const moduleName = spec.slice('kuratchi:'.length);
+                const moduleMap = {
+                    'request': '@kuratchi/js/request',
+                    'navigation': '@kuratchi/js/navigation',
+                };
+                return moduleMap[moduleName] ?? spec;
+            }
             const target = resolveImportTarget(resolved, spec);
             if (!target)
                 return spec;
@@ -96,6 +111,15 @@ export function createServerModuleCompiler(options) {
         return outPath;
     }
     function resolveCompiledImportPath(origPath, importerDir, outFileDir) {
+        // Rewrite kuratchi:* virtual modules to @kuratchi/js runtime paths
+        if (origPath.startsWith('kuratchi:')) {
+            const moduleName = origPath.slice('kuratchi:'.length);
+            const moduleMap = {
+                'request': '@kuratchi/js/request',
+                'navigation': '@kuratchi/js/navigation',
+            };
+            return moduleMap[moduleName] ?? origPath;
+        }
         const isBareModule = !origPath.startsWith('.') && !origPath.startsWith('/') && !origPath.startsWith('$');
         if (isBareModule)
             return origPath;

package/dist/compiler/template.js

@@ -37,6 +37,36 @@ const JS_CONTROL_PATTERNS = [
 function isJsControlLine(line) {
     return JS_CONTROL_PATTERNS.some(p => p.test(line));
 }
+/** HTML boolean attributes that should be present or absent, never have a value */
+const BOOLEAN_ATTRIBUTES = new Set([
+    'disabled',
+    'checked',
+    'selected',
+    'readonly',
+    'required',
+    'hidden',
+    'open',
+    'autofocus',
+    'autoplay',
+    'controls',
+    'default',
+    'defer',
+    'formnovalidate',
+    'inert',
+    'ismap',
+    'itemscope',
+    'loop',
+    'multiple',
+    'muted',
+    'nomodule',
+    'novalidate',
+    'playsinline',
+    'reversed',
+    'async',
+]);
+function isBooleanAttribute(name) {
+    return BOOLEAN_ATTRIBUTES.has(name.toLowerCase());
+}
 const FRAGMENT_OPEN_MARKER = '<!--__KURATCHI_FRAGMENT_OPEN:';
 const FRAGMENT_CLOSE_MARKER = '<!--__KURATCHI_FRAGMENT_CLOSE-->';
 export function splitTemplateRenderSections(template) {
@@ -1130,9 +1160,13 @@ function compileHtmlSegment(line, actionNames, rpcNameMap, options = {}) {
                     pos = closeIdx + 1;
                     continue;
                 }
-                else if (attrName === 'disabled' || attrName === 'checked' || attrName === 'hidden' || attrName === 'readonly') {
-                    // Boolean attributes: disabled={expr} → conditionally include
-                    result += `"\${${inner} ? '' : undefined}"`;
+                else if (isBooleanAttribute(attrName)) {
+                    // Boolean attributes: disabled={expr} → conditionally include the attribute or omit entirely
+                    // Remove the trailing "attrName=" we already appended, we'll handle it with a ternary
+                    result = result.replace(new RegExp(`\\s*${attrName}=$`), '');
+                    result += `\${${inner} ? ' ${attrName}' : ''}`;
+                    pos = closeIdx + 1;
+                    continue;
                 }
                 else {
                     // Regular attribute: value={expr} → value="escaped"

package/dist/compiler/type-generator.d.ts

@@ -0,0 +1,8 @@
+export interface GenerateTypesOptions {
+    projectDir: string;
+    schemaPath?: string;
+    outputPath?: string;
+    localsInterface?: string;
+}
+export declare function generateAppTypes(options: GenerateTypesOptions): string;
+export declare function writeAppTypes(options: GenerateTypesOptions): void;

package/dist/compiler/type-generator.js

@@ -0,0 +1,124 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function sqliteTypeToTs(sqlType) {
+    const lower = sqlType.toLowerCase();
+    if (lower.includes('integer') || lower.includes('int') || lower.includes('real') || lower.includes('numeric')) {
+        return 'number';
+    }
+    if (lower.includes('text') || lower.includes('varchar') || lower.includes('char')) {
+        return 'string';
+    }
+    if (lower.includes('blob')) {
+        return 'Uint8Array';
+    }
+    if (lower.includes('json')) {
+        return 'Record<string, unknown>';
+    }
+    if (lower.includes('boolean') || lower.includes('bool')) {
+        return 'boolean';
+    }
+    return 'unknown';
+}
+function parseSchemaColumn(name, definition) {
+    const lower = definition.toLowerCase();
+    const nullable = !lower.includes('not null');
+    const hasDefault = lower.includes('default');
+    const type = sqliteTypeToTs(definition);
+    return { name, type, nullable, hasDefault };
+}
+function parseSchemaFromSource(source) {
+    const tables = [];
+    // Match tables: { tableName: { col: 'def', ... }, ... }
+    const tablesMatch = source.match(/tables\s*:\s*\{([\s\S]*?)\n\t?\}/);
+    if (!tablesMatch)
+        return tables;
+    const tablesBlock = tablesMatch[1];
+    // Match each table definition
+    const tableRegex = /(\w+)\s*:\s*\{([^}]+)\}/g;
+    let match;
+    while ((match = tableRegex.exec(tablesBlock)) !== null) {
+        const tableName = match[1];
+        const columnsBlock = match[2];
+        const columns = [];
+        // Match each column: name: 'definition'
+        const colRegex = /(\w+)\s*:\s*['"]([^'"]+)['"]/g;
+        let colMatch;
+        while ((colMatch = colRegex.exec(columnsBlock)) !== null) {
+            columns.push(parseSchemaColumn(colMatch[1], colMatch[2]));
+        }
+        tables.push({ name: tableName, columns });
+    }
+    return tables;
+}
+function generateTableTypes(tables) {
+    const lines = [];
+    for (const table of tables) {
+        const pascalName = table.name
+            .split('_')
+            .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+            .join('');
+        lines.push(`    /** Row type for ${table.name} table */`);
+        lines.push(`    interface ${pascalName}Row {`);
+        for (const col of table.columns) {
+            const optional = col.nullable || col.hasDefault ? '?' : '';
+            lines.push(`      ${col.name}${optional}: ${col.type};`);
+        }
+        lines.push(`    }`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function generateAppTypes(options) {
+    const { projectDir, schemaPath = 'src/server/schema.ts', outputPath = 'src/app.d.ts', localsInterface, } = options;
+    const schemaFullPath = path.join(projectDir, schemaPath);
+    let tables = [];
+    if (fs.existsSync(schemaFullPath)) {
+        const schemaSource = fs.readFileSync(schemaFullPath, 'utf-8');
+        tables = parseSchemaFromSource(schemaSource);
+    }
+    const tableTypes = tables.length > 0 ? generateTableTypes(tables) : '';
+    // Check if user has existing Locals definition to preserve
+    const outputFullPath = path.join(projectDir, outputPath);
+    let existingLocals = null;
+    if (fs.existsSync(outputFullPath)) {
+        const existing = fs.readFileSync(outputFullPath, 'utf-8');
+        // Extract user-defined Locals interface (between USER LOCALS START/END markers)
+        const localsMatch = existing.match(/\/\/ USER LOCALS START\n([\s\S]*?)\/\/ USER LOCALS END/);
+        if (localsMatch) {
+            existingLocals = localsMatch[1];
+        }
+    }
+    const localsBlock = existingLocals || localsInterface || `    interface Locals {
+      userId: number;
+      userEmail: string;
+    }`;
+    const output = `/**
+ * Type declarations for kuratchi app.
+ * 
+ * DB types are auto-generated from schema.ts - regenerate with: kuratchi types
+ * Edit the Locals interface below to match your runtime.hook.ts
+ */
+declare global {
+  namespace App {
+    /** Request-scoped locals set by runtime hooks */
+// USER LOCALS START
+${localsBlock}
+// USER LOCALS END
+
+${tableTypes ? `    // Database table row types (auto-generated from schema.ts)\n${tableTypes}` : ''}  }
+}
+
+export {};
+`;
+    return output;
+}
+export function writeAppTypes(options) {
+    const output = generateAppTypes(options);
+    const outputPath = path.join(options.projectDir, options.outputPath || 'src/app.d.ts');
+    const dir = path.dirname(outputPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(outputPath, output, 'utf-8');
+    console.log(`[kuratchi] Generated types → ${path.relative(options.projectDir, outputPath)}`);
+}

package/dist/compiler/wrangler-sync.js

@@ -1,5 +1,26 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+function nextMigrationTag(existing) {
+    const used = new Set(existing
+        .map((entry) => (entry && typeof entry.tag === 'string' ? entry.tag : null))
+        .filter(Boolean));
+    let maxNumeric = 0;
+    for (const tag of used) {
+        const match = /^v(\d+)$/i.exec(String(tag));
+        if (match) {
+            maxNumeric = Math.max(maxNumeric, Number(match[1]));
+        }
+    }
+    let candidate = `v${maxNumeric > 0 ? maxNumeric + 1 : 1}`;
+    if (!used.has(candidate))
+        return candidate;
+    let index = maxNumeric + 1;
+    while (used.has(candidate)) {
+        index += 1;
+        candidate = `v${index}`;
+    }
+    return candidate;
+}
 function stripJsonComments(content) {
     let result = '';
     let i = 0;
@@ -169,8 +190,34 @@ export function syncWranglerConfig(opts) {
                 changed = true;
                 console.log(`[kuratchi] Added durable_object "${durableObject.binding}" to wrangler config`);
             }
+            else if (existing.class_name !== durableObject.className) {
+                existing.class_name = durableObject.className;
+                changed = true;
+                console.log(`[kuratchi] Updated durable_object "${durableObject.binding}" class_name to "${durableObject.className}"`);
+            }
         }
         wranglerConfig.durable_objects.bindings = existingBindings;
+        const existingMigrations = Array.isArray(wranglerConfig.migrations) ? wranglerConfig.migrations : [];
+        const knownClasses = new Set();
+        for (const migration of existingMigrations) {
+            const newClasses = Array.isArray(migration?.new_sqlite_classes) ? migration.new_sqlite_classes : [];
+            for (const className of newClasses) {
+                if (typeof className === 'string' && className)
+                    knownClasses.add(className);
+            }
+        }
+        const missingClasses = opts.config.durableObjects
+            .map((entry) => entry.className)
+            .filter((className) => !knownClasses.has(className));
+        if (missingClasses.length > 0) {
+            existingMigrations.push({
+                tag: nextMigrationTag(existingMigrations),
+                new_sqlite_classes: missingClasses,
+            });
+            wranglerConfig.migrations = existingMigrations;
+            changed = true;
+            console.log(`[kuratchi] Added durable object migration for ${missingClasses.join(', ')}`);
+        }
     }
     if (opts.config.assetsDirectory !== undefined) {
         const existing = wranglerConfig.assets;