@kuratchi/js 0.0.18 → 0.0.20

package/dist/compiler/index.js

@@ -29,6 +29,7 @@ export { compileTemplate, generateRenderFunction } from './template.js';
 const FRAMEWORK_PACKAGE_NAME = getFrameworkPackageName();
 const RUNTIME_CONTEXT_IMPORT = `${FRAMEWORK_PACKAGE_NAME}/runtime/context.js`;
 const RUNTIME_DO_IMPORT = `${FRAMEWORK_PACKAGE_NAME}/runtime/do.js`;
+const RUNTIME_SCHEMA_IMPORT = `${FRAMEWORK_PACKAGE_NAME}/runtime/schema.js`;
 const RUNTIME_WORKER_IMPORT = `${FRAMEWORK_PACKAGE_NAME}/runtime/generated-worker.js`;
 function getFrameworkPackageName() {
     try {
@@ -151,6 +152,7 @@ export async function compile(options) {
             const proxyCode = generateHandlerProxy(handler, {
                 projectDir,
                 runtimeDoImport: RUNTIME_DO_IMPORT,
+                runtimeSchemaImport: RUNTIME_SCHEMA_IMPORT,
             });
             const proxyFile = path.join(doProxyDir, handler.fileName + '.ts');
             const proxyFileDir = path.dirname(proxyFile);
@@ -168,7 +170,7 @@ export async function compile(options) {
             if (handler.fileName.endsWith('.do')) {
                 const aliasFileName = handler.fileName.slice(0, -3);
                 const aliasProxyFile = path.join(doProxyDir, aliasFileName + '.ts');
-                const aliasCode = `// Auto-generated alias for .do handler\nexport * from './${handler.fileName}.ts';\n`;
+                const aliasCode = `// Auto-generated alias for .do handler\nexport * from './${path.basename(handler.fileName)}.ts';\n`;
                 const aliasProxyDir = path.dirname(aliasProxyFile);
                 if (!fs.existsSync(aliasProxyDir))
                     fs.mkdirSync(aliasProxyDir, { recursive: true });
@@ -220,7 +222,7 @@ export async function compile(options) {
             }));
             continue;
         }
-        // -- Page route (page.html) --
+        // -- Page route (index.html) --
         const source = fileContents.get(fullPath) ?? fs.readFileSync(fullPath, 'utf-8');
         const parsed = parseFile(source, { kind: 'route', filePath: fullPath });
         const routeState = assembleRouteState({
@@ -285,6 +287,7 @@ export async function compile(options) {
         assetsPrefix,
         runtimeContextImport: RUNTIME_CONTEXT_IMPORT,
         runtimeDoImport: RUNTIME_DO_IMPORT,
+        runtimeSchemaImport: RUNTIME_SCHEMA_IMPORT,
         runtimeWorkerImport: RUNTIME_WORKER_IMPORT,
     });
     // Write to .kuratchi/routes.ts
@@ -308,12 +311,26 @@ export async function compile(options) {
     }));
     writeIfChanged(path.join(outDir, 'worker.js'), buildCompatEntrypointSource('./worker.ts'));
     // Auto-sync wrangler.jsonc with workflow/container/DO config from kuratchi.config.ts
+    // Also sync the static assets directory when src/assets/ exists, so Cloudflare Workers
+    // serves them natively without any manual wrangler.jsonc edits from the user.
+    const srcAssetsDir = path.join(srcDir, 'assets');
+    let syncedAssetsDirectory;
+    if (fs.existsSync(srcAssetsDir)) {
+        // Mirror src/assets/ into .kuratchi/public/<prefix>/ so Cloudflare serves them at the
+        // correct URL (e.g. /assets/app.css) — the directory passed to wrangler is the parent.
+        const prefixSegment = assetsPrefix.replace(/^\/|\/$/g, ''); // '/assets/' -> 'assets'
+        const publicDir = path.join(projectDir, '.kuratchi', 'public');
+        const publicAssetsDir = prefixSegment ? path.join(publicDir, prefixSegment) : publicDir;
+        copyDirIfChanged(srcAssetsDir, publicAssetsDir);
+        syncedAssetsDirectory = path.relative(projectDir, publicDir).replace(/\\/g, '/');
+    }
     syncWranglerConfigPipeline({
         projectDir,
         config: {
             workflows: workflowConfig,
             containers: containerConfig,
             durableObjects: doConfig,
+            assetsDirectory: syncedAssetsDirectory,
         },
         writeFile: writeIfChanged,
     });
@@ -332,3 +349,25 @@ function writeIfChanged(filePath, content) {
     }
     fs.writeFileSync(filePath, content, 'utf-8');
 }
+/**
+ * Recursively copy files from src to dest, skipping files whose content is already identical.
+ * Used to mirror src/assets/ into .kuratchi/public/ for Cloudflare Workers Static Assets.
+ */
+function copyDirIfChanged(src, dest) {
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirIfChanged(srcPath, destPath);
+        }
+        else {
+            const srcBuf = fs.readFileSync(srcPath);
+            const destBuf = fs.existsSync(destPath) ? fs.readFileSync(destPath) : null;
+            if (!destBuf || !srcBuf.equals(destBuf)) {
+                fs.writeFileSync(destPath, srcBuf);
+            }
+        }
+    }
+}

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

@@ -42,10 +42,38 @@ export function compilePageRoute(opts) {
         query.rpcId = rpcNameMap.get(query.fnName);
     }
     const clientRouteRegistry = opts.clientModuleCompiler.createRouteRegistry(opts.routeIndex, opts.routeState.routeBrowserImportEntries);
+    const awaitQueryBindings = new Map(opts.routeState.mergedParsed.dataGetQueries
+        .filter((query) => !!query.awaitExpr)
+        .map((query) => [query.awaitExpr, { asName: query.asName, rpcId: query.rpcId || rpcNameMap.get(query.fnName) || query.fnName }]));
     const renderSections = splitTemplateRenderSections(opts.routeState.effectiveTemplate);
-    const renderBody = compileTemplate(renderSections.bodyTemplate, routeComponentNames, actionNames, rpcNameMap, { emitCall: '__emit', enableFragmentManifest: true, clientRouteRegistry });
-    const renderHeadBody = compileTemplate(renderSections.headTemplate, routeComponentNames, actionNames, rpcNameMap, { clientRouteRegistry });
+    const renderBody = compileTemplate(renderSections.bodyTemplate, routeComponentNames, actionNames, rpcNameMap, { emitCall: '__emit', enableFragmentManifest: true, clientRouteRegistry, awaitQueryBindings });
+    const renderHeadBody = compileTemplate(renderSections.headTemplate, routeComponentNames, actionNames, rpcNameMap, { clientRouteRegistry, awaitQueryBindings });
     const clientEntryAsset = clientRouteRegistry.buildEntryAsset();
+    const clientServerProxyBindings = clientRouteRegistry.getServerProxyBindings();
+    const clientServerProxyModules = new Map();
+    const extraRpcBindings = [];
+    const seenClientServerRpcIds = new Set();
+    for (const binding of clientServerProxyBindings) {
+        const moduleKey = `${binding.importerDir}::${binding.moduleSpecifier}`;
+        let moduleId = clientServerProxyModules.get(moduleKey);
+        if (!moduleId) {
+            moduleId = opts.allocateModuleId();
+            clientServerProxyModules.set(moduleKey, moduleId);
+            const importPath = opts.resolveCompiledImportPath(binding.moduleSpecifier, binding.importerDir, outFileDir);
+            opts.pushImport(`import * as ${moduleId} from '${importPath}';`);
+        }
+        if (!seenClientServerRpcIds.has(binding.rpcId)) {
+            seenClientServerRpcIds.add(binding.rpcId);
+            extraRpcBindings.push({
+                name: `${binding.moduleSpecifier}:${binding.importedName}`,
+                rpcId: binding.rpcId,
+                expression: binding.importedName === 'default' ? `${moduleId}.default` : `${moduleId}.${binding.importedName}`,
+                schemaExpression: binding.importedName === 'default'
+                    ? 'undefined'
+                    : `${moduleId}.schemas?.[${JSON.stringify(binding.importedName)}]`,
+            });
+        }
+    }
     const clientModuleHref = clientEntryAsset ? `${opts.assetsPrefix}${clientEntryAsset.assetName}` : null;
     const routePlan = analyzeRouteBuild({
         pattern: opts.pattern,
@@ -55,6 +83,7 @@ export function compilePageRoute(opts) {
         parsed: opts.routeState.mergedParsed,
         fnToModule,
         rpcNameMap,
+        extraRpcBindings,
         componentStyles: opts.componentCompiler.collectStyles(routeComponentNames),
         clientModuleHref,
     });

package/dist/compiler/parser.d.ts

@@ -33,6 +33,7 @@ export interface ParsedFile {
         asName: string;
         key?: string;
         rpcId?: string;
+        awaitExpr?: string;
     }>;
     /** Imports found in a top-level client script block */
     clientImports: string[];

package/dist/compiler/parser.js

@@ -451,10 +451,37 @@ function extractCallExpression(value) {
     const match = expr.match(/^([A-Za-z_$][\w$]*)\(([\s\S]*)\)$/);
     if (!match)
         return null;
-    return {
-        fnName: match[1],
-        argsExpr: (match[2] || '').trim(),
-    };
+    return { fnName: match[1], argsExpr: (match[2] || '').trim() };
+}
+function extractAwaitCallExpression(expr) {
+    const match = expr.trim().match(/^await\s+([A-Za-z_$][\w$]*)\(([\s\S]*)\)$/);
+    if (!match)
+        return null;
+    return { fnName: match[1], argsExpr: (match[2] || '').trim() };
+}
+function collectAwaitTemplateQueries(template) {
+    const source = template.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '');
+    const queries = [];
+    const seen = new Map();
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== '{')
+            continue;
+        const closeIdx = findMatchingToken(source, i, '{', '}');
+        if (closeIdx === -1)
+            continue;
+        const inner = source.slice(i + 1, closeIdx).trim();
+        const call = extractAwaitCallExpression(inner);
+        if (call) {
+            const awaitExpr = `${call.fnName}(${call.argsExpr})`;
+            if (!seen.has(awaitExpr)) {
+                const asName = `__await_query_${queries.length}`;
+                seen.set(awaitExpr, asName);
+                queries.push({ fnName: call.fnName, argsExpr: call.argsExpr, asName, awaitExpr });
+            }
+        }
+        i = closeIdx;
+    }
+    return queries;
 }
 function extractTopLevelImportNames(source) {
     const sourceFile = ts.createSourceFile('kuratchi-inline-client.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
@@ -1144,6 +1171,22 @@ export function parseFile(source, options = {}) {
         if (!exists)
             dataGetQueries.push({ fnName: getCall.fnName, argsExpr: getCall.argsExpr, asName, key });
     }
+    for (const awaitQuery of collectAwaitTemplateQueries(templateWithoutComments)) {
+        if (!pollFunctions.includes(awaitQuery.fnName))
+            pollFunctions.push(awaitQuery.fnName);
+        if (!dataVars.includes(awaitQuery.asName))
+            dataVars.push(awaitQuery.asName);
+        const exists = dataGetQueries.some((query) => query.awaitExpr === awaitQuery.awaitExpr);
+        if (!exists) {
+            dataGetQueries.push({
+                fnName: awaitQuery.fnName,
+                argsExpr: awaitQuery.argsExpr,
+                asName: awaitQuery.asName,
+                key: awaitQuery.asName,
+                awaitExpr: awaitQuery.awaitExpr,
+            });
+        }
+    }
     for (const clientBinding of routeClientImportBindings) {
         const idx = actionFunctions.indexOf(clientBinding);
         if (idx !== -1)

package/dist/compiler/root-layout-pipeline.js

@@ -206,6 +206,20 @@ const BRIDGE_SOURCE = `(function(){
     if(!keys.length){ location.reload(); return Promise.resolve(); }
     return Promise.all(keys.map(function(k){ return replaceBlocksWithKey('key:' + k); })).then(function(){});
   }
+  function refreshRemoteReads(){
+    var seen = Object.create(null);
+    var tasks = [];
+    by('[data-remote-read][data-get]').forEach(function(el){
+      var fn = el.getAttribute('data-get');
+      if(!fn) return;
+      var args = String(el.getAttribute('data-get-args') || '[]');
+      var key = String(fn) + '|' + args;
+      if(seen[key]) return;
+      seen[key] = true;
+      tasks.push(replaceBlocksByDescriptor(fn, args));
+    });
+    return Promise.all(tasks).then(function(){});
+  }
   function act(e){
     var clientSel = '[data-client-event="' + e.type + '"]';
     var clientEl = e.target && e.target.closest ? e.target.closest(clientSel) : null;
@@ -301,6 +315,9 @@ const BRIDGE_SOURCE = `(function(){
   } else {
     autoLoadQueries();
   }
+  window.addEventListener('kuratchi:invalidate-reads', function(){
+    refreshRemoteReads().catch(function(err){ console.error('[kuratchi] remote read refresh error:', err); });
+  });
   document.addEventListener('click', function(e){
     var b = e.target && e.target.closest ? e.target.closest('[command="fill-dialog"]') : null;
     if(!b) return;
@@ -354,8 +371,16 @@ const BRIDGE_SOURCE = `(function(){
       (function tick(){
         setTimeout(function(){
           fetch(location.pathname + location.search, { headers: { 'x-kuratchi-fragment': pollId } })
-            .then(function(r){ return r.text(); })
+            .then(function(r){
+              if(r.status === 404){
+                el.remove();
+                return null;
+              }
+              if(!r.ok) throw new Error('Poll fragment request failed: ' + r.status);
+              return r.text();
+            })
             .then(function(html){
+              if(html === null) return;
               if(prevHtml !== html){
                 el.innerHTML = html;
                 prevHtml = html;

package/dist/compiler/route-discovery.js

@@ -26,9 +26,9 @@ export function discoverRoutes(routesDir) {
         for (const entry of entries) {
             if (entry.isDirectory()) {
                 const childPrefix = prefix ? `${prefix}/${entry.name}` : entry.name;
-                const pageFile = path.join(dir, entry.name, 'page.html');
+                const pageFile = path.join(dir, entry.name, 'index.html');
                 if (fs.existsSync(pageFile)) {
-                    const routeFile = `${childPrefix}/page.html`;
+                    const routeFile = `${childPrefix}/index.html`;
                     if (!registered.has(routeFile)) {
                         registered.add(routeFile);
                         results.push({ file: routeFile, name: childPrefix, layouts: getLayoutsForPrefix(childPrefix), type: 'page' });
@@ -56,15 +56,15 @@ export function discoverRoutes(routesDir) {
                 }
                 continue;
             }
-            if (entry.name === 'page.html') {
-                const routeFile = prefix ? `${prefix}/page.html` : 'page.html';
+            if (entry.name === 'index.html') {
+                const routeFile = prefix ? `${prefix}/index.html` : 'index.html';
                 if (!registered.has(routeFile)) {
                     registered.add(routeFile);
                     results.push({ file: routeFile, name: prefix || 'index', layouts: getLayoutsForPrefix(prefix), type: 'page' });
                 }
                 continue;
             }
-            if (entry.name.endsWith('.html') && entry.name !== 'page.html') {
+            if (entry.name.endsWith('.html') && entry.name !== 'index.html') {
                 const name = prefix
                     ? `${prefix}/${entry.name.replace('.html', '')}`
                     : entry.name.replace('.html', '');

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

@@ -15,6 +15,7 @@ export interface RouteRpcBinding {
     name: string;
     rpcId: string;
     expression: string;
+    schemaExpression: string;
 }
 export interface RouteLoadPlan {
     mode: 'none' | 'explicit' | 'generated';
@@ -49,6 +50,7 @@ interface AnalyzeRouteOptions {
     parsed: RoutePipelineParsedFile;
     fnToModule: Record<string, string>;
     rpcNameMap?: Map<string, string>;
+    extraRpcBindings?: RouteRpcBinding[];
     componentStyles: string[];
     clientModuleHref?: string | null;
 }

package/dist/compiler/route-pipeline.js

@@ -20,7 +20,7 @@ function buildLoadQueryStateCode(opts) {
         lines.push(`let ${asName} = { state: 'loading', loading: true, error: null, data: null, empty: false, success: false };`);
         lines.push(`const __qOverride_${asName} = __getLocals().__queryOverride;`);
         lines.push(`const __qArgs_${asName} = ${defaultArgs};`);
-        lines.push(`const __qShouldRun_${asName} = !!(__qOverride_${asName} && __qOverride_${asName}.fn === '${rpcId}' && Array.isArray(__qOverride_${asName}.args) && JSON.stringify(__qOverride_${asName}.args) === JSON.stringify(__qArgs_${asName}));`);
+        lines.push(`const __qShouldRun_${asName} = !__qOverride_${asName} || (__qOverride_${asName}.fn === '${rpcId}' && Array.isArray(__qOverride_${asName}.args) && JSON.stringify(__qOverride_${asName}.args) === JSON.stringify(__qArgs_${asName}));`);
         lines.push(`if (__qShouldRun_${asName}) {`);
         lines.push(`  try {`);
         lines.push(`    const __qData_${asName} = await ${qualifiedFn}(...__qArgs_${asName});`);
@@ -83,7 +83,7 @@ function assertRoutePlanInvariants(opts) {
     }
 }
 export function analyzeRouteBuild(opts) {
-    const { pattern, renderBody, renderHeadBody, isDev, parsed, fnToModule, rpcNameMap, componentStyles, clientModuleHref } = opts;
+    const { pattern, renderBody, renderHeadBody, isDev, parsed, fnToModule, rpcNameMap, extraRpcBindings, componentStyles, clientModuleHref } = opts;
     const hasFns = Object.keys(fnToModule).length > 0;
     const queryDefs = parsed.dataGetQueries ?? [];
     const queryVars = queryDefs.map((query) => query.asName);
@@ -94,10 +94,18 @@ export function analyzeRouteBuild(opts) {
     const routeImportDecls = routeImportDeclLines.join('\n');
     const importedBindingNames = new Set(Object.keys(fnToModule));
     const renderScopeActionNames = new Set(parsed.actionFunctions);
+    // Filter out params/breadcrumbs from render prelude since they come from data destructuring
+    const reservedRenderVars = new Set(['params', 'breadcrumbs']);
     const renderImportPrelude = routeImportDeclLines
         .filter((statement) => {
         const declaredName = extractDeclaredConstName(statement);
-        return declaredName ? !renderScopeActionNames.has(declaredName) : true;
+        if (!declaredName)
+            return true;
+        if (renderScopeActionNames.has(declaredName))
+            return false;
+        if (reservedRenderVars.has(declaredName))
+            return false;
+        return true;
     })
         .join('\n');
     let scriptBody = '';
@@ -191,9 +199,21 @@ export function analyzeRouteBuild(opts) {
         ? parsed.pollFunctions.map((name) => {
             const moduleId = fnToModule[name];
             const rpcId = rpcNameMap?.get(name) || name;
-            return { name, rpcId, expression: moduleId ? `${moduleId}.${name}` : name };
+            const schemaExpression = moduleId
+                ? `${moduleId}.schemas?.[${JSON.stringify(name)}]`
+                : `(typeof schemas !== 'undefined' ? schemas?.[${JSON.stringify(name)}] : undefined)`;
+            return { name, rpcId, expression: moduleId ? `${moduleId}.${name}` : name, schemaExpression };
         })
         : [];
+    if (extraRpcBindings?.length) {
+        const seenRpcIds = new Set(rpc.map((binding) => binding.rpcId));
+        for (const binding of extraRpcBindings) {
+            if (seenRpcIds.has(binding.rpcId))
+                continue;
+            seenRpcIds.add(binding.rpcId);
+            rpc.push(binding);
+        }
+    }
     assertRoutePlanInvariants({
         pattern,
         loadReturnVars: loadPlan.returnVars,
@@ -242,6 +262,10 @@ export function emitRouteObject(plan) {
             .map((rpc) => `'${rpc.rpcId}': ${rpc.expression}`)
             .join(', ');
         parts.push(`    rpc: { ${rpcEntries} }`);
+        const rpcSchemaEntries = plan.rpc
+            .map((rpc) => `'${rpc.rpcId}': ${rpc.schemaExpression}`)
+            .join(', ');
+        parts.push(`    rpcSchemas: { ${rpcSchemaEntries} }`);
         // Also emit allowedQueries for query override validation
         const allowedQueryNames = plan.rpc.map((rpc) => `'${rpc.rpcId}'`).join(', ');
         parts.push(`    allowedQueries: [${allowedQueryNames}]`);

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

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import { toSafeIdentifier } from './compiler-shared.js';
 export function buildRoutesModuleFeatureBlocks(opts) {
     const workerImport = `import { env as __env } from 'cloudflare:workers';`;
-    const contextImport = `import { __setRequestContext, __esc, __rawHtml, __sanitizeHtml, __setLocal, __getLocals, __getCsrfToken, __signFragment, buildDefaultBreadcrumbs as __buildDefaultBreadcrumbs } from '${opts.runtimeContextImport}';`;
+    const contextImport = `import { __setRequestContext, __pushRequestContext, __esc, __rawHtml, __sanitizeHtml, __setLocal, __getLocals, __getCsrfToken, __signFragment, buildDefaultBreadcrumbs as __buildDefaultBreadcrumbs } from '${opts.runtimeContextImport}';`;
     const runtimeImport = opts.hasRuntime && opts.runtimeImportPath
         ? `import __kuratchiRuntime from '${opts.runtimeImportPath}';`
         : '';
@@ -182,7 +182,10 @@ function buildDurableObjectBlock(opts) {
     doImportLines.push(`import { DurableObject as __DO } from 'cloudflare:workers';`);
     doImportLines.push(`import { initDO as __initDO } from '@kuratchi/orm';`);
     doImportLines.push(`import { __registerDoResolver, __registerDoClassBinding, __setDoContext } from '${opts.runtimeDoImport}';`);
+    doImportLines.push(`import { validateSchemaInput as __validateSchemaInput } from '${opts.runtimeSchemaImport}';`);
     doImportLines.push(`const __DO_FD_TAG = '__kuratchi_form_data__';`);
+    doImportLines.push(`const __DO_RPC_CTX_TAG = '__kuratchi_rpc_context__';`);
+    doImportLines.push(`const __DO_RPC_RESULT_TAG = '__kuratchi_rpc_result__';`);
     doImportLines.push(`function __isDoPlainObject(__v) {`);
     doImportLines.push(`  if (!__v || typeof __v !== 'object') return false;`);
     doImportLines.push(`  const __proto = Object.getPrototypeOf(__v);`);
@@ -203,6 +206,38 @@ function buildDurableObjectBlock(opts) {
     doImportLines.push(`  }`);
     doImportLines.push(`  return __v;`);
     doImportLines.push(`}`);
+    doImportLines.push(`function __extractDoRpcContext(__args) {`);
+    doImportLines.push(`  if (!Array.isArray(__args) || __args.length === 0) return { args: __args, context: null };`);
+    doImportLines.push(`  const __tail = __args[__args.length - 1];`);
+    doImportLines.push(`  if (!__isDoPlainObject(__tail) || !(__DO_RPC_CTX_TAG in __tail)) return { args: __args, context: null };`);
+    doImportLines.push(`  return { args: __args.slice(0, -1), context: __tail[__DO_RPC_CTX_TAG] || null };`);
+    doImportLines.push(`}`);
+    doImportLines.push(`function __wrapDoRpcResult(__value) {`);
+    doImportLines.push(`  const __locals = __getLocals();`);
+    doImportLines.push(`  return { [__DO_RPC_RESULT_TAG]: { value: __value, effects: { redirectTo: __locals.__redirectTo ?? null, redirectStatus: __locals.__redirectStatus ?? null, setCookieHeaders: Array.isArray(__locals.__setCookieHeaders) ? __locals.__setCookieHeaders : [] } } };`);
+    doImportLines.push(`}`);
+    doImportLines.push(`function __invokeDoRpc(__self, __methodName, __fn, __args) {`);
+    doImportLines.push(`  __setDoContext(__self);`);
+    doImportLines.push(`  const { args: __callArgs, context: __rpcContext } = __extractDoRpcContext(__args);`);
+    doImportLines.push(`  const __decoded = (__callArgs ?? []).map(__decodeDoArg);`);
+    doImportLines.push(`  const __schema = __self?.constructor?.schemas?.[__methodName];`);
+    doImportLines.push(`  const __validated = __validateSchemaInput(__schema, __decoded);`);
+    doImportLines.push(`  if (!__rpcContext) return __fn.apply(__self, __validated);`);
+    doImportLines.push(`  const __restore = __pushRequestContext(__rpcContext, __self.ctx, __self.env);`);
+    doImportLines.push(`  const __finish = (__value) => __wrapDoRpcResult(__value);`);
+    doImportLines.push(`  const __fail = (__err) => { if (__err && __err.isRedirectError) return __wrapDoRpcResult(undefined); throw __err; };`);
+    doImportLines.push(`  try {`);
+    doImportLines.push(`    const __result = __fn.apply(__self, __validated);`);
+    doImportLines.push(`    if (__result && typeof __result.then === 'function') {`);
+    doImportLines.push(`      return __result.then(__finish, __fail).finally(__restore);`);
+    doImportLines.push(`    }`);
+    doImportLines.push(`    const __wrapped = __finish(__result);`);
+    doImportLines.push(`    __restore();`);
+    doImportLines.push(`    return __wrapped;`);
+    doImportLines.push(`  } catch (__err) {`);
+    doImportLines.push(`    try { return __fail(__err); } finally { __restore(); }`);
+    doImportLines.push(`  }`);
+    doImportLines.push(`}`);
     doImportLines.push(`import { getCurrentUser as __getCU, getOrgStubByName as __getOSBN } from '@kuratchi/auth';`);
     const handlersByBinding = new Map();
     for (const handler of opts.doHandlers) {
@@ -213,6 +248,10 @@ function buildDurableObjectBlock(opts) {
     for (const doEntry of opts.doConfig) {
         const handlers = handlersByBinding.get(doEntry.binding) ?? [];
         const ormDb = opts.ormDatabases.find((db) => db.binding === doEntry.binding);
+        const fnHandlers = handlers.filter((h) => h.mode === 'function');
+        const initHandlers = fnHandlers.filter((h) => h.exportedFunctions.includes('onInit'));
+        const alarmHandlers = fnHandlers.filter((h) => h.exportedFunctions.includes('onAlarm'));
+        const messageHandlers = fnHandlers.filter((h) => h.exportedFunctions.includes('onMessage'));
         if (ormDb) {
             const schemaPath = ormDb.schemaImportPath.replace(/^\.\//, '../');
             doImportLines.push(`import { ${ormDb.schemaExportName} as __doSchema_${doEntry.binding} } from '${schemaPath}';`);
@@ -225,22 +264,114 @@ function buildDurableObjectBlock(opts) {
             if (!handlerImportPath.startsWith('.'))
                 handlerImportPath = './' + handlerImportPath;
             const handlerVar = `__handler_${toSafeIdentifier(handler.fileName)}`;
-            doImportLines.push(`import ${handlerVar} from '${handlerImportPath}';`);
+            if (handler.mode === 'class') {
+                if (handler.exportKind === 'named' && handler.className) {
+                    doImportLines.push(`import { ${handler.className} as ${handlerVar} } from '${handlerImportPath}';`);
+                }
+                else {
+                    doImportLines.push(`import ${handlerVar} from '${handlerImportPath}';`);
+                }
+                for (const [index, contributor] of (handler.classContributors ?? []).entries()) {
+                    let contributorImportPath = path
+                        .relative(path.join(opts.projectDir, '.kuratchi'), contributor.absPath)
+                        .replace(/\\/g, '/')
+                        .replace(/\.ts$/, '.js');
+                    if (!contributorImportPath.startsWith('.'))
+                        contributorImportPath = './' + contributorImportPath;
+                    const contributorVar = `__handler_${toSafeIdentifier(`${handler.fileName}__${contributor.className}_${index}`)}`;
+                    if (contributor.exportKind === 'named') {
+                        doImportLines.push(`import { ${contributor.className} as ${contributorVar} } from '${contributorImportPath}';`);
+                    }
+                    else {
+                        doImportLines.push(`import ${contributorVar} from '${contributorImportPath}';`);
+                    }
+                }
+            }
+            else {
+                doImportLines.push(`import * as ${handlerVar} from '${handlerImportPath}';`);
+            }
         }
+        // Generate the DO class
+        doClassLines.push(`export class ${doEntry.className} extends __DO {`);
+        doClassLines.push(`  constructor(ctx, env) {`);
+        doClassLines.push(`    super(ctx, env);`);
         if (ormDb) {
-            const handler = handlers[0];
-            const handlerVar = handler ? `__handler_${toSafeIdentifier(handler.fileName)}` : '__DO';
-            const baseClass = handler ? handlerVar : '__DO';
-            doClassLines.push(...buildOrmDurableObjectClassLines(doEntry.className, doEntry.binding, baseClass));
+            doClassLines.push(`    this.db = __initDO(ctx.storage.sql, __doSchema_${doEntry.binding});`);
+        }
+        for (const handler of handlers.filter((h) => h.mode === 'class')) {
+            const handlerVar = `__handler_${toSafeIdentifier(handler.fileName)}`;
+            const handlerInstanceVar = `__instance_${toSafeIdentifier(handler.fileName)}`;
+            doClassLines.push(`    const ${handlerInstanceVar} = new ${handlerVar}(ctx, env);`);
+            doClassLines.push(`    Object.assign(this, ${handlerInstanceVar});`);
         }
-        else if (handlers.length > 0) {
-            const handler = handlers[0];
+        for (const handler of initHandlers) {
             const handlerVar = `__handler_${toSafeIdentifier(handler.fileName)}`;
-            doClassLines.push(`export { ${handlerVar} as ${doEntry.className} };`);
+            doClassLines.push(`    __setDoContext(this);`);
+            doClassLines.push(`    Promise.resolve(${handlerVar}.onInit.call(this)).catch((err) => console.error('[KuratchiJS] DO onInit failed:', err?.message || err));`);
         }
+        doClassLines.push(`  }`);
+        if (ormDb) {
+            doClassLines.push(...buildOrmDoActivityLogLines(doEntry.binding));
+        }
+        if (alarmHandlers.length > 0) {
+            doClassLines.push(`  async alarm(...args) {`);
+            doClassLines.push(`    __setDoContext(this);`);
+            for (const handler of alarmHandlers) {
+                const handlerVar = `__handler_${toSafeIdentifier(handler.fileName)}`;
+                doClassLines.push(`    await ${handlerVar}.onAlarm.call(this, ...args);`);
+            }
+            doClassLines.push(`  }`);
+        }
+        if (messageHandlers.length > 0) {
+            doClassLines.push(`  webSocketMessage(...args) {`);
+            doClassLines.push(`    __setDoContext(this);`);
+            for (const handler of messageHandlers) {
+                const handlerVar = `__handler_${toSafeIdentifier(handler.fileName)}`;
+                doClassLines.push(`    ${handlerVar}.onMessage.call(this, ...args);`);
+            }
+            doClassLines.push(`  }`);
+        }
+        doClassLines.push(`  static schemas = {};`);
+        doClassLines.push(`}`);
+        // Apply prototype methods from each class handler (and its contributors) onto the generated class
         for (const handler of handlers) {
             const handlerVar = `__handler_${toSafeIdentifier(handler.fileName)}`;
-            doResolverLines.push(`  __registerDoClassBinding(${handlerVar}, '${doEntry.binding}');`);
+            if (handler.mode === 'class') {
+                const classSourceVars = [
+                    handlerVar,
+                    ...(handler.classContributors ?? []).map((c, i) => `__handler_${toSafeIdentifier(`${handler.fileName}__${c.className}_${i}`)}`),
+                ];
+                doClassLines.push(`{`);
+                doClassLines.push(`  for (const __source of [${classSourceVars.join(', ')}]) {`);
+                doClassLines.push(`    const __seen = new Set();`);
+                doClassLines.push(`    for (let __p = __source.prototype; __p && __p !== __DO.prototype && __p !== Object.prototype; __p = Object.getPrototypeOf(__p)) {`);
+                doClassLines.push(`      for (const __k of Object.getOwnPropertyNames(__p)) {`);
+                doClassLines.push(`        if (__k === 'constructor' || __seen.has(__k)) continue;`);
+                doClassLines.push(`        const __desc = Object.getOwnPropertyDescriptor(__p, __k);`);
+                doClassLines.push(`        const __fn = __desc?.value;`);
+                doClassLines.push(`        if (typeof __fn !== 'function') continue;`);
+                doClassLines.push(`        __seen.add(__k);`);
+                doClassLines.push(`        ${doEntry.className}.prototype[__k] = function(...__a){ return __invokeDoRpc(this, __k, __fn, __a); };`);
+                doClassLines.push(`      }`);
+                doClassLines.push(`    }`);
+                doClassLines.push(`  }`);
+                doClassLines.push(`}`);
+                doClassLines.push(`Object.assign(${doEntry.className}.schemas, ${handlerVar}.schemas || {});`);
+                for (const [index] of (handler.classContributors ?? []).entries()) {
+                    const contributorVar = `__handler_${toSafeIdentifier(`${handler.fileName}__${handler.classContributors[index].className}_${index}`)}`;
+                    doClassLines.push(`Object.assign(${doEntry.className}.schemas, ${contributorVar}.schemas || {});`);
+                }
+                doResolverLines.push(`  __registerDoClassBinding(${handlerVar}, '${doEntry.binding}');`);
+            }
+            else {
+                const lifecycle = new Set(['onInit', 'onAlarm', 'onMessage']);
+                for (const fn of handler.exportedFunctions) {
+                    if (lifecycle.has(fn))
+                        continue;
+                    doClassLines.push(`${doEntry.className}.prototype[${JSON.stringify(fn)}] = function(...__a){ return __invokeDoRpc(this, ${JSON.stringify(fn)}, ${handlerVar}.${fn}, __a); };`);
+                }
+                doClassLines.push(`Object.assign(${doEntry.className}.schemas, ${handlerVar}.schemas || {});`);
+            }
         }
         if (doEntry.stubId) {
             const fieldPath = doEntry.stubId.startsWith('user.') ? `__u.${doEntry.stubId.slice(5)}` : doEntry.stubId;
@@ -261,13 +392,8 @@ function buildDurableObjectBlock(opts) {
         doResolverInit: `\nfunction __initDoResolvers() {\n${doResolverLines.join('\n')}\n}\n`,
     };
 }
-function buildOrmDurableObjectClassLines(className, binding, baseClass) {
+function buildOrmDoActivityLogLines(binding) {
     return [
-        `export class ${className} extends ${baseClass} {`,
-        `  constructor(ctx, env) {`,
-        `    super(ctx, env);`,
-        `    this.db = __initDO(ctx.storage.sql, __doSchema_${binding});`,
-        `  }`,
         `  async __kuratchiLogActivity(payload) {`,
         `    const now = new Date().toISOString();`,
         `    try {`,
@@ -302,8 +428,8 @@ function buildOrmDurableObjectClassLines(className, binding, baseClass) {
         `    if (Number.isFinite(limit) && limit > 0) return rows.slice(0, Math.floor(limit));`,
         `    return rows;`,
         `  }`,
-        `}`,
     ];
+    void binding;
 }
 function buildWorkflowStatusRpc(opts) {
     if (opts.workflowConfig.length === 0)
@@ -311,10 +437,12 @@ function buildWorkflowStatusRpc(opts) {
     const rpcLines = [];
     rpcLines.push(`\n// Workflow Status RPCs (auto-generated)`);
     rpcLines.push(`const __workflowStatusRpc = {`);
+    const rpcNames = [];
     for (const workflow of opts.workflowConfig) {
         const baseName = workflow.file.split('/').pop()?.replace(/\.workflow\.ts$/, '') || '';
         const camelName = baseName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
         const rpcName = `${camelName}WorkflowStatus`;
+        rpcNames.push(rpcName);
         rpcLines.push(`  '${rpcName}': async (instanceId) => {`);
         rpcLines.push(`    if (!instanceId) return { status: 'unknown', error: { name: 'Error', message: 'Missing instanceId' } };`);
         rpcLines.push(`    try {`);
@@ -326,5 +454,9 @@ function buildWorkflowStatusRpc(opts) {
         rpcLines.push(`  },`);
     }
     rpcLines.push(`};`);
+    // Export individual functions for use in route templates
+    for (const rpcName of rpcNames) {
+        rpcLines.push(`const ${rpcName} = __workflowStatusRpc['${rpcName}'];`);
+    }
     return rpcLines.join('\n');
 }

package/dist/compiler/routes-module-types.d.ts

@@ -27,6 +27,7 @@ export interface GenerateRoutesModuleOptions {
     assetsPrefix: string;
     runtimeContextImport: string;
     runtimeDoImport: string;
+    runtimeSchemaImport: string;
     runtimeWorkerImport: string;
 }
 export interface RoutesModuleFeatureBlocks {

package/dist/compiler/template.d.ts

@@ -28,6 +28,10 @@ export interface CompileTemplateOptions {
     enableFragmentManifest?: boolean;
     appendNewline?: boolean;
     clientRouteRegistry?: ClientRouteRegistry;
+    awaitQueryBindings?: Map<string, {
+        asName: string;
+        rpcId: string;
+    }>;
 }
 export declare function splitTemplateRenderSections(template: string): TemplateRenderSections;
 /**