@shapeshift-labs/frontier-lang-parser 0.3.9 → 0.3.11

package/dist/conversion.js

@@ -0,0 +1,121 @@
+const FAMILIES = {
+  type: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
+  typeConstraint: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
+  controlFlow: { field: 'controlFlowConstraints', sourceKey: 'sourceControlFlows', targetKey: 'targetControlFlows' },
+  controlFlowConstraint: { field: 'controlFlowConstraints', sourceKey: 'sourceControlFlows', targetKey: 'targetControlFlows' },
+  lifetime: { field: 'lifetimeConstraints', sourceKey: 'sourceLifetimeConstraints', targetKey: 'targetLifetimeConstraints' },
+  lifetimeConstraint: { field: 'lifetimeConstraints', sourceKey: 'sourceLifetimeConstraints', targetKey: 'targetLifetimeConstraints' },
+  callableBoundary: { field: 'callableBoundaryConstraints', sourceKey: 'sourceCallables', targetKey: 'targetCallables' },
+  adtPattern: { field: 'adtPatternConstraints', sourceKey: 'sourcePatterns', targetKey: 'targetPatterns' },
+  dataLayout: { field: 'dataLayoutConstraints', sourceKey: 'sourceLayouts', targetKey: 'targetLayouts' },
+  effect: { field: 'effectConstraints', sourceKey: 'sourceEffects', targetKey: 'targetEffects' },
+  concurrencyModel: { field: 'concurrencyModelConstraints', sourceKey: 'sourceConcurrencyModels', targetKey: 'targetConcurrencyModels' },
+  errorModel: { field: 'errorModelConstraints', sourceKey: 'sourceErrors', targetKey: 'targetErrors' },
+  evaluationModel: { field: 'evaluationModelConstraints', sourceKey: 'sourceEvaluations', targetKey: 'targetEvaluations' },
+  hostEnvironment: { field: 'hostEnvironmentConstraints', sourceKey: 'sourceHosts', targetKey: 'targetHosts' },
+  memoryModel: { field: 'memoryModelConstraints', sourceKey: 'sourceMemoryModels', targetKey: 'targetMemoryModels' },
+  metaprogramming: { field: 'metaprogrammingConstraints', sourceKey: 'sourceMetaprograms', targetKey: 'targetMetaprograms' },
+  module: { field: 'moduleConstraints', sourceKey: 'sourceModules', targetKey: 'targetModules' },
+  scopeBinding: { field: 'scopeBindingConstraints', sourceKey: 'sourceBindings', targetKey: 'targetBindings' },
+  numericSemantics: { field: 'numericSemanticsConstraints', sourceKey: 'sourceNumerics', targetKey: 'targetNumerics' },
+  textSemantics: { field: 'textSemanticsConstraints', sourceKey: 'sourceTexts', targetKey: 'targetTexts' },
+  collectionSemantics: { field: 'collectionSemanticsConstraints', sourceKey: 'sourceCollections', targetKey: 'targetCollections' },
+  serializationSemantics: { field: 'serializationSemanticsConstraints', sourceKey: 'sourceSerializations', targetKey: 'targetSerializations' },
+  dependencySemantics: { field: 'dependencySemanticsConstraints', sourceKey: 'sourceDependencies', targetKey: 'targetDependencies' },
+  objectModel: { field: 'objectModelConstraints', sourceKey: 'sourceObjects', targetKey: 'targetObjects' },
+  protocol: { field: 'protocolConstraints', sourceKey: 'sourceProtocols', targetKey: 'targetProtocols' }
+};
+
+export function parseConversionBlock(block) {
+  const name = nameFrom(block.header);
+  const plan = { id: idFrom(block.header, `conversion_${name}`), targets: [], 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 sourceLanguage = /^sourceLanguage\s+([^\s,]+)/.exec(line)?.[1] ?? /^source\s+([^\s,]+)/.exec(line)?.[1];
+    const constraint = /^constraint\s+([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (target) plan.targets.push(target);
+    else if (sourceLanguage) plan.sourceLanguage = sourceLanguage;
+    else if (constraint) addConstraint(plan, constraint[1], constraint[2], constraint[3]);
+  }
+  return cleanRecord({ ...plan, targets: unique(plan.targets) });
+}
+
+function addConstraint(plan, family, name, text) {
+  const config = FAMILIES[family] ?? { field: family.endsWith('s') ? family : `${family}Constraints`, sourceKey: 'sourceRecords', targetKey: 'targetRecords' };
+  const role = readInlineWord('role', text) ?? 'source';
+  const record = parseConstraintRecord(name, text, role);
+  const entry = cleanRecord({
+    id: idFrom(text, `${config.field}_${name}`),
+    sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('source', text) ?? plan.sourceLanguage,
+    target: readInlineWord('target', text) ?? plan.targets[0],
+    mode: readInlineWord('mode', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence'),
+    blockers: readInlineList(text, 'blocker', 'blockers'),
+    review: readInlineList(text, 'review'),
+    metadata: { name, family, authoredConversionBlockId: plan.id }
+  });
+  const recordKey = role === 'target' ? config.targetKey : config.sourceKey;
+  entry[recordKey] = [record];
+  plan[config.field] = [...(plan[config.field] ?? []), entry];
+}
+
+function parseConstraintRecord(name, text, role) {
+  const kind = readInlineWord('kind', text) ?? readInlineWord('constraintKind', text);
+  return cleanRecord({
+    id: readInlineWord('recordId', text) ?? idFrom(text, `constraint_record_${name}`),
+    role,
+    kind,
+    name: readInlineWord('name', text) ?? name,
+    constraintKind: readInlineWord('constraintKind', text),
+    constraintKinds: readInlineList(text, 'constraint', 'constraints', 'constraintKind', 'constraintKinds') ?? (kind ? [kind] : undefined),
+    factKinds: readInlineList(text, 'fact', 'facts', 'factKind', 'factKinds'),
+    symbolId: readInlineWord('symbol', text) ?? readInlineWord('symbolId', text),
+    symbolName: readInlineWord('symbolName', text),
+    localName: readInlineWord('localName', text),
+    typeKind: readInlineWord('typeKind', text),
+    signatureHash: readInlineWord('signatureHash', text),
+    contractHash: readInlineWord('contractHash', text),
+    typeHash: readInlineWord('typeHash', text),
+    flowKind: readInlineWord('flowKind', text),
+    sourceId: readInlineWord('from', text) ?? readInlineWord('sourceId', text),
+    targetId: readInlineWord('to', text) ?? readInlineWord('targetId', text),
+    label: readInlineWord('label', text),
+    conditionHash: readInlineWord('conditionHash', text),
+    orderingKey: readInlineWord('orderingKey', text) ?? readInlineWord('orderKey', text),
+    lifetimeKind: readInlineWord('lifetimeKind', text),
+    regionKind: readInlineWord('regionKind', text),
+    predicate: readInlineQuoted('predicate', text) ?? readInlineWord('predicate', text),
+    resourceId: readInlineWord('resource', text) ?? readInlineWord('resourceId', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text),
+    sourceHash: readInlineWord('sourceHash', text),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    nullable: readInlineFlag('nullable', text),
+    optional: readInlineFlag('optional', text),
+    publicContract: readInlineFlag('publicContract', text),
+    async: readInlineFlag('async', text),
+    generator: readInlineFlag('generator', text),
+    exceptional: readInlineFlag('exceptional', text),
+    cancellable: readInlineFlag('cancellable', 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] ?? 'Conversion'; }
+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 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/index.js

@@ -1,23 +1,17 @@
-import {
-  actionNode,
-  capabilityNode,
-  createDocument,
-  effectNode,
-  entityNode,
-  externNode,
-  latticeNode,
-  migrationNode,
-  nativeSourceNode,
-  stateNode,
-  targetNode,
-  typeNode
-} from '@shapeshift-labs/frontier-lang-kernel';
+import { actionNode, capabilityNode, createDocument, effectNode, entityNode, externNode, latticeNode, migrationNode, nativeSourceNode, stateNode, targetNode, typeNode } from '@shapeshift-labs/frontier-lang-kernel';
+import { parseConversionBlock } from './conversion.js';
+import { createParsedMetadata } from './metadata.js';
+import { parseSemanticOperationsBlock } from './operations.js';
+import { parseParadigmBlock } from './paradigm.js';
 import { parseProofBlock } from './proof.js';
 import { parseViewBlock } from './view.js';
 
 export function parseFrontierSource(source, options = {}) {
   const nodes = [];
   const proofBlocks = [];
+  const paradigmBlocks = [];
+  const operationBlocks = [];
+  const conversionBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
   for (const block of readBlocks(source)) {
@@ -34,8 +28,12 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'nativeSource') nodes.push(parseNativeSource(block));
     if (block.kind === 'target') nodes.push(parseTarget(block));
     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 === 'conversion' || block.kind === 'universalConversionPlan') conversionBlocks.push(parseConversionBlock(block));
   }
-  return createDocument({ id: documentId, name: documentName, nodes, ...(proofBlocks.length ? { metadata: { proof: mergeProofBlocks(proofBlocks) } } : {}) });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks });
+  return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
 export function parseFrontierFile(name, source) { return parseFrontierSource(source, { name: name.replace(/\.frontier$/, '') }); }
@@ -44,7 +42,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)\s+([^{}]+)\{/g;
+  const header = /\b(entity|state|action|view|migration|capability|effect|type|extern|lattice|nativeSource|target|proof|paradigm|paradigmSemantics|operations|semanticOperations|conversion|universalConversionPlan)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;
@@ -54,15 +52,6 @@ function readBlocks(source) {
   }
   return blocks;
 }
-const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
-function mergeProofBlocks(blocks) {
-  const proof = {
-    id: blocks.length === 1 ? blocks[0].id : 'proof:source',
-    metadata: { authoredProofBlockIds: blocks.map((block) => block.id) }
-  };
-  for (const group of PROOF_GROUPS) proof[group] = blocks.flatMap((block) => block[group] ?? []);
-  return proof;
-}
 function idFrom(header, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1] ?? fallback; }
 function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Unnamed'; }
 function parseEntity(block) {

package/dist/metadata.js

@@ -0,0 +1,72 @@
+const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
+const PARADIGM_GROUPS = [
+  'bindingScopes',
+  'bindings',
+  'patterns',
+  'typeConstraints',
+  'evaluationModels',
+  'memoryLocations',
+  'effectRegions',
+  'controlRegions',
+  'logicPrograms',
+  'actorSystems',
+  'stackEffects',
+  'arrayShapes',
+  'numericKernels',
+  'dataflowNetworks',
+  'clockModels',
+  'objectModels',
+  'macroExpansions',
+  'reflectionBoundaries',
+  'loweringRecords'
+];
+
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [] } = {}) {
+  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);
+  return Object.keys(metadata).length ? metadata : undefined;
+}
+
+function mergeProofBlocks(blocks) {
+  const proof = {
+    id: blocks.length === 1 ? blocks[0].id : 'proof:source',
+    metadata: { authoredProofBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const group of PROOF_GROUPS) proof[group] = blocks.flatMap((block) => block[group] ?? []);
+  return proof;
+}
+
+function mergeParadigmBlocks(blocks) {
+  const paradigm = {
+    id: blocks.length === 1 ? blocks[0].id : 'paradigm:source',
+    metadata: { authoredParadigmBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const group of PARADIGM_GROUPS) paradigm[group] = blocks.flatMap((block) => block[group] ?? []);
+  return paradigm;
+}
+
+function mergeOperationBlocks(blocks) {
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'semanticOperations:source',
+    operations: blocks.flatMap((block) => block.operations ?? []),
+    metadata: { authoredSemanticOperationBlockIds: blocks.map((block) => block.id) }
+  };
+}
+
+function mergeConversionBlocks(blocks) {
+  const plan = {
+    id: blocks.length === 1 ? blocks[0].id : 'universalConversionPlan:source',
+    targets: [...new Set(blocks.flatMap((block) => block.targets ?? []))],
+    metadata: { authoredConversionBlockIds: blocks.map((block) => block.id) }
+  };
+  for (const block of blocks) {
+    if (block.sourceLanguage && !plan.sourceLanguage) plan.sourceLanguage = block.sourceLanguage;
+    for (const [key, value] of Object.entries(block)) {
+      if (Array.isArray(value) && key !== 'targets') plan[key] = [...(plan[key] ?? []), ...value];
+    }
+  }
+  return plan;
+}

package/dist/operations.js

@@ -0,0 +1,59 @@
+export function parseSemanticOperationsBlock(block) {
+  const name = nameFrom(block.header);
+  const operationSet = { id: idFrom(block.header, `semanticOperations_${name}`), operations: [], metadata: { name } };
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const match = /^(operation|op)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (match) operationSet.operations.push(parseSemanticOperationRecord(match[2], match[3]));
+  }
+  return operationSet;
+}
+
+function parseSemanticOperationRecord(name, text) {
+  return cleanRecord({
+    id: idFrom(text, `semanticOperation_${name}`),
+    operationKind: readInlineWord('operationKind', text) ?? readInlineWord('op', text) ?? readInlineWord('kind', text),
+    language: readInlineWord('language', text),
+    name,
+    target: readInlineWord('target', text),
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeIds: readInlineList(text, 'nativeAstNode', 'nativeAstNodes', 'nativeAstNodeIds'),
+    semanticNodeIds: readInlineList(text, 'semanticNode', 'semanticNodes', 'semanticNodeIds'),
+    semanticSymbolIds: readInlineList(text, 'semanticSymbol', 'semanticSymbols', 'semanticSymbolIds'),
+    semanticOccurrenceIds: readInlineList(text, 'semanticOccurrence', 'semanticOccurrences', 'semanticOccurrenceIds'),
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMaps', 'sourceMapIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingIds'),
+    proofObligationIds: readInlineList(text, 'proofObligation', 'proofObligations', 'proofObligationIds'),
+    proofArtifactIds: readInlineList(text, 'proofArtifact', 'proofArtifacts', 'proofArtifactIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    lossIds: readInlineList(text, 'loss', 'lossIds'),
+    reads: readInlineList(text, 'read', 'reads'),
+    writes: readInlineList(text, 'write', 'writes'),
+    effectIds: readInlineList(text, 'effect', 'effects', 'effectIds'),
+    resources: readInlineList(text, 'resource', 'resources'),
+    ownershipKeys: readInlineList(text, 'ownerKey', 'ownershipKey', 'ownershipKeys'),
+    conflictKeys: readInlineList(text, 'conflictKey', 'conflictKeys'),
+    readiness: readInlineWord('readiness', text),
+    dynamic: readInlineFlag('dynamic', text),
+    opaque: readInlineFlag('opaque', text),
+    summary: readInlineQuoted('summary', text)
+  });
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'SemanticOperations'; }
+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 cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/paradigm.js

@@ -0,0 +1,93 @@
+const GROUPS = {
+  bindingScope: 'bindingScopes',
+  binding: 'bindings',
+  pattern: 'patterns',
+  typeConstraint: 'typeConstraints',
+  evaluationModel: 'evaluationModels',
+  memoryLocation: 'memoryLocations',
+  effectRegion: 'effectRegions',
+  controlRegion: 'controlRegions',
+  logicProgram: 'logicPrograms',
+  actorSystem: 'actorSystems',
+  stackEffect: 'stackEffects',
+  arrayShape: 'arrayShapes',
+  numericKernel: 'numericKernels',
+  dataflowNetwork: 'dataflowNetworks',
+  clockModel: 'clockModels',
+  objectModel: 'objectModels',
+  macroExpansion: 'macroExpansions',
+  reflectionBoundary: 'reflectionBoundaries',
+  lowering: 'loweringRecords',
+  loweringRecord: 'loweringRecords'
+};
+
+export function parseParadigmBlock(block) {
+  const name = nameFrom(block.header);
+  const layer = { id: idFrom(block.header, `paradigm_${name}`), metadata: { name } };
+  for (const group of new Set(Object.values(GROUPS))) layer[group] = [];
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const match = /^([A-Za-z_$][\w$-]*)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, section, recordName, rest] = match;
+    const group = GROUPS[section];
+    if (group) layer[group].push(parseParadigmRecord(section, recordName, rest));
+  }
+  return omitEmptyArrays(layer);
+}
+
+function parseParadigmRecord(section, name, text) {
+  return cleanRecord({
+    id: idFrom(text, `paradigm_${section}_${name}`),
+    kind: readInlineWord('kind', text) ?? section,
+    subjectKind: readInlineWord('subjectKind', text),
+    subjectId: readInlineWord('subject', text) ?? readInlineWord('subjectId', text),
+    semanticNodeId: readInlineWord('semanticNode', text) ?? readInlineWord('semanticNodeId', text),
+    semanticSymbolId: readInlineWord('semanticSymbol', text) ?? readInlineWord('semanticSymbolId', text),
+    semanticOccurrenceId: readInlineWord('semanticOccurrence', text) ?? readInlineWord('semanticOccurrenceId', text),
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeId: readInlineWord('nativeAstNode', text) ?? readInlineWord('nativeAstNodeId', text),
+    sourceMapId: readInlineWord('sourceMap', text) ?? readInlineWord('sourceMapId', text),
+    sourceMapMappingId: readInlineWord('sourceMapMapping', text) ?? readInlineWord('sourceMapMappingId', text),
+    bindingScopeId: readInlineWord('bindingScope', text) ?? readInlineWord('bindingScopeId', text),
+    parentScopeId: readInlineWord('parentScope', text) ?? readInlineWord('parentScopeId', text),
+    bindingId: readInlineWord('binding', text) ?? readInlineWord('bindingId', text),
+    patternId: readInlineWord('pattern', text) ?? readInlineWord('patternId', text),
+    typeConstraintId: readInlineWord('typeConstraint', text) ?? readInlineWord('typeConstraintId', text),
+    evaluationModelId: readInlineWord('evaluationModel', text) ?? readInlineWord('evaluationModelId', text),
+    memoryLocationId: readInlineWord('memoryLocation', text) ?? readInlineWord('memoryLocationId', text),
+    effectRegionId: readInlineWord('effectRegion', text) ?? readInlineWord('effectRegionId', text),
+    controlRegionId: readInlineWord('controlRegion', text) ?? readInlineWord('controlRegionId', text),
+    loweringRecordId: readInlineWord('lowering', text) ?? readInlineWord('loweringRecordId', text),
+    sourceRecordId: readInlineWord('sourceRecord', text) ?? readInlineWord('sourceRecordId', text),
+    targetRecordId: readInlineWord('targetRecord', text) ?? readInlineWord('targetRecordId', text),
+    effectIds: readInlineList(text, 'effect', 'effects', 'effectIds'),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    lossIds: readInlineList(text, 'loss', 'lossIds'),
+    relatedRecordIds: readInlineList(text, 'related', 'relatedRecordIds'),
+    statement: readInlineQuoted('statement', text),
+    description: readInlineQuoted('description', text),
+    language: readInlineWord('language', 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] ?? 'Paradigm'; }
+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 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 cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}
+function omitEmptyArrays(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => !Array.isArray(value) || value.length > 0));
+}

package/package.json

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