@shapeshift-labs/frontier-lang-compiler 0.2.78 → 0.2.80

package/README.md

@@ -353,6 +353,27 @@ console.log(changeSet.mergeCandidate.readiness); // merge-admission classificati
 
 Use `diffNativeSourceImports` when the worker or runner already produced `importNativeSource` results. Changed regions include a `metadata.changedRegionProjection` envelope with before/after source hashes, source-map links, ownership keys, readiness, and `autoMergeClaim: false` so swarm admission tools can score or port patches without treating semantic metadata as proof. Body-only edits that the lightweight scanner cannot anchor to a symbol are still reported as file-level changed regions instead of being silently treated as safe.
 
+Build a three-way semantic edit script when a coordinator has base, worker, and current-head source text. This is the first deterministic bridge from semantic sidecars to automatic merge admission:
+
+```js
+import { createSemanticEditScript } from '@shapeshift-labs/frontier-lang-compiler';
+
+const script = createSemanticEditScript({
+  language: 'typescript',
+  sourcePath: 'src/runtime.ts',
+  baseSourceText: 'export function step(v) { return v + 1; }\n',
+  workerSourceText: 'export function step(v) { return v + 2; }\n',
+  headSourceText: 'export function step(v) { return v + 1; }\n'
+});
+
+console.log(script.operations[0].kind); // "replaceBody"
+console.log(script.operations[0].status); // "portable"
+console.log(script.admission.status); // "auto-merge-candidate"
+console.log(script.admission.autoMergeClaim); // false
+```
+
+If the current head already changed the same semantic anchor, the script reports `conflict`; if the anchor moved or was renamed, it reports `needs-port` with a `reanchor` target; if no current head is supplied, it reports a review-only candidate. The script is intentionally an edit/admission record, not a proof of semantic equivalence.
+
 Bundle a native diff into a compact semantic patch record when a coordinator needs hashes, changed semantic regions, source-map links, proof/history/evidence IDs, and merge-admission status without loading whole source files:
 
 ```js

package/dist/declarations/semantic-edit-script.d.ts

@@ -0,0 +1,143 @@
+import type {
+  EvidenceRecord,
+  FrontierSourceLanguage,
+  SemanticMergeReadiness,
+  SourceSpan
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { ImportNativeSourceOptions, NativeSourceImportResult } from './import-adapter-core.js';
+
+export type SemanticEditScriptOperationStatus =
+  | 'candidate'
+  | 'portable'
+  | 'already-applied'
+  | 'needs-port'
+  | 'conflict'
+  | 'stale'
+  | 'blocked';
+
+export type SemanticEditScriptAdmissionStatus =
+  | 'auto-merge-candidate'
+  | 'needs-port'
+  | 'conflict'
+  | 'stale'
+  | 'blocked'
+  | 'evidence-only';
+
+export interface SemanticEditScriptOperation {
+  readonly id: string;
+  readonly kind: string;
+  readonly changeKind?: string;
+  readonly anchor: {
+    readonly key?: string;
+    readonly conflictKey?: string;
+    readonly regionId?: string;
+    readonly regionKind?: string;
+    readonly granularity?: string;
+    readonly language?: FrontierSourceLanguage | string;
+    readonly sourcePath?: string;
+    readonly symbolId?: string;
+    readonly symbolName?: string;
+    readonly symbolKind?: string;
+    readonly sourceSpan?: SourceSpan;
+  };
+  readonly hashes?: {
+    readonly baseSourceHash?: string;
+    readonly workerSourceHash?: string;
+    readonly headSourceHash?: string;
+    readonly baseSpanHash?: string;
+    readonly workerSpanHash?: string;
+    readonly headSpanHash?: string;
+    readonly baseTextHash?: string;
+    readonly workerTextHash?: string;
+    readonly beforeSignatureHash?: string;
+    readonly afterSignatureHash?: string;
+  };
+  readonly status: SemanticEditScriptOperationStatus;
+  readonly reanchor?: {
+    readonly fromAnchorKey?: string;
+    readonly toAnchorKey?: string;
+    readonly lineageStatus?: string;
+    readonly traversedEventIds?: readonly string[];
+  };
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly confidence: number;
+  readonly reasonCodes: readonly string[];
+  readonly evidenceIds?: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticEditScriptSummary {
+  readonly operations: number;
+  readonly byStatus: Readonly<Record<string, number>>;
+  readonly byKind: Readonly<Record<string, number>>;
+  readonly portable: number;
+  readonly alreadyApplied: number;
+  readonly needsPort: number;
+  readonly conflicts: number;
+  readonly stale: number;
+  readonly blocked: number;
+  readonly candidates: number;
+  readonly autoMergeCandidates: number;
+}
+
+export interface SemanticEditScriptAdmission {
+  readonly status: SemanticEditScriptAdmissionStatus;
+  readonly action: 'run-gates-and-apply' | 'reanchor-or-human-port' | 'record-evidence' | 'block' | string;
+  readonly reviewRequired: boolean;
+  readonly autoApplyCandidate: boolean;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly reasonCodes: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+}
+
+export interface SemanticEditScript {
+  readonly kind: 'frontier.lang.semanticEditScript';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.semanticEditScript.v1';
+  readonly id: string;
+  readonly stableId: string;
+  readonly hash: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly baseHash?: string;
+  readonly workerHash?: string;
+  readonly headHash?: string;
+  readonly workerChangeSetId: string;
+  readonly headChangeSetId?: string;
+  readonly lineageInferenceId?: string;
+  readonly operations: readonly SemanticEditScriptOperation[];
+  readonly summary: SemanticEditScriptSummary;
+  readonly admission: SemanticEditScriptAdmission;
+  readonly evidence: readonly EvidenceRecord[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CreateSemanticEditScriptOptions {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly parser?: string;
+  readonly base?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly before?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly worker?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly after?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly head?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly current?: NativeSourceImportResult | ImportNativeSourceOptions;
+  readonly baseSourceText?: string;
+  readonly beforeSourceText?: string;
+  readonly workerSourceText?: string;
+  readonly afterSourceText?: string;
+  readonly headSourceText?: string;
+  readonly currentSourceText?: string;
+  readonly baseSourceHash?: string;
+  readonly workerSourceHash?: string;
+  readonly headSourceHash?: string;
+  readonly generatedAt?: number;
+  readonly evidenceId?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export declare const SemanticEditScriptAdmissionStatuses: readonly SemanticEditScriptAdmissionStatus[];
+export declare function createSemanticEditScript(input?: CreateSemanticEditScriptOptions): SemanticEditScript;

package/dist/declarations/semantic-history.d.ts

@@ -6,7 +6,7 @@ import type {
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { SemanticImportOwnershipRegion } from './semantic-sidecar.js';
-import type { CreateSemanticLineageEventInput, SemanticLineageEvent } from './semantic-lineage.js';
+import type { CreateSemanticLineageEventInput, SemanticAnchor, SemanticLineageEvent, SemanticLineageMap, SemanticLineageResolution } from './semantic-lineage.js';
 
 import type { SemanticHistoryAdmissionStatus, SemanticHistoryReviewerStatus, SemanticHistoryReplayLinkKind, SemanticHistoryOverlapKind, SemanticHistoryConflictReason, SemanticHistoryClaimKind, SemanticHistoryClaimStatus, SemanticHistoryProofAttemptStatus, SemanticHistoryMergeDecisionStatus, SemanticHistoryActorRef, SemanticHistoryRecordSourceRef, SemanticHistorySourceRef, SemanticHistoryOwnershipRegionRef, SemanticHistoryCandidateRef, SemanticHistoryClaimRecord, SemanticHistoryImportedParserEvidenceRecord, SemanticHistoryProofAttemptRecord, SemanticHistoryPatchAncestryRecord, SemanticHistoryMergeDecisionRecord, SemanticHistoryClaimInput, SemanticHistoryImportedParserEvidenceInput, SemanticHistoryProofAttemptInput, SemanticHistoryPatchAncestryInput, SemanticHistoryMergeDecisionInput, SemanticHistoryReviewerState, SemanticHistoryAdmissionState, SemanticHistoryReplayLink, SemanticHistoryRecordIndex } from './semantic-history-records.js';
 export type { SemanticHistoryAdmissionStatus, SemanticHistoryReviewerStatus, SemanticHistoryReplayLinkKind, SemanticHistoryOverlapKind, SemanticHistoryConflictReason, SemanticHistoryClaimKind, SemanticHistoryClaimStatus, SemanticHistoryProofAttemptStatus, SemanticHistoryMergeDecisionStatus, SemanticHistoryActorRef, SemanticHistoryRecordSourceRef, SemanticHistorySourceRef, SemanticHistoryOwnershipRegionRef, SemanticHistoryCandidateRef, SemanticHistoryClaimRecord, SemanticHistoryImportedParserEvidenceRecord, SemanticHistoryProofAttemptRecord, SemanticHistoryPatchAncestryRecord, SemanticHistoryMergeDecisionRecord, SemanticHistoryClaimInput, SemanticHistoryImportedParserEvidenceInput, SemanticHistoryProofAttemptInput, SemanticHistoryPatchAncestryInput, SemanticHistoryMergeDecisionInput, SemanticHistoryReviewerState, SemanticHistoryAdmissionState, SemanticHistoryReplayLink, SemanticHistoryRecordIndex } from './semantic-history-records.js';
@@ -138,6 +138,51 @@ export interface SemanticHistoryOverlapRecord {
   readonly reviewer: { readonly left?: SemanticHistoryReviewerStatus; readonly right?: SemanticHistoryReviewerStatus };
 }
 
+export type SemanticHistoryLineageAnchorSetKind = 'active' | 'candidate' | 'inactive' | 'deleted' | 'unresolved' | 'blocked';
+
+export interface SemanticHistoryLineageAnchorRecord extends Pick<SemanticAnchor, 'key' | 'id' | 'kind' | 'language' | 'sourcePath' | 'symbolId' | 'symbolName'> {
+  readonly status: string;
+  readonly resolutionId: string;
+  readonly reasonCodes: readonly string[];
+}
+
+export type SemanticHistoryLineageAnchorInventory = Readonly<Record<SemanticHistoryLineageAnchorSetKind, readonly SemanticHistoryLineageAnchorRecord[]>>;
+
+export interface SemanticHistoryRecordLineageResolution {
+  readonly kind: 'frontier.lang.semanticHistoryRecordLineageResolution';
+  readonly version: 1;
+  readonly id: string;
+  readonly stableId: string;
+  readonly hash: string;
+  readonly sourceRecordId?: string;
+  readonly sourceRecordStableId?: string;
+  readonly sourceRecordHash?: string;
+  readonly generatedAt: number | string;
+  readonly resolutions: readonly SemanticLineageResolution[];
+  readonly anchorInventory: SemanticHistoryLineageAnchorInventory;
+  readonly resolvedRecord: SemanticHistoryRecord;
+  readonly summary: Record<string, unknown> & {
+    readonly anchorCount: number;
+    readonly currentAnchorKeys: readonly string[];
+    readonly ownershipKeys: readonly string[];
+    readonly conflictKeys: readonly string[];
+    readonly activeAnchorKeys: readonly string[];
+    readonly candidateAnchorKeys: readonly string[];
+    readonly inactiveAnchorKeys: readonly string[];
+    readonly deletedAnchorKeys: readonly string[];
+    readonly unresolvedAnchorKeys: readonly string[];
+    readonly blockedAnchorKeys: readonly string[];
+    readonly reasonCodes: readonly string[];
+  };
+  readonly admission: {
+    readonly readiness: SemanticMergeReadiness | string;
+    readonly reviewRequired: boolean;
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+  };
+  readonly metadata?: Record<string, unknown>;
+}
+
 export declare const SemanticHistoryAdmissionStatuses: readonly SemanticHistoryAdmissionStatus[];
 export declare const SemanticHistoryReviewerStatuses: readonly SemanticHistoryReviewerStatus[];
 export declare const SemanticHistoryOverlapKinds: readonly SemanticHistoryOverlapKind[];
@@ -146,3 +191,5 @@ export declare function createSemanticHistoryRecord(input?: CreateSemanticHistor
 export declare function querySemanticHistoryRecordOverlaps(records: SemanticHistoryRecord | readonly SemanticHistoryRecord[], options?: SemanticHistoryOverlapQueryOptions): readonly SemanticHistoryOverlapRecord[];
 export declare function semanticHistoryRecordsOverlap(left: SemanticHistoryRecord, right: SemanticHistoryRecord, options?: SemanticHistoryOverlapQueryOptions): boolean;
 export declare function semanticHistoryRecordsConflict(left: SemanticHistoryRecord, right: SemanticHistoryRecord, options?: SemanticHistoryOverlapQueryOptions): boolean;
+export declare function resolveSemanticHistoryRecordLineage(record: SemanticHistoryRecord, eventsOrMap?: SemanticLineageMap | readonly CreateSemanticLineageEventInput[], options?: { readonly id?: string; readonly generatedAt?: number | string; readonly maxDepth?: number; readonly keepDeletedAnchors?: boolean; readonly keepCandidateAnchors?: boolean; readonly keepBlockedAnchors?: boolean; readonly keepUnresolvedAnchors?: boolean; readonly metadata?: Record<string, unknown> }): SemanticHistoryRecordLineageResolution;
+export declare function resolveSemanticHistoryRecordsLineage(records: readonly SemanticHistoryRecord[] | SemanticHistoryRecord, eventsOrMap?: SemanticLineageMap | readonly CreateSemanticLineageEventInput[], options?: { readonly generatedAt?: number | string; readonly maxDepth?: number; readonly keepDeletedAnchors?: boolean; readonly keepCandidateAnchors?: boolean; readonly keepBlockedAnchors?: boolean; readonly keepUnresolvedAnchors?: boolean; readonly metadata?: Record<string, unknown> }): readonly SemanticHistoryRecordLineageResolution[];

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from './declarations/source-preservation.js';
 export * from './declarations/semantic-sidecar-admission.js';
 export * from './declarations/semantic-merge-candidates.js';
 export * from './declarations/semantic-merge-conflicts.js';
+export * from './declarations/semantic-edit-script.js';
 export * from './declarations/semantic-lineage.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';

package/dist/index.js

@@ -69,10 +69,12 @@ export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProje
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.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';
 export { queryUniversalConversionPlan } from './internal/index-impl/queryUniversalConversionPlan.js';
 export { createSemanticAnchor, createSemanticLineageEvent, createSemanticLineageMap, querySemanticLineageEvents, SemanticLineageEventKinds } from './internal/index-impl/semanticLineageRecords.js';
 export { resolveSemanticLineage, resolveSemanticLineageBatch, SemanticLineageResolutionStatuses } from './internal/index-impl/semanticLineageResolutionRecords.js';
 export { createSemanticHistoryRecord, querySemanticHistoryRecordOverlaps, SemanticHistoryAdmissionStatuses, SemanticHistoryConflictReasons, SemanticHistoryOverlapKinds, SemanticHistoryReviewerStatuses, semanticHistoryRecordsConflict, semanticHistoryRecordsOverlap } from './internal/index-impl/semanticHistoryRecords.js';
+export { resolveSemanticHistoryRecordLineage, resolveSemanticHistoryRecordsLineage } from './internal/index-impl/semanticHistoryLineageResolution.js';
 export { readSemanticSliceJson } from './internal/index-impl/readSemanticSliceJson.js';
 export { readUniversalAstJson } from './internal/index-impl/readUniversalAstJson.js';
 export { renderTargetAst } from './internal/index-impl/renderTargetAst.js';

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

@@ -0,0 +1,135 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+import { resolveSemanticLineage } from './semanticLineageResolutionRecords.js';
+
+export const SemanticEditScriptAdmissionStatuses = Object.freeze([
+  'auto-merge-candidate',
+  'needs-port',
+  'conflict',
+  'stale',
+  'blocked',
+  'evidence-only'
+]);
+
+export function classifySemanticEdit(input) {
+  if (!input.context.head) return editStatus('candidate', 'needs-review', 0.66, ['head-source-not-provided']);
+  if (!input.anchorKey) return editStatus('blocked', 'blocked', 0, ['missing-semantic-anchor']);
+  if (input.context.workerChangeSet.beforeHash &&
+    input.context.headChangeSet?.afterHash === input.context.workerChangeSet.beforeHash &&
+    sameSourcePath(input.context.base, input.context.head)) {
+    return editStatus('portable', 'ready', 0.95, ['head-source-matches-base']);
+  }
+  if (input.region.changeKind === 'added') return classifyAddedRegion(input);
+  if (!input.baseSymbol) return classifyMissingBaseAnchor(input);
+  if (!input.headSymbol) return classifyMissingHeadAnchor(input);
+  if (input.headSymbol.spanHash && input.baseSymbol.spanHash && input.headSymbol.spanHash === input.baseSymbol.spanHash) {
+    return editStatus('portable', 'ready', 0.9, ['head-anchor-matches-base']);
+  }
+  if (input.headSymbol.spanHash && input.workerSymbol?.spanHash && input.headSymbol.spanHash === input.workerSymbol.spanHash) {
+    return editStatus('already-applied', 'ready', 0.92, ['head-anchor-matches-worker']);
+  }
+  return editStatus('conflict', 'blocked', 0.2, ['head-anchor-changed-since-base']);
+}
+
+export function summarizeSemanticEditOperations(operations) {
+  const byStatus = countBy(operations.map((operation) => operation.status));
+  const byKind = countBy(operations.map((operation) => operation.kind));
+  return {
+    operations: operations.length,
+    byStatus,
+    byKind,
+    portable: byStatus.portable ?? 0,
+    alreadyApplied: byStatus['already-applied'] ?? 0,
+    needsPort: byStatus['needs-port'] ?? 0,
+    conflicts: byStatus.conflict ?? 0,
+    stale: byStatus.stale ?? 0,
+    blocked: byStatus.blocked ?? 0,
+    candidates: byStatus.candidate ?? 0,
+    autoMergeCandidates: (byStatus.portable ?? 0) + (byStatus['already-applied'] ?? 0)
+  };
+}
+
+export function semanticEditAdmission(input) {
+  const status = admissionStatus(input.summary);
+  return {
+    status,
+    action: admissionAction(status),
+    reviewRequired: status !== 'auto-merge-candidate',
+    autoApplyCandidate: status === 'auto-merge-candidate',
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: uniqueStrings([
+      ...input.workerChangeSet.reasons,
+      ...(input.headChangeSet?.reasons ?? []),
+      ...input.operations.flatMap((operation) => operation.reasonCodes ?? [])
+    ]),
+    conflictKeys: uniqueStrings(input.operations.map((operation) => operation.anchor?.conflictKey).filter(Boolean)),
+    evidenceIds: uniqueStrings(input.operations.flatMap((operation) => operation.evidenceIds ?? []))
+  };
+}
+
+function classifyAddedRegion(input) {
+  if (!input.headSymbol) return editStatus('portable', 'ready', 0.86, ['added-anchor-absent-from-head']);
+  if (input.headSymbol.spanHash && input.workerSymbol?.spanHash && input.headSymbol.spanHash === input.workerSymbol.spanHash) {
+    return editStatus('already-applied', 'ready', 0.88, ['added-anchor-already-present-in-head']);
+  }
+  return editStatus('conflict', 'blocked', 0.25, ['added-anchor-already-exists-in-head']);
+}
+
+function classifyMissingBaseAnchor(input) {
+  const conflictKey = input.region.conflictKey ?? `region:${input.anchorKey}`;
+  if (input.context.headChangedConflictKeys.has(conflictKey)) {
+    return editStatus('conflict', 'blocked', 0.18, ['base-anchor-missing-and-head-changed-same-region']);
+  }
+  return editStatus('stale', 'needs-review', 0.25, ['base-anchor-missing']);
+}
+
+function classifyMissingHeadAnchor(input) {
+  const resolved = input.context.headLineage
+    ? resolveSemanticLineage(input.context.headLineage.lineageMap, { anchorKey: input.anchorKey })
+    : undefined;
+  if (resolved?.status === 'resolved' && resolved.currentAnchors.length === 1) {
+    return editStatus('needs-port', 'needs-review', 0.72, ['anchor-moved-or-renamed'], {
+      fromAnchorKey: input.anchorKey,
+      toAnchorKey: resolved.currentAnchors[0].key,
+      lineageStatus: resolved.status,
+      traversedEventIds: resolved.traversedEventIds
+    }, resolved.evidenceIds);
+  }
+  if (resolved?.status === 'ambiguous') {
+    return editStatus('blocked', 'blocked', 0.1, ['anchor-lineage-ambiguous'], { fromAnchorKey: input.anchorKey, lineageStatus: resolved.status }, resolved.evidenceIds);
+  }
+  if (resolved?.status === 'deleted') {
+    return editStatus('blocked', 'blocked', 0.1, ['anchor-deleted-in-head'], { fromAnchorKey: input.anchorKey, lineageStatus: resolved.status }, resolved.evidenceIds);
+  }
+  return editStatus('stale', 'needs-review', 0.25, ['head-anchor-missing']);
+}
+
+function editStatus(status, readiness, confidence, reasonCodes, reanchor, evidenceIds = []) {
+  return { status, readiness, confidence, reasonCodes, reanchor, evidenceIds };
+}
+
+function admissionStatus(summary) {
+  if (summary.operations === 0) return 'evidence-only';
+  if (summary.blocked > 0) return 'blocked';
+  if (summary.conflicts > 0) return 'conflict';
+  if (summary.stale > 0) return 'stale';
+  if (summary.needsPort > 0 || summary.candidates > 0) return 'needs-port';
+  return 'auto-merge-candidate';
+}
+
+function admissionAction(status) {
+  if (status === 'auto-merge-candidate') return 'run-gates-and-apply';
+  if (status === 'needs-port') return 'reanchor-or-human-port';
+  if (status === 'evidence-only') return 'record-evidence';
+  return 'block';
+}
+
+function countBy(values) {
+  const result = {};
+  for (const value of values.filter(Boolean)) result[value] = (result[value] ?? 0) + 1;
+  return result;
+}
+
+function sameSourcePath(left, right) {
+  return (left?.sourcePath ?? left?.nativeSource?.sourcePath) === (right?.sourcePath ?? right?.nativeSource?.sourcePath);
+}

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

@@ -0,0 +1,220 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
+import { diffNativeSourceImports } from './diffNativeSourceImports.js';
+import { inferSemanticLineageEvents } from './inferSemanticLineageEvents.js';
+import { mapDiffSymbols } from './mapDiffSymbols.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import {
+  classifySemanticEdit,
+  SemanticEditScriptAdmissionStatuses,
+  semanticEditAdmission,
+  summarizeSemanticEditOperations
+} from './semanticEditScriptClassification.js';
+import { sourceTextForSpan } from './sourceTextForSpan.js';
+
+export { SemanticEditScriptAdmissionStatuses };
+
+export function createSemanticEditScript(input = {}, options = {}) {
+  const language = input.language ?? input.worker?.language ?? input.after?.language ?? input.base?.language ?? input.before?.language;
+  if (!language) throw new Error('createSemanticEditScript requires a language');
+  const sourcePath = input.sourcePath ?? input.worker?.sourcePath ?? input.after?.sourcePath ?? input.base?.sourcePath ?? input.before?.sourcePath;
+  const base = normalizeNativeDiffImport(sourceInput(input, 'base'), { ...input, language, sourcePath }, 'base');
+  const worker = normalizeNativeDiffImport(sourceInput(input, 'worker'), { ...input, language, sourcePath }, 'worker');
+  if (!base || !worker) throw new Error('createSemanticEditScript requires base and worker source inputs');
+  const head = normalizeNativeDiffImport(sourceInput(input, 'head'), { ...input, language, sourcePath }, 'head');
+  const workerChangeSet = diffNativeSourceImports({
+    ...input,
+    language,
+    sourcePath,
+    before: base,
+    after: worker,
+    id: input.workerChangeSetId ?? `${input.id ?? 'semantic_edit'}_worker`
+  });
+  const headChangeSet = head ? diffNativeSourceImports({
+    ...input,
+    language,
+    sourcePath,
+    before: base,
+    after: head,
+    id: input.headChangeSetId ?? `${input.id ?? 'semantic_edit'}_head`
+  }) : undefined;
+  const headLineage = head ? inferSemanticLineageEvents({
+    before: base,
+    after: head,
+    id: input.lineageInferenceId ?? `${input.id ?? 'semantic_edit'}_head_lineage`,
+    language,
+    sourcePath,
+    generatedAt: input.generatedAt,
+    metadata: { source: 'createSemanticEditScript' }
+  }) : undefined;
+  const context = createEditContext({ base, worker, head, workerChangeSet, headChangeSet, headLineage });
+  const operations = workerChangeSet.changedRegions.map((region, index) => semanticEditOperation(region, index, context, input));
+  const summary = summarizeSemanticEditOperations(operations);
+  const admission = semanticEditAdmission({ operations, summary, head, workerChangeSet, headChangeSet, input });
+  const evidence = semanticEditEvidence({ input, language, sourcePath, workerChangeSet, headChangeSet, headLineage, summary, admission });
+  const core = {
+    kind: 'frontier.lang.semanticEditScript',
+    version: 1,
+    schema: 'frontier.lang.semanticEditScript.v1',
+    language,
+    sourcePath,
+    baseHash: workerChangeSet.beforeHash,
+    workerHash: workerChangeSet.afterHash,
+    headHash: headChangeSet?.afterHash,
+    workerChangeSetId: workerChangeSet.id,
+    headChangeSetId: headChangeSet?.id,
+    lineageInferenceId: headLineage?.id,
+    operations,
+    summary,
+    admission,
+    evidence,
+    metadata: compactRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      workerReadiness: workerChangeSet.readiness,
+      headReadiness: headChangeSet?.readiness,
+      workerReasons: workerChangeSet.reasons,
+      headReasons: headChangeSet?.reasons,
+      ...input.metadata,
+      ...options.metadata
+    })
+  };
+  const hash = hashSemanticValue(core);
+  const id = input.id ?? `semantic_edit_script_${idFragment(firstString(sourcePath, language, hash))}`;
+  return { ...core, id, stableId: `semantic_edit_script_${idFragment(hash)}`, hash };
+}
+
+function sourceInput(input, side) {
+  if (side === 'base') return input.base ?? input.before ?? sourceTextInput(input, 'base') ?? sourceTextInput(input, 'before');
+  if (side === 'worker') return input.worker ?? input.after ?? sourceTextInput(input, 'worker') ?? sourceTextInput(input, 'after');
+  return input.head ?? input.current ?? sourceTextInput(input, 'head') ?? sourceTextInput(input, 'current');
+}
+
+function sourceTextInput(input, side) {
+  const sourceText = input[`${side}SourceText`];
+  if (sourceText === undefined) return undefined;
+  return {
+    language: input.language,
+    sourcePath: input[`${side}SourcePath`] ?? input.sourcePath,
+    sourceText,
+    sourceHash: input[`${side}SourceHash`],
+    parser: input.parser,
+    metadata: input[`${side}Metadata`]
+  };
+}
+
+function createEditContext(input) {
+  return {
+    ...input,
+    baseSymbols: symbolsByAnchor(input.base),
+    workerSymbols: symbolsByAnchor(input.worker),
+    headSymbols: symbolsByAnchor(input.head),
+    headChangedConflictKeys: new Set(input.headChangeSet?.conflictKeys ?? [])
+  };
+}
+
+function symbolsByAnchor(imported) {
+  if (!imported) return new Map();
+  const sidecar = createSemanticImportSidecar(imported, { id: `semantic_edit_sidecar_${idFragment(imported.id ?? imported.sourcePath ?? 'source')}` });
+  const result = new Map();
+  for (const symbol of mapDiffSymbols(imported, sidecar).values()) {
+    for (const key of uniqueStrings([symbol.ownershipKey, symbol.key, symbol.id])) {
+      result.set(key, symbol);
+    }
+  }
+  return result;
+}
+
+function semanticEditOperation(region, index, context, input) {
+  const anchorKey = region.key ?? region.conflictKey ?? region.id;
+  const baseSymbol = context.baseSymbols.get(anchorKey);
+  const workerSymbol = context.workerSymbols.get(anchorKey);
+  const headSymbol = context.headSymbols.get(anchorKey);
+  const classification = classifySemanticEdit({ region, anchorKey, baseSymbol, workerSymbol, headSymbol, context });
+  const kind = semanticEditOperationKind(region);
+  const baseText = spanText(context.base, baseSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.before?.sourceSpan ?? region.sourceSpan);
+  const workerText = spanText(context.worker, workerSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.after?.sourceSpan ?? region.sourceSpan);
+  return compactRecord({
+    id: `semantic_edit_op_${idFragment(firstString(input.id, anchorKey, index))}`,
+    kind,
+    changeKind: region.changeKind,
+    anchor: compactRecord({
+      key: anchorKey,
+      conflictKey: region.conflictKey ?? `region:${anchorKey}`,
+      regionId: region.id,
+      regionKind: region.regionKind,
+      granularity: region.granularity,
+      language: region.language ?? context.workerChangeSet.language,
+      sourcePath: region.sourcePath ?? context.workerChangeSet.sourcePath,
+      symbolId: region.symbolId ?? workerSymbol?.id ?? baseSymbol?.id,
+      symbolName: region.symbolName ?? workerSymbol?.name ?? baseSymbol?.name,
+      symbolKind: region.symbolKind ?? workerSymbol?.kind ?? baseSymbol?.kind,
+      sourceSpan: workerSymbol?.sourceSpan ?? region.sourceSpan
+    }),
+    hashes: compactRecord({
+      baseSourceHash: context.workerChangeSet.beforeHash,
+      workerSourceHash: context.workerChangeSet.afterHash,
+      headSourceHash: context.headChangeSet?.afterHash,
+      baseSpanHash: baseSymbol?.spanHash,
+      workerSpanHash: workerSymbol?.spanHash,
+      headSpanHash: headSymbol?.spanHash,
+      baseTextHash: baseText === undefined ? undefined : hashSemanticValue(baseText),
+      workerTextHash: workerText === undefined ? undefined : hashSemanticValue(workerText),
+      beforeSignatureHash: workerSymbol?.beforeSignatureHash ?? baseSymbol?.signatureHash,
+      afterSignatureHash: workerSymbol?.afterSignatureHash ?? workerSymbol?.signatureHash
+    }),
+    status: classification.status,
+    reanchor: classification.reanchor,
+    readiness: classification.readiness,
+    confidence: classification.confidence,
+    reasonCodes: classification.reasonCodes,
+    evidenceIds: classification.evidenceIds,
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  });
+}
+
+function semanticEditOperationKind(region) {
+  const prefix = region.changeKind === 'added' ? 'add' : region.changeKind === 'removed' ? 'remove' : 'replace';
+  const kind = String(region.regionKind ?? region.granularity ?? 'region');
+  if (kind === 'body') return `${prefix}Body`;
+  if (kind === 'import') return `${prefix}Import`;
+  if (kind === 'type') return `${prefix}TypeDeclaration`;
+  if (kind === 'property') return `${prefix}Property`;
+  return `${prefix}Region`;
+}
+
+function spanText(imported, span) {
+  return sourceTextForSpan(nativeImportSourceText(imported), span);
+}
+
+function semanticEditEvidence(input) {
+  return [{
+    id: input.input.evidenceId ?? `evidence_${idFragment(input.input.id ?? input.sourcePath ?? 'semantic_edit')}_semantic_edit_script`,
+    kind: 'semantic-edit-script',
+    status: input.admission.status === 'blocked' || input.admission.status === 'conflict' ? 'needs-review' : 'passed',
+    path: input.sourcePath,
+    summary: `Created semantic edit script with ${input.summary.operations} operation(s): ${input.admission.status}.`,
+    metadata: {
+      workerChangeSetId: input.workerChangeSet.id,
+      headChangeSetId: input.headChangeSet?.id,
+      lineageInferenceId: input.headLineage?.id,
+      summary: input.summary,
+      admissionStatus: input.admission.status,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  }];
+}
+
+function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(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/semanticHistoryLineageResolution.js

@@ -0,0 +1,256 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings as uniqueRawStrings } from '../../native-import-utils.js';
+import { resolveSemanticLineage } from './semanticLineageResolutionRecords.js';
+
+export function resolveSemanticHistoryRecordLineage(record = {}, eventsOrMap = [], options = {}) {
+  const generatedAt = options.generatedAt ?? Date.now();
+  const sourceIndex = record.index ?? {};
+  const anchorKeys = uniqueStrings([
+    ...array(sourceIndex.semanticAnchorKeys),
+    ...array(sourceIndex.ownershipKeys),
+    ...array(sourceIndex.conflictKeys)
+  ]);
+  const resolutions = anchorKeys.map((anchorKey) => resolveSemanticLineage(eventsOrMap, {
+    anchorKey,
+    generatedAt
+  }, { maxDepth: options.maxDepth }));
+  const byAnchorKey = new Map(resolutions.map((resolution) => [resolution.query.anchorKey, resolution]));
+  const resolvedIndex = {
+    ...sourceIndex,
+    ownershipKeys: resolveIndexKeys(sourceIndex.ownershipKeys, byAnchorKey, options),
+    conflictKeys: resolveIndexKeys(sourceIndex.conflictKeys, byAnchorKey, options),
+    semanticAnchorKeys: resolveIndexKeys(sourceIndex.semanticAnchorKeys, byAnchorKey, options),
+    sourcePaths: uniqueStrings([
+      ...array(sourceIndex.sourcePaths),
+      ...resolutions.flatMap((resolution) => resolution.currentAnchors.map((anchor) => anchor.sourcePath))
+    ]),
+    lineageEventIds: uniqueStrings([
+      ...array(sourceIndex.lineageEventIds),
+      ...resolutions.flatMap((resolution) => resolution.traversedEventIds)
+    ]),
+    semanticLineageKinds: uniqueStrings([
+      ...array(sourceIndex.semanticLineageKinds),
+      ...resolutions.flatMap((resolution) => resolution.lineageEventKinds)
+    ]),
+    crdtOperationIds: uniqueStrings([
+      ...array(sourceIndex.crdtOperationIds),
+      ...resolutions.flatMap((resolution) => resolution.crdtOperationIds)
+    ]),
+    crdtHeads: uniqueStrings([
+      ...array(sourceIndex.crdtHeads),
+      ...resolutions.flatMap((resolution) => resolution.crdtHeads)
+    ]),
+    evidenceIds: uniqueStrings([
+      ...array(sourceIndex.evidenceIds),
+      ...resolutions.flatMap((resolution) => resolution.evidenceIds)
+    ]),
+    proofIds: uniqueStrings([
+      ...array(sourceIndex.proofIds),
+      ...resolutions.flatMap((resolution) => resolution.proofIds)
+    ])
+  };
+  const anchorInventory = createAnchorInventory(resolutions);
+  const summary = summarizeSemanticHistoryLineageResolutions(resolutions, resolvedIndex, anchorInventory);
+  const readiness = summary.cycle > 0 || summary.maxDepth > 0 ? 'blocked' : summary.resolved > 0 || summary.ambiguous > 0 || summary.deleted > 0 || summary.recreated > 0 ? 'needs-review' : 'ready';
+  const resolutionCore = {
+    kind: 'frontier.lang.semanticHistoryRecordLineageResolution',
+    version: 1,
+    sourceRecordId: record.id,
+    sourceRecordStableId: record.stableId,
+    sourceRecordHash: record.hash,
+    generatedAt,
+    resolutions,
+    anchorInventory,
+    summary,
+    admission: {
+      readiness,
+      reviewRequired: readiness !== 'ready',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    },
+    metadata: compactRecord(options.metadata)
+  };
+  const hash = hashSemanticValue(resolutionCore);
+  const id = options.id ?? `semantic_history_lineage_resolution_${idFragment(firstString(record.id, record.stableId, hash))}`;
+  const resolvedRecord = createResolvedHistoryRecord(record, resolvedIndex, { id, hash, generatedAt, summary, readiness });
+  return {
+    ...resolutionCore,
+    id,
+    stableId: `semantic_history_lineage_resolution_${idFragment(hash)}`,
+    hash,
+    resolvedRecord
+  };
+}
+
+export function resolveSemanticHistoryRecordsLineage(records = [], eventsOrMap = [], options = {}) {
+  return array(records).map((record) => resolveSemanticHistoryRecordLineage(record, eventsOrMap, options));
+}
+
+function createResolvedHistoryRecord(record, index, resolution) {
+  const core = {
+    ...record,
+    id: `${record.id ?? 'semantic_history'}#lineage-resolved`,
+    index,
+    metadata: {
+      ...(record.metadata ?? {}),
+      semanticHistoryLineageResolution: {
+        id: resolution.id,
+        sourceRecordId: record.id,
+        sourceRecordHash: record.hash,
+        readiness: resolution.readiness,
+        summary: resolution.summary,
+        anchorSummary: {
+          activeAnchorKeys: resolution.summary.activeAnchorKeys,
+          candidateAnchorKeys: resolution.summary.candidateAnchorKeys,
+          inactiveAnchorKeys: resolution.summary.inactiveAnchorKeys,
+          blockedAnchorKeys: resolution.summary.blockedAnchorKeys
+        },
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }
+  };
+  const stableCore = { ...core };
+  delete stableCore.hash;
+  delete stableCore.stableId;
+  const hash = hashSemanticValue(stableCore);
+  return {
+    ...core,
+    stableId: `semantic_history_${idFragment(hash)}`,
+    hash
+  };
+}
+
+function resolveIndexKeys(values, resolutions, options) {
+  return uniqueStrings(array(values).flatMap((value) => {
+    const key = String(value);
+    const resolution = resolutions.get(key);
+    if (!resolution) return [key];
+    if (resolution.status === 'deleted' && options.keepDeletedAnchors !== true) return [];
+    if (resolution.status === 'cycle' && options.keepBlockedAnchors !== true) return [];
+    if (resolution.status === 'max-depth' && options.keepBlockedAnchors !== true) return [];
+    if (resolution.status === 'not-found' && options.keepUnresolvedAnchors !== true) return [];
+    if (resolution.status === 'ambiguous' && options.keepCandidateAnchors === false) return [];
+    const current = resolution.currentAnchors.map((anchor) => anchor.key).filter(Boolean);
+    return current.length ? current : [key];
+  }));
+}
+
+function summarizeSemanticHistoryLineageResolutions(resolutions, index, anchorInventory) {
+  const byStatus = {};
+  for (const resolution of resolutions) byStatus[resolution.status] = (byStatus[resolution.status] ?? 0) + 1;
+  return {
+    anchorCount: resolutions.length,
+    unchanged: byStatus.unchanged ?? 0,
+    resolved: byStatus.resolved ?? 0,
+    ambiguous: byStatus.ambiguous ?? 0,
+    deleted: byStatus.deleted ?? 0,
+    recreated: byStatus.recreated ?? 0,
+    cycle: byStatus.cycle ?? 0,
+    maxDepth: byStatus['max-depth'] ?? 0,
+    notFound: byStatus['not-found'] ?? 0,
+    currentAnchorKeys: uniqueStrings(index.semanticAnchorKeys),
+    ownershipKeys: uniqueStrings(index.ownershipKeys),
+    conflictKeys: uniqueStrings(index.conflictKeys),
+    sourcePaths: uniqueStrings(index.sourcePaths),
+    activeAnchorKeys: uniqueStrings(anchorInventory.active.map((anchor) => anchor.key)),
+    candidateAnchorKeys: uniqueStrings(anchorInventory.candidate.map((anchor) => anchor.key)),
+    inactiveAnchorKeys: uniqueStrings(anchorInventory.inactive.map((anchor) => anchor.key)),
+    deletedAnchorKeys: uniqueStrings(anchorInventory.deleted.map((anchor) => anchor.key)),
+    unresolvedAnchorKeys: uniqueStrings(anchorInventory.unresolved.map((anchor) => anchor.key)),
+    blockedAnchorKeys: uniqueStrings(anchorInventory.blocked.map((anchor) => anchor.key)),
+    traversedEventIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.traversedEventIds)),
+    terminalEventIds: uniqueStrings(resolutions.flatMap((resolution) => resolution.terminalEventIds)),
+    reasonCodes: uniqueStrings(resolutions.flatMap((resolution) => resolution.reasonCodes))
+  };
+}
+
+function createAnchorInventory(resolutions) {
+  const inventory = {
+    active: [],
+    candidate: [],
+    inactive: [],
+    deleted: [],
+    unresolved: [],
+    blocked: []
+  };
+  for (const resolution of resolutions) {
+    const start = anchorEntry(resolution.startAnchor ?? queryAnchor(resolution), resolution);
+    const current = resolution.currentAnchors.map((anchor) => anchorEntry(anchor, resolution));
+    if (resolution.status === 'ambiguous') {
+      inventory.candidate.push(...current);
+      if (start) inventory.inactive.push(start);
+      continue;
+    }
+    if (resolution.status === 'deleted') {
+      if (start) {
+        inventory.inactive.push(start);
+        inventory.deleted.push(start);
+      }
+      continue;
+    }
+    if (resolution.status === 'cycle' || resolution.status === 'max-depth') {
+      if (start) {
+        inventory.inactive.push(start);
+        inventory.blocked.push(start);
+      }
+      continue;
+    }
+    if (resolution.status === 'not-found') {
+      if (start) {
+        inventory.inactive.push(start);
+        inventory.unresolved.push(start);
+      }
+      continue;
+    }
+    inventory.active.push(...current);
+  }
+  return {
+    active: uniqueAnchorEntries(inventory.active),
+    candidate: uniqueAnchorEntries(inventory.candidate),
+    inactive: uniqueAnchorEntries(inventory.inactive),
+    deleted: uniqueAnchorEntries(inventory.deleted),
+    unresolved: uniqueAnchorEntries(inventory.unresolved),
+    blocked: uniqueAnchorEntries(inventory.blocked)
+  };
+}
+
+function anchorEntry(anchor, resolution) {
+  if (!anchor) return undefined;
+  return compactRecord({
+    key: anchor.key,
+    id: anchor.id,
+    kind: anchor.kind,
+    language: anchor.language,
+    sourcePath: anchor.sourcePath,
+    symbolId: anchor.symbolId,
+    symbolName: anchor.symbolName,
+    status: resolution.status,
+    resolutionId: resolution.id,
+    reasonCodes: uniqueStrings(resolution.reasonCodes)
+  });
+}
+
+function queryAnchor(resolution) {
+  return compactRecord({
+    key: resolution.query?.anchorKey,
+    id: resolution.query?.anchorId,
+    sourcePath: resolution.query?.sourcePath,
+    symbolName: resolution.query?.symbolName
+  });
+}
+
+function uniqueAnchorEntries(entries) {
+  const seen = new Set();
+  return entries.filter(Boolean).filter((entry) => {
+    const key = entry.key ?? entry.id ?? `${entry.sourcePath ?? ''}:${entry.symbolName ?? ''}`;
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+function uniqueStrings(values) { return uniqueRawStrings(array(values).map((value) => String(value ?? '')).filter(Boolean)); }
+function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined)); }

package/package.json

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