@shapeshift-labs/frontier-lang-compiler 0.2.161 → 0.2.163

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

@@ -0,0 +1,196 @@
+import { isJsxSpreadAttribute } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { parseStaticObjectLiteralExpression } from './projectSymbolGraphJsxStaticLiterals.js';
+
+function jsxSpreadPropValueEvidence(tag, attribute, context = {}) {
+  const expressionText = jsxSpreadExpressionText(attribute);
+  const source = staticObjectSpreadSource(expressionText, attribute, context);
+  if (!source?.status) return dynamicSpreadPropValueEvidence(expressionText, source?.reasonCode);
+  const precedence = staticSpreadPrecedenceEvidence(tag, attribute, source.entries);
+  const propNames = uniqueStrings(source.entries.map((entry) => entry.propName));
+  return compactRecord({
+    proofStatus: 'static-object-spread-jsx-prop-value-evidence',
+    reasonCode: 'jsx-render-prop-spread-static-object-evidence',
+    valueKind: 'object-spread',
+    valueText: source.valueText,
+    expressionText,
+    staticSpreadSourceKind: source.sourceKind,
+    staticSpreadSourceName: source.sourceName,
+    staticSpreadPropEntries: source.entries,
+    staticSpreadPropNames: propNames,
+    staticSpreadPropCount: propNames.length,
+    staticSpreadEffectivePropEntries: precedence.effectiveEntries,
+    staticSpreadEffectivePropNames: uniqueStrings(precedence.effectiveEntries.map((entry) => entry.propName)),
+    staticSpreadExplicitOverridePropNames: precedence.explicitOverridePropNames,
+    staticSpreadOverridesExplicitPropNames: precedence.overridesExplicitPropNames,
+    staticSpreadDuplicatePropNames: duplicatePropNames(source.entries),
+    staticSpreadPrecedenceStatus: precedence.status,
+    claimScope: 'static-object-spread-props-only',
+    renderEquivalenceClaim: false
+  });
+}
+
+function dynamicSpreadPropValueEvidence(expressionText, reasonCode) {
+  return {
+    proofStatus: 'dynamic-jsx-prop-spread-unsupported',
+    reasonCode: 'jsx-render-prop-spread-unsupported',
+    valueKind: 'spread-expression',
+    expressionText,
+    dynamicText: expressionText,
+    dynamicBlockerReasonCode: reasonCode ?? jsxPropSpreadDynamicBlockerReasonCode(expressionText),
+    claimScope: 'static-object-spread-props-only',
+    renderEquivalenceClaim: false
+  };
+}
+
+function staticObjectSpreadSource(expressionText, attribute, context = {}) {
+  const text = normalizedText(expressionText);
+  if (!text) return { reasonCode: 'jsx-render-prop-spread-expression-unsupported' };
+  if (text.startsWith('{')) {
+    const parsed = parseStaticObjectLiteralExpression(text);
+    return parsed.value
+      ? { status: 'static', sourceKind: 'inline-object-literal', valueText: text, entries: parsed.value.entries }
+      : { reasonCode: parsed.reasonCode ?? jsxPropSpreadDynamicBlockerReasonCode(text) };
+  }
+  if (simpleIdentifierExpression(text)) {
+    const resolved = sameFileConstObjectSpreadSource(text, attribute, context);
+    return resolved.status ? resolved : { reasonCode: resolved.reasonCode ?? 'jsx-render-prop-spread-reference-unsupported' };
+  }
+  return { reasonCode: jsxPropSpreadDynamicBlockerReasonCode(text) };
+}
+
+function sameFileConstObjectSpreadSource(name, attribute, context = {}) {
+  const sourceText = String(context.sourceText ?? '');
+  if (!sourceText) return { reasonCode: 'jsx-render-prop-spread-reference-unsupported' };
+  const beforeOffset = Number.isFinite(attribute?.start) ? attribute.start : sourceText.length;
+  const declarations = constObjectInitializers(sourceText, name).filter((declaration) => declaration.start < beforeOffset);
+  if (declarations.length !== 1) return {
+    reasonCode: declarations.length > 1 ? 'jsx-render-prop-spread-ambiguous-const-object-unsupported' : 'jsx-render-prop-spread-reference-unsupported'
+  };
+  const parsed = parseStaticObjectLiteralExpression(declarations[0].initializerText);
+  return parsed.value
+    ? {
+      status: 'static',
+      sourceKind: 'same-file-const-object',
+      sourceName: name,
+      valueText: normalizedText(declarations[0].initializerText),
+      entries: parsed.value.entries
+    }
+    : { reasonCode: parsed.reasonCode ?? 'jsx-render-prop-spread-const-object-dynamic-unsupported' };
+}
+
+function constObjectInitializers(sourceText, name) {
+  const result = [];
+  const pattern = new RegExp(`\\bconst\\s+${escapeRegExp(name)}\\s*=\\s*`, 'g');
+  let match;
+  while ((match = pattern.exec(sourceText))) {
+    const start = match.index;
+    const initializerText = readConstInitializerText(sourceText, pattern.lastIndex);
+    if (initializerText) result.push({ start, initializerText });
+  }
+  return result;
+}
+
+function readConstInitializerText(sourceText, start) {
+  let quote;
+  let depth = 0;
+  for (let index = start; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (quote) {
+      if (char === '\\') index += 1;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') quote = char;
+    else if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth = Math.max(0, depth - 1);
+    else if (depth === 0 && (char === ';' || char === '\n')) return sourceText.slice(start, index).trim();
+  }
+  return sourceText.slice(start).trim();
+}
+
+function staticSpreadPrecedenceEvidence(tag, attribute, entries) {
+  const index = attributeIndexInTag(tag, attribute);
+  const before = namedAttributesBefore(tag, index);
+  const after = namedAttributesAfter(tag, index);
+  const lastEntries = lastStaticEntriesByProp(entries);
+  const explicitOverridePropNames = uniqueStrings(lastEntries.filter((entry) => after.has(entry.propName)).map((entry) => entry.propName));
+  const overridesExplicitPropNames = uniqueStrings(lastEntries.filter((entry) => before.has(entry.propName)).map((entry) => entry.propName));
+  const effectiveEntries = lastEntries.filter((entry) => !after.has(entry.propName));
+  return {
+    effectiveEntries,
+    explicitOverridePropNames,
+    overridesExplicitPropNames,
+    status: staticSpreadPrecedenceStatus(explicitOverridePropNames, overridesExplicitPropNames, duplicatePropNames(entries))
+  };
+}
+
+function namedAttributesBefore(tag, index) {
+  return new Set((tag.attributes ?? []).slice(0, Math.max(0, index)).filter((candidate) => !isJsxSpreadAttribute(candidate)).map((candidate) => candidate.name));
+}
+
+function namedAttributesAfter(tag, index) {
+  return new Set((tag.attributes ?? []).slice(index + 1).filter((candidate) => !isJsxSpreadAttribute(candidate)).map((candidate) => candidate.name));
+}
+
+function staticSpreadPrecedenceStatus(explicitOverridePropNames, overridesExplicitPropNames, duplicateNames) {
+  if (explicitOverridePropNames.length && overridesExplicitPropNames.length) return 'static-spread-between-explicit-props';
+  if (explicitOverridePropNames.length) return 'static-spread-overridden-by-later-explicit-prop';
+  if (overridesExplicitPropNames.length) return 'static-spread-overrides-earlier-explicit-prop';
+  if (duplicateNames.length) return 'static-spread-duplicate-prop-last-write-wins';
+  return 'static-spread-props-preserved';
+}
+
+function attributeIndexInTag(tag, attribute) {
+  const attributes = tag.attributes ?? [];
+  const direct = attributes.indexOf(attribute);
+  if (direct >= 0) return direct;
+  return attributes.findIndex((candidate) => candidate.start === attribute?.start && candidate.end === attribute?.end && candidate.name === attribute?.name);
+}
+
+function lastStaticEntriesByProp(entries) {
+  const byProp = new Map();
+  for (const entry of entries) byProp.set(entry.propName, entry);
+  return [...byProp.values()].sort((left, right) => left.ordinal - right.ordinal);
+}
+
+function duplicatePropNames(entries) {
+  const counts = new Map();
+  for (const entry of entries) counts.set(entry.propName, (counts.get(entry.propName) ?? 0) + 1);
+  return [...counts.entries()].filter(([, count]) => count > 1).map(([name]) => name);
+}
+
+function jsxSpreadExpressionText(attribute) {
+  const expressionText = normalizedText(attribute?.expressionText);
+  if (expressionText) return expressionText;
+  const text = String(attribute?.text ?? '').trim();
+  const braced = /^\{\s*\.\.\.\s*([\s\S]*?)\s*\}$/.exec(text);
+  if (braced) return normalizedText(braced[1]);
+  const unbraced = /^\.\.\.\s*([\s\S]*)$/.exec(text);
+  return unbraced ? normalizedText(unbraced[1]) : undefined;
+}
+
+function jsxPropSpreadDynamicBlockerReasonCode(text) {
+  const value = normalizedText(text);
+  if (/\[[\s\S]*\]/.test(value)) return 'jsx-render-prop-spread-computed-reference-unsupported';
+  if (/^`[\s\S]*\$\{[\s\S]*`$/.test(value)) return 'jsx-render-prop-spread-template-interpolation-unsupported';
+  if (/\?\.\s*\(/.test(value) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(value)) return 'jsx-render-prop-spread-call-expression-unsupported';
+  if (/^\{/.test(value)) return 'jsx-render-prop-spread-dynamic-object-unsupported';
+  if (staticPropReference(value)) return 'jsx-render-prop-spread-reference-unsupported';
+  return 'jsx-render-prop-spread-expression-unsupported';
+}
+
+function staticPropReference(text) {
+  const value = normalizedText(text);
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(value)) return undefined;
+  const normalized = value.replace(/\s+/g, '');
+  const path = normalized.split('.');
+  return { text: normalized, root: path[0], path };
+}
+
+function simpleIdentifierExpression(text) { return /^[A-Za-z_$][\w$]*$/.test(String(text ?? '').trim()); }
+function escapeRegExp(text) { return String(text ?? '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxSpreadPropValueEvidence };

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

@@ -0,0 +1,207 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function parseStaticLiteralExpression(text) {
+  return parseStaticLiteralExpressionResult(text).value;
+}
+
+function parseStaticObjectLiteralExpression(text) {
+  const result = parseStaticLiteralExpressionResult(text);
+  return result.value?.kind === 'object-literal' ? result : { reasonCode: result.reasonCode };
+}
+
+function parseStaticLiteralExpressionResult(text) {
+  const state = { text: String(text ?? ''), index: 0 };
+  const parsed = parseStaticLiteralValue(state);
+  skipWhitespace(state);
+  return parsed && state.index === state.text.length
+    ? { value: parsed }
+    : { reasonCode: state.errorReason };
+}
+
+function parseStaticLiteralValue(state) {
+  skipWhitespace(state);
+  const char = state.text[state.index];
+  if (char === '"' || char === "'") return parseQuotedStaticString(state) ? { kind: 'string' } : undefined;
+  if (char === '`') return parseStaticTemplateString(state) ? { kind: 'template-string' } : undefined;
+  if (char === '{') {
+    const parsed = parseStaticObjectLiteral(state);
+    return parsed ? { kind: 'object-literal', entries: parsed.entries } : undefined;
+  }
+  if (char === '[') return parseStaticArrayLiteral(state) ? { kind: 'array-literal' } : undefined;
+  if (looksLikeCallExpression(state.text.slice(state.index))) state.errorReason ??= 'jsx-render-prop-spread-call-expression-unsupported';
+  const primitive = parseStaticPrimitiveToken(state);
+  return primitive ? { kind: primitive } : undefined;
+}
+
+function parseStaticObjectLiteral(state) {
+  state.index += 1;
+  skipWhitespace(state);
+  const entries = [];
+  if (consumeChar(state, '}')) return { entries };
+  while (state.index < state.text.length) {
+    if (state.text.startsWith('...', state.index)) {
+      state.errorReason ??= 'jsx-render-prop-spread-nested-spread-unsupported';
+      return undefined;
+    }
+    if (state.text[state.index] === '[') {
+      state.errorReason ??= 'jsx-render-prop-spread-computed-key-unsupported';
+      return undefined;
+    }
+    const key = parseStaticObjectKey(state);
+    if (!key) return undefined;
+    skipWhitespace(state);
+    if (!consumeChar(state, ':')) {
+      if (key.propName === 'get' || key.propName === 'set') state.errorReason ??= 'jsx-render-prop-spread-getter-unsupported';
+      else if (state.text[state.index] === '(') state.errorReason ??= 'jsx-render-prop-spread-method-unsupported';
+      else state.errorReason ??= 'jsx-render-prop-spread-dynamic-object-unsupported';
+      return undefined;
+    }
+    skipWhitespace(state);
+    const valueStart = state.index;
+    const value = parseStaticLiteralValue(state);
+    if (!value) return undefined;
+    const valueText = normalizedText(state.text.slice(valueStart, state.index));
+    entries.push(staticSpreadPropEntry(key, value, valueText, entries.length + 1));
+    skipWhitespace(state);
+    if (consumeChar(state, '}')) return { entries };
+    if (!consumeChar(state, ',')) return undefined;
+    skipWhitespace(state);
+    if (consumeChar(state, '}')) return { entries };
+  }
+  return undefined;
+}
+
+function parseStaticArrayLiteral(state) {
+  state.index += 1;
+  skipWhitespace(state);
+  if (consumeChar(state, ']')) return true;
+  while (state.index < state.text.length) {
+    if (state.text.startsWith('...', state.index) || state.text[state.index] === ',') {
+      state.errorReason ??= 'jsx-render-prop-spread-dynamic-object-unsupported';
+      return false;
+    }
+    if (!parseStaticLiteralValue(state)) return false;
+    skipWhitespace(state);
+    if (consumeChar(state, ']')) return true;
+    if (!consumeChar(state, ',')) return false;
+    skipWhitespace(state);
+    if (consumeChar(state, ']')) return true;
+  }
+  return false;
+}
+
+function parseStaticObjectKey(state) {
+  skipWhitespace(state);
+  const char = state.text[state.index];
+  const start = state.index;
+  if (char === '"' || char === "'") {
+    if (!parseQuotedStaticString(state)) return undefined;
+    const keyText = state.text.slice(start, state.index);
+    return { propName: staticStringLiteralValue(keyText), keyText };
+  }
+  const numberStart = state.index;
+  const number = parseStaticNumberToken(state);
+  if (number) return { propName: number, keyText: number };
+  state.index = numberStart;
+  const identifier = parseIdentifierToken(state);
+  return identifier ? { propName: identifier, keyText: identifier } : undefined;
+}
+
+function staticSpreadPropEntry(key, value, valueText, ordinal) {
+  return {
+    propName: key.propName,
+    keyText: key.keyText,
+    valueKind: value.kind,
+    valueText,
+    ordinal,
+    entryHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxStaticObjectSpreadPropEntry',
+      propName: key.propName,
+      keyText: key.keyText,
+      valueKind: value.kind,
+      valueText,
+      ordinal
+    })
+  };
+}
+
+function parseQuotedStaticString(state) {
+  const quote = state.text[state.index];
+  if (quote !== '"' && quote !== "'") return false;
+  state.index += 1;
+  while (state.index < state.text.length) {
+    const char = state.text[state.index];
+    if (char === '\\') {
+      state.index += 2;
+      continue;
+    }
+    state.index += 1;
+    if (char === quote) return true;
+  }
+  return false;
+}
+
+function parseStaticTemplateString(state) {
+  if (state.text[state.index] !== '`') return false;
+  state.index += 1;
+  while (state.index < state.text.length) {
+    const char = state.text[state.index];
+    if (char === '\\') {
+      state.index += 2;
+      continue;
+    }
+    if (char === '$' && state.text[state.index + 1] === '{') return false;
+    state.index += 1;
+    if (char === '`') return true;
+  }
+  return false;
+}
+
+function parseStaticPrimitiveToken(state) {
+  const number = parseStaticNumberToken(state);
+  if (number) return 'number';
+  const identifierStart = state.index;
+  const identifier = parseIdentifierToken(state);
+  if (['true', 'false'].includes(identifier)) return 'boolean';
+  if (identifier === 'null') return 'null';
+  if (identifier === 'undefined') return 'undefined';
+  state.index = identifierStart;
+  return undefined;
+}
+
+function parseStaticNumberToken(state) {
+  const match = /^[-]?(?:0|[1-9]\d*)(?:\.\d+)?/.exec(state.text.slice(state.index));
+  if (!match) return undefined;
+  state.index += match[0].length;
+  return match[0];
+}
+
+function parseIdentifierToken(state) {
+  const match = /^[A-Za-z_$][\w$]*/.exec(state.text.slice(state.index));
+  if (!match) return undefined;
+  state.index += match[0].length;
+  return match[0];
+}
+
+function consumeChar(state, char) {
+  if (state.text[state.index] !== char) return false;
+  state.index += 1;
+  return true;
+}
+
+function skipWhitespace(state) {
+  while (/\s/.test(state.text[state.index] ?? '')) state.index += 1;
+}
+
+function staticStringLiteralValue(text) {
+  const value = String(text ?? '');
+  return value.slice(1, -1).replace(/\\([\s\S])/g, '$1');
+}
+
+function looksLikeCallExpression(text) {
+  return /^\s*[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(String(text ?? ''));
+}
+
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+
+export { parseStaticLiteralExpression, parseStaticObjectLiteralExpression };

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

@@ -3,6 +3,7 @@ import { exportMapMatch, exportTargetsForValue, packageEnvironmentConditionAmbig
 
 const UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER = '<dynamic-import>';
 const UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER = '<host-dependency>';
+const PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_MISSING = 'package-runtime-condition-host-resource-import-ambiguous-missing';
 
 export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath) {
   if (!sourcePath || !moduleSpecifier || !moduleSpecifier.startsWith('.')) return undefined;
@@ -115,6 +116,12 @@ function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, document
     ...runtimeEvidence
   };
   if (match.value === null) return { kind: 'package-import-null-target-missing', packageImportKey: match.key, packageName: packageContext.packageName, ...runtimeEvidence };
+  if (runtimeEvidence.packageRuntimeConditionReasonCode === PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_MISSING) return {
+    kind: PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_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);
@@ -188,6 +195,7 @@ function packageCandidates(sourcePath, packageInfo, moduleResolution = {}, edgeM
     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 }];
+    if (runtimeEvidence.packageRuntimeConditionReasonCode === PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_MISSING) return [{ kind: 'package', failClosedKind: PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_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);
@@ -251,15 +259,8 @@ function moduleTargetDocument(path, documentsByPath) {
   return undefined;
 }
 
-function targetExportName(edge) {
-  const name = edge.importedName ?? edge.localName ?? edge.exportedName;
-  if (!name || name === '*') return undefined;
-  return String(name);
-}
-
-function symbolKey(documentId, name) {
-  return `${documentId}\u0000${name}`;
-}
+function targetExportName(edge) { const name = edge.importedName ?? edge.localName ?? edge.exportedName; return name && name !== '*' ? String(name) : undefined; }
+function symbolKey(documentId, name) { return `${documentId}\u0000${name}`; }
 
 function patternCapture(value, pattern) {
   if (pattern === value) return '';
@@ -278,9 +279,7 @@ function uniquePaths(candidates) {
   });
 }
 
-function joinProjectPath(left, right) {
-  return left ? `${left}/${right}` : String(right);
-}
+function joinProjectPath(left, right) { return left ? `${left}/${right}` : String(right); }
 
 function packageSpecifierInfo(moduleSpecifier) {
   if (!moduleSpecifier || String(moduleSpecifier).startsWith('#')) return undefined;
@@ -295,11 +294,10 @@ 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, 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 };
+  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, packageRuntimeConditionExcludedConditions: candidate.packageRuntimeConditionExcludedConditions, packageRuntimeConditionReasonCode: candidate.packageRuntimeConditionReasonCode, packageRuntimeConditionHostResourceKind: candidate.packageRuntimeConditionHostResourceKind, 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 environmentAmbiguityFields(ambiguity) { return { packageEnvironmentConditionCandidates: ambiguity.split('|'), packageEnvironmentConditionReasonCode: 'package-environment-condition-ambiguous-missing' }; }
-
 function isRecord(value) { return value && typeof value === 'object' && !Array.isArray(value); }
 
 function normalizeProjectPath(path) {

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

@@ -1,3 +1,6 @@
+import { runtimeAdmittedConditions, runtimeConditionRecord } from './projectSymbolGraphPackageRuntimeConditions.js';
+import { hostResourceImportDependencyKind } from './moduleHostResourceImportMetadata.js';
+
 const EnvironmentPackageConditions = Object.freeze([
   'browser',
   'node',
@@ -9,6 +12,7 @@ const EnvironmentPackageConditions = Object.freeze([
   'bun',
   'react-native'
 ]);
+const PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_MISSING = 'package-runtime-condition-host-resource-import-ambiguous-missing';
 
 function exportTargetsForValue(value, conditions, condition) {
   if (!value) return [];
@@ -30,7 +34,10 @@ function exportMapMatch(exportsValue, subpath) {
 
 function packageConditions(moduleResolution = {}, sourcePath, packageContext, edgeMetadata) {
   return prioritizeConditions(
-    moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'],
+    runtimeAdmittedConditions(
+      moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'],
+      packageRuntimeConditionEvidence(moduleResolution, sourcePath, packageContext, edgeMetadata).packageRuntimeCondition
+    ),
     packageConditionPreferences(sourcePath, moduleResolution, packageContext, edgeMetadata)
   );
 }
@@ -57,9 +64,11 @@ function packageEnvironmentConditionAmbiguity(value, moduleResolution, sourcePat
 }
 
 function packageRuntimeConditionEvidence(moduleResolution = {}, sourcePath, packageContext, edgeMetadata) {
+  const packageType = packageTypeForSource(moduleResolution, sourcePath, packageContext);
+  const hostResourceAmbiguity = packageRuntimeHostResourceConditionAmbiguity(edgeMetadata, packageType);
+  if (hostResourceAmbiguity) return hostResourceAmbiguity;
   const edgeCondition = packageRuntimeConditionFromEdge(edgeMetadata);
   const extensionCondition = packageRuntimeConditionFromExtension(sourcePath);
-  const packageType = packageTypeForSource(moduleResolution, sourcePath, packageContext);
   const packageTypeCondition = packageType === 'module' ? 'import' : packageType === 'commonjs' ? 'require' : undefined;
   if (edgeCondition) {
     const conflict = edgeCondition.conflictsWithSource && (
@@ -78,8 +87,8 @@ function packageRuntimeConditionEvidence(moduleResolution = {}, sourcePath, pack
   }
   const hostAmbiguity = edgeCondition ? undefined : packageRuntimeHostConditionAmbiguity(edgeMetadata, packageType);
   if (hostAmbiguity) return hostAmbiguity;
-  if (extensionCondition) return { packageRuntimeCondition: extensionCondition, packageRuntimeConditionEvidenceSource: 'source-extension', packageType };
-  if (packageTypeCondition) return { packageRuntimeCondition: packageTypeCondition, packageRuntimeConditionEvidenceSource: 'package-type', packageType };
+  if (extensionCondition) return runtimeConditionRecord({ packageRuntimeCondition: extensionCondition, packageRuntimeConditionEvidenceSource: 'source-extension', packageType });
+  if (packageTypeCondition) return runtimeConditionRecord({ packageRuntimeCondition: packageTypeCondition, packageRuntimeConditionEvidenceSource: 'package-type', packageType });
   return {};
 }
 
@@ -177,15 +186,28 @@ function packageRuntimeHostConditionAmbiguity(edgeMetadata = {}, packageType) {
   });
 }
 
+function packageRuntimeHostResourceConditionAmbiguity(edgeMetadata = {}, packageType) {
+  const hostKind = edgeMetadata.hostDependencyKind;
+  const hostResourceKind = hostResourceImportDependencyKind(hostKind);
+  if (!hostResourceKind) return undefined;
+  return compactRecord({
+    packageRuntimeConditionEvidenceSource: 'host-resource-import-ambiguous',
+    packageRuntimeConditionEdgeKind: `host-${hostKind}`,
+    packageRuntimeConditionReasonCode: PACKAGE_RUNTIME_CONDITION_HOST_RESOURCE_IMPORT_AMBIGUOUS_MISSING,
+    packageRuntimeConditionHostResourceKind: hostResourceKind,
+    packageType
+  });
+}
+
 function edgeCondition(packageRuntimeCondition, packageRuntimeConditionEdgeKind, packageRuntimeConditionReasonCode, preferred, conflictsWithSource) {
-  return {
+  return runtimeConditionRecord({
     packageRuntimeCondition,
     packageRuntimeConditionEvidenceSource: 'edge-kind',
     packageRuntimeConditionEdgeKind,
     packageRuntimeConditionReasonCode,
     preferred,
     conflictsWithSource
-  };
+  });
 }
 
 function staticImportKind(importKind) {
@@ -240,10 +262,7 @@ function packageTypeByRoot(typeMap, sourcePath) {
     .sort((left, right) => right.root.length - left.root.length)[0]?.value;
 }
 
-function normalizePackageType(value) {
-  const type = typeof value === 'string' ? value : value?.type ?? value?.packageType;
-  return type === 'module' || type === 'commonjs' ? type : undefined;
-}
+function normalizePackageType(value) { const type = typeof value === 'string' ? value : value?.type ?? value?.packageType; return type === 'module' || type === 'commonjs' ? type : undefined; }
 
 function sameSet(left, right) {
   if (left.size !== right.size) return false;
@@ -251,13 +270,8 @@ function sameSet(left, right) {
   return true;
 }
 
-function uniqueStrings(values) {
-  return [...new Set(values.filter((value) => typeof value === 'string' && value))];
-}
-
-function stringValue(value) {
-  return typeof value === 'string' && value.length ? value : undefined;
-}
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value))]; }
+function stringValue(value) { return typeof value === 'string' && value.length ? value : undefined; }
 
 function prioritizeConditions(conditions, preferred) {
   const entries = Array.isArray(conditions) ? conditions : [conditions];
@@ -271,7 +285,6 @@ function prioritizeConditions(conditions, preferred) {
 }
 
 function isRecord(value) { return value && typeof value === 'object' && !Array.isArray(value); }
-
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
 
 function replaceTargetCapture(target, capture) {
@@ -298,17 +311,6 @@ function patternCapture(value, pattern) {
   return String(value).slice(prefix.length, String(value).length - suffix.length);
 }
 
-function pathInsideRoot(sourcePath, root) {
-  if (!root) return true;
-  return sourcePath === root || sourcePath.startsWith(`${root}/`);
-}
+function pathInsideRoot(sourcePath, root) { return !root || sourcePath === root || sourcePath.startsWith(`${root}/`); }
 
-export {
-  exportMapMatch,
-  exportTargetsForValue,
-  packageConditions,
-  packageEnvironmentConditionAmbiguity,
-  packageEnvironmentConditionEvidence,
-  packageRuntimeConditionAmbiguity,
-  packageRuntimeConditionEvidence
-};
+export { exportMapMatch, exportTargetsForValue, packageConditions, packageEnvironmentConditionAmbiguity, packageEnvironmentConditionEvidence, packageRuntimeConditionAmbiguity, packageRuntimeConditionEvidence };

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

@@ -0,0 +1,22 @@
+function runtimeAdmittedConditions(conditions, runtimeCondition) {
+  const entries = Array.isArray(conditions) ? conditions : [conditions];
+  const excluded = new Set(runtimeExcludedConditions(runtimeCondition));
+  return excluded.size ? entries.filter((entry) => !excluded.has(String(entry))) : entries;
+}
+
+function runtimeConditionRecord(record) {
+  return compactRecord({
+    ...record,
+    packageRuntimeConditionExcludedConditions: runtimeExcludedConditions(record.packageRuntimeCondition)
+  });
+}
+
+function runtimeExcludedConditions(runtimeCondition) {
+  if (runtimeCondition === 'import') return ['require'];
+  if (runtimeCondition === 'require') return ['import', 'module'];
+  return [];
+}
+
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { runtimeAdmittedConditions, runtimeConditionRecord };