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

package/dist/declarations/js-ts-project-merge-summary.d.ts

@@ -5,7 +5,7 @@ export interface JsTsProjectSafeMergeSummary {
   readonly files: number; readonly mergedFiles: number; readonly blockedFiles: number; readonly outputFiles: number;
   readonly htmlFiles:number; readonly cssFiles:number; readonly htmlCssFiles:number; readonly htmlMergedFiles:number; readonly cssMergedFiles:number; readonly htmlCssMergedFiles:number; readonly htmlBlockedFiles:number; readonly cssBlockedFiles:number; readonly htmlCssBlockedFiles:number; readonly htmlCssBrowserRuntimeProofs:number;
   readonly htmlParserEvidenceFiles:number; readonly cssParserEvidenceFiles:number; readonly htmlCssParserEvidenceFiles:number; readonly htmlParserEvidenceFailedFiles:number; readonly cssParserEvidenceFailedFiles:number; readonly htmlCssParserEvidenceFailedFiles:number;
-  readonly htmlIdentityEvidenceFiles:number; readonly cssSelectorTargetEvidenceFiles:number; readonly htmlCssStructuralTargetEvidenceFiles:number; readonly htmlIdentityEvidenceFailedFiles:number; readonly cssSelectorTargetConflictFiles:number; readonly htmlCssStructuralTargetEvidenceFailedFiles:number;
+  readonly htmlIdentityEvidenceFiles:number; readonly cssSelectorTargetEvidenceFiles:number; readonly htmlCssStructuralTargetEvidenceFiles:number; readonly htmlIdentityEvidenceFailedFiles:number; readonly cssSelectorTargetConflictFiles:number; readonly htmlCssStructuralTargetEvidenceFailedFiles:number; readonly cssSelectorTargetRebasedFiles:number;
   readonly projectGraphConflicts: number; readonly projectGraphDeltaEvidenceIncluded: number; readonly outputProjectGraphConflicts:number; readonly projectGraphCssModuleUseSiteConflicts:number; readonly projectGraphDeltaConflicts: number; readonly projectGraphLimitConflicts: number; readonly projectGraphPublicContractConflicts: number; readonly projectGraphSourceSpanConflicts: number;
   readonly projectGraphCompilerTypeConflicts: number; readonly projectGraphRuntimeRegionConflicts: number; readonly projectGraphScopeUseDefConflicts: number; readonly projectGraphJsxPropConflicts: number; readonly projectGraphJsxRenderRiskConflicts: number; readonly projectGraphReExportIdentityConflicts: number; readonly projectGraphModuleDeclarationShapeConflicts: number; readonly projectGraphExportAssignmentShapeConflicts: number;
   readonly projectGraphImportAttributeConflicts: number; readonly projectGraphImportTargetConflicts: number; readonly outputDiagnostics: number; readonly outputDiagnosticConflicts: number; readonly outputDiagnosticErrors: number; readonly outputDiagnosticWarnings: number; readonly outputDeclarations: number; readonly outputDeclarationBytes: number; readonly outputDeclarationConflicts: number; readonly outputDeclarationDiagnosticErrors: number; readonly outputQualityGates: number; readonly outputQualityGateConflicts: number;

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

@@ -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);
   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,6 +38,145 @@ function compilerAdvancedTypeMetadata(value) {
   };
 }
 
+const AdvancedTypeProofRequirementKind = 'typescript-checker-public-api-advanced-type-shape-equivalence';
+const AdvancedTypeProofRequiredEvidence = 'typescript-checker-public-api-type-equivalence';
+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) {
+  if (!counts.advancedTypeShapeCount) return {};
+  const requiredSignals = advancedTypeRequiredProofSignals(counts);
+  const missingSignals = missingAdvancedTypeProofSignals(advancedTypeShapes, counts);
+  const unsupportedSignals = unsupportedAdvancedTypeProofSignals(counts);
+  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,
+    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) {
+  return uniqueStrings(AdvancedTypeProofShapeSpecs.flatMap((spec) => (
+    counts[spec.countKey] > 0 ? [countSignal(spec.kind), ...spec.fields.map((field) => field.signal)] : []
+  )));
+}
+
+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 unsupportedAdvancedTypeProofSignals(counts) {
+  const knownShapeCount = AdvancedTypeProofShapeSpecs.reduce((sum, spec) => sum + (counts[spec.countKey] || 0), 0);
+  return counts.advancedTypeShapeCount > knownShapeCount ? ['compiler-unknown-advanced-type-shape'] : [];
+}
+
+function fieldMissing(value) {
+  if (Array.isArray(value)) return !value.length || value.some((item) => item === undefined || item === null);
+  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)); }

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/projectSymbolGraphJsxPropValues.js

@@ -119,9 +119,145 @@ function staticLiteralKind(text) {
   if (value === 'undefined') return 'undefined';
   if (/^[-]?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) return 'number';
   if (quotedLiteralText(value)) return 'string';
+  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 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;
@@ -133,6 +269,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';

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

@@ -295,7 +295,7 @@ function packageSpecifierInfo(moduleSpecifier) {
 
 function packageResolutionFields(candidate, packageInfo) {
   if (!candidate.packageName && candidate.kind !== 'package') return {};
-  return { packageName: candidate.packageName ?? packageInfo?.packageName, packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath, packageExportKey: candidate.packageExportKey, packageExportCondition: candidate.packageExportCondition, packageExportTarget: candidate.packageExportTarget, packageImportKey: candidate.packageImportKey, packageImportCondition: candidate.packageImportCondition, packageImportTarget: candidate.packageImportTarget, packageRuntimeCondition: candidate.packageRuntimeCondition, packageRuntimeConditionEvidenceSource: candidate.packageRuntimeConditionEvidenceSource, packageRuntimeConditionEdgeKind: candidate.packageRuntimeConditionEdgeKind, packageRuntimeConditionCandidates: candidate.packageRuntimeConditionCandidates, packageRuntimeConditionReasonCode: candidate.packageRuntimeConditionReasonCode, packageEnvironmentCondition: candidate.packageEnvironmentCondition, packageEnvironmentConditionEvidenceSource: candidate.packageEnvironmentConditionEvidenceSource, packageEnvironmentConditionCandidates: candidate.packageEnvironmentConditionCandidates, packageEnvironmentConditionReasonCode: candidate.packageEnvironmentConditionReasonCode, packageType: candidate.packageType, packageWorkspaceRootAmbiguous: candidate.packageWorkspaceRootAmbiguous, packageWorkspaceRoots: candidate.packageWorkspaceRoots, packageResolutionReasonCode: candidate.packageResolutionReasonCode };
+  return { packageName: candidate.packageName ?? packageInfo?.packageName, packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath, packageExportKey: candidate.packageExportKey, packageExportCondition: candidate.packageExportCondition, packageExportTarget: candidate.packageExportTarget, packageImportKey: candidate.packageImportKey, packageImportCondition: candidate.packageImportCondition, packageImportTarget: candidate.packageImportTarget, packageRuntimeCondition: candidate.packageRuntimeCondition, packageRuntimeConditionEvidenceSource: candidate.packageRuntimeConditionEvidenceSource, packageRuntimeConditionEdgeKind: candidate.packageRuntimeConditionEdgeKind, packageRuntimeConditionCandidates: candidate.packageRuntimeConditionCandidates, packageRuntimeConditionExcludedConditions: candidate.packageRuntimeConditionExcludedConditions, packageRuntimeConditionReasonCode: candidate.packageRuntimeConditionReasonCode, 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' }; }

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

@@ -1,3 +1,5 @@
+import { runtimeAdmittedConditions, runtimeConditionRecord } from './projectSymbolGraphPackageRuntimeConditions.js';
+
 const EnvironmentPackageConditions = Object.freeze([
   'browser',
   'node',
@@ -30,7 +32,10 @@ function exportMapMatch(exportsValue, subpath) {
 
 function packageConditions(moduleResolution = {}, sourcePath, packageContext, edgeMetadata) {
   return prioritizeConditions(
-    moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'],
+    runtimeAdmittedConditions(
+      moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'],
+      packageRuntimeConditionEvidence(moduleResolution, sourcePath, packageContext, edgeMetadata).packageRuntimeCondition
+    ),
     packageConditionPreferences(sourcePath, moduleResolution, packageContext, edgeMetadata)
   );
 }
@@ -78,8 +83,8 @@ function packageRuntimeConditionEvidence(moduleResolution = {}, sourcePath, pack
   }
   const hostAmbiguity = edgeCondition ? undefined : packageRuntimeHostConditionAmbiguity(edgeMetadata, packageType);
   if (hostAmbiguity) return hostAmbiguity;
-  if (extensionCondition) return { packageRuntimeCondition: extensionCondition, packageRuntimeConditionEvidenceSource: 'source-extension', packageType };
-  if (packageTypeCondition) return { packageRuntimeCondition: packageTypeCondition, packageRuntimeConditionEvidenceSource: 'package-type', packageType };
+  if (extensionCondition) return runtimeConditionRecord({ packageRuntimeCondition: extensionCondition, packageRuntimeConditionEvidenceSource: 'source-extension', packageType });
+  if (packageTypeCondition) return runtimeConditionRecord({ packageRuntimeCondition: packageTypeCondition, packageRuntimeConditionEvidenceSource: 'package-type', packageType });
   return {};
 }
 
@@ -178,14 +183,14 @@ function packageRuntimeHostConditionAmbiguity(edgeMetadata = {}, packageType) {
 }
 
 function edgeCondition(packageRuntimeCondition, packageRuntimeConditionEdgeKind, packageRuntimeConditionReasonCode, preferred, conflictsWithSource) {
-  return {
+  return runtimeConditionRecord({
     packageRuntimeCondition,
     packageRuntimeConditionEvidenceSource: 'edge-kind',
     packageRuntimeConditionEdgeKind,
     packageRuntimeConditionReasonCode,
     preferred,
     conflictsWithSource
-  };
+  });
 }
 
 function staticImportKind(importKind) {
@@ -303,12 +308,4 @@ function pathInsideRoot(sourcePath, root) {
   return sourcePath === root || sourcePath.startsWith(`${root}/`);
 }
 
-export {
-  exportMapMatch,
-  exportTargetsForValue,
-  packageConditions,
-  packageEnvironmentConditionAmbiguity,
-  packageEnvironmentConditionEvidence,
-  packageRuntimeConditionAmbiguity,
-  packageRuntimeConditionEvidence
-};
+export { exportMapMatch, exportTargetsForValue, packageConditions, packageEnvironmentConditionAmbiguity, packageEnvironmentConditionEvidence, packageRuntimeConditionAmbiguity, packageRuntimeConditionEvidence };

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

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

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

@@ -8,6 +8,7 @@ import { nearestPublicOwnerForOffset } from './projectSymbolGraphScopeUseDefOwne
 import { readStaticMemberLiteral } from './staticMemberLiteral.js';
 
 const jsTsKeywords = new Set('abstract as async await break case catch class const continue debugger declare default delete do else enum export extends false finally for from function if implements import in infer instanceof interface keyof let module namespace new null of package private protected public readonly return satisfies static super switch this throw true try type typeof undefined unique unknown var void while with yield'.split(' '));
+const namespaceComputedMemberDynamicUnsupportedReason = 'lexical-scope-namespace-computed-member-dynamic-unsupported', namespaceComputedMemberUnresolvedReason = 'lexical-scope-namespace-computed-member-unresolved';
 
 function lexicalScopeRecordsForImport(sourceText, context) {
   const masked = maskNonCode(sourceText);
@@ -230,15 +231,17 @@ function namespacePropertyAccess(code, token, binding, context) {
 
 function namespaceComputedPropertyAccess(sourceText, code, tokenStart, open) {
   const close = findMatchingBracket(code, open);
-  if (close === -1) return blockedNamespaceComputedPropertyAccess();
+  if (close === -1) return blockedNamespaceComputedPropertyAccess(undefined, [namespaceComputedMemberUnresolvedReason]);
   const writeOperation = namespaceMemberWriteOperation(code, tokenStart, close + 1);
   let index = open + 1;
   while (index < close && /\s/.test(sourceText[index])) index += 1;
+  if (index >= close) return blockedNamespaceComputedPropertyAccess(writeOperation, [namespaceComputedMemberUnresolvedReason]);
   const literal = readStaticMemberLiteral(sourceText, index, close);
-  if (!literal) return blockedNamespaceComputedPropertyAccess(writeOperation);
+  if (!literal) return blockedNamespaceComputedPropertyAccess(writeOperation, [namespaceComputedMemberDynamicUnsupportedReason]);
   let afterLiteral = literal.end + 1;
   while (afterLiteral < close && /\s/.test(sourceText[afterLiteral])) afterLiteral += 1;
-  if (afterLiteral !== close || !identifierRegExp.test(literal.value)) return blockedNamespaceComputedPropertyAccess(writeOperation);
+  if (afterLiteral !== close) return blockedNamespaceComputedPropertyAccess(writeOperation, [namespaceComputedMemberDynamicUnsupportedReason]);
+  if (!identifierRegExp.test(literal.value)) return blockedNamespaceComputedPropertyAccess(writeOperation);
   if (writeOperation) {
     return blockedNamespaceMemberWrite('namespace-computed-property-write', {
       memberName: literal.value,
@@ -252,31 +255,18 @@ function namespaceComputedPropertyAccess(sourceText, code, tokenStart, open) {
   return { referenceKind: 'namespace-computed-property-read', memberName: literal.value, memberStart: literal.start, memberEnd: literal.end, memberComputed: true, memberLiteralKind: literal.literalKind };
 }
 
-function blockedNamespaceComputedPropertyAccess(writeOperation) {
+function blockedNamespaceComputedPropertyAccess(writeOperation, reasonCodes = []) {
   return {
     referenceKind: writeOperation ? 'namespace-computed-property-write' : 'namespace-computed-property-read',
     memberComputed: true,
     writeOperation,
     status: 'blocked',
-    reasonCodes: [
-      LexicalUseDefReasonCodes.namespaceComputedMemberUnsupported,
-      ...(writeOperation ? [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported] : [])
-    ]
+    reasonCodes: uniqueReasonCodes([LexicalUseDefReasonCodes.namespaceComputedMemberUnsupported, ...reasonCodes, ...(writeOperation ? [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported] : [])])
   };
 }
 
 function blockedNamespaceMemberWrite(referenceKind, fields = {}) {
-  return {
-    referenceKind,
-    memberName: fields.memberName,
-    memberStart: fields.memberStart,
-    memberEnd: fields.memberEnd,
-    memberComputed: fields.memberComputed,
-    memberLiteralKind: fields.memberLiteralKind,
-    status: 'blocked',
-    reasonCodes: [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported],
-    writeOperation: fields.writeOperation
-  };
+  return { referenceKind, memberName: fields.memberName, memberStart: fields.memberStart, memberEnd: fields.memberEnd, memberComputed: fields.memberComputed, memberLiteralKind: fields.memberLiteralKind, status: 'blocked', reasonCodes: [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported], writeOperation: fields.writeOperation };
 }
 
 function namespaceMemberWriteOperation(code, tokenStart, accessEnd) {
@@ -317,4 +307,6 @@ function findMatchingBracket(code, open) {
   return -1;
 }
 
+function uniqueReasonCodes(reasonCodes) { return [...new Set(reasonCodes.filter(Boolean))]; }
+
 export { lexicalScopeRecordsForImport };

package/dist/js-ts-safe-project-merge-admission.js

@@ -80,10 +80,18 @@ function exactBranchProjectSemanticEditAdmission(options) {
     if (requireOtherBranchUnchanged && !otherProjectBranchUnchanged(file, classification.branch, { requireBase: requireBaseForOtherBranchUnchanged })) return undefined;
   }
   const outputHash = hashProjectSourceText(branchText);
+  const admissionOutcome = 'safe';
+  const admissionOutcomeReasonCode = exactMergedOutput && allowExistingExactOutput
+    ? 'existing-exact-branch-output'
+    : typeof branchText === 'string'
+      ? 'exact-branch-output-other-branch-unchanged'
+      : 'exact-branch-deletion-other-branch-unchanged';
   const admission = {
     id: safeProjectEvidenceId(`${classification.details?.conflictKey ?? classification.code}_${file.sourcePath}`),
     kind: admissionKind,
     status: 'passed',
+    admissionOutcome,
+    admissionOutcomeReasonCode,
     branch: classification.branch,
     ...(admissionFields(classification) ?? {}),
     sourcePath: file.sourcePath,
@@ -94,6 +102,8 @@ function exactBranchProjectSemanticEditAdmission(options) {
       ...(details(classification) ?? {}),
       sourcePath: file.sourcePath,
       outputHash,
+      admissionOutcome,
+      admissionOutcomeReasonCode,
       exactBranchOutput: true,
       deletedOutput: typeof branchText !== 'string' || undefined,
       autoMergeClaim: false,

package/dist/js-ts-safe-project-merge-evidence-routing.js

@@ -21,7 +21,7 @@ function fileAdmissionEvidenceRecords(files = []) {
   return files.flatMap((file) => [
     ...recordArraysWithSuffix(file.summary, 'AdmissionEvidence'),
     ...recordArraysWithSuffix(file.metadata, 'Admissions')
-  ]);
+  ].map(admissionEvidenceRecordWithOutcome));
 }
 
 function recordArraysWithSuffix(record, suffix) {
@@ -32,7 +32,35 @@ function recordArraysWithSuffix(record, suffix) {
     .filter((value) => value?.kind && value?.id);
 }
 
+function admissionEvidenceRecordWithOutcome(record) {
+  const admissionOutcome = admissionEvidenceOutcome(record);
+  return compactRecord({
+    ...record,
+    admissionOutcome,
+    admissionOutcomeReasonCode: admissionEvidenceOutcomeReasonCode(record, admissionOutcome)
+  });
+}
+
+function admissionEvidenceOutcome(record) {
+  if (['safe', 'review', 'blocked'].includes(record?.admissionOutcome)) return record.admissionOutcome;
+  const routeStatus = record?.admissionRoute?.status;
+  if (record?.status === 'passed' && (!routeStatus || routeStatus === 'passed')) return 'safe';
+  if (record?.status === 'failed' || routeStatus === 'failed' || routeStatus === 'blocked') return 'blocked';
+  return 'review';
+}
+
+function admissionEvidenceOutcomeReasonCode(record, admissionOutcome) {
+  if (typeof record?.admissionOutcomeReasonCode === 'string' && record.admissionOutcomeReasonCode.length > 0) return record.admissionOutcomeReasonCode;
+  const routeReasonCode = record?.admissionRoute?.reasonCodes?.[0];
+  if (typeof record?.details?.reasonCode === 'string' && record.details.reasonCode.length > 0) return record.details.reasonCode;
+  if (typeof routeReasonCode === 'string' && routeReasonCode.length > 0) return routeReasonCode;
+  if (admissionOutcome === 'safe' && record?.details?.exactBranchOutput === true) return 'passed-exact-branch-output';
+  if (admissionOutcome === 'safe') return 'passed-admission-evidence';
+  if (admissionOutcome === 'blocked') return 'failed-admission-evidence';
+  return 'review-admission-evidence';
+}
+
 function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
 
-export { failedEvidenceMissingItems, fileAdmissionEvidenceRecords };
+export { admissionEvidenceOutcome, failedEvidenceMissingItems, fileAdmissionEvidenceRecords };

package/dist/js-ts-safe-project-merge-graph-delta-compiler-conflicts.js

@@ -117,6 +117,8 @@ function missingSharedCompilerTypeEquivalenceEvidence(workerRecord, headRecord)
       enumMemberCount: record.enumMemberCount,
       enumComputedMemberCount: record.enumComputedMemberCount,
       typeEquivalenceEnumRuntimeShapeHash: record.typeEquivalenceEnumRuntimeShapeHash,
+      advancedTypeProofRequirement: record.advancedTypeProofRequirement,
+      advancedTypeMissingProof: record.advancedTypeMissingProof,
       typeEquivalenceSignatureSetHash: record.typeEquivalenceSignatureSetHash,
       typeEquivalenceCallSignatureSetHash: record.typeEquivalenceCallSignatureSetHash, typeEquivalenceConstructSignatureSetHash: record.typeEquivalenceConstructSignatureSetHash,
       typeEquivalenceTypeParameterSetHash: record.typeEquivalenceTypeParameterSetHash,
@@ -169,9 +171,14 @@ function hasPassedCompilerTypeEquivalenceProof(record) {
   ];
   return Boolean(record?.typeEquivalenceStatus === 'compiler-backed-equivalent'
     && record?.typeEquivalenceProof?.status === 'passed'
+    && !hasMissingAdvancedTypeProof(record)
     && requiredHashes.every(([required, hash]) => !required || hash)
     && record?.apiSignatureHash);
 }
+function hasMissingAdvancedTypeProof(record) {
+  const status = record?.advancedTypeMissingProof?.status ?? record?.advancedTypeProofRequirement?.status;
+  return status === 'missing-compiler-evidence' || status === 'requires-review';
+}
 function recordsByIdentityKey(records, identityKey) { const result = new Map(); for (const record of records ?? []) { const key = identityKey(record); if (!key || result.has(key)) continue; result.set(key, record); } return result; }
 function optionalFingerprint(record, fingerprint) { return record ? fingerprint(record) : undefined; }
 function stableKey(parts) { const values = parts.map((part) => part === undefined || part === null ? '' : String(part)); return values.some(Boolean) ? values.join('#') : undefined; }

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

@@ -7,7 +7,11 @@ function htmlCssProjectSummary(files) {
     htmlParserEvidenceFiles: htmlFiles.filter(hasHtmlParserEvidence).length, cssParserEvidenceFiles: cssFiles.filter(hasCssParserEvidence).length, htmlCssParserEvidenceFiles: htmlCssFiles.filter((file) => hasHtmlParserEvidence(file) || hasCssParserEvidence(file)).length,
     htmlParserEvidenceFailedFiles: htmlFiles.filter(hasParserEvidenceFailure).length, cssParserEvidenceFailedFiles: cssFiles.filter(hasParserEvidenceFailure).length, htmlCssParserEvidenceFailedFiles: htmlCssFiles.filter(hasParserEvidenceFailure).length,
     htmlIdentityEvidenceFiles: htmlFiles.filter(hasHtmlIdentityEvidence).length, cssSelectorTargetEvidenceFiles: cssFiles.filter(hasCssSelectorTargetEvidence).length, htmlCssStructuralTargetEvidenceFiles: htmlCssFiles.filter((file) => hasHtmlIdentityEvidence(file) || hasCssSelectorTargetEvidence(file)).length,
+    htmlExplicitIdentityEvidenceFiles: htmlFiles.filter(hasHtmlExplicitIdentityEvidence).length, htmlPathOnlyIdentityResidualFiles: htmlFiles.filter(hasHtmlPathOnlyIdentityResidual).length,
+    htmlRuntimeBoundaryEvidenceFiles: htmlFiles.filter(hasHtmlRuntimeBoundaryEvidence).length, htmlFrameworkBoundaryEvidenceFiles: htmlFiles.filter(hasHtmlFrameworkBoundaryEvidence).length, htmlProofGapBlockedFiles: htmlFiles.filter(hasHtmlProofGapBlockedConflict).length,
     htmlIdentityEvidenceFailedFiles: htmlFiles.filter(hasHtmlIdentityEvidenceFailure).length, cssSelectorTargetConflictFiles: cssFiles.filter(hasCssSelectorTargetConflict).length, htmlCssStructuralTargetEvidenceFailedFiles: htmlCssFiles.filter((file) => hasHtmlIdentityEvidenceFailure(file) || hasCssSelectorTargetConflict(file)).length,
+    cssSelectorTargetRebasedFiles: cssFiles.filter(hasCssSelectorTargetRebase).length,
+    cssScopedCascadeFiles: cssFiles.filter(hasCssScopedCascadeScope).length, cssScopedCascadeEvidenceFiles: cssFiles.filter(hasCssScopedCascadeEvidence).length, cssScopedCascadeBlockedFiles: cssFiles.filter(hasCssScopedCascadeMissingProof).length,
     htmlCssBrowserRuntimeProofs: htmlCssFiles.filter(hasBrowserRuntimeProof).length
   };
 }
@@ -30,6 +34,13 @@ function hasHtmlIdentityEvidence(file) {
   const evidence = file?.result?.identityEvidence;
   return evidence?.parserBackedStructuralSpans === true && evidence.structuralAddressability === true;
 }
+function hasHtmlExplicitIdentityEvidence(file) {
+  const evidence = file?.result?.identityEvidence;
+  return hasHtmlIdentityEvidence(file) && evidence.explicitIdentityAvailable === true;
+}
+function hasHtmlPathOnlyIdentityResidual(file) { return (file?.result?.identityEvidence?.pathOnlyIdentityElements ?? 0) > 0; }
+function hasHtmlRuntimeBoundaryEvidence(file) { return (file?.result?.identityEvidence?.runtimeBoundaryElements ?? 0) > 0; }
+function hasHtmlFrameworkBoundaryEvidence(file) { return (file?.result?.identityEvidence?.frameworkBoundaryElements ?? 0) > 0; }
 function hasHtmlIdentityEvidenceFailure(file) {
   const evidence = file?.result?.identityEvidence;
   return Boolean(evidence) && (evidence.parserBackedStructuralSpans !== true || evidence.structuralAddressability !== true);
@@ -41,9 +52,26 @@ function hasCssSelectorTargetEvidence(file) {
 function hasCssSelectorTargetConflict(file) {
   return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => conflict.code === 'css-selector-target-conflict');
 }
+function hasHtmlProofGapBlockedConflict(file) {
+  return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => conflict.code === 'html-proof-gap-blocked');
+}
+function hasCssSelectorTargetRebase(file) { return (file?.result?.selectorTargetEvidence?.rebasedChangeCount ?? 0) > 0; }
+function hasCssScopedCascadeScope(file) { return cssScopedRuleCount(file) > 0; }
+function hasCssScopedCascadeEvidence(file) {
+  return hasCssScopedCascadeScope(file) && file?.result?.parserEvidence?.scopedCascadeGraphHashPresent === true;
+}
+function hasCssScopedCascadeMissingProof(file) {
+  return hasCssScopedCascadeScope(file) && (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => ScopedCascadeMissingProofReasonCodes.has(conflict?.details?.reasonCode));
+}
+function cssScopedRuleCount(file) {
+  const sides = Object.values(file?.result?.selectorTargetEvidence?.sides ?? {});
+  return sides.reduce((count, side) => Math.max(count, side?.scopedRuleCount ?? 0), 0);
+}
 function hasBrowserRuntimeProof(file) {
   const admission = file?.result?.admission ?? file?.admission ?? {};
   return admission.browserRuntimeEquivalenceClaim === true || admission.browserCascadeEquivalenceClaim === true || admission.browserRenderEquivalenceClaim === true;
 }
 
+const ScopedCascadeMissingProofReasonCodes = new Set(['css-scoped-cascade-equivalence-unproved', 'css-media-cascade-scope-unproved', 'css-supports-cascade-scope-unproved', 'css-container-cascade-scope-unproved', 'css-layer-cascade-scope-unproved', 'css-scope-cascade-scope-unproved']);
+
 export { htmlCssProjectSummary };

package/dist/native-source-preservation-scanner.js

@@ -57,6 +57,16 @@ function scanPreservedSourceTokens(sourceText, input) {
       push(trivia, 'whitespace', text, start);
       continue;
     }
+    if (offset === 0 && char === '#' && next === '!') {
+      let text = '';
+      while (offset < sourceText.length && sourceText[offset] !== '\n' && sourceText[offset] !== '\r') {
+        text += sourceText[offset];
+        offset += 1;
+        column += 1;
+      }
+      push(trivia, 'shebang', text, start);
+      continue;
+    }
     if (char === '/' && next === '/') {
       let text = '';
       while (offset < sourceText.length && sourceText[offset] !== '\n' && sourceText[offset] !== '\r') {

package/dist/semantic-import-runtime-dynamic-import-evidence.js

@@ -0,0 +1,141 @@
+function dynamicImportEvidenceRecords(line, start, end) {
+  const expression = String(line ?? '');
+  const records = [];
+  for (const call of dynamicImportCalls(expression)) {
+    if (!rangesOverlap(start, end, call.start, call.end) && !rangesOverlap(start, end, call.argumentStart, call.argumentEnd)) continue;
+    const specifier = normalizeOrderEvidenceText(call.argumentText);
+    const specifierKind = dynamicImportSpecifierKind(specifier, call.closed);
+    const staticSpecifier = dynamicImportStaticSpecifierEvidence(specifier, specifierKind);
+    records.push(compactRecord({
+      kind: 'dynamic-import',
+      ordinal: records.length + 1,
+      text: normalizeOrderEvidenceText(call.text),
+      specifierText: specifier,
+      specifierKind,
+      dynamicImportStaticSpecifierEvidence: staticSpecifier,
+      dynamicImportRuntimeResolutionClaim: false,
+      dynamicImportResolutionProofRequired: !staticSpecifier,
+      runtimeEquivalenceClaim: false
+    }));
+  }
+  return records;
+}
+
+function dynamicImportCalls(expression) {
+  const text = String(expression ?? '');
+  const records = [];
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') { quote = char; continue; }
+    const match = dynamicImportAt(text, index);
+    if (!match) continue;
+    records.push(match);
+    index = Math.max(index, match.end - 1);
+  }
+  return records;
+}
+
+function dynamicImportAt(text, index) {
+  if (text.slice(index, index + 6) !== 'import' || isIdentifierPart(text[index - 1]) || isIdentifierPart(text[index + 6])) return undefined;
+  let cursor = index + 6;
+  while (/\s/.test(text[cursor] ?? '')) cursor += 1;
+  if (text[cursor] !== '(') return undefined;
+  const close = matchingParenIndex(text, cursor);
+  const end = close === undefined ? statementEnd(text, cursor) : close + 1;
+  return {
+    start: index,
+    text: text.slice(index, end),
+    argumentText: firstCallArgumentText(text, cursor + 1, close ?? end),
+    argumentStart: cursor + 1,
+    argumentEnd: close ?? end,
+    end,
+    closed: close !== undefined
+  };
+}
+
+function firstCallArgumentText(text, start, end) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let index = start; index < end; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') { quote = char; continue; }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth = Math.max(0, depth - 1);
+    else if (char === ',' && depth === 0) return text.slice(start, index);
+  }
+  return text.slice(start, end);
+}
+
+function dynamicImportSpecifierKind(specifierText, closed) {
+  const text = String(specifierText ?? '').trim();
+  if (!closed || !text) return 'unparsed';
+  if (isStaticStringLiteral(text) || isStaticTemplateLiteral(text)) return 'literal';
+  if (text.startsWith('`')) return 'template';
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) return 'identifier';
+  if (/^[A-Za-z_$][\w$]*(?:(?:\.|\?\.)[A-Za-z_$][\w$]*|\[[^\]]+\])+$/.test(text)) return 'member';
+  if (/\?/.test(text) && /:/.test(text)) return 'conditional';
+  if (/[+\-*/%]|\|\||&&|\?\?/.test(text)) return 'binary';
+  if (/\)\s*$/.test(text)) return 'call';
+  return 'expression';
+}
+
+function dynamicImportStaticSpecifierEvidence(specifierText, specifierKind) {
+  if (specifierKind !== 'literal') return false;
+  return isStaticStringLiteral(specifierText) || isStaticTemplateLiteral(specifierText);
+}
+
+function dynamicImportSignatureEvidence(record) {
+  return compactRecord({
+    specifierKind: record?.specifierKind,
+    specifierText: record?.specifierText,
+    dynamicImportStaticSpecifierEvidence: record?.dynamicImportStaticSpecifierEvidence,
+    dynamicImportRuntimeResolutionClaim: record?.dynamicImportRuntimeResolutionClaim,
+    dynamicImportResolutionProofRequired: record?.dynamicImportResolutionProofRequired,
+    runtimeEquivalenceClaim: record?.runtimeEquivalenceClaim
+  });
+}
+
+function matchingParenIndex(line, open) {
+  if (open < 0) return undefined;
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let index = open; index < line.length; index += 1) {
+    const char = line[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') { quote = char; continue; }
+    if (char === '(') depth += 1;
+    else if (char === ')' && --depth === 0) return index;
+  }
+  return undefined;
+}
+
+function rangesOverlap(leftStart, leftEnd, rightStart, rightEnd) { return Math.max(leftStart, rightStart) < Math.min(leftEnd, rightEnd); }
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function isStaticStringLiteral(value) { const text = String(value ?? '').trim(), quote = text[0]; return (quote === '\'' || quote === '"') && text.endsWith(quote); }
+function isStaticTemplateLiteral(value) { const text = String(value ?? '').trim(); return text.startsWith('`') && text.endsWith('`') && !text.includes('${'); }
+function isIdentifierPart(char) { return /[A-Za-z0-9_$]/.test(char ?? ''); }
+function statementEnd(line, start) { const semicolon = line.indexOf(';', start); return semicolon === -1 ? line.length : semicolon + 1; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }
+
+export { dynamicImportEvidenceRecords, dynamicImportSignatureEvidence };

package/dist/semantic-import-runtime-order-evidence.js

@@ -9,6 +9,7 @@ import { reachabilityOrderEvidence } from './semantic-import-runtime-reachabilit
 import { throwOrderEvidenceRecords } from './semantic-import-runtime-throw-evidence.js';
 import { promiseCombinatorEvidenceRecords } from './semantic-import-runtime-promise-combinator-evidence.js';
 import { promiseChainEvidenceRecords } from './semantic-import-runtime-promise-chain-evidence.js';
+import { dynamicImportEvidenceRecords, dynamicImportSignatureEvidence } from './semantic-import-runtime-dynamic-import-evidence.js';
 function semanticFactOrderInfo(groups) {
   const bySubject = new Map();
   const info = new Map();
@@ -61,6 +62,7 @@ function semanticFactRuntimeOrderEvidence(sourceText, group, fact, spanInfo, ord
     sameLineAwaitOrder: sameLineEvidence.awaitOrder,
     sameLineOptionalChain: sameLineEvidence.optionalChain,
     sameLineConditionalExpression: sameLineEvidence.conditionalExpression,
+    sameLineDynamicImport: sameLineEvidence.dynamicImport,
     sameLinePromiseCombinator: sameLineEvidence.promiseCombinator,
     sameLinePromiseChain: sameLineEvidence.promiseChain,
     sameLineThrow: sameLineEvidence.throw,
@@ -85,6 +87,7 @@ function semanticFactRuntimeOrderSignatureEvidence(evidence) {
     sameLineAwaitOrder: evidence?.sameLineAwaitOrder,
     sameLineOptionalChain: evidence?.sameLineOptionalChain,
     sameLineConditionalExpression: evidence?.sameLineConditionalExpression,
+    sameLineDynamicImport: evidence?.sameLineDynamicImport?.map(dynamicImportSignatureEvidence),
     sameLinePromiseCombinator: evidence?.sameLinePromiseCombinator,
     sameLinePromiseChain: evidence?.sameLinePromiseChain,
     sameLineThrow: evidence?.sameLineThrow,
@@ -100,7 +103,7 @@ function sameLineRuntimeOrderEvidence(line, start, end) {
   const prefix = String(line ?? '').slice(0, start);
   const controlFlow = controlHeadEvidenceRecords(prefix), shortCircuit = shortCircuitEvidenceRecords(prefix), awaitOrder = awaitOrderEvidenceRecords(prefix);
   const optionalChain = optionalChainEvidenceRecords(line, start, end), conditionalExpression = conditionalExpressionEvidenceRecords(line, start, end);
-  const promiseCombinator = promiseCombinatorEvidenceRecords(line, start, end), promiseChain = promiseChainEvidenceRecords(line, start, end), throwOrder = throwOrderEvidenceRecords(line, start, end);
+  const dynamicImport = dynamicImportEvidenceRecords(line, start, end), promiseCombinator = promiseCombinatorEvidenceRecords(line, start, end), promiseChain = promiseChainEvidenceRecords(line, start, end), throwOrder = throwOrderEvidenceRecords(line, start, end);
   return {
     controlFlow: controlFlow.length ? controlFlow : undefined,
     shortCircuit: shortCircuit.length ? shortCircuit : undefined,
@@ -108,6 +111,7 @@ function sameLineRuntimeOrderEvidence(line, start, end) {
     awaitOrder: awaitOrder.length ? awaitOrder : undefined,
     optionalChain: optionalChain.length ? optionalChain : undefined,
     conditionalExpression: conditionalExpression.length ? conditionalExpression : undefined,
+    dynamicImport: dynamicImport.length ? dynamicImport : undefined,
     promiseCombinator: promiseCombinator.length ? promiseCombinator : undefined,
     promiseChain: promiseChain.length ? promiseChain : undefined,
     throw: throwOrder.length ? true : /\bthrow\b/.test(prefix) || undefined,
@@ -126,7 +130,6 @@ function controlFlowOrderEvidence(line, lineNumber, group) {
     loop: records.filter((record) => record.kind === 'loop')
   };
 }
-
 function optionalChainEvidenceRecords(line, start, end) {
   const expression = String(line ?? '').slice(Math.max(0, start), Math.max(start, end));
   const matches = [...expression.matchAll(/\?\.(?:\s*\(|\s*[A-Za-z_$][\w$]*|\s*\[)/g)];
@@ -136,7 +139,6 @@ function optionalChainEvidenceRecords(line, start, end) {
     text: normalizeOrderEvidenceText(expression.slice(Math.max(0, match.index - 24), match.index + match[0].length + 24))
   }));
 }
-
 function awaitOrderEvidenceRecords(prefix) {
   const text = String(prefix ?? '');
   const tokens = awaitTokenIndexes(text);
@@ -164,7 +166,6 @@ function awaitTokenIndexes(text) {
   }
   return indexes;
 }
-
 function shortCircuitEvidenceRecords(prefix) {
   const text = String(prefix ?? '');
   const operators = shortCircuitOperators(text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.160",
+  "version": "0.2.162",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,7 +63,7 @@
   "dependencies": {
     "@shapeshift-labs/frontier-lang-c": "0.2.9",
     "@shapeshift-labs/frontier-lang-checker": "0.3.8",
-    "@shapeshift-labs/frontier-lang-css": "^0.1.8",
+    "@shapeshift-labs/frontier-lang-css": "^0.1.9",
     "@shapeshift-labs/frontier-lang-html": "^0.1.6",
     "@shapeshift-labs/frontier-lang-javascript": "0.2.9",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.12",