@shapeshift-labs/frontier-lang-parser 0.3.24 → 0.3.26

package/README.md

@@ -220,6 +220,46 @@ 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 view render graph syntax
+
+`.frontier` view blocks can describe UI render graphs directly. Nested `render`
+blocks are flattened into `view.renders`, and each parent stores stable child
+render IDs in `children`. This keeps authored UI structural and target-neutral:
+HTML, JSX, SwiftUI, or another target can lower the same semantic graph without
+the parser claiming browser or runtime equivalence.
+
+```frontier
+view TodoList @id("view_todo_list") {
+  reads TodoDb.todos
+  dispatches action_add
+  prop disabled @id("view_prop_disabled"): Boolean
+  event save @id("view_event_save") action action_add input TodoInput
+
+  render Article @id("render_todo_root") {
+    key todo-list-root
+
+    render Button @id("render_save_button") {
+      identity save
+      text "Save"
+      prop disabled disabled
+      on press save
+    }
+
+    render SaveIcon kind component @id("render_save_icon") {
+      component Icon
+      key save-icon
+      prop name "check"
+    }
+  }
+}
+```
+
+The root render becomes a graph node whose `children` reference
+`render_save_button` and `render_save_icon` in source order. Child props, text,
+and events stay attached to the child render node instead of leaking onto the
+parent. `kind component` records `component` instead of a literal HTML tag, so
+target adapters can decide how to project it.
+
 ## Authored target projection syntax
 
 `.frontier` target blocks can carry projection contracts next to their emit settings. These rows describe what a target lowering claims to represent, what it still needs proof for, and which losses or missing evidence must stay visible to merge and translation tooling.
@@ -323,11 +363,18 @@ conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
   dialect nodeProcess @id("dialect_node_process") language javascript dialect node.runtime kind runtime target rust disposition unsupported readiness blocked loss loss_node_process_projection
   extern viteRoutes @id("extern_vite_routes") language javascript dialect vite.plugin.virtual-module externKind generatorArtifact target rust disposition runtime-required evidence evidence_vite_routes_manifest bindingSymbol virtual:routes
   constraint type publicApi @id("type_constraint_public_api") role source kind public-function symbol symbol:addTodo signatureHash sig_add_todo evidence artifact_todo_title_probe
+  constraint module-constraint todoModule @id("module_constraint_todo") role source kind module-boundary specifier ./todo exportedName addTodo packageName @app/todo packageCondition import resolutionKind node16 evidence artifact_todo_title_probe
+  constraint scope-binding todoLocal @id("scope_binding_todo") role source kind lexical-binding bindingId binding:todo referenceId ref:todo scopeId scope:handler resolvedBindingId binding:todo evidence artifact_todo_title_probe
+  constraint memory-model todoMemory @id("memory_model_todo") role source kind stable-reference resource TodoDb.todos memoryKind shared-memory memoryOrder acquire lockId lock:todo shared evidence artifact_todo_title_probe
+  constraint effect-constraint todoWrite @id("effect_constraint_todo_write") role source kind storage-write capability storage.write resource TodoDb.todos adapterRequired evidence artifact_todo_title_probe
+  constraint host-environment browserFetch @id("host_environment_fetch") role source kind browser-api capability fetch apiName fetch globalName window permission network adapterRequired evidence artifact_todo_title_probe
 }
 ```
 
 `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.
 
+`constraint` rows accept every universal conversion constraint family used by route admission, including hyphenated spellings such as `module-constraint`, `scope-binding`, `memory-model`, `effect-constraint`, `control-flow`, `borrow-scope`, `borrow-checker`, `host-environment`, `data-layout`, and `object-model`. The parser preserves family-specific fields such as module specifiers, package conditions, binding/reference ids, memory ordering, locks, capabilities, host permissions, ABI/layout hints, and effect adapters as authored evidence inputs. Record-level targets use explicit labels such as `effectTarget` so `role target` rows cannot be mistaken for an authored target field. These rows do not prove translation equivalence; they make the required proof surface explicit for downstream gates and admission records.
+
 ## Authored dialect registry syntax
 
 `.frontier` files can carry reusable dialect registries with `dialectRegistry` or `universalDialectRegistry` blocks. These blocks describe language-specific constructs that should stay visible during translation instead of being silently collapsed into generic stubs.

package/dist/conversion-constraint-record.js

@@ -0,0 +1,113 @@
+const FAMILY_ROWS = [
+  ['type', 'typeConstraints', 'sourceTypes', 'targetTypes', ['typeConstraint', 'type-constraint']],
+  ['resourceTransfer', 'resourceTransfers', 'sourceGraphs', 'targetGraphs', ['resourceTransferConstraint', 'resource-transfer', 'resource-transfer-constraint', 'ownership'], { graph: true }],
+  ['controlFlow', 'controlFlowConstraints', 'sourceControlFlows', 'targetControlFlows', ['controlFlowConstraint', 'control-flow', 'control-flow-constraint']],
+  ['lifetime', 'lifetimeConstraints', 'sourceLifetimeConstraints', 'targetLifetimeConstraints', ['lifetimeConstraint', 'lifetime-constraint']],
+  ['borrowScope', 'borrowScopeConstraints', 'sourceBorrowScopes', 'targetBorrowScopes', ['borrowScopeConstraint', 'borrow-scope', 'borrow-scope-constraint']],
+  ['borrowChecker', 'borrowCheckerConstraints', 'sourceBorrowScopes', 'targetBorrowScopes', ['borrowCheckerConstraint', 'borrow-checker', 'borrow-checker-constraint']],
+  ['callableBoundary', 'callableBoundaryConstraints', 'sourceCallables', 'targetCallables', ['callableBoundaryConstraint', 'callable-boundary', 'callable-boundary-constraint'], { extraSourceKeys: ['sourceCallableBoundaryRecords'], extraTargetKeys: ['targetCallableBoundaryRecords'] }],
+  ['adtPattern', 'adtPatternConstraints', 'sourcePatterns', 'targetPatterns', ['adtPatternConstraint', 'adt-pattern', 'adt-pattern-constraint'], { extraSourceKeys: ['sourceAdtPatternRecords'], extraTargetKeys: ['targetAdtPatternRecords'] }],
+  ['dataLayout', 'dataLayoutConstraints', 'sourceLayouts', 'targetLayouts', ['dataLayoutConstraint', 'data-layout', 'data-layout-constraint'], { extraSourceKeys: ['sourceDataLayoutRecords'], extraTargetKeys: ['targetDataLayoutRecords'] }],
+  ['effect', 'effectConstraints', 'sourceEffects', 'targetEffects', ['effectConstraint', 'effect-constraint']],
+  ['concurrencyModel', 'concurrencyModelConstraints', 'sourceConcurrencyModels', 'targetConcurrencyModels', ['concurrencyModelConstraint', 'concurrency-model', 'concurrency-model-constraint'], { extraSourceKeys: ['sourceConcurrencyModelRecords'], extraTargetKeys: ['targetConcurrencyModelRecords'] }],
+  ['errorModel', 'errorModelConstraints', 'sourceErrors', 'targetErrors', ['errorModelConstraint', 'error-model', 'error-model-constraint'], { extraSourceKeys: ['sourceErrorModelRecords'], extraTargetKeys: ['targetErrorModelRecords'] }],
+  ['evaluationModel', 'evaluationModelConstraints', 'sourceEvaluations', 'targetEvaluations', ['evaluationModelConstraint', 'evaluation-model', 'evaluation-model-constraint'], { extraSourceKeys: ['sourceEvaluationModelRecords'], extraTargetKeys: ['targetEvaluationModelRecords'] }],
+  ['hostEnvironment', 'hostEnvironmentConstraints', 'sourceHosts', 'targetHosts', ['hostEnvironmentConstraint', 'host-environment', 'host-environment-constraint'], { extraSourceKeys: ['sourceHostEnvironmentRecords'], extraTargetKeys: ['targetHostEnvironmentRecords'] }],
+  ['memoryModel', 'memoryModelConstraints', 'sourceMemoryModels', 'targetMemoryModels', ['memoryModelConstraint', 'memory-model', 'memory-model-constraint'], { extraSourceKeys: ['sourceMemoryModelRecords'], extraTargetKeys: ['targetMemoryModelRecords'] }],
+  ['metaprogramming', 'metaprogrammingConstraints', 'sourceMetaprograms', 'targetMetaprograms', ['metaprogrammingConstraint', 'metaprogramming-constraint'], { extraSourceKeys: ['sourceMetaprogrammingRecords'], extraTargetKeys: ['targetMetaprogrammingRecords'] }],
+  ['module', 'moduleConstraints', 'sourceModules', 'targetModules', ['moduleConstraint', 'module-constraint']],
+  ['scopeBinding', 'scopeBindingConstraints', 'sourceBindings', 'targetBindings', ['scopeBindingConstraint', 'scope-binding', 'scope-binding-constraint'], { extraSourceKeys: ['sourceScopeBindingRecords'], extraTargetKeys: ['targetScopeBindingRecords'] }],
+  ['numericSemantics', 'numericSemanticsConstraints', 'sourceNumerics', 'targetNumerics', ['numericSemanticsConstraint', 'numeric-semantics', 'numeric-semantics-constraint'], { extraSourceKeys: ['sourceNumericSemanticsRecords'], extraTargetKeys: ['targetNumericSemanticsRecords'] }],
+  ['textSemantics', 'textSemanticsConstraints', 'sourceTexts', 'targetTexts', ['textSemanticsConstraint', 'text-semantics', 'text-semantics-constraint'], { extraSourceKeys: ['sourceTextSemanticsRecords'], extraTargetKeys: ['targetTextSemanticsRecords'] }],
+  ['collectionSemantics', 'collectionSemanticsConstraints', 'sourceCollections', 'targetCollections', ['collectionSemanticsConstraint', 'collection-semantics', 'collection-semantics-constraint'], { extraSourceKeys: ['sourceCollectionSemanticsRecords'], extraTargetKeys: ['targetCollectionSemanticsRecords'] }],
+  ['serializationSemantics', 'serializationSemanticsConstraints', 'sourceSerializations', 'targetSerializations', ['serializationSemanticsConstraint', 'serialization-semantics', 'serialization-semantics-constraint'], { extraSourceKeys: ['sourceSerializationSemanticsRecords'], extraTargetKeys: ['targetSerializationSemanticsRecords'] }],
+  ['dependencySemantics', 'dependencySemanticsConstraints', 'sourceDependencies', 'targetDependencies', ['dependencySemanticsConstraint', 'dependency-semantics', 'dependency-semantics-constraint'], { extraSourceKeys: ['sourceDependencySemanticsRecords'], extraTargetKeys: ['targetDependencySemanticsRecords'] }],
+  ['objectModel', 'objectModelConstraints', 'sourceObjects', 'targetObjects', ['objectModelConstraint', 'object-model', 'object-model-constraint'], { extraSourceKeys: ['sourceObjectModelRecords'], extraTargetKeys: ['targetObjectModelRecords'] }],
+  ['protocol', 'protocolConstraints', 'sourceProtocols', 'targetProtocols', ['protocolConstraint', 'protocol-constraint']]
+];
+
+const WORD_FIELDS = [
+  ['symbolId', 'symbol', 'symbolId'], ['symbolName'], ['localName'], ['ownerId', 'owner', 'ownerId'], ['ownerKind'],
+  ['bindingKind'], ['referenceKind'], ['scopeId', 'scopeId', 'scope'], ['ownerScopeId'], ['bindingId', 'bindingId', 'binding'],
+  ['externalBindingId', 'externalBindingId', 'externalBinding'], ['resolvedBindingId', 'resolvedBindingId', 'resolvedBinding'],
+  ['declarationId', 'declarationId', 'declaration'], ['referenceId', 'referenceId', 'reference'], ['occurrenceId', 'occurrenceId', 'occurrence'],
+  ['resolvedName'], ['namespace'], ['scopeType'], ['variableScopeType'], ['lookupKind'], ['resolutionKind', 'resolutionKind', 'moduleResolutionKind'],
+  ['moduleKind'], ['edgeKind'], ['declarationKind'], ['specifier', 'specifier', 'moduleSpecifier'], ['moduleSpecifier', 'moduleSpecifier', 'specifier'],
+  ['importedName', 'importedName', 'importName'], ['importName', 'importName', 'importedName'], ['exportedName', 'exportedName', 'exportName'],
+  ['exportName', 'exportName', 'exportedName'], ['reExportedName', 'reExportedName', 'reexportedName'], ['packageName', 'packageName', 'package'],
+  ['packageSubpath', 'packageSubpath', 'subpath'], ['packageCondition', 'packageCondition', 'condition'], ['packageExportKey'], ['packageImportKey'],
+  ['resolvedPath', 'resolvedPath', 'targetPath'], ['targetPath', 'targetPath', 'resolvedPath'], ['capability'], ['hostKind'], ['runtimeKind'],
+  ['apiName', 'apiName', 'callee'], ['globalName', 'globalName', 'global', 'objectName'], ['permission', 'permission', 'permissionKind'],
+  ['permissionKind', 'permissionKind', 'permission'], ['effectKind'], ['memoryKind'],
+  ['operationKind'], ['memoryOrder', 'memoryOrder', 'ordering'], ['ordering', 'ordering', 'memoryOrder'], ['lockId', 'lockId', 'lock'],
+  ['channelId', 'channelId', 'channel'], ['actorId', 'actorId', 'actor'], ['synchronizationKey', 'synchronizationKey', 'syncKey'],
+  ['callableId', 'callableId', 'callable'], ['functionId', 'functionId', 'function'], ['receiverId', 'receiverId', 'receiver'],
+  ['abi'], ['callingConvention'], ['layoutKind'], ['endian'], ['objectKind'], ['memberKind'], ['protocolId', 'protocolId', 'protocol'],
+  ['traitId', 'traitId', 'trait'], ['interfaceId', 'interfaceId', 'interface'], ['mode', 'mode', 'loanMode'], ['aliasKind'], ['moveKind'],
+  ['dropKind'], ['resourceKind'], ['scopeKind'], ['typeKind'], ['signatureHash'], ['contractHash'], ['typeHash'], ['flowKind'],
+  ['controlFlowKind'], ['sourceControlFlowId'], ['sourceId', 'from', 'sourceId'], ['targetId', 'to', 'targetId'], ['label'],
+  ['conditionHash'], ['orderingKey', 'orderingKey', 'orderKey'], ['lifetimeKind'], ['lifetimeRegionId', 'lifetimeRegion', 'lifetimeRegionId'],
+  ['regionKind'], ['resourceId', 'resource', 'resourceId'], ['sourcePath', 'sourcePath', 'path'], ['sourceHash'], ['target', 'effectTarget', 'targetResource']
+];
+const LIST_FIELDS = [
+  ['factKinds', 'fact', 'facts', 'factKind', 'factKinds'], ['importAttributes', 'importAttribute', 'importAttributes', 'assertion', 'assertions'],
+  ['reads', 'read', 'reads'], ['writes', 'write', 'writes'], ['evidenceIds', 'evidence', 'evidenceIds']
+];
+const NUMBER_FIELDS = [['arity'], ['size'], ['alignment']];
+const FLAG_FIELDS = ['nullable', 'optional', 'publicContract', 'closure', 'captured', 'writeExpr', 'mutable', 'shadowed', 'hoisted', 'typeOnly', 'isTypeReference', 'isValueReference', 'shared', 'volatile', 'atomic', 'adapterRequired', 'async', 'generator', 'exceptional', 'cancellable'];
+
+export const FAMILIES = Object.freeze(Object.fromEntries(FAMILY_ROWS.flatMap(([name, field, sourceKey, targetKey, aliases = [], extra = {}]) => {
+  const config = { field, sourceKey, targetKey, ...extra };
+  return [name, ...aliases].map((alias) => [alias, config]);
+})));
+
+export function parseConstraintRecord(name, text, role) {
+  const kind = wordAny(text, 'kind', 'constraintKind');
+  return cleanRecord({
+    id: wordAny(text, 'recordId') ?? idFrom(text, `constraint_record_${name}`),
+    role,
+    kind,
+    name: wordAny(text, 'name') ?? name,
+    constraintKind: wordAny(text, 'constraintKind'),
+    constraintKinds: listAny(text, 'constraint', 'constraints', 'constraintKind', 'constraintKinds') ?? (kind ? [kind] : undefined),
+    ...readMapped(text, WORD_FIELDS, wordAny),
+    ...readMapped(text, LIST_FIELDS, listAny),
+    ...readMapped(text, NUMBER_FIELDS, numberAny),
+    ...Object.fromEntries(FLAG_FIELDS.map((field) => [field, flag(field, text)])),
+    predicate: quoted('predicate', text) ?? wordAny(text, 'predicate'),
+    metadata: { name }
+  });
+}
+
+function readMapped(text, specs, reader) {
+  return Object.fromEntries(specs.map(([key, ...labels]) => [key, reader(text, ...(labels.length ? labels : [key]))]));
+}
+function wordAny(text, ...labels) {
+  for (const label of labels) {
+    const value = word(label, text);
+    if (value !== undefined) return value;
+  }
+  return undefined;
+}
+function listAny(text, ...labels) {
+  for (const label of labels) {
+    const value = list(label, text);
+    if (value) return value;
+  }
+  return undefined;
+}
+function numberAny(text, ...labels) {
+  const value = wordAny(text, ...labels);
+  return value === undefined ? undefined : Number(value);
+}
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function word(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function quoted(label, text) { return new RegExp("(?:^|\\s)" + label + "\\s+[\"']([^\"']+)[\"']").exec(text)?.[1]?.trim(); }
+function flag(label, text) { return new RegExp('(?:^|\\s)' + label + '(?:\\s|$)').test(text) || undefined; }
+function list(label, text) {
+  const value = new RegExp('(?:^|\\s)' + label + '\\s+([^\\s]+)').exec(text)?.[1]?.trim();
+  return value ? value.split(/[|,]/).map((item) => item.trim()).filter(Boolean) : undefined;
+}
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0)));
+}

package/dist/conversion.js

@@ -1,42 +1,4 @@
-const FAMILIES = {
-  type: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
-  typeConstraint: { field: 'typeConstraints', sourceKey: 'sourceTypes', targetKey: 'targetTypes' },
-  resourceTransfer: { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
-  resourceTransferConstraint: { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
-  'resource-transfer': { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
-  ownership: { field: 'resourceTransfers', sourceKey: 'sourceGraphs', targetKey: 'targetGraphs', graph: true },
-  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' },
-  borrowScope: { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  borrowScopeConstraint: { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  'borrow-scope': { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  'borrow-scope-constraint': { field: 'borrowScopeConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  borrowChecker: { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  borrowCheckerConstraint: { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  'borrow-checker': { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  'borrow-checker-constraint': { field: 'borrowCheckerConstraints', sourceKey: 'sourceBorrowScopes', targetKey: 'targetBorrowScopes' },
-  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' }
-};
+import { FAMILIES, parseConstraintRecord } from './conversion-constraint-record.js';
 
 export function parseConversionBlock(block) {
   const name = nameFrom(block.header);
@@ -133,62 +95,13 @@ function addConstraint(plan, family, name, text) {
     metadata: { name, family, authoredConversionBlockId: plan.id }
   });
   const recordKey = role === 'target' ? config.targetKey : config.sourceKey;
-  entry[recordKey] = [config.graph ? resourceGraphFromRecord(record, entry) : record];
+  const recordValue = config.graph ? resourceGraphFromRecord(record, entry) : record;
+  for (const key of unique([recordKey, ...(role === 'target' ? config.extraTargetKeys ?? [] : config.extraSourceKeys ?? [])])) {
+    entry[key] = [recordValue];
+  }
   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),
-    ownerId: readInlineWord('owner', text) ?? readInlineWord('ownerId', text),
-    ownerKind: readInlineWord('ownerKind', text),
-    mode: readInlineWord('mode', text) ?? readInlineWord('loanMode', text),
-    aliasKind: readInlineWord('aliasKind', text),
-    moveKind: readInlineWord('moveKind', text),
-    dropKind: readInlineWord('dropKind', text),
-    resourceKind: readInlineWord('resourceKind', text),
-    scopeKind: readInlineWord('scopeKind', text),
-    typeKind: readInlineWord('typeKind', text),
-    signatureHash: readInlineWord('signatureHash', text),
-    contractHash: readInlineWord('contractHash', text),
-    typeHash: readInlineWord('typeHash', text),
-    flowKind: readInlineWord('flowKind', text),
-    controlFlowKind: readInlineWord('controlFlowKind', text),
-    sourceControlFlowId: readInlineWord('sourceControlFlowId', 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),
-    lifetimeRegionId: readInlineWord('lifetimeRegion', text) ?? readInlineWord('lifetimeRegionId', 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 resourceGraphFromRecord(record, entry) {
   const tokens = lowerTokens(record);
   const resourceId = record.resourceId ?? record.symbolId ?? `${record.id}_resource`;

package/dist/view.js

@@ -34,20 +34,32 @@ function readViewEvents(body) {
 }
 
 function readRenderNodes(body) {
-  return readNestedBlocks('render', body).map((block) => {
-    const tagName = nameFrom(block.header);
-    const props = readRenderProps(block.body);
-    const events = readRenderEvents(block.body);
-    return {
-      id: idFrom(block.header, `render_${tagName}`),
-      kind: readInlineWord('kind', block.header) ?? 'element',
-      tagName,
-      identityKey: readLine('identity', block.body) ?? readLine('key', block.body),
-      text: readQuotedLine('text', block.body),
-      props: props.length ? props : undefined,
-      events: events.length ? events : undefined
-    };
-  });
+  const renders = [];
+  for (const block of readNestedBlocks('render', body)) pushRenderNode(block, renders);
+  return renders;
+}
+
+function pushRenderNode(block, renders) {
+  const headerName = nameFrom(block.header);
+  const ownBody = stripNestedBlocks('render', block.body);
+  const kind = readInlineWord('kind', block.header) ?? readLine('kind', ownBody) ?? 'element';
+  const props = readRenderProps(ownBody);
+  const events = readRenderEvents(ownBody);
+  const childBlocks = readNestedBlocks('render', block.body);
+  const explicitChildren = readList('children', ownBody) ?? readList('child', ownBody);
+  const nestedChildren = childBlocks.map((child) => idFrom(child.header, `render_${nameFrom(child.header)}`));
+  renders.push(compactRecord({
+    id: idFrom(block.header, `render_${headerName}`),
+    kind,
+    tagName: readLine('tag', ownBody) ?? readLine('tagName', ownBody) ?? (kind === 'component' || kind === 'text' ? undefined : headerName),
+    component: readLine('component', ownBody) ?? (kind === 'component' ? headerName : undefined),
+    identityKey: readLine('identity', ownBody) ?? readLine('key', ownBody),
+    text: readQuotedLine('text', ownBody),
+    props: props.length ? props : undefined,
+    events: events.length ? events : undefined,
+    children: uniqueStrings([...(explicitChildren ?? []), ...nestedChildren])
+  }));
+  for (const child of childBlocks) pushRenderNode(child, renders);
 }
 
 function readRenderProps(body) {
@@ -92,6 +104,8 @@ function readLine(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\n
 function readQuotedLine(label, body) { return new RegExp(`^\\s*${label}\\s+["']([^"']+)["']`, 'm').exec(body)?.[1]; }
 function readInlineWord(label, text = '') { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
 function readRenderValue(value) { const quoted = /^["']([^"']+)["']$/.exec(value.trim()); return quoted ? { value: quoted[1] } : { expression: value.trim() }; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueStrings(values) { const result = []; for (const value of values) if (value && !result.includes(value)) result.push(value); return result.length ? result : undefined; }
 function parseOptionalTypeExpression(value) { return value ? parseTypeExpression(value.trim()) : undefined; }
 function parseTypeExpression(value) {
   const text = value.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "description": "Parser for the first Frontier Lang .frontier syntax slice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   ],
   "scripts": {
     "build": "node scripts/build.mjs",
-    "test": "npm run build && node test/smoke.mjs && node test/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs && node test/dialect-registry-smoke.mjs",
+    "test": "npm run build && node test/smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/view-render-graph-smoke.mjs && node test/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs && node test/dialect-registry-smoke.mjs",
     "typecheck": "node ./node_modules/typescript/bin/tsc --noEmit -p test/tsconfig.json",
     "fuzz": "npm run build && node fuzz/smoke.mjs",
     "bench": "npm run build && node bench/smoke.mjs",