@shapeshift-labs/frontier-lang-parser 0.3.17 → 0.3.19

package/README.md

@@ -220,6 +220,29 @@ npm install @shapeshift-labs/frontier-lang-parser
 
 The parser projects text into `@shapeshift-labs/frontier-lang-kernel` documents. The syntax is intentionally small and experimental.
 
+## Authored decision graph syntax
+
+`.frontier` files can carry semantic merge admission evidence directly in `decisionGraph` or `admissionGraph` blocks. These blocks preserve the causal review shape around a candidate edit: semantic changes, gates, evidence records, patch events, admission decisions, merge decisions, graph nodes, and graph edges.
+
+```frontier
+decisionGraph TodoAdmission @id("decision_graph_todo") {
+  graphKind semantic-merge-admission
+  scope mod_todo
+  root merge_decision_title
+  subject action_add,field_title
+  node change @id("decision_node_change") kind semantic-change record semantic_change_title label "Title change" status passed
+  edge changeToGate @id("decision_edge_change_gate") from semantic_change_title to gate_typecheck kind gates status passed
+  change title @id("semantic_change_title") kind source-edit language typescript sourcePath src/todo.ts semanticNode field_title semanticSymbol symbol:Todo.title evidence evidence_typecheck
+  gate typecheck @id("gate_typecheck") kind typecheck status passed required command "npm run typecheck" semanticChange semantic_change_title evidence evidence_typecheck
+  evidence typecheck @id("evidence_typecheck") kind test status passed path reports/typecheck.json gate gate_typecheck semanticChange semantic_change_title
+  patchEvent workerPatch @id("patch_event_worker") patch patch_worker status passed baseHash h_base targetHash h_worker semanticChange semantic_change_title gate gate_typecheck evidence evidence_typecheck deterministic
+  admission titleSafe @id("admission_title_safe") candidate candidate_todo_title semanticChange semantic_change_title classification safe decision merge autoMergeable gate gate_typecheck evidence evidence_typecheck
+  merge titleMerge @id("merge_decision_title") candidate candidate_todo_title semanticChange semantic_change_title admissionDecision admission_title_safe decision merge autoMergeable gate gate_typecheck evidence evidence_typecheck
+}
+```
+
+The parser projects these rows into `metadata.decisionGraph`. Decision graph records are normalized by the kernel helpers, so authored files can describe why a merge is admissible without embedding raw JSON. This is intentionally evidence-first: a safe merge can be represented as a graph of changes, gates, evidence, and decisions, while missing proof can remain explicit as blocked or review-required records.
+
 ## Authored conversion syntax
 
 `.frontier` files can carry universal conversion evidence directly in `conversion` or `universalConversionPlan` blocks. The parser projects these records into `metadata.universalConversionPlan` for the compiler facade and downstream semantic merge tooling.
@@ -239,6 +262,27 @@ conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
 
 `sourceRuntime` and `targetRuntime` become runtime maps. `runtimeRequirement` rows become proof obligations for host/runtime capabilities, including authored `requiredSignals` denominators such as source hashes, target hashes, probe ids, runtime commands, telemetry hashes, and capability-specific trace hashes. `proofEvidence` and `evidence` attach evidence ids, but the compiler still requires bound evidence records before a proof obligation is satisfied. `dialect` and `extern` rows preserve dialect-specific constructs, projection readiness, loss/evidence ids, and binding metadata without requiring the authored Frontier file to drop down to raw JSON.
 
+## Authored possibility spaces
+
+`.frontier` files can describe a governed space of valid implementations with `constraintSpace` or `possibilitySpace` blocks. These blocks are metadata-only: they do not add kernel nodes, but they preserve the variables, hard constraints, preferences, collapse strategies, and admission rules that let tools reason about semantic merge, translation, refactoring, and runtime projection as constraint satisfaction.
+
+```frontier
+possibilitySpace CheckoutSurface @id("space_checkout_surface") {
+  subject action_checkout
+  scope mod_checkout
+  target react
+  target swiftui
+  variable surface @id("space_variable_surface") kind projection domain react|swiftui|html-css-js default react preserve identity|event-flow
+  hard identity @id("space_constraint_identity") kind semantic-identity family identity subject action_checkout requires action|state|effect failClosed
+  soft bundleSize @id("space_constraint_bundle_size") kind bundle-budget family runtime target react predicate "bundle < 50kb"
+  preference nativeControls @id("space_preference_native_controls") kind platform-idiom target swiftui weight 0.8 reason "prefer native controls on iOS"
+  collapse mobileCheckout @id("space_collapse_mobile_checkout") strategy evidence-first target swiftui requires identity|runtime-proof produces view_checkout_mobile
+  admission mergeSafe @id("space_admission_merge_safe") kind semantic-merge status open requires hardConstraints|runtimeProof decision review failClosed
+}
+```
+
+The parser projects these blocks into `metadata.constraintSpaces`. Hard and soft constraints remain separate from preferences: hard constraints define validity, while preferences help choose among several valid shapes. `collapse` rows describe how a tool may choose a concrete projection, and `admission` rows describe what proof is required before a generated or merged shape should be accepted.
+
 ## Authored native source evidence
 
 `nativeSource` blocks can also carry source-bound merge evidence. This keeps parser/source-map/merge-candidate facts in `.frontier` text instead of requiring a raw JSON sidecar for the first authored program slice.

package/dist/constraint-space.js

@@ -0,0 +1,152 @@
+export function parseConstraintSpaceBlock(block) {
+  const name = nameFrom(block.header);
+  const space = {
+    id: idFrom(block.header, `constraint_space_${name}`),
+    name,
+    targets: [],
+    variables: [],
+    constraints: [],
+    preferences: [],
+    collapseStrategies: [],
+    admissions: [],
+    metadata: { name }
+  };
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const target = /^target\s+([^\s,]+)/.exec(line)?.[1];
+    const subject = /^subject\s+([^\s,]+)/.exec(line)?.[1];
+    const scope = /^scope\s+([^\s,]+)/.exec(line)?.[1];
+    const record = /^(variable|var|constraint|hard|soft|preference|prefer|collapse|admission)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (target) space.targets.push(target);
+    else if (subject) space.subjectId = subject;
+    else if (scope) space.scopeId = scope;
+    else if (record) addConstraintSpaceRecord(space, record[1], record[2], record[3]);
+  }
+  return cleanRecord({
+    ...space,
+    targets: unique(space.targets),
+    summary: {
+      variableCount: space.variables.length,
+      constraintCount: space.constraints.length,
+      preferenceCount: space.preferences.length,
+      collapseStrategyCount: space.collapseStrategies.length,
+      admissionCount: space.admissions.length
+    }
+  });
+}
+
+function addConstraintSpaceRecord(space, section, name, text) {
+  if (section === 'variable' || section === 'var') space.variables.push(parseVariable(name, text));
+  else if (section === 'constraint' || section === 'hard' || section === 'soft') space.constraints.push(parseConstraint(name, text, section));
+  else if (section === 'preference' || section === 'prefer') space.preferences.push(parsePreference(name, text));
+  else if (section === 'collapse') space.collapseStrategies.push(parseCollapseStrategy(name, text));
+  else if (section === 'admission') space.admissions.push(parseAdmission(name, text));
+}
+
+function parseVariable(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `constraint_space_variable_${name}`),
+    name,
+    kind: readInlineWord('kind', text),
+    domain: readInlineList(text, 'domain', 'choices', 'values'),
+    default: readInlineWord('default', text),
+    subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text),
+    sourceId: readInlineWord('source', text) ?? readInlineWord('sourceId', text),
+    target: readInlineWord('target', text),
+    preserve: readInlineList(text, 'preserve', 'preserves'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    metadata: { name }
+  });
+}
+
+function parseConstraint(name, text, section) {
+  return cleanRecord({
+    id: idFrom(text, `constraint_space_constraint_${name}`),
+    name,
+    kind: readInlineWord('kind', text),
+    strength: readInlineWord('strength', text) ?? (section === 'hard' ? 'hard' : section === 'soft' ? 'soft' : undefined),
+    family: readInlineWord('family', text),
+    subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text),
+    variableIds: readInlineList(text, 'variable', 'variables', 'variableIds'),
+    target: readInlineWord('target', text),
+    predicate: readInlineQuoted('predicate', text) ?? readInlineWord('predicate', text),
+    requires: readInlineList(text, 'requires', 'required', 'require'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    proofObligationIds: readInlineList(text, 'proofObligation', 'proofObligations', 'proofObligationIds'),
+    conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'),
+    failClosed: readInlineFlag('failClosed', text),
+    metadata: { name }
+  });
+}
+
+function parsePreference(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `constraint_space_preference_${name}`),
+    name,
+    kind: readInlineWord('kind', text),
+    weight: readNumber(readInlineWord('weight', text)),
+    subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text),
+    variableIds: readInlineList(text, 'variable', 'variables', 'variableIds'),
+    target: readInlineWord('target', text),
+    prefer: readInlineList(text, 'prefer', 'prefers'),
+    reason: readInlineQuoted('reason', text) ?? readInlineWord('reason', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    metadata: { name }
+  });
+}
+
+function parseCollapseStrategy(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `constraint_space_collapse_${name}`),
+    name,
+    strategy: readInlineWord('strategy', text) ?? readInlineWord('kind', text),
+    target: readInlineWord('target', text),
+    variableIds: readInlineList(text, 'variable', 'variables', 'variableIds'),
+    requires: readInlineList(text, 'requires', 'required', 'require'),
+    produces: readInlineList(text, 'produces', 'produce', 'outputs', 'output'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    admissionIds: readInlineList(text, 'admission', 'admissions', 'admissionIds'),
+    status: readInlineWord('status', text),
+    metadata: { name }
+  });
+}
+
+function parseAdmission(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `constraint_space_admission_${name}`),
+    name,
+    kind: readInlineWord('kind', text),
+    status: readInlineWord('status', text),
+    subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text),
+    target: readInlineWord('target', text),
+    requires: readInlineList(text, 'requires', 'required', 'require'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    decision: readInlineWord('decision', text),
+    reason: readInlineQuoted('reason', text) ?? readInlineWord('reason', text),
+    failClosed: readInlineFlag('failClosed', text),
+    metadata: { name }
+  });
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'ConstraintSpace'; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(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(text) || undefined; }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function readNumber(value) {
+  if (value === undefined) return undefined;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : undefined;
+}
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}
+function unique(values) { return [...new Set(values.filter(Boolean))]; }

package/dist/decision-graph.js

@@ -0,0 +1,239 @@
+import {
+  createDecisionGraphAdmissionDecisionRecord,
+  createDecisionGraphCandidateDecisionRecord,
+  createDecisionGraphChunkRecord,
+  createDecisionGraphEvidenceRecord,
+  createDecisionGraphGateRecord,
+  createDecisionGraphGraphRecord,
+  createDecisionGraphImprovementFeedbackRecord,
+  createDecisionGraphMergeDecisionRecord,
+  createDecisionGraphPanelProjectionRecord,
+  createDecisionGraphPatchEventRecord,
+  createDecisionGraphReplayRecord,
+  createDecisionGraphRsiLoopRecord,
+  createDecisionGraphSemanticChangeRecord,
+  createDecisionGraphTournamentCandidateRecord,
+  createDecisionGraphTournamentRecord
+} from '@shapeshift-labs/frontier-lang-kernel';
+
+const RECORD_FIELDS = Object.freeze({
+  gate: 'gateIds',
+  evidence: 'evidenceIds',
+  semanticChange: 'semanticChangeIds',
+  patchEvent: 'patchEventIds',
+  admissionDecision: 'admissionDecisionIds',
+  candidateDecision: 'decisionIds',
+  mergeDecision: 'decisionIds',
+  replay: 'replayRecordIds',
+  tournament: 'tournamentRecordIds',
+  tournamentCandidate: 'tournamentRecordIds',
+  rsiLoop: 'rsiLoopIds',
+  improvementFeedback: 'feedbackIds'
+});
+
+export function parseDecisionGraphBlock(block) {
+  const name = nameFrom(block.header);
+  const graph = {
+    id: idFrom(block.header, `decisionGraph_${name}`),
+    graphKind: readLine('graphKind', block.body) ?? readLine('kind', block.body) ?? 'semantic-merge-admission',
+    scopeId: readLine('scope', block.body) ?? readLine('scopeId', block.body),
+    rootId: readLine('root', block.body) ?? readLine('rootId', block.body),
+    status: readLine('status', block.body) ?? 'open',
+    subjectIds: readListLine('subject', block.body) ?? readListLine('subjects', block.body) ?? [],
+    nodes: [],
+    edges: [],
+    records: [],
+    metadata: { name }
+  };
+
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || isGraphPropertyLine(line)) continue;
+    const match = /^([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, rest] = match;
+    const normalized = normalizeRowKind(rowKind);
+    if (normalized === 'node') graph.nodes.push(parseNode(rowName, rest));
+    else if (normalized === 'edge') graph.edges.push(parseEdge(rowName, rest));
+    else {
+      const record = parseDecisionRecord(normalized, rowName, rest, graph.id);
+      if (record) graph.records.push(record);
+    }
+  }
+
+  const grouped = groupRecords(graph.records);
+  const graphRecord = createDecisionGraphGraphRecord({
+    id: graph.id,
+    graphKind: graph.graphKind,
+    scopeId: graph.scopeId,
+    rootId: graph.rootId,
+    status: graph.status,
+    subjectIds: graph.subjectIds,
+    recordIds: graph.records.map((record) => record.id),
+    nodeIds: graph.nodes.map((node) => node.id),
+    edgeIds: graph.edges.map((edge) => edge.id),
+    semanticChangeIds: grouped.semanticChangeIds,
+    admissionDecisionIds: grouped.admissionDecisionIds,
+    decisionIds: grouped.decisionIds,
+    gateIds: grouped.gateIds,
+    evidenceIds: grouped.evidenceIds,
+    replayRecordIds: grouped.replayRecordIds,
+    patchEventIds: grouped.patchEventIds,
+    tournamentRecordIds: grouped.tournamentRecordIds,
+    rsiLoopIds: grouped.rsiLoopIds,
+    nodes: graph.nodes,
+    edges: graph.edges,
+    metadata: graph.metadata
+  });
+
+  return {
+    id: graph.id,
+    graph: graphRecord,
+    records: graph.records,
+    nodes: graph.nodes,
+    edges: graph.edges,
+    summary: {
+      graphCount: 1,
+      recordCount: graph.records.length,
+      nodeCount: graph.nodes.length,
+      edgeCount: graph.edges.length,
+      semanticChangeCount: grouped.semanticChangeIds.length,
+      gateCount: grouped.gateIds.length,
+      evidenceCount: grouped.evidenceIds.length,
+      admissionDecisionCount: grouped.admissionDecisionIds.length,
+      decisionCount: grouped.decisionIds.length,
+      patchEventCount: grouped.patchEventIds.length,
+      replayCount: grouped.replayRecordIds.length,
+      tournamentCount: grouped.tournamentRecordIds.length,
+      rsiLoopCount: grouped.rsiLoopIds.length
+    },
+    metadata: { name }
+  };
+}
+
+function parseNode(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `decision_node_${name}`),
+    nodeKind: readInlineWord('nodeKind', text) ?? readInlineWord('kind', text) ?? 'record',
+    recordId: readInlineWord('record', text) ?? readInlineWord('recordId', text),
+    label: readInlineQuoted('label', text) ?? readInlineWord('label', text) ?? name,
+    status: readInlineWord('status', text)
+  });
+}
+
+function parseEdge(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `decision_edge_${name}`),
+    edgeKind: readInlineWord('edgeKind', text) ?? readInlineWord('kind', text) ?? 'relates-to',
+    fromId: readInlineWord('from', text) ?? readInlineWord('fromId', text) ?? readInlineWord('source', text) ?? readInlineWord('sourceId', text),
+    toId: readInlineWord('to', text) ?? readInlineWord('toId', text) ?? readInlineWord('target', text) ?? readInlineWord('targetId', text),
+    status: readInlineWord('status', text)
+  });
+}
+
+function parseDecisionRecord(kind, name, text, graphId) {
+  const common = commonRecord(name, text, graphId);
+  if (kind === 'chunk') return createDecisionGraphChunkRecord({ ...common, chunkKind: readInlineWord('chunkKind', text) ?? readInlineWord('kind', text), sequence: readInlineNumber('sequence', text), recordIds: readInlineList(text, 'record', 'records', 'recordIds') });
+  if (kind === 'gate') return createDecisionGraphGateRecord({ ...common, gateKind: readInlineWord('gateKind', text) ?? readInlineWord('kind', text) ?? name, command: readInlineQuoted('command', text) ?? readInlineWord('command', text), required: readInlineFlag('required', text) });
+  if (kind === 'evidence') return createDecisionGraphEvidenceRecord({ ...common, evidenceKind: readInlineWord('evidenceKind', text) ?? readInlineWord('kind', text) ?? name, path: readInlineWord('path', text) });
+  if (kind === 'semanticChange') return createDecisionGraphSemanticChangeRecord({ ...common, changeKind: readInlineWord('changeKind', text) ?? readInlineWord('kind', text) ?? 'semantic', language: readInlineWord('language', text), sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text), baseHash: readInlineWord('baseHash', text), targetHash: readInlineWord('targetHash', text), patchIds: readInlineList(text, 'patch', 'patches', 'patchId', 'patchIds'), operationIds: readInlineList(text, 'operation', 'operations', 'operationId', 'operationIds'), semanticNodeIds: readInlineList(text, 'semanticNode', 'semanticNodes', 'semanticNodeId', 'semanticNodeIds'), semanticSymbolIds: readInlineList(text, 'semanticSymbol', 'semanticSymbols', 'symbol', 'symbols', 'semanticSymbolId', 'semanticSymbolIds'), effectIds: readInlineList(text, 'effect', 'effects', 'effectId', 'effectIds'), regions: readInlineList(text, 'region', 'regions'), risk: readInlineWord('risk', text) });
+  if (kind === 'patchEvent') return createDecisionGraphPatchEventRecord({ ...common, eventId: readInlineWord('event', text) ?? readInlineWord('eventId', text), patchId: readInlineWord('patch', text) ?? readInlineWord('patchId', text), patchIds: readInlineList(text, 'patch', 'patches', 'patchId', 'patchIds'), actor: readInlineWord('actor', text), at: readInlineWord('at', text), baseHash: readInlineWord('baseHash', text), targetHash: readInlineWord('targetHash', text), operationIds: readInlineList(text, 'operation', 'operations', 'operationId', 'operationIds'), deterministic: readInlineFlag('deterministic', text) });
+  if (kind === 'admissionDecision') return createDecisionGraphAdmissionDecisionRecord({ ...common, admissionId: readInlineWord('admission', text) ?? readInlineWord('admissionId', text), candidateId: readInlineWord('candidate', text) ?? readInlineWord('candidateId', text), classification: readInlineWord('classification', text), decision: readInlineWord('decision', text), autoMergeable: readInlineFlag('autoMergeable', text) || readInlineFlag('autoMerge', text), conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'), conflictKeyKinds: readInlineList(text, 'conflictKeyKind', 'conflictKeyKinds'), reasons: readInlineList(text, 'reason', 'reasons') });
+  if (kind === 'candidateDecision') return createDecisionGraphCandidateDecisionRecord({ ...common, candidateId: readInlineWord('candidate', text) ?? readInlineWord('candidateId', text), decision: readInlineWord('decision', text), score: readInlineNumber('score', text), rank: readInlineNumber('rank', text), reviewerIds: readInlineList(text, 'reviewer', 'reviewers', 'reviewerId', 'reviewerIds'), reasons: readInlineList(text, 'reason', 'reasons') });
+  if (kind === 'mergeDecision') return createDecisionGraphMergeDecisionRecord({ ...common, decision: readInlineWord('decision', text), autoMergeable: readInlineFlag('autoMergeable', text) || readInlineFlag('autoMerge', text), baseHash: readInlineWord('baseHash', text), targetHash: readInlineWord('targetHash', text), conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'), reasons: readInlineList(text, 'reason', 'reasons'), candidateDecisionIds: readInlineList(text, 'candidateDecision', 'candidateDecisionId', 'candidateDecisionIds') });
+  if (kind === 'replay') return createDecisionGraphReplayRecord({ ...common, eventIds: readInlineList(text, 'event', 'events', 'eventId', 'eventIds'), patchIds: readInlineList(text, 'patch', 'patches', 'patchId', 'patchIds'), baseHash: readInlineWord('baseHash', text), finalHash: readInlineWord('finalHash', text), issues: readInlineList(text, 'issue', 'issues'), replayComplete: readInlineFlag('replayComplete', text), deterministic: readInlineFlag('deterministic', text) });
+  if (kind === 'tournament') return createDecisionGraphTournamentRecord({ ...common, tournamentId: readInlineWord('tournament', text) ?? readInlineWord('tournamentId', text), tournamentKind: readInlineWord('tournamentKind', text) ?? readInlineWord('kind', text), winnerCandidateId: readInlineWord('winner', text) ?? readInlineWord('winnerCandidateId', text) });
+  if (kind === 'tournamentCandidate') return createDecisionGraphTournamentCandidateRecord({ ...common, tournamentId: readInlineWord('tournament', text) ?? readInlineWord('tournamentId', text), candidateId: readInlineWord('candidate', text) ?? readInlineWord('candidateId', text), lane: readInlineWord('lane', text), taskId: readInlineWord('task', text) ?? readInlineWord('taskId', text), agentId: readInlineWord('agent', text) ?? readInlineWord('agentId', text), score: readInlineNumber('score', text), rank: readInlineNumber('rank', text) });
+  if (kind === 'panelProjection') return createDecisionGraphPanelProjectionRecord({ ...common, panelId: readInlineWord('panel', text) ?? readInlineWord('panelId', text), projectionKind: readInlineWord('projectionKind', text) ?? readInlineWord('kind', text), mergeDecisionIds: readInlineList(text, 'mergeDecision', 'mergeDecisionId', 'mergeDecisionIds'), fields: readInlineList(text, 'field', 'fields') });
+  if (kind === 'rsiLoop') return createDecisionGraphRsiLoopRecord({ ...common, loopId: readInlineWord('loop', text) ?? readInlineWord('loopId', text), loopKind: readInlineWord('loopKind', text) ?? readInlineWord('kind', text), iteration: readInlineNumber('iteration', text), objective: readInlineQuoted('objective', text) ?? readInlineWord('objective', text), action: readInlineWord('action', text), feedbackIds: readInlineList(text, 'feedback', 'feedbackId', 'feedbackIds') });
+  if (kind === 'improvementFeedback') return createDecisionGraphImprovementFeedbackRecord({ ...common, loopId: readInlineWord('loop', text) ?? readInlineWord('loopId', text), loopKind: readInlineWord('loopKind', text), feedbackKind: readInlineWord('feedbackKind', text) ?? readInlineWord('kind', text), subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text), severity: readInlineWord('severity', text), action: readInlineWord('action', text), feedback: readInlineQuoted('feedback', text) });
+  return undefined;
+}
+
+function commonRecord(name, text, graphId) {
+  return cleanRecord({
+    id: idFrom(text, undefined),
+    name,
+    graphIds: [graphId],
+    status: readInlineWord('status', text),
+    subjectIds: readInlineList(text, 'subject', 'subjects', 'subjectId', 'subjectIds'),
+    candidateIds: readInlineList(text, 'candidate', 'candidates', 'candidateId', 'candidateIds'),
+    semanticMergeCandidateIds: readInlineList(text, 'semanticMergeCandidate', 'semanticMergeCandidates', 'semanticMergeCandidateId', 'semanticMergeCandidateIds'),
+    semanticChangeIds: readInlineList(text, 'semanticChange', 'semanticChanges', 'semanticChangeId', 'semanticChangeIds'),
+    admissionDecisionIds: readInlineList(text, 'admissionDecision', 'admissionDecisionId', 'admissionDecisionIds'),
+    decisionIds: readInlineList(text, 'decisionId', 'decisionIds'),
+    gateIds: readInlineList(text, 'gate', 'gates', 'gateId', 'gateIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+    replayRecordIds: readInlineList(text, 'replay', 'replayId', 'replayRecord', 'replayRecordId', 'replayRecordIds'),
+    patchEventIds: readInlineList(text, 'patchEvent', 'patchEventId', 'patchEventIds'),
+    tournamentRecordIds: readInlineList(text, 'tournamentRecord', 'tournamentRecordId', 'tournamentRecordIds'),
+    rsiLoopIds: readInlineList(text, 'rsiLoop', 'rsiLoopId', 'rsiLoopIds'),
+    summary: readInlineQuoted('summary', text),
+    metadata: { authoredName: name }
+  });
+}
+
+function groupRecords(records) {
+  const grouped = {
+    gateIds: [],
+    evidenceIds: [],
+    semanticChangeIds: [],
+    patchEventIds: [],
+    admissionDecisionIds: [],
+    decisionIds: [],
+    replayRecordIds: [],
+    tournamentRecordIds: [],
+    rsiLoopIds: [],
+    feedbackIds: []
+  };
+  for (const record of records) {
+    const key = RECORD_FIELDS[recordName(record)];
+    if (key && record.id) grouped[key].push(record.id);
+  }
+  return Object.fromEntries(Object.entries(grouped).map(([key, value]) => [key, unique(value)]));
+}
+
+function recordName(record) {
+  return String(record?.recordKind ?? record?.kind ?? '').replace('frontier.lang.decisionGraph.', '');
+}
+
+function normalizeRowKind(kind) {
+  if (kind === 'change') return 'semanticChange';
+  if (kind === 'patch') return 'patchEvent';
+  if (kind === 'admission') return 'admissionDecision';
+  if (kind === 'candidate') return 'candidateDecision';
+  if (kind === 'merge') return 'mergeDecision';
+  if (kind === 'panel') return 'panelProjection';
+  if (kind === 'feedback') return 'improvementFeedback';
+  return kind;
+}
+
+function isGraphPropertyLine(line) {
+  return /^(graphKind|kind|scope|scopeId|root|rootId|status|subject|subjects)\s+/.test(line);
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'DecisionGraph'; }
+function readLine(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\n]+)', 'm').exec(body)?.[1]?.trim(); }
+function readListLine(label, body) {
+  const line = readLine(label, body);
+  return line ? line.split(/[|,]/).map((item) => item.trim()).filter(Boolean) : undefined;
+}
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(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(text) || undefined; }
+function readInlineNumber(label, text) {
+  const value = readInlineWord(label, text);
+  return value === undefined ? undefined : Number(value);
+}
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/index.js

@@ -1,5 +1,7 @@
 import { actionNode, capabilityNode, createDocument, effectNode, entityNode, externNode, latticeNode, migrationNode, stateNode, targetNode, typeNode } from '@shapeshift-labs/frontier-lang-kernel';
+import { parseConstraintSpaceBlock } from './constraint-space.js';
 import { parseConversionBlock } from './conversion.js';
+import { parseDecisionGraphBlock } from './decision-graph.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseSemanticOperationsBlock } from './operations.js';
 import { parseParadigmBlock } from './paradigm.js';
@@ -13,6 +15,8 @@ export function parseFrontierSource(source, options = {}) {
   const paradigmBlocks = [];
   const operationBlocks = [];
   const conversionBlocks = [];
+  const constraintSpaceBlocks = [];
+  const decisionGraphBlocks = [];
   const nativeSourceBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
@@ -37,8 +41,10 @@ export function parseFrontierSource(source, options = {}) {
     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 === '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));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -48,7 +54,7 @@ function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[
 function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }
 function readBlocks(source) {
   const blocks = [];
-  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan)\s+([^{}]+)\{/g;
+  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan|constraintSpace|possibilitySpace|decisionGraph|admissionGraph)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -21,12 +21,14 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
   if (operationBlocks.length) metadata.semanticOperations = mergeOperationBlocks(operationBlocks);
   if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
+  if (constraintSpaceBlocks.length) metadata.constraintSpaces = mergeConstraintSpaceBlocks(constraintSpaceBlocks);
+  if (decisionGraphBlocks.length) metadata.decisionGraph = mergeDecisionGraphBlocks(decisionGraphBlocks);
   if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length)) {
     metadata.universalAst = mergeNativeSourceBlocks(nativeSourceBlocks);
   }
@@ -77,6 +79,28 @@ function mergeConversionBlocks(blocks) {
   return plan;
 }
 
+function mergeConstraintSpaceBlocks(blocks) {
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'constraintSpaces:source',
+    spaces: blocks,
+    targets: [...new Set(blocks.flatMap((block) => block.targets ?? []))],
+    variableIds: blocks.flatMap((block) => ids(block.variables)),
+    constraintIds: blocks.flatMap((block) => ids(block.constraints)),
+    preferenceIds: blocks.flatMap((block) => ids(block.preferences)),
+    collapseStrategyIds: blocks.flatMap((block) => ids(block.collapseStrategies)),
+    admissionIds: blocks.flatMap((block) => ids(block.admissions)),
+    summary: {
+      spaceCount: blocks.length,
+      variableCount: sum(blocks, 'variableCount'),
+      constraintCount: sum(blocks, 'constraintCount'),
+      preferenceCount: sum(blocks, 'preferenceCount'),
+      collapseStrategyCount: sum(blocks, 'collapseStrategyCount'),
+      admissionCount: sum(blocks, 'admissionCount')
+    },
+    metadata: { authoredConstraintSpaceBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
 function mergeNativeSourceBlocks(blocks) {
   return {
     id: blocks.length === 1 ? `universalAst:${blocks[0].node.id}` : 'universalAst:source',
@@ -88,3 +112,54 @@ function mergeNativeSourceBlocks(blocks) {
     metadata: { authoredNativeSourceIds: blocks.map((block) => block.node.id) }
   };
 }
+
+function mergeDecisionGraphBlocks(blocks) {
+  const records = blocks.flatMap((block) => block.records ?? []);
+  const graphs = blocks.map((block) => block.graph).filter(Boolean);
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'decisionGraph:source',
+    graphs,
+    records,
+    nodes: blocks.flatMap((block) => block.nodes ?? []),
+    edges: blocks.flatMap((block) => block.edges ?? []),
+    graphIds: ids(graphs),
+    recordIds: ids(records),
+    gateIds: idsByKind(records, 'frontier.lang.decisionGraph.gate'),
+    evidenceIds: idsByKind(records, 'frontier.lang.decisionGraph.evidence'),
+    semanticChangeIds: idsByKind(records, 'frontier.lang.decisionGraph.semanticChange'),
+    patchEventIds: idsByKind(records, 'frontier.lang.decisionGraph.patchEvent'),
+    admissionDecisionIds: idsByKind(records, 'frontier.lang.decisionGraph.admissionDecision'),
+    decisionIds: idsByKind(records, 'frontier.lang.decisionGraph.candidateDecision').concat(idsByKind(records, 'frontier.lang.decisionGraph.mergeDecision')),
+    replayRecordIds: idsByKind(records, 'frontier.lang.decisionGraph.replay'),
+    tournamentRecordIds: idsByKind(records, 'frontier.lang.decisionGraph.tournament').concat(idsByKind(records, 'frontier.lang.decisionGraph.tournamentCandidate')),
+    rsiLoopIds: idsByKind(records, 'frontier.lang.decisionGraph.rsiLoop'),
+    summary: {
+      graphCount: blocks.length,
+      recordCount: records.length,
+      nodeCount: sum(blocks, 'nodeCount'),
+      edgeCount: sum(blocks, 'edgeCount'),
+      semanticChangeCount: sum(blocks, 'semanticChangeCount'),
+      gateCount: sum(blocks, 'gateCount'),
+      evidenceCount: sum(blocks, 'evidenceCount'),
+      admissionDecisionCount: sum(blocks, 'admissionDecisionCount'),
+      decisionCount: sum(blocks, 'decisionCount'),
+      patchEventCount: sum(blocks, 'patchEventCount'),
+      replayCount: sum(blocks, 'replayCount'),
+      tournamentCount: sum(blocks, 'tournamentCount'),
+      rsiLoopCount: sum(blocks, 'rsiLoopCount')
+    },
+    metadata: { authoredDecisionGraphBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
+function ids(records = []) {
+  return records.map((record) => record?.id).filter(Boolean);
+}
+
+function idsByKind(records = [], kind) {
+  return ids(records.filter((record) => record?.recordKind === kind || record?.kind === kind));
+}
+
+function sum(blocks, key) {
+  return blocks.reduce((total, block) => total + (block.summary?.[key] ?? 0), 0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.17",
+  "version": "0.3.19",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@shapeshift-labs/frontier-lang-kernel": "0.3.12"
+    "@shapeshift-labs/frontier-lang-kernel": "0.3.13"
   },
   "devDependencies": {
     "typescript": "^5.9.3"