@kuratchi/js 0.0.10 → 0.0.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kuratchi contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -54,6 +54,7 @@ Kuratchi routes are server-first.
 - Top-level route `<script>` blocks run on the server.
 - Template expressions, `if`, and `for` blocks render on the server.
 - `src/server` is for private server-only modules and reusable backend logic.
+- `src/server/runtime.hook.ts` is the server runtime hook entrypoint for request interception.
 - Reactive `$:` code is the browser-only escape hatch.
 
 Route files are not client files. They are server-rendered routes that can opt into small browser-side reactive behavior when needed.
@@ -542,6 +543,38 @@ const postSlug = slug;
 - `slug` is `params.slug` when the matched route defines a `slug` param.
 - `headers`, `method`, and `params` are also exported from `@kuratchi/js/request`.
 - Use `getRequest()` when you want the raw native `Request` object.
+
+## Runtime Hook
+
+Optional server runtime hook file. Export a `RuntimeDefinition` from `src/server/runtime.hook.ts`
+to intercept requests before they reach the framework router. Use it for agent routing,
+pre-route auth, or custom response/error handling.
+
+```ts
+import type { RuntimeDefinition } from '@kuratchi/js';
+
+const runtime: RuntimeDefinition = {
+  agents: {
+    async request(ctx, next) {
+      if (!ctx.url.pathname.startsWith('/agents/')) {
+        return next();
+      }
+
+      return new Response('Agent response');
+    },
+  },
+};
+
+export default runtime;
+```
+
+`ctx` includes:
+
+- `ctx.url` - parsed URL
+- `ctx.request` - raw Request
+- `ctx.env` - Cloudflare env bindings
+- `next()` - pass control to the next handler
+
 ## Environment bindings
 
 Cloudflare env is server-only.

package/dist/compiler/index.js

@@ -725,6 +725,8 @@ export function compile(options) {
         // 500.html receives `error` as a variable; others don't need it
         compiledErrorPages.set(status, `function __error_${status}(error) {\n  ${body}\n  return __html;\n}`);
     }
+    // Read assets prefix from kuratchi.config.ts (default: /assets/)
+    const assetsPrefix = readAssetsPrefix(projectDir);
     // Read kuratchi.config.ts at build time to discover ORM database configs
     const ormDatabases = readOrmConfig(projectDir);
     // Read auth config from kuratchi.config.ts
@@ -1202,7 +1204,7 @@ export function compile(options) {
         });
         compiledRoutes.push(routeObj);
     }
-    // Scan src/assets/ for static files to embed
+    // Scan src/assets/ for static files to embed (recursive)
     const assetsDir = path.join(srcDir, 'assets');
     const compiledAssets = [];
     if (fs.existsSync(assetsDir)) {
@@ -1213,15 +1215,23 @@ export function compile(options) {
             '.svg': 'image/svg+xml',
             '.txt': 'text/plain; charset=utf-8',
         };
-        for (const file of fs.readdirSync(assetsDir).sort()) {
-            const ext = path.extname(file).toLowerCase();
-            const mime = mimeTypes[ext];
-            if (!mime)
-                continue; // skip unknown file types
-            const content = fs.readFileSync(path.join(assetsDir, file), 'utf-8');
-            const etag = '"' + crypto.createHash('md5').update(content).digest('hex').slice(0, 12) + '"';
-            compiledAssets.push({ name: file, content, mime, etag });
-        }
+        const scanAssets = (dir, prefix) => {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+                if (entry.isDirectory()) {
+                    scanAssets(path.join(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+                    continue;
+                }
+                const ext = path.extname(entry.name).toLowerCase();
+                const mime = mimeTypes[ext];
+                if (!mime)
+                    continue;
+                const content = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+                const etag = '"' + crypto.createHash('md5').update(content).digest('hex').slice(0, 12) + '"';
+                const name = prefix ? `${prefix}/${entry.name}` : entry.name;
+                compiledAssets.push({ name, content, mime, etag });
+            }
+        };
+        scanAssets(assetsDir, '');
     }
     // Collect only the components that were actually imported by routes
     const compiledComponents = Array.from(compiledComponentCache.values());
@@ -1254,6 +1264,7 @@ export function compile(options) {
         compiledLayoutActions,
         hasRuntime,
         runtimeImportPath,
+        assetsPrefix,
     });
     // Write to .kuratchi/routes.js
     const outFile = options.outFile ?? path.join(projectDir, '.kuratchi', 'routes.js');
@@ -1720,7 +1731,7 @@ function buildRouteObject(opts) {
       return { ${loadReturnVars.join(', ')} };`;
             }
         }
-        parts.push(`    async load(params = {}) {
+        parts.push(`    async load(__routeParams = {}) {
       ${loadBody}${returnObj}
     }`);
     }
@@ -2039,6 +2050,21 @@ function resolveClassExportFromFile(absPath, errorLabel) {
     }
     throw new Error(`[kuratchi] ${errorLabel} must export a class via "export class X" or "export default class X". File: ${absPath}`);
 }
+function readAssetsPrefix(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return '/assets/';
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const match = source.match(/assetsPrefix\s*:\s*['"]([^'"]+)['"]/);
+    if (!match)
+        return '/assets/';
+    let prefix = match[1];
+    if (!prefix.startsWith('/'))
+        prefix = '/' + prefix;
+    if (!prefix.endsWith('/'))
+        prefix += '/';
+    return prefix;
+}
 function discoverConventionClassFiles(projectDir, dir, suffix, errorLabel) {
     const absDir = path.join(projectDir, dir);
     const files = discoverFilesWithSuffix(absDir, suffix);
@@ -2933,9 +2959,9 @@ ${migrationInit ? '    await __runMigrations();\n' : ''}${authInit ? '    __init
       const url = __runtimeCtx.url;
 ${ac?.hasRateLimit ? '\n      // Rate limiting - check before route handlers\n      { const __rlRes = await __checkRL(); if (__rlRes) return __secHeaders(__rlRes); }\n' : ''}${ac?.hasTurnstile ? '      // Turnstile bot protection\n      { const __tsRes = await __checkTS(); if (__tsRes) return __secHeaders(__tsRes); }\n' : ''}${ac?.hasGuards ? '      // Route guards - redirect if not authenticated\n      { const __gRes = __checkGuard(); if (__gRes) return __secHeaders(__gRes); }\n' : ''}
 
-      // Serve static assets from src/assets/ at /_assets/*
-      if (url.pathname.startsWith('/_assets/')) {
-        const name = url.pathname.slice('/_assets/'.length);
+      // Serve static assets from src/assets/
+      if (url.pathname.startsWith('${opts.assetsPrefix}')) {
+        const name = url.pathname.slice('${opts.assetsPrefix}'.length);
         const asset = __assets[name];
         if (asset) {
           if (request.headers.get('if-none-match') === asset.etag) {
@@ -3116,12 +3142,7 @@ ${ac?.hasRateLimit ? '\n      // Rate limiting - check before route handlers\n
 }
 function resolveRuntimeImportPath(projectDir) {
     const candidates = [
-        { file: 'src/kuratchi.runtime.ts', importPath: '../src/kuratchi.runtime' },
-        { file: 'src/kuratchi.runtime.js', importPath: '../src/kuratchi.runtime' },
-        { file: 'src/kuratchi.runtime.mjs', importPath: '../src/kuratchi.runtime' },
-        { file: 'kuratchi.runtime.ts', importPath: '../kuratchi.runtime' },
-        { file: 'kuratchi.runtime.js', importPath: '../kuratchi.runtime' },
-        { file: 'kuratchi.runtime.mjs', importPath: '../kuratchi.runtime' },
+        { file: 'src/server/runtime.hook.ts', importPath: '../src/server/runtime.hook' },
     ];
     for (const candidate of candidates) {
         if (fs.existsSync(path.join(projectDir, candidate.file))) {

package/dist/compiler/parser.js

@@ -770,6 +770,21 @@ export function parseFile(source, options = {}) {
             if (!dataVars.includes(name))
                 dataVars.push(name);
         }
+        // Server import named bindings are also data vars (available in templates)
+        for (const line of serverImports) {
+            const namesMatch = line.match(/import\s*\{([^}]+)\}/);
+            if (!namesMatch)
+                continue;
+            for (const part of namesMatch[1].split(',')) {
+                const trimmed = part.trim();
+                if (!trimmed)
+                    continue;
+                const segments = trimmed.split(/\s+as\s+/);
+                const localName = (segments[1] || segments[0]).trim();
+                if (localName && !dataVars.includes(localName))
+                    dataVars.push(localName);
+            }
+        }
     }
     const hasLoad = scriptBody.length > 0 || !!loadFunction;
     // Strip HTML comments from the template before scanning for action references.

package/dist/runtime/request.js

@@ -8,7 +8,7 @@ export let slug = undefined;
 function __syncDerivedState() {
     pathname = url.pathname;
     searchParams = url.searchParams;
-    slug = params.slug;
+    slug = params.slug ?? Object.values(params)[0];
 }
 export function __setRequestState(request) {
     url = new URL(request.url);

package/package.json

@@ -1,16 +1,18 @@
 {
     "name": "@kuratchi/js",
-    "version": "0.0.10",
+    "version": "0.0.12",
     "description": "A thin, Cloudflare Workers-native web framework with Svelte-inspired syntax",
+    "license": "MIT",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "bin": {
-        "kuratchi": "./dist/cli.js"
+        "kuratchi": "dist/cli.js"
     },
     "files": [
         "dist",
-        "README.md"
+        "README.md",
+        "LICENSE"
     ],
     "scripts": {
         "build": "tsc -p tsconfig.build.json",