@shapeshift-labs/frontier-lang-compiler 0.2.79 → 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/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,6 +69,7 @@ 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';

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/package.json

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