@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/internal/index-impl/projectSymbolGraphModuleDeclarationShapes.js

@@ -0,0 +1,138 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+
+function createProjectModuleDeclarationShapeRecords(semanticIndex, exportEdges = []) {
+  const documentsByPath = new Map((semanticIndex?.documents ?? []).filter((document) => document.path).map((document) => [document.path, document]));
+  return {
+    moduleDeclarationRecords: uniqueRecords((semanticIndex?.symbols ?? []).filter(isModuleDeclarationSymbol).map((symbol) => moduleDeclarationShapeRecord(symbol, documentsByPath))),
+    exportAssignmentRecords: uniqueRecords((exportEdges ?? []).filter(isExportAssignmentEdge).map(exportAssignmentShapeRecord))
+  };
+}
+
+function moduleDeclarationShapeRecord(symbol, documentsByPath) {
+  const metadata = objectValue(symbol.metadata);
+  const sourcePath = symbol.definitionSpan?.path;
+  const moduleName = firstString(metadata.moduleName, metadata.namespace, symbol.name);
+  const surfaceKind = moduleDeclarationSurfaceKind(moduleName);
+  const document = documentsByPath.get(sourcePath);
+  const shapeInput = { sourcePath, sourceHash: document?.sourceHash, sourceSpan: symbol.definitionSpan, moduleName, surfaceKind, symbolKind: symbol.kind, signatureHash: symbol.signatureHash };
+  const shapeHash = hashSemanticValue({ kind: 'frontier.lang.moduleDeclarationShape', ...shapeInput });
+  return compactRecord({
+    kind: 'frontier.lang.projectModuleDeclarationShape',
+    version: 1,
+    id: `module_declaration_shape_${idFragment(symbol.id)}`,
+    symbolId: symbol.id,
+    language: symbol.language,
+    sourcePath,
+    sourceHash: document?.sourceHash,
+    moduleName,
+    namespace: firstString(metadata.namespace, moduleName),
+    surfaceKind,
+    declarationOnly: surfaceKind !== 'namespace-declaration',
+    runtimeNamespace: surfaceKind === 'namespace-declaration',
+    ambient: surfaceKind === 'ambient-module-declaration' || surfaceKind === 'global-augmentation',
+    nativeAstNodeId: symbol.nativeAstNodeId,
+    sourceSpan: symbol.definitionSpan,
+    signatureHash: symbol.signatureHash,
+    shapeHash,
+    shapeProof: moduleDeclarationShapeProof(surfaceKind, shapeHash)
+  });
+}
+
+function exportAssignmentShapeRecord(edge) {
+  const shapeInput = { sourcePath: edge.sourcePath, exportedName: edge.exportedName, localName: edge.localName, exportKind: edge.exportKind };
+  const shapeHash = hashSemanticValue({ kind: 'frontier.lang.exportAssignmentShape', ...shapeInput });
+  return compactRecord({
+    kind: 'frontier.lang.projectExportAssignmentShape',
+    version: 1,
+    id: `export_assignment_shape_${idFragment(edge.id)}`,
+    edgeId: edge.id,
+    sourcePath: edge.sourcePath,
+    sourceHash: edge.sourceHash,
+    exportedName: edge.exportedName,
+    localName: edge.localName,
+    exportKind: edge.exportKind,
+    publicContract: edge.publicContract,
+    commonJsShape: true,
+    shapeHash,
+    shapeProof: exportAssignmentShapeProof(shapeHash)
+  });
+}
+
+function moduleDeclarationShapeProof(surfaceKind, shapeHash) {
+  return {
+    kind: 'frontier.lang.projectModuleDeclarationShapeProof',
+    version: 1,
+    status: 'static-shape-evidence',
+    proofLevel: 'module-declaration-static-shape',
+    shapeHash,
+    requiredSignals: ['parser-module-declaration-symbol', 'source-span', 'static-shape-hash'],
+    providedSignals: ['parser-module-declaration-symbol', 'source-span', 'static-shape-hash'],
+    unsupportedSignals: moduleDeclarationUnsupportedSignals(surfaceKind),
+    runtimeEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function exportAssignmentShapeProof(shapeHash) {
+  return {
+    kind: 'frontier.lang.projectExportAssignmentShapeProof',
+    version: 1,
+    status: 'static-shape-evidence',
+    proofLevel: 'export-assignment-static-shape',
+    shapeHash,
+    requiredSignals: ['parser-export-assignment-edge', 'source-span', 'static-shape-hash'],
+    providedSignals: ['parser-export-assignment-edge', 'source-span', 'static-shape-hash'],
+    unsupportedSignals: ['commonjs-runtime-interop-equivalence-unproven', 'module-export-assignment-side-effects-unproven'],
+    runtimeInteropEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function moduleDeclarationUnsupportedSignals(surfaceKind) {
+  if (surfaceKind === 'global-augmentation') return ['global-augmentation-compatibility-unproven'];
+  if (surfaceKind === 'ambient-module-declaration') return ['ambient-module-consumer-compatibility-unproven'];
+  return ['namespace-runtime-evaluation-order-unproven'];
+}
+
+function isModuleDeclarationSymbol(symbol) {
+  return symbol?.kind === 'module' && String(symbol.metadata?.scan ?? '').includes('module-declaration');
+}
+
+function isExportAssignmentEdge(edge) {
+  return edge?.exportKind === 'assignment' || edge?.exportedName === 'module.exports';
+}
+
+function moduleDeclarationSurfaceKind(moduleName) {
+  const name = String(moduleName ?? '');
+  if (name === 'global') return 'global-augmentation';
+  if (/^(?:\.|\.\.|@|#|[A-Za-z0-9_-]+\/)/.test(name)) return 'ambient-module-declaration';
+  return 'namespace-declaration';
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}
+
+function uniqueRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record?.id ?? hashSemanticValue(record);
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export { createProjectModuleDeclarationShapeRecords };

package/dist/internal/index-impl/projectSymbolGraphModuleResolution.js

@@ -1,4 +1,8 @@
 import { modulePathCandidates } from './projectSymbolGraphModulePathCandidates.js';
+import { exportMapMatch, exportTargetsForValue, packageEnvironmentConditionAmbiguity, packageEnvironmentConditionEvidence, packageConditions, packageRuntimeConditionAmbiguity, packageRuntimeConditionEvidence } from './projectSymbolGraphPackageConditions.js';
+
+const UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER = '<dynamic-import>';
+const UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER = '<host-dependency>';
 
 export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath) {
   if (!sourcePath || !moduleSpecifier || !moduleSpecifier.startsWith('.')) return undefined;
@@ -13,11 +17,13 @@ export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, docume
   };
 }
 
-export function resolveProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution) {
+export function resolveProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution, edgeMetadata) {
   if (!sourcePath || !moduleSpecifier) return undefined;
+  if (moduleSpecifier === UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER) return { kind: 'dynamic-import-non-literal-missing' };
+  if (moduleSpecifier === UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER) return { kind: 'host-dependency-non-literal-missing' };
   if (String(moduleSpecifier).startsWith('.')) return resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath);
-  if (String(moduleSpecifier).startsWith('#')) return resolvePackageImportProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution);
-  return resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution);
+  if (String(moduleSpecifier).startsWith('#')) return resolvePackageImportProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution, edgeMetadata);
+  return resolveConfiguredProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution, edgeMetadata);
 }
 
 export function createProjectModuleSymbolResolver(symbols, documents) {
@@ -26,7 +32,15 @@ export function createProjectModuleSymbolResolver(symbols, documents) {
     if (!edge?.targetDocumentId) return undefined;
     const targetName = targetExportName(edge);
     if (!targetName) return undefined;
-    return exportedByDocumentAndName.get(symbolKey(edge.targetDocumentId, targetName))?.id;
+    if (edge.importKind === 'commonjs-require' && targetName === 'default') {
+      return exportedByDocumentAndName.get(symbolKey(edge.targetDocumentId, 'module.exports'))?.id;
+    }
+    const directExport = exportedByDocumentAndName.get(symbolKey(edge.targetDocumentId, targetName));
+    if (directExport) return directExport.id;
+    if (targetName === 'default') {
+      return exportedByDocumentAndName.get(symbolKey(edge.targetDocumentId, 'module.exports'))?.id;
+    }
+    return undefined;
   };
 }
 
@@ -68,28 +82,51 @@ function projectExportSymbolMap(symbols, documents) {
 function symbolDocumentId(symbol, documentsByPath) {
   return symbol?.metadata?.moduleEdge?.sourceDocumentId ?? documentsByPath.get(symbol.definitionSpan?.path)?.id;
 }
-
-function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution) {
+function resolveConfiguredProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution, edgeMetadata) {
   const packageInfo = packageSpecifierInfo(moduleSpecifier);
-  const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution, packageInfo);
+  const candidates = configuredModuleCandidates(sourcePath, moduleSpecifier, moduleResolution, packageInfo, edgeMetadata);
   let firstMissing;
   for (const candidate of candidates) {
-    const target = moduleTargetDocument(candidate.path, documentsByPath);
     const packageFields = packageResolutionFields(candidate, packageInfo);
+    if (candidate.failClosedKind) {
+      firstMissing ??= { path: candidate.path, kind: candidate.failClosedKind, ...packageFields };
+      continue;
+    }
+    const target = moduleTargetDocument(candidate.path, documentsByPath);
     if (target) return { path: target.path, documentId: target.id, resolutionPathVariant: target.resolutionPathVariant, kind: `${candidate.kind}-source`, ...packageFields };
     firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing`, ...packageFields };
   }
   return firstMissing ?? (packageInfo ? { kind: 'package-external', ...packageInfo } : undefined);
 }
 
-function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution = {}) {
+function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution = {}, edgeMetadata) {
   const packageContext = packageImportContext(sourcePath, moduleResolution);
+  if (packageContext.packageWorkspaceRootAmbiguous) return { kind: 'package-workspace-root-ambiguous-missing', packageImportKey: moduleSpecifier, packageName: packageContext.packageName, ...packageWorkspaceRootAmbiguityFields(packageContext) };
+  if (packageContext.packageImportScopeMismatch) return { kind: 'package-import-scope-missing', packageImportKey: moduleSpecifier };
   const importsValue = packageContext.imports;
   if (!importsValue) return { kind: 'package-import-external', packageImportKey: moduleSpecifier };
   const match = packageImportMapValue(importsValue, moduleSpecifier);
   if (!match) return { kind: 'package-import-external', packageImportKey: moduleSpecifier };
+  const runtimeEvidence = packageRuntimeConditionEvidence(moduleResolution, sourcePath, packageContext, edgeMetadata);
+  if (runtimeEvidence.packageRuntimeConditionConflict) return {
+    kind: 'package-runtime-condition-conflict-missing',
+    packageImportKey: match.key,
+    packageName: packageContext.packageName,
+    ...runtimeEvidence
+  };
+  if (match.value === null) return { kind: 'package-import-null-target-missing', packageImportKey: match.key, packageName: packageContext.packageName, ...runtimeEvidence };
+  const runtimeAmbiguity = packageRuntimeConditionAmbiguity(match.value, moduleResolution, sourcePath, packageContext, edgeMetadata);
+  if (runtimeAmbiguity) return { kind: 'package-import-runtime-ambiguous-missing', packageImportKey: match.key, packageImportCondition: runtimeAmbiguity, packageName: packageContext.packageName, ...runtimeEvidence };
+  const environmentEvidence = packageEnvironmentConditionEvidence(moduleResolution, edgeMetadata);
+  const environmentAmbiguity = packageEnvironmentConditionAmbiguity(match.value, moduleResolution, sourcePath, packageContext, edgeMetadata);
+  if (environmentAmbiguity) return { kind: 'package-import-environment-ambiguous-missing', packageImportKey: match.key, packageImportCondition: environmentAmbiguity, packageName: packageContext.packageName, ...environmentAmbiguityFields(environmentAmbiguity), ...runtimeEvidence, ...environmentEvidence };
+  const conditions = packageConditions(moduleResolution, sourcePath, packageContext, edgeMetadata);
+  const targets = exportTargetsForValue(match.value, conditions);
+  if (!targets.length && isRecord(match.value)) {
+    return { kind: 'package-import-condition-missing', packageImportKey: match.key, packageName: packageContext.packageName, ...runtimeEvidence };
+  }
   let firstMissing;
-  for (const target of exportTargetsForValue(match.value, packageConditions(moduleResolution))) {
+  for (const target of targets) {
     const packageImportTarget = target.path;
     if (!packageImportTarget || !String(packageImportTarget).startsWith('.')) {
       return { kind: 'package-import-external', packageImportKey: match.key, packageImportCondition: target.condition, packageImportTarget };
@@ -100,7 +137,9 @@ function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, document
       packageImportKey: match.key,
       packageImportCondition: target.condition,
       packageImportTarget,
-      packageName: packageContext.packageName
+      packageName: packageContext.packageName,
+      ...runtimeEvidence,
+      ...environmentEvidence
     };
     if (resolved) return { path: resolved.path, documentId: resolved.id, resolutionPathVariant: resolved.resolutionPathVariant, kind: 'package-import-source', ...record };
     firstMissing ??= { path: candidatePath, kind: 'package-import-missing', ...record };
@@ -108,17 +147,16 @@ function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, document
   return firstMissing ?? { kind: 'package-import-external', packageImportKey: match.key };
 }
 
-function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}, packageInfo) {
+function configuredModuleCandidates(sourcePath, moduleSpecifier, moduleResolution = {}, packageInfo, edgeMetadata) {
   const compilerOptions = moduleResolution.compilerOptions ?? {};
   const baseUrl = normalizeProjectPath(moduleResolution.baseUrl ?? compilerOptions.baseUrl ?? '');
   return uniquePaths([
     ...aliasCandidates(moduleSpecifier, moduleResolution.aliases, 'alias', baseUrl),
     ...aliasCandidates(moduleSpecifier, moduleResolution.paths ?? compilerOptions.paths, 'path-alias', baseUrl),
-    ...packageCandidates(packageInfo, moduleResolution),
+    ...packageCandidates(sourcePath, packageInfo, moduleResolution, edgeMetadata),
     ...baseUrlCandidates(moduleSpecifier, baseUrl)
   ]);
 }
-
 function aliasCandidates(moduleSpecifier, aliases, kind, baseUrl) {
   return Object.entries(aliases ?? {}).flatMap(([pattern, targetPatterns]) => {
     const capture = patternCapture(moduleSpecifier, pattern);
@@ -135,41 +173,31 @@ function baseUrlCandidates(moduleSpecifier, baseUrl) {
   if (!baseUrl || String(moduleSpecifier).startsWith('@')) return [];
   return [{ kind: 'base-url', path: normalizeProjectPath(joinProjectPath(baseUrl, moduleSpecifier)) }];
 }
-
-function packageCandidates(packageInfo, moduleResolution = {}) {
+function packageCandidates(sourcePath, packageInfo, moduleResolution = {}, edgeMetadata) {
   if (!packageInfo) return [];
   const options = moduleResolution.packages?.[packageInfo.packageName];
   if (!options) return [];
+  const rootAmbiguity = packageWorkspaceRootAmbiguity(options, packageInfo); if (rootAmbiguity) return [rootAmbiguity];
   const root = normalizeProjectPath(options.root ?? '');
   const subpath = packageInfo.packageSubpath === '.' ? '' : packageInfo.packageSubpath.slice(2);
-  return uniquePaths([
-    ...packageExportCandidates(packageInfo, options, moduleResolution).map((candidate) => ({
-      ...candidate,
-      path: normalizeProjectPath(joinProjectPath(root, candidate.path))
-    })),
-    ...packageFallbackTargets(options, subpath).map((path) => ({
-      kind: 'package',
-      path: normalizeProjectPath(joinProjectPath(root, path)),
-      ...packageInfo
-    }))
-  ]);
-}
-
-function packageExportCandidates(packageInfo, options, moduleResolution) {
-  const targets = packageExportTargets(options.exports, packageInfo.packageSubpath, packageConditions(moduleResolution));
-  return targets.map((target) => ({
-    kind: 'package',
-    path: target.path,
-    packageExportCondition: target.condition,
-    ...packageInfo
-  }));
-}
-
-function packageExportTargets(exportsValue, subpath, conditions) {
-  if (!exportsValue) return [];
-  return exportTargetsForValue(exportMapValue(exportsValue, subpath), conditions);
+  const exportMatch = exportMapMatch(options.exports, packageInfo.packageSubpath);
+  const exportValue = exportMatch?.value;
+  const runtimeEvidence = packageRuntimeConditionEvidence(moduleResolution, sourcePath, undefined, edgeMetadata);
+  const environmentEvidence = packageEnvironmentConditionEvidence(moduleResolution, edgeMetadata);
+  if (Object.prototype.hasOwnProperty.call(options, 'exports')) {
+    const fallbackPath = normalizeProjectPath(joinProjectPath(root, subpath || '.'));
+    if (runtimeEvidence.packageRuntimeConditionConflict) return [{ kind: 'package', failClosedKind: 'package-runtime-condition-conflict-missing', path: fallbackPath, packageExportKey: exportMatch?.key, ...runtimeEvidence, ...packageInfo }];
+    if (exportValue === undefined || exportValue === null) return [{ kind: 'package', failClosedKind: exportValue === null ? 'package-export-null-target-missing' : 'package-subpath-not-exported-missing', path: fallbackPath, packageExportKey: exportMatch?.key, ...runtimeEvidence, ...packageInfo }];
+    const runtimeAmbiguity = packageRuntimeConditionAmbiguity(exportValue, moduleResolution, sourcePath, undefined, edgeMetadata);
+    if (runtimeAmbiguity) return [{ kind: 'package', failClosedKind: 'package-export-runtime-ambiguous-missing', path: fallbackPath, packageExportKey: exportMatch?.key, packageExportCondition: runtimeAmbiguity, ...runtimeEvidence, ...packageInfo }];
+    const environmentAmbiguity = packageEnvironmentConditionAmbiguity(exportValue, moduleResolution, sourcePath, undefined, edgeMetadata);
+    if (environmentAmbiguity) return [{ kind: 'package', failClosedKind: 'package-export-environment-ambiguous-missing', path: fallbackPath, packageExportKey: exportMatch?.key, packageExportCondition: environmentAmbiguity, ...environmentAmbiguityFields(environmentAmbiguity), ...runtimeEvidence, ...environmentEvidence, ...packageInfo }];
+    const exportTargets = exportTargetsForValue(exportValue, packageConditions(moduleResolution, sourcePath, undefined, edgeMetadata));
+    if (!exportTargets.length) return [{ kind: 'package', failClosedKind: 'package-export-condition-missing', path: fallbackPath, packageExportKey: exportMatch?.key, ...runtimeEvidence, ...packageInfo }];
+    return uniquePaths(exportTargets.map((target) => ({ kind: 'package', path: normalizeProjectPath(joinProjectPath(root, target.path)), packageExportKey: exportMatch?.key, packageExportCondition: target.condition, packageExportTarget: target.path, ...runtimeEvidence, ...environmentEvidence, ...packageInfo })));
+  }
+  return uniquePaths(packageFallbackTargets(options, subpath).map((path) => ({ kind: 'package', path: normalizeProjectPath(joinProjectPath(root, path)), ...packageInfo })));
 }
-
 function packageImportMapValue(importsValue, moduleSpecifier) {
   if (!isRecord(importsValue)) return undefined;
   if (Object.prototype.hasOwnProperty.call(importsValue, moduleSpecifier)) return { key: moduleSpecifier, value: importsValue[moduleSpecifier] };
@@ -185,29 +213,19 @@ function packageImportContext(sourcePath, moduleResolution = {}) {
     .map(([packageName, options]) => ({
       packageName,
       root: normalizeProjectPath(options.root ?? ''),
-      imports: options.imports
+      packageType: options.packageType ?? options.type,
+      imports: options.imports,
+      ...packageWorkspaceRootAmbiguityFields(options)
     }))
-    .filter((entry) => entry.imports && pathInsideRoot(sourcePath, entry.root))
+    .filter((entry) => entry.imports && packageRootContainsSource(sourcePath, entry))
     .sort((left, right) => right.root.length - left.root.length);
-  return packages[0] ?? {
-    root: normalizeProjectPath(moduleResolution.packageRoot ?? moduleResolution.root ?? ''),
-    imports: moduleResolution.imports ?? moduleResolution.packageImports
-  };
+  if (packages[0]) return packages[0];
+  const root = normalizeProjectPath(moduleResolution.packageRoot ?? moduleResolution.root ?? '');
+  const imports = moduleResolution.imports ?? moduleResolution.packageImports;
+  return imports && root && !pathInsideRoot(sourcePath, root)
+    ? { root, imports, packageImportScopeMismatch: true }
+    : { root, imports };
 }
-
-function exportMapValue(exportsValue, subpath) {
-  if (!isRecord(exportsValue) || !Object.keys(exportsValue).some((key) => key.startsWith('.'))) return subpath === '.' ? exportsValue : undefined;
-  return exportsValue[subpath] ?? patternExportMapValue(exportsValue, subpath);
-}
-
-function patternExportMapValue(exportsValue, subpath) {
-  for (const [pattern, target] of Object.entries(exportsValue)) {
-    const capture = patternCapture(subpath, pattern);
-    if (capture !== undefined) return replaceExportTargetCapture(target, capture);
-  }
-  return undefined;
-}
-
 function replaceExportTargetCapture(target, capture) {
   if (typeof target === 'string') return target.replace('*', capture);
   if (Array.isArray(target)) return target.map((entry) => replaceExportTargetCapture(entry, capture));
@@ -215,19 +233,15 @@ function replaceExportTargetCapture(target, capture) {
   return Object.fromEntries(Object.entries(target).map(([key, value]) => [key, replaceExportTargetCapture(value, capture)]));
 }
 
-function exportTargetsForValue(value, conditions, condition) {
-  if (!value) return [];
-  if (typeof value === 'string') return [{ path: value, condition }];
-  if (Array.isArray(value)) return value.flatMap((entry) => exportTargetsForValue(entry, conditions, condition));
-  if (!isRecord(value)) return [];
-  return conditions.flatMap((key) => exportTargetsForValue(value[key], conditions, key));
-}
-
 function packageFallbackTargets(options, subpath) {
   const sourceRoot = normalizeProjectPath(options.sourceRoot ?? 'src');
   if (subpath) return [joinProjectPath(sourceRoot, subpath), subpath];
   return [options.types, options.main, joinProjectPath(sourceRoot, 'index')].filter(Boolean);
 }
+function packageWorkspaceRootAmbiguity(options, packageInfo) { const fields = packageWorkspaceRootAmbiguityFields(options); return fields.packageWorkspaceRootAmbiguous ? { kind: 'package', failClosedKind: 'package-workspace-root-ambiguous-missing', path: packageSpecifierPath(packageInfo), ...fields, ...packageInfo } : undefined; }
+function packageWorkspaceRootAmbiguityFields(options = {}) { const roots = uniquePaths([...(Array.isArray(options.packageWorkspaceRoots) ? options.packageWorkspaceRoots.map((path) => ({ path: normalizeProjectPath(path) })) : []), { path: normalizeProjectPath(options.root ?? '') }]).map((entry) => entry.path); return options.packageWorkspaceRootAmbiguous || roots.length > 1 ? { packageWorkspaceRootAmbiguous: true, packageWorkspaceRoots: roots, packageResolutionReasonCode: 'package-workspace-root-ambiguous-missing' } : {}; }
+function packageRootContainsSource(sourcePath, entry) { return (entry.packageWorkspaceRootAmbiguous ? entry.packageWorkspaceRoots : [entry.root]).some((root) => pathInsideRoot(sourcePath, root)); }
+function packageSpecifierPath(packageInfo) { return packageInfo.packageSubpath === '.' ? packageInfo.packageName : `${packageInfo.packageName}/${packageInfo.packageSubpath.slice(2)}`; }
 
 function moduleTargetDocument(path, documentsByPath) {
   for (const candidate of modulePathCandidates(path)) {
@@ -281,30 +295,18 @@ function packageSpecifierInfo(moduleSpecifier) {
 
 function packageResolutionFields(candidate, packageInfo) {
   if (!candidate.packageName && candidate.kind !== 'package') return {};
-  return {
-    packageName: candidate.packageName ?? packageInfo?.packageName,
-    packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath,
-    packageExportCondition: candidate.packageExportCondition,
-    packageImportKey: candidate.packageImportKey,
-    packageImportCondition: candidate.packageImportCondition,
-    packageImportTarget: candidate.packageImportTarget
-  };
+  return { packageName: candidate.packageName ?? packageInfo?.packageName, packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath, packageExportKey: candidate.packageExportKey, packageExportCondition: candidate.packageExportCondition, packageExportTarget: candidate.packageExportTarget, packageImportKey: candidate.packageImportKey, packageImportCondition: candidate.packageImportCondition, packageImportTarget: candidate.packageImportTarget, packageRuntimeCondition: candidate.packageRuntimeCondition, packageRuntimeConditionEvidenceSource: candidate.packageRuntimeConditionEvidenceSource, packageRuntimeConditionEdgeKind: candidate.packageRuntimeConditionEdgeKind, packageRuntimeConditionCandidates: candidate.packageRuntimeConditionCandidates, packageRuntimeConditionReasonCode: candidate.packageRuntimeConditionReasonCode, packageEnvironmentCondition: candidate.packageEnvironmentCondition, packageEnvironmentConditionEvidenceSource: candidate.packageEnvironmentConditionEvidenceSource, packageEnvironmentConditionCandidates: candidate.packageEnvironmentConditionCandidates, packageEnvironmentConditionReasonCode: candidate.packageEnvironmentConditionReasonCode, packageType: candidate.packageType, packageWorkspaceRootAmbiguous: candidate.packageWorkspaceRootAmbiguous, packageWorkspaceRoots: candidate.packageWorkspaceRoots, packageResolutionReasonCode: candidate.packageResolutionReasonCode };
 }
 
-function packageConditions(moduleResolution = {}) {
-  return moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'];
-}
+function environmentAmbiguityFields(ambiguity) { return { packageEnvironmentConditionCandidates: ambiguity.split('|'), packageEnvironmentConditionReasonCode: 'package-environment-condition-ambiguous-missing' }; }
 
-function isRecord(value) {
-  return value && typeof value === 'object' && !Array.isArray(value);
-}
+function isRecord(value) { return value && typeof value === 'object' && !Array.isArray(value); }
 
 function normalizeProjectPath(path) {
   const parts = [];
   for (const part of String(path).split('/')) {
     if (!part || part === '.') continue;
-    if (part === '..') parts.pop();
-    else parts.push(part);
+    if (part === '..') parts.pop(); else parts.push(part);
   }
   return parts.join('/');
 }