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

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,7 +14,7 @@ function compilerAdvancedTypeMetadata(value) {
     intersectionTypeCount: numberValue(value.intersectionTypeCount) ?? countKind(advancedTypeShapes, 'intersection-type'),
     tupleTypeCount: numberValue(value.tupleTypeCount) ?? countKind(advancedTypeShapes, 'tuple-type')
   };
-  const proofRequirement = advancedTypeProofRequirement(advancedTypeShapes, counts);
+  const proofRequirement = advancedTypeProofRequirement(advancedTypeShapes, counts, source);
   return {
     counts,
     record: compactRecord({
@@ -40,6 +40,11 @@ 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'),
@@ -98,11 +103,15 @@ const AdvancedTypeProofShapeSpecs = [
   ])
 ];
 
-function advancedTypeProofRequirement(advancedTypeShapes, counts) {
+function advancedTypeProofRequirement(advancedTypeShapes, counts, source = {}) {
   if (!counts.advancedTypeShapeCount) return {};
-  const requiredSignals = advancedTypeRequiredProofSignals(counts);
-  const missingSignals = missingAdvancedTypeProofSignals(advancedTypeShapes, counts);
-  const unsupportedSignals = unsupportedAdvancedTypeProofSignals(counts);
+  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';
@@ -124,6 +133,9 @@ function advancedTypeProofRequirement(advancedTypeShapes, counts) {
     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
   });
@@ -144,10 +156,14 @@ function advancedTypeProofRequirement(advancedTypeShapes, counts) {
   };
 }
 
-function advancedTypeRequiredProofSignals(counts) {
-  return uniqueStrings(AdvancedTypeProofShapeSpecs.flatMap((spec) => (
+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) {
@@ -164,13 +180,68 @@ function missingAdvancedTypeProofSignals(advancedTypeShapes, counts) {
   }));
 }
 
-function unsupportedAdvancedTypeProofSignals(counts) {
+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'] : [];
+  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((item) => item === undefined || item === null);
+  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;
 }
 
@@ -182,6 +253,7 @@ 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/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;
@@ -129,135 +149,6 @@ function staticStructuredLiteralKind(text) {
     : undefined;
 }
 
-function parseStaticLiteralExpression(text) {
-  const state = { text: String(text ?? ''), index: 0 };
-  const parsed = parseStaticLiteralValue(state);
-  skipWhitespace(state);
-  return parsed && state.index === state.text.length ? parsed : undefined;
-}
-
-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 === '{') return parseStaticObjectLiteral(state) ? { kind: 'object-literal' } : undefined;
-  if (char === '[') return parseStaticArrayLiteral(state) ? { kind: 'array-literal' } : undefined;
-  const primitive = parseStaticPrimitiveToken(state);
-  return primitive ? { kind: primitive } : undefined;
-}
-
-function parseStaticObjectLiteral(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] === '[') return false;
-    if (!parseStaticObjectKey(state)) return false;
-    skipWhitespace(state);
-    if (!consumeChar(state, ':')) 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 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] === ',') 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];
-  if (char === '"' || char === "'") return parseQuotedStaticString(state);
-  const numberStart = state.index;
-  if (parseStaticNumberToken(state)) return true;
-  state.index = numberStart;
-  return Boolean(parseIdentifierToken(state));
-}
-
-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 identifier = parseIdentifierToken(state);
-  if (['true', 'false'].includes(identifier)) return 'boolean';
-  if (identifier === 'null') return 'null';
-  if (identifier === 'undefined') return 'undefined';
-  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 staticPropReference(text) {
   const value = normalizedText(text);
   if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(value)) return undefined;

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

@@ -11,6 +11,7 @@ import { jsxImportedComponentOwnerIndexes, jsxImportedMemberComponentOwnerIndexe
 import { jsxSameFileMemberComponentObjectIndex, jsxSameFileMemberComponentOwnerIndex } from './projectSymbolGraphJsxMemberComponents.js';
 import { jsxProviderFlowAncestorMap, jsxProviderFlowRecords } from './projectSymbolGraphJsxProviderFlows.js';
 import { jsxComponentPropRenderFlowBoundary, jsxComponentPropRenderFlowRecords } from './projectSymbolGraphJsxPropFlows.js';
+import { jsxPropComponentFlowRecordFields, jsxPropValueRecordFields } from './projectSymbolGraphJsxPropRecordFields.js';
 import { jsxPropValueEvidence } from './projectSymbolGraphJsxPropValues.js';
 import { lineColumnForOffset } from './lineColumnForOffset.js';
 
@@ -112,7 +113,7 @@ function jsxElementRecord(tag, index, context) {
 function jsxPropRecordsForTag(tag, index, element, context) {
   return tag.attributes.map((attribute, attrIndex) => {
     const sourceSpan = sourceSpanForRange(context, attribute.start, attribute.end);
-    const valueEvidence = jsxPropValueEvidence(tag, attribute);
+    const valueEvidence = jsxPropValueEvidence(tag, attribute, context);
     const componentPropRenderFlow = jsxComponentPropRenderFlowBoundary(tag, attribute, valueEvidence, { componentOwners: context.componentOwners, componentMemberOwners: context.componentMemberOwners, sourcePath: context.sourcePath, sourceText: context.sourceText });
     return compactRecord({
       id: `jsx_prop_${idFragment(context.sourcePath)}_${index + 1}_${attrIndex + 1}`,
@@ -122,36 +123,8 @@ function jsxPropRecordsForTag(tag, index, element, context) {
       propKind: propKind(attribute), keyProp: attribute.name === 'key' || undefined,
       spread: isJsxSpreadAttribute(attribute) || undefined, spreadOrdinal: attribute.spreadOrdinal,
       spreadExpressionHash: spreadExpressionHash(attribute),
-      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,
-      propValueDynamicBlockerReasonCode: valueEvidence?.dynamicBlockerReasonCode,
-      propValueExpressionHash: valueEvidence?.expressionHash, propValueSignatureHash: valueEvidence?.signatureHash,
-      componentPropRenderFlowStatus: componentPropRenderFlow?.status, componentPropRenderFlowReasonCode: componentPropRenderFlow?.reasonCode,
-      componentPropRenderFlowClaim: componentPropRenderFlow?.claim, componentPropRenderFlowClaimScope: componentPropRenderFlow?.claimScope,
-      componentPropRenderFlowRenderEquivalenceClaim: componentPropRenderFlow?.renderEquivalenceClaim,
-      componentPropRenderFlowScope: componentPropRenderFlow?.scope,
-      componentPropRenderFlowTargetName: componentPropRenderFlow?.targetName,
-      componentPropRenderFlowTargetKind: componentPropRenderFlow?.targetKind,
-      componentPropRenderFlowTargetOwnerName: componentPropRenderFlow?.targetOwnerName,
-      componentPropRenderFlowTargetOwnerCount: componentPropRenderFlow?.targetOwnerCount,
-      componentPropRenderFlowTargetSourcePath: componentPropRenderFlow?.targetSourcePath,
-      componentPropRenderFlowTargetLookupStatus: componentPropRenderFlow?.targetLookupStatus, componentPropRenderFlowTargetLookupScope: componentPropRenderFlow?.targetLookupScope,
-      componentPropRenderFlowImportEdgeId: componentPropRenderFlow?.importEdgeId, componentPropRenderFlowImportKind: componentPropRenderFlow?.importKind, componentPropRenderFlowImportedName: componentPropRenderFlow?.importedName, componentPropRenderFlowLocalName: componentPropRenderFlow?.localName, componentPropRenderFlowTargetExportName: componentPropRenderFlow?.targetExportName,
-      componentPropRenderFlowReExportEdgeId: componentPropRenderFlow?.reExportEdgeId, componentPropRenderFlowReExportSourcePath: componentPropRenderFlow?.reExportSourcePath, componentPropRenderFlowReExportExportedName: componentPropRenderFlow?.reExportExportedName, componentPropRenderFlowReExportLocalName: componentPropRenderFlow?.reExportLocalName, componentPropRenderFlowReExportTargetSourcePath: componentPropRenderFlow?.reExportTargetSourcePath, componentPropRenderFlowReExportKind: componentPropRenderFlow?.reExportKind, componentPropRenderFlowReExportIdentityId: componentPropRenderFlow?.reExportIdentityId, componentPropRenderFlowTargetLookupHash: componentPropRenderFlow?.targetLookupHash,
-      componentPropRenderFlowMemberObjectName: componentPropRenderFlow?.memberObjectName, componentPropRenderFlowMemberPropertyName: componentPropRenderFlow?.memberPropertyName, componentPropRenderFlowMemberLocalName: componentPropRenderFlow?.memberLocalName, componentPropRenderFlowMemberBindingKind: componentPropRenderFlow?.memberBindingKind, componentPropRenderFlowMemberBindingHash: componentPropRenderFlow?.memberBindingHash,
-      componentPropRenderFlowComponentPropName: componentPropRenderFlow?.componentPropName,
-      componentPropRenderFlowRenderedTagName: componentPropRenderFlow?.renderedTagName,
-      componentPropRenderFlowRenderedPropName: componentPropRenderFlow?.renderedPropName,
-      componentPropRenderFlowPassthroughExpressionText: componentPropRenderFlow?.passthroughExpressionText,
-      componentPropRenderFlowBindingKind: componentPropRenderFlow?.bindingKind,
-      componentPropRenderFlowReturnOrdinal: componentPropRenderFlow?.returnOrdinal,
-      componentPropRenderFlowDynamicBlockerReasonCode: componentPropRenderFlow?.dynamicBlockerReasonCode,
-      componentPropRenderFlowTargetSignatureHash: componentPropRenderFlow?.targetSignatureHash,
-      componentPropRenderFlowSignatureHash: componentPropRenderFlow?.signatureHash,
+      ...jsxPropValueRecordFields(valueEvidence),
+      ...jsxPropComponentFlowRecordFields(componentPropRenderFlow),
       publicContract: element.publicContract, publicOwnerName: element.publicOwnerName,
       signatureHash: hashSemanticValue({
         kind: 'frontier.lang.projectJsxPropSignature', tagName: tag.tagName, tagKey: tag.key,