@shapeshift-labs/frontier-lang-compiler 0.2.100 → 0.2.102

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

@@ -0,0 +1,221 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+const scoreFacetWeights = Object.freeze({ ownership: 18, staleStatus: 20, testEvidence: 18, overlap: 18, size: 10, semanticSidecarQuality: 16 });
+
+export function semanticMergeCandidateScoreFacets(input) {
+  const components = {
+    ownership: ownershipFacet(input),
+    staleStatus: staleStatusFacet(input),
+    testEvidence: testEvidenceFacet(input),
+    overlap: overlapFacet(input),
+    size: sizeFacet(input),
+    semanticSidecarQuality: semanticSidecarQualityFacet(input)
+  };
+  const weightedTotal = Object.values(components).reduce((sum, component) => sum + component.weightedScore, 0);
+  const weightTotal = Object.values(components).reduce((sum, component) => sum + component.weight, 0);
+  const value = roundScore(weightTotal ? weightedTotal * 100 / weightTotal : 0);
+  const weakFacets = Object.values(components).filter((component) => component.status === 'weak').map((component) => component.key);
+  const blockedFacets = Object.values(components).filter((component) => component.status === 'blocked').map((component) => component.key);
+  const lowestScore = Math.min(...Object.values(components).map((component) => component.score));
+  return {
+    schema: 'frontier.lang.semanticMergeCandidateScoreFacets.v1',
+    version: 1,
+    higherIsBetter: true,
+    value,
+    risk: value < 50 || blockedFacets.length ? 'high' : value < 80 || weakFacets.length ? 'medium' : 'low',
+    components,
+    summary: {
+      value,
+      risk: value < 50 || blockedFacets.length ? 'high' : value < 80 || weakFacets.length ? 'medium' : 'low',
+      lowestScore,
+      weakFacets,
+      blockedFacets,
+      availableFacets: Object.values(components).filter((component) => component.signals.available !== false).map((component) => component.key)
+    }
+  };
+}
+
+function ownershipFacet(input) {
+  const regions = input.changedSemanticRegions;
+  const keyedRegions = regions.filter((region) => region.key || region.conflictKey);
+  const kindedRegions = regions.filter((region) => region.regionKind);
+  const spannedRegions = regions.filter((region) => region.sourceSpan);
+  const score = regions.length
+    ? roundScore(keyedRegions.length * 70 / regions.length + kindedRegions.length * 15 / regions.length + spannedRegions.length * 15 / regions.length)
+    : input.conflictKeys.length ? 45 : 70;
+  return scoreFacet('ownership', score, [
+    ...(regions.length === 0 ? ['missing-changed-semantic-regions'] : []),
+    ...(regions.length && keyedRegions.length < regions.length ? ['missing-ownership-keys'] : [])
+  ], {
+    changedSemanticRegions: regions.length,
+    keyedRegions: keyedRegions.length,
+    regionKinds: uniqueStrings(regions.map((region) => region.regionKind)),
+    conflictKeys: input.conflictKeys,
+    ownershipKeys: uniqueStrings(regions.map((region) => region.key))
+  });
+}
+
+function staleStatusFacet(input) {
+  const staleEvidence = input.evidenceRecords.filter((record) => evidenceStatus(record) === 'stale' || record?.metadata?.stale === true);
+  const sourceHashVerified = [
+    input.source?.metadata?.sourceHashVerified,
+    input.source?.before?.metadata?.sourceHashVerified,
+    input.source?.after?.metadata?.sourceHashVerified,
+    input.candidate?.metadata?.sourceHashVerified,
+    input.patch?.metadata?.sourceHashVerified
+  ].filter((value) => value !== undefined);
+  const staleProofs = semanticSidecarQuality(input)?.proofSummary?.stale ?? 0;
+  const sourceHashStale = sourceHashVerified.includes(false);
+  const score = sourceHashStale ? 0 : staleEvidence.length ? 35 : staleProofs > 0 ? 55 : 100;
+  return scoreFacet('staleStatus', score, [
+    ...(sourceHashStale ? ['stale-source-hash'] : []),
+    ...(staleEvidence.length ? ['stale-evidence'] : []),
+    ...(staleProofs > 0 ? ['stale-sidecar-proof-obligations'] : [])
+  ], {
+    staleEvidenceIds: staleEvidence.map((record) => record.id).filter(Boolean),
+    staleProofObligations: staleProofs,
+    sourceHashVerified
+  });
+}
+
+function testEvidenceFacet(input) {
+  const failed = input.evidenceRecords.filter((record) => evidenceStatus(record) === 'failed');
+  const stale = input.evidenceRecords.filter((record) => evidenceStatus(record) === 'stale');
+  const pending = input.evidenceRecords.filter((record) => ['pending', 'assumed', 'unknown'].includes(evidenceStatus(record)));
+  const passed = input.evidenceRecords.filter((record) => ['passed', 'ok', 'success'].includes(evidenceStatus(record)));
+  const score = failed.length ? 0 : stale.length ? 45 : pending.length ? 65 : input.proofIds.length ? 100 : input.evidenceIds.length ? 82 : 35;
+  return scoreFacet('testEvidence', score, [
+    ...(failed.length ? ['failed-evidence'] : []),
+    ...(stale.length ? ['stale-evidence'] : []),
+    ...(pending.length ? ['pending-evidence'] : []),
+    ...(!input.evidenceIds.length && !input.proofIds.length ? ['missing-evidence'] : [])
+  ], {
+    evidenceIds: input.evidenceIds,
+    proofIds: input.proofIds,
+    evidenceRecords: input.evidenceRecords.length,
+    passedEvidenceIds: passed.map((record) => record.id).filter(Boolean),
+    failedEvidenceIds: failed.map((record) => record.id).filter(Boolean),
+    staleEvidenceIds: stale.map((record) => record.id).filter(Boolean),
+    pendingEvidenceIds: pending.map((record) => record.id).filter(Boolean)
+  });
+}
+
+function overlapFacet(input) {
+  const high = input.overlaps.filter((overlap) => overlap.risk === 'high').length;
+  const medium = input.overlaps.filter((overlap) => overlap.risk === 'medium').length;
+  const score = clampScore(100 - high * 45 - medium * 25 - Math.max(0, input.overlaps.length - high - medium) * 15);
+  return scoreFacet('overlap', score, [
+    ...(input.overlaps.length ? ['overlapping-semantic-regions'] : [])
+  ], {
+    overlaps: input.overlaps.length,
+    highRiskOverlaps: high,
+    mediumRiskOverlaps: medium,
+    conflictKeys: uniqueStrings(input.overlaps.flatMap((overlap) => overlap.conflictKeys ?? [])),
+    byKind: countBy(input.overlaps.map((overlap) => overlap.overlapKind))
+  });
+}
+
+function sizeFacet(input) {
+  const operationCount = array(input.candidate?.operations ?? input.patch?.operations).length;
+  const changedSemanticRegions = input.changedSemanticRegions.length;
+  const conflictKeys = input.conflictKeys.length;
+  const score = clampScore(100 - Math.max(0, changedSemanticRegions - 3) * 8 - Math.max(0, operationCount - 3) * 4 - Math.max(0, conflictKeys - 4) * 3);
+  return scoreFacet('size', score, [
+    ...(changedSemanticRegions > 3 ? ['large-changed-region-set'] : []),
+    ...(operationCount > 3 ? ['large-operation-set'] : []),
+    ...(conflictKeys > 4 ? ['many-conflict-keys'] : [])
+  ], { changedSemanticRegions, operationCount, conflictKeys });
+}
+
+function semanticSidecarQualityFacet(input) {
+  const quality = semanticSidecarQuality(input);
+  if (!quality) return scoreFacet('semanticSidecarQuality', 100, [], { available: false });
+  const proofSummary = quality.proofSummary ?? {};
+  const warningCodes = uniqueStrings([...(quality.warnings ?? []).map((warning) => warning.code), ...strings(quality.expectedMissingReasonCodes)]);
+  const reviewProofs = (proofSummary.open ?? 0) + (proofSummary.stale ?? 0) + (proofSummary.assumed ?? 0) + (proofSummary.externalToolRequired ?? 0) + (proofSummary.unknown ?? 0);
+  const score = clampScore(
+    (quality.imported === false || quality.selected === false ? 25 : 100)
+    - (quality.eligible === false ? 35 : 0)
+    - Math.min(35, (quality.warningCount ?? warningCodes.length ?? 0) * 7)
+    - Math.min(40, (proofSummary.failed ?? 0) * 20)
+    - Math.min(25, reviewProofs * 5)
+  );
+  return scoreFacet('semanticSidecarQuality', score, [
+    ...(quality.imported === false || quality.selected === false ? ['semantic-sidecar-not-imported'] : []),
+    ...(quality.eligible === false ? ['semantic-sidecar-not-eligible'] : []),
+    ...warningCodes
+  ], {
+    available: true,
+    expected: quality.expected,
+    expectedSatisfied: quality.expectedSatisfied,
+    selected: quality.selected,
+    imported: quality.imported,
+    eligible: quality.eligible,
+    importCount: quality.importCount,
+    symbolCount: quality.symbolCount,
+    ownershipRegionCount: quality.ownershipRegionCount,
+    patchHintCount: quality.patchHintCount,
+    evidenceCount: quality.evidenceCount,
+    warningCount: quality.warningCount ?? warningCodes.length,
+    warningCodes,
+    proofSummary
+  });
+}
+
+function semanticSidecarQuality(input) {
+  return [
+    input.candidate?.semanticSidecarQuality,
+    input.candidate?.sidecarQuality,
+    input.candidate?.semanticSidecar?.quality,
+    input.candidate?.sidecar?.quality,
+    input.candidate?.metadata?.semanticSidecarQuality,
+    input.candidate?.metadata?.sidecarQuality,
+    input.source?.semanticSidecarQuality,
+    input.source?.sidecarQuality,
+    input.source?.semanticSidecar?.quality,
+    input.source?.sidecar?.quality,
+    input.source?.metadata?.semanticSidecarQuality,
+    input.source?.metadata?.sidecarQuality,
+    input.patch?.semanticSidecarQuality,
+    input.patch?.metadata?.semanticSidecarQuality
+  ].find(looksLikeSemanticSidecarQuality);
+}
+
+function looksLikeSemanticSidecarQuality(value) {
+  return value && typeof value === 'object' && (
+    value.schema === 'frontier.lang.semanticSidecarQuality.v1'
+    || value.eligible !== undefined
+    || value.imported !== undefined
+    || value.proofSummary !== undefined
+    || value.warningCount !== undefined
+  );
+}
+
+function scoreFacet(key, score, reasonCodes, signals) {
+  const normalizedScore = clampScore(score);
+  const weight = scoreFacetWeights[key] ?? 1;
+  return {
+    key,
+    score: normalizedScore,
+    weight,
+    weightedScore: roundScore(normalizedScore * weight / 100),
+    status: facetStatus(normalizedScore),
+    reasonCodes: uniqueStrings(reasonCodes),
+    signals: compactRecord(signals)
+  };
+}
+
+function facetStatus(score) {
+  if (score <= 0) return 'blocked';
+  if (score < 50) return 'weak';
+  if (score < 80) return 'partial';
+  return 'strong';
+}
+
+function evidenceStatus(record) { return String(record?.status ?? record?.metadata?.status ?? '').toLowerCase(); }
+function countBy(values) { const counts = {}; for (const value of values ?? []) { const key = String(value ?? 'unknown'); counts[key] = (counts[key] ?? 0) + 1; } return counts; }
+function clampScore(value) { return Math.max(0, Math.min(100, roundScore(value))); }
+function roundScore(value) { return Math.round((Number.isFinite(value) ? value : 0) * 100) / 100; }
+function array(value) { if (value === undefined || value === null) return []; return Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -90,7 +90,7 @@ export function querySemanticPatchBundleOverlaps(records,query={}){
 }
 
 function sharedIndex(left,right,options){
-  return{
+  const shared={
     operationContentHashes:intersect(left.operationContentHashes,right.operationContentHashes),
     editContentHashes:intersect(left.editContentHashes,right.editContentHashes),
     semanticEditKeys:intersect(left.semanticEditKeys,right.semanticEditKeys),
@@ -110,6 +110,28 @@ function sharedIndex(left,right,options){
     baseHashes:intersect(left.baseHashes,right.baseHashes),
     targetHashes:intersect(left.targetHashes,right.targetHashes)
   };
+  const scopedEdit=hasSharedEditScope(shared);
+  const scopedSource=hasSharedSourceScope(shared);
+  return{
+    ...shared,
+    operationContentHashes:scopedEdit?shared.operationContentHashes:[],
+    editContentHashes:scopedEdit?shared.editContentHashes:[],
+    semanticEditKeys:scopedSource?shared.semanticEditKeys:[],
+    semanticIdentityHashes:scopedSource?shared.semanticIdentityHashes:[],
+    semanticEditReplayCurrentHashes:scopedSource?shared.semanticEditReplayCurrentHashes:[],
+    semanticEditReplayOutputHashes:scopedEdit?shared.semanticEditReplayOutputHashes:[],
+    semanticTransformContentHashes:shared.projectionIdentityHashes.length?shared.semanticTransformContentHashes:[],
+    semanticTransformIdentityHashes:shared.projectionIdentityHashes.length?shared.semanticTransformIdentityHashes:[]
+  };
+}
+
+function hasSharedEditScope(shared){
+  return Boolean(shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length
+    ||(shared.sourcePaths.length&&(shared.semanticEditKeys.length||shared.semanticIdentityHashes.length)));
+}
+
+function hasSharedSourceScope(shared){
+  return Boolean(shared.sourcePaths.length||shared.regionKeys.length||shared.conflictKeys.length||shared.sourceIdentityHashes.length);
 }
 
 function overlapAdmission(shared,{leftIndex,rightIndex,options}){

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

@@ -1,5 +1,12 @@
 export function sourcePreservationFromProjectionContext(context) {
-  return context.nativeSource?.metadata?.sourcePreservation
+  return context.sourcePreservation
+    ?? context.metadata?.sourcePreservation
+    ?? context.importResult?.metadata?.sourcePreservation
+    ?? context.importResult?.nativeSource?.metadata?.sourcePreservation
+    ?? context.importResult?.nativeAst?.metadata?.sourcePreservation
+    ?? context.nativeSource?.metadata?.sourcePreservation
     ?? context.nativeAst?.metadata?.sourcePreservation
-    ?? context.nativeSource?.ast?.metadata?.sourcePreservation;
+    ?? context.nativeSource?.ast?.metadata?.sourcePreservation
+    ?? context.universalAst?.metadata?.sourcePreservation
+    ?? context.importResult?.universalAst?.metadata?.sourcePreservation;
 }

package/dist/native-import-language-profiles.js

@@ -17,13 +17,21 @@ export const NativeImportLanguageProfiles = Object.freeze([
     aliases: ['js', 'mjs', 'cjs', 'jsx'],
     extensions: ['.js', '.mjs', '.cjs', '.jsx'],
     parserAdapters: ['estree', 'babel', 'tree-sitter'],
-    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'dynamicRuntime']
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'dynamicRuntime'],
+    notes: [
+      'lightweight scanner records declarations only; exact parser adapters must be injected by the host',
+      '.jsx sources are classified as javascript for declaration scanning; JSX element trees remain opaque without host parser evidence'
+    ]
   }),
   nativeImportLanguageProfile('typescript', {
     aliases: ['ts', 'tsx'],
     extensions: ['.ts', '.tsx'],
     parserAdapters: ['typescript-compiler-api', 'babel', 'tree-sitter'],
-    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'unsupportedSyntax']
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'unsupportedSyntax'],
+    notes: [
+      'lightweight scanner records declarations only; exact parser adapters must be injected by the host',
+      '.tsx sources are classified as typescript for declaration scanning; JSX element trees remain opaque without host parser evidence'
+    ]
   }),
   nativeImportLanguageProfile('python', {
     aliases: ['py'],

package/dist/native-region-scanner-js-helpers.js

@@ -4,7 +4,6 @@ import {
   splitParameters
 } from './native-region-scanner-core.js';
 import { jsImportDeclarations } from './native-region-scanner-js-imports.js';
-
 function jsCommentOnlyLine(trimmed) {
   return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
 }
@@ -128,7 +127,7 @@ function jsExportedContainerDeclaration(input, lineNumber, trimmed) {
 }
 
 function jsExportedFunctionWrapperDeclaration(input, lineNumber, trimmed) {
-  const match = trimmed.match(/^export\s+default\s+((?:React\.)?(?:forwardRef|memo|lazy|observer))\s*(?:<[^>]+>)?\s*\(\s*(.+)$/);
+  const match = trimmed.match(/^export\s+default\s+((?:React\.)?(?:forwardRef|memo|lazy|observer)|Object\.freeze)\s*(?:<[^>]+>)?\s*\(\s*(.+)$/);
   if (!match) return undefined;
   const wrapper = match[1];
   const argument = match[2].trim();
@@ -148,6 +147,13 @@ function jsExportedFunctionWrapperDeclaration(input, lineNumber, trimmed) {
       parameters: splitParameters(functionMatch[1] ?? functionMatch[2])
     }, true);
   }
+  const classMatch = argument.match(/^(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/);
+  if (classMatch) {
+    return nativeDeclaration(input, lineNumber, 'ExportDefaultClassWrapperDeclaration', 'class', classMatch[1] ?? 'default', {
+      exportDefault: true,
+      wrapper
+    }, true);
+  }
   const aliasMatch = argument.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*(?:[,)]|$)/);
   if (!aliasMatch) return undefined;
   return nativeDeclaration(input, lineNumber, 'ExportDefaultWrappedAlias', 'variable', 'default', {

package/dist/native-region-scanner-js-imports.js

@@ -44,6 +44,13 @@ export function jsImportDeclarations(input, lineNumber, trimmed) {
     importedName: 'default',
     importKind: trimmed.includes('import') ? 'dynamic-import-binding' : 'commonjs-require'
   }]);
+  const sideEffectRequireMatch = trimmed.match(/^require\s*\(\s*(['"])([^'"]+)\1\s*\)\s*;?$/);
+  if (sideEffectRequireMatch) {
+    return jsImportModuleDeclarations(input, lineNumber, sideEffectRequireMatch[2], 'CommonJsSideEffectRequireDeclaration', [], {
+      sideEffectOnly: true,
+      importKind: 'commonjs-require'
+    });
+  }
   return [];
 }
 

package/dist/native-region-scanner-js.js

@@ -126,18 +126,18 @@ function scanJavaScriptLike(input) {
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
       const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
       pushDeclaration(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
         methodName: match[1],
         owner: currentClass,
         parameters: splitParameters(match[2])
       }, declarationLine.includes('{') || declarationLine.includes('=>')));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*([A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*(#?[A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
         propertyName: match[1],
         owner: currentClass,
         valueType: match[2]?.trim()
-      }, false));
+      }, false, { regionKind: 'property' }));
     }
     if (currentClass) {
       classDepth += braceDelta(trimmed);
@@ -271,7 +271,7 @@ function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, cla
   if (open < 0 || close <= open) return [];
   const body = declarationLine.slice(open + 1, close);
   const declarations = [];
-  for (const match of body.matchAll(/(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
+  for (const match of body.matchAll(/(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
     if (jsControlKeyword(match[1])) continue;
     declarations.push(nativeDeclaration(input, lineNumber, 'MethodDefinition', 'method', `${className}.${match[1]}`, {
       methodName: match[1],

package/dist/native-region-scanner.js

@@ -26,6 +26,7 @@ import {
   scanHaskell,
   scanR
 } from './native-region-scanner-functional.js';
+import { normalizeNativeLanguageId } from './native-import-utils.js';
 export { lightweightCoverageLosses } from './native-region-scanner-core.js';
 export {
   detectNewlineStyle,
@@ -34,7 +35,7 @@ export {
 } from './native-source-preservation-scanner.js';
 
 function scanNativeDeclarations(input) {
-  const language = String(input.language).toLowerCase();
+  const language = normalizeNativeLanguageId(input.language) || String(input.language).toLowerCase();
   if (language === 'javascript' || language === 'typescript') return scanJavaScriptLike(input);
   if (language === 'python') return scanPython(input);
   if (language === 'rust') return scanRust(input);

package/dist/semantic-import-regions.js

@@ -1,4 +1,4 @@
-import { caseSensitiveIdFragment, idFragment, uniqueStrings } from './native-import-utils.js';
+import { caseSensitiveIdFragment, idFragment, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
 
 const NativeImportRegionTaxonomyKinds = Object.freeze([
   'symbol',
@@ -20,20 +20,20 @@ function semanticOwnershipRegionForSymbol(imported, symbol, mapping, nativeNode,
   const language = symbol.language ?? imported?.language ?? imported?.nativeAst?.language ?? imported?.nativeSource?.language;
   const sourceSpan = mapping?.sourceSpan ?? symbol.definitionSpan ?? nativeNode?.span;
   const regionKind = semanticRegionKindForSymbol(symbol, mapping, nativeNode);
-  const key = [
+  const key = symbol?.metadata?.ownershipRegionKey ?? [
     options.regionPrefix ?? 'source',
     sourcePath ?? `${language}:memory`,
     regionKind,
     symbol.name ?? symbol.id
   ].map((part) => String(part).replace(/\s+/g, ' ').trim()).join('#');
   return {
-    id: `region_${caseSensitiveIdFragment(key)}`,
+    id: symbol?.metadata?.ownershipRegionId ?? `region_${caseSensitiveIdFragment(key)}`,
     key,
     regionKind,
     granularity: 'symbol',
     language,
     sourcePath,
-    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash,
+    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? imported?.sourceHash,
     symbolId: symbol.id,
     symbolName: symbol.name,
     symbolKind: symbol.kind,
@@ -76,17 +76,19 @@ function semanticOwnershipRegionForDeclaration(input, declaration, documentId) {
 }
 
 function semanticPatchHintForRegion(region, readiness, options = {}) {
+  const supportedOperations = semanticRegionSupportedOperations(region);
   return {
     id: `hint_${idFragment(region.id)}`,
     kind: 'source-region-patch',
     ownershipRegionId: region.id,
     ownershipKey: region.key,
+    operation: supportedOperations[0] ?? 'replace-region',
     sourcePath: region.sourcePath,
     sourceHash: region.sourceHash,
     sourceSpan: region.sourceSpan,
     readiness,
     precision: region.precision,
-    supportedOperations: semanticRegionSupportedOperations(region),
+    supportedOperations,
     projection: {
       sourceLanguage: region.language,
       targetPath: options.targetPath ?? region.sourcePath,
@@ -170,9 +172,20 @@ function summarizeSemanticImportRegionTaxonomy(regions) {
   };
 }
 
+function semanticOwnershipRegionsFromSemanticIndex(semanticIndex) {
+  const factRegions = (semanticIndex?.facts ?? [])
+    .filter((fact) => fact?.predicate === 'semanticOwnershipRegion' && fact.value && typeof fact.value === 'object')
+    .map((fact) => fact.value);
+  return uniqueRecordsById([
+    ...(Array.isArray(semanticIndex?.ownershipRegions) ? semanticIndex.ownershipRegions : []),
+    ...factRegions
+  ]);
+}
+
 export {
   NativeImportRegionTaxonomyKinds,
   semanticOwnershipRegionForDeclaration,
+  semanticOwnershipRegionsFromSemanticIndex,
   semanticOwnershipRegionForSymbol,
   semanticPatchHintForRegion,
   semanticRegionKindForSymbol,

package/dist/semantic-import-sidecar-admission-types.d.ts

@@ -8,6 +8,16 @@ export interface SemanticImportSidecarQualityWarning {
   readonly sourcePaths: readonly string[];
 }
 
+export type SemanticImportSidecarRecordClassification = 'useful' | 'expected-empty' | 'unexpectedly-empty' | 'missing' | string;
+
+export interface SemanticImportSidecarQualityRecord {
+  readonly classification: SemanticImportSidecarRecordClassification;
+  readonly reasonCode: string;
+  readonly message: string;
+  readonly action: string;
+  readonly sourcePaths: readonly string[];
+}
+
 export interface SemanticImportSidecarProofAdmissionSummary {
   readonly total: number;
   readonly obligations: number;
@@ -26,12 +36,14 @@ export interface SemanticImportSidecarProofAdmissionSummary {
 export interface SemanticImportSidecarQuality {
   readonly schema: 'frontier.lang.semanticSidecarQuality.v1';
   readonly expected: boolean;
+  readonly expectedEmpty: boolean;
   readonly expectedSatisfied: boolean;
   readonly expectedMissingReasonCodes: readonly string[];
   readonly selected: boolean;
   readonly eligible: boolean;
   readonly imported: boolean;
   readonly importCount: number;
+  readonly record: SemanticImportSidecarQualityRecord;
   readonly symbolCount: number;
   readonly ownershipRegionCount: number;
   readonly patchHintCount: number;
@@ -45,6 +57,7 @@ export interface SemanticImportSidecarQuality {
 export interface SemanticImportSidecarAdmission {
   readonly schema: 'frontier.lang.semanticSidecarAdmission.v1';
   readonly expected: boolean;
+  readonly expectedEmpty: boolean;
   readonly expectedSatisfied: boolean;
   readonly expectedMissingReasonCodes: readonly string[];
   readonly selected: boolean;
@@ -53,6 +66,7 @@ export interface SemanticImportSidecarAdmission {
   readonly importCount: number;
   readonly readiness: SemanticMergeReadiness;
   readonly action: string;
+  readonly record: SemanticImportSidecarQualityRecord;
   readonly counts: {
     readonly symbols: number;
     readonly ownershipRegions: number;