@kuratchi/js 0.0.14 → 0.0.16

package/dist/compiler/config-reading.js

@@ -0,0 +1,323 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function skipWhitespace(source, start) {
+    let i = start;
+    while (i < source.length && /\s/.test(source[i]))
+        i++;
+    return i;
+}
+function extractBalancedBody(source, start, openChar, closeChar) {
+    if (source[start] !== openChar)
+        return null;
+    let depth = 0;
+    for (let i = start; i < source.length; i++) {
+        if (source[i] === openChar)
+            depth++;
+        else if (source[i] === closeChar) {
+            depth--;
+            if (depth === 0)
+                return source.slice(start + 1, i);
+        }
+    }
+    return null;
+}
+function readConfigBlock(source, key) {
+    const keyRegex = new RegExp(`\\b${key}\\s*:`);
+    const keyMatch = keyRegex.exec(source);
+    if (!keyMatch)
+        return null;
+    const colonIdx = source.indexOf(':', keyMatch.index);
+    if (colonIdx === -1)
+        return null;
+    const valueIdx = skipWhitespace(source, colonIdx + 1);
+    if (valueIdx >= source.length)
+        return null;
+    if (source[valueIdx] === '{') {
+        throw new Error(`[kuratchi] "${key}" config must use an adapter call (e.g. ${key}: kuratchi${key[0].toUpperCase()}${key.slice(1)}Config({...})).`);
+    }
+    const callOpen = source.indexOf('(', valueIdx);
+    if (callOpen === -1)
+        return null;
+    const argIdx = skipWhitespace(source, callOpen + 1);
+    if (argIdx >= source.length)
+        return null;
+    if (source[argIdx] === ')')
+        return { kind: 'call-empty', body: '' };
+    if (source[argIdx] === '{') {
+        const body = extractBalancedBody(source, argIdx, '{', '}');
+        if (body == null)
+            return null;
+        return { kind: 'call-object', body };
+    }
+    return { kind: 'call-empty', body: '' };
+}
+export function readUiTheme(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return null;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const uiBlock = readConfigBlock(source, 'ui');
+    if (!uiBlock)
+        return null;
+    const themeMatch = uiBlock.body.match(/theme\s*:\s*['"]([^'"]+)['"]/);
+    const themeValue = themeMatch?.[1] ?? 'default';
+    if (themeValue === 'default' || themeValue === 'dark' || themeValue === 'light' || themeValue === 'system') {
+        const candidates = [
+            path.join(projectDir, 'node_modules', '@kuratchi/ui', 'src', 'styles', 'theme.css'),
+            path.join(path.resolve(projectDir, '../..'), 'packages', 'kuratchi-ui', 'src', 'styles', 'theme.css'),
+            path.join(path.resolve(projectDir, '../..'), 'node_modules', '@kuratchi/ui', 'src', 'styles', 'theme.css'),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return fs.readFileSync(candidate, 'utf-8');
+            }
+        }
+        console.warn(`[kuratchi] ui.theme: "${themeValue}" configured but @kuratchi/ui theme.css not found`);
+        return null;
+    }
+    const customPath = path.resolve(projectDir, themeValue);
+    if (fs.existsSync(customPath)) {
+        return fs.readFileSync(customPath, 'utf-8');
+    }
+    console.warn(`[kuratchi] ui.theme: "${themeValue}" not found at ${customPath}`);
+    return null;
+}
+export function readUiConfigValues(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return null;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const uiBlock = readConfigBlock(source, 'ui');
+    if (!uiBlock)
+        return null;
+    const themeMatch = uiBlock.body.match(/theme\s*:\s*['"]([^'"]+)['"]/);
+    const radiusMatch = uiBlock.body.match(/radius\s*:\s*['"]([^'"]+)['"]/);
+    return {
+        theme: themeMatch?.[1] ?? 'dark',
+        radius: radiusMatch?.[1] ?? 'default',
+    };
+}
+export function readOrmConfig(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return [];
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const ormBlock = readConfigBlock(source, 'orm');
+    if (!ormBlock)
+        return [];
+    const importMap = new Map();
+    const importRegex = /import\s*\{\s*([^}]+)\s*\}\s*from\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(source)) !== null) {
+        const names = match[1].split(',').map((name) => name.trim()).filter(Boolean);
+        const importPath = match[2];
+        for (const name of names) {
+            importMap.set(name, importPath);
+        }
+    }
+    const databasesIdx = ormBlock.body.search(/databases\s*:\s*\{/);
+    if (databasesIdx === -1)
+        return [];
+    const dbBraceStart = ormBlock.body.indexOf('{', databasesIdx);
+    if (dbBraceStart === -1)
+        return [];
+    const databasesBody = extractBalancedBody(ormBlock.body, dbBraceStart, '{', '}');
+    if (databasesBody == null)
+        return [];
+    const entries = [];
+    const entryRegex = /(\w+)\s*:\s*\{\s*schema\s*:\s*(\w+)([^}]*)\}/g;
+    while ((match = entryRegex.exec(databasesBody)) !== null) {
+        const binding = match[1];
+        const schemaExportName = match[2];
+        const rest = match[3] || '';
+        const skipMatch = rest.match(/skipMigrations\s*:\s*(true|false)/);
+        const skipMigrations = skipMatch?.[1] === 'true';
+        const typeMatch = rest.match(/type\s*:\s*['"]?(d1|do)['"]?/);
+        const type = typeMatch?.[1] ?? 'd1';
+        const schemaImportPath = importMap.get(schemaExportName);
+        if (!schemaImportPath)
+            continue;
+        entries.push({ binding, schemaImportPath, schemaExportName, skipMigrations, type });
+    }
+    return entries;
+}
+export function readAuthConfig(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return null;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const authBlockMatch = readConfigBlock(source, 'auth');
+    if (!authBlockMatch)
+        return null;
+    const authBlock = authBlockMatch.body;
+    const cookieMatch = authBlock.match(/cookieName\s*:\s*['"]([^'"]+)['"]/);
+    const secretMatch = authBlock.match(/secretEnvKey\s*:\s*['"]([^'"]+)['"]/);
+    const sessionMatch = authBlock.match(/sessionEnabled\s*:\s*(true|false)/);
+    return {
+        cookieName: cookieMatch?.[1] ?? 'kuratchi_session',
+        secretEnvKey: secretMatch?.[1] ?? 'AUTH_SECRET',
+        sessionEnabled: sessionMatch?.[1] !== 'false',
+        hasCredentials: /credentials\s*:/.test(authBlock),
+        hasActivity: /activity\s*:/.test(authBlock),
+        hasRoles: /roles\s*:/.test(authBlock),
+        hasOAuth: /oauth\s*:/.test(authBlock),
+        hasGuards: /guards\s*:/.test(authBlock),
+        hasRateLimit: /rateLimit\s*:/.test(authBlock),
+        hasTurnstile: /turnstile\s*:/.test(authBlock),
+        hasOrganization: /organizations\s*:/.test(authBlock),
+    };
+}
+export function readDoConfig(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return [];
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const doIdx = source.search(/durableObjects\s*:\s*\{/);
+    if (doIdx === -1)
+        return [];
+    const braceStart = source.indexOf('{', doIdx);
+    if (braceStart === -1)
+        return [];
+    let depth = 0;
+    let braceEnd = braceStart;
+    for (let i = braceStart; i < source.length; i++) {
+        if (source[i] === '{')
+            depth++;
+        else if (source[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                braceEnd = i;
+                break;
+            }
+        }
+    }
+    const doBlock = source.slice(braceStart + 1, braceEnd);
+    const entries = [];
+    const objRegex = /(\w+)\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+    let match;
+    while ((match = objRegex.exec(doBlock)) !== null) {
+        const binding = match[1];
+        const body = match[2];
+        const cnMatch = body.match(/className\s*:\s*['"](\w+)['"]/);
+        if (!cnMatch)
+            continue;
+        const entry = { binding, className: cnMatch[1] };
+        const stubIdMatch = body.match(/stubId\s*:\s*['"]([^'"]+)['"]/);
+        if (stubIdMatch)
+            entry.stubId = stubIdMatch[1];
+        const filesMatch = body.match(/files\s*:\s*\[([\s\S]*?)\]/);
+        if (filesMatch) {
+            const list = [];
+            const itemRegex = /['"]([^'"]+)['"]/g;
+            let fileMatch;
+            while ((fileMatch = itemRegex.exec(filesMatch[1])) !== null) {
+                list.push(fileMatch[1]);
+            }
+            if (list.length > 0)
+                entry.files = list;
+        }
+        entries.push(entry);
+    }
+    const foundBindings = new Set(entries.map((entry) => entry.binding));
+    const pairRegex = /(\w+)\s*:\s*['"](\w+)['"]\s*[,}\n]/g;
+    while ((match = pairRegex.exec(doBlock)) !== null) {
+        if (foundBindings.has(match[1]))
+            continue;
+        if (['className', 'stubId'].includes(match[1]))
+            continue;
+        entries.push({ binding: match[1], className: match[2] });
+    }
+    return entries;
+}
+export function readWorkerClassConfig(projectDir, key) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return [];
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const keyIdx = source.search(new RegExp(`\\b${key}\\s*:\\s*\\{`));
+    if (keyIdx === -1)
+        return [];
+    const braceStart = source.indexOf('{', keyIdx);
+    if (braceStart === -1)
+        return [];
+    const body = extractBalancedBody(source, braceStart, '{', '}');
+    if (body == null)
+        return [];
+    const entries = [];
+    const expectedSuffix = key === 'containers' ? '.container' : '.workflow';
+    const allowedExt = /\.(ts|js|mjs|cjs)$/i;
+    const requiredFilePattern = new RegExp(`\\${expectedSuffix}\\.(ts|js|mjs|cjs)$`, 'i');
+    const resolveClassFromFile = (binding, filePath) => {
+        if (!requiredFilePattern.test(filePath)) {
+            throw new Error(`[kuratchi] ${key}.${binding} must reference a file ending in "${expectedSuffix}.ts|js|mjs|cjs". Received: ${filePath}`);
+        }
+        if (!allowedExt.test(filePath)) {
+            throw new Error(`[kuratchi] ${key}.${binding} file must be a TypeScript or JavaScript module. Received: ${filePath}`);
+        }
+        const absPath = path.isAbsolute(filePath) ? filePath : path.join(projectDir, filePath);
+        if (!fs.existsSync(absPath)) {
+            throw new Error(`[kuratchi] ${key}.${binding} file not found: ${filePath}`);
+        }
+        const fileSource = fs.readFileSync(absPath, 'utf-8');
+        const defaultClass = fileSource.match(/export\s+default\s+class\s+(\w+)/);
+        if (defaultClass) {
+            return { className: defaultClass[1], exportKind: 'default' };
+        }
+        const namedClass = fileSource.match(/export\s+class\s+(\w+)/);
+        if (namedClass) {
+            return { className: namedClass[1], exportKind: 'named' };
+        }
+        throw new Error(`[kuratchi] ${key}.${binding} must export a class via "export class X" or "export default class X". File: ${filePath}`);
+    };
+    const objRegex = /(\w+)\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+    let match;
+    while ((match = objRegex.exec(body)) !== null) {
+        const binding = match[1];
+        const entryBody = match[2];
+        const fileMatch = entryBody.match(/file\s*:\s*['"]([^'"]+)['"]/);
+        if (!fileMatch)
+            continue;
+        const inferred = resolveClassFromFile(binding, fileMatch[1]);
+        const classMatch = entryBody.match(/className\s*:\s*['"](\w+)['"]/);
+        const className = classMatch?.[1] ?? inferred.className;
+        entries.push({
+            binding,
+            className,
+            file: fileMatch[1],
+            exportKind: inferred.exportKind,
+        });
+    }
+    const foundBindings = new Set(entries.map((entry) => entry.binding));
+    const pairRegex = /(\w+)\s*:\s*['"]([^'"]+)['"]\s*[,}\n]/g;
+    while ((match = pairRegex.exec(body)) !== null) {
+        const binding = match[1];
+        const file = match[2];
+        if (foundBindings.has(binding))
+            continue;
+        if (binding === 'file' || binding === 'className')
+            continue;
+        const inferred = resolveClassFromFile(binding, file);
+        entries.push({
+            binding,
+            className: inferred.className,
+            file,
+            exportKind: inferred.exportKind,
+        });
+    }
+    return entries;
+}
+export 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;
+}

package/dist/compiler/convention-discovery.d.ts

@@ -0,0 +1,9 @@
+import { type ConventionClassEntry, type WorkerClassConfigEntry } from './compiler-shared.js';
+export declare function resolveClassExportFromFile(absPath: string, errorLabel: string): {
+    className: string;
+    exportKind: 'named' | 'default';
+};
+export declare function discoverConventionClassFiles(projectDir: string, dir: string, suffix: string, errorLabel: string): ConventionClassEntry[];
+export declare function discoverFilesWithSuffix(dir: string, suffix: string): string[];
+export declare function discoverWorkflowFiles(projectDir: string): WorkerClassConfigEntry[];
+export declare function discoverContainerFiles(projectDir: string): WorkerClassConfigEntry[];

package/dist/compiler/convention-discovery.js

@@ -0,0 +1,83 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function resolveClassExportFromFile(absPath, errorLabel) {
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`[kuratchi] ${errorLabel} file not found: ${absPath}`);
+    }
+    const fileSource = fs.readFileSync(absPath, 'utf-8');
+    const defaultClass = fileSource.match(/export\s+default\s+class\s+(\w+)/);
+    if (defaultClass) {
+        return { className: defaultClass[1], exportKind: 'default' };
+    }
+    const namedClass = fileSource.match(/export\s+class\s+(\w+)/);
+    if (namedClass) {
+        return { className: namedClass[1], exportKind: 'named' };
+    }
+    throw new Error(`[kuratchi] ${errorLabel} must export a class via "export class X" or "export default class X". File: ${absPath}`);
+}
+export function discoverConventionClassFiles(projectDir, dir, suffix, errorLabel) {
+    const absDir = path.join(projectDir, dir);
+    const files = discoverFilesWithSuffix(absDir, suffix);
+    if (files.length === 0)
+        return [];
+    return files.map((absPath) => {
+        const resolved = resolveClassExportFromFile(absPath, errorLabel);
+        return {
+            className: resolved.className,
+            file: path.relative(projectDir, absPath).replace(/\\/g, '/'),
+            exportKind: resolved.exportKind,
+        };
+    });
+}
+export function discoverFilesWithSuffix(dir, suffix) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    const walk = (absDir) => {
+        for (const entry of fs.readdirSync(absDir, { withFileTypes: true })) {
+            const abs = path.join(absDir, entry.name);
+            if (entry.isDirectory()) {
+                walk(abs);
+            }
+            else if (entry.isFile() && abs.endsWith(suffix)) {
+                out.push(abs);
+            }
+        }
+    };
+    walk(dir);
+    return out;
+}
+export function discoverWorkflowFiles(projectDir) {
+    const serverDir = path.join(projectDir, 'src', 'server');
+    const files = discoverFilesWithSuffix(serverDir, '.workflow.ts');
+    if (files.length === 0)
+        return [];
+    return files.map((absPath) => {
+        const fileName = path.basename(absPath, '.workflow.ts');
+        const binding = fileName.toUpperCase().replace(/-/g, '_') + '_WORKFLOW';
+        const resolved = resolveClassExportFromFile(absPath, '.workflow');
+        return {
+            binding,
+            className: resolved.className,
+            file: path.relative(projectDir, absPath).replace(/\\/g, '/'),
+            exportKind: resolved.exportKind,
+        };
+    });
+}
+export function discoverContainerFiles(projectDir) {
+    const serverDir = path.join(projectDir, 'src', 'server');
+    const files = discoverFilesWithSuffix(serverDir, '.container.ts');
+    if (files.length === 0)
+        return [];
+    return files.map((absPath) => {
+        const fileName = path.basename(absPath, '.container.ts');
+        const binding = fileName.toUpperCase().replace(/-/g, '_') + '_CONTAINER';
+        const resolved = resolveClassExportFromFile(absPath, '.container');
+        return {
+            binding,
+            className: resolved.className,
+            file: path.relative(projectDir, absPath).replace(/\\/g, '/'),
+            exportKind: resolved.exportKind,
+        };
+    });
+}

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

@@ -0,0 +1,9 @@
+import { type DoConfigEntry, type DoHandlerEntry, type OrmDatabaseEntry } from './compiler-shared.js';
+export declare function discoverDurableObjects(srcDir: string, configDoEntries: DoConfigEntry[], ormDatabases: OrmDatabaseEntry[]): {
+    config: DoConfigEntry[];
+    handlers: DoHandlerEntry[];
+};
+export declare function generateHandlerProxy(handler: DoHandlerEntry, opts: {
+    projectDir: string;
+    runtimeDoImport: string;
+}): string;

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

@@ -0,0 +1,255 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { toSafeIdentifier, } from './compiler-shared.js';
+import { discoverFilesWithSuffix } from './convention-discovery.js';
+export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
+    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 configByBinding = new Map();
+    for (const entry of configDoEntries) {
+        configByBinding.set(entry.binding, entry);
+    }
+    const handlers = [];
+    const discoveredConfig = [];
+    const fileNameToAbsPath = new Map();
+    const seenBindings = new Set();
+    for (const absPath of discoveredFiles) {
+        const file = path.basename(absPath);
+        const source = fs.readFileSync(absPath, 'utf-8');
+        if (!/extends\s+DurableObject\b/.test(source))
+            continue;
+        const classMatch = source.match(/export\s+default\s+class\s+(\w+)\s+extends\s+DurableObject/);
+        const className = classMatch?.[1] ?? null;
+        if (!className)
+            continue;
+        const bindingMatch = source.match(/static\s+binding\s*=\s*['"](\w+)['"]/);
+        const baseName = file.replace(/\.do\.ts$/, '').replace(/\.ts$/, '');
+        const derivedBinding = baseName.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase() + '_DO';
+        const binding = bindingMatch?.[1] ?? derivedBinding;
+        if (seenBindings.has(binding)) {
+            throw new Error(`[KuratchiJS] Duplicate DO binding '${binding}' detected. Use 'static binding = "UNIQUE_NAME"' in one of the classes.`);
+        }
+        seenBindings.add(binding);
+        const classMethods = extractClassMethods(source, className);
+        const fileName = file.replace(/\.ts$/, '');
+        const existing = fileNameToAbsPath.get(fileName);
+        if (existing && existing !== absPath) {
+            throw new Error(`[KuratchiJS] Duplicate DO handler file name '${fileName}.ts' detected:\n- ${existing}\n- ${absPath}\nRename one file or move it to avoid proxy name collision.`);
+        }
+        fileNameToAbsPath.set(fileName, absPath);
+        const configEntry = configByBinding.get(binding);
+        void ormDatabases;
+        discoveredConfig.push({
+            binding,
+            className,
+            stubId: configEntry?.stubId,
+            files: [file],
+        });
+        handlers.push({
+            fileName,
+            absPath,
+            binding,
+            mode: 'class',
+            className,
+            classMethods,
+            exportedFunctions: [],
+        });
+    }
+    return { config: discoveredConfig, handlers };
+}
+export function generateHandlerProxy(handler, opts) {
+    const doDir = path.join(opts.projectDir, '.kuratchi', 'do');
+    const origRelPath = path.relative(doDir, handler.absPath).replace(/\\/g, '/').replace(/\.ts$/, '.js');
+    const handlerLocal = `__handler_${toSafeIdentifier(handler.fileName)}`;
+    const lifecycle = new Set(['constructor', 'fetch', 'alarm', 'webSocketMessage', 'webSocketClose', 'webSocketError']);
+    const rpcFunctions = handler.classMethods
+        .filter((method) => method.visibility === 'public' && !method.name.startsWith('_') && !lifecycle.has(method.name))
+        .map((method) => method.name);
+    const methods = handler.classMethods.map((method) => ({ ...method }));
+    const methodMap = new Map(methods.map((method) => [method.name, method]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const method of methods) {
+            if (method.hasWorkerContextCalls)
+                continue;
+            for (const called of method.callsThisMethods) {
+                const target = methodMap.get(called);
+                if (target?.hasWorkerContextCalls) {
+                    method.hasWorkerContextCalls = true;
+                    changed = true;
+                    break;
+                }
+            }
+        }
+    }
+    const workerContextMethods = methods
+        .filter((method) => method.visibility === 'public' && method.hasWorkerContextCalls)
+        .map((method) => method.name);
+    const asyncMethods = methods.filter((method) => method.isAsync).map((method) => method.name);
+    const lines = [
+        `// Auto-generated by KuratchiJS compiler �" do not edit.`,
+        `import { __getDoStub } from '${opts.runtimeDoImport}';`,
+        `import ${handlerLocal} from '${origRelPath}';`,
+        ``,
+        `const __FD_TAG = '__kuratchi_form_data__';`,
+        `function __isPlainObject(__v) {`,
+        `  if (!__v || typeof __v !== 'object') return false;`,
+        `  const __proto = Object.getPrototypeOf(__v);`,
+        `  return __proto === Object.prototype || __proto === null;`,
+        `}`,
+        `function __encodeArg(__v, __seen = new WeakSet()) {`,
+        `  if (typeof FormData !== 'undefined' && __v instanceof FormData) {`,
+        `    return { [__FD_TAG]: Array.from(__v.entries()) };`,
+        `  }`,
+        `  if (Array.isArray(__v)) return __v.map((__x) => __encodeArg(__x, __seen));`,
+        `  if (__isPlainObject(__v)) {`,
+        `    if (__seen.has(__v)) throw new Error('[KuratchiJS] Circular object passed to DO RPC');`,
+        `    __seen.add(__v);`,
+        `    const __out = {};`,
+        `    for (const [__k, __val] of Object.entries(__v)) __out[__k] = __encodeArg(__val, __seen);`,
+        `    __seen.delete(__v);`,
+        `    return __out;`,
+        `  }`,
+        `  return __v;`,
+        `}`,
+        `function __decodeArg(__v) {`,
+        `  if (Array.isArray(__v)) return __v.map(__decodeArg);`,
+        `  if (__isPlainObject(__v)) {`,
+        `    const __obj = __v;`,
+        `    if (__FD_TAG in __obj) {`,
+        `      const __fd = new FormData();`,
+        `      const __entries = Array.isArray(__obj[__FD_TAG]) ? __obj[__FD_TAG] : [];`,
+        `      for (const __pair of __entries) {`,
+        `        if (Array.isArray(__pair) && __pair.length >= 2) __fd.append(String(__pair[0]), __pair[1]);`,
+        `      }`,
+        `      return __fd;`,
+        `    }`,
+        `    const __out = {};`,
+        `    for (const [__k, __val] of Object.entries(__obj)) __out[__k] = __decodeArg(__val);`,
+        `    return __out;`,
+        `  }`,
+        `  return __v;`,
+        `}`,
+        ``,
+    ];
+    if (workerContextMethods.length > 0) {
+        lines.push(`const __workerMethods = new Set(${JSON.stringify(workerContextMethods)});`);
+        lines.push(`const __asyncMethods = new Set(${JSON.stringify(asyncMethods)});`);
+        lines.push(`function __callWorkerMethod(__name, __args) {`);
+        lines.push(`  const __self = new Proxy({}, {`);
+        lines.push(`    get(_, __k) {`);
+        lines.push(`      if (typeof __k !== 'string') return undefined;`);
+        lines.push(`      if (__k === 'db') {`);
+        lines.push(`        throw new Error("[KuratchiJS] Worker-executed DO method cannot use this.db directly. Move DB access into a non-public method and call it via this.<method>().");`);
+        lines.push(`      }`);
+        lines.push(`      if (__workerMethods.has(__k)) {`);
+        lines.push(`        return (...__a) => ${handlerLocal}.prototype[__k].apply(__self, __a);`);
+        lines.push(`      }`);
+        lines.push(`      const __local = ${handlerLocal}.prototype[__k];`);
+        lines.push(`      if (typeof __local === 'function' && !__asyncMethods.has(__k)) {`);
+        lines.push(`        return (...__a) => __local.apply(__self, __a);`);
+        lines.push(`      }`);
+        lines.push(`      return async (...__a) => { const __s = await __getDoStub('${handler.binding}'); if (!__s) throw new Error('Not authenticated'); return __s[__k](...__a.map((__x) => __encodeArg(__x))); };`);
+        lines.push(`    },`);
+        lines.push(`  });`);
+        lines.push(`  return ${handlerLocal}.prototype[__name].apply(__self, __args.map(__decodeArg));`);
+        lines.push(`}`);
+        lines.push(``);
+    }
+    for (const method of rpcFunctions) {
+        if (workerContextMethods.includes(method)) {
+            lines.push(`export async function ${method}(...a) { return __callWorkerMethod('${method}', a); }`);
+        }
+        else {
+            lines.push(`export async function ${method}(...a) { const s = await __getDoStub('${handler.binding}'); if (!s) throw new Error('Not authenticated'); return s.${method}(...a.map((__x) => __encodeArg(__x))); }`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+function extractClassMethods(source, className) {
+    const classIdx = source.search(new RegExp(`class\\s+${className}\\s+extends\\s+DurableObject`));
+    if (classIdx === -1)
+        return [];
+    const braceStart = source.indexOf('{', classIdx);
+    if (braceStart === -1)
+        return [];
+    let depth = 0;
+    let braceEnd = braceStart;
+    for (let i = braceStart; i < source.length; i++) {
+        if (source[i] === '{')
+            depth++;
+        else if (source[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                braceEnd = i;
+                break;
+            }
+        }
+    }
+    const classBody = source.slice(braceStart + 1, braceEnd);
+    const methods = [];
+    const methodRegex = /^\s+(?:(public|private|protected)\s+)?(?:(static)\s+)?(?:(async)\s+)?([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?::[^{]+)?\{/gm;
+    const reserved = new Set([
+        'constructor', 'static', 'get', 'set',
+        'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case',
+        'throw', 'try', 'catch', 'finally', 'new', 'delete', 'typeof',
+        'void', 'instanceof', 'in', 'of', 'await', 'yield', 'const',
+        'let', 'var', 'function', 'class', 'import', 'export', 'default',
+        'break', 'continue', 'with', 'super', 'this',
+    ]);
+    let match;
+    while ((match = methodRegex.exec(classBody)) !== null) {
+        const visibility = match[1] ?? 'public';
+        const isStatic = !!match[2];
+        const isAsync = !!match[3];
+        const name = match[4];
+        if (!name || isStatic || reserved.has(name))
+            continue;
+        const matchText = match[0] ?? '';
+        const openRel = matchText.lastIndexOf('{');
+        const openAbs = openRel >= 0 ? match.index + openRel : -1;
+        let hasWorkerContextCalls = false;
+        const callsThisMethods = [];
+        if (openAbs >= 0) {
+            let innerDepth = 0;
+            let endAbs = openAbs;
+            for (let i = openAbs; i < classBody.length; i++) {
+                const ch = classBody[i];
+                if (ch === '{')
+                    innerDepth++;
+                else if (ch === '}') {
+                    innerDepth--;
+                    if (innerDepth === 0) {
+                        endAbs = i;
+                        break;
+                    }
+                }
+            }
+            const bodySource = classBody.slice(openAbs + 1, endAbs);
+            hasWorkerContextCalls = /\b(getCurrentUser|redirect|goto|getRequest|getLocals)\s*\(/.test(bodySource);
+            const called = new Set();
+            const callRegex = /\bthis\.([A-Za-z_$][\w$]*)\s*\(/g;
+            let callMatch;
+            while ((callMatch = callRegex.exec(bodySource)) !== null) {
+                called.add(callMatch[1]);
+            }
+            callsThisMethods.push(...called);
+        }
+        methods.push({
+            name,
+            visibility: visibility,
+            isStatic,
+            isAsync,
+            hasWorkerContextCalls,
+            callsThisMethods,
+        });
+    }
+    return methods;
+}

package/dist/compiler/error-page-pipeline.d.ts

@@ -0,0 +1 @@
+export declare function compileErrorPages(routesDir: string): Map<number, string>;