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

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

@@ -0,0 +1,47 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const HOST_RESOURCE_IMPORT_KINDS = Object.freeze({
+  'css-import': 'css',
+  'css-module-import': 'css-module',
+  'html-import': 'html'
+});
+
+export function moduleHostResourceImportMetadata(moduleSpecifier, options = {}) {
+  const hostDependencyKind = moduleHostResourceImportKind(moduleSpecifier);
+  if (!hostDependencyKind) return {};
+  const hostDependencyBase = options.hostDependencyBase ?? 'module-import';
+  const hostDependencyExpressionText = options.expressionText ?? String(moduleSpecifier);
+  return {
+    hostDependency: true,
+    hostDependencyKind,
+    hostDependencyBase,
+    hostDependencyExpressionText,
+    hostDependencyExpressionHash: hashSemanticValue({
+      kind: hostDependencyKind,
+      moduleSpecifier,
+      base: hostDependencyBase,
+      expressionText: hostDependencyExpressionText
+    }),
+    hostDependencyStaticSpecifierEvidence: true,
+    hostDependencyRuntimeResolutionClaim: false,
+    hostDependencyResolutionProofRequired: true
+  };
+}
+
+export function moduleHostResourceImportKind(moduleSpecifier) {
+  const path = resourcePath(moduleSpecifier);
+  if (!path) return undefined;
+  if (/\.module\.css$/i.test(path)) return 'css-module-import';
+  if (/\.css$/i.test(path)) return 'css-import';
+  if (/\.html?$/i.test(path)) return 'html-import';
+  return undefined;
+}
+
+export function hostResourceImportDependencyKind(hostDependencyKind) {
+  return HOST_RESOURCE_IMPORT_KINDS[hostDependencyKind];
+}
+
+function resourcePath(moduleSpecifier) {
+  const path = String(moduleSpecifier ?? '').split(/[?#]/, 1)[0];
+  return path || undefined;
+}

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

@@ -1,4 +1,4 @@
-function compilerAdvancedTypeMetadata(value) {
+function compilerAdvancedTypeMetadata(value, source = {}) {
   const advancedTypeShapes = arrayValue(value.advancedTypeShapes);
   const typeReferenceTargets = arrayValue(value.typeReferenceTargets);
   const counts = {
@@ -14,11 +14,14 @@ function compilerAdvancedTypeMetadata(value) {
     intersectionTypeCount: numberValue(value.intersectionTypeCount) ?? countKind(advancedTypeShapes, 'intersection-type'),
     tupleTypeCount: numberValue(value.tupleTypeCount) ?? countKind(advancedTypeShapes, 'tuple-type')
   };
+  const proofRequirement = advancedTypeProofRequirement(advancedTypeShapes, counts, source);
   return {
     counts,
     record: compactRecord({
       advancedTypeShapeCount: counts.advancedTypeShapeCount || undefined,
       advancedTypeShapeKinds: value.advancedTypeShapeKinds ?? nonEmptyArray(uniqueStrings(advancedTypeShapes.map((shape) => shape.kind))),
+      advancedTypeProofRequirement: proofRequirement.requirement,
+      advancedTypeMissingProof: proofRequirement.missingProof,
       typeReferenceTargetCount: counts.typeReferenceTargetCount || undefined,
       conditionalTypeCount: counts.conditionalTypeCount || undefined,
       mappedTypeCount: counts.mappedTypeCount || undefined,
@@ -35,11 +38,222 @@ function compilerAdvancedTypeMetadata(value) {
   };
 }
 
+const AdvancedTypeProofRequirementKind = 'typescript-checker-public-api-advanced-type-shape-equivalence';
+const AdvancedTypeProofRequiredEvidence = 'typescript-checker-public-api-type-equivalence';
+const AdvancedTypeSourcePathSignal = 'compiler-public-api-advanced-type-source-path';
+const AdvancedTypeSourceHashSignal = 'compiler-public-api-advanced-type-source-hash';
+const AdvancedTypeSourcePathStaleSignal = 'compiler-public-api-advanced-type-source-path-stale';
+const AdvancedTypeSourceHashStaleSignal = 'compiler-public-api-advanced-type-source-hash-stale';
+const AdvancedTypeClaimBearingSignal = 'compiler-advanced-type-shape-claim-bearing';
+const AdvancedTypeProofShapeSpecs = [
+  proofShapeSpec('conditional-type', 'conditionalTypeCount', [
+    proofField('nodeText', 'compiler-conditional-type-node-texts'),
+    proofField('typeText', 'compiler-conditional-type-type-texts'),
+    proofField('checkTypeText', 'compiler-conditional-type-check-type-texts'),
+    proofField('extendsTypeText', 'compiler-conditional-type-extends-type-texts'),
+    proofField('trueTypeText', 'compiler-conditional-type-true-type-texts'),
+    proofField('falseTypeText', 'compiler-conditional-type-false-type-texts')
+  ]),
+  proofShapeSpec('mapped-type', 'mappedTypeCount', [
+    proofField('nodeText', 'compiler-mapped-type-node-texts'),
+    proofField('typeText', 'compiler-mapped-type-type-texts'),
+    proofField('mappedConstraintTypeText', 'compiler-mapped-type-constraint-type-texts'),
+    proofField('mappedValueTypeText', 'compiler-mapped-type-value-type-texts')
+  ]),
+  proofShapeSpec('indexed-access-type', 'indexedAccessTypeCount', [
+    proofField('nodeText', 'compiler-indexed-access-type-node-texts'),
+    proofField('typeText', 'compiler-indexed-access-type-type-texts'),
+    proofField('objectTypeText', 'compiler-indexed-access-type-object-type-texts'),
+    proofField('indexTypeText', 'compiler-indexed-access-type-index-type-texts')
+  ]),
+  proofShapeSpec('keyof-type-operator', 'keyofTypeOperatorCount', [
+    proofField('nodeText', 'compiler-keyof-type-operator-node-texts'),
+    proofField('typeText', 'compiler-keyof-type-operator-type-texts'),
+    proofField('keyofTargetTypeText', 'compiler-keyof-type-operator-target-type-texts')
+  ]),
+  proofShapeSpec('template-literal-type', 'templateLiteralTypeCount', [
+    proofField('nodeText', 'compiler-template-literal-type-node-texts'),
+    proofField('typeText', 'compiler-template-literal-type-type-texts'),
+    proofField('templateHeadText', 'compiler-template-literal-type-head-texts'),
+    proofField('templateSpanTexts', 'compiler-template-literal-type-span-texts'),
+    proofField('templateSpanTypeTexts', 'compiler-template-literal-type-span-type-texts'),
+    proofField('templateLiteralTexts', 'compiler-template-literal-type-literal-texts')
+  ]),
+  proofShapeSpec('infer-type', 'inferTypeCount', [
+    proofField('nodeText', 'compiler-infer-type-node-texts'),
+    proofField('typeText', 'compiler-infer-type-type-texts'),
+    proofField('typeParameterText', 'compiler-infer-type-type-parameter-texts'),
+    proofField('typeParameterName', 'compiler-infer-type-type-parameter-names')
+  ]),
+  proofShapeSpec('union-type', 'unionTypeCount', [
+    proofField('nodeText', 'compiler-union-type-node-texts'),
+    proofField('typeText', 'compiler-union-type-type-texts'),
+    proofField('memberTypeTexts', 'compiler-union-type-member-type-texts')
+  ]),
+  proofShapeSpec('intersection-type', 'intersectionTypeCount', [
+    proofField('nodeText', 'compiler-intersection-type-node-texts'),
+    proofField('typeText', 'compiler-intersection-type-type-texts'),
+    proofField('memberTypeTexts', 'compiler-intersection-type-member-type-texts')
+  ]),
+  proofShapeSpec('tuple-type', 'tupleTypeCount', [
+    proofField('nodeText', 'compiler-tuple-type-node-texts'),
+    proofField('typeText', 'compiler-tuple-type-type-texts'),
+    proofField('tupleElementTexts', 'compiler-tuple-type-element-texts'),
+    proofField('tupleElementTypeTexts', 'compiler-tuple-type-element-type-texts')
+  ])
+];
+
+function advancedTypeProofRequirement(advancedTypeShapes, counts, source = {}) {
+  if (!counts.advancedTypeShapeCount) return {};
+  const sourceBinding = advancedTypeSourceBinding(source);
+  const requiredSignals = advancedTypeRequiredProofSignals(counts, sourceBinding);
+  const missingSignals = uniqueStrings([
+    ...missingAdvancedTypeProofSignals(advancedTypeShapes, counts),
+    ...missingAdvancedTypeSourceBindingSignals(sourceBinding)
+  ]);
+  const unsupportedSignals = unsupportedAdvancedTypeProofSignals(advancedTypeShapes, counts, sourceBinding);
+  const status = unsupportedSignals.length
+    ? 'requires-review'
+    : missingSignals.length ? 'missing-compiler-evidence' : 'requires-type-equivalence-proof';
+  const requirement = compactRecord({
+    kind: AdvancedTypeProofRequirementKind,
+    requiredEvidence: AdvancedTypeProofRequiredEvidence,
+    status,
+    requiredSignals,
+    missingSignals: nonEmptyArray(missingSignals),
+    unsupportedSignals: nonEmptyArray(unsupportedSignals),
+    advancedTypeShapeCount: counts.advancedTypeShapeCount,
+    advancedTypeShapeKinds: nonEmptyArray(uniqueStrings(advancedTypeShapes.map((shape) => shape.kind))),
+    conditionalTypeCount: counts.conditionalTypeCount || undefined,
+    mappedTypeCount: counts.mappedTypeCount || undefined,
+    indexedAccessTypeCount: counts.indexedAccessTypeCount || undefined,
+    keyofTypeOperatorCount: counts.keyofTypeOperatorCount || undefined,
+    templateLiteralTypeCount: counts.templateLiteralTypeCount || undefined,
+    inferTypeCount: counts.inferTypeCount || undefined,
+    unionTypeCount: counts.unionTypeCount || undefined,
+    intersectionTypeCount: counts.intersectionTypeCount || undefined,
+    tupleTypeCount: counts.tupleTypeCount || undefined,
+    sourcePath: sourceBinding.sourcePath,
+    sourceHash: sourceBinding.sourceHash,
+    sourceBound: sourceBinding.required ? sourceBinding.bound : undefined,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+  return {
+    requirement,
+    missingProof: status === 'requires-type-equivalence-proof' ? undefined : compactRecord({
+      kind: AdvancedTypeProofRequirementKind,
+      requiredEvidence: AdvancedTypeProofRequiredEvidence,
+      status,
+      reasonCode: status === 'missing-compiler-evidence'
+        ? 'typescript-public-api-advanced-type-shape-proof-missing'
+        : 'typescript-public-api-advanced-type-shape-proof-requires-review',
+      missingSignals: nonEmptyArray(missingSignals),
+      unsupportedSignals: nonEmptyArray(unsupportedSignals),
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+}
+
+function advancedTypeRequiredProofSignals(counts, sourceBinding) {
+  const shapeSignals = AdvancedTypeProofShapeSpecs.flatMap((spec) => (
+    counts[spec.countKey] > 0 ? [countSignal(spec.kind), ...spec.fields.map((field) => field.signal)] : []
+  ));
+  return uniqueStrings([
+    ...shapeSignals,
+    ...(sourceBinding.required ? [AdvancedTypeSourcePathSignal, AdvancedTypeSourceHashSignal] : [])
+  ]);
+}
+
+function missingAdvancedTypeProofSignals(advancedTypeShapes, counts) {
+  return uniqueStrings(AdvancedTypeProofShapeSpecs.flatMap((spec) => {
+    const count = counts[spec.countKey] || 0;
+    if (!count) return [];
+    const shapes = advancedTypeShapes.filter((shape) => shape?.kind === spec.kind);
+    const missing = [];
+    if (shapes.length !== count) missing.push(countSignal(spec.kind));
+    for (const field of spec.fields) {
+      if (shapes.some((shape) => fieldMissing(shape?.[field.key]))) missing.push(field.signal);
+    }
+    return missing;
+  }));
+}
+
+function missingAdvancedTypeSourceBindingSignals(sourceBinding) {
+  if (!sourceBinding.required) return [];
+  return [
+    sourceBinding.sourcePath ? undefined : AdvancedTypeSourcePathSignal,
+    sourceBinding.sourceHash ? undefined : AdvancedTypeSourceHashSignal
+  ].filter(Boolean);
+}
+
+function unsupportedAdvancedTypeProofSignals(advancedTypeShapes, counts, sourceBinding) {
+  const knownShapeCount = AdvancedTypeProofShapeSpecs.reduce((sum, spec) => sum + (counts[spec.countKey] || 0), 0);
+  return [
+    counts.advancedTypeShapeCount > knownShapeCount ? 'compiler-unknown-advanced-type-shape' : undefined,
+    ...staleAdvancedTypeSourceBindingSignals(advancedTypeShapes, sourceBinding),
+    hasClaimBearingAdvancedTypeShape(advancedTypeShapes) ? AdvancedTypeClaimBearingSignal : undefined
+  ].filter(Boolean);
+}
+
+function staleAdvancedTypeSourceBindingSignals(advancedTypeShapes, sourceBinding) {
+  if (!sourceBinding.required) return [];
+  const stalePath = sourceBinding.sourcePath
+    && advancedTypeShapes.some((shape) => nonBlankString(shape?.sourcePath) && shape.sourcePath !== sourceBinding.sourcePath);
+  const staleHash = sourceBinding.sourceHash
+    && advancedTypeShapes.some((shape) => nonBlankString(shape?.sourceHash) && shape.sourceHash !== sourceBinding.sourceHash);
+  return [
+    stalePath ? AdvancedTypeSourcePathStaleSignal : undefined,
+    staleHash ? AdvancedTypeSourceHashStaleSignal : undefined
+  ].filter(Boolean);
+}
+
+function hasClaimBearingAdvancedTypeShape(advancedTypeShapes) {
+  return advancedTypeShapes.some((shape) => [
+    shape?.proofClaim,
+    shape?.autoMergeClaim,
+    shape?.semanticEquivalenceClaim,
+    shape?.runtimeEquivalenceClaim,
+    shape?.proof?.proofClaim,
+    shape?.proof?.autoMergeClaim,
+    shape?.proof?.semanticEquivalenceClaim,
+    shape?.proof?.runtimeEquivalenceClaim
+  ].some((value) => value === true));
+}
+
+function advancedTypeSourceBinding(source) {
+  const required = source?.publicContract === true;
+  const sourcePath = nonBlankString(source?.sourcePath) ? source.sourcePath : undefined;
+  const sourceHash = nonBlankString(source?.sourceHash) ? source.sourceHash : undefined;
+  return {
+    required,
+    sourcePath,
+    sourceHash,
+    bound: !required || Boolean(sourcePath && sourceHash)
+  };
+}
+
+function fieldMissing(value) {
+  if (Array.isArray(value)) return !value.length || value.some(arrayFieldEntryMissing);
+  if (typeof value === 'string') return value.trim().length === 0;
+  return value === undefined || value === null;
+}
+
+function arrayFieldEntryMissing(value) {
+  if (Array.isArray(value)) return !value.length || value.some(arrayFieldEntryMissing);
+  return value === undefined || value === null;
+}
+
+function proofShapeSpec(kind, countKey, fields) { return { kind, countKey, fields }; }
+function proofField(key, signal) { return { key, signal }; }
+function countSignal(kind) { return `compiler-${kind}-count`; }
 function countKind(records, kind) { return records.filter((record) => record.kind === kind).length; }
 function arrayValue(value) { return Array.isArray(value) ? value : []; }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
 function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
 function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function nonBlankString(value) { return typeof value === 'string' && value.trim().length > 0; }
 function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
 
 export { compilerAdvancedTypeMetadata };

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

@@ -69,7 +69,7 @@ function compilerTypeRecord(fact, symbol, document, publicSymbolIds, compilerSym
   const indexSignatureReadonlyCount = numberValue(value.indexSignatureReadonlyCount) ?? compilerIndexSignatureReadonlyCount(value.indexSignatures);
   const constructorSignatureCount = numberValue(value.constructorSignatureCount) ?? arrayLength(value.constructorSignatures);
   const classHeritageCount = numberValue(value.classHeritageCount) ?? arrayLength(value.classHeritage);
-  const advancedType = compilerAdvancedTypeMetadata(value);
+  const advancedType = compilerAdvancedTypeMetadata(value, sourceBinding);
   const enumShape = compilerEnumShapeMetadata(value);
   const typeInferenceSyntax = compilerTypeInferenceSyntaxMetadata(value, sourceBinding);
   const classMemberShape = compilerClassMemberShapeMetadata(value, sourceBinding);

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

@@ -19,10 +19,11 @@ function cssModuleSourceRecord(imported) {
   );
   const sourceText = nativeImportSourceText(imported);
   const inferredEvidence = suppliedEvidence ? undefined : inferCssModuleEvidence(sourceText, sourcePath, metadata, nativeMetadata, astMetadata);
+  const cssModuleEvidence = normalizeCssModuleEvidence(suppliedEvidence ?? inferredEvidence);
   return compactRecord({
     sourcePath,
     sourceHash: imported?.nativeSource?.sourceHash ?? imported?.metadata?.sourceHash,
-    cssModuleEvidence: suppliedEvidence ?? inferredEvidence,
+    cssModuleEvidence,
     cssModuleEvidenceSource: suppliedEvidence ? 'supplied' : inferredEvidence ? 'inferred-source' : undefined,
     bundlerTransformHash: firstString(metadata.bundlerTransformHash, nativeMetadata.bundlerTransformHash, astMetadata.bundlerTransformHash),
     sourceMapProofHash: firstString(metadata.sourceMapProofHash, nativeMetadata.sourceMapProofHash, astMetadata.sourceMapProofHash)
@@ -134,6 +135,48 @@ function semanticSpanForHash(span) {
   return span ? { path: span.path, start: span.start, end: span.end, startLine: span.startLine, startColumn: span.startColumn, endLine: span.endLine, endColumn: span.endColumn } : undefined;
 }
 
+function normalizeCssModuleEvidence(evidence) {
+  if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return undefined;
+  const icssExportNames = cssModuleIcssExportNames(evidence);
+  const exportNames = uniqueSortedStrings([
+    ...cssModuleEvidenceExportNames(evidence),
+    ...(evidence.icssGraphHash ? icssExportNames : [])
+  ]);
+  return compactRecord({
+    ...evidence,
+    icssExportNames: icssExportNames.length ? icssExportNames : undefined,
+    exportNames: exportNames.length ? exportNames : evidence.exportNames
+  });
+}
+
+function cssModuleEvidenceExportNames(evidence) {
+  return uniqueSortedStrings([
+    ...arrayValue(evidence?.exportNames),
+    ...arrayValue(evidence?.localClassNames),
+    ...arrayValue(evidence?.classNames),
+    ...cssModuleExportRecordNames(evidence?.exports),
+    ...objectKeys(evidence?.exports),
+    ...objectKeys(evidence?.generatedClassNameMap),
+    ...objectKeys(evidence?.classMap)
+  ]);
+}
+
+function cssModuleIcssExportNames(evidence) {
+  return uniqueSortedStrings([
+    ...arrayValue(evidence?.icssExportNames),
+    ...cssModuleExportRecordNames(evidence?.icssExports),
+    ...objectKeys(evidence?.icssExports),
+    ...cssModuleExportRecordNames(evidence?.icss?.exports),
+    ...objectKeys(evidence?.icss?.exports)
+  ]);
+}
+
+function cssModuleExportRecordNames(value) {
+  return Array.isArray(value)
+    ? value.map((entry) => entry?.name ?? entry?.localName ?? entry?.exportedName).filter(Boolean)
+    : [];
+}
+
 function compactRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }
@@ -150,6 +193,18 @@ function objectValue(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
 
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function objectKeys(value) {
+  return Object.keys(objectValue(value));
+}
+
+function uniqueSortedStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))].sort();
+}
+
 function firstObject(...values) {
   return values.find((value) => value && typeof value === 'object' && !Array.isArray(value));
 }

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

@@ -37,10 +37,13 @@ function createProjectCssModuleGraphRecords(semanticIndex, imports, importEdges,
   const namedImportBlockers = importBindings
     .filter((binding) => binding.importKind === 'named')
     .map((binding) => cssModuleNamedExportBlocker(binding));
-  const missingTransformBlockers = importBindings
-    .filter((binding) => hasUseSite(binding, lexicalUseSites) || hasUseSite(binding, jsxUseSites))
-    .flatMap((binding) => cssModuleTransformBlockers(binding));
   const cssModuleUseSites = uniqueRecords([...jsxUseSites, ...lexicalUseSites], cssModuleUseSiteKey);
+  const usedImportBindings = importBindings
+    .filter((binding) => hasUseSite(binding, cssModuleUseSites));
+  const missingTransformBlockers = usedImportBindings
+    .flatMap((binding) => cssModuleTransformBlockers(binding));
+  const missingDependencyGraphBlockers = usedImportBindings
+    .flatMap((binding) => cssModuleDependencyGraphBlockers(binding, cssSourcesByPath));
   const bindingsById = new Map(importBindings.map((binding) => [binding.id, binding]));
   const missingExportBlockers = cssModuleMissingExportBlockers(bindingsById, cssModuleUseSites);
   const cssModuleUseSiteBlockers = uniqueRecords([
@@ -48,7 +51,8 @@ function createProjectCssModuleGraphRecords(semanticIndex, imports, importEdges,
     ...jsxBlockers,
     ...namedImportBlockers,
     ...missingExportBlockers,
-    ...missingTransformBlockers
+    ...missingTransformBlockers,
+    ...missingDependencyGraphBlockers
   ], cssModuleBlockerKey);
   return {
     cssModuleImportBindings: importBindings,
@@ -75,6 +79,46 @@ function cssModuleNamedExportBlocker(binding) {
   });
 }
 
+function cssModuleDependencyGraphBlockers(binding, cssSourcesByPath) {
+  const cssModuleEvidence = cssSourcesByPath.get(binding.cssModuleSourcePath)?.cssModuleEvidence;
+  const blockers = [];
+  if (requiresCssModuleCompositionGraph(cssModuleEvidence) && !binding.cssModuleCompositionGraphHash) {
+    blockers.push(cssModuleBindingBlocker(binding, {
+      reasonCode: 'css-module-composition-resolution-unproved',
+      expressionText: binding.localName
+    }));
+  }
+  if (requiresIcssGraph(cssModuleEvidence) && !binding.icssGraphHash) {
+    blockers.push(cssModuleBindingBlocker(binding, {
+      reasonCode: 'css-module-icss-graph-unproved',
+      expressionText: binding.localName
+    }));
+  }
+  return blockers;
+}
+
+function requiresCssModuleCompositionGraph(cssModuleEvidence) {
+  return hasCssModuleProofGap(cssModuleEvidence, 'css-module-composition-resolution-unproved')
+    || hasRecords(cssModuleEvidence?.compositions);
+}
+
+function requiresIcssGraph(cssModuleEvidence) {
+  return hasCssModuleProofGap(cssModuleEvidence, 'css-module-icss-graph-unproved')
+    || hasRecords(cssModuleEvidence?.icssImports)
+    || hasRecords(cssModuleEvidence?.icssExports)
+    || hasRecords(cssModuleEvidence?.icss?.imports)
+    || hasRecords(cssModuleEvidence?.icss?.exports);
+}
+
+function hasCssModuleProofGap(cssModuleEvidence, code) {
+  return (cssModuleEvidence?.proofGaps ?? []).some((gap) => gap?.code === code);
+}
+
+function hasRecords(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  return value && typeof value === 'object' ? Object.keys(value).length > 0 : false;
+}
+
 function hasUseSite(binding, useSites) {
   return useSites.some((site) => site.cssModuleImportBindingId === binding.id);
 }

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

@@ -0,0 +1,91 @@
+function jsxPropValueRecordFields(valueEvidence) {
+  return {
+    propValueProofStatus: valueEvidence?.proofStatus,
+    propValueReasonCode: valueEvidence?.reasonCode,
+    propValueKind: valueEvidence?.valueKind,
+    propValueText: valueEvidence?.valueText,
+    propValueExpressionText: valueEvidence?.expressionText,
+    propValueReferenceRoot: valueEvidence?.referenceRoot,
+    propValueReferencePath: valueEvidence?.referencePath,
+    propValueDynamicText: valueEvidence?.dynamicText,
+    propValueOptionalReference: valueEvidence?.optionalReference,
+    propValueOptionalReferenceSegments: valueEvidence?.optionalReferenceSegments,
+    propValueOptionalReferenceSegmentIndexes: valueEvidence?.optionalReferenceSegmentIndexes,
+    propValueOptionalNullishBoundaryCount: valueEvidence?.optionalNullishBoundaryCount,
+    propValueClaimScope: valueEvidence?.claimScope,
+    propValueRenderEquivalenceClaim: valueEvidence?.renderEquivalenceClaim,
+    propValueStaticSpreadSourceKind: valueEvidence?.staticSpreadSourceKind,
+    propValueStaticSpreadSourceName: valueEvidence?.staticSpreadSourceName,
+    propValueStaticSpreadPropEntries: valueEvidence?.staticSpreadPropEntries,
+    propValueStaticSpreadPropNames: valueEvidence?.staticSpreadPropNames,
+    propValueStaticSpreadPropCount: valueEvidence?.staticSpreadPropCount,
+    propValueStaticSpreadEffectivePropEntries: valueEvidence?.staticSpreadEffectivePropEntries,
+    propValueStaticSpreadEffectivePropNames: valueEvidence?.staticSpreadEffectivePropNames,
+    propValueStaticSpreadExplicitOverridePropNames: valueEvidence?.staticSpreadExplicitOverridePropNames,
+    propValueStaticSpreadOverridesExplicitPropNames: valueEvidence?.staticSpreadOverridesExplicitPropNames,
+    propValueStaticSpreadDuplicatePropNames: valueEvidence?.staticSpreadDuplicatePropNames,
+    propValueStaticSpreadPrecedenceStatus: valueEvidence?.staticSpreadPrecedenceStatus,
+    propValueDynamicBlockerReasonCode: valueEvidence?.dynamicBlockerReasonCode,
+    propValueExpressionHash: valueEvidence?.expressionHash,
+    propValueSignatureHash: valueEvidence?.signatureHash
+  };
+}
+
+function jsxPropComponentFlowRecordFields(flow) {
+  return {
+    componentPropRenderFlowStatus: flow?.status,
+    componentPropRenderFlowReasonCode: flow?.reasonCode,
+    componentPropRenderFlowClaim: flow?.claim,
+    componentPropRenderFlowClaimScope: flow?.claimScope,
+    componentPropRenderFlowRenderEquivalenceClaim: flow?.renderEquivalenceClaim,
+    componentPropRenderFlowScope: flow?.scope,
+    componentPropRenderFlowTargetName: flow?.targetName,
+    componentPropRenderFlowTargetKind: flow?.targetKind,
+    componentPropRenderFlowTargetOwnerName: flow?.targetOwnerName,
+    componentPropRenderFlowTargetOwnerCount: flow?.targetOwnerCount,
+    componentPropRenderFlowTargetSourcePath: flow?.targetSourcePath,
+    componentPropRenderFlowTargetLookupStatus: flow?.targetLookupStatus,
+    componentPropRenderFlowTargetLookupScope: flow?.targetLookupScope,
+    componentPropRenderFlowImportEdgeId: flow?.importEdgeId,
+    componentPropRenderFlowImportKind: flow?.importKind,
+    componentPropRenderFlowImportedName: flow?.importedName,
+    componentPropRenderFlowLocalName: flow?.localName,
+    componentPropRenderFlowTargetExportName: flow?.targetExportName,
+    ...jsxPropComponentFlowReExportFields(flow),
+    ...jsxPropComponentFlowMemberFields(flow),
+    componentPropRenderFlowComponentPropName: flow?.componentPropName,
+    componentPropRenderFlowRenderedTagName: flow?.renderedTagName,
+    componentPropRenderFlowRenderedPropName: flow?.renderedPropName,
+    componentPropRenderFlowPassthroughExpressionText: flow?.passthroughExpressionText,
+    componentPropRenderFlowBindingKind: flow?.bindingKind,
+    componentPropRenderFlowReturnOrdinal: flow?.returnOrdinal,
+    componentPropRenderFlowDynamicBlockerReasonCode: flow?.dynamicBlockerReasonCode,
+    componentPropRenderFlowTargetSignatureHash: flow?.targetSignatureHash,
+    componentPropRenderFlowSignatureHash: flow?.signatureHash
+  };
+}
+
+function jsxPropComponentFlowReExportFields(flow) {
+  return {
+    componentPropRenderFlowReExportEdgeId: flow?.reExportEdgeId,
+    componentPropRenderFlowReExportSourcePath: flow?.reExportSourcePath,
+    componentPropRenderFlowReExportExportedName: flow?.reExportExportedName,
+    componentPropRenderFlowReExportLocalName: flow?.reExportLocalName,
+    componentPropRenderFlowReExportTargetSourcePath: flow?.reExportTargetSourcePath,
+    componentPropRenderFlowReExportKind: flow?.reExportKind,
+    componentPropRenderFlowReExportIdentityId: flow?.reExportIdentityId,
+    componentPropRenderFlowTargetLookupHash: flow?.targetLookupHash
+  };
+}
+
+function jsxPropComponentFlowMemberFields(flow) {
+  return {
+    componentPropRenderFlowMemberObjectName: flow?.memberObjectName,
+    componentPropRenderFlowMemberPropertyName: flow?.memberPropertyName,
+    componentPropRenderFlowMemberLocalName: flow?.memberLocalName,
+    componentPropRenderFlowMemberBindingKind: flow?.memberBindingKind,
+    componentPropRenderFlowMemberBindingHash: flow?.memberBindingHash
+  };
+}
+
+export { jsxPropComponentFlowRecordFields, jsxPropValueRecordFields };

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

@@ -1,13 +1,13 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { isJsxSpreadAttribute } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { jsxSpreadPropValueEvidence } from './projectSymbolGraphJsxSpreadPropValues.js';
+import { parseStaticLiteralExpression } from './projectSymbolGraphJsxStaticLiterals.js';
 import { staticOptionalMemberReference } from './staticOptionalMemberReference.js';
 
-function jsxPropValueEvidence(tag, attribute) {
-  if (isJsxSpreadAttribute(attribute)) return undefined;
-  const assignedValueText = jsxAssignedPropValueText(attribute);
-  const evidence = assignedValueText === undefined
-    ? staticPropValueEvidence('boolean-shorthand', 'true', 'true')
-    : jsxAssignedPropValueEvidence(assignedValueText);
+function jsxPropValueEvidence(tag, attribute, context = {}) {
+  const evidence = isJsxSpreadAttribute(attribute)
+    ? jsxSpreadPropValueEvidence(tag, attribute, context)
+    : jsxNonSpreadPropValueEvidence(attribute);
   return compactRecord({
     ...evidence,
     expressionHash: hashSemanticValue({
@@ -34,12 +34,32 @@ function jsxPropValueEvidence(tag, attribute) {
       optionalReferenceSegments: evidence.optionalReferenceSegments,
       optionalReferenceSegmentIndexes: evidence.optionalReferenceSegmentIndexes,
       optionalNullishBoundaryCount: evidence.optionalNullishBoundaryCount,
+      claimScope: evidence.claimScope,
+      renderEquivalenceClaim: evidence.renderEquivalenceClaim,
+      staticSpreadSourceKind: evidence.staticSpreadSourceKind,
+      staticSpreadSourceName: evidence.staticSpreadSourceName,
+      staticSpreadPropEntries: evidence.staticSpreadPropEntries,
+      staticSpreadPropNames: evidence.staticSpreadPropNames,
+      staticSpreadPropCount: evidence.staticSpreadPropCount,
+      staticSpreadEffectivePropEntries: evidence.staticSpreadEffectivePropEntries,
+      staticSpreadEffectivePropNames: evidence.staticSpreadEffectivePropNames,
+      staticSpreadExplicitOverridePropNames: evidence.staticSpreadExplicitOverridePropNames,
+      staticSpreadOverridesExplicitPropNames: evidence.staticSpreadOverridesExplicitPropNames,
+      staticSpreadDuplicatePropNames: evidence.staticSpreadDuplicatePropNames,
+      staticSpreadPrecedenceStatus: evidence.staticSpreadPrecedenceStatus,
       dynamicText: evidence.dynamicText,
       dynamicBlockerReasonCode: evidence.dynamicBlockerReasonCode
     })
   });
 }
 
+function jsxNonSpreadPropValueEvidence(attribute) {
+  const assignedValueText = jsxAssignedPropValueText(attribute);
+  return assignedValueText === undefined
+    ? staticPropValueEvidence('boolean-shorthand', 'true', 'true')
+    : jsxAssignedPropValueEvidence(assignedValueText);
+}
+
 function jsxAssignedPropValueText(attribute) {
   const match = /^[A-Za-z_$][\w$:-]*\s*=\s*([\s\S]*)$/.exec(String(attribute?.text ?? '').trim());
   return match ? normalizedText(match[1]) : undefined;
@@ -119,7 +139,14 @@ function staticLiteralKind(text) {
   if (value === 'undefined') return 'undefined';
   if (/^[-]?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) return 'number';
   if (quotedLiteralText(value)) return 'string';
-  return undefined;
+  return staticStructuredLiteralKind(value);
+}
+
+function staticStructuredLiteralKind(text) {
+  const parsed = parseStaticLiteralExpression(text);
+  return parsed && ['object-literal', 'array-literal', 'template-string'].includes(parsed.kind)
+    ? parsed.kind
+    : undefined;
 }
 
 function staticPropReference(text) {
@@ -133,6 +160,7 @@ function staticPropReference(text) {
 function jsxPropValueDynamicBlockerReasonCode(text) {
   const value = normalizedText(text);
   if (/\[[\s\S]*\]/.test(value)) return 'jsx-render-prop-value-computed-reference-unsupported';
+  if (/^`[\s\S]*\$\{[\s\S]*`$/.test(value)) return 'jsx-render-prop-value-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-value-call-expression-unsupported';
   if (/\?\./.test(value)) return 'jsx-render-prop-value-optional-reference-unsupported';
   return 'jsx-render-prop-value-expression-unsupported';