@kuratchi/js 0.0.15 → 0.0.16

package/dist/compiler/component-pipeline.js

@@ -0,0 +1,163 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parseFile, stripTopLevelImports } from './parser.js';
+import { compileTemplate } from './template.js';
+import { transpileTypeScript } from './transpile.js';
+import { buildDevAliasDeclarations } from './script-transform.js';
+function resolvePackageComponent(projectDir, pkgName, componentFile) {
+    const nmPath = path.join(projectDir, 'node_modules', pkgName, 'src', 'lib', componentFile + '.html');
+    if (fs.existsSync(nmPath))
+        return nmPath;
+    const pkgDirName = pkgName.replace(/^@/, '').replace(/\//g, '-');
+    const workspaceRoot = path.resolve(projectDir, '../..');
+    const wsPath = path.join(workspaceRoot, 'packages', pkgDirName, 'src', 'lib', componentFile + '.html');
+    if (fs.existsSync(wsPath))
+        return wsPath;
+    const rootNmPath = path.join(workspaceRoot, 'node_modules', pkgName, 'src', 'lib', componentFile + '.html');
+    if (fs.existsSync(rootNmPath))
+        return rootNmPath;
+    return '';
+}
+function escapeTemplateLiteral(source) {
+    return source.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+function scopeComponentCss(source, scopeHash) {
+    return source.replace(/([^{}]+)\{/g, (_match, selectors) => {
+        const scoped = selectors
+            .split(',')
+            .map((selector) => `.${scopeHash} ${selector.trim()}`)
+            .join(', ');
+        return scoped + ' {';
+    });
+}
+export function createComponentCompiler(options) {
+    const { projectDir, srcDir, isDev } = options;
+    const libDir = path.join(srcDir, 'lib');
+    const compiledComponentCache = new Map();
+    const componentStyleCache = new Map();
+    const componentActionCache = new Map();
+    function ensureCompiled(fileName) {
+        if (compiledComponentCache.has(fileName))
+            return compiledComponentCache.get(fileName);
+        let filePath;
+        let funcName;
+        const pkgMatch = fileName.match(/^(@[^:]+):(.+)$/);
+        if (pkgMatch) {
+            const pkgName = pkgMatch[1];
+            const componentFile = pkgMatch[2];
+            funcName = '__c_' + componentFile.replace(/[\/\-]/g, '_');
+            filePath = resolvePackageComponent(projectDir, pkgName, componentFile);
+            if (!filePath || !fs.existsSync(filePath))
+                return null;
+        }
+        else {
+            funcName = '__c_' + fileName.replace(/[\/\-]/g, '_');
+            filePath = path.join(libDir, fileName + '.html');
+            if (!fs.existsSync(filePath))
+                return null;
+        }
+        const scopeHash = 'dz-' + crypto.createHash('md5').update(fileName).digest('hex').slice(0, 6);
+        const rawSource = fs.readFileSync(filePath, 'utf-8');
+        const parsed = parseFile(rawSource, { kind: 'component', filePath });
+        const propsCode = parsed.script ? stripTopLevelImports(parsed.script) : '';
+        const devDecls = buildDevAliasDeclarations(parsed.devAliases, isDev);
+        const effectivePropsCode = [devDecls, propsCode].filter(Boolean).join('\n');
+        const transpiledPropsCode = propsCode
+            ? transpileTypeScript(effectivePropsCode, `component-script:${fileName}.ts`)
+            : devDecls
+                ? transpileTypeScript(devDecls, `component-script:${fileName}.ts`)
+                : '';
+        let source = parsed.template;
+        let styleBlock = '';
+        const styleMatch = source.match(/<style[\s>][\s\S]*?<\/style>/i);
+        if (styleMatch) {
+            styleBlock = styleMatch[0];
+            source = source.replace(styleMatch[0], '').trim();
+        }
+        let scopedStyle = '';
+        if (styleBlock) {
+            const cssContent = styleBlock.replace(/<style[^>]*>/i, '').replace(/<\/style>/i, '').trim();
+            scopedStyle = `<style>${scopeComponentCss(cssContent, scopeHash)}</style>`;
+        }
+        componentStyleCache.set(fileName, scopedStyle ? escapeTemplateLiteral(scopedStyle) : '');
+        source = source.replace(/<slot\s*><\/slot>/g, '{@raw props.children || ""}');
+        source = source.replace(/<slot\s*\/>/g, '{@raw props.children || ""}');
+        const subComponentNames = collectComponentMap(parsed.componentImports);
+        for (const subFileName of subComponentNames.values()) {
+            const subStyle = componentStyleCache.get(subFileName);
+            if (subStyle) {
+                const existing = componentStyleCache.get(fileName) || '';
+                if (!existing.includes(subStyle)) {
+                    componentStyleCache.set(fileName, existing + subStyle);
+                }
+            }
+        }
+        const actionPropNames = new Set();
+        for (const match of source.matchAll(/\baction=\{([A-Za-z_$][\w$]*)\}/g)) {
+            actionPropNames.add(match[1]);
+        }
+        componentActionCache.set(fileName, actionPropNames);
+        const body = compileTemplate(source, subComponentNames, undefined, undefined);
+        const scopeOpen = `__html += '<div class="${scopeHash}">';`;
+        const scopeClose = `__html += '</div>';`;
+        const bodyLines = body.split('\n');
+        const scopedBody = [bodyLines[0], scopeOpen, ...bodyLines.slice(1), scopeClose].join('\n');
+        const fnBody = transpiledPropsCode ? `${transpiledPropsCode}\n  ${scopedBody}` : scopedBody;
+        const compiled = `function ${funcName}(props, __esc) {\n  ${fnBody}\n  return __html;\n}`;
+        compiledComponentCache.set(fileName, compiled);
+        return compiled;
+    }
+    function collectComponentMap(componentImports) {
+        const componentNames = new Map();
+        for (const [pascalName, fileName] of Object.entries(componentImports)) {
+            ensureCompiled(fileName);
+            componentNames.set(pascalName, fileName);
+        }
+        return componentNames;
+    }
+    function getActionPropNames(fileName) {
+        return componentActionCache.get(fileName) ?? new Set();
+    }
+    function collectStyles(componentNames) {
+        const styles = [];
+        for (const fileName of componentNames.values()) {
+            const css = componentStyleCache.get(fileName);
+            if (css)
+                styles.push(css);
+        }
+        return styles;
+    }
+    function resolveActionProps(template, componentNames, shouldInclude) {
+        const names = new Set();
+        for (const [pascalName, compFileName] of componentNames.entries()) {
+            const actionPropNames = getActionPropNames(compFileName);
+            const compTagRegex = new RegExp(`<${pascalName}\\b([\\s\\S]*?)(?:/?)>`, 'g');
+            for (const tagMatch of template.matchAll(compTagRegex)) {
+                const attrs = tagMatch[1];
+                for (const propName of actionPropNames) {
+                    const propRegex = new RegExp(`\\b${propName}=\\{([A-Za-z_$][\\w$]*)\\}`);
+                    const propMatch = attrs.match(propRegex);
+                    if (!propMatch)
+                        continue;
+                    const fnName = propMatch[1];
+                    if (!shouldInclude || shouldInclude(fnName)) {
+                        names.add(fnName);
+                    }
+                }
+            }
+        }
+        return names;
+    }
+    function getCompiledComponents() {
+        return Array.from(compiledComponentCache.values());
+    }
+    return {
+        ensureCompiled,
+        collectComponentMap,
+        getActionPropNames,
+        collectStyles,
+        resolveActionProps,
+        getCompiledComponents,
+    };
+}

package/dist/compiler/config-reading.d.ts

@@ -0,0 +1,11 @@
+import { type AuthConfigEntry, type DoConfigEntry, type OrmDatabaseEntry, type WorkerClassConfigEntry } from './compiler-shared.js';
+export declare function readUiTheme(projectDir: string): string | null;
+export declare function readUiConfigValues(projectDir: string): {
+    theme: string;
+    radius: string;
+} | null;
+export declare function readOrmConfig(projectDir: string): OrmDatabaseEntry[];
+export declare function readAuthConfig(projectDir: string): AuthConfigEntry | null;
+export declare function readDoConfig(projectDir: string): DoConfigEntry[];
+export declare function readWorkerClassConfig(projectDir: string, key: 'containers' | 'workflows'): WorkerClassConfigEntry[];
+export declare function readAssetsPrefix(projectDir: string): string;

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;