@shapeshift-labs/frontier-lang-parser 0.3.32 → 0.3.34

package/README.md

@@ -220,6 +220,22 @@ 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.
 
+## Source syntax reports
+
+Use `inspectFrontierSourceSyntax` when a `.frontier` file is being treated as authored source, not only as convenient input to `parseFrontierSource`. It returns a `frontier.lang.sourceSyntaxReport` with every module-level or top-level declaration block the parser can see, whether that block kind is recognized, and any unsupported block kinds that would make a translation or merge proof fail closed.
+
+```js
+import { inspectFrontierSourceSyntax } from '@shapeshift-labs/frontier-lang-parser';
+
+const report = inspectFrontierSourceSyntax(source);
+
+if (report.summary.failClosed) {
+  console.error(report.summary.unknownKinds);
+}
+```
+
+Nested child syntax such as `render` blocks inside a `view` is not reported as an unknown top-level block; the parent parser owns those child rows. The report is evidence about parser coverage only. It keeps `autoMergeClaim` and `semanticEquivalenceClaim` false.
+
 ## Authored view render graph syntax
 
 `.frontier` view blocks can describe UI render graphs directly. Nested `render`
@@ -473,7 +489,7 @@ 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.
 
-`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`, `callable-boundary`, `adt-pattern`, `data-layout`, `numeric-semantics`, `text-semantics`, `collection-semantics`, `serialization-semantics`, `dependency-semantics`, `object-model`, and `protocol`. The parser preserves family-specific fields such as module specifiers, package conditions, binding/reference ids, memory ordering, locks, capabilities, host permissions, callable signatures, pattern exhaustiveness, ABI/layout hints, numeric/text/collection behavior, wire formats, dependency lockfile evidence, 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.
+`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`, `callable-boundary`, `adt-pattern`, `data-layout`, `layout-style`, `layout`, `style`, `numeric-semantics`, `text-semantics`, `collection-semantics`, `serialization-semantics`, `dependency-semantics`, `object-model`, and `protocol`. The parser preserves family-specific fields such as module specifiers, package conditions, binding/reference ids, memory ordering, locks, capabilities, host permissions, callable signatures, pattern exhaustiveness, ABI/layout hints, selector/style/cascade/layout evidence, numeric/text/collection behavior, wire formats, dependency lockfile evidence, and effect adapters as authored evidence inputs. Constraint entries and family-specific records can also carry `sourceMap`, `sourceMapMapping`, `proofObligation`, `proofEvidence`, `missingEvidence`, and `failClosed` so downstream compiler, merge, and admission tooling can keep source-bound denominators visible. 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 runtime capability syntax
 

package/dist/conversion-constraint-record.js

@@ -8,6 +8,7 @@ const FAMILY_ROWS = [
   ['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'] }],
+  ['layoutStyle', 'layoutStyleConstraints', 'sourceLayoutStyles', 'targetLayoutStyles', ['layoutStyleConstraint', 'layout-style', 'layout-style-constraint', 'layout', 'layoutConstraint', 'layout-constraint', 'style', 'styleConstraint', 'style-constraint', 'css-style', 'css-rule', 'style-layout', 'render-layout'], { extraSourceKeys: ['sourceLayoutStyleRecords'], extraTargetKeys: ['targetLayoutStyleRecords'] }],
   ['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'] }],
@@ -48,7 +49,7 @@ const WORD_FIELDS = [
   ['controlFlowKind'], ['sourceControlFlowId'], ['sourceId', 'from', 'sourceId'], ['targetId', 'to', 'targetId'], ['label'],
   ['conditionHash'], ['orderingKey', 'orderingKey', 'orderKey'], ['lifetimeKind'], ['lifetimeRegionId', 'lifetimeRegion', 'lifetimeRegionId'],
   ['regionKind'], ['resourceId', 'resource', 'resourceId'],
-  ['functionName'], ['methodName'], ['callableName'], ['callableKind'], ['callSignatureHash'],
+  ['functionName'], ['methodName'], ['callableName'], ['callableKind'], ['callSignatureHash'], ['restParameter', 'restParameter', 'rest'],
   ['receiverKind', 'receiverKind', 'receiver'], ['thisBinding'], ['selfBinding'], ['returnKind', 'returnKind', 'returnType'],
   ['asyncKind', 'asyncKind', 'asyncMode'], ['generatorKind', 'generatorKind', 'yieldKind'], ['callbackKind'],
   ['closureCapture', 'closureCapture', 'captureKind'], ['overloadSet', 'overloadSet', 'overloads'],
@@ -57,7 +58,7 @@ const WORD_FIELDS = [
   ['symbolKind'], ['relationKind'], ['representationKind'], ['typeId', 'typeId', 'nodeId'], ['nodeId'], ['structId'], ['unionId'],
   ['enumId'], ['fieldId'], ['bitfieldId'], ['endianness', 'endianness', 'endian'], ['repr', 'repr', 'reprAttribute'],
   ['numericKind', 'numericKind', 'numberKind'], ['numberKind'], ['numericTypeName'], ['signedness'], ['overflowMode', 'overflowMode', 'overflowBehavior'],
-  ['divisionMode', 'divisionMode', 'integerDivisionMode'], ['moduloMode', 'moduloMode', 'remainderMode'], ['floatPrecision'], ['roundingMode'],
+  ['divisionMode', 'divisionMode', 'integerDivisionMode'], ['moduloMode', 'moduloMode', 'remainderMode'], ['floatFormat'], ['floatPrecision'], ['roundingMode'],
   ['separatorPolicy'], ['coercionKind', 'coercionKind', 'conversionKind'], ['conversionKind'], ['literalKind'],
   ['textKind', 'textKind', 'stringKind'], ['stringKind'], ['stringTypeName'], ['encoding', 'encoding', 'charset', 'codepage'],
   ['charset'], ['codepage'], ['codeUnit', 'codeUnit', 'codeUnitWidth'], ['indexingUnit', 'indexingUnit', 'indexUnit'],
@@ -83,15 +84,19 @@ const WORD_FIELDS = [
   ['buildTool', 'buildTool', 'builder'], ['packageManagerVersion', 'packageManagerVersion', 'managerVersion'],
   ['offlineCache', 'offlineCache', 'cachePolicy'], ['dedupeHoist', 'dedupeHoist', 'hoistPolicy'], ['provenance', 'provenance', 'sourceProvenance'],
   ['trust', 'trust', 'supplyChainTrust'], ['concurrencyKind'], ['constructId', 'constructId', 'taskId', 'threadId', 'actorId', 'channelId'],
-  ['taskId'], ['threadId'], ['executor', 'executor', 'queue', 'runtime'], ['executorId'], ['isolationKey'], ['cancellationKey', 'cancellationKey', 'signalId', 'contextId'],
+  ['taskId'], ['threadId'], ['scheduler'], ['executor', 'executor', 'queue', 'runtime'], ['executorId'], ['isolationKey'], ['cancellationKey', 'cancellationKey', 'signalId', 'contextId'],
   ['signalId'], ['contextId'], ['errorKind'], ['errorType', 'errorType', 'exceptionType', 'resultType'], ['exceptionType'], ['resultType'],
   ['boundaryId', 'boundaryId', 'catchId', 'handlerId'], ['catchId'], ['handlerId'], ['evaluationKind', 'evaluationKind', 'expressionKind'],
   ['expressionKind'], ['expressionId', 'expressionId', 'nodeId'], ['operator'], ['evaluationOrder', 'evaluationOrder', 'order'],
   ['expansionKind', 'expansionKind', 'macroKind', 'templateKind', 'decoratorKind', 'generatorKind'], ['macroKind'], ['templateKind'],
   ['decoratorKind'], ['expansionId'], ['generatorId'], ['generatedSourcePath'], ['expandedHash', 'expandedHash', 'generatedHash'],
-  ['generatedHash'], ['classId'], ['classKind'], ['prototypeId'], ['mixinId'], ['constructorId'], ['inheritanceKind'], ['referenceSemantics'],
+  ['generatedHash'], ['classId'], ['classKind'], ['prototypeId'], ['mixinId'], ['methodId'], ['constructorId'], ['inheritanceKind'], ['referenceSemantics'],
   ['valueSemantics'], ['protocolKind'], ['protocolName'], ['traitName'], ['interfaceName'], ['subjectName', 'subjectName', 'receiverName', 'implementedFor'],
-  ['implementedFor'], ['sourcePath', 'sourcePath', 'path'], ['sourceHash'], ['target', 'effectTarget', 'targetResource']
+  ['implementedFor'], ['sourcePath', 'sourcePath', 'path'], ['sourceHash'], ['selector'], ['value'], ['styleProperty', 'styleProperty', 'property', 'cssProperty'],
+  ['cssProperty', 'cssProperty', 'styleProperty', 'property'], ['computedValue'], ['cascadeLayer'], ['specificity'], ['mediaQuery'],
+  ['containerQuery'], ['boxModel'], ['display'], ['position'], ['zIndex'], ['writingMode'], ['direction'], ['viewport'], ['renderTreeId'],
+  ['styleRuleId'], ['computedStyleHash'], ['layoutSnapshotHash'], ['bitmapHash'], ['accessibilityTreeHash'], ['focusOrderHash'],
+  ['target', 'effectTarget', 'targetResource']
 ];
 const LIST_FIELDS = [
   ['factKinds', 'fact', 'facts', 'factKind', 'factKinds'], ['importAttributes', 'importAttribute', 'importAttributes', 'assertion', 'assertions'],
@@ -108,14 +113,20 @@ const LIST_FIELDS = [
   ['devDependencies'], ['features', 'features', 'extras', 'flags'], ['lifecycleScripts', 'lifecycleScripts', 'scripts'],
   ['requirementNames', 'requirementNames', 'requirements', 'methods', 'members'], ['associatedTypeNames', 'associatedTypeNames', 'associatedTypes'],
   ['boundNames', 'boundNames', 'bounds', 'traitBounds', 'protocolBounds', 'whereBounds'], ['implementationKinds', 'implementationKinds', 'implKinds', 'implementations'],
-  ['dispatchKinds', 'dispatchKinds', 'dispatchModes'], ['coherenceKinds', 'coherenceKinds', 'coherenceRules'], ['evidenceIds', 'evidence', 'evidenceIds']
+  ['dispatchKinds', 'dispatchKinds', 'dispatchModes'], ['coherenceKinds', 'coherenceKinds', 'coherenceRules'],
+  ['sourceMapIds', 'sourceMap', 'sourceMaps', 'sourceMapId', 'sourceMapIds'],
+  ['sourceMapMappingIds', 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingId', 'sourceMapMappingIds'],
+  ['proofObligationIds', 'proofObligation', 'proofObligations', 'proofObligationId', 'proofObligationIds', 'obligation', 'obligations'],
+  ['proofEvidenceIds', 'proofEvidence', 'proofEvidenceId', 'proofEvidenceIds'],
+  ['missingEvidence', 'missingEvidence', 'missingEvidenceIds'],
+  ['evidenceIds', 'evidence', 'evidenceIds']
 ];
 const NUMBER_FIELDS = [
   ['arity'], ['size'], ['alignment'], ['parameterCount'], ['requiredParameterCount'], ['optionalParameterCount'],
   ['sizeBytes'], ['alignmentBytes'], ['offsetBytes'], ['pointerWidth'], ['integerWidth'], ['bitWidth'], ['width'],
   ['codeUnitWidth'], ['indexBase']
 ];
-const FLAG_FIELDS = ['nullable', 'optional', 'publicContract', 'closure', 'captured', 'writeExpr', 'mutable', 'shadowed', 'hoisted', 'typeOnly', 'isTypeReference', 'isValueReference', 'shared', 'volatile', 'atomic', 'adapterRequired', 'async', 'generator', 'exceptional', 'cancellable', 'variadic', 'signed', 'nan', 'infinity', 'deterministic', 'streaming', 'framing', 'copyOnWrite', 'multipleInheritance', 'reflection', 'staticDispatch', 'virtual', 'spawn', 'await', 'structured', 'reentrant', 'cancelable'];
+const FLAG_FIELDS = ['nullable', 'optional', 'publicContract', 'closure', 'captured', 'writeExpr', 'mutable', 'shadowed', 'hoisted', 'typeOnly', 'isTypeReference', 'isValueReference', 'shared', 'volatile', 'atomic', 'adapterRequired', 'async', 'generator', 'exceptional', 'cancellable', 'variadic', 'signed', 'nan', 'infinity', 'deterministic', 'streaming', 'framing', 'copyOnWrite', 'multipleInheritance', 'reflection', 'staticDispatch', 'virtual', 'spawn', 'await', 'structured', 'reentrant', 'cancelable', 'failClosed'];
 
 export const FAMILIES = Object.freeze(Object.fromEntries(FAMILY_ROWS.flatMap(([name, field, sourceKey, targetKey, aliases = [], extra = {}]) => {
   const config = { field, sourceKey, targetKey, ...extra };

package/dist/conversion.js

@@ -88,10 +88,15 @@ function addConstraint(plan, family, name, text) {
     sourceLanguage: readInlineWord('sourceLanguage', text) ?? plan.sourceLanguage,
     target: readInlineWord('targetLanguage', text) ?? plan.targets[0],
     mode: readInlineWord('mode', text),
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMaps', 'sourceMapId', 'sourceMapIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappings', 'sourceMapMappingId', 'sourceMapMappingIds'),
+    proofObligationIds: readInlineList(text, 'proofObligation', 'proofObligations', 'proofObligationId', 'proofObligationIds', 'obligation', 'obligations'),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceId', 'proofEvidenceIds'),
     evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
     missingEvidence: readInlineList(text, 'missingEvidence'),
     blockers: readInlineList(text, 'blocker', 'blockers'),
     review: readInlineList(text, 'review'),
+    failClosed: readInlineFlag('failClosed', text),
     metadata: { name, family, authoredConversionBlockId: plan.id }
   });
   const recordKey = role === 'target' ? config.targetKey : config.sourceKey;
@@ -113,6 +118,12 @@ function resourceGraphFromRecord(record, entry) {
     sourcePath: record.sourcePath,
     sourceHash: record.sourceHash,
     evidenceIds,
+    sourceMapIds: record.sourceMapIds ?? entry.sourceMapIds,
+    sourceMapMappingIds: record.sourceMapMappingIds ?? entry.sourceMapMappingIds,
+    proofObligationIds: record.proofObligationIds ?? entry.proofObligationIds,
+    proofEvidenceIds: record.proofEvidenceIds ?? entry.proofEvidenceIds,
+    missingEvidence: record.missingEvidence ?? entry.missingEvidence,
+    failClosed: record.failClosed ?? entry.failClosed,
     resources: [{
       id: resourceId,
       resourceKind: record.resourceKind ?? record.kind ?? record.constraintKind,

package/dist/index.d.ts

@@ -1,4 +1,47 @@
 import type { FrontierLangDocument } from '@shapeshift-labs/frontier-lang-kernel';
 export interface ParseFrontierOptions { readonly id?: string; readonly name?: string; }
+export declare const FrontierSourceBlockKinds: readonly string[];
+export interface FrontierSourceBlockSyntaxRecord {
+  readonly kind: string;
+  readonly name: string;
+  readonly id?: string;
+  readonly header: string;
+  readonly startOffset: number;
+  readonly endOffset: number;
+  readonly bodyStartOffset: number;
+  readonly bodyEndOffset: number;
+  readonly location: { readonly line: number; readonly column: number; readonly offset: number };
+  readonly moduleId?: string;
+  readonly moduleName?: string;
+  readonly recognized: boolean;
+}
+export interface FrontierUnknownSourceBlockSyntaxRecord extends FrontierSourceBlockSyntaxRecord {
+  readonly recognized: false;
+  readonly reason: 'unsupported-top-level-block';
+}
+export interface FrontierSourceSyntaxReport {
+  readonly kind: 'frontier.lang.sourceSyntaxReport';
+  readonly version: 1;
+  readonly documentId: string;
+  readonly documentName: string;
+  readonly blocks: readonly FrontierSourceBlockSyntaxRecord[];
+  readonly recognizedBlocks: readonly FrontierSourceBlockSyntaxRecord[];
+  readonly unknownBlocks: readonly FrontierUnknownSourceBlockSyntaxRecord[];
+  readonly summary: {
+    readonly blockCount: number;
+    readonly recognizedBlockCount: number;
+    readonly unknownBlockCount: number;
+    readonly recognizedKinds: readonly string[];
+    readonly unknownKinds: readonly string[];
+    readonly failClosed: boolean;
+    readonly unsupportedSyntax: boolean;
+  };
+  readonly metadata: {
+    readonly sourceBytes: number;
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+  };
+}
+export declare function inspectFrontierSourceSyntax(source: string, options?: ParseFrontierOptions): FrontierSourceSyntaxReport;
 export declare function parseFrontierSource(source: string, options?: ParseFrontierOptions): FrontierLangDocument;
 export declare function parseFrontierFile(name: string, source: string): FrontierLangDocument;

package/dist/index.js

@@ -16,6 +16,8 @@ import { parseRuntimeCapabilityBlock } from './runtime-capability.js';
 import { parseNativeSourceBlock } from './source-evidence.js';
 import { parseTargetProjectionMetadata } from './target-projection.js';
 import { parseViewBlock } from './view.js';
+import { FrontierSourceBlockKinds } from './source-syntax-report.js';
+export { FrontierSourceBlockKinds, inspectFrontierSourceSyntax } from './source-syntax-report.js';
 
 export function parseFrontierSource(source, options = {}) {
   const nodes = [];
@@ -76,7 +78,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|constraintSpace|possibilitySpace|decisionGraph|admissionGraph|dialectRegistry|universalDialectRegistry|interlingua|universalInterlingua|resourceGraph|semanticResourceGraph|packageManifest|packageGraph|packageSurface|canvasSurface|canvasGraph|applicationSurface|appHost|plugin|pluginSurface|pluginContract|runtimeCapabilities|runtimeCapabilityMatrix|runtimeHosts)\s+([^{}]+)\{/g;
+  const header = new RegExp('\\b(' + FrontierSourceBlockKinds.join('|') + ')\\s+([^{}]+)\\{', 'g');
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/source-syntax-report.js

@@ -0,0 +1,170 @@
+export const FrontierSourceBlockKinds = Object.freeze([
+  'entity',
+  'state',
+  'action',
+  'view',
+  'migration',
+  'capability',
+  'effect',
+  'type',
+  'extern',
+  'lattice',
+  'nativeSource',
+  'target',
+  'proof',
+  'paradigm',
+  'paradigmSemantics',
+  'operations',
+  'semanticOperations',
+  'conversion',
+  'universalConversionPlan',
+  'constraintSpace',
+  'possibilitySpace',
+  'decisionGraph',
+  'admissionGraph',
+  'dialectRegistry',
+  'universalDialectRegistry',
+  'interlingua',
+  'universalInterlingua',
+  'resourceGraph',
+  'semanticResourceGraph',
+  'packageManifest',
+  'packageGraph',
+  'packageSurface',
+  'canvasSurface',
+  'canvasGraph',
+  'applicationSurface',
+  'appHost',
+  'plugin',
+  'pluginSurface',
+  'pluginContract',
+  'runtimeCapabilities',
+  'runtimeCapabilityMatrix',
+  'runtimeHosts'
+]);
+
+const FrontierSourceBlockKindSet = new Set(FrontierSourceBlockKinds);
+
+export function inspectFrontierSourceSyntax(source, options = {}) {
+  const documentId = options.id ?? readId(source) ?? 'mod_frontier';
+  const documentName = options.name ?? readName(source) ?? 'FrontierModule';
+  const blocks = readCandidateDeclarationBlocks(source).map((block) => ({
+    ...block,
+    recognized: FrontierSourceBlockKindSet.has(block.kind)
+  }));
+  const recognizedBlocks = blocks.filter((block) => block.recognized);
+  const unknownBlocks = blocks.filter((block) => !block.recognized).map((block) => ({
+    ...block,
+    reason: 'unsupported-top-level-block'
+  }));
+  return {
+    kind: 'frontier.lang.sourceSyntaxReport',
+    version: 1,
+    documentId,
+    documentName,
+    blocks,
+    recognizedBlocks,
+    unknownBlocks,
+    summary: {
+      blockCount: blocks.length,
+      recognizedBlockCount: recognizedBlocks.length,
+      unknownBlockCount: unknownBlocks.length,
+      recognizedKinds: unique(recognizedBlocks.map((block) => block.kind)),
+      unknownKinds: unique(unknownBlocks.map((block) => block.kind)),
+      failClosed: unknownBlocks.length > 0,
+      unsupportedSyntax: unknownBlocks.length > 0
+    },
+    metadata: {
+      sourceBytes: source.length,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+function readCandidateDeclarationBlocks(source) {
+  const moduleRanges = readModuleRanges(source);
+  const blocks = [];
+  const header = /(^|\n)\s*([A-Za-z_$][\w$]*)\s+([^{}\n]+)\{/g;
+  let match;
+  while ((match = header.exec(source))) {
+    const fullStart = match.index + match[1].length;
+    const leading = /^\s*/.exec(source.slice(fullStart))?.[0].length ?? 0;
+    const start = fullStart + leading;
+    const kind = match[2];
+    if (kind === 'module') continue;
+    const open = header.lastIndex - 1;
+    const close = findMatchingBrace(source, open);
+    const depth = braceDepthBefore(source, start);
+    const moduleRange = moduleRanges.find((range) => start > range.open && start < range.close);
+    const declarationDepth = moduleRange ? moduleRange.depth + 1 : 0;
+    if (depth !== declarationDepth) continue;
+    const headerText = match[3].trim();
+    blocks.push({
+      kind,
+      name: nameFrom(headerText),
+      id: idFrom(headerText),
+      header: headerText,
+      startOffset: start,
+      endOffset: close + 1,
+      bodyStartOffset: open + 1,
+      bodyEndOffset: close,
+      location: sourcePosition(source, start),
+      moduleId: moduleRange?.id,
+      moduleName: moduleRange?.name
+    });
+  }
+  return blocks;
+}
+
+function readModuleRanges(source) {
+  const ranges = [];
+  const header = /(^|\n)\s*module\s+([^{}\n]+)\{/g;
+  let match;
+  while ((match = header.exec(source))) {
+    const fullStart = match.index + match[1].length;
+    const leading = /^\s*/.exec(source.slice(fullStart))?.[0].length ?? 0;
+    const start = fullStart + leading;
+    const open = header.lastIndex - 1;
+    const close = findMatchingBrace(source, open);
+    ranges.push({
+      start,
+      open,
+      close,
+      depth: braceDepthBefore(source, start),
+      name: nameFrom(match[2].trim()),
+      id: idFrom(match[2].trim())
+    });
+  }
+  return ranges;
+}
+
+function findMatchingBrace(source, open) {
+  let depth = 1;
+  for (let index = open + 1; index < source.length; index++) {
+    if (source[index] === '{') depth++;
+    if (source[index] === '}') depth--;
+    if (depth === 0) return index;
+  }
+  return source.length - 1;
+}
+
+function braceDepthBefore(source, offset) {
+  let depth = 0;
+  for (let index = 0; index < offset; index++) {
+    if (source[index] === '{') depth++;
+    if (source[index] === '}') depth = Math.max(0, depth - 1);
+  }
+  return depth;
+}
+
+function sourcePosition(source, offset) {
+  const lines = source.slice(0, offset).split('\n');
+  return { line: lines.length, column: lines[lines.length - 1].length + 1, offset };
+}
+
+function readName(source) { return /module\s+([A-Za-z_$][\w$]*)/.exec(source)?.[1]; }
+function readId(source) { return /module\s+[A-Za-z_$][\w$]*\s+@id\(\s*["']([^"']+)["']\s*\)/.exec(source)?.[1]; }
+function idFrom(header) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(header)?.[1]; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Unnamed'; }
+function unique(values) { return [...new Set(values.filter(Boolean))]; }

package/package.json

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