@flighthq/tool-compiler 0.5.1-edge.1687.b63c819

package/dist/packages/compiler-orchestration/src/compilerPackageCompilation.js

@@ -0,0 +1,745 @@
+import { compareTextCodeUnits, normalizePathPortable } from '../../compiler-canonical-form/src/index.js';
+import { createCompilerInvariantFailure, isBackendEmissionFailure, isCompilerInvariantFailure, normalizeEmittedFile, validateCompilerEmittedSourceSyntax, validateCompilerTargetCompilationSmoke, } from '../../compiler-emission/src/index.js';
+import { isCompilerLoweringFailure } from '../../compiler-lowering/src/index.js';
+import { createCompilerModuleFacadePlanForEntries, createCompilerModuleEvaluationPlan, isCompilerModuleEvaluationFailure, } from '../../compiler-module/src/index.js';
+import { applySemanticPatchSet } from '../../compiler-patch/src/index.js';
+import { createCompilerTypeScriptAnalysisIdentity, lowerTypeScriptSources } from '../../compiler-semantic/src/index.js';
+export function compileTypeScriptPackageGraph(options) {
+    const packages = validateCompilerPackageGraphPackages(options.graph, options.sources);
+    const semanticResolution = createCompilerPackageGraphModuleResolution(options.graph.moduleDependencies, options.moduleResolution);
+    const lowered = lowerTypeScriptSources(options.sources.map(({ packageRoot: _packageRoot, ...source }) => source), semanticResolution);
+    validateCompilerPackageGraphModuleIdentities(lowered.map((result) => result.module));
+    validateCompilerPackageGraphReferences(options.graph.entries, options.graph.moduleDependencies, lowered, packages);
+    const patched = applySemanticPatchSet(lowered.map((result) => result.module), options.patches ?? [], options.backend.name);
+    const modules = [...patched.modules].sort(compareCompilerPackageGraphModules);
+    const graphEntries = options.graph.entries.length > 0
+        ? options.graph.entries
+        : modules.map(cloneCompilerPackageGraphIdentity).sort(compareCompilerPackageGraphModules);
+    const moduleDependencies = createCompilerPackageGraphModuleDependencies(modules, options.graph.moduleDependencies, packages, options.moduleResolution);
+    validateCompilerPackageGraphReferences(graphEntries, moduleDependencies, lowered, packages);
+    const records = new Map(modules.map((module) => [
+        getCompilerPackageGraphModuleKey(module),
+        { files: [], module, refusals: [] },
+    ]));
+    const diagnostics = lowered.flatMap((result) => result.diagnostics).sort(compareCompilerPackageGraphDiagnostics);
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.severity !== 'error')
+            continue;
+        const record = [...records.values()].find((candidate) => candidate.module.packageName === diagnostic.packageName && candidate.module.source === diagnostic.source);
+        if (!record)
+            continue;
+        record.refusals.push({
+            classification: 'compiler-restriction',
+            code: diagnostic.code,
+            ...(diagnostic.column === undefined ? {} : { column: diagnostic.column }),
+            ...(diagnostic.line === undefined ? {} : { line: diagnostic.line }),
+            message: diagnostic.message,
+            stage: 'lowering',
+        });
+    }
+    propagateCompilerPackageGraphRefusals(records, moduleDependencies);
+    const emissionModules = modules.filter((module) => records.get(getCompilerPackageGraphModuleKey(module)).refusals.length === 0);
+    const moduleResolution = createCompilerPackageGraphModuleResolution(moduleDependencies, options.moduleResolution);
+    const emitContext = {
+        moduleResolution,
+        modules: emissionModules,
+        options: options.backendOptions,
+    };
+    const emissionSession = options.backend.createEmissionSession?.(emitContext);
+    for (const module of emissionModules) {
+        const record = records.get(getCompilerPackageGraphModuleKey(module));
+        try {
+            record.files.push(...(emissionSession ? emissionSession.emitModule(module) : options.backend.emitModule(module, emitContext)).map(normalizeEmittedFile));
+        }
+        catch (error) {
+            record.refusals.push(createCompilerPackageGraphEmissionRefusal(error));
+        }
+    }
+    refuseCompilerPackageGraphOutputCollisions(records);
+    propagateCompilerPackageGraphRefusals(records, moduleDependencies);
+    const initialization = createCompilerPackageGraphInitialization(records, graphEntries, moduleDependencies);
+    propagateCompilerPackageGraphRefusals(records, moduleDependencies);
+    const refusedDependencies = createCompilerPackageGraphRefusedDependencies(records, moduleDependencies);
+    const exports = createCompilerPackageGraphExportPlan(modules, initialization);
+    const files = [...records.values()]
+        .filter((record) => record.refusals.length === 0)
+        .flatMap((record) => record.files)
+        .sort(compareCompilerPackageGraphFiles);
+    validateCompilerPackageGraphOutput(files, options);
+    const moduleReports = createCompilerPackageGraphModuleReports(records, refusedDependencies);
+    const fileReports = createCompilerPackageGraphFileReports(records);
+    return {
+        compilation: { backend: options.backend.name, files },
+        diagnostics,
+        patchAudit: patched.audit,
+        report: {
+            backend: options.backend.name,
+            entries: graphEntries.map(cloneCompilerPackageGraphIdentity).sort(compareCompilerPackageGraphModules),
+            exports,
+            files: fileReports,
+            initialization,
+            modules: moduleReports,
+            packages: [...packages.values()].sort(compareCompilerPackageGraphPackages).map((package_) => {
+                const packageModules = moduleReports.filter((report) => report.module.packageName === package_.name);
+                return {
+                    dependencies: [...package_.dependencies].sort(compareTextCodeUnits),
+                    modules: packageModules,
+                    name: package_.name,
+                    outputFiles: packageModules.flatMap((module) => module.outputFiles).sort(compareTextCodeUnits),
+                };
+            }),
+            ...(options.backend.runtimeAbi ? { runtimeAbi: options.backend.runtimeAbi() } : {}),
+            schema: 'flight-compiler-package-report/1',
+            typescript: createCompilerTypeScriptAnalysisIdentity(),
+        },
+    };
+}
+function createCompilerPackageGraphExportPlan(modules, initialization) {
+    const available = new Set(initialization.modules.map(({ module }) => getCompilerPackageGraphModuleKey(module)));
+    const facadeModules = modules
+        .filter((module) => available.has(getCompilerPackageGraphModuleKey(module)))
+        .map((module) => ({
+        ...module,
+        exports: [...new Map(module.exports.map((exported) => [JSON.stringify(exported), exported])).values()],
+    }));
+    return createCompilerModuleFacadePlanForEntries({ evaluation: initialization, modules: facadeModules }, initialization.entries);
+}
+export function isCompilerPackageGraphFailure(value) {
+    return (value instanceof Error &&
+        'kind' in value &&
+        value.kind === 'compiler-package-graph' &&
+        'code' in value &&
+        compilerPackageGraphFailureCodes.has(value.code) &&
+        'subject' in value &&
+        typeof value.subject === 'string' &&
+        value.subject.length > 0);
+}
+function cloneCompilerPackageGraphIdentity(identity) {
+    return { name: identity.name, packageName: identity.packageName, source: identity.source };
+}
+function compareCompilerPackageGraphDiagnostics(left, right) {
+    return (compareTextCodeUnits(left.packageName, right.packageName) ||
+        compareTextCodeUnits(left.source, right.source) ||
+        (left.line ?? 0) - (right.line ?? 0) ||
+        (left.column ?? 0) - (right.column ?? 0) ||
+        compareTextCodeUnits(left.code, right.code) ||
+        compareTextCodeUnits(left.message, right.message));
+}
+function compareCompilerPackageGraphFiles(left, right) {
+    return compareTextCodeUnits(left.path, right.path);
+}
+function compareCompilerPackageGraphModules(left, right) {
+    return (compareTextCodeUnits(left.packageName, right.packageName) ||
+        compareTextCodeUnits(left.source, right.source) ||
+        compareTextCodeUnits(left.name, right.name));
+}
+function compareCompilerPackageGraphPackages(left, right) {
+    return compareTextCodeUnits(left.name, right.name);
+}
+function compareCompilerPackageGraphRefusals(left, right) {
+    return (compareTextCodeUnits(left.stage, right.stage) ||
+        (left.line ?? 0) - (right.line ?? 0) ||
+        (left.column ?? 0) - (right.column ?? 0) ||
+        compareTextCodeUnits(left.code, right.code) ||
+        compareTextCodeUnits(left.message, right.message));
+}
+function createCompilerPackageGraphEmissionRefusal(error) {
+    if (isBackendEmissionFailure(error)) {
+        return {
+            ...(error.classification === undefined ? {} : { classification: error.classification }),
+            code: error.code,
+            ...(error.column === undefined ? {} : { column: error.column }),
+            ...(error.line === undefined ? {} : { line: error.line }),
+            message: error.message,
+            ...(error.rule === undefined ? {} : { rule: error.rule }),
+            stage: 'emission',
+        };
+    }
+    if (isCompilerLoweringFailure(error) && error.code === 'unsupported-ir') {
+        return {
+            classification: 'compiler-restriction',
+            code: error.code,
+            message: error.message,
+            stage: 'emission',
+        };
+    }
+    if (isCompilerInvariantFailure(error)) {
+        return {
+            ...(compilerDefectEmissionCodes.has(error.code) ? { classification: 'compiler-defect' } : {}),
+            code: error.code,
+            message: error.message,
+            stage: 'emission',
+        };
+    }
+    if (error instanceof Error) {
+        return { code: 'internal-error', message: error.message, stage: 'emission' };
+    }
+    throw error;
+}
+function createCompilerPackageGraphFailure(code, subject, message) {
+    const failure = Object.assign(new Error(message), { code, kind: 'compiler-package-graph', subject });
+    failure.name = 'CompilerPackageGraphError';
+    return failure;
+}
+function createCompilerPackageGraphFileReports(records) {
+    return [...records.values()]
+        .filter((record) => record.refusals.length === 0)
+        .flatMap((record) => record.files.map((file) => ({
+        dependencies: [...(file.dependencies ?? [])],
+        module: cloneCompilerPackageGraphIdentity(record.module),
+        path: file.path,
+    })))
+        .sort((left, right) => compareTextCodeUnits(left.path, right.path));
+}
+function createCompilerPackageGraphInitialization(records, entries, dependencies) {
+    for (;;) {
+        const availableKeys = new Set([...records].filter(([, record]) => record.refusals.length === 0).map(([key]) => key));
+        const availableEntries = entries.filter((entry) => availableKeys.has(getCompilerPackageGraphModuleKey(entry)));
+        const reachableKeys = collectCompilerPackageGraphReachableKeys(availableEntries, dependencies, availableKeys);
+        const reachableModules = [...records]
+            .filter(([key]) => reachableKeys.has(key))
+            .map(([, record]) => record.module)
+            .sort(compareCompilerPackageGraphModules);
+        const reachableDependencies = dependencies.filter((dependency) => reachableKeys.has(getCompilerPackageGraphModuleKey(dependency.importer)) &&
+            reachableKeys.has(getCompilerPackageGraphModuleKey(dependency.target)));
+        try {
+            return createCompilerModuleEvaluationPlan({
+                dependencies: reachableDependencies,
+                entries: availableEntries.map(cloneCompilerPackageGraphIdentity).sort(compareCompilerPackageGraphModules),
+                modules: reachableModules,
+            });
+        }
+        catch (error) {
+            if (!isCompilerModuleEvaluationFailure(error) || !error.module)
+                throw error;
+            const record = records.get(getCompilerPackageGraphModuleKey(error.module));
+            if (!record || record.refusals.length > 0)
+                throw error;
+            record.refusals.push({
+                ...(compilerRestrictionInitializationCodes.has(error.code)
+                    ? { classification: 'compiler-restriction' }
+                    : {}),
+                code: error.code,
+                message: error.message,
+                stage: 'initialization',
+            });
+            record.files.splice(0);
+            propagateCompilerPackageGraphRefusals(records, dependencies);
+        }
+    }
+}
+function createCompilerPackageGraphModuleReports(records, refusedDependencies) {
+    return [...records.values()]
+        .sort((left, right) => compareCompilerPackageGraphModules(left.module, right.module))
+        .map((record) => ({
+        module: cloneCompilerPackageGraphIdentity(record.module),
+        outputFiles: record.refusals.length === 0 ? record.files.map((file) => file.path).sort(compareTextCodeUnits) : [],
+        refusals: [...record.refusals]
+            .sort(compareCompilerPackageGraphRefusals)
+            .map((refusal) => attachCompilerPackageGraphRefusedDependencies(refusal, refusedDependencies.get(getCompilerPackageGraphModuleKey(record.module)))),
+        status: record.refusals.length === 0 ? 'emitted' : 'refused',
+    }));
+}
+function attachCompilerPackageGraphRefusedDependencies(refusal, refusedDependencies) {
+    if (refusal.code !== 'dependency-refused' || refusedDependencies === undefined)
+        return refusal;
+    return { ...refusal, refusedDependencies };
+}
+// Every refused dependency that blocked a refused module.
+//
+// The propagation fixed point stops at the first refused edge it reaches for a module, because one
+// `dependency-refused` record is what makes the module refused. That is enough to decide the
+// outcome and not enough to plan against: a module held back by three refused dependencies is
+// attributed to whichever edge the sorted scan happened to reach first, so a ranking built on those
+// records ranks dependency order and reads as a ranking of causes.
+//
+// This records the complete edge set instead, which is what lets a consumer ask the question the
+// ranking actually needs - which modules would emit if this rule were closed - rather than a guess
+// at it. It reads the records rather than mutating them, so replaying it is free.
+function createCompilerPackageGraphRefusedDependencies(records, dependencies) {
+    const refusedDependencies = new Map();
+    for (const dependency of dependencies) {
+        const importer = records.get(getCompilerPackageGraphModuleKey(dependency.importer));
+        const target = records.get(getCompilerPackageGraphModuleKey(dependency.target));
+        if (!importer || !target || target.refusals.length === 0)
+            continue;
+        // Only a propagated refusal has refused dependencies; a module refused on its own account is
+        // refused for that reason and listing its refused neighbours would misattribute the cause.
+        if (!importer.refusals.some((refusal) => refusal.code === 'dependency-refused'))
+            continue;
+        const blocked = refusedDependencies.get(getCompilerPackageGraphModuleKey(dependency.importer)) ?? new Set();
+        blocked.add(getCompilerPackageGraphModuleSubject(dependency.target));
+        refusedDependencies.set(getCompilerPackageGraphModuleKey(dependency.importer), blocked);
+    }
+    return new Map([...refusedDependencies.entries()].map(([module, blocked]) => [module, [...blocked].sort(compareTextCodeUnits)]));
+}
+// How a refused dependency is named to a consumer. One definition, because the message and the
+// structured list have to agree on it or a reader matching one against the other sees two names.
+function getCompilerPackageGraphModuleSubject(module) {
+    return `${module.packageName}/${module.source}`;
+}
+function createCompilerPackageGraphModuleDependencies(modules, dependencies, packages, resolution) {
+    const resolveModule = createCompilerPackageGraphModuleResolver(modules, resolution);
+    const modulesByIdentity = new Map(modules.map((module) => [getCompilerPackageGraphModuleKey(module), module]));
+    const dependencyByRequest = new Map();
+    for (const dependency of dependencies) {
+        const key = `${getCompilerPackageGraphModuleKey(dependency.importer)}\0${dependency.specifier}`;
+        dependencyByRequest.set(key, [...(dependencyByRequest.get(key) ?? []), dependency]);
+    }
+    for (const module of modules) {
+        const specifiers = new Set([
+            ...module.imports.map((imported) => imported.specifier),
+            ...module.exports.flatMap((exported) => exported.kind === 'all' || exported.kind === 'namespace' || exported.kind === 'reexport'
+                ? [exported.specifier]
+                : []),
+        ]);
+        for (const specifier of specifiers) {
+            const key = `${getCompilerPackageGraphModuleKey(module)}\0${specifier}`;
+            if (dependencyByRequest.has(key))
+                continue;
+            const target = resolveModule(module, specifier);
+            if (!target)
+                continue;
+            dependencyByRequest.set(key, [
+                {
+                    importer: cloneCompilerPackageGraphIdentity(module),
+                    specifier,
+                    target: cloneCompilerPackageGraphIdentity(target),
+                },
+            ]);
+        }
+    }
+    const dependencyResolution = createCompilerPackageGraphModuleResolution([...dependencyByRequest.values()].flat(), resolution);
+    const resolveDependencyModule = createCompilerPackageGraphModuleResolver(modules, dependencyResolution);
+    const exportResolutionCache = new Map();
+    for (const module of modules) {
+        const importsBySpecifier = new Map();
+        for (const imported of module.imports) {
+            importsBySpecifier.set(imported.specifier, [...(importsBySpecifier.get(imported.specifier) ?? []), imported]);
+        }
+        for (const [specifier, imports] of importsBySpecifier) {
+            // A request that also drives a re-export, a side-effect import, or a namespace import needs
+            // the module itself. Only a set of named bindings can safely bypass a barrel.
+            if (module.exports.some((exported) => 'specifier' in exported && exported.specifier === specifier))
+                continue;
+            const bindings = imports.flatMap((imported) => imported.bindings);
+            if (bindings.length === 0 ||
+                imports.some((imported) => imported.bindings.length === 0) ||
+                bindings.some((binding) => binding.imported === '*')) {
+                continue;
+            }
+            const requestKey = `${getCompilerPackageGraphModuleKey(module)}\0${specifier}`;
+            const requestDependencies = dependencyByRequest.get(requestKey);
+            if (requestDependencies?.length !== 1 || requestDependencies[0]?.importedNames)
+                continue;
+            const dependency = requestDependencies[0];
+            const barrel = modulesByIdentity.get(getCompilerPackageGraphModuleKey(dependency.target));
+            if (!barrel)
+                continue;
+            const targets = bindings.map((binding) => resolveCompilerPackageGraphExportSource(barrel, binding.imported, resolveDependencyModule, exportResolutionCache, new Set()));
+            if (targets.some((target) => target.kind !== 'resolved'))
+                continue;
+            if (targets.some((target, index) => target.kind === 'resolved' && target.exported !== bindings[index].imported)) {
+                // A renamed re-export needs the barrel's generated alias until symbol routes also carry the
+                // final declaration name. Do not silently spell the public alias against the leaf module.
+                continue;
+            }
+            const resolvedModules = new Map(targets.flatMap((target) => target.kind === 'resolved' ? [[getCompilerPackageGraphModuleKey(target.module), target.module]] : []));
+            const importerPackage = packages.get(module.packageName);
+            if ([...resolvedModules.values()].some((target) => target.packageName !== module.packageName && !importerPackage?.dependencies.includes(target.packageName))) {
+                continue;
+            }
+            if (resolvedModules.size === 1) {
+                const target = [...resolvedModules.values()][0];
+                dependencyByRequest.set(requestKey, [
+                    {
+                        importer: cloneCompilerPackageGraphIdentity(module),
+                        specifier,
+                        target: cloneCompilerPackageGraphIdentity(target),
+                    },
+                ]);
+                continue;
+            }
+            const importedNamesByModule = new Map();
+            targets.forEach((target, index) => {
+                if (target.kind !== 'resolved')
+                    return;
+                const key = getCompilerPackageGraphModuleKey(target.module);
+                importedNamesByModule.set(key, [...(importedNamesByModule.get(key) ?? []), bindings[index].imported]);
+            });
+            dependencyByRequest.set(requestKey, [...resolvedModules]
+                .sort((left, right) => compareTextCodeUnits(left[0], right[0]))
+                .map(([key, target]) => ({
+                importer: cloneCompilerPackageGraphIdentity(module),
+                importedNames: [...new Set(importedNamesByModule.get(key) ?? [])].sort(compareTextCodeUnits),
+                specifier,
+                target: cloneCompilerPackageGraphIdentity(target),
+            })));
+        }
+    }
+    return [...dependencyByRequest.values()]
+        .flat()
+        .sort((left, right) => compareCompilerPackageGraphModules(left.importer, right.importer) ||
+        compareTextCodeUnits(left.specifier, right.specifier) ||
+        compareCompilerPackageGraphModules(left.target, right.target));
+}
+function resolveCompilerPackageGraphExportSource(module, exportName, resolveModule, cache, active) {
+    const key = `${getCompilerPackageGraphModuleKey(module)}\0${exportName}`;
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    if (active.has(key))
+        return { kind: 'absent' };
+    const nextActive = new Set(active).add(key);
+    const explicit = module.exports.filter((exported) => (exported.kind === 'default' && exportName === 'default') ||
+        (exported.kind !== 'all' && exported.kind !== 'default' && exported.exported === exportName));
+    let result;
+    if (explicit.length > 1) {
+        result = { kind: 'unknown' };
+    }
+    else if (explicit[0]?.kind === 'local') {
+        result = { exported: explicit[0].binding.name, kind: 'resolved', module };
+    }
+    else if (explicit[0]?.kind === 'default') {
+        result = { exported: 'default', kind: 'resolved', module };
+    }
+    else if (explicit[0]?.kind === 'namespace') {
+        // The namespace object is an export created by this module, not a declaration in its source
+        // module. Preserve the barrel dependency until namespace-object lowering can represent it.
+        result = { kind: 'unknown' };
+    }
+    else if (explicit[0]?.kind === 'reexport') {
+        const target = resolveModule(module, explicit[0].specifier);
+        result = target
+            ? resolveCompilerPackageGraphExportSource(target, explicit[0].imported, resolveModule, cache, nextActive)
+            : { kind: 'unknown' };
+        if (result.kind === 'absent')
+            result = { kind: 'unknown' };
+    }
+    else if (exportName === 'default') {
+        result = { kind: 'absent' };
+    }
+    else {
+        const sources = new Map();
+        let unknown = false;
+        for (const exported of module.exports) {
+            if (exported.kind !== 'all')
+                continue;
+            const target = resolveModule(module, exported.specifier);
+            if (!target) {
+                unknown = true;
+                continue;
+            }
+            const candidate = resolveCompilerPackageGraphExportSource(target, exportName, resolveModule, cache, nextActive);
+            if (candidate.kind === 'unknown')
+                unknown = true;
+            if (candidate.kind === 'resolved') {
+                sources.set(`${getCompilerPackageGraphModuleKey(candidate.module)}\0${candidate.exported}`, candidate);
+            }
+        }
+        result =
+            unknown || sources.size > 1
+                ? { kind: 'unknown' }
+                : sources.size === 1
+                    ? [...sources.values()][0]
+                    : { kind: 'absent' };
+    }
+    cache.set(key, result);
+    return result;
+}
+function createCompilerPackageGraphModuleResolution(dependencies, resolution) {
+    const exactRequests = new Set(dependencies.map((dependency) => `${getCompilerPackageGraphModuleKey(dependency.importer)}\0${dependency.specifier}`));
+    return {
+        edges: [
+            ...(resolution?.edges.filter((edge) => !edge.importer || !exactRequests.has(`${getCompilerPackageGraphModuleKey(edge.importer)}\0${edge.specifier}`)) ?? []),
+            ...dependencies.map((dependency) => ({
+                importer: cloneCompilerPackageGraphIdentity(dependency.importer),
+                ...(dependency.importedNames ? { importedNames: [...dependency.importedNames] } : {}),
+                specifier: dependency.specifier,
+                target: {
+                    packageName: dependency.target.packageName,
+                    source: dependency.target.source,
+                },
+            })),
+        ],
+        schema: 'flight-compiler-module-resolution/1',
+    };
+}
+function collectCompilerPackageGraphReachableKeys(entries, dependencies, availableKeys) {
+    const byImporter = new Map();
+    for (const dependency of dependencies) {
+        const importerKey = getCompilerPackageGraphModuleKey(dependency.importer);
+        if (!availableKeys.has(importerKey) || !availableKeys.has(getCompilerPackageGraphModuleKey(dependency.target))) {
+            continue;
+        }
+        byImporter.set(importerKey, [...(byImporter.get(importerKey) ?? []), dependency.target]);
+    }
+    const reachable = new Set();
+    const pending = [...entries];
+    while (pending.length > 0) {
+        const identity = pending.pop();
+        const key = getCompilerPackageGraphModuleKey(identity);
+        if (reachable.has(key))
+            continue;
+        reachable.add(key);
+        pending.push(...(byImporter.get(key) ?? []));
+    }
+    return reachable;
+}
+function getCompilerPackageGraphModuleKey(identity) {
+    const cached = compilerPackageGraphModuleKeyCache.get(identity);
+    if (cached !== undefined)
+        return cached;
+    const key = JSON.stringify([identity.packageName, normalizePathPortable(identity.source), identity.name]);
+    compilerPackageGraphModuleKeyCache.set(identity, key);
+    return key;
+}
+const compilerPackageGraphModuleKeyCache = new WeakMap();
+const compilerDefectEmissionCodes = new Set([
+    'duplicate-emitted-path',
+    'unsafe-emitted-contents',
+    'unsafe-emitted-path',
+]);
+const compilerRestrictionInitializationCodes = new Set([
+    'top-level-await',
+    'unsupported-default-expression-order',
+]);
+function propagateCompilerPackageGraphRefusals(records, dependencies) {
+    const ordered = [...dependencies].sort((left, right) => compareCompilerPackageGraphModules(left.importer, right.importer) ||
+        compareTextCodeUnits(left.specifier, right.specifier) ||
+        compareCompilerPackageGraphModules(left.target, right.target));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const dependency of ordered) {
+            const importer = records.get(getCompilerPackageGraphModuleKey(dependency.importer));
+            const target = records.get(getCompilerPackageGraphModuleKey(dependency.target));
+            if (!importer || !target || importer.refusals.length > 0 || target.refusals.length === 0)
+                continue;
+            importer.refusals.push({
+                code: 'dependency-refused',
+                message: `dependency ${dependency.specifier} was refused for ${getCompilerPackageGraphModuleSubject(dependency.target)}`,
+                stage: 'dependency',
+            });
+            importer.files.splice(0);
+            changed = true;
+        }
+    }
+}
+function refuseCompilerPackageGraphOutputCollisions(records) {
+    const owners = new Map();
+    for (const record of records.values()) {
+        if (record.refusals.length > 0)
+            continue;
+        for (const file of record.files) {
+            const key = file.path.normalize('NFC').toLowerCase();
+            owners.set(key, [...(owners.get(key) ?? []), record]);
+        }
+    }
+    for (const [path, colliding] of owners) {
+        if (colliding.length < 2)
+            continue;
+        const message = `Backend emitted colliding package file path: ${path}`;
+        for (const record of colliding) {
+            record.refusals.push({
+                classification: 'compiler-defect',
+                code: 'duplicate-emitted-path',
+                message,
+                stage: 'emission',
+            });
+            record.files.splice(0);
+        }
+    }
+}
+function createCompilerPackageGraphModuleResolver(modules, resolution) {
+    const modulesBySource = new Map();
+    for (const module of modules) {
+        const key = `${module.packageName}\0${normalizePathPortable(module.source)}`;
+        modulesBySource.set(key, [...(modulesBySource.get(key) ?? []), module]);
+    }
+    const exactTargets = new Map();
+    const globalTargets = new Map();
+    for (const edge of resolution?.edges ?? []) {
+        if (edge.importer) {
+            const key = `${getCompilerPackageGraphModuleKey(edge.importer)}\0${edge.specifier}`;
+            exactTargets.set(key, [...(exactTargets.get(key) ?? []), edge]);
+        }
+        else {
+            globalTargets.set(edge.specifier, [...(globalTargets.get(edge.specifier) ?? []), edge]);
+        }
+    }
+    return (importer, specifier) => {
+        const exact = exactTargets.get(`${getCompilerPackageGraphModuleKey(importer)}\0${specifier}`) ?? [];
+        const targets = exact.length > 0 ? exact : (globalTargets.get(specifier) ?? []);
+        const resolved = targets.flatMap((edge) => modulesBySource.get(`${edge.target.packageName}\0${normalizePathPortable(edge.target.source)}`) ?? []);
+        if (resolved.length === 1)
+            return resolved[0];
+        if (!specifier.startsWith('.'))
+            return undefined;
+        const sourceParts = normalizePathPortable(importer.source).split('/');
+        sourceParts.pop();
+        for (const part of normalizePathPortable(specifier).split('/')) {
+            if (part === '' || part === '.')
+                continue;
+            if (part === '..')
+                sourceParts.pop();
+            else
+                sourceParts.push(part);
+        }
+        const unresolved = sourceParts.join('/');
+        const candidates = new Set([unresolved]);
+        for (const [emitted, source] of [
+            ['.cjs', '.cts'],
+            ['.js', '.ts'],
+            ['.jsx', '.tsx'],
+            ['.mjs', '.mts'],
+        ]) {
+            if (unresolved.endsWith(emitted))
+                candidates.add(`${unresolved.slice(0, -emitted.length)}${source}`);
+        }
+        if (!/\.[^/]+$/u.test(unresolved)) {
+            candidates.add(`${unresolved}.ts`);
+            candidates.add(`${unresolved}/index.ts`);
+        }
+        const local = [...candidates].flatMap((candidate) => modulesBySource.get(`${importer.packageName}\0${candidate}`) ?? []);
+        return local.length === 1 ? local[0] : undefined;
+    };
+}
+function validateCompilerPackageGraphModuleIdentities(modules) {
+    const identities = new Set();
+    for (const module of modules) {
+        const key = getCompilerPackageGraphModuleKey(module);
+        if (identities.has(key)) {
+            throw createCompilerInvariantFailure('duplicate-module-identity', key, `Duplicate compiler module identity: ${module.packageName}/${module.source}#${module.name}`);
+        }
+        identities.add(key);
+    }
+}
+function validateCompilerPackageGraphOutput(files, options) {
+    if (options.sourceParser) {
+        const syntax = validateCompilerEmittedSourceSyntax(files, options.sourceParser);
+        if (files.length > 0 && syntax.checkedFiles === 0) {
+            throw createCompilerInvariantFailure('insufficient-emitted-source-syntax-files', syntax.parser, `Emitted-source parser ${syntax.parser} did not support any of ${String(files.length)} emitted file(s)`);
+        }
+    }
+    if (options.targetCompilationSmoke) {
+        const smoke = validateCompilerTargetCompilationSmoke(files, options.targetCompilationSmoke);
+        if (files.length > 0 && smoke.checkedFiles === 0) {
+            throw createCompilerInvariantFailure('insufficient-target-compilation-smoke-files', smoke.compiler, `Target compiler ${smoke.compiler} did not support any of ${String(files.length)} emitted file(s)`);
+        }
+    }
+}
+function validateCompilerPackageGraphPackages(graph, sources) {
+    if (!graph ||
+        graph.schema !== 'flight-compiler-package-graph/1' ||
+        !Array.isArray(graph.entries) ||
+        !Array.isArray(graph.moduleDependencies) ||
+        !Array.isArray(graph.packages)) {
+        throw createCompilerPackageGraphFailure('invalid-graph', 'graph', 'Package compilation requires flight-compiler-package-graph/1');
+    }
+    const packages = new Map();
+    for (const [index, package_] of graph.packages.entries()) {
+        const subject = `packages[${String(index)}]`;
+        if (!package_ ||
+            typeof package_.name !== 'string' ||
+            package_.name.length === 0 ||
+            typeof package_.root !== 'string' ||
+            package_.root.length === 0 ||
+            !Array.isArray(package_.dependencies) ||
+            package_.dependencies.some((dependency) => typeof dependency !== 'string' || dependency.length === 0)) {
+            throw createCompilerPackageGraphFailure('invalid-package', subject, `Package graph entry is malformed at ${subject}`);
+        }
+        if (packages.has(package_.name)) {
+            throw createCompilerPackageGraphFailure('duplicate-package', package_.name, `Package graph contains duplicate package ${package_.name}`);
+        }
+        packages.set(package_.name, {
+            dependencies: [...package_.dependencies],
+            name: package_.name,
+            root: normalizePathPortable(package_.root),
+        });
+    }
+    for (const package_ of packages.values()) {
+        const dependencies = new Set();
+        for (const dependency of package_.dependencies) {
+            if (dependency === package_.name || dependencies.has(dependency) || !packages.has(dependency)) {
+                throw createCompilerPackageGraphFailure('invalid-package-dependency', `${package_.name}:${dependency}`, `Package ${package_.name} has invalid dependency ${dependency}`);
+            }
+            dependencies.add(dependency);
+        }
+    }
+    for (const [index, source] of sources.entries()) {
+        const subject = `sources[${String(index)}]`;
+        if (!source ||
+            typeof source.packageName !== 'string' ||
+            typeof source.packageRoot !== 'string' ||
+            !source.sourceFile) {
+            throw createCompilerPackageGraphFailure('invalid-source', subject, `Package source is malformed at ${subject}`);
+        }
+        const package_ = packages.get(source.packageName);
+        if (!package_) {
+            throw createCompilerPackageGraphFailure('unknown-package', source.packageName, `Package source names unknown package ${source.packageName}`);
+        }
+        const root = normalizePathPortable(source.packageRoot);
+        const sourcePath = normalizePathPortable(source.sourceFile.fileName);
+        if (root !== package_.root || !sourcePath.startsWith(`${root}/`)) {
+            throw createCompilerPackageGraphFailure('package-root-mismatch', source.sourceFile.fileName, `Source ${source.sourceFile.fileName} is not within declared package root ${package_.root}`);
+        }
+    }
+    return packages;
+}
+function validateCompilerPackageGraphReferences(entries, dependencies, lowered, packages) {
+    const identities = new Set(lowered.map((result) => getCompilerPackageGraphModuleKey(result.module)));
+    const entryKeys = new Set();
+    for (const entry of entries) {
+        const key = getCompilerPackageGraphModuleKey(entry);
+        if (!identities.has(key)) {
+            throw createCompilerPackageGraphFailure('invalid-entry', key, `Package graph entry does not name an input module: ${key}`);
+        }
+        if (entryKeys.has(key)) {
+            throw createCompilerPackageGraphFailure('duplicate-entry', key, `Package graph entry is duplicated: ${key}`);
+        }
+        entryKeys.add(key);
+    }
+    const dependencyNamesByRequest = new Map();
+    for (const dependency of dependencies) {
+        const importerKey = getCompilerPackageGraphModuleKey(dependency.importer);
+        const targetKey = getCompilerPackageGraphModuleKey(dependency.target);
+        const dependencyKey = `${importerKey}\0${dependency.specifier}`;
+        const importedNamesValid = dependency.importedNames === undefined ||
+            (Array.isArray(dependency.importedNames) &&
+                dependency.importedNames.length > 0 &&
+                dependency.importedNames.every((name) => typeof name === 'string' && name.length > 0) &&
+                new Set(dependency.importedNames).size === dependency.importedNames.length);
+        const importedNames = dependency.importedNames ? new Set(dependency.importedNames) : undefined;
+        const priorNames = dependencyNamesByRequest.get(dependencyKey);
+        const duplicateRequest = dependencyNamesByRequest.has(dependencyKey) &&
+            (priorNames === undefined ||
+                importedNames === undefined ||
+                [...importedNames].some((name) => priorNames.has(name)));
+        const importerPackage = packages.get(dependency.importer.packageName);
+        if (!identities.has(importerKey) ||
+            !identities.has(targetKey) ||
+            typeof dependency.specifier !== 'string' ||
+            dependency.specifier.length === 0 ||
+            !importedNamesValid ||
+            duplicateRequest ||
+            (dependency.importer.packageName !== dependency.target.packageName &&
+                !importerPackage?.dependencies.includes(dependency.target.packageName))) {
+            throw createCompilerPackageGraphFailure('invalid-module-dependency', dependencyKey, `Package module dependency is invalid for ${dependency.importer.packageName}/${dependency.importer.source}`);
+        }
+        dependencyNamesByRequest.set(dependencyKey, importedNames === undefined ? undefined : new Set([...(priorNames ?? []), ...importedNames]));
+    }
+}
+const compilerPackageGraphFailureCodes = new Set([
+    'duplicate-entry',
+    'duplicate-package',
+    'invalid-entry',
+    'invalid-graph',
+    'invalid-module-dependency',
+    'invalid-package',
+    'invalid-package-dependency',
+    'invalid-source',
+    'package-root-mismatch',
+    'unknown-package',
+]);
+//# sourceMappingURL=compilerPackageCompilation.js.map