@virune/compiler 1.1.0-rc.0

package/dist/src/project/project.js

@@ -0,0 +1,884 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { checkModule } from '../checker/checker.js';
+import { emitJavaScript } from '../codegen/emitter.js';
+import { DiagnosticBag } from '../diagnostics/diagnostic.js';
+import { lowerToHir } from '../hir/lower.js';
+import { validateFrontendComponentEmissionBoundary } from '../interop/frontend-component-emission.js';
+import { validateFrontendJsxUsage } from '../interop/jsx-view-validation.js';
+import { collectIdentityViewRepetitions, discoverRepetitionHostLocator } from '../interop/repetition-host-locator.js';
+import { validateRepetitionHostTypeScriptUsage } from '../interop/repetition-host-usage-validation.js';
+import { buildAst } from '../syntax/cst-to-ast.js';
+import { attachDocumentation } from '../syntax/documentation.js';
+import { parse } from '../syntax/parser.js';
+import { lex } from '../syntax/tokens.js';
+const runtimeDependencies = new WeakMap();
+/**
+ * Return the exact modules that can be loaded from the supplied roots by emitted
+ * Virune-to-Virune runtime imports in this ProjectBuildResult. The dependency
+ * sidecar is attached to the same BuiltModule objects that own emitted output,
+ * so execution checks do not need to rebuild or re-read project state.
+ */
+export function projectRuntimeModuleClosure(result, rootPaths) {
+    const modulesByPath = new Map(result.modules.map(module => [resolve(module.source.path), module]));
+    const reachable = new Set();
+    const visit = (path) => {
+        const normalized = resolve(path);
+        if (reachable.has(normalized))
+            return;
+        const module = modulesByPath.get(normalized);
+        if (module === undefined)
+            throw new Error(`Project runtime dependency ${normalized} is unavailable in this build result`);
+        const dependencies = runtimeDependencies.get(module);
+        if (dependencies === undefined)
+            throw new Error(`Project runtime dependency evidence is unavailable for ${normalized}`);
+        reachable.add(normalized);
+        for (const dependency of dependencies)
+            visit(dependency);
+    };
+    for (const rootPath of rootPaths)
+        visit(isAbsolute(rootPath) ? rootPath : resolve(result.root, rootPath));
+    return Object.freeze(result.modules.filter(module => reachable.has(resolve(module.source.path))));
+}
+/**
+ * Reusable state for incremental project builds. The cache is intentionally
+ * explicit so one-shot CLI builds remain deterministic and side-effect free.
+ */
+export class ProjectBuildCache {
+    #entries = new Map();
+    #fileIds = new Map();
+    #nextFileId = 1;
+    clear() {
+        this.#entries.clear();
+    }
+    invalidate(path) {
+        if (path === undefined)
+            this.clear();
+        else
+            this.#entries.delete(resolve(path));
+    }
+    fileId(path) {
+        const normalized = resolve(path);
+        const existing = this.#fileIds.get(normalized);
+        if (existing !== undefined)
+            return existing;
+        const id = this.#nextFileId++;
+        this.#fileIds.set(normalized, id);
+        return id;
+    }
+    get(path) { return this.#entries.get(resolve(path)); }
+    set(path, value) { this.#entries.set(resolve(path), value); }
+    prune(paths) {
+        let removed = 0;
+        for (const path of this.#entries.keys()) {
+            if (paths.has(path))
+                continue;
+            this.#entries.delete(path);
+            removed++;
+        }
+        return removed;
+    }
+}
+const nodeProjectHost = {
+    readFile: path => readFile(path, 'utf8'),
+};
+const defaultConfig = {
+    languageVersion: '1.0', platform: 'node', sourceDir: 'src', outDir: 'dist', entry: 'src/main.virune', target: 'es2022', sourceMap: true, sourcesContent: true,
+};
+export async function loadConfig(root, host = nodeProjectHost) {
+    let value;
+    try {
+        value = JSON.parse(await host.readFile(join(root, 'virune.json')));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return defaultConfig;
+        throw new Error(`Invalid virune.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid virune.json: root value must be an object');
+    const raw = value;
+    const merged = { ...defaultConfig, ...raw };
+    if (merged.languageVersion !== '1.0')
+        throw new Error('Invalid virune.json: languageVersion must be "1.0"');
+    if (!['node', 'browser', 'neutral'].includes(String(merged.platform)))
+        throw new Error('Invalid virune.json: platform must be node, browser, or neutral');
+    if (merged.target !== 'es2022')
+        throw new Error('Invalid virune.json: target must be "es2022"');
+    for (const key of ['sourceDir', 'outDir', 'entry'])
+        if (typeof merged[key] !== 'string' || merged[key].length === 0)
+            throw new Error(`Invalid virune.json: ${key} must be a non-empty string`);
+    for (const key of ['sourceMap', 'sourcesContent'])
+        if (typeof merged[key] !== 'boolean')
+            throw new Error(`Invalid virune.json: ${key} must be boolean`);
+    return merged;
+}
+export function parseSource(source) {
+    const diagnostics = new DiagnosticBag();
+    const lexed = lex(source.text);
+    for (const error of lexed.errors)
+        diagnostics.error('L0001', error.message, spanAt(source.id, error.offset, error.length, error.line ?? 1, error.column ?? 1));
+    const parsed = parse(lexed.tokens);
+    for (const error of parsed.errors) {
+        const token = error.token;
+        const offset = finitePosition(token.startOffset, source.text.length);
+        const endOffset = Math.min(source.text.length, Math.max(offset, finitePosition(token.endOffset, offset)));
+        const line = finitePosition(token.startLine, lineAt(source.text, offset));
+        const column = finitePosition(token.startColumn, columnAt(source.text, offset));
+        diagnostics.error('L0002', error.message, spanAt(source.id, offset, endOffset - offset, line, column));
+    }
+    if (diagnostics.hasErrors)
+        return { source, diagnostics: diagnostics.items };
+    try {
+        const ast = attachDocumentation(buildAst(source.id, parsed.cst), source, lexed.comments, lexed.tokens, diagnostics);
+        return { source, ast, diagnostics: diagnostics.items };
+    }
+    catch (error) {
+        diagnostics.error('L9001', `AST construction failed: ${error instanceof Error ? error.message : String(error)}`, spanAt(source.id, 0, 1, 1, 1));
+        return { source, diagnostics: diagnostics.items };
+    }
+}
+export async function buildProject(rootDirectory, optionsOrWrite = true, legacyAdditionalEntries = []) {
+    const options = typeof optionsOrWrite === 'boolean'
+        ? { write: optionsOrWrite, additionalEntries: legacyAdditionalEntries }
+        : optionsOrWrite;
+    const write = options.write ?? true;
+    const additionalEntries = options.additionalEntries ?? [];
+    const host = options.host ?? nodeProjectHost;
+    const includeConfigEntry = options.includeConfigEntry ?? true;
+    const root = resolve(rootDirectory);
+    const projectDiagnostics = new DiagnosticBag();
+    const cache = options.incrementalCache;
+    const jsInteropProvider = options.jsInteropProvider;
+    const mutableStats = { parsedModules: 0, reusedParsedModules: 0, checkedModules: 0, reusedCheckedModules: 0, emittedModules: 0, reusedEmittedModules: 0, invalidatedModules: 0 };
+    let config;
+    try {
+        config = await loadConfig(root, host);
+    }
+    catch (error) {
+        config = defaultConfig;
+        projectDiagnostics.error('L5002', error instanceof Error ? error.message : String(error), spanAt(0, 0, 1, 1, 1));
+        return { root, config, modules: [], diagnostics: projectDiagnostics.items, stats: mutableStats };
+    }
+    const entry = resolve(root, config.entry);
+    const parsedByPath = new Map();
+    const sourceHashes = new Map();
+    const dependenciesByPath = new Map();
+    let nextFileId = 1;
+    const visiting = new Set();
+    const visited = new Set();
+    const order = [];
+    const visit = async (path, fromImport) => {
+        const normalized = resolve(path);
+        if (visiting.has(normalized)) {
+            projectDiagnostics.error('L4002', `Module cycle detected at ${normalized}`, fromImport?.span ?? spanAt(0, 0, 1, 1, 1));
+            return;
+        }
+        if (visited.has(normalized))
+            return;
+        visiting.add(normalized);
+        let text;
+        try {
+            text = await host.readFile(normalized);
+        }
+        catch (error) {
+            projectDiagnostics.error('L5001', `Cannot read module ${normalized}: ${error instanceof Error ? error.message : String(error)}`, fromImport?.span ?? spanAt(0, 0, 1, 1, 1));
+            visiting.delete(normalized);
+            return;
+        }
+        const sourceHash = contentHash(text);
+        sourceHashes.set(normalized, sourceHash);
+        const cached = cache?.get(normalized);
+        let parsed;
+        if (cached?.sourceHash === sourceHash) {
+            parsed = cached.parsed;
+            mutableStats.reusedParsedModules++;
+        }
+        else {
+            parsed = parseSource({ id: cache?.fileId(normalized) ?? nextFileId++, path: normalized, text });
+            mutableStats.parsedModules++;
+        }
+        parsedByPath.set(normalized, parsed);
+        const dependencies = [];
+        if (parsed.ast !== undefined) {
+            validateModulePolicy(root, config, normalized, parsed.ast, projectDiagnostics);
+            validateSignatureVisibility(parsed.ast, projectDiagnostics);
+            for (const declaration of parsed.ast.imports) {
+                if (declaration.sourceKind === 'javascript')
+                    continue;
+                const dependency = await resolveImport(root, normalized, declaration.source, host);
+                if (dependency === undefined)
+                    projectDiagnostics.error('L4003', `Cannot resolve import ${declaration.source}`, declaration.span);
+                else {
+                    dependencies.push(resolve(dependency));
+                    await visit(dependency, declaration);
+                }
+            }
+        }
+        dependenciesByPath.set(normalized, dependencies);
+        visiting.delete(normalized);
+        visited.add(normalized);
+        order.push(normalized);
+    };
+    if (includeConfigEntry)
+        await visit(entry);
+    for (const additionalEntry of additionalEntries)
+        await visit(isAbsolute(additionalEntry) ? additionalEntry : resolve(root, additionalEntry));
+    const repetitionHostLocator = discoverRepetitionHostLocator(order.flatMap(path => {
+        const ast = parsedByPath.get(path)?.ast;
+        return ast === undefined || modulePackageScope(root, path) !== 'project' ? [] : [{ path, ast }];
+    }));
+    const repetitionHostFingerprint = fingerprintRepetitionHostResolution(repetitionHostLocator);
+    const moduleInterfaces = await buildModuleInterfaces(root, order, parsedByPath, projectDiagnostics, host);
+    const interfaceHashes = new Map();
+    for (const path of order)
+        interfaceHashes.set(path, moduleInterfaceHash(moduleInterfaces.get(path)));
+    const configFingerprint = contentHash(JSON.stringify({ config, jsInterop: jsInteropProvider === undefined ? null : { id: jsInteropProvider.id, version: jsInteropProvider.version, generation: jsInteropProvider.generation } }));
+    const builtByPath = new Map();
+    let cloneId = -1;
+    for (const path of order) {
+        const parsed = parsedByPath.get(path);
+        const component = parsed.ast?.declarations.find(declaration => declaration.kind === 'ComponentDeclaration');
+        const identityRepetitions = parsed.ast === undefined ? [] : collectIdentityViewRepetitions(parsed.ast);
+        const dependencySignature = contentHash((dependenciesByPath.get(path) ?? []).map(dependency => `${dependency}:${interfaceHashes.get(dependency) ?? ''}:${parsedByPath.get(dependency)?.ast?.declarations.some(declaration => declaration.kind === 'ComponentDeclaration') === true ? 'jsx' : 'js'}`).sort().join('|'));
+        const hostResolutionFingerprint = identityRepetitions.length === 0 ? '' : repetitionHostFingerprint;
+        const buildFingerprint = contentHash(`${sourceHashes.get(path) ?? ''}|${dependencySignature}|${configFingerprint}|${hostResolutionFingerprint}`);
+        const cached = cache?.get(path);
+        if (cached?.buildFingerprint === buildFingerprint) {
+            builtByPath.set(path, cached.built);
+            mutableStats.reusedCheckedModules++;
+            if (cached.built.output !== undefined) {
+                mutableStats.reusedEmittedModules++;
+                if (write && cached.built.outputPath !== undefined)
+                    await writeEmitOutput(cached.built.outputPath, cached.built.output, config.sourceMap);
+            }
+            continue;
+        }
+        let built;
+        let moduleRuntimeDependencies = Object.freeze([]);
+        if (parsed.ast === undefined || parsed.diagnostics.some(item => item.severity === 'error')) {
+            built = parsed;
+        }
+        else {
+            const importModel = await buildImportModel(root, path, parsed.ast, parsedByPath, moduleInterfaces, projectDiagnostics, cloneId, host);
+            cloneId = importModel.nextId;
+            const { signatureOnly, typeOnlyNodeIds, importedDeclarations, emissionImports } = importModel;
+            moduleRuntimeDependencies = importModel.runtimeDependencies;
+            const synthetic = { ...parsed.ast, imports: parsed.ast.imports.filter(item => item.sourceKind === 'javascript'), declarations: [...importedDeclarations, ...parsed.ast.declarations] };
+            const semantic = checkModule(synthetic, { signatureOnlyNodeIds: signatureOnly, typeOnlyNodeIds, platform: config.platform, moduleId: moduleIdentity(root, path), containingFile: path, ...(jsInteropProvider === undefined ? {} : { jsInteropProvider }) });
+            mutableStats.checkedModules++;
+            const inSourceDirectory = isWithin(resolve(root, config.sourceDir), path);
+            if (!semantic.diagnostics.hasErrors && component !== undefined && inSourceDirectory) {
+                validateFrontendComponentEmissionBoundary(parsed.ast, semantic, semantic.diagnostics);
+            }
+            if (!semantic.diagnostics.hasErrors && identityRepetitions.length > 0 && inSourceDirectory && repetitionHostLocator.status !== 'ready') {
+                const message = repetitionHostLocator.status === 'none'
+                    ? 'Identity-bearing View repetition requires exactly one project @repetitionHost locator'
+                    : 'Identity-bearing View repetition cannot emit while the project @repetitionHost locator is ambiguous';
+                for (const repetition of identityRepetitions)
+                    semantic.diagnostics.error('L2135', message, repetition.span);
+            }
+            const repetitionHostValidation = identityRepetitions.length > 0 && inSourceDirectory && repetitionHostLocator.status === 'ready'
+                ? {
+                    moduleSpecifier: rebaseRepetitionHostModuleSpecifierForValidation(repetitionHostLocator.locator, path),
+                    exportName: repetitionHostLocator.locator.exportName,
+                }
+                : undefined;
+            if (!semantic.diagnostics.hasErrors && repetitionHostValidation !== undefined) {
+                const accepted = validateRepetitionHostTypeScriptUsage({
+                    containingFile: path,
+                    platform: config.platform,
+                    ...repetitionHostValidation,
+                    ...(jsInteropProvider === undefined ? {} : { jsInteropProvider }),
+                });
+                if (!accepted) {
+                    for (const repetition of identityRepetitions)
+                        semantic.diagnostics.error('L2136', 'TypeScript whole-usage validation rejected the project @repetitionHost export', repetition.span);
+                }
+            }
+            if (!semantic.diagnostics.hasErrors) {
+                validateFrontendJsxUsage(parsed.ast, semantic, {
+                    containingFile: path,
+                    platform: config.platform,
+                    ...(jsInteropProvider === undefined ? {} : { jsInteropProvider }),
+                    ...(repetitionHostValidation === undefined ? {} : { repetitionHost: repetitionHostValidation }),
+                });
+            }
+            const diagnostics = [...parsed.diagnostics, ...semantic.diagnostics.items];
+            let output;
+            let outputPath;
+            if (!diagnostics.some(item => item.severity === 'error') && inSourceDirectory) {
+                const relativePath = relative(resolve(root, config.sourceDir), path);
+                outputPath = resolve(root, config.outDir, relativePath.replace(/\.virune$/u, component === undefined ? '.js' : '.jsx'));
+                const emissionModule = { ...parsed.ast, imports: emissionImports };
+                const repetitionHost = identityRepetitions.length > 0 && repetitionHostLocator.status === 'ready'
+                    ? { moduleSpecifier: rebaseRepetitionHostModuleSpecifier(repetitionHostLocator.locator, outputPath, root, config), exportName: repetitionHostLocator.locator.exportName }
+                    : undefined;
+                output = emitJavaScript(lowerToHir(emissionModule, semantic), parsed.source, outputPath, {
+                    sourceMap: config.sourceMap,
+                    sourcesContent: config.sourcesContent,
+                    sourcePath: relative(root, path).replaceAll('\\', '/'),
+                    ...(repetitionHost === undefined ? {} : { repetitionHost }),
+                });
+                mutableStats.emittedModules++;
+                if (write)
+                    await writeEmitOutput(outputPath, output, config.sourceMap);
+            }
+            built = { ...parsed, semantic, ...(output === undefined ? {} : { output }), ...(outputPath === undefined ? {} : { outputPath }), diagnostics };
+        }
+        runtimeDependencies.set(built, moduleRuntimeDependencies);
+        builtByPath.set(path, built);
+        cache?.set(path, { sourceHash: sourceHashes.get(path), parsed, interfaceHash: interfaceHashes.get(path) ?? '', buildFingerprint, built });
+    }
+    const modules = order.map(path => builtByPath.get(path) ?? parsedByPath.get(path)).filter((item) => item !== undefined);
+    const diagnostics = [...projectDiagnostics.items, ...modules.flatMap(item => item.diagnostics)];
+    mutableStats.invalidatedModules = cache?.prune(new Set(order)) ?? 0;
+    return { root, config, modules, diagnostics, stats: mutableStats };
+}
+function contentHash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function fingerprintRepetitionHostResolution(resolution) {
+    if (resolution.status === 'none')
+        return contentHash('none');
+    const locatorKey = (locator) => `${locator.declarationFile}\u0000${locator.module}\u0000${locator.exportName}\u0000${locator.protocolVersion}`;
+    if (resolution.status === 'ready')
+        return contentHash(`ready\u0000${locatorKey(resolution.locator)}`);
+    return contentHash(`ambiguous\u0000${resolution.locators.map(locatorKey).sort().join('\u0001')}`);
+}
+function rebaseRepetitionHostModuleSpecifier(locator, outputPath, root, config) {
+    if (!locator.module.startsWith('.'))
+        return locator.module;
+    const absoluteTarget = resolve(dirname(locator.declarationFile), locator.module);
+    const sourceRoot = resolve(root, config.sourceDir);
+    const emittedTarget = isWithin(sourceRoot, absoluteTarget)
+        ? resolve(root, config.outDir, relative(sourceRoot, absoluteTarget))
+        : absoluteTarget;
+    const rebased = relative(dirname(outputPath), emittedTarget).replaceAll('\\', '/');
+    return rebased.startsWith('.') ? rebased : `./${rebased}`;
+}
+function rebaseRepetitionHostModuleSpecifierForValidation(locator, containingFile) {
+    if (!locator.module.startsWith('.'))
+        return locator.module;
+    const absoluteTarget = resolve(dirname(locator.declarationFile), locator.module);
+    const rebased = relative(dirname(containingFile), absoluteTarget).replaceAll('\\', '/');
+    return rebased.startsWith('.') ? rebased : `./${rebased}`;
+}
+function moduleInterfaceHash(moduleInterface) {
+    if (moduleInterface === undefined)
+        return contentHash('missing');
+    const entries = [...moduleInterface.exports.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, entry]) => ({ name, visibility: entry.visibility, originPath: entry.originPath, declaration: canonicalAst(publicSignatureAst(entry.declaration)) }));
+    return contentHash(JSON.stringify(entries));
+}
+function publicSignatureAst(declaration) {
+    switch (declaration.kind) {
+        case 'FunctionDeclaration': {
+            const { body: _body, expressionBody: _expressionBody, attributes, ...signature } = declaration;
+            return attributes.some(attribute => attribute.name === 'jsExport') ? { ...signature, jsExport: true } : signature;
+        }
+        case 'ComponentDeclaration': {
+            const { body: _body, attributes: _attributes, ...signature } = declaration;
+            return signature;
+        }
+        case 'TopLevelLetDeclaration': {
+            const { value: _value, attributes: _attributes, ...signature } = declaration;
+            return signature;
+        }
+        case 'RecordDeclaration':
+        case 'NewtypeDeclaration':
+            return declaration;
+        default: {
+            const { attributes: _attributes, ...signature } = declaration;
+            return signature;
+        }
+    }
+}
+function canonicalAst(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalAst);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const result = {};
+    for (const [key, child] of Object.entries(value).sort(([left], [right]) => left.localeCompare(right))) {
+        if (['id', 'span', 'documentation', 'symbolId', 'inferredTypeId', 'resolvedTypeId'].includes(key))
+            continue;
+        result[key] = canonicalAst(child);
+    }
+    return result;
+}
+async function writeEmitOutput(outputPath, output, sourceMap) {
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, output.code, 'utf8');
+    if (sourceMap)
+        await writeFile(`${outputPath}.map`, output.map, 'utf8');
+}
+/**
+ * Validate the executable entry point without making library builds depend on
+ * the presence of `main`. The CLI invokes this only for `virune run`.
+ */
+export function validateEntryPoint(module) {
+    const diagnostics = new DiagnosticBag();
+    const moduleSpan = module.ast?.span ?? spanAt(module.source.id, 0, 1, 1, 1);
+    if (module.ast === undefined || module.semantic === undefined) {
+        diagnostics.error('L5010', 'Entry module could not be analyzed', moduleSpan);
+        return { diagnostics: diagnostics.items };
+    }
+    const namedMain = module.ast.declarations.find(declaration => 'name' in declaration && declaration.name === 'main');
+    if (namedMain === undefined || namedMain.kind !== 'FunctionDeclaration') {
+        diagnostics.error('L5011', 'Entry module must declare pub fn main', namedMain?.span ?? moduleSpan);
+        return { diagnostics: diagnostics.items };
+    }
+    if (!namedMain.public)
+        diagnostics.error('L5012', 'Entry function main must be public', namedMain.span);
+    if (namedMain.typeParameters.length > 0)
+        diagnostics.error('L5013', 'Entry function main cannot be generic', namedMain.span);
+    if (namedMain.parameters.length > 1) {
+        diagnostics.error('L5014', 'Entry function main accepts zero parameters or one List<String> parameter', namedMain.span);
+    }
+    else if (namedMain.parameters.length === 1) {
+        const parameter = namedMain.parameters[0];
+        const typeId = parameter.type.resolvedTypeId;
+        const type = typeId === undefined ? undefined : module.semantic.arena.get(typeId);
+        const valid = type?.kind === 'list' && module.semantic.arena.equals(type.element, module.semantic.arena.string);
+        if (!valid)
+            diagnostics.error('L5015', 'Entry function main parameter must be List<String>', parameter.span);
+    }
+    const returnTypeId = namedMain.inferredTypeId;
+    const returnType = returnTypeId === undefined ? undefined : module.semantic.arena.get(returnTypeId);
+    const validReturn = returnTypeId !== undefined && (module.semantic.arena.equals(returnTypeId, module.semantic.arena.unit)
+        || (returnType?.kind === 'result' && module.semantic.arena.equals(returnType.value, module.semantic.arena.unit)));
+    if (!validReturn)
+        diagnostics.error('L5016', 'Entry function main must return Unit or Result<Unit, E>', namedMain.returnType?.span ?? namedMain.span);
+    return diagnostics.hasErrors ? { diagnostics: diagnostics.items } : { main: namedMain, diagnostics: diagnostics.items };
+}
+async function resolveImport(projectRoot, importer, specifier, host) {
+    if (specifier.startsWith('.')) {
+        if (extname(specifier) !== '.virune')
+            return undefined;
+        return resolve(dirname(importer), specifier);
+    }
+    const segments = specifier.split('/');
+    const packageName = specifier.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];
+    const subpathSegments = specifier.startsWith('@') ? segments.slice(2) : segments.slice(1);
+    const exportKey = subpathSegments.length === 0 ? '.' : `./${subpathSegments.join('/')}`;
+    const packageRoot = join(projectRoot, 'node_modules', packageName);
+    try {
+        const packageJson = JSON.parse(await host.readFile(join(packageRoot, 'package.json')));
+        if (exportKey === '.' && typeof packageJson.virune === 'string')
+            return resolve(packageRoot, packageJson.virune);
+        const target = resolveViruneExport(packageJson.exports, exportKey);
+        return target === undefined ? undefined : resolve(packageRoot, target);
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveViruneExport(exportsValue, key) {
+    if (typeof exportsValue === 'string')
+        return key === '.' ? undefined : undefined;
+    if (exportsValue === null || typeof exportsValue !== 'object' || Array.isArray(exportsValue))
+        return undefined;
+    const record = exportsValue;
+    const selected = Object.keys(record).some(item => item.startsWith('.')) ? record[key] : key === '.' ? exportsValue : undefined;
+    if (typeof selected === 'string')
+        return undefined;
+    if (selected === null || typeof selected !== 'object' || Array.isArray(selected))
+        return undefined;
+    const virune = selected.virune;
+    return typeof virune === 'string' ? virune : undefined;
+}
+function isWithin(parent, child) {
+    const value = relative(parent, child);
+    return value === '' || (!value.startsWith('..') && !isAbsolute(value));
+}
+function modulePackageScope(root, path) {
+    const normalizedRoot = resolve(root);
+    const normalizedPath = resolve(path);
+    if (!isWithin(normalizedRoot, normalizedPath))
+        return undefined;
+    const segments = relative(normalizedRoot, normalizedPath).replaceAll('\\', '/').split('/');
+    const nodeModulesIndex = segments.lastIndexOf('node_modules');
+    if (nodeModulesIndex < 0)
+        return 'project';
+    const first = segments[nodeModulesIndex + 1];
+    if (first === undefined || first.length === 0)
+        return undefined;
+    const packageEnd = first.startsWith('@') ? nodeModulesIndex + 3 : nodeModulesIndex + 2;
+    if (first.startsWith('@') && (segments[nodeModulesIndex + 2]?.length ?? 0) === 0)
+        return undefined;
+    return `package:${segments.slice(0, packageEnd).join('/')}`;
+}
+function samePackageScope(root, left, right) {
+    const leftScope = modulePackageScope(root, left);
+    return leftScope !== undefined && leftScope === modulePackageScope(root, right);
+}
+function validateModulePolicy(root, config, path, module, diagnostics) {
+    const sourceRelative = relative(resolve(root, config.sourceDir), path).replaceAll('\\', '/');
+    const inFfiDirectory = sourceRelative === 'ffi' || sourceRelative.startsWith('ffi/');
+    for (const declaration of module.imports) {
+        if (declaration.internal === true)
+            diagnostics.error('L4019', '`internal` is a declaration visibility modifier and cannot be applied to imports', declaration.span);
+    }
+    for (const declaration of module.declarations) {
+        if (declaration.kind !== 'ExternDeclaration')
+            continue;
+        if (declaration.module.startsWith('node:') && config.platform !== 'node')
+            diagnostics.error('L4006', `Node.js module ${declaration.module} is not available for platform ${config.platform}`, declaration.span);
+        if (declaration.unsafe && !module.unsafe)
+            diagnostics.error('L4007', 'unsafe extern requires an unsafe module declaration', declaration.span);
+        if (declaration.unsafe && !inFfiDirectory)
+            diagnostics.error('L4008', 'unsafe extern is allowed only under the source ffi/ directory', declaration.span);
+    }
+    if (module.unsafe && !inFfiDirectory)
+        diagnostics.error('L4009', 'unsafe module is allowed only under the source ffi/ directory', module.span);
+}
+function declarationHasRuntimeExport(declaration) {
+    return declaration.kind === 'FunctionDeclaration' || declaration.kind === 'ComponentDeclaration' || declaration.kind === 'RecordDeclaration' || declaration.kind === 'EnumDeclaration' || declaration.kind === 'NewtypeDeclaration' || (declaration.kind === 'TopLevelLetDeclaration' && (declaration.public || declaration.internal === true));
+}
+function exportVisibleTo(root, importerPath, entry) {
+    return entry.visibility === 'public' || samePackageScope(root, importerPath, entry.originPath);
+}
+async function buildModuleInterfaces(root, order, parsedByPath, diagnostics, host) {
+    const interfaces = new Map();
+    for (const path of order) {
+        const module = parsedByPath.get(path)?.ast;
+        if (module === undefined)
+            continue;
+        const exports = new Map();
+        for (const declaration of module.declarations) {
+            if (!('name' in declaration) || !('public' in declaration))
+                continue;
+            const visibility = declaration.public ? 'public' : declaration.internal === true ? 'internal' : undefined;
+            if (visibility === undefined)
+                continue;
+            exports.set(declaration.name, { declaration, originPath: path, originModule: module, visibility });
+        }
+        const importedTypeVisibilities = new Map();
+        for (const importDeclaration of module.imports.filter(item => item.sourceKind === 'virune' && item.internal !== true)) {
+            const dependencyPath = await resolveImport(root, path, importDeclaration.source, host);
+            const dependencyInterface = dependencyPath === undefined ? undefined : interfaces.get(dependencyPath);
+            if (dependencyInterface === undefined)
+                continue;
+            for (const item of importDeclaration.items) {
+                const exported = dependencyInterface.exports.get(item.imported);
+                const visible = exported !== undefined && exportVisibleTo(root, path, exported);
+                if (visible && exported !== undefined && isTypeDeclaration(exported.declaration)) {
+                    const previous = importedTypeVisibilities.get(item.local);
+                    if (previous === undefined || exported.visibility === 'internal')
+                        importedTypeVisibilities.set(item.local, exported.visibility);
+                }
+                if (!importDeclaration.public)
+                    continue;
+                if (!visible || exported === undefined) {
+                    diagnostics.error('L4004', `Module ${importDeclaration.source} does not export ${item.imported}`, item.span);
+                    continue;
+                }
+                if (exported.visibility === 'internal') {
+                    diagnostics.error('L4018', `Public import cannot re-export internal declaration ${item.imported}`, item.span);
+                    continue;
+                }
+                if (importDeclaration.typeOnly && !isTypeDeclaration(exported.declaration)) {
+                    diagnostics.error('L4015', `Type-only re-export ${item.local} must refer to a type`, item.span);
+                    continue;
+                }
+                if (exports.has(item.local)) {
+                    diagnostics.error('L4016', `Duplicate public export ${item.local}`, item.span);
+                    continue;
+                }
+                exports.set(item.local, exported);
+            }
+        }
+        validateImportedSignatureVisibility(module, importedTypeVisibilities, diagnostics);
+        interfaces.set(path, { exports });
+    }
+    return interfaces;
+}
+const builtinTypeNames = new Set([
+    'Bool', 'Int', 'Float', 'BigInt', 'String', 'Unit', 'Unknown', 'Never', 'Option', 'Result', 'List', 'Map', 'Set', 'Stream',
+    'JsError', 'JsonError', 'Duration', 'TaskTimeoutError', 'SupervisorRestartLimitError', 'HttpResponse', 'HttpBody', 'FileHandle', 'Bytes', 'MutableBytes', 'ByteOrder', 'BytesError', 'IntegerRangeError', 'Byte', 'Int8', 'UInt8', 'Int16', 'UInt16', 'Int32', 'UInt32', 'Int64', 'UInt64',
+]);
+async function buildImportModel(root, importerPath, module, parsedByPath, moduleInterfaces, diagnostics, initialId, host) {
+    let nextId = initialId;
+    const next = () => nextId--;
+    const signatureOnly = new Set();
+    const typeOnlyNodeIds = new Set();
+    const importedDeclarations = [];
+    const emissionImports = [];
+    const runtimeDependencyPaths = [];
+    const emittedTypeDefinitions = new Set();
+    for (const importDeclaration of module.imports) {
+        if (importDeclaration.internal === true)
+            continue;
+        if (importDeclaration.sourceKind === 'javascript') {
+            emissionImports.push(importDeclaration);
+            continue;
+        }
+        const dependencyPath = await resolveImport(root, importerPath, importDeclaration.source, host);
+        const dependencyInterface = dependencyPath === undefined ? undefined : moduleInterfaces.get(dependencyPath);
+        if (dependencyPath === undefined || dependencyInterface === undefined)
+            continue;
+        const runtimeItems = [];
+        const groups = new Map();
+        for (const item of importDeclaration.items) {
+            const exported = dependencyInterface.exports.get(item.imported);
+            if (exported === undefined || !exportVisibleTo(root, importerPath, exported)) {
+                diagnostics.error('L4004', `Module ${importDeclaration.source} does not export ${item.imported}`, item.span);
+                continue;
+            }
+            if (importDeclaration.public && exported.visibility === 'internal')
+                continue;
+            const group = groups.get(exported.originPath) ?? { module: exported.originModule, entries: [] };
+            group.entries.push({ item, exported });
+            groups.set(exported.originPath, group);
+            if (!importDeclaration.typeOnly && declarationHasRuntimeExport(exported.declaration))
+                runtimeItems.push(item);
+        }
+        for (const [originPath, group] of groups) {
+            const explicitAliases = new Map();
+            const roots = new Set();
+            const valueImports = [];
+            for (const entry of group.entries) {
+                const declaration = entry.exported.declaration;
+                if (isTypeDeclaration(declaration)) {
+                    const previous = explicitAliases.get(declaration.name);
+                    if (previous !== undefined && previous !== entry.item.local)
+                        diagnostics.error('L4012', `Type ${declaration.name} cannot be imported under multiple local names`, entry.item.span);
+                    else
+                        explicitAliases.set(declaration.name, entry.item.local);
+                    roots.add(declaration.name);
+                }
+                else
+                    valueImports.push({ declaration, localName: entry.item.local });
+                for (const name of referencedTypeNames(declaration))
+                    if (!builtinTypeNames.has(name))
+                        roots.add(name);
+            }
+            const requiredTypes = collectTypeClosure(group.module, roots, diagnostics, importDeclaration.span);
+            const rename = new Map();
+            for (const name of requiredTypes)
+                rename.set(name, explicitAliases.get(name) ?? hiddenImportName(root, originPath, name));
+            for (const name of requiredTypes) {
+                const declaration = group.module.declarations.find(candidate => isTypeDeclaration(candidate) && candidate.name === name);
+                if (declaration === undefined || !isTypeDeclaration(declaration))
+                    continue;
+                const definitionId = `${moduleIdentity(root, originPath)}#${name}`;
+                const emittedKey = `${definitionId}:${rename.get(name)}`;
+                if (emittedTypeDefinitions.has(emittedKey))
+                    continue;
+                emittedTypeDefinitions.add(emittedKey);
+                const clone = cloneTypeSignature(declaration, rename.get(name), definitionId, rename, next);
+                signatureOnly.add(clone.id);
+                if (!explicitAliases.has(name) || importDeclaration.typeOnly)
+                    typeOnlyNodeIds.add(clone.id);
+                importedDeclarations.push(clone);
+            }
+            for (const valueImport of valueImports) {
+                const clone = cloneValueSignature(valueImport.declaration, valueImport.localName, rename, next);
+                signatureOnly.add(clone.id);
+                if (importDeclaration.typeOnly)
+                    typeOnlyNodeIds.add(clone.id);
+                importedDeclarations.push(clone);
+            }
+        }
+        if (runtimeItems.length > 0) {
+            const componentDependency = parsedByPath.get(dependencyPath)?.ast?.declarations.some(declaration => declaration.kind === 'ComponentDeclaration') === true;
+            const source = componentDependency && importDeclaration.source.endsWith('.virune') ? `${importDeclaration.source.slice(0, -7)}.jsx` : importDeclaration.source;
+            emissionImports.push({ ...importDeclaration, source, items: runtimeItems });
+            if (importDeclaration.source.endsWith('.virune') && !runtimeDependencyPaths.includes(dependencyPath))
+                runtimeDependencyPaths.push(dependencyPath);
+        }
+    }
+    return { signatureOnly, typeOnlyNodeIds, importedDeclarations, emissionImports, runtimeDependencies: Object.freeze(runtimeDependencyPaths), nextId };
+}
+function isTypeDeclaration(declaration) {
+    return declaration.kind === 'RecordDeclaration' || declaration.kind === 'EnumDeclaration' || declaration.kind === 'NewtypeDeclaration' || declaration.kind === 'TypeAliasDeclaration';
+}
+function collectTypeClosure(module, roots, diagnostics, span) {
+    const declarations = new Map(module.declarations.filter(isTypeDeclaration).map(declaration => [declaration.name, declaration]));
+    const result = new Set();
+    const visit = (name) => {
+        if (builtinTypeNames.has(name) || result.has(name))
+            return;
+        const declaration = declarations.get(name);
+        if (declaration === undefined) {
+            diagnostics.error('L4011', `Public signature refers to imported or unavailable type ${name}; re-exported signature types are not supported in Virune 1.0`, span);
+            return;
+        }
+        result.add(name);
+        for (const dependency of referencedTypeNames(declaration))
+            visit(dependency);
+    };
+    for (const root of roots)
+        visit(root);
+    return result;
+}
+function referencedTypeNames(declaration) {
+    const result = new Set();
+    const addReference = (reference, typeParameters) => {
+        if (reference.functionType !== undefined) {
+            for (const parameter of reference.functionType.parameters)
+                addReference(parameter, typeParameters);
+            addReference(reference.functionType.result, typeParameters);
+            return;
+        }
+        if (!typeParameters.has(reference.name))
+            result.add(reference.name);
+        for (const argument of reference.arguments)
+            addReference(argument, typeParameters);
+    };
+    if (declaration.kind === 'FunctionDeclaration') {
+        const parameters = new Set(declaration.typeParameters.map(item => item.name));
+        for (const parameter of declaration.parameters)
+            addReference(parameter.type, parameters);
+        if (declaration.returnType !== undefined)
+            addReference(declaration.returnType, parameters);
+    }
+    else if (declaration.kind === 'ComponentDeclaration') {
+        for (const parameter of declaration.parameters)
+            addReference(parameter.type, new Set());
+    }
+    else if (declaration.kind === 'RecordDeclaration') {
+        const parameters = new Set(declaration.typeParameters.map(item => item.name));
+        for (const field of declaration.fields)
+            addReference(field.type, parameters);
+    }
+    else if (declaration.kind === 'EnumDeclaration') {
+        const parameters = new Set(declaration.typeParameters.map(item => item.name));
+        for (const variant of declaration.variants)
+            for (const value of variant.values)
+                addReference(value, parameters);
+    }
+    else if (declaration.kind === 'NewtypeDeclaration')
+        addReference(declaration.underlying, new Set());
+    else if (declaration.kind === 'TypeAliasDeclaration')
+        addReference(declaration.target, new Set(declaration.typeParameters.map(item => item.name)));
+    else if (declaration.kind === 'TopLevelLetDeclaration' && declaration.annotation !== undefined)
+        addReference(declaration.annotation, new Set());
+    return result;
+}
+function cloneValueSignature(declaration, localName, rename, next) {
+    if (declaration.kind === 'TopLevelLetDeclaration') {
+        const id = next();
+        return {
+            ...declaration,
+            id,
+            name: localName,
+            public: false,
+            attributes: [],
+            ...(declaration.annotation === undefined ? {} : { annotation: cloneTypeReference(declaration.annotation, rename, next) }),
+            value: { id: next(), kind: 'LiteralExpression', span: declaration.span, literalKind: 'Bool', value: false },
+        };
+    }
+    if (declaration.kind === 'ComponentDeclaration') {
+        return {
+            ...declaration,
+            id: next(),
+            name: localName,
+            public: false,
+            attributes: [],
+            parameters: declaration.parameters.map(parameter => ({ ...parameter, type: cloneTypeReference(parameter.type, rename, next) })),
+            effects: declaration.effects,
+            body: { id: next(), kind: 'BlockStatement', span: declaration.span, statements: [] },
+        };
+    }
+    if (declaration.kind !== 'FunctionDeclaration')
+        throw new Error(`Declaration ${declaration.kind} cannot be imported as a value signature`);
+    const id = next();
+    return {
+        ...declaration,
+        id,
+        name: localName,
+        public: false,
+        attributes: declaration.attributes.filter(attribute => attribute.name === 'jsExport'),
+        parameters: declaration.parameters.map(parameter => ({ ...parameter, type: cloneTypeReference(parameter.type, rename, next) })),
+        ...(declaration.returnType === undefined ? {} : { returnType: cloneTypeReference(declaration.returnType, rename, next) }),
+        effects: declaration.effects,
+        body: { id: next(), kind: 'LiteralExpression', span: declaration.span, literalKind: 'Bool', value: false },
+        expressionBody: true,
+    };
+}
+function cloneTypeSignature(declaration, localName, definitionId, rename, next) {
+    const id = next();
+    switch (declaration.kind) {
+        case 'RecordDeclaration': return { ...declaration, id, name: localName, definitionId, public: false, attributes: declaration.attributes, fields: declaration.fields.map(field => ({ ...field, type: cloneTypeReference(field.type, rename, next), attributes: field.attributes })) };
+        case 'EnumDeclaration': return { ...declaration, id, name: localName, definitionId, public: false, attributes: [], variants: declaration.variants.map(variant => ({ ...variant, values: variant.values.map(value => cloneTypeReference(value, rename, next)) })) };
+        case 'NewtypeDeclaration': return { ...declaration, id, name: localName, definitionId, public: false, attributes: declaration.attributes, underlying: cloneTypeReference(declaration.underlying, rename, next) };
+        case 'TypeAliasDeclaration': return { ...declaration, id, name: localName, definitionId, public: false, attributes: [], target: cloneTypeReference(declaration.target, rename, next) };
+    }
+}
+function cloneTypeReference(reference, rename, next) {
+    return {
+        id: next(), kind: 'TypeReference', span: reference.span, name: rename.get(reference.name) ?? reference.name,
+        arguments: reference.arguments.map(argument => cloneTypeReference(argument, rename, next)), optional: reference.optional,
+        ...(reference.functionType === undefined ? {} : { functionType: {
+                async: reference.functionType.async,
+                parameters: reference.functionType.parameters.map(parameter => cloneTypeReference(parameter, rename, next)),
+                result: cloneTypeReference(reference.functionType.result, rename, next),
+                effects: reference.functionType.effects,
+            } }),
+    };
+}
+function hiddenImportName(root, dependencyPath, name) {
+    const hash = createHash('sha256').update(moduleIdentity(root, dependencyPath)).digest('hex').slice(0, 10);
+    return `$import_${hash}_${name}`;
+}
+function moduleIdentity(root, path) {
+    const relativePath = relative(root, path).replaceAll('\\', '/');
+    return relativePath.startsWith('../') ? `external:${createHash('sha256').update(path).digest('hex').slice(0, 16)}` : `project:${relativePath}`;
+}
+function declarationVisibilityRank(declaration) {
+    return 'public' in declaration && declaration.public ? 2 : 'internal' in declaration && declaration.internal === true ? 1 : 0;
+}
+function validateSignatureVisibility(module, diagnostics) {
+    const localTypes = new Map(module.declarations.filter(isTypeDeclaration).map(declaration => [declaration.name, declaration]));
+    for (const declaration of module.declarations) {
+        const rank = declarationVisibilityRank(declaration);
+        if (rank === 0 || declaration.kind === 'NewtypeDeclaration' || !('name' in declaration))
+            continue;
+        for (const name of referencedTypeNames(declaration)) {
+            const local = localTypes.get(name);
+            if (local === undefined || declarationVisibilityRank(local) >= rank)
+                continue;
+            const owner = rank === 2 ? 'Public' : 'Internal';
+            const exposed = local.internal === true ? 'internal' : 'private';
+            diagnostics.error('L4010', `${owner} declaration ${declaration.name} exposes ${exposed} type ${name}`, declaration.span);
+        }
+    }
+}
+function validateImportedSignatureVisibility(module, importedTypes, diagnostics) {
+    for (const declaration of module.declarations) {
+        const rank = declarationVisibilityRank(declaration);
+        if (rank === 0 || declaration.kind === 'NewtypeDeclaration' || !('name' in declaration))
+            continue;
+        for (const name of referencedTypeNames(declaration)) {
+            const importedVisibility = importedTypes.get(name);
+            if (importedVisibility === undefined)
+                continue;
+            const importedRank = importedVisibility === 'public' ? 2 : 1;
+            if (importedRank >= rank)
+                continue;
+            const owner = rank === 2 ? 'Public' : 'Internal';
+            diagnostics.error('L4010', `${owner} declaration ${declaration.name} exposes internal type ${name}`, declaration.span);
+        }
+    }
+}
+function finitePosition(value, fallback) {
+    return value !== undefined && Number.isFinite(value) ? value : fallback;
+}
+function lineAt(text, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index++)
+        if (text[index] === '\n')
+            line++;
+    return line;
+}
+function columnAt(text, offset) {
+    return offset - text.lastIndexOf('\n', Math.max(0, offset - 1));
+}
+function spanAt(fileId, offset, length, line, column) {
+    return { fileId, start: { offset, line, column }, end: { offset: offset + length, line, column: column + length } };
+}
+//# sourceMappingURL=project.js.map