@shapeshift-labs/frontier-lang-compiler 0.2.162 → 0.2.164

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, packageRuntimeConditionExcludedConditions: candidate.packageRuntimeConditionExcludedConditions, 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,4 +1,5 @@
 import { runtimeAdmittedConditions, runtimeConditionRecord } from './projectSymbolGraphPackageRuntimeConditions.js';
+import { hostResourceImportDependencyKind } from './moduleHostResourceImportMetadata.js';
 
 const EnvironmentPackageConditions = Object.freeze([
   'browser',
@@ -11,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 [];
@@ -62,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 && (
@@ -182,6 +186,19 @@ 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 runtimeConditionRecord({
     packageRuntimeCondition,
@@ -245,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;
@@ -256,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];
@@ -276,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) {
@@ -303,9 +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 };

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

@@ -5,6 +5,7 @@ import {
 } from './syntaxCommonJsModuleDeclarationEntries.js';
 import { dynamicImportExpressionMetadata } from './dynamicImportExpressionMetadata.js';
 import { hostModuleDependencyMetadata } from './importMetaUrlDependencyMetadata.js';
+import { moduleHostResourceImportMetadata } from './moduleHostResourceImportMetadata.js';
 import { moduleImportAttributeMetadata } from './moduleImportAttributeMetadata.js';
 import {
   declarationName,
@@ -38,10 +39,15 @@ function importDeclarationEntries(node, nativeNodeId, input) {
   if (!moduleSpecifier) return [];
   const typeOnly = node.importKind === 'type';
   const bindings = (node.specifiers ?? []).map((specifier) => importSpecifierBinding(specifier, typeOnly)).filter(Boolean);
+  const importKind = bindings.length === 0 ? 'side-effect' : 'module';
   return importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
     typeOnly,
     sideEffectOnly: bindings.length === 0,
-    importKind: bindings.length === 0 ? 'side-effect' : 'module',
+    importKind,
+    ...moduleHostResourceImportMetadata(moduleSpecifier, {
+      hostDependencyBase: 'module-import',
+      expressionText: `import ${JSON.stringify(moduleSpecifier)}`
+    }),
     ...moduleImportAttributeMetadata(node)
   });
 }
@@ -54,6 +60,10 @@ function dynamicImportExpressionEntries(node, nativeNodeId, input) {
     importKind: 'dynamic-import',
     dynamicImport: true,
     ...dynamicImportExpressionMetadata(importArgument, moduleSpecifier),
+    ...moduleHostResourceImportMetadata(moduleSpecifier, {
+      hostDependencyBase: 'dynamic-import',
+      expressionText: `import(${JSON.stringify(moduleSpecifier)})`
+    }),
     ...moduleImportAttributeMetadata(node)
   });
 }
@@ -75,12 +85,20 @@ function exportNamedDeclarationEntries(node, nativeNodeId, input) {
       typeOnly,
       reexport: true,
       importKind: 'reexport',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     }) : []),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       reExport: Boolean(moduleSpecifier),
       exportKind: typeOnly ? 'type-named' : 'named',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     })
   ];
@@ -107,6 +125,10 @@ function exportAllDeclarationEntries(node, nativeNodeId, input) {
       reexport: true,
       exportStar: !exportedName,
       importKind: exportedName ? 'namespace-reexport' : 'reexport',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     }),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
@@ -114,6 +136,10 @@ function exportAllDeclarationEntries(node, nativeNodeId, input) {
       reExport: true,
       exportStar: !exportedName,
       exportKind: exportedName ? 'namespace-reexport' : 'export-star',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     })
   ];

package/dist/js-ts-safe-project-merge-html-css-matrix.js

@@ -5,6 +5,7 @@ const HtmlCssProjectMergeMissingSignals = Object.freeze({
   cssSelectorTargetEvidence: 'css-selector-target-evidence-missing',
   htmlStructuralMerge: 'html-structural-merge-proof-blocked',
   cssCascadeMerge: 'css-cascade-merge-proof-blocked',
+  cssDependencyGraphEvidence: 'css-dependency-graph-evidence-missing',
   htmlCssBrowserRuntimeProof: 'html-css-browser-runtime-proof-not-available'
 });
 
@@ -16,6 +17,7 @@ function htmlCssProjectMergeMissingEvidenceRoutes(route, signals) {
     [signals.cssSelectorTargetEvidence]: route('prove-css-selector-target-evidence', 'layout-style-targets', 'supply-selector-target-graph-and-rebase-evidence'),
     [signals.htmlStructuralMerge]: route('admit-html-structural-merge', 'layout-markup-graph', 'supply-html-parser-reference-and-boundary-evidence'),
     [signals.cssCascadeMerge]: route('admit-css-cascade-merge', 'layout-style-graph', 'supply-css-parser-cascade-and-scope-evidence'),
+    [signals.cssDependencyGraphEvidence]: route('prove-css-dependency-graph', 'layout-style-graph', 'supply-css-custom-property-animation-font-and-asset-dependency-graph'),
     [signals.htmlCssBrowserRuntimeProof]: route('prove-html-css-browser-runtime', 'browser-proof', 'attach-browser-runtime-proof-bundle')
   };
 }
@@ -28,6 +30,7 @@ function htmlCssProjectMergeAdmissionMatrixRows(matrixRow, signals) {
     matrixRow('css-selector-target-evidence', 'bounded-evidence', ['css-selector-target-evidence'], [signals.cssSelectorTargetEvidence]),
     matrixRow('html-structural-merge-admission', 'partial', ['html-structural-merge'], [signals.htmlStructuralMerge]),
     matrixRow('css-cascade-merge-admission', 'partial', ['css-cascade-merge'], [signals.cssCascadeMerge]),
+    matrixRow('css-dependency-graph-evidence', 'bounded-evidence', ['css-dependency-graph'], [signals.cssDependencyGraphEvidence]),
     matrixRow('html-css-browser-runtime-proof', 'bounded-evidence', ['browser-runtime-proof'], [signals.htmlCssBrowserRuntimeProof])
   ];
 }
@@ -36,10 +39,11 @@ function htmlCssProjectMergeMissingEvidenceItems(summary, signals, missingEviden
   const items = [];
   if (summary.htmlFiles && summary.htmlParserEvidenceFiles !== summary.htmlFiles) items.push(missingEvidenceItem({ code: signals.htmlParserEvidence, scope: 'layout-markup-parser', kind: 'html-parser-source-evidence', proofLevel: 'html-parser-source-evidence', action: 'review', summary: `HTML project merge has parser/source evidence for ${summary.htmlParserEvidenceFiles}/${summary.htmlFiles} file(s); require parse5 source spans, zero parse errors, and attribute/trivia spans when those surfaces are present before parser evidence admission.` }));
   if (summary.cssFiles && summary.cssParserEvidenceFiles !== summary.cssFiles) items.push(missingEvidenceItem({ code: signals.cssParserEvidence, scope: 'layout-style-parser', kind: 'css-parser-source-evidence', proofLevel: 'css-parser-source-evidence', action: 'review', summary: `CSS project merge has parser/source evidence for ${summary.cssParserEvidenceFiles}/${summary.cssFiles} file(s); require PostCSS rule/declaration spans, raw trivia hashes, and zero parse errors before parser evidence admission.` }));
-  if (summary.htmlFiles && summary.htmlIdentityEvidenceFiles !== summary.htmlFiles) items.push(missingEvidenceItem({ code: signals.htmlIdentityEvidence, scope: 'layout-markup-identity', kind: 'html-identity-evidence', proofLevel: 'html-identity-evidence', action: 'review', summary: `HTML project merge has structural identity evidence for ${summary.htmlIdentityEvidenceFiles}/${summary.htmlFiles} file(s); require parser-backed structural spans and stable explicit/path identity accounting before structural admission.` }));
+  if (summary.htmlFiles && summary.htmlIdentityEvidenceFiles !== summary.htmlFiles) items.push(missingEvidenceItem({ code: signals.htmlIdentityEvidence, scope: 'layout-markup-identity', kind: 'html-identity-evidence', proofLevel: 'html-identity-evidence', action: 'review', summary: `HTML project merge has structural identity evidence for ${summary.htmlIdentityEvidenceFiles}/${summary.htmlFiles} file(s) with ${summary.htmlDuplicateIdentityEvidenceFiles ?? 0} duplicate identity evidence file(s); require parser-backed structural spans, unique explicit identity keys, and stable explicit/path identity accounting before structural admission.` }));
   if (summary.cssFiles && (summary.cssSelectorTargetEvidenceFiles !== summary.cssFiles || summary.cssSelectorTargetConflictFiles)) items.push(missingEvidenceItem({ code: signals.cssSelectorTargetEvidence, scope: 'layout-style-targets', kind: 'css-selector-target-evidence', proofLevel: 'css-selector-target-evidence', action: 'review', summary: `CSS project merge has selector-target evidence for ${summary.cssSelectorTargetEvidenceFiles}/${summary.cssFiles} file(s) with ${summary.cssSelectorTargetConflictFiles} selector target conflict(s); require selector target graph and proven rebase before target-moving merges.` }));
   if (summary.htmlBlockedFiles) items.push(missingEvidenceItem({ code: signals.htmlStructuralMerge, scope: 'layout-markup-graph', kind: 'html-structural-merge-proof', proofLevel: 'html-structural-merge', action: 'review', summary: `HTML project merge has ${summary.htmlBlockedFiles} blocked file(s); supply parser/source-span evidence, stable element identity, and runtime-boundary proof before admission.` }));
-  if (summary.cssBlockedFiles) items.push(missingEvidenceItem({ code: signals.cssCascadeMerge, scope: 'layout-style-graph', kind: 'css-cascade-merge-proof', proofLevel: 'css-cascade-merge', action: 'review', summary: `CSS project merge has ${summary.cssBlockedFiles} blocked file(s); supply parser/cascade/scope evidence and keep browser claims false until runtime proof passes.` }));
+  if (summary.cssBlockedFiles) items.push(missingEvidenceItem({ code: signals.cssCascadeMerge, scope: 'layout-style-graph', kind: 'css-cascade-merge-proof', proofLevel: 'css-cascade-merge', action: 'review', summary: `CSS project merge has ${summary.cssBlockedFiles} blocked file(s), including ${summary.cssScopedCascadeBlockedFiles} scoped cascade proof block(s); supply parser/cascade/scope evidence, require scopedCascadeGraphHash for changed declarations under @media/@supports/@container/@layer/@scope or nested scopes, and keep browser claims false until runtime proof passes.` }));
+  if (summary.cssDependencySurfaceFiles && (summary.cssDependencyGraphEvidenceFiles !== summary.cssDependencySurfaceFiles || summary.cssDependencyGraphMissingProofFiles || summary.cssDependencyGraphBlockedFiles)) items.push(missingEvidenceItem({ code: signals.cssDependencyGraphEvidence, scope: 'layout-style-graph', kind: 'css-dependency-graph-evidence', proofLevel: 'css-dependency-graph', action: 'review', summary: `CSS project merge has dependency graph evidence for ${summary.cssDependencyGraphEvidenceFiles}/${summary.cssDependencySurfaceFiles} dependency-surface file(s), ${summary.cssDependencyGraphMissingProofFiles} missing dependency graph proof(s), and ${summary.cssDependencyGraphBlockedFiles} dependency blocker(s); require custom property, var() fallback, @keyframes/animation-name, @font-face, and url() asset graph evidence before cascade/browser equivalence claims.`, suggestedInput: { cssDependencyGraphEvidence: true } }));
   if (summary.htmlCssMergedFiles && !summary.htmlCssBrowserRuntimeProofs) items.push(missingEvidenceItem({ code: signals.htmlCssBrowserRuntimeProof, scope: 'browser-proof', kind: 'browser-runtime-proof', proofLevel: 'browser-runtime-proof', action: 'review', summary: 'HTML/CSS structural source merge was available, but browser DOM/cascade/layout/runtime proof was not attached; keep browser equivalence claims false.', suggestedInput: { browserRuntimeProof: true } }));
   return items;
 }
@@ -51,6 +55,7 @@ function htmlCssProjectMergeMatrixProofStatus(level, summary) {
   if (level === 'css-selector-target-evidence') return summary.cssFiles ? (summary.cssSelectorTargetConflictFiles ? 'failed' : summary.cssSelectorTargetEvidenceFiles === summary.cssFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'html-structural-merge') return summary.htmlFiles ? (summary.htmlBlockedFiles ? 'failed' : summary.htmlMergedFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'css-cascade-merge') return summary.cssFiles ? (summary.cssBlockedFiles ? 'failed' : summary.cssMergedFiles ? 'passed' : 'missing') : 'absent';
+  if (level === 'css-dependency-graph') return summary.cssDependencySurfaceFiles ? (summary.cssDependencyGraphBlockedFiles ? 'failed' : summary.cssDependencyGraphEvidenceFiles === summary.cssDependencySurfaceFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'browser-runtime-proof') return summary.htmlCssFiles ? (summary.htmlCssBrowserRuntimeProofs ? 'passed' : 'missing') : 'absent';
   return undefined;
 }