@shapeshift-labs/frontier-lang-compiler 0.2.88 → 0.2.90

package/dist/declarations/semantic-patch-bundle-overlaps.d.ts

@@ -6,6 +6,9 @@ export type SemanticPatchBundleOverlapKind =
   | 'semantic-edit-key'
   | 'semantic-identity'
   | 'source-identity'
+  | 'transform-content'
+  | 'semantic-transform'
+  | 'projection-identity'
   | 'region'
   | 'conflict-key'
   | 'source-path'
@@ -24,6 +27,9 @@ export interface SemanticPatchBundleOverlapShared {
   readonly semanticEditKeys: readonly string[];
   readonly semanticIdentityHashes: readonly string[];
   readonly sourceIdentityHashes: readonly string[];
+  readonly semanticTransformContentHashes: readonly string[];
+  readonly semanticTransformIdentityHashes: readonly string[];
+  readonly projectionIdentityHashes: readonly string[];
   readonly regionKeys: readonly string[];
   readonly conflictKeys: readonly string[];
   readonly sourcePaths: readonly string[];
@@ -91,6 +97,12 @@ export interface SemanticPatchBundleOverlapQuery {
   readonly conflictKeys?: readonly string[];
   readonly semanticEditKey?: string | readonly string[];
   readonly semanticEditKeys?: readonly string[];
+  readonly semanticTransformIdentityHash?: string | readonly string[];
+  readonly semanticTransformIdentityHashes?: readonly string[];
+  readonly semanticTransformContentHash?: string | readonly string[];
+  readonly semanticTransformContentHashes?: readonly string[];
+  readonly projectionIdentityHash?: string | readonly string[];
+  readonly projectionIdentityHashes?: readonly string[];
   readonly operationContentHash?: string | readonly string[];
   readonly operationContentHashes?: readonly string[];
   readonly editContentHash?: string | readonly string[];

package/dist/declarations/semantic-patch-bundle.d.ts

@@ -8,6 +8,7 @@ import type {
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-diff.js';
 import type { SemanticEditProjection, SemanticEditScript } from './semantic-edit-script.js';
+import type { SemanticTransformIdentityRecord } from './semantic-transform-identity.js';
 
 export type SemanticPatchBundleAdmissionStatus = 'proposed' | 'queued' | 'admitted' | 'needs-review' | 'blocked' | 'rejected' | string;
 
@@ -110,6 +111,15 @@ export interface SemanticPatchBundleRecordIndex {
   readonly sourceIdentityHashes: readonly string[];
   readonly operationContentHashes: readonly string[];
   readonly editContentHashes: readonly string[];
+  readonly semanticTransformIds: readonly string[];
+  readonly semanticTransformKeys: readonly string[];
+  readonly semanticTransformIdentityHashes: readonly string[];
+  readonly semanticTransformContentHashes: readonly string[];
+  readonly projectionIdentityHashes: readonly string[];
+  readonly transformSourceLanguages: readonly string[];
+  readonly transformTargetLanguages: readonly string[];
+  readonly transformSourcePaths: readonly string[];
+  readonly transformTargetPaths: readonly string[];
   readonly patchIds: readonly string[];
   readonly mergeCandidateIds: readonly string[];
   readonly readinesses: readonly string[];
@@ -137,6 +147,7 @@ export interface SemanticPatchBundleRecord {
   readonly semanticOperationIds: readonly string[];
   readonly semanticEditScriptIds: readonly string[];
   readonly semanticEditProjectionIds: readonly string[];
+  readonly semanticTransformIdentityIds: readonly string[];
   readonly admission: SemanticPatchBundleAdmission;
   readonly index: SemanticPatchBundleRecordIndex;
   readonly summary: {
@@ -149,6 +160,7 @@ export interface SemanticPatchBundleRecord {
     readonly semanticEditScripts: number;
     readonly semanticEditProjections: number;
     readonly semanticEditProjectionEdits: number;
+    readonly semanticTransformIdentities: number;
     readonly reviewRequired: boolean;
     readonly autoMergeClaim: false;
   };
@@ -181,6 +193,10 @@ export interface CreateSemanticPatchBundleRecordOptions {
   readonly semanticEditScripts?: readonly SemanticEditScript[] | SemanticEditScript;
   readonly semanticEditProjection?: SemanticEditProjection;
   readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
+  readonly semanticTransformIdentity?: SemanticTransformIdentityRecord | Record<string, unknown>;
+  readonly semanticTransformIdentities?: readonly (SemanticTransformIdentityRecord | Record<string, unknown>)[];
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly targetLanguage?: FrontierSourceLanguage | string;
   readonly conflictKeys?: readonly string[] | string;
   readonly admission?: Partial<SemanticPatchBundleAdmission>;
   readonly metadata?: Record<string, unknown>;
@@ -237,6 +253,24 @@ export interface SemanticPatchBundleRecordQuery {
   readonly operationContentHashes?: readonly string[];
   readonly editContentHash?: string | readonly string[];
   readonly editContentHashes?: readonly string[];
+  readonly semanticTransformId?: string | readonly string[];
+  readonly semanticTransformIds?: readonly string[];
+  readonly semanticTransformKey?: string | readonly string[];
+  readonly semanticTransformKeys?: readonly string[];
+  readonly semanticTransformIdentityHash?: string | readonly string[];
+  readonly semanticTransformIdentityHashes?: readonly string[];
+  readonly semanticTransformContentHash?: string | readonly string[];
+  readonly semanticTransformContentHashes?: readonly string[];
+  readonly projectionIdentityHash?: string | readonly string[];
+  readonly projectionIdentityHashes?: readonly string[];
+  readonly transformSourceLanguage?: string | readonly string[];
+  readonly transformSourceLanguages?: readonly string[];
+  readonly transformTargetLanguage?: string | readonly string[];
+  readonly transformTargetLanguages?: readonly string[];
+  readonly transformSourcePath?: string | readonly string[];
+  readonly transformSourcePaths?: readonly string[];
+  readonly transformTargetPath?: string | readonly string[];
+  readonly transformTargetPaths?: readonly string[];
   readonly readiness?: SemanticMergeReadiness | string | readonly string[];
   readonly readinesses?: readonly string[];
   readonly admissionStatus?: SemanticPatchBundleAdmissionStatus | readonly string[];

package/dist/declarations/semantic-transform-identity.d.ts

@@ -0,0 +1,68 @@
+import type { FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+
+export interface SemanticTransformIdentityRecord {
+  readonly kind: 'frontier.lang.semanticTransformIdentityRecord';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.semanticTransformIdentityRecord.v1';
+  readonly id: string;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly targetLanguage?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly targetPath?: string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly semanticKey?: string;
+  readonly transformKey?: string;
+  readonly semanticIdentityHash?: string;
+  readonly sourceIdentityHash?: string;
+  readonly operationContentHash?: string;
+  readonly editContentHash?: string;
+  readonly transformIdentityHash?: string;
+  readonly projectionIdentityHash?: string;
+  readonly transformContentHash?: string;
+  readonly readiness?: string;
+  readonly confidence?: number;
+  readonly evidenceIds?: readonly string[];
+  readonly metadata?: {
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly sourceTransformId?: string;
+    readonly [key: string]: unknown;
+  };
+}
+
+export interface CreateSemanticTransformIdentityRecordOptions extends Partial<SemanticTransformIdentityRecord> {
+  readonly language?: FrontierSourceLanguage | string;
+  readonly projectedLanguage?: FrontierSourceLanguage | string;
+  readonly originalSourcePath?: string;
+  readonly targetSourcePath?: string;
+  readonly projectedSourcePath?: string;
+  readonly symbolName?: string;
+  readonly symbolKind?: string;
+  readonly anchorKey?: string;
+  readonly regionId?: string;
+  readonly operationId?: string;
+}
+
+export interface DeriveSemanticTransformIdentityRecordsOptions extends CreateSemanticTransformIdentityRecordOptions {
+  readonly semanticEditProjection?: unknown;
+  readonly semanticEditProjections?: readonly unknown[] | unknown;
+  readonly projection?: unknown;
+  readonly projections?: readonly unknown[] | unknown;
+}
+
+export type CreateSemanticTransformIdentityRecordInput =
+  | Partial<SemanticTransformIdentityRecord>
+  | Record<string, unknown>;
+
+export declare function createSemanticTransformIdentityRecord(
+  input?: CreateSemanticTransformIdentityRecordInput,
+  options?: CreateSemanticTransformIdentityRecordOptions
+): SemanticTransformIdentityRecord;
+export declare function semanticTransformIdentityFields(
+  record?: SemanticTransformIdentityRecord | Record<string, unknown>
+): SemanticTransformIdentityRecord;
+export declare function deriveSemanticTransformIdentityRecords(
+  input?: DeriveSemanticTransformIdentityRecordsOptions | Record<string, unknown>,
+  options?: DeriveSemanticTransformIdentityRecordsOptions
+): readonly SemanticTransformIdentityRecord[];

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export * from './declarations/semantic-lineage.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-patch-bundle-overlaps.js';
+export * from './declarations/semantic-transform-identity.js';
 export * from './declarations/bidirectional-target-change.js';
 export * from './declarations/semantic-impact.js';
 export * from './declarations/semantic-sidecar.js';

package/dist/index.js

@@ -68,6 +68,7 @@ export { queryNativeParserFeatureMatrix } from './internal/index-impl/queryNativ
 export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProjectionReadinessMatrix.js';
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
 export { compareSemanticPatchBundleRecords, querySemanticPatchBundleOverlaps, SemanticPatchBundleOverlapKinds, SemanticPatchBundleOverlapStatuses } from './internal/index-impl/semanticPatchBundleOverlaps.js';
+export { createSemanticTransformIdentityRecord, deriveSemanticTransformIdentityRecords, semanticTransformIdentityFields } from './internal/index-impl/semanticTransformIdentityRecords.js';
 export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandidateForAdmission, querySemanticMergeCandidateAdmissionOverlaps, SemanticMergeCandidateProjectionRisks, semanticMergeCandidateReadinessSortKey, sortSemanticMergeCandidateAdmissionRecords } from './internal/index-impl/semanticMergeCandidateRecords.js';
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';
 export { createSemanticEditScript, SemanticEditScriptAdmissionStatuses } from './internal/index-impl/semanticEditScripts.js';

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

@@ -6,6 +6,9 @@ export const SemanticPatchBundleOverlapKinds=Object.freeze([
   'semantic-edit-key',
   'semantic-identity',
   'source-identity',
+  'transform-content',
+  'semantic-transform',
+  'projection-identity',
   'region',
   'conflict-key',
   'source-path'
@@ -24,6 +27,9 @@ const KIND_FIELDS=Object.freeze({
   'semantic-edit-key':'semanticEditKeys',
   'semantic-identity':'semanticIdentityHashes',
   'source-identity':'sourceIdentityHashes',
+  'transform-content':'semanticTransformContentHashes',
+  'semantic-transform':'semanticTransformIdentityHashes',
+  'projection-identity':'projectionIdentityHashes',
   region:'regionKeys',
   'conflict-key':'conflictKeys',
   'source-path':'sourcePaths'
@@ -49,8 +55,8 @@ export function compareSemanticPatchBundleRecords(left={},right={},options={}){
     score:overlapScore(admission.status,shared,admission.reasonCodes),
     summary:{
       sharedKeys:countShared(shared),
-      duplicateSignals:shared.operationContentHashes.length+shared.editContentHashes.length,
-      semanticSignals:shared.semanticEditKeys.length+shared.semanticIdentityHashes.length+shared.sourceIdentityHashes.length,
+      duplicateSignals:shared.operationContentHashes.length+shared.editContentHashes.length+shared.semanticTransformContentHashes.length,
+      semanticSignals:shared.semanticEditKeys.length+shared.semanticIdentityHashes.length+shared.sourceIdentityHashes.length+shared.semanticTransformIdentityHashes.length+shared.projectionIdentityHashes.length,
       sourceSignals:shared.regionKeys.length+shared.conflictKeys.length+shared.sourcePaths.length,
       baseHashMismatch:admission.reasonCodes.includes('base-hash-mismatch'),
       targetHashMismatch:admission.reasonCodes.includes('target-hash-mismatch')
@@ -84,6 +90,9 @@ function sharedIndex(left,right,options){
     semanticEditKeys:intersect(left.semanticEditKeys,right.semanticEditKeys),
     semanticIdentityHashes:intersect(left.semanticIdentityHashes,right.semanticIdentityHashes),
     sourceIdentityHashes:intersect(left.sourceIdentityHashes,right.sourceIdentityHashes),
+    semanticTransformContentHashes:intersect(left.semanticTransformContentHashes,right.semanticTransformContentHashes),
+    semanticTransformIdentityHashes:intersect(left.semanticTransformIdentityHashes,right.semanticTransformIdentityHashes),
+    projectionIdentityHashes:intersect(left.projectionIdentityHashes,right.projectionIdentityHashes),
     regionKeys:intersect(left.regionKeys,right.regionKeys),
     conflictKeys:intersect(left.conflictKeys,right.conflictKeys),
     sourcePaths:options.includeSourcePaths===false?[]:intersect(left.sourcePaths,right.sourcePaths),
@@ -93,16 +102,19 @@ function sharedIndex(left,right,options){
 }
 
 function overlapAdmission(shared,{leftIndex,rightIndex,options}){
-  const duplicate=shared.operationContentHashes.length||shared.editContentHashes.length;
-  const semantic=shared.semanticEditKeys.length||shared.semanticIdentityHashes.length||shared.sourceIdentityHashes.length;
+  const duplicate=shared.operationContentHashes.length||shared.editContentHashes.length||shared.semanticTransformContentHashes.length;
+  const semantic=shared.semanticEditKeys.length||shared.semanticIdentityHashes.length||shared.sourceIdentityHashes.length||shared.semanticTransformIdentityHashes.length||shared.projectionIdentityHashes.length;
   const source=shared.regionKeys.length||shared.conflictKeys.length||shared.sourcePaths.length;
   const status=duplicate?'duplicate':semantic?'semantic-overlap':source?'source-overlap':'independent';
   const reasonCodes=uniqueStrings([
     shared.operationContentHashes.length?'same-operation-content':undefined,
     shared.editContentHashes.length?'same-edit-content':undefined,
+    shared.semanticTransformContentHashes.length?'same-transform-content':undefined,
     shared.semanticEditKeys.length?'same-semantic-edit-key':undefined,
     shared.semanticIdentityHashes.length?'same-semantic-identity':undefined,
     shared.sourceIdentityHashes.length?'same-source-identity':undefined,
+    shared.semanticTransformIdentityHashes.length?'same-semantic-transform':undefined,
+    shared.projectionIdentityHashes.length?'same-projection-identity':undefined,
     shared.regionKeys.length?'same-region-key':undefined,
     shared.conflictKeys.length?'same-conflict-key':undefined,
     shared.sourcePaths.length?'same-source-path':undefined,
@@ -129,6 +141,9 @@ function bundleIndex(record){
     semanticEditKeys:uniqueStrings(index.semanticEditKeys),
     semanticIdentityHashes:uniqueStrings(index.semanticIdentityHashes),
     sourceIdentityHashes:uniqueStrings(index.sourceIdentityHashes),
+    semanticTransformContentHashes:uniqueStrings(index.semanticTransformContentHashes),
+    semanticTransformIdentityHashes:uniqueStrings(index.semanticTransformIdentityHashes),
+    projectionIdentityHashes:uniqueStrings(index.projectionIdentityHashes),
     operationContentHashes:uniqueStrings(index.operationContentHashes),
     editContentHashes:uniqueStrings(index.editContentHashes)
   };
@@ -146,6 +161,9 @@ function matchesOverlap(overlap,query){
     &&matchAny(queryValues(query.sourcePath,query.sourcePaths),overlap.shared.sourcePaths)
     &&matchAny(queryValues(query.conflictKey,query.conflictKeys),overlap.shared.conflictKeys)
     &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),overlap.shared.semanticEditKeys)
+    &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),overlap.shared.semanticTransformIdentityHashes)
+    &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),overlap.shared.semanticTransformContentHashes)
+    &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),overlap.shared.projectionIdentityHashes)
     &&matchAny(queryValues(query.operationContentHash,query.operationContentHashes),overlap.shared.operationContentHashes)
     &&matchAny(queryValues(query.editContentHash,query.editContentHashes),overlap.shared.editContentHashes)
     &&(query.reviewRequired===undefined||overlap.admission.reviewRequired===query.reviewRequired)

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

@@ -1,4 +1,5 @@
 import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{normalizeSemanticTransformIdentityRecords,semanticTransformInputs,semanticTransformRecordIndex,semanticTransformSummary}from'./semanticTransformIdentityRecords.js';
 
 export const SemanticPatchBundleAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
 
@@ -9,6 +10,9 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const semanticEditScripts=array(options.semanticEditScripts??source.semanticEditScripts??source.semanticEditScript);
   const semanticEditProjections=array(options.semanticEditProjections??source.semanticEditProjections??source.semanticEditProjection);
   const semanticEditIndex=semanticEditRecordIndex(semanticEditScripts,semanticEditProjections,source);
+  const transformContext={sourceLanguage:options.sourceLanguage??source.sourceLanguage??source.language,targetLanguage:options.targetLanguage??source.targetLanguage};
+  const semanticTransformIdentities=normalizeSemanticTransformIdentityRecords(semanticTransformInputs(source,options),transformContext);
+  const semanticTransformIndex=semanticTransformRecordIndex(semanticTransformIdentities,source);
   const regionInputs=array(options.changedRegions??source.changedRegions??source.regions);
   const sourceMapLinks=normalizeSourceMapLinks([
     ...array(options.sourceMapLinks??source.sourceMapLinks),
@@ -43,7 +47,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     ??`semantic_patch_bundle_${idFragment(firstString(source.id,patchId,mergeCandidateId,source.sourcePath,source.language,'record'))}`;
   const language=options.language??source.language??mergeCandidate?.language??sources.find((item)=>item.language)?.language;
   const sourcePath=options.sourcePath??source.sourcePath??mergeCandidate?.sourcePath??sources.find((item)=>item.sourcePath)?.sourcePath;
-  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex,semanticTransformIndex});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -65,9 +69,10 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     semanticOperationIds,
     semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
     semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
+    semanticTransformIdentityIds:semanticTransformIndex.semanticTransformIds,
     admission,
     index,
-    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,semanticOperations:semanticOperationIds.length,semanticEditScripts:semanticEditScripts.length,semanticEditProjections:semanticEditProjections.length,semanticEditProjectionEdits:semanticEditIndex.semanticEditProjectionEditCount,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
+    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,semanticOperations:semanticOperationIds.length,semanticEditScripts:semanticEditScripts.length,semanticEditProjections:semanticEditProjections.length,semanticEditProjectionEdits:semanticEditIndex.semanticEditProjectionEditCount,semanticTransformIdentities:semanticTransformIdentities.length,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
       patchRisk:patch?.risk,
@@ -75,6 +80,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary,
       semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
       semanticEditSummary:semanticEditSummary(semanticEditIndex),
+      semanticTransformSummary:semanticTransformSummary(semanticTransformIndex),
       ...options.metadata
     })
   };
@@ -197,11 +203,12 @@ function normalizeAdmission(input={},context){
 
 function recordIndex(parts){
   const semanticEditIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[]);
+  const semanticTransformIndex=parts.semanticTransformIndex??semanticTransformRecordIndex([],parts);
   return{
     baseHashes:uniqueStrings([parts.baseHash,...parts.sources.map((item)=>item.baseHash)]),
     targetHashes:uniqueStrings([parts.targetHash,...parts.sources.map((item)=>item.targetHash)]),
     sourceHashes:uniqueStrings(parts.sources.map((item)=>item.sourceHash)),
-    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...semanticEditIndex.projectedSourcePaths]),
+    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...semanticEditIndex.projectedSourcePaths,...semanticTransformIndex.transformSourcePaths,...semanticTransformIndex.transformTargetPaths]),
     regionKeys:uniqueStrings([...parts.changedRegions.map((region)=>region.key),...semanticEditIndex.anchorKeys]),
     regionKinds:uniqueStrings(parts.changedRegions.map((region)=>region.regionKind)),
     conflictKeys:uniqueStrings([...parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),...semanticEditIndex.conflictKeys]),
@@ -219,6 +226,15 @@ function recordIndex(parts){
     sourceIdentityHashes:semanticEditIndex.sourceIdentityHashes,
     operationContentHashes:semanticEditIndex.operationContentHashes,
     editContentHashes:semanticEditIndex.editContentHashes,
+    semanticTransformIds:semanticTransformIndex.semanticTransformIds,
+    semanticTransformKeys:semanticTransformIndex.semanticTransformKeys,
+    semanticTransformIdentityHashes:semanticTransformIndex.semanticTransformIdentityHashes,
+    semanticTransformContentHashes:semanticTransformIndex.semanticTransformContentHashes,
+    projectionIdentityHashes:semanticTransformIndex.projectionIdentityHashes,
+    transformSourceLanguages:semanticTransformIndex.transformSourceLanguages,
+    transformTargetLanguages:semanticTransformIndex.transformTargetLanguages,
+    transformSourcePaths:semanticTransformIndex.transformSourcePaths,
+    transformTargetPaths:semanticTransformIndex.transformTargetPaths,
     patchIds:uniqueStrings([parts.patchId]),
     mergeCandidateIds:uniqueStrings([parts.mergeCandidateId]),
     readinesses:uniqueStrings([parts.admission.readiness,...parts.changedRegions.map((region)=>region.admission?.readiness)]),
@@ -252,6 +268,15 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.sourceIdentityHash,query.sourceIdentityHashes),index.sourceIdentityHashes)
     &&matchAny(queryValues(query.operationContentHash,query.operationContentHashes),index.operationContentHashes)
     &&matchAny(queryValues(query.editContentHash,query.editContentHashes),index.editContentHashes)
+    &&matchAny(queryValues(query.semanticTransformId,query.semanticTransformIds),index.semanticTransformIds)
+    &&matchAny(queryValues(query.semanticTransformKey,query.semanticTransformKeys),index.semanticTransformKeys)
+    &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),index.semanticTransformIdentityHashes)
+    &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),index.semanticTransformContentHashes)
+    &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),index.projectionIdentityHashes)
+    &&matchAny(queryValues(query.transformSourceLanguage,query.transformSourceLanguages),index.transformSourceLanguages)
+    &&matchAny(queryValues(query.transformTargetLanguage,query.transformTargetLanguages),index.transformTargetLanguages)
+    &&matchAny(queryValues(query.transformSourcePath,query.transformSourcePaths),index.transformSourcePaths)
+    &&matchAny(queryValues(query.transformTargetPath,query.transformTargetPaths),index.transformTargetPaths)
     &&matchAny(queryValues(query.readiness,query.readinesses),index.readinesses)
     &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
 }

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

@@ -0,0 +1,183 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings as uniqueRawStrings } from '../../native-import-utils.js';
+import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+
+export function createSemanticTransformIdentityRecord(input = {}, options = {}) {
+  const source = input?.transform ?? input;
+  const merged = { ...source, ...options };
+  const editIdentity = semanticEditIdentityFields(merged);
+  const semanticKey = firstString(merged.semanticKey, editIdentity.semanticKey);
+  const transformKey = firstString(merged.transformKey, semanticTransformKey({ ...merged, semanticKey }));
+  const sourceLanguage = firstString(merged.sourceLanguage, merged.language);
+  const targetLanguage = firstString(merged.targetLanguage, merged.projectedLanguage);
+  const sourcePath = firstString(merged.sourcePath, merged.originalSourcePath);
+  const targetPath = firstString(merged.targetPath, merged.targetSourcePath, merged.projectedSourcePath);
+  const semanticIdentityHash = firstString(merged.semanticIdentityHash, editIdentity.semanticIdentityHash);
+  const sourceIdentityHash = firstString(merged.sourceIdentityHash, editIdentity.sourceIdentityHash);
+  const transformIdentityHash = firstString(merged.transformIdentityHash, hashSemanticValue(compactRecord({
+    transformKey,
+    semanticIdentityHash,
+    sourceLanguage,
+    targetLanguage
+  })));
+  const projectionIdentityHash = firstString(merged.projectionIdentityHash, hashSemanticValue(compactRecord({
+    transformIdentityHash,
+    sourceIdentityHash,
+    sourcePath,
+    targetPath
+  })));
+  const operationContentHash = firstString(merged.operationContentHash);
+  const editContentHash = firstString(merged.editContentHash);
+  const transformContentHash = firstString(
+    merged.transformContentHash,
+    operationContentHash || editContentHash ? hashSemanticValue(compactRecord({ transformIdentityHash, operationContentHash, editContentHash })) : undefined
+  );
+  const id = merged.id && source.kind === 'frontier.lang.semanticTransformIdentityRecord'
+    ? merged.id
+    : firstString(merged.id, `semantic_transform_${idFragment(firstString(transformKey, semanticKey, sourcePath, targetPath, 'record'))}`);
+  return compactRecord({
+    kind: 'frontier.lang.semanticTransformIdentityRecord',
+    version: 1,
+    schema: 'frontier.lang.semanticTransformIdentityRecord.v1',
+    id,
+    sourceLanguage,
+    targetLanguage,
+    sourcePath,
+    targetPath,
+    baseHash: firstString(merged.baseHash),
+    targetHash: firstString(merged.targetHash, merged.projectedHash),
+    semanticKey,
+    transformKey,
+    semanticIdentityHash,
+    sourceIdentityHash,
+    operationContentHash,
+    editContentHash,
+    transformIdentityHash,
+    projectionIdentityHash,
+    transformContentHash,
+    readiness: firstString(merged.readiness),
+    confidence: typeof merged.confidence === 'number' ? merged.confidence : undefined,
+    evidenceIds: uniqueStrings(merged.evidenceIds),
+    metadata: compactRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceTransformId: source.kind === 'frontier.lang.semanticTransformIdentityRecord' ? source.id : undefined,
+      ...merged.metadata
+    })
+  });
+}
+
+export function semanticTransformIdentityFields(record = {}) {
+  return createSemanticTransformIdentityRecord(record);
+}
+
+export function normalizeSemanticTransformIdentityRecords(records, context = {}) {
+  return uniqueRecords(array(records).filter(Boolean).map((record) => createSemanticTransformIdentityRecord(record, context)));
+}
+
+export function semanticTransformInputs(source = {}, options = {}) {
+  const projections = [
+    ...array(options.semanticEditProjections ?? options.semanticEditProjection),
+    ...array(source.semanticEditProjections ?? source.semanticEditProjection)
+  ];
+  return [
+    ...array(options.semanticTransformIdentities ?? options.semanticTransformIdentity),
+    ...array(source.semanticTransformIdentities ?? source.semanticTransformIdentity ?? source.semanticTransforms),
+    ...array(source.index?.semanticTransformIdentities),
+    ...deriveSemanticTransformIdentityRecords({ semanticEditProjections: projections }, { ...source, ...options })
+  ];
+}
+
+export function deriveSemanticTransformIdentityRecords(input = {}, options = {}) {
+  const projections = semanticEditProjectionInputs(input);
+  return uniqueRecords(projections.flatMap((projection, projectionIndex) => {
+    const edits = array(projection.edits).filter((edit) => edit && typeof edit === 'object');
+    return edits.map((edit, editIndex) => transformRecordForProjectionEdit(edit, projection, input, options, projectionIndex, editIndex));
+  }));
+}
+
+export function semanticTransformRecordIndex(records, source = {}) {
+  const index = source.index ?? {};
+  return {
+    semanticTransformIds: uniqueStrings([...strings(source.semanticTransformIds), ...strings(index.semanticTransformIds), ...records.map((record) => record.id)]),
+    semanticTransformKeys: uniqueStrings([...strings(source.semanticTransformKeys), ...strings(index.semanticTransformKeys), ...records.map((record) => record.transformKey)]),
+    semanticTransformIdentityHashes: uniqueStrings([...strings(source.semanticTransformIdentityHashes), ...strings(index.semanticTransformIdentityHashes), ...records.map((record) => record.transformIdentityHash)]),
+    semanticTransformContentHashes: uniqueStrings([...strings(source.semanticTransformContentHashes), ...strings(index.semanticTransformContentHashes), ...records.map((record) => record.transformContentHash)]),
+    projectionIdentityHashes: uniqueStrings([...strings(source.projectionIdentityHashes), ...strings(index.projectionIdentityHashes), ...records.map((record) => record.projectionIdentityHash)]),
+    transformSourceLanguages: uniqueStrings([...strings(source.transformSourceLanguages), ...strings(index.transformSourceLanguages), ...records.map((record) => record.sourceLanguage)]),
+    transformTargetLanguages: uniqueStrings([...strings(source.transformTargetLanguages), ...strings(index.transformTargetLanguages), ...records.map((record) => record.targetLanguage)]),
+    transformSourcePaths: uniqueStrings([...strings(source.transformSourcePaths), ...strings(index.transformSourcePaths), ...records.map((record) => record.sourcePath)]),
+    transformTargetPaths: uniqueStrings([...strings(source.transformTargetPaths), ...strings(index.transformTargetPaths), ...records.map((record) => record.targetPath)])
+  };
+}
+
+export function semanticTransformSummary(index) {
+  if (!index.semanticTransformIds.length && !index.semanticTransformKeys.length) return undefined;
+  return compactRecord({
+    ids: index.semanticTransformIds,
+    keys: index.semanticTransformKeys,
+    identityHashes: index.semanticTransformIdentityHashes,
+    contentHashes: index.semanticTransformContentHashes,
+    projectionIdentityHashes: index.projectionIdentityHashes,
+    sourceLanguages: index.transformSourceLanguages,
+    targetLanguages: index.transformTargetLanguages,
+    targetPaths: index.transformTargetPaths
+  });
+}
+
+function semanticTransformKey(record) {
+  const scope = record.semanticKey ?? (record.symbolName
+    ? `${record.symbolKind ?? 'symbol'}:${record.symbolName}`
+    : record.anchorKey ?? record.regionId ?? record.operationId ?? record.id);
+  const route = [record.sourceLanguage ?? record.language, record.targetLanguage ?? record.projectedLanguage].filter(Boolean).join('->');
+  return ['semantic-transform', route, scope].filter(Boolean).join(':');
+}
+
+function semanticEditProjectionInputs(input) {
+  if (input.kind === 'frontier.lang.semanticEditProjection') return [input];
+  return [
+    ...array(input.semanticEditProjections ?? input.semanticEditProjection),
+    ...array(input.projections ?? input.projection)
+  ].filter((entry) => entry && typeof entry === 'object');
+}
+
+function transformRecordForProjectionEdit(edit, projection, input, options, projectionIndex, editIndex) {
+  const sourceLanguage = firstString(edit.sourceLanguage, edit.language, input.sourceLanguage, options.sourceLanguage, projection.sourceLanguage, projection.language);
+  const targetLanguage = firstString(edit.targetLanguage, edit.projectedLanguage, input.targetLanguage, options.targetLanguage, projection.targetLanguage, projection.projectedLanguage, projection.language);
+  const sourcePath = firstString(edit.originalSourcePath, edit.sourcePath, input.sourcePath, options.sourcePath, projection.sourcePath);
+  const targetPath = firstString(edit.targetPath, edit.targetSourcePath, input.targetPath, options.targetPath, projection.targetPath, projection.projectedSourcePath, projection.sourcePath);
+  const transformId = [projection.id, edit.operationId, projectionIndex, editIndex].filter((entry) => entry !== undefined && entry !== null).join(':');
+  return createSemanticTransformIdentityRecord(edit, {
+    id: `semantic_transform_${idFragment(transformId)}`,
+    sourceLanguage,
+    targetLanguage,
+    sourcePath,
+    targetPath,
+    baseHash: firstString(edit.baseHash, projection.baseHash, input.baseHash, options.baseHash),
+    targetHash: firstString(edit.targetHash, projection.projectedHash, projection.targetHash, input.targetHash, options.targetHash),
+    readiness: firstString(edit.readiness, projection.admission?.status, projection.status),
+    evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(options.evidenceIds), ...strings(projection.evidenceIds), ...strings(edit.evidenceIds)]),
+    metadata: compactRecord({
+      sourceProjectionId: projection.id,
+      sourceProjectionEditOperationId: edit.operationId
+    })
+  });
+}
+
+function uniqueRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = firstString(record.id, record.transformContentHash, record.projectionIdentityHash, record.transformIdentityHash);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+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 firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }
+function uniqueStrings(values) { return uniqueRawStrings((values ?? []).filter((entry) => entry !== undefined && entry !== null && String(entry) !== '')); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.88",
+  "version": "0.2.90",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",