@shapeshift-labs/frontier-lang-compiler 0.2.98 → 0.2.99

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

@@ -0,0 +1,78 @@
+import type { SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
+import type { SemanticEditProjection, SemanticEditReplay, SemanticEditScript } from './semantic-edit-script.js';
+
+export type SemanticEditBundleAdmissionStatus =
+  | 'none'
+  | 'ready'
+  | 'already-applied'
+  | 'needs-review'
+  | 'stale'
+  | 'conflict'
+  | 'blocked'
+  | string;
+
+export interface SemanticEditBundleAdmissionSummary {
+  readonly scripts: number;
+  readonly projections: number;
+  readonly replays: number;
+  readonly files: number;
+  readonly acceptedClean: number;
+  readonly alreadyApplied: number;
+  readonly conflicts: number;
+  readonly stale: number;
+  readonly blocked: number;
+  readonly needsReview: number;
+  readonly projected: number;
+  readonly projectionBlocked: number;
+  readonly scriptStatuses: readonly string[];
+  readonly projectionStatuses: readonly string[];
+  readonly replayStatuses: readonly string[];
+  readonly replayActions: readonly string[];
+  readonly sourcePaths: readonly string[];
+  readonly scriptIds: readonly string[];
+  readonly projectionIds: readonly string[];
+  readonly replayIds: readonly string[];
+  readonly reasonCodes: readonly string[];
+}
+
+export interface SemanticEditBundleAdmission {
+  readonly status: SemanticEditBundleAdmissionStatus;
+  readonly action: 'none' | 'admit' | 'skip' | 'review' | 'rerun-semantic-import' | 'block' | string;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly reviewRequired: boolean;
+  readonly autoApplyCandidate: boolean;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly reasonCodes: readonly string[];
+  readonly sourcePaths: readonly string[];
+  readonly scriptIds: readonly string[];
+  readonly projectionIds: readonly string[];
+  readonly replayIds: readonly string[];
+  readonly summary: SemanticEditBundleAdmissionSummary;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CreateSemanticEditBundleAdmissionInput {
+  readonly status?: SemanticEditBundleAdmissionStatus;
+  readonly action?: string;
+  readonly readiness?: SemanticMergeReadiness | string;
+  readonly reviewRequired?: boolean;
+  readonly autoApplyCandidate?: boolean;
+  readonly reasonCodes?: readonly string[] | string;
+  readonly semanticEditScript?: SemanticEditScript;
+  readonly semanticEditScripts?: readonly SemanticEditScript[] | SemanticEditScript;
+  readonly scripts?: readonly SemanticEditScript[] | SemanticEditScript;
+  readonly semanticEditProjection?: SemanticEditProjection;
+  readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
+  readonly projections?: readonly SemanticEditProjection[] | SemanticEditProjection;
+  readonly semanticEditReplay?: SemanticEditReplay;
+  readonly semanticEditReplays?: readonly SemanticEditReplay[] | SemanticEditReplay;
+  readonly replays?: readonly SemanticEditReplay[] | SemanticEditReplay;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export declare const SemanticEditBundleAdmissionStatuses: readonly SemanticEditBundleAdmissionStatus[];
+export declare function createSemanticEditBundleAdmission(
+  input?: CreateSemanticEditBundleAdmissionInput,
+  options?: Partial<CreateSemanticEditBundleAdmissionInput>
+): SemanticEditBundleAdmission;

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

@@ -18,6 +18,9 @@ export interface SemanticPatchBundleRecordIndex {
   readonly semanticEditReplayIds: readonly string[];
   readonly semanticEditReplayStatuses: readonly string[];
   readonly semanticEditReplayActions: readonly string[];
+  readonly semanticEditAdmissionStatuses: readonly string[];
+  readonly semanticEditAdmissionActions: readonly string[];
+  readonly semanticEditAdmissionReadinesses: readonly string[];
   readonly semanticEditReplayCurrentHashes: readonly string[];
   readonly semanticEditReplayOutputHashes: readonly string[];
   readonly semanticEditKeys: readonly string[];

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

@@ -7,6 +7,7 @@ import type {
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticEditBundleAdmission } from './semantic-edit-bundle.js';
 import type { SemanticEditProjection, SemanticEditReplay, SemanticEditScript } from './semantic-edit-script.js';
 import type { SemanticPatchBundleRecordIndex } from './semantic-patch-bundle-index.js';
 import type { SemanticTransformIdentityRecord } from './semantic-transform-identity.js';
@@ -88,6 +89,7 @@ export interface SemanticPatchBundleAdmission {
   readonly autoMergeClaim: false;
   readonly autoApplyCandidate?: boolean;
   readonly transformAdmission?: SemanticPatchBundleTransformAdmission;
+  readonly semanticEditAdmission?: SemanticEditBundleAdmission;
   readonly reasonCodes?: readonly string[];
   readonly conflictKeys?: readonly string[];
   readonly admittedAt?: number | string;
@@ -150,6 +152,7 @@ export interface SemanticPatchBundleRecord {
     readonly semanticEditReplays: number;
     readonly semanticEditProjectionEdits: number;
     readonly semanticEditReplayEdits: number;
+    readonly semanticEditBundleStatus?: string;
     readonly semanticTransformIdentities: number;
     readonly reviewRequired: boolean;
     readonly autoMergeClaim: false;
@@ -185,6 +188,7 @@ export interface CreateSemanticPatchBundleRecordOptions {
   readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
   readonly semanticEditReplay?: SemanticEditReplay;
   readonly semanticEditReplays?: readonly SemanticEditReplay[] | SemanticEditReplay;
+  readonly semanticEditAdmission?: Partial<SemanticEditBundleAdmission>;
   readonly semanticTransformIdentity?: SemanticTransformIdentityRecord | Record<string, unknown>;
   readonly semanticTransformIdentities?: readonly (SemanticTransformIdentityRecord | Record<string, unknown>)[];
   readonly targetPortability?: BidirectionalTargetPortabilityRecord | Record<string, unknown>;
@@ -242,6 +246,12 @@ export interface SemanticPatchBundleRecordQuery {
   readonly semanticEditReplayStatuses?: readonly string[];
   readonly semanticEditReplayAction?: string | readonly string[];
   readonly semanticEditReplayActions?: readonly string[];
+  readonly semanticEditAdmissionStatus?: string | readonly string[];
+  readonly semanticEditAdmissionStatuses?: readonly string[];
+  readonly semanticEditAdmissionAction?: string | readonly string[];
+  readonly semanticEditAdmissionActions?: readonly string[];
+  readonly semanticEditAdmissionReadiness?: string | readonly string[];
+  readonly semanticEditAdmissionReadinesses?: readonly string[];
   readonly semanticEditReplayCurrentHash?: string | readonly string[];
   readonly semanticEditReplayCurrentHashes?: readonly string[];
   readonly semanticEditReplayOutputHash?: string | readonly string[];

package/dist/index.d.ts

@@ -19,6 +19,7 @@ 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-edit-bundle.js';
 export * from './declarations/semantic-patch-bundle-index.js';
 export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-patch-bundle-overlaps.js';

package/dist/index.js

@@ -67,6 +67,7 @@ export { projectNativeImportToSource } from './internal/index-impl/projectNative
 export { queryNativeParserFeatureMatrix } from './internal/index-impl/queryNativeParserFeatureMatrix.js';
 export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProjectionReadinessMatrix.js';
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
+export { createSemanticEditBundleAdmission, SemanticEditBundleAdmissionStatuses } from './internal/index-impl/semanticEditBundleAdmission.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';

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

@@ -0,0 +1,137 @@
+import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-import-utils.js';
+
+export const SemanticEditBundleAdmissionStatuses = Object.freeze([
+  'none',
+  'ready',
+  'already-applied',
+  'needs-review',
+  'stale',
+  'conflict',
+  'blocked'
+]);
+
+export function createSemanticEditBundleAdmission(input = {}, options = {}) {
+  const scripts = array(input.semanticEditScripts ?? input.scripts ?? input.semanticEditScript);
+  const projections = array(input.semanticEditProjections ?? input.projections ?? input.semanticEditProjection);
+  const replays = array(input.semanticEditReplays ?? input.replays ?? input.semanticEditReplay);
+  const summary = summarizeSemanticEditBundle(scripts, projections, replays);
+  const status = input.status ?? options.status ?? semanticEditBundleStatus(summary);
+  const readiness = normalizeSemanticMergeReadiness(input.readiness ?? options.readiness ?? readinessForStatus(status))
+    ?? input.readiness ?? options.readiness ?? readinessForStatus(status);
+  return compactRecord({
+    status,
+    action: input.action ?? options.action ?? actionForStatus(status),
+    readiness,
+    reviewRequired: input.reviewRequired ?? !['ready', 'already-applied', 'none'].includes(status),
+    autoApplyCandidate: input.autoApplyCandidate ?? status === 'ready',
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: uniqueStrings([
+      ...strings(input.reasonCodes),
+      ...strings(options.reasonCodes),
+      ...summary.reasonCodes,
+      ...derivedReasonCodes(summary, status)
+    ]),
+    sourcePaths: summary.sourcePaths,
+    scriptIds: summary.scriptIds,
+    projectionIds: summary.projectionIds,
+    replayIds: summary.replayIds,
+    summary,
+    metadata: input.metadata ?? options.metadata
+  });
+}
+
+function summarizeSemanticEditBundle(scripts, projections, replays) {
+  const scriptStatusEntries = scripts.map((script) => script.admission?.status);
+  const projectionStatusEntries = projections.flatMap((projection) => [projection.status, projection.admission?.status]);
+  const replayStatusEntries = replays.map((replay) => replay.status);
+  const scriptStatuses = uniqueStrings(strings(scriptStatusEntries));
+  const projectionStatuses = uniqueStrings(strings(projectionStatusEntries));
+  const replayStatuses = uniqueStrings(strings(replayStatusEntries));
+  const replayActions = uniqueStrings(strings(replays.map((replay) => replay.admission?.action)));
+  return {
+    scripts: scripts.length,
+    projections: projections.length,
+    replays: replays.length,
+    files: sourcePaths(scripts, projections, replays).length,
+    acceptedClean: replays.filter((replay) => replay.status === 'accepted-clean').length,
+    alreadyApplied: replays.filter((replay) => replay.status === 'already-applied').length,
+    conflicts: countStatuses(scriptStatusEntries, replayStatusEntries, ['conflict']),
+    stale: countStatuses(scriptStatusEntries, replayStatusEntries, ['stale']),
+    blocked: countStatuses(scriptStatusEntries, projectionStatusEntries, replayStatusEntries, ['blocked']),
+    needsReview: countStatuses(scriptStatusEntries, replayStatusEntries, ['needs-port', 'evidence-only']),
+    projected: projections.filter((projection) => projection.status === 'projected').length,
+    projectionBlocked: projections.filter((projection) => projection.status === 'blocked').length,
+    scriptStatuses,
+    projectionStatuses,
+    replayStatuses,
+    replayActions,
+    sourcePaths: sourcePaths(scripts, projections, replays),
+    scriptIds: uniqueStrings(scripts.map((script) => script.id)),
+    projectionIds: uniqueStrings(projections.map((projection) => projection.id)),
+    replayIds: uniqueStrings(replays.map((replay) => replay.id)),
+    reasonCodes: uniqueStrings([
+      ...scripts.flatMap((script) => strings(script.admission?.reasonCodes)),
+      ...projections.flatMap((projection) => strings(projection.admission?.reasonCodes)),
+      ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes))
+    ])
+  };
+}
+
+function semanticEditBundleStatus(summary) {
+  const total = summary.scripts + summary.projections + summary.replays;
+  if (total === 0) return 'none';
+  if (summary.blocked || summary.projectionBlocked) return 'blocked';
+  if (summary.conflicts) return 'conflict';
+  if (summary.stale) return 'stale';
+  if (!summary.replays || summary.needsReview) return 'needs-review';
+  if (summary.acceptedClean === 0 && summary.alreadyApplied === summary.replays) return 'already-applied';
+  return summary.acceptedClean + summary.alreadyApplied === summary.replays ? 'ready' : 'needs-review';
+}
+
+function derivedReasonCodes(summary, status) {
+  return [
+    summary.scripts && !summary.projections ? 'semantic-edit-projection-missing' : undefined,
+    (summary.scripts || summary.projections) && !summary.replays ? 'semantic-edit-replay-missing' : undefined,
+    status === 'ready' ? 'semantic-edit-replay-accepted-clean' : undefined,
+    status === 'already-applied' ? 'semantic-edit-replay-already-applied' : undefined,
+    status === 'blocked' ? 'semantic-edit-blocked' : undefined,
+    status === 'conflict' ? 'semantic-edit-conflict' : undefined,
+    status === 'stale' ? 'semantic-edit-stale' : undefined
+  ];
+}
+
+function readinessForStatus(status) {
+  if (['ready', 'already-applied'].includes(status)) return 'ready';
+  if (['blocked', 'conflict'].includes(status)) return 'blocked';
+  return 'needs-review';
+}
+
+function actionForStatus(status) {
+  if (status === 'ready') return 'admit';
+  if (status === 'already-applied') return 'skip';
+  if (status === 'none') return 'none';
+  if (status === 'stale') return 'rerun-semantic-import';
+  if (status === 'blocked' || status === 'conflict') return 'block';
+  return 'review';
+}
+
+function sourcePaths(scripts, projections, replays) {
+  return uniqueStrings(strings([
+    ...scripts.map((script) => script.sourcePath),
+    ...projections.map((projection) => projection.sourcePath),
+    ...projections.flatMap((projection) => array(projection.edits).flatMap((edit) => [edit.sourcePath, edit.targetSourcePath])),
+    ...replays.map((replay) => replay.sourcePath),
+    ...replays.flatMap((replay) => array(replay.edits).map((edit) => edit.sourcePath))
+  ]));
+}
+
+function countStatuses(...args) {
+  const statuses = args.slice(0, -1).flatMap((value) => strings(value));
+  const needles = new Set(args.at(-1));
+  return statuses.filter((status) => needles.has(status)).length;
+}
+
+function array(value) { if (value === undefined || value === null) return []; return Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -2,10 +2,14 @@ import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-imp
 
 export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
   const transformAdmission = semanticTransformAdmission(context);
-  const fallbackReadiness = transformAdmission.readiness === 'ready' ? 'ready' : context.readiness;
+  const semanticEditAdmission = context.semanticEditAdmission ?? { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
+  const fallbackReadiness = fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, context.readiness);
   const readiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
-  const status = input.status ?? admissionStatusForReadiness(readiness, transformAdmission);
-  const autoApplyCandidate = input.autoApplyCandidate ?? (status === 'admitted' && transformAdmission.action === 'admit');
+  const status = input.status ?? admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission);
+  const autoApplyCandidate = input.autoApplyCandidate ?? (status === 'admitted' && [
+    transformAdmission.action,
+    semanticEditAdmission.action
+  ].includes('admit'));
   return compactRecord({
     status,
     readiness,
@@ -13,11 +17,13 @@ export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
     autoMergeClaim: false,
     autoApplyCandidate,
     transformAdmission,
+    semanticEditAdmission,
     reasonCodes: uniqueStrings([
       ...strings(input.reasonCodes),
       ...strings(context.source?.reasons),
       ...strings(context.mergeCandidate?.reasons),
-      ...transformAdmission.reasonCodes
+      ...transformAdmission.reasonCodes,
+      ...strings(semanticEditAdmission.reasonCodes)
     ]),
     conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
     admittedAt: input.admittedAt,
@@ -81,12 +87,23 @@ function transformReadiness(value) {
   return undefined;
 }
 
-function admissionStatusForReadiness(readiness, transformAdmission) {
+function fallbackAdmissionReadiness(transformAdmission, semanticEditAdmission, fallback) {
+  if ([transformAdmission.readiness, semanticEditAdmission.readiness].includes('blocked')) return 'blocked';
+  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission)) return 'ready';
+  return fallback;
+}
+
+function admissionStatusForReadiness(readiness, transformAdmission, semanticEditAdmission) {
   if (readiness === 'blocked') return 'blocked';
-  if (transformAdmission.action === 'admit' && readiness === 'ready') return 'admitted';
+  if (hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission) && readiness === 'ready') return 'admitted';
   return readiness === 'needs-review' ? 'needs-review' : 'proposed';
 }
 
+function hasAdmissibleReadyAction(transformAdmission, semanticEditAdmission) {
+  return [transformAdmission.action, semanticEditAdmission.action].includes('admit') ||
+    (semanticEditAdmission.action === 'skip' && semanticEditAdmission.readiness === 'ready' && semanticEditAdmission.reviewRequired === false);
+}
+
 function hasCrossLanguageTransform(index) {
   const source = new Set(strings(index.transformSourceLanguages));
   return strings(index.transformTargetLanguages).some((target) => !source.has(target));

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

@@ -1,4 +1,5 @@
 import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{createSemanticEditBundleAdmission}from'./semanticEditBundleAdmission.js';
 import{createSemanticPatchBundleAdmission}from'./semanticPatchBundleAdmission.js';
 import{semanticEditRecordIndex,semanticEditSummary}from'./semanticEditBundleIndex.js';
 import{normalizeSemanticTransformIdentityRecords,semanticTransformInputs,semanticTransformRecordIndex,semanticTransformSummary}from'./semanticTransformIdentityRecords.js';
@@ -12,7 +13,13 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const semanticEditScripts=array(options.semanticEditScripts??source.semanticEditScripts??source.semanticEditScript);
   const semanticEditProjections=array(options.semanticEditProjections??source.semanticEditProjections??source.semanticEditProjection);
   const semanticEditReplays=array(options.semanticEditReplays??source.semanticEditReplays??source.semanticEditReplay);
-  const semanticEditIndex=semanticEditRecordIndex(semanticEditScripts,semanticEditProjections,semanticEditReplays,source);
+  const editAdmission=createSemanticEditBundleAdmission({
+    semanticEditScripts,semanticEditProjections,semanticEditReplays,
+    ...(source.metadata?.semanticEditAdmission??{}),
+    ...(source.semanticEditAdmission??{}),
+    ...(options.semanticEditAdmission??{})
+  });
+  const editIndex=semanticEditRecordIndex(semanticEditScripts,semanticEditProjections,semanticEditReplays,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);
@@ -38,7 +45,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const evidenceIds=uniqueStrings([...strings(options.evidenceIds),...strings(source.evidenceIds),...evidenceRecords.map((record)=>record?.id),...strings(mergeCandidate?.evidenceIds)]);
   const proofIds=uniqueStrings([...strings(options.proofIds),...strings(source.proofIds),...evidenceRecords.filter((record)=>record?.kind==='proof').map((record)=>record.id),...strings(mergeCandidate?.proofIds)]);
   const historyIds=uniqueStrings([...strings(options.historyIds),...strings(options.historyId),...strings(source.historyIds),...strings(source.historyId)]);
-  const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds),...semanticEditIndex.semanticEditOperationIds]);
+  const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds),...editIndex.semanticEditOperationIds]);
   const conflictKeys=uniqueStrings([
     ...strings(options.conflictKeys),
     ...strings(source.conflictKeys),
@@ -46,12 +53,12 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     ...changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),
     ...(source.metadata?.semanticMergeConflictSummary?.conflictKeys??[])
   ]);
-  const admission=createSemanticPatchBundleAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate,semanticTransformIndex,semanticTransformIdentities});
+  const admission=createSemanticPatchBundleAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate,semanticTransformIndex,semanticTransformIdentities,semanticEditAdmission:editAdmission});
   const id=options.id??(source.kind==='frontier.lang.semanticPatchBundleRecord'?source.id:undefined)
     ??`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,semanticTransformIndex,targetPortability});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditAdmission:editAdmission,semanticEditIndex:editIndex,semanticTransformIndex,targetPortability});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -71,20 +78,21 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     proofIds,
     historyIds,
     semanticOperationIds,
-    semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
-    semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
-    semanticEditReplayIds:semanticEditIndex.semanticEditReplayIds,
+    semanticEditScriptIds:editIndex.semanticEditScriptIds,
+    semanticEditProjectionIds:editIndex.semanticEditProjectionIds,
+    semanticEditReplayIds:editIndex.semanticEditReplayIds,
     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,semanticEditReplays:semanticEditReplays.length,semanticEditProjectionEdits:semanticEditIndex.semanticEditProjectionEditCount,semanticEditReplayEdits:semanticEditIndex.semanticEditReplayEditCount,semanticTransformIdentities:semanticTransformIdentities.length,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,semanticEditReplays:semanticEditReplays.length,semanticEditProjectionEdits:editIndex.semanticEditProjectionEditCount,semanticEditReplayEdits:editIndex.semanticEditReplayEditCount,semanticEditBundleStatus:editAdmission.status,semanticTransformIdentities:semanticTransformIdentities.length,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
       patchRisk:patch?.risk,
       nativeChangeSummary:source.summary,
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary,
       semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
-      semanticEditSummary:semanticEditSummary(semanticEditIndex),
+      semanticEditSummary:semanticEditSummary(editIndex),
+      semanticEditAdmission:editAdmission,
       semanticTransformSummary:semanticTransformSummary(semanticTransformIndex),
       targetPortability,
       ...options.metadata
@@ -192,16 +200,17 @@ function normalizeSourceMapLinks(links){
 }
 
 function recordIndex(parts){
-  const semanticEditIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[],[],parts);
+  const editIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[],[],parts);
+  const editAdmission=parts.semanticEditAdmission??{};
   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,...semanticTransformIndex.transformSourcePaths,...semanticTransformIndex.transformTargetPaths]),
-    regionKeys:uniqueStrings([...parts.changedRegions.map((region)=>region.key),...semanticEditIndex.anchorKeys]),
+    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...strings(editAdmission.sourcePaths),...editIndex.projectedSourcePaths,...semanticTransformIndex.transformSourcePaths,...semanticTransformIndex.transformTargetPaths]),
+    regionKeys:uniqueStrings([...parts.changedRegions.map((region)=>region.key),...editIndex.anchorKeys]),
     regionKinds:uniqueStrings(parts.changedRegions.map((region)=>region.regionKind)),
-    conflictKeys:uniqueStrings([...parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),...semanticEditIndex.conflictKeys]),
+    conflictKeys:uniqueStrings([...parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),...editIndex.conflictKeys]),
     sourceMapIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapId),...parts.changedRegions.flatMap((region)=>region.sourceMapIds??[])]),
     sourceMapMappingIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapMappingId),...parts.changedRegions.flatMap((region)=>region.sourceMapMappingIds??[])]),
     sourceMapLinkIds:uniqueStrings(parts.sourceMapLinks.map((link)=>link.id)),
@@ -209,18 +218,21 @@ function recordIndex(parts){
     proofIds:parts.proofIds,
     historyIds:parts.historyIds,
     semanticOperationIds:uniqueStrings(parts.semanticOperationIds),
-    semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
-    semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
-    semanticEditReplayIds:semanticEditIndex.semanticEditReplayIds,
-    semanticEditReplayStatuses:semanticEditIndex.semanticEditReplayStatuses,
-    semanticEditReplayActions:semanticEditIndex.semanticEditReplayActions,
-    semanticEditReplayCurrentHashes:semanticEditIndex.semanticEditReplayCurrentHashes,
-    semanticEditReplayOutputHashes:semanticEditIndex.semanticEditReplayOutputHashes,
-    semanticEditKeys:semanticEditIndex.semanticEditKeys,
-    semanticIdentityHashes:semanticEditIndex.semanticIdentityHashes,
-    sourceIdentityHashes:semanticEditIndex.sourceIdentityHashes,
-    operationContentHashes:semanticEditIndex.operationContentHashes,
-    editContentHashes:semanticEditIndex.editContentHashes,
+    semanticEditScriptIds:editIndex.semanticEditScriptIds,
+    semanticEditProjectionIds:editIndex.semanticEditProjectionIds,
+    semanticEditReplayIds:editIndex.semanticEditReplayIds,
+    semanticEditReplayStatuses:editIndex.semanticEditReplayStatuses,
+    semanticEditReplayActions:editIndex.semanticEditReplayActions,
+    semanticEditAdmissionStatuses:uniqueStrings([editAdmission.status]),
+    semanticEditAdmissionActions:uniqueStrings([editAdmission.action]),
+    semanticEditAdmissionReadinesses:uniqueStrings([editAdmission.readiness]),
+    semanticEditReplayCurrentHashes:editIndex.semanticEditReplayCurrentHashes,
+    semanticEditReplayOutputHashes:editIndex.semanticEditReplayOutputHashes,
+    semanticEditKeys:editIndex.semanticEditKeys,
+    semanticIdentityHashes:editIndex.semanticIdentityHashes,
+    sourceIdentityHashes:editIndex.sourceIdentityHashes,
+    operationContentHashes:editIndex.operationContentHashes,
+    editContentHashes:editIndex.editContentHashes,
     semanticTransformIds:semanticTransformIndex.semanticTransformIds,
     semanticTransformKeys:semanticTransformIndex.semanticTransformKeys,
     semanticTransformIdentityHashes:semanticTransformIndex.semanticTransformIdentityHashes,
@@ -243,7 +255,7 @@ function recordIndex(parts){
 }
 
 function matchesRecord(record,query){
-  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],semanticOperationIds:record.semanticOperationIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{},targetPortability:record.metadata?.targetPortability});
+  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],semanticOperationIds:record.semanticOperationIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{},semanticEditAdmission:record.admission?.semanticEditAdmission??record.metadata?.semanticEditAdmission,targetPortability:record.metadata?.targetPortability});
   return matchAny(queryValues(query.id,query.ids),[record.id])
     &&matchAny(queryValues(query.patchId,query.patchIds),index.patchIds)
     &&matchAny(queryValues(query.mergeCandidateId,query.mergeCandidateIds),index.mergeCandidateIds)
@@ -266,6 +278,9 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.semanticEditReplayId,query.semanticEditReplayIds),index.semanticEditReplayIds)
     &&matchAny(queryValues(query.semanticEditReplayStatus,query.semanticEditReplayStatuses),index.semanticEditReplayStatuses)
     &&matchAny(queryValues(query.semanticEditReplayAction,query.semanticEditReplayActions),index.semanticEditReplayActions)
+    &&matchAny(queryValues(query.semanticEditAdmissionStatus,query.semanticEditAdmissionStatuses),index.semanticEditAdmissionStatuses)
+    &&matchAny(queryValues(query.semanticEditAdmissionAction,query.semanticEditAdmissionActions),index.semanticEditAdmissionActions)
+    &&matchAny(queryValues(query.semanticEditAdmissionReadiness,query.semanticEditAdmissionReadinesses),index.semanticEditAdmissionReadinesses)
     &&matchAny(queryValues(query.semanticEditReplayCurrentHash,query.semanticEditReplayCurrentHashes),index.semanticEditReplayCurrentHashes)
     &&matchAny(queryValues(query.semanticEditReplayOutputHash,query.semanticEditReplayOutputHashes),index.semanticEditReplayOutputHashes)
     &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),index.semanticEditKeys)

package/package.json

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