@shapeshift-labs/frontier-lang-parser 0.3.68 → 0.3.70

package/dist/gate-admission-evidence.js

@@ -0,0 +1,288 @@
+export function parseGateAdmissionEvidenceBlock(block) {
+  const name = nameFrom(block.header);
+  const surface = {
+    kind: 'frontier.lang.authoredGateAdmissionEvidenceInput',
+    version: 1,
+    schema: 'frontier.lang.authoredGateAdmissionEvidenceInput.v1',
+    id: idFrom(block.header, `gate_admission_${safeId(name)}`),
+    name,
+    gates: [],
+    evidence: [],
+    admissions: [],
+    proofGaps: [],
+    parser: { status: 'authored', errors: [] },
+    claims: falseClaims(),
+    metadata: { authoredName: name, authoredBlockKind: block.kind }
+  };
+  for (const authoredLine of readAuthoredLines(block)) {
+    const line = authoredLine.text;
+    if (!line || line.startsWith('#')) continue;
+    const match = /^(gate|evidence|proofEvidence|admission|admissionDecision|gap|proofGap)\s+([A-Za-z_$@/.:*-][\w$./@:*+-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, text] = match;
+    if (rowKind === 'gate') surface.gates.push(gateRecord(rowName, text, authoredLine));
+    else if (rowKind === 'evidence' || rowKind === 'proofEvidence') surface.evidence.push(evidenceRecord(rowName, text, authoredLine, rowKind));
+    else if (rowKind === 'admission' || rowKind === 'admissionDecision') surface.admissions.push(admissionRecord(rowName, text, authoredLine));
+    else surface.proofGaps.push(proofGapRecord(rowName, text, authoredLine));
+  }
+  surface.gateIds = ids(surface.gates);
+  surface.evidenceIds = ids(surface.evidence);
+  surface.proofEvidenceIds = surface.evidence.filter((record) => record.proof).map((record) => record.id).filter(Boolean);
+  surface.admissionIds = ids(surface.admissions);
+  surface.proofGapCodes = uniqueStrings(surface.proofGaps.map((record) => record.code));
+  surface.missingEvidence = uniqueStrings([
+    ...surface.gates.flatMap((record) => record.missingEvidence ?? []),
+    ...surface.admissions.flatMap((record) => record.missingEvidence ?? []),
+    ...surface.proofGaps.map((record) => record.code)
+  ]);
+  surface.summary = {
+    gateCount: surface.gates.length,
+    evidenceCount: surface.evidence.length,
+    proofEvidenceCount: surface.proofEvidenceIds.length,
+    admissionCount: surface.admissions.length,
+    proofGapCount: surface.proofGaps.length,
+    missingEvidenceCount: surface.missingEvidence.length,
+    passedGateCount: surface.gates.filter((record) => record.status === 'passed').length,
+    failedGateCount: surface.gates.filter((record) => record.status === 'failed').length,
+    blockedAdmissionCount: surface.admissions.filter((record) => /blocked|missing|failed|review/.test(record.status ?? '')).length
+  };
+  return surface;
+}
+
+export function mergeGateAdmissionEvidenceBlocks(blocks) {
+  const gates = uniqueRecords(blocks.flatMap((block) => block.gates ?? []));
+  const evidence = uniqueRecords(blocks.flatMap((block) => block.evidence ?? []));
+  const admissions = uniqueRecords(blocks.flatMap((block) => block.admissions ?? []));
+  const proofGaps = uniqueRecords(blocks.flatMap((block) => block.proofGaps ?? []));
+  const proofEvidenceIds = evidence.filter((record) => record.proof).map((record) => record.id).filter(Boolean);
+  const missingEvidence = uniqueStrings([
+    ...gates.flatMap((record) => record.missingEvidence ?? []),
+    ...admissions.flatMap((record) => record.missingEvidence ?? []),
+    ...proofGaps.map((record) => record.code)
+  ]);
+  return {
+    kind: 'frontier.lang.authoredGateAdmissionEvidenceInput',
+    version: 1,
+    schema: 'frontier.lang.authoredGateAdmissionEvidenceInput.v1',
+    id: blocks.length === 1 ? blocks[0].id : 'gateAdmissionEvidence:source',
+    blocks,
+    blockIds: ids(blocks),
+    gates,
+    evidence,
+    admissions,
+    proofGaps,
+    gateIds: ids(gates),
+    evidenceIds: ids(evidence),
+    proofEvidenceIds,
+    admissionIds: ids(admissions),
+    proofGapCodes: uniqueStrings(proofGaps.map((record) => record.code)),
+    missingEvidence,
+    summary: {
+      blockCount: blocks.length,
+      gateCount: gates.length,
+      evidenceCount: evidence.length,
+      proofEvidenceCount: proofEvidenceIds.length,
+      admissionCount: admissions.length,
+      proofGapCount: proofGaps.length,
+      missingEvidenceCount: missingEvidence.length,
+      passedGateCount: gates.filter((record) => record.status === 'passed').length,
+      failedGateCount: gates.filter((record) => record.status === 'failed').length,
+      blockedAdmissionCount: admissions.filter((record) => /blocked|missing|failed|review/.test(record.status ?? '')).length
+    },
+    claims: falseClaims(),
+    metadata: { authoredGateAdmissionBlockIds: ids(blocks) }
+  };
+}
+
+function gateRecord(name, text, authoredLine) {
+  const evidenceIds = readInlineList(text, 'evidence', 'evidenceIds');
+  return cleanRecord({
+    kind: 'frontier.lang.gateAdmissionEvidence.gate',
+    version: 1,
+    id: idFrom(text, `gate_${safeId(name)}`),
+    name,
+    gateKind: readInlineWord('kind', text) ?? readInlineWord('gateKind', text) ?? 'gate',
+    status: readInlineWord('status', text) ?? 'unknown',
+    required: readInlineFlag('required', text),
+    command: readInlineQuoted('command', text) ?? readInlineWord('command', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    language: readInlineWord('language', text) ?? readInlineWord('sourceLanguage', text),
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('language', text),
+    target: readInlineWord('target', text) ?? readInlineWord('targetLanguage', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    outputHash: readInlineWord('outputHash', text),
+    telemetryHash: readInlineWord('telemetryHash', text),
+    subjectIds: readInlineList(text, 'subject', 'subjects', 'subjectId', 'subjectIds'),
+    semanticChangeIds: readInlineList(text, 'semanticChange', 'semanticChangeId', 'semanticChangeIds'),
+    semanticEditScriptIds: readInlineList(text, 'semanticEditScript', 'semanticEditScriptId', 'semanticEditScriptIds', 'script', 'scriptIds'),
+    semanticEditReplayIds: readInlineList(text, 'semanticEditReplay', 'semanticEditReplayId', 'semanticEditReplayIds', 'replay', 'replayIds'),
+    evidenceIds,
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence'),
+    reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes'),
+    failClosed: true,
+    claims: falseClaims(),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({ authoredName: name, summary: readInlineQuoted('summary', text), ...falseClaims() })
+  });
+}
+
+function evidenceRecord(name, text, authoredLine, rowKind) {
+  return cleanRecord({
+    kind: 'frontier.lang.gateAdmissionEvidence.evidence',
+    version: 1,
+    id: idFrom(text, `evidence_${safeId(name)}`),
+    name,
+    evidenceKind: readInlineWord('kind', text) ?? 'evidence',
+    status: readInlineWord('status', text) ?? 'unknown',
+    proof: rowKind === 'proofEvidence' || readInlineFlag('proof', text),
+    path: readInlineWord('path', text),
+    hash: readInlineWord('hash', text),
+    command: readInlineQuoted('command', text) ?? readInlineWord('command', text),
+    probeId: readInlineWord('probeId', text) ?? readInlineWord('probe', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    language: readInlineWord('language', text) ?? readInlineWord('sourceLanguage', text),
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('language', text),
+    target: readInlineWord('target', text) ?? readInlineWord('targetLanguage', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    outputHash: readInlineWord('outputHash', text),
+    telemetryHash: readInlineWord('telemetryHash', text),
+    gateIds: readInlineList(text, 'gate', 'gateId', 'gateIds'),
+    admissionIds: readInlineList(text, 'admission', 'admissionId', 'admissionIds'),
+    summary: readInlineQuoted('summary', text),
+    failClosed: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({ authoredName: name, authoredRowKind: rowKind, ...falseClaims() })
+  });
+}
+
+function admissionRecord(name, text, authoredLine) {
+  const status = readInlineWord('status', text) ?? readInlineWord('admissionStatus', text) ?? 'review';
+  return cleanRecord({
+    kind: 'frontier.lang.gateAdmissionEvidence.admission',
+    version: 1,
+    id: idFrom(text, `admission_${safeId(name)}`),
+    name,
+    status,
+    action: readInlineWord('action', text) ?? readInlineWord('admissionAction', text) ?? 'review',
+    readiness: readInlineWord('readiness', text) ?? readInlineWord('admissionReadiness', text),
+    decision: readInlineWord('decision', text),
+    classification: readInlineWord('classification', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    language: readInlineWord('language', text) ?? readInlineWord('sourceLanguage', text),
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('language', text),
+    target: readInlineWord('target', text) ?? readInlineWord('targetLanguage', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    baseHash: readInlineWord('baseHash', text),
+    targetHash: readInlineWord('targetHash', text),
+    gateIds: readInlineList(text, 'gate', 'gateId', 'gateIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence'),
+    conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'),
+    reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes', 'reason', 'reasons'),
+    semanticEditScriptIds: readInlineList(text, 'semanticEditScript', 'semanticEditScriptId', 'semanticEditScriptIds', 'script', 'scriptIds'),
+    semanticEditReplayIds: readInlineList(text, 'semanticEditReplay', 'semanticEditReplayId', 'semanticEditReplayIds', 'replay', 'replayIds'),
+    reviewRequired: true,
+    failClosed: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({ authoredName: name, summary: readInlineQuoted('summary', text), ...falseClaims() })
+  });
+}
+
+function proofGapRecord(name, text, authoredLine) {
+  const code = readInlineWord('code', text) ?? name;
+  return cleanRecord({
+    kind: 'frontier.lang.gateAdmissionEvidence.proofGap',
+    version: 1,
+    id: idFrom(text, `gate_admission_gap_${safeId(code)}`),
+    name,
+    code,
+    status: readInlineWord('status', text) ?? 'missing',
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    gateIds: readInlineList(text, 'gate', 'gateId', 'gateIds'),
+    admissionIds: readInlineList(text, 'admission', 'admissionId', 'admissionIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    summary: readInlineQuoted('summary', text) ?? readInlineQuoted('message', text),
+    failClosed: true,
+    ...falseClaims(),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({ authoredName: name, ...falseClaims() })
+  });
+}
+
+function readAuthoredLines(block) {
+  const lines = block.body.split('\n');
+  const records = [];
+  let lineStart = block.syntax?.bodyStartOffset ?? 0;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length;
+    const leading = /^\s*/.exec(rawLine)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const startOffset = lineStart + leading;
+    const endOffset = Math.max(startOffset, rawEnd - trailing);
+    records.push({
+      text: rawLine.trim(),
+      startOffset,
+      endOffset,
+      sourceSpan: typeof block.sourceSpan === 'function' ? block.sourceSpan(startOffset, endOffset) : undefined
+    });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+
+function falseClaims() {
+  return {
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    gatePassImpliesAdmissionClaim: false
+  };
+}
+
+function ids(records = []) { return records.map((record) => record?.id).filter(Boolean); }
+function uniqueRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record?.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function uniqueStrings(values = []) { return [...new Set(values.filter(Boolean).map(String))]; }
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'GateAdmissionEvidence'; }
+function safeId(value) { return String(value ?? 'record').replace(/[^A-Za-z0-9_$-]+/g, '_'); }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(unquotedText(text))?.[1]?.trim(); }
+function readInlineQuoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function readInlineFlag(label, text) { return new RegExp('(?:^|\\s)' + label + '(?:\\s|$)').test(unquotedText(text)) || undefined; }
+function readInlineList(text, ...labels) {
+  const source = unquotedText(text);
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(source)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function unquotedText(text) { return text.replace(/"[^"]*"|'[^']*'/g, (match) => ' '.repeat(match.length)); }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0) && !(value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0)));
+}

package/dist/index.js

@@ -6,9 +6,11 @@ import { parseApplicationSurfaceBlock } from './application-surface.js';
 import { parseCanvasSurfaceBlock } from './canvas-surface.js';
 import { parseDecisionGraphBlock } from './decision-graph.js';
 import { parseDialectRegistryBlock } from './dialect-registry.js';
+import { parseGateAdmissionEvidenceBlock } from './gate-admission-evidence.js';
 import { parseInterlinguaBlock } from './interlingua.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseEntityBlock, parseStateBlock, readTypeFields } from './member-records.js';
+import { parseSemanticEditRecordsBlock } from './semantic-edit-records.js';
 import { parseSemanticOperationsBlock } from './operations.js';
 import { parsePackageManifestBlock } from './package-manifest.js';
 import { parseParadigmBlock } from './paradigm.js';
@@ -29,9 +31,11 @@ export function parseFrontierSource(source, options = {}) {
   const proofBlocks = [];
   const paradigmBlocks = [];
   const operationBlocks = [];
+  const semanticEditBlocks = [];
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
   const decisionGraphBlocks = [];
+  const gateAdmissionEvidenceBlocks = [];
   const dialectRegistryBlocks = [];
   const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
@@ -62,9 +66,11 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'proof') proofBlocks.push(parseProofBlock(block));
     if (block.kind === 'paradigm' || block.kind === 'paradigmSemantics') paradigmBlocks.push(parseParadigmBlock(block));
     if (block.kind === 'operations' || block.kind === 'semanticOperations') operationBlocks.push(parseSemanticOperationsBlock(block));
+    if (block.kind === 'semanticEdits' || block.kind === 'semanticEditRecords') semanticEditBlocks.push(parseSemanticEditRecordsBlock(block));
     if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') conversionBlocks.push(parseConversionBlock(block));
     if (block.kind === 'constraintSpace' || block.kind === 'possibilitySpace') constraintSpaceBlocks.push(parseConstraintSpaceBlock(block));
     if (block.kind === 'decisionGraph' || block.kind === 'admissionGraph') decisionGraphBlocks.push(parseDecisionGraphBlock(block));
+    if (block.kind === 'gateEvidence' || block.kind === 'admissionEvidence' || block.kind === 'routeEvidence') gateAdmissionEvidenceBlocks.push(parseGateAdmissionEvidenceBlock(block));
     if (block.kind === 'dialectRegistry' || block.kind === 'universalDialectRegistry') dialectRegistryBlocks.push(parseDialectRegistryBlock(block));
     if (block.kind === 'interlingua' || block.kind === 'universalInterlingua') interlinguaBlocks.push(parseInterlinguaBlock(block));
     if (block.kind === 'resourceGraph' || block.kind === 'semanticResourceGraph') resourceGraphBlocks.push(parseResourceGraphBlock(block));
@@ -73,7 +79,7 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'applicationSurface' || block.kind === 'appHost' || block.kind === 'plugin' || block.kind === 'pluginSurface' || block.kind === 'pluginContract') applicationSurfaceBlocks.push(parseApplicationSurfaceBlock(block));
     if (block.kind === 'runtimeCapabilities' || block.kind === 'runtimeCapabilityMatrix' || block.kind === 'runtimeHosts') runtimeCapabilityBlocks.push(parseRuntimeCapabilityBlock(block));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks, runtimeCapabilityBlocks, targetProjectionTargets });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, semanticEditBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, gateAdmissionEvidenceBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks, runtimeCapabilityBlocks, targetProjectionTargets });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 

package/dist/metadata.js

@@ -3,6 +3,8 @@ import { mergeApplicationSurfaceBlocks } from './application-surface.js';
 import { mergeRuntimeCapabilityBlocks } from './runtime-capability.js';
 import { mergeTargetProjectionTargets } from './target-projection-aggregate.js';
 import { mergeConversionBlocks } from './conversion-metadata.js';
+import { mergeSemanticEditBlocks } from './semantic-edit-metadata.js';
+import { mergeGateAdmissionEvidenceBlocks } from './gate-admission-evidence.js';
 
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
@@ -11,14 +13,16 @@ const PARADIGM_GROUPS = [
   'clockModels', 'objectModels', 'macroExpansions', 'reflectionBoundaries', 'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [], runtimeCapabilityBlocks = [], targetProjectionTargets = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], semanticEditBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], gateAdmissionEvidenceBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [], runtimeCapabilityBlocks = [], targetProjectionTargets = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
   if (operationBlocks.length) metadata.semanticOperations = mergeOperationBlocks(operationBlocks);
+  if (semanticEditBlocks.length) metadata.semanticEditRecords = mergeSemanticEditBlocks(semanticEditBlocks);
   if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
   if (constraintSpaceBlocks.length) metadata.constraintSpaces = mergeConstraintSpaceBlocks(constraintSpaceBlocks);
   if (decisionGraphBlocks.length) metadata.decisionGraph = mergeDecisionGraphBlocks(decisionGraphBlocks);
+  if (gateAdmissionEvidenceBlocks.length) metadata.gateAdmissionEvidence = mergeGateAdmissionEvidenceBlocks(gateAdmissionEvidenceBlocks);
   if (dialectRegistryBlocks.length) metadata.dialects = mergeDialectRegistryBlocks(dialectRegistryBlocks);
   if (interlinguaBlocks.length) metadata.universalInterlingua = mergeInterlinguaBlocks(interlinguaBlocks);
   if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);

package/dist/semantic-edit-metadata.js

@@ -0,0 +1,51 @@
+export function mergeSemanticEditBlocks(blocks) {
+  const scripts = blocks.flatMap((block) => block.scripts ?? []);
+  const projections = blocks.flatMap((block) => block.projections ?? []);
+  const replays = blocks.flatMap((block) => block.replays ?? []);
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'semanticEditRecords:source',
+    scripts,
+    projections,
+    replays,
+    scriptIds: ids(scripts),
+    projectionIds: ids(projections),
+    replayIds: ids(replays),
+    evidenceIds: uniqueStrings([
+      ...scripts.flatMap((record) => record.evidenceIds ?? []),
+      ...projections.flatMap((record) => record.evidenceIds ?? []),
+      ...replays.flatMap((record) => record.evidenceIds ?? [])
+    ]),
+    operationIds: uniqueStrings([
+      ...scripts.flatMap((record) => (record.operations ?? []).map((operation) => operation.id)),
+      ...projections.flatMap((record) => (record.edits ?? []).map((edit) => edit.operationId)),
+      ...replays.flatMap((record) => (record.edits ?? []).map((edit) => edit.operationId)),
+      ...replays.flatMap((record) => record.appliedOperations ?? []),
+      ...replays.flatMap((record) => record.skippedOperations ?? [])
+    ]),
+    sourceMapIds: uniqueStrings([
+      ...scripts.flatMap((record) => record.sourceMapIds ?? []),
+      ...projections.flatMap((record) => record.sourceMapIds ?? [])
+    ]),
+    sourceMapLinkIds: uniqueStrings([
+      ...scripts.flatMap((record) => record.sourceMapLinkIds ?? []),
+      ...projections.flatMap((record) => record.sourceMapLinkIds ?? [])
+    ]),
+    sourceMapMappingIds: uniqueStrings([
+      ...scripts.flatMap((record) => record.sourceMapMappingIds ?? []),
+      ...projections.flatMap((record) => record.sourceMapMappingIds ?? [])
+    ]),
+    summary: {
+      scriptCount: scripts.length,
+      projectionCount: projections.length,
+      replayCount: replays.length,
+      operationCount: scripts.reduce((sum, record) => sum + (record.operations?.length ?? 0), 0),
+      projectionEditCount: projections.reduce((sum, record) => sum + (record.edits?.length ?? 0), 0),
+      replayEditCount: replays.reduce((sum, record) => sum + (record.edits?.length ?? 0), 0)
+    },
+    claims: { autoMergeClaim: false, semanticEquivalenceClaim: false },
+    metadata: { authoredSemanticEditBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
+function ids(records = []) { return records.map((record) => record?.id).filter(Boolean); }
+function uniqueStrings(values = []) { return [...new Set(values.filter(Boolean).map(String))]; }

package/dist/semantic-edit-records.js

@@ -0,0 +1,320 @@
+export function parseSemanticEditRecordsBlock(block) {
+  const name = nameFrom(block.header);
+  const recordSet = {
+    id: idFrom(block.header, `semanticEditRecords_${name}`),
+    scripts: [],
+    projections: [],
+    replays: [],
+    metadata: { name }
+  };
+  for (const authoredLine of readAuthoredLines(block)) {
+    const line = authoredLine.text;
+    if (!line || line.startsWith('#')) continue;
+    const match = /^(script|semanticEditScript|projection|semanticEditProjection|replay|semanticEditReplay)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, kind, rowName, text] = match;
+    if (kind === 'script' || kind === 'semanticEditScript') {
+      recordSet.scripts.push(parseSemanticEditScript(rowName, text, authoredLine));
+    } else if (kind === 'projection' || kind === 'semanticEditProjection') {
+      recordSet.projections.push(parseSemanticEditProjection(rowName, text, authoredLine));
+    } else {
+      recordSet.replays.push(parseSemanticEditReplay(rowName, text, authoredLine));
+    }
+  }
+  return recordSet;
+}
+
+function parseSemanticEditScript(name, text, authoredLine) {
+  const operation = semanticEditOperationRecord(text, authoredLine);
+  const status = readInlineWord('status', text) ?? readInlineWord('admissionStatus', text) ?? 'evidence-only';
+  const sourceBackprojectionMode = readInlineWord('sourceBackprojection', text) ?? readInlineWord('sourceBackprojectionMode', text);
+  const evidenceIds = readInlineList(text, 'evidence', 'evidenceIds');
+  return cleanRecord({
+    kind: 'frontier.lang.semanticEditScript',
+    version: 1,
+    schema: 'frontier.lang.semanticEditScript.v1',
+    id: idFrom(text, `semantic_edit_script_${name}`),
+    stableId: readInlineWord('stableId', text),
+    hash: readInlineWord('hash', text) ?? readInlineWord('editScriptHash', text) ?? readInlineWord('scriptHash', text),
+    name,
+    language: readInlineWord('language', text),
+    target: readInlineWord('target', text),
+    targetLanguage: readInlineWord('targetLanguage', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    targetPath: readInlineWord('targetPath', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    baseHash: readInlineWord('baseHash', text),
+    workerHash: readInlineWord('workerHash', text),
+    headHash: readInlineWord('headHash', text),
+    workerChangeSetId: readInlineWord('workerChangeSet', text) ?? readInlineWord('workerChangeSetId', text),
+    headChangeSetId: readInlineWord('headChangeSet', text) ?? readInlineWord('headChangeSetId', text),
+    lineageInferenceId: readInlineWord('lineageInference', text) ?? readInlineWord('lineageInferenceId', text),
+    operations: operation ? [operation] : [],
+    summary: cleanRecord({ operations: operation ? 1 : 0, status }),
+    admission: semanticEditAdmission(status, readInlineWord('action', text) ?? readInlineWord('admissionAction', text), text, evidenceIds),
+    evidence: evidenceIds?.map((id) => ({ id })),
+    evidenceIds,
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMaps', 'sourceMapIds'),
+    sourceMapLinkIds: readInlineList(text, 'sourceMapLink', 'sourceMapLinks', 'sourceMapLinkIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingIds'),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceBackprojectionMode,
+      sourceBackprojection: sourceBackprojectionMode ? { mode: sourceBackprojectionMode } : undefined,
+      authoredSourceSpan: authoredLine.sourceSpan,
+      summary: readInlineQuoted('summary', text)
+    })
+  });
+}
+
+function parseSemanticEditProjection(name, text, authoredLine) {
+  const edit = semanticEditProjectionEditRecord(text, authoredLine);
+  const status = readInlineWord('status', text) ?? 'blocked';
+  const evidenceIds = readInlineList(text, 'evidence', 'evidenceIds');
+  return cleanRecord({
+    kind: 'frontier.lang.semanticEditProjection',
+    version: 1,
+    schema: 'frontier.lang.semanticEditProjection.v1',
+    id: idFrom(text, `semantic_edit_projection_${name}`),
+    hash: readInlineWord('hash', text) ?? readInlineWord('projectionHash', text),
+    name,
+    scriptId: readInlineWord('script', text) ?? readInlineWord('scriptId', text) ?? readInlineWord('semanticEditScript', text) ?? readInlineWord('semanticEditScriptId', text),
+    language: readInlineWord('language', text),
+    target: readInlineWord('target', text),
+    targetLanguage: readInlineWord('targetLanguage', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    targetPath: readInlineWord('targetPath', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    status,
+    baseHash: readInlineWord('baseHash', text),
+    workerHash: readInlineWord('workerHash', text),
+    headHash: readInlineWord('headHash', text),
+    projectedHash: readInlineWord('projectedHash', text) ?? readInlineWord('targetHash', text),
+    appliedOperations: edit?.operationId ? [edit.operationId] : [],
+    skippedOperations: [],
+    edits: edit ? [edit] : [],
+    admission: {
+      status: readInlineWord('admissionStatus', text) ?? (status === 'projected' ? 'auto-merge-candidate' : 'blocked'),
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes') ?? []
+    },
+    evidenceIds,
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMaps', 'sourceMapIds'),
+    sourceMapLinkIds: readInlineList(text, 'sourceMapLink', 'sourceMapLinks', 'sourceMapLinkIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingIds'),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceBackprojectionMode: readInlineWord('sourceBackprojection', text) ?? readInlineWord('sourceBackprojectionMode', text),
+      authoredSourceSpan: authoredLine.sourceSpan,
+      summary: readInlineQuoted('summary', text)
+    })
+  });
+}
+
+function parseSemanticEditReplay(name, text, authoredLine) {
+  const edit = semanticEditReplayEditRecord(text, authoredLine);
+  const status = readInlineWord('status', text) ?? readInlineWord('replayStatus', text) ?? 'blocked';
+  const action = readInlineWord('action', text) ?? readInlineWord('replayAction', text) ?? readInlineWord('admissionAction', text) ?? 'human-review';
+  const reasonCodes = readInlineList(text, 'reasonCode', 'reasonCodes') ?? [];
+  const evidenceIds = readInlineList(text, 'evidence', 'evidenceIds');
+  const applied = edit && (status === 'accepted-clean' || status === 'already-applied' || action === 'apply') ? [edit.operationId].filter(Boolean) : [];
+  const skipped = edit && !applied.length ? [edit.operationId].filter(Boolean) : [];
+  return cleanRecord({
+    kind: 'frontier.lang.semanticEditReplay',
+    version: 1,
+    schema: 'frontier.lang.semanticEditReplay.v1',
+    id: idFrom(text, `semantic_edit_replay_${name}`),
+    hash: readInlineWord('hash', text) ?? readInlineWord('replayHash', text),
+    name,
+    projectionId: readInlineWord('projection', text) ?? readInlineWord('projectionId', text) ?? readInlineWord('semanticEditProjection', text) ?? readInlineWord('semanticEditProjectionId', text),
+    scriptId: readInlineWord('script', text) ?? readInlineWord('scriptId', text) ?? readInlineWord('semanticEditScript', text) ?? readInlineWord('semanticEditScriptId', text),
+    language: readInlineWord('language', text),
+    target: readInlineWord('target', text),
+    targetLanguage: readInlineWord('targetLanguage', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    targetPath: readInlineWord('targetPath', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    routeIds: readInlineList(text, 'routeIds'),
+    currentHash: readInlineWord('currentHash', text) ?? readInlineWord('replayCurrentHash', text),
+    projectedHash: readInlineWord('projectedHash', text) ?? readInlineWord('targetHash', text),
+    outputHash: readInlineWord('outputHash', text) ?? readInlineWord('replayOutputHash', text),
+    status,
+    edits: edit ? [edit] : [],
+    appliedOperations: applied,
+    skippedOperations: skipped,
+    admission: {
+      status,
+      action,
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: replaySummary(edit, status, reasonCodes),
+    evidenceIds,
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceBackprojectionMode: readInlineWord('sourceBackprojection', text) ?? readInlineWord('sourceBackprojectionMode', text),
+      authoredSourceSpan: authoredLine.sourceSpan,
+      summary: readInlineQuoted('summary', text)
+    })
+  });
+}
+
+function semanticEditOperationRecord(text, authoredLine) {
+  const operationId = readInlineWord('operation', text) ?? readInlineWord('operationId', text) ?? readInlineWord('op', text);
+  if (!operationId) return undefined;
+  const sourceBackprojectionMode = readInlineWord('sourceBackprojection', text) ?? readInlineWord('sourceBackprojectionMode', text);
+  return cleanRecord({
+    id: operationId,
+    kind: readInlineWord('operationKind', text) ?? readInlineWord('kind', text),
+    changeKind: readInlineWord('changeKind', text),
+    semanticKey: readInlineWord('semanticKey', text),
+    semanticIdentityHash: readInlineWord('semanticIdentityHash', text),
+    sourceIdentityHash: readInlineWord('sourceIdentityHash', text),
+    operationContentHash: readInlineWord('operationContentHash', text),
+    editContentHash: readInlineWord('editContentHash', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    symbolId: readInlineWord('symbolId', text),
+    symbolName: readInlineWord('symbolName', text),
+    symbolKind: readInlineWord('symbolKind', text),
+    anchor: cleanRecord({
+      key: readInlineWord('anchorKey', text) ?? readInlineWord('ownerKey', text) ?? readInlineWord('ownershipKey', text) ?? readInlineWord('semanticKey', text),
+      conflictKey: readInlineWord('conflictKey', text),
+      regionId: readInlineWord('region', text) ?? readInlineWord('regionId', text),
+      regionKind: readInlineWord('regionKind', text),
+      sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+      symbolId: readInlineWord('symbolId', text),
+      symbolName: readInlineWord('symbolName', text),
+      symbolKind: readInlineWord('symbolKind', text)
+    }),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes'),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    metadata: cleanRecord({
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      sourceBackprojection: sourceBackprojectionMode ? { mode: sourceBackprojectionMode } : undefined
+    })
+  });
+}
+
+function semanticEditProjectionEditRecord(text, authoredLine) {
+  const operationId = readInlineWord('edit', text) ?? readInlineWord('operation', text) ?? readInlineWord('operationId', text);
+  if (!operationId) return undefined;
+  return cleanRecord({
+    operationId,
+    status: readInlineWord('editStatus', text) ?? 'applied',
+    kind: readInlineWord('kind', text),
+    editKind: readInlineWord('editKind', text),
+    changeKind: readInlineWord('changeKind', text),
+    anchorKey: readInlineWord('anchorKey', text) ?? readInlineWord('ownerKey', text) ?? readInlineWord('semanticKey', text),
+    conflictKey: readInlineWord('conflictKey', text),
+    regionId: readInlineWord('region', text) ?? readInlineWord('regionId', text),
+    regionKind: readInlineWord('regionKind', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    targetSourcePath: readInlineWord('targetPath', text),
+    symbolId: readInlineWord('symbolId', text),
+    symbolName: readInlineWord('symbolName', text),
+    symbolKind: readInlineWord('symbolKind', text),
+    semanticKey: readInlineWord('semanticKey', text),
+    semanticIdentityHash: readInlineWord('semanticIdentityHash', text),
+    sourceIdentityHash: readInlineWord('sourceIdentityHash', text),
+    operationContentHash: readInlineWord('operationContentHash', text),
+    editContentHash: readInlineWord('editContentHash', text),
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan,
+    reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes')
+  });
+}
+
+function semanticEditReplayEditRecord(text, authoredLine) {
+  const operationId = readInlineWord('edit', text) ?? readInlineWord('operation', text) ?? readInlineWord('operationId', text);
+  if (!operationId) return undefined;
+  return cleanRecord({
+    operationId,
+    status: readInlineWord('editStatus', text) ?? readInlineWord('status', text) ?? 'blocked',
+    semanticKey: readInlineWord('semanticKey', text),
+    semanticIdentityHash: readInlineWord('semanticIdentityHash', text),
+    sourceIdentityHash: readInlineWord('sourceIdentityHash', text),
+    operationContentHash: readInlineWord('operationContentHash', text),
+    editContentHash: readInlineWord('editContentHash', text),
+    editKind: readInlineWord('editKind', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    symbolName: readInlineWord('symbolName', text),
+    symbolKind: readInlineWord('symbolKind', text),
+    reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes') ?? [],
+    sourceSpan: authoredLine.sourceSpan,
+    authoredSourceSpan: authoredLine.sourceSpan
+  });
+}
+
+function semanticEditAdmission(status, action, text, evidenceIds = []) {
+  return {
+    status,
+    action: action ?? 'record-evidence',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: readInlineList(text, 'reasonCode', 'reasonCodes') ?? [],
+    conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys') ?? [],
+    evidenceIds
+  };
+}
+
+function replaySummary(edit, status, reasonCodes) {
+  return { edits: edit ? 1 : 0, applied: status === 'accepted-clean' ? 1 : 0, alreadyApplied: status === 'already-applied' ? 1 : 0, conflicts: status === 'conflict' ? 1 : 0, stale: status === 'stale' ? 1 : 0, blocked: status === 'blocked' ? 1 : 0, reasonCodes };
+}
+
+function readAuthoredLines(block) {
+  const lines = block.body.split('\n');
+  const records = [];
+  let lineStart = block.syntax?.bodyStartOffset ?? 0;
+  for (const rawLine of lines) {
+    const rawEnd = lineStart + rawLine.length;
+    const leading = /^\s*/.exec(rawLine)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(rawLine)?.[0].length ?? 0;
+    const startOffset = lineStart + leading;
+    const endOffset = Math.max(startOffset, rawEnd - trailing);
+    records.push({
+      text: rawLine.trim(),
+      startOffset,
+      endOffset,
+      sourceSpan: typeof block.sourceSpan === 'function' ? block.sourceSpan(startOffset, endOffset) : undefined
+    });
+    lineStart = rawEnd + 1;
+  }
+  return records;
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'SemanticEditRecords'; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(unquotedText(text))?.[1]?.trim(); }
+function readInlineQuoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function readInlineList(text, ...labels) {
+  const source = unquotedText(text);
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(source)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function unquotedText(text) { return text.replace(/"[^"]*"|'[^']*'/g, (match) => ' '.repeat(match.length)); }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0) && !(value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0)));
+}

package/dist/source-block-kinds.js

@@ -16,12 +16,17 @@ export const FrontierSourceBlockKinds = Object.freeze([
   'paradigmSemantics',
   'operations',
   'semanticOperations',
+  'semanticEdits',
+  'semanticEditRecords',
   'conversion',
   'universalConversionPlan',
   'constraintSpace',
   'possibilitySpace',
   'decisionGraph',
   'admissionGraph',
+  'gateEvidence',
+  'admissionEvidence',
+  'routeEvidence',
   'dialectRegistry',
   'universalDialectRegistry',
   'interlingua',

package/dist/source-syntax-row-config.js

@@ -5,6 +5,8 @@ const dialectRows = words('dialect record extern');
 const interlinguaRows = words('layer constraint edge obligation proofObligation proof lowering lower source sourceLift lift evidence');
 const packageRows = words('metadata dependency script export gap proofGap evidence proofEvidence');
 const runtimeRows = words('host runtimeHost hostProfile sourceHost targetHost capability hostCapability hostBinding binding requirement runtimeRequirement requiredRuntime evidence proofEvidence gap proofGap');
+const semanticEditRows = words('script semanticEditScript projection semanticEditProjection replay semanticEditReplay');
+const gateAdmissionRows = words('gate evidence proofEvidence admission admissionDecision gap proofGap');
 
 export const ROW_SYNTAX_CONFIG = Object.freeze({
   interlingua: rowConfig('interlinguaRow', 'interlingua_row', interlinguaRows, normalizeInterlinguaRow),
@@ -31,8 +33,13 @@ export const ROW_SYNTAX_CONFIG = Object.freeze({
   possibilitySpace: rowConfig('constraintSpaceRow', 'constraint_space_row', constraintRows, normalizeConstraintSpaceRow),
   decisionGraph: rowConfig('decisionGraphRow', 'decision_graph_row', words('node edge chunk gate evidence semanticChange change patchEvent patch admissionDecision admission candidateDecision candidate mergeDecision merge replay tournament tournamentCandidate panelProjection panel rsiLoop improvementFeedback feedback'), normalizeDecisionGraphRow),
   admissionGraph: rowConfig('decisionGraphRow', 'decision_graph_row', words('node edge chunk gate evidence semanticChange change patchEvent patch admissionDecision admission candidateDecision candidate mergeDecision merge replay tournament tournamentCandidate panelProjection panel rsiLoop improvementFeedback feedback'), normalizeDecisionGraphRow),
+  gateEvidence: rowConfig('gateAdmissionEvidenceRow', 'gate_admission_evidence_row', gateAdmissionRows, normalizeGateAdmissionRow),
+  admissionEvidence: rowConfig('gateAdmissionEvidenceRow', 'gate_admission_evidence_row', gateAdmissionRows, normalizeGateAdmissionRow),
+  routeEvidence: rowConfig('gateAdmissionEvidenceRow', 'gate_admission_evidence_row', gateAdmissionRows, normalizeGateAdmissionRow),
   operations: rowConfig('semanticOperationRow', 'semantic_operation_row', words('operation op'), normalizeOperationRow),
   semanticOperations: rowConfig('semanticOperationRow', 'semantic_operation_row', words('operation op'), normalizeOperationRow),
+  semanticEdits: rowConfig('semanticEditRecordRow', 'semantic_edit_record_row', semanticEditRows, normalizeSemanticEditRow),
+  semanticEditRecords: rowConfig('semanticEditRecordRow', 'semantic_edit_record_row', semanticEditRows, normalizeSemanticEditRow),
   paradigm: rowConfig('paradigmRow', 'paradigm_row', words('valueSemantics mutationModel effectModel ownership ownershipModel lifetime lifetimeModel bindingScope binding dispatch typeModel moduleModel concurrency errorModel memoryModel evaluation metaprogramming interop lowering'), normalizeParadigmRow),
   paradigmSemantics: rowConfig('paradigmRow', 'paradigm_row', words('valueSemantics mutationModel effectModel ownership ownershipModel lifetime lifetimeModel bindingScope binding dispatch typeModel moduleModel concurrency errorModel memoryModel evaluation metaprogramming interop lowering'), normalizeParadigmRow),
   proof: rowConfig('proofRow', 'proof_row', words('contract refinement invariant termination temporal obligation artifact assumption')),
@@ -118,6 +125,20 @@ function normalizeOperationRow(rowKind) {
   return rowKind;
 }
 
+function normalizeSemanticEditRow(rowKind) {
+  if (rowKind === 'semanticEditScript') return 'script';
+  if (rowKind === 'semanticEditProjection') return 'projection';
+  if (rowKind === 'semanticEditReplay') return 'replay';
+  return rowKind;
+}
+
+function normalizeGateAdmissionRow(rowKind) {
+  if (rowKind === 'proofEvidence') return 'evidence';
+  if (rowKind === 'admissionDecision') return 'admission';
+  if (rowKind === 'gap') return 'proofGap';
+  return rowKind;
+}
+
 function normalizeParadigmRow(rowKind) {
   if (rowKind === 'ownership') return 'ownershipModel';
   if (rowKind === 'lifetime') return 'lifetimeModel';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.68",
+  "version": "0.3.70",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",