@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

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

@@ -0,0 +1,134 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { sourceTextForSpan } from './sourceTextForSpan.js';
+
+export function typeSyntaxEditClassification(input) {
+  const reasonCodes = typeSyntaxEditReasonCodes(input);
+  if (!reasonCodes.length) return undefined;
+  const evidenceIds = typeSyntaxEvidenceIds(input);
+  if (evidenceIds.length) {
+    return {
+      status: 'portable',
+      reasonCodes: uniqueStrings([...reasonCodes, 'type-syntax-edit-backed-by-typechecker-or-declaration-evidence']),
+      evidenceIds
+    };
+  }
+  return {
+    status: 'blocked',
+    reasonCodes: uniqueStrings([...reasonCodes, 'type-syntax-edit-requires-typechecker-or-declaration-evidence']),
+    evidenceIds: []
+  };
+}
+
+export function typeSyntaxEditReasonCodes(input) {
+  if (!isJsTsLanguage(input) || input.region?.regionKind === 'import') return [];
+  if (!['modified', 'removed', 'added'].includes(input.region?.changeKind)) return [];
+  const baseText = typeSyntaxSourceText(input.context.base, input.baseSymbol, input.region, 'before');
+  const workerText = typeSyntaxSourceText(input.context.worker, input.workerSymbol, input.region, 'after');
+  if (typeof baseText !== 'string' || typeof workerText !== 'string' || baseText === workerText) return [];
+  const allowAngleAssertion = !isJsxLikeLanguage(input);
+  const base = typeSyntaxSignals(baseText, allowAngleAssertion);
+  const worker = typeSyntaxSignals(workerText, allowAngleAssertion);
+  const reasons = [];
+  if (base.satisfies || worker.satisfies) reasons.push('satisfies-expression-edit-requires-typechecker-evidence');
+  if (base.asConst || worker.asConst) reasons.push('as-const-assertion-edit-requires-declaration-evidence');
+  if (base.typeAssertion || worker.typeAssertion) reasons.push('type-assertion-edit-requires-typechecker-evidence');
+  if (base.constTypeParameters !== worker.constTypeParameters) reasons.push('const-type-parameter-edit-requires-declaration-evidence');
+  if (base.constraints !== worker.constraints) reasons.push('generic-constraint-edit-requires-typechecker-evidence');
+  if (base.generics !== worker.generics) reasons.push('generic-type-parameter-edit-requires-typechecker-evidence');
+  if (base.conditionalTypes !== worker.conditionalTypes) reasons.push('conditional-type-edit-requires-declaration-evidence');
+  return uniqueStrings(reasons);
+}
+
+function typeSyntaxSignals(text, allowAngleAssertion) {
+  const normalized = String(text ?? '').replace(/\s+/g, ' ').trim();
+  const genericClauses = typeParameterClauses(normalized);
+  return {
+    satisfies: /\bsatisfies\b/.test(normalized),
+    asConst: /\bas\s+const\b/.test(normalized),
+    typeAssertion: hasTypeAssertionSyntax(normalized, allowAngleAssertion),
+    generics: genericClauses.join('|'),
+    constraints: genericClauses.filter((clause) => /\bextends\b/.test(clause)).join('|'),
+    constTypeParameters: genericClauses.filter((clause) => /<[^>]*\bconst\s+[A-Za-z_$]/.test(clause)).join('|'),
+    conditionalTypes: conditionalTypeClauses(normalized).join('|')
+  };
+}
+
+function typeSyntaxSourceText(imported, symbol, region, projectionSide) {
+  const sourceText = nativeImportSourceText(imported);
+  const projection = region?.metadata?.changedRegionProjection;
+  const span = symbol?.sourceSpan ?? projection?.[projectionSide]?.sourceSpan ?? region?.sourceSpan;
+  const exact = sourceTextForSpan(sourceText, span);
+  const lineText = sourceLineTextForSpan(sourceText, span);
+  return typeof lineText === 'string' && hasTypeSyntaxCue(lineText) ? lineText : exact;
+}
+
+function hasTypeSyntaxCue(text) {
+  return /\b(?:satisfies|extends|infer|as\s+const|as\s+(?:unknown|any|never|string|number|boolean|symbol|bigint))\b|<\s*const\s+[A-Za-z_$]|\btype\s+[A-Za-z_$][\w$]*(?:\s*<[^>\n]+>)?\s*=/.test(String(text ?? ''));
+}
+
+function sourceLineTextForSpan(sourceText, span) {
+  if (typeof sourceText !== 'string' || typeof span?.startLine !== 'number') return undefined;
+  const lines = sourceText.split('\n');
+  const startLine = Math.max(1, span.startLine);
+  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
+  return lines.slice(startLine - 1, endLine).join('\n');
+}
+
+function typeParameterClauses(text) {
+  const clauses = [];
+  const pattern = /\b(?:export\s+)?(?:declare\s+)?(?:async\s+)?(?:function|class|interface|type)\s+[A-Za-z_$][\w$]*\s*(<[^>\n]+>)/g;
+  for (const match of text.matchAll(pattern)) clauses.push(match[1].replace(/\s+/g, ' '));
+  return clauses;
+}
+
+function conditionalTypeClauses(text) {
+  const clauses = [];
+  const pattern = /\btype\s+[A-Za-z_$][\w$]*(?:\s*<[^>\n]+>)?\s*=\s*([^;\n]*\bextends\b[^;\n]*\?[^;\n]*:[^;\n]*)/g;
+  for (const match of text.matchAll(pattern)) clauses.push(match[1].replace(/\s+/g, ' '));
+  return clauses;
+}
+
+function hasTypeAssertionSyntax(text, allowAngleAssertion) {
+  if (/\bas\s+const\b/.test(text)) return true;
+  const asAssertion = /\bas\s+(?:unknown|any|never|string|number|boolean|symbol|bigint|readonly|[A-Z_$][\w$]*|\{|\[)/;
+  const angleAssertion = /(?:\b(?:return|throw)\b|[=([,])\s*<\s*[A-Za-z_$][^>\n]*>\s*(?:[A-Za-z_$"'[(])/;
+  return asAssertion.test(text) || (allowAngleAssertion && angleAssertion.test(text));
+}
+
+function typeSyntaxEvidenceIds(input) {
+  return uniqueStrings(typeSyntaxEvidenceRecords(input)
+    .filter(typeSyntaxEvidencePassed).map((record) => String(record.id ?? record.evidenceId ?? record.hash ?? record.kind)));
+}
+
+function typeSyntaxEvidenceRecords(input) {
+  return [
+    input.scriptInput?.typeSyntaxEvidence,
+    input.scriptInput?.typeCheckerEvidence,
+    input.scriptInput?.typescriptEvidence,
+    input.scriptInput?.diagnosticsEvidence,
+    input.scriptInput?.declarationEvidence,
+    input.scriptInput?.evidence,
+    input.context?.typeSyntaxEvidence
+  ].flatMap((entry) => Array.isArray(entry) ? entry : [entry]).filter((entry) => entry && typeof entry === 'object');
+}
+
+function typeSyntaxEvidencePassed(record) {
+  const status = String(record.status ?? record.result ?? '').toLowerCase();
+  if (status && !['passed', 'pass', 'ok', 'clean', 'accepted-clean'].includes(status)) return false;
+  const text = [
+    record.kind, record.type, record.source, record.gateId, record.summary, record.metadata?.kind,
+    record.metadata?.source, record.metadata?.diagnosticSource, record.metadata?.declarationSource
+  ].filter(Boolean).join(' ').toLowerCase();
+  return /\b(typechecker|type-checker|typescript|diagnostic|diagnostics|declaration|declarations|d\.ts|type-syntax)\b/.test(text);
+}
+
+function isJsTsLanguage(input) {
+  const language = String(input.region?.language ?? input.context?.workerChangeSet?.language ?? input.context?.base?.language ?? '').toLowerCase();
+  return ['javascript', 'typescript', 'jsx', 'tsx'].includes(language);
+}
+
+function isJsxLikeLanguage(input) {
+  const language = String(input.region?.language ?? input.context?.workerChangeSet?.language ?? input.context?.base?.language ?? '').toLowerCase();
+  return ['jsx', 'tsx'].includes(language);
+}

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

@@ -1,4 +1,5 @@
 import{idFragment,caseSensitiveIdFragment}from'../../native-import-utils.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{dynamicImportExpressionEdgeFields}from'./dynamicImportExpressionMetadata.js';import{hostDependencyEdgeFields}from'./importMetaUrlDependencyMetadata.js';import{moduleImportAttributeEdgeFields}from'./moduleImportAttributeMetadata.js';
 import{relationPredicateForDeclaration}from'./relationPredicateForDeclaration.js';
 export function semanticIndexFromNativeDeclarations(declarations, input, options) {
   const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`;
@@ -94,7 +95,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
         granularity: ownershipRegion.granularity,
         key: ownershipRegion.key
       }
-    }, ...projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }));
+    }, ...projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId, compilerSymbol: declaration.metadata?.compilerSymbol, compilerSymbolIdentityHash: declaration.metadata?.compilerSymbolIdentityHash, compilerType: declaration.metadata?.compilerType, compilerTypeIdentityHash: declaration.metadata?.compilerTypeIdentityHash }));
     mappings.push({
       id: `map_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}`,
       nativeAstNodeId: declaration.nativeNode.id,
@@ -124,7 +125,8 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
           fileHashes: input.sourceHash ? 1 : 0,
           moduleEdges: facts.filter((fact) => fact.predicate === 'moduleEdge').length,
           reExportIdentities: facts.filter((fact) => fact.predicate === 'reExportIdentity').length,
-          publicContractRegions: facts.filter((fact) => fact.predicate === 'publicContractRegion').length
+          publicContractRegions: facts.filter((fact) => fact.predicate === 'publicContractRegion').length,
+          compilerSymbols: facts.filter((fact) => fact.predicate === 'compilerSymbol').length, compilerTypes: facts.filter((fact) => fact.predicate === 'compilerType').length
         }
       }
   }];
@@ -199,6 +201,8 @@ function moduleEdgeForDeclaration(declaration, input, documentId, relationId, ow
     namespace: declaration.namespace ?? declaration.metadata?.namespace,
     isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly ?? declaration.metadata?.typeOnly,
     exportStar: declaration.exportStar ?? declaration.metadata?.exportStar,
+    ...dynamicImportExpressionEdgeFields(declaration.metadata), ...hostDependencyEdgeFields(declaration.metadata),
+    ...moduleImportAttributeEdgeFields(declaration.metadata),
     isReExport: edgeKind === 're-export',
     publicContract: publicContractForDeclaration(declaration, edgeKind)
   });
@@ -256,16 +260,18 @@ function reExportIdentityForDeclaration(declaration, input, documentId, relation
     localName: declaration.localName ?? declaration.metadata?.localName, namespace: declaration.namespace ?? declaration.metadata?.namespace,
     isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly ?? declaration.metadata?.typeOnly, exportStar: declaration.exportStar ?? declaration.metadata?.exportStar,
     symbolId: declaration.symbolId, relationId, ownershipRegionId: ownershipRegion.id, ownershipRegionKey: ownershipRegion.key,
-    publicContract: true
+    publicContract: true, hasImportAttributes: moduleEdge?.hasImportAttributes, importAttributeCount: moduleEdge?.importAttributeCount, importAttributeKeys: moduleEdge?.importAttributeKeys, importAttributeHash: moduleEdge?.importAttributeHash, importAttributes: moduleEdge?.importAttributes
   });
 }
 
-function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }) {
+function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId, compilerSymbol, compilerSymbolIdentityHash, compilerType, compilerTypeIdentityHash }) {
   return [
+    compilerSymbol ? { id: graphFactId(relationId, symbolId, 'compiler_symbol'), predicate: 'compilerSymbol', subjectId: symbolId, value: { ...compilerSymbol, identityHash: compilerSymbolIdentityHash }, evidenceIds: [evidenceId] } : undefined,
+    compilerType ? { id: graphFactId(relationId, symbolId, 'compiler_type'), predicate: 'compilerType', subjectId: symbolId, value: { ...compilerType, identityHash: compilerTypeIdentityHash }, evidenceIds: [evidenceId] } : undefined,
     moduleEdge ? {
       id: graphFactId(relationId, symbolId, 'module_edge'),
       predicate: 'moduleEdge',
-      subjectId: relationId,
+      subjectId: symbolId,
       objectId: symbolId,
       value: moduleEdge,
       evidenceIds: [evidenceId]

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

@@ -0,0 +1,150 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+
+function semanticStructuralEdit(input) {
+  const actions = structuralEditActions(input);
+  const structuralKind = structuralEditKind(actions);
+  const record = compactRecord({
+    id: `semantic_structural_edit_${idFragment(input.operationId)}`,
+    kind: 'frontier.lang.semanticStructuralEdit',
+    version: 1,
+    algorithm: 'frontier.semantic-edit-structural-diff.v1',
+    runtimeNeutral: true,
+    operationId: input.operationId,
+    structuralKind,
+    actions,
+    operationKind: input.kind,
+    changeKind: input.changeKind,
+    anchorKey: input.anchor?.key,
+    conflictKey: input.anchor?.conflictKey,
+    regionKind: input.anchor?.regionKind,
+    sourcePath: input.anchor?.sourcePath,
+    symbolName: input.anchor?.symbolName,
+    symbolKind: input.anchor?.symbolKind,
+    from: structuralSpanLocation(input.spans?.base),
+    to: structuralSpanLocation(input.spans?.worker),
+    head: structuralSpanLocation(input.spans?.head),
+    baseTextHash: input.hashes?.baseTextHash,
+    workerTextHash: input.hashes?.workerTextHash,
+    headTextHash: input.hashes?.headTextHash,
+    beforeSignatureHash: input.hashes?.beforeSignatureHash,
+    afterSignatureHash: input.hashes?.afterSignatureHash,
+    status: input.status,
+    reviewRequired: true,
+    confidence: input.confidence,
+    reasonCodes: uniqueStrings([
+      ...(input.reasonCodes ?? []),
+      'structural-diff-review-required',
+      'replay-required-for-safety'
+    ]),
+    reanchor: input.reanchor,
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+  return { ...record, hash: hashSemanticValue(record) };
+}
+
+function semanticStructuralDiff(input) {
+  const edits = (input.operations ?? []).map((operation) => operation.structuralEdit).filter(Boolean);
+  const summary = summarizeStructuralEdits(edits);
+  const core = {
+    kind: 'frontier.lang.semanticStructuralDiff',
+    version: 1,
+    schema: 'frontier.lang.semanticStructuralDiff.v1',
+    id: input.input.structuralDiffId ?? `semantic_structural_diff_${idFragment(input.input.id ?? input.sourcePath ?? 'semantic_edit')}`,
+    algorithm: 'frontier.semantic-edit-structural-diff.v1',
+    runtimeNeutral: true,
+    language: input.language,
+    sourcePath: input.sourcePath,
+    workerChangeSetId: input.workerChangeSet.id,
+    headChangeSetId: input.headChangeSet?.id,
+    edits,
+    summary,
+    admission: {
+      status: 'review-required',
+      action: 'run-replay-and-diagnostics',
+      reviewRequired: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: ['structural-diff-review-required', 'replay-required-for-safety']
+    },
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      note: 'Structural edit records classify AST/CST-neutral anchor movement and content changes; source replay diagnostics still decide safety.'
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function structuralEditActions(input) {
+  if (input.changeKind === 'added') return ['insert'];
+  if (input.changeKind === 'removed') return ['delete'];
+  const actions = [];
+  if (structuralSpanMoved(input.spans?.base, input.spans?.worker) || input.reanchor?.toAnchorKey) actions.push('move');
+  if (structuralContentChanged(input.hashes)) actions.push('update');
+  return actions.length ? actions : ['update'];
+}
+
+function structuralEditKind(actions) {
+  if (actions.includes('move') && actions.includes('update')) return 'move-update';
+  return actions[0] ?? 'update';
+}
+
+function structuralContentChanged(hashes) {
+  return Boolean(
+    hashes?.baseTextHash && hashes?.workerTextHash && hashes.baseTextHash !== hashes.workerTextHash
+    || hashes?.beforeSignatureHash && hashes?.afterSignatureHash && hashes.beforeSignatureHash !== hashes.afterSignatureHash
+  );
+}
+
+function structuralSpanMoved(left, right) {
+  if (!left || !right) return false;
+  return (left.path && right.path && left.path !== right.path)
+    || left.startLine !== right.startLine
+    || left.startColumn !== right.startColumn
+    || left.endLine !== right.endLine
+    || left.endColumn !== right.endColumn;
+}
+
+function structuralSpanLocation(span) {
+  return span ? compactRecord({
+    path: span.path,
+    startLine: span.startLine,
+    startColumn: span.startColumn,
+    endLine: span.endLine,
+    endColumn: span.endColumn
+  }) : undefined;
+}
+
+function summarizeStructuralEdits(edits) {
+  const byKind = countBy(edits.map((edit) => edit.structuralKind));
+  const byAction = countBy(edits.flatMap((edit) => edit.actions ?? []));
+  return {
+    edits: edits.length,
+    byKind,
+    byAction,
+    moves: byAction.move ?? 0,
+    updates: byAction.update ?? 0,
+    inserts: byAction.insert ?? 0,
+    deletes: byAction.delete ?? 0,
+    moveUpdates: byKind['move-update'] ?? 0,
+    reviewRequired: edits.length > 0,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function countBy(values) {
+  const result = {};
+  for (const value of values.filter(Boolean)) result[value] = (result[value] ?? 0) + 1;
+  return result;
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}
+
+export { semanticStructuralDiff, semanticStructuralEdit };

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

@@ -0,0 +1,185 @@
+import { countBy, uniqueStrings } from '../../native-import-utils.js';
+
+export function classifySourceMapGeneratedBoundary(sourceMaps, options = {}) {
+  const maps = normalizeSourceMapCollection(sourceMaps);
+  const entries = maps.flatMap((sourceMap) => (sourceMap?.mappings ?? [])
+    .map((mapping) => ({ sourceMap, mapping })));
+  const exactEntries = entries.filter(({ sourceMap, mapping }) => hasExactGeneratedBoundary(sourceMap, mapping));
+  const generatedBoundaryOwnershipRecords = exactEntries.map(generatedBoundaryOwnershipRecord).filter(Boolean);
+  const summary = sourceMapGeneratedBoundarySummary(maps, entries);
+  const exactBoundary = generatedBoundaryOwnershipRecords.length > 0;
+  return {
+    schema: 'frontier.lang.sourceMapGeneratedBoundaryGate.v1',
+    version: 1,
+    status: exactBoundary ? 'ready' : 'blocked',
+    readiness: exactBoundary ? 'ready' : 'blocked',
+    action: exactBoundary ? 'admit-exact-source-map-generated-boundary' : 'block-generated-file-merge-admission',
+    reviewRequired: !exactBoundary,
+    exactBoundary,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    sourceLanguage: options.sourceLanguage,
+    target: options.target,
+    outputMode: options.outputMode,
+    projectionMode: options.projectionMode,
+    sourceMapIds: uniqueStrings(maps.map((sourceMap) => sourceMap?.id)),
+    sourceMapMappingIds: uniqueStrings(exactEntries.map(({ mapping }) => mapping?.id)),
+    generatedBoundaryOwnershipStatus: exactBoundary ? 'deterministic-source-map-span' : 'blocked',
+    generatedBoundaryOwnershipKeys: uniqueStrings(generatedBoundaryOwnershipRecords.map((record) => record.key)),
+    generatedBoundaryOwnershipRecords,
+    invariant: 'ECMA-426 source maps identify generated positions and original positions; Frontier generated-file merge admission requires validated source-map evidence plus exact source and generated spans with source and target hashes.',
+    missingInvariant: exactBoundary ? undefined : 'ecma-426-generated-position-only-no-range-boundary',
+    summary,
+    reasonCodes: sourceMapGeneratedBoundaryReasonCodes(summary, exactBoundary)
+  };
+}
+
+function normalizeSourceMapCollection(sourceMaps) {
+  if (!sourceMaps) return [];
+  return Array.isArray(sourceMaps) ? sourceMaps.filter(Boolean) : [sourceMaps].filter(Boolean);
+}
+
+function hasExactGeneratedBoundary(sourceMap, mapping) {
+  return mapping?.precision === 'exact'
+    && hasExactSpan(mapping.sourceSpan)
+    && hasExactSpan(mapping.generatedSpan)
+    && Boolean(sourceBoundaryHash(sourceMap, mapping))
+    && Boolean(targetBoundaryHash(sourceMap, mapping));
+}
+
+function hasExactSpan(span) {
+  if (!span) return false;
+  return [span.startLine, span.startColumn, span.endLine, span.endColumn]
+    .every((value) => Number.isFinite(value));
+}
+
+function sourceMapGeneratedBoundarySummary(maps, entries) {
+  const mappings = entries.map(({ mapping }) => mapping);
+  const ecma426Payloads = maps.map(ecma426SourceMapEvidence).filter((record) => record?.present);
+  const ecma426ReasonCodes = uniqueStrings(ecma426Payloads.flatMap((record) => record?.reasonCodes ?? []));
+  const generatedBoundaryOwnershipRecords = entries
+    .filter(({ sourceMap, mapping }) => hasExactGeneratedBoundary(sourceMap, mapping))
+    .map(generatedBoundaryOwnershipRecord)
+    .filter(Boolean);
+  return {
+    sourceMaps: maps.length,
+    mappings: mappings.length,
+    exactBoundaryMappings: entries.filter(({ sourceMap, mapping }) => hasExactGeneratedBoundary(sourceMap, mapping)).length,
+    deterministicGeneratedBoundaryOwnerships: generatedBoundaryOwnershipRecords.length,
+    exactPrecisionMappings: mappings.filter((mapping) => mapping?.precision === 'exact').length,
+    withSourceSpan: mappings.filter((mapping) => hasExactSpan(mapping?.sourceSpan)).length,
+    withGeneratedSpan: mappings.filter((mapping) => hasExactSpan(mapping?.generatedSpan)).length,
+    withSourceHash: entries.filter(({ sourceMap, mapping }) => sourceBoundaryHash(sourceMap, mapping)).length,
+    withTargetHash: entries.filter(({ sourceMap, mapping }) => targetBoundaryHash(sourceMap, mapping)).length,
+    byPrecision: countBy(mappings.map((mapping) => mapping?.precision ?? 'unknown')),
+    byOrigin: countBy(mappings.map((mapping) => mapping?.metadata?.sourceMapOrigin ?? 'native-import')),
+    byBoundaryKind: countBy(entries.map(({ sourceMap, mapping }) => sourceMapBoundaryKind(sourceMap, mapping))),
+    byEcma426Status: countBy(maps.map((sourceMap) => ecma426SourceMapEvidence(sourceMap)?.status ?? 'missing')),
+    ecma426Payloads: ecma426Payloads.length,
+    validEcma426Payloads: ecma426Payloads.filter((record) => record?.status === 'valid').length,
+    invalidEcma426Payloads: ecma426Payloads.filter((record) => record?.status === 'blocked').length,
+    decodedEcma426Mappings: ecma426Payloads.reduce((sum, record) => sum + numeric(record?.summary?.decodedMappings), 0),
+    ecma426ReasonCodes,
+    sourcePaths: uniqueStrings(entries.map(({ sourceMap, mapping }) => mapping?.sourceSpan?.path ?? sourceMap?.sourcePath)),
+    targetPaths: uniqueStrings(entries.map(({ sourceMap, mapping }) => mapping?.generatedSpan?.targetPath
+      ?? mapping?.generatedSpan?.path ?? sourceMap?.targetPath ?? sourceMap?.target?.emitPath))
+  };
+}
+
+function sourceMapGeneratedBoundaryReasonCodes(summary, exactBoundary) {
+  return uniqueStrings([
+    'ecma-426:source-map-generated-boundary-gate',
+    'runtime-neutral:source-map-records-only',
+    exactBoundary ? 'source-map-generated-boundary:exact' : 'ecma-426:missing-exact-source-generated-boundary',
+    exactBoundary ? 'source-map-generated-boundary:deterministic-source-map-span-ownership' : undefined,
+    summary.sourceMaps === 0 ? 'source-map:missing' : undefined,
+    !exactBoundary && summary.ecma426Payloads === 0 ? 'ecma-426:payload-missing' : undefined,
+    summary.validEcma426Payloads > 0 ? 'ecma-426:payload-valid' : undefined,
+    !exactBoundary && summary.invalidEcma426Payloads > 0 ? 'ecma-426:payload-invalid' : undefined,
+    !exactBoundary && summary.validEcma426Payloads > 0 && summary.exactBoundaryMappings === 0 ? 'ecma-426:payload-position-only' : undefined,
+    ...summary.ecma426ReasonCodes,
+    summary.mappings === 0 ? 'source-map:mappings-missing' : undefined,
+    summary.exactPrecisionMappings === 0 ? 'source-map:exact-precision-missing' : undefined,
+    summary.withSourceSpan < summary.mappings ? 'ecma-426:missing-original-range' : undefined,
+    summary.withGeneratedSpan < summary.mappings ? 'ecma-426:missing-generated-range' : undefined,
+    summary.withSourceHash < summary.mappings ? 'source-map:source-hash-missing' : undefined,
+    summary.withTargetHash < summary.mappings ? 'source-map:target-hash-missing' : undefined
+  ]);
+}
+
+function sourceBoundaryHash(sourceMap, mapping) {
+  return sourceMap?.sourceHash ?? mapping?.sourceSpan?.sourceHash ?? mapping?.sourceSpan?.sourceId;
+}
+
+function targetBoundaryHash(sourceMap, mapping) {
+  return sourceMap?.targetHash ?? mapping?.generatedSpan?.targetHash ?? mapping?.targetHash;
+}
+
+function generatedBoundaryOwnershipRecord({ sourceMap, mapping }) {
+  if (!hasExactGeneratedBoundary(sourceMap, mapping)) return undefined;
+  const sourceSpan = mapping?.sourceSpan;
+  const generatedSpan = mapping?.generatedSpan;
+  const sourcePath = sourceSpan?.path ?? sourceMap?.sourcePath;
+  const targetPath = generatedSpan?.targetPath ?? generatedSpan?.path ?? sourceMap?.targetPath ?? sourceMap?.target?.emitPath;
+  const sourceHash = sourceBoundaryHash(sourceMap, mapping);
+  const targetHash = targetBoundaryHash(sourceMap, mapping);
+  const sourceSpanKey = exactSpanKey(sourceSpan);
+  const generatedSpanKey = exactSpanKey(generatedSpan);
+  const key = stableKey(['generated-boundary', sourcePath, sourceHash, sourceSpanKey, targetPath, targetHash, generatedSpanKey]);
+  return compactRecord({
+    key,
+    status: 'deterministic-source-map-span',
+    sourceMapId: sourceMap?.id,
+    sourceMapMappingId: mapping?.id,
+    sourcePath,
+    targetPath,
+    sourceHash,
+    targetHash,
+    sourceSpanKey,
+    generatedSpanKey,
+    boundaryKind: sourceMapBoundaryKind(sourceMap, mapping),
+    sourceMapOrigin: mapping?.metadata?.sourceMapOrigin ?? 'native-import'
+  });
+}
+
+function exactSpanKey(span) {
+  return stableKey([
+    span?.path ?? span?.targetPath ?? span?.sourceId,
+    span?.start,
+    span?.end,
+    span?.startLine,
+    span?.startColumn,
+    span?.endLine,
+    span?.endColumn
+  ]);
+}
+
+function ecma426SourceMapEvidence(sourceMap) {
+  return sourceMap?.metadata?.ecma426SourceMap;
+}
+
+function numeric(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : 0;
+}
+
+function sourceMapBoundaryKind(sourceMap, mapping) {
+  const sourcePath = mapping?.sourceSpan?.path ?? sourceMap?.sourcePath;
+  const targetPath = mapping?.generatedSpan?.targetPath ?? mapping?.generatedSpan?.path
+    ?? sourceMap?.targetPath ?? sourceMap?.target?.emitPath;
+  const sourceHash = sourceBoundaryHash(sourceMap, mapping);
+  const targetHash = targetBoundaryHash(sourceMap, mapping);
+  if (sourcePath && targetPath && sourcePath === targetPath && sourceHash && targetHash && sourceHash === targetHash) {
+    return 'preserved-source';
+  }
+  return 'source-generated';
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -0,0 +1,31 @@
+function readStaticMemberLiteral(sourceText, start, limit) {
+  const quote = sourceText[start];
+  if (quote === '\'' || quote === '"') return readQuotedMemberLiteral(sourceText, start, limit, quote);
+  if (quote === '`') return readTemplateMemberLiteral(sourceText, start, limit);
+  return undefined;
+}
+
+function readQuotedMemberLiteral(sourceText, start, limit, quote) {
+  let value = '';
+  for (let index = start + 1; index < limit; index += 1) {
+    const char = sourceText[index];
+    if (char === '\\' || char === '\n' || char === '\r') return undefined;
+    if (char === quote) return { value, start: start + 1, end: index, literalKind: 'string-literal' };
+    value += char;
+  }
+  return undefined;
+}
+
+function readTemplateMemberLiteral(sourceText, start, limit) {
+  let value = '';
+  for (let index = start + 1; index < limit; index += 1) {
+    const char = sourceText[index];
+    if (char === '\\' || char === '\n' || char === '\r') return undefined;
+    if (char === '$' && sourceText[index + 1] === '{') return undefined;
+    if (char === '`') return { value, start: start + 1, end: index, literalKind: 'static-template-literal' };
+    value += char;
+  }
+  return undefined;
+}
+
+export { readStaticMemberLiteral };

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

@@ -0,0 +1,22 @@
+function staticOptionalMemberReference(text) {
+  const normalized = normalizedOptionalMemberExpression(text);
+  if (!normalized.includes('?.')) return undefined;
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:(?:\?\.|\.)[A-Za-z_$][\w$]*)+$/.test(normalized)) return undefined;
+  const path = normalized.split(/\?\.|\./);
+  const operators = normalized.match(/\?\.|\./g) ?? [];
+  const optionalSegmentIndexes = operators.flatMap((operator, index) => operator === '?.' ? [index + 1] : []);
+  return {
+    text: normalized,
+    root: path[0],
+    path,
+    memberPath: path.slice(1),
+    optionalSegments: optionalSegmentIndexes.map((index) => path[index]),
+    optionalSegmentIndexes
+  };
+}
+
+function normalizedOptionalMemberExpression(text) {
+  return String(text ?? '').trim().replace(/\s+/g, ' ').replace(/\s*(\?\.|\.)\s*/g, '$1').replace(/\s+/g, '');
+}
+
+export { staticOptionalMemberReference };