@shapeshift-labs/frontier-lang-parser 0.3.28 → 0.3.30

package/README.md

@@ -309,6 +309,49 @@ Runtime probes, package-manager solver output, lockfile proof, browser pixels,
 worker transfer evidence, and GPU validation must still be supplied by higher
 layers before admission.
 
+## Authored application and plugin syntax
+
+`.frontier` files can describe application composition boundaries directly.
+These blocks make host/plugin contracts source-level objects: mount points,
+provided surfaces, required capabilities, routes, events, assets, gates, and
+proof gaps can be queried by projection and merge tooling without collapsing
+them into a target-language implementation detail.
+
+```frontier
+appHost WorkbenchHost @id("app_surface_workbench") {
+  role host
+  sourcePath app.frontier
+  sourceHash sha256:host
+  evidence previewProbe @id("evidence_preview_probe") kind browser-probe status passed path reports/preview.json
+  mount dashboard @id("app_mount_dashboard") kind region path /dashboard view view_dashboard target react evidence evidence_preview_probe
+  provides shell @id("app_provide_shell") surface view view view_dashboard mount app_mount_dashboard capability host.fetch|host.storage evidence evidence_preview_probe
+  requires fetch @id("app_require_fetch") capability host.fetch category network permission network proofGap app-host-capability-adapter-boundary evidence evidence_preview_probe
+  route dashboard @id("app_route_dashboard") path /dashboard view view_dashboard action action_refresh mount app_mount_dashboard evidence evidence_preview_probe
+  gate preview @id("app_gate_preview") kind browser-probe command "npm run preview:probe" required subject view_dashboard evidence evidence_preview_probe
+  gap pluginAbi @id("app_gap_plugin_abi") code plugin-abi-compatibility-boundary summary "Plugin ABI requires host/runtime compatibility proof."
+}
+
+plugin WeatherWidget @id("plugin_weather_widget") {
+  role plugin
+  host app_surface_workbench
+  sourcePath plugins/weather.frontier
+  sourceHash sha256:plugin
+  evidence sandboxProbe @id("evidence_sandbox_probe") kind sandbox-probe status passed path reports/sandbox.json
+  provides weatherPanel @id("plugin_provide_weather") surface view view view_weather_panel mount app_mount_dashboard capability host.fetch proofGap plugin-projection-runtime-boundary evidence evidence_sandbox_probe
+  requires fetch @id("plugin_require_fetch") capability host.fetch category network permission network adapter host_fetch_adapter proofGap plugin-capability-grant-boundary evidence evidence_sandbox_probe
+  gate sandbox @id("plugin_gate_sandbox") kind sandbox command "npm run sandbox:probe" required subject view_weather_panel evidence evidence_sandbox_probe
+  gap sandbox @id("plugin_gap_sandbox") code plugin-sandbox-safety-boundary summary "Sandbox safety requires runtime proof."
+}
+```
+
+The parser stores these blocks in `metadata.applicationSurfaces` and mirrors
+them under `metadata.universalAst.applicationSurfaces`. They are composition
+contracts, not compatibility proof: `runtimeEquivalenceClaim`,
+`autoMergeClaim`, `semanticEquivalenceClaim`, `abiCompatibilityClaim`,
+`projectionEquivalenceClaim`, `pluginCompatibilityClaim`, and
+`sandboxSafetyClaim` remain false until a higher layer supplies source-bound
+runtime, ABI, projection, sandbox, and admission evidence.
+
 ## 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.

package/dist/application-surface.js

@@ -0,0 +1,308 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function parseApplicationSurfaceBlock(block) {
+  const name = nameFrom(block.header);
+  const surfaceKind = surfaceKindFrom(block.kind);
+  const role = readLine('role', block.body) ?? defaultRole(surfaceKind);
+  const sourcePath = readLine('sourcePath', block.body) ?? readLine('path', block.body);
+  const sourceHash = readLine('sourceHash', block.body);
+  const evidence = parseEvidenceRows(block.body);
+  const records = [];
+  const proofGaps = [];
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || isPropertyLine(line)) continue;
+    const match = /^(mount|provide|provides|required|requires|require|route|event|asset|gate|gap|proofGap)\s+([A-Za-z_$@/.*][\w$./@:*+-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, rest] = match;
+    if (rowKind === 'gap' || rowKind === 'proofGap') {
+      proofGaps.push(applicationProofGap(rowName, rest));
+      continue;
+    }
+    records.push(applicationRecord(normalizeRowKind(rowKind), rowName, rest, {
+      surfaceId: idFrom(block.header, `application_surface_${safeId(name)}`),
+      surfaceName: name,
+      role,
+      sourcePath,
+      sourceHash
+    }));
+  }
+  const allGaps = [...records.flatMap((record) => record.proofGaps ?? []), ...proofGaps];
+  const tree = {
+    kind: 'frontier.lang.applicationSurface',
+    version: 1,
+    id: idFrom(block.header, `application_surface_${safeId(name)}`),
+    name,
+    surfaceKind,
+    role,
+    hostId: readLine('host', block.body) ?? readLine('hostId', block.body),
+    sourcePath,
+    sourceHash,
+    records,
+    proofGaps: allGaps,
+    evidence,
+    parser: { status: 'authored', errors: [] },
+    claims: applicationFalseClaims(),
+    metadata: { authoredName: name, authoredBlockKind: block.kind }
+  };
+  tree.summary = summarizeApplicationSurface(tree);
+  tree.treeHash = hashSemanticValue({
+    kind: 'frontier.lang.applicationSurface.authoredTree.v1',
+    role,
+    records: records.map(hashableRecord),
+    proofGaps: allGaps.map((gap) => gap.code)
+  });
+  return tree;
+}
+
+export function mergeApplicationSurfaceBlocks(blocks) {
+  const records = blocks.flatMap((block) => block.records ?? []);
+  const evidenceIds = [
+    ...blocks.flatMap((block) => ids(block.evidence)),
+    ...records.flatMap((record) => record.evidenceIds ?? []),
+    ...records.flatMap((record) => record.proofEvidenceIds ?? [])
+  ];
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'applicationSurfaces:source',
+    surfaces: blocks,
+    surfaceIds: ids(blocks),
+    recordIds: ids(records),
+    mountIds: idsByRecordKind(records, 'mount'),
+    providedSurfaceIds: idsByRecordKind(records, 'provided-surface'),
+    requiredCapabilityIds: idsByRecordKind(records, 'required-capability'),
+    routeIds: idsByRecordKind(records, 'route'),
+    eventIds: idsByRecordKind(records, 'event'),
+    assetIds: idsByRecordKind(records, 'asset'),
+    gateIds: idsByRecordKind(records, 'gate'),
+    evidenceIds: [...new Set(evidenceIds.filter(Boolean))],
+    proofGapCodes: [...new Set(blocks.flatMap((block) => (block.proofGaps ?? []).map((gap) => gap.code).filter(Boolean)))],
+    summary: {
+      surfaceCount: blocks.length,
+      recordCount: records.length,
+      mountCount: blocks.reduce((total, block) => total + (block.summary?.mountCount ?? 0), 0),
+      providedSurfaceCount: blocks.reduce((total, block) => total + (block.summary?.providedSurfaceCount ?? 0), 0),
+      requiredCapabilityCount: blocks.reduce((total, block) => total + (block.summary?.requiredCapabilityCount ?? 0), 0),
+      routeCount: blocks.reduce((total, block) => total + (block.summary?.routeCount ?? 0), 0),
+      eventCount: blocks.reduce((total, block) => total + (block.summary?.eventCount ?? 0), 0),
+      assetCount: blocks.reduce((total, block) => total + (block.summary?.assetCount ?? 0), 0),
+      gateCount: blocks.reduce((total, block) => total + (block.summary?.gateCount ?? 0), 0),
+      proofGapCount: blocks.reduce((total, block) => total + (block.proofGaps?.length ?? 0), 0)
+    },
+    claims: applicationFalseClaims(),
+    metadata: { authoredApplicationSurfaceIds: ids(blocks) }
+  };
+}
+
+function applicationRecord(kind, name, text, context) {
+  const recordName = readInlineWord('name', text) ?? name;
+  const proofGaps = readInlineList(text, 'proofGap', 'proofGaps', 'gap', 'gaps')?.map((code) => applicationProofGap(code, '')) ?? [];
+  const base = {
+    kind: 'frontier.lang.applicationSurface.record',
+    recordKind: kind,
+    id: idFrom(text, `application_${kind.replace(/-/g, '_')}_${safeId(recordName)}`),
+    name: recordName,
+    surfaceId: context.surfaceId,
+    surfaceName: context.surfaceName,
+    role: context.role,
+    identityKey: readInlineWord('identity', text) ?? readInlineWord('identityKey', text) ?? `${kind}:${context.role}:${recordName}`,
+    sourcePath: readInlineWord('sourcePath', text) ?? context.sourcePath,
+    sourceHash: readInlineWord('sourceHash', text) ?? context.sourceHash,
+    sourceSpan: parseSpan(readInlineWord('sourceSpan', text)),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    proofEvidenceIds: readInlineList(text, 'proofEvidence', 'proofEvidenceIds'),
+    missingEvidence: readInlineList(text, 'missingEvidence'),
+    proofGaps,
+    claims: applicationFalseClaims()
+  };
+  if (kind === 'mount') return cleanRecord({
+    ...base,
+    mountKind: readInlineWord('kind', text) ?? readInlineWord('mountKind', text) ?? 'region',
+    path: readInlineQuoted('path', text) ?? readInlineWord('path', text),
+    slot: readInlineWord('slot', text),
+    parentId: readInlineWord('parent', text) ?? readInlineWord('parentId', text),
+    viewId: readInlineWord('view', text) ?? readInlineWord('viewId', text),
+    target: readInlineWord('target', text),
+    renderer: readInlineWord('renderer', text)
+  });
+  if (kind === 'provided-surface') return cleanRecord({
+    ...base,
+    surfaceKind: readInlineWord('surface', text) ?? readInlineWord('surfaceKind', text) ?? readInlineWord('kind', text) ?? 'view',
+    viewId: readInlineWord('view', text) ?? readInlineWord('viewId', text),
+    actionId: readInlineWord('action', text) ?? readInlineWord('actionId', text),
+    effectId: readInlineWord('effect', text) ?? readInlineWord('effectId', text),
+    component: readInlineWord('component', text),
+    mountId: readInlineWord('mount', text) ?? readInlineWord('mountId', text),
+    routeId: readInlineWord('route', text) ?? readInlineWord('routeId', text),
+    capabilityIds: readInlineList(text, 'capability', 'capabilities', 'capabilityIds'),
+    target: readInlineWord('target', text),
+    language: readInlineWord('language', text),
+    contractId: readInlineWord('contract', text) ?? readInlineWord('contractId', text)
+  });
+  if (kind === 'required-capability') return cleanRecord({
+    ...base,
+    capability: readInlineWord('capability', text) ?? readInlineWord('capabilityId', text) ?? recordName,
+    category: readInlineWord('category', text),
+    permission: readInlineWord('permission', text),
+    adapterId: readInlineWord('adapter', text) ?? readInlineWord('adapterId', text),
+    hostId: readInlineWord('host', text) ?? readInlineWord('hostId', text),
+    runtime: readInlineWord('runtime', text),
+    target: readInlineWord('target', text)
+  });
+  if (kind === 'route') return cleanRecord({
+    ...base,
+    path: readInlineQuoted('path', text) ?? readInlineWord('path', text) ?? recordName,
+    method: readInlineWord('method', text),
+    viewId: readInlineWord('view', text) ?? readInlineWord('viewId', text),
+    actionId: readInlineWord('action', text) ?? readInlineWord('actionId', text),
+    mountId: readInlineWord('mount', text) ?? readInlineWord('mountId', text),
+    paramIds: readInlineList(text, 'param', 'params', 'paramIds')
+  });
+  if (kind === 'event') return cleanRecord({
+    ...base,
+    eventKind: readInlineWord('kind', text) ?? readInlineWord('eventKind', text),
+    eventName: readInlineWord('event', text) ?? readInlineWord('eventName', text) ?? recordName,
+    actionId: readInlineWord('action', text) ?? readInlineWord('actionId', text),
+    input: readInlineWord('input', text),
+    sourceId: readInlineWord('source', text) ?? readInlineWord('sourceId', text),
+    targetId: readInlineWord('target', text) ?? readInlineWord('targetId', text)
+  });
+  if (kind === 'asset') return cleanRecord({
+    ...base,
+    assetKind: readInlineWord('kind', text) ?? readInlineWord('assetKind', text),
+    path: readInlineQuoted('path', text) ?? readInlineWord('path', text),
+    assetHash: readInlineWord('hash', text) ?? readInlineWord('assetHash', text),
+    integrity: readInlineWord('integrity', text),
+    runtime: readInlineWord('runtime', text),
+    mountId: readInlineWord('mount', text) ?? readInlineWord('mountId', text)
+  });
+  if (kind === 'gate') return cleanRecord({
+    ...base,
+    gateKind: readInlineWord('kind', text) ?? readInlineWord('gateKind', text) ?? 'test',
+    command: readInlineQuoted('command', text) ?? readInlineWord('command', text),
+    required: readInlineFlag('required', text) ?? undefined,
+    status: readInlineWord('status', text),
+    subjectIds: readInlineList(text, 'subject', 'subjects', 'subjectIds'),
+    runtime: readInlineWord('runtime', text)
+  });
+  return cleanRecord(base);
+}
+
+function applicationProofGap(name, text) {
+  const code = readInlineWord('code', text) ?? name;
+  return cleanRecord({
+    id: idFrom(text, `application_gap_${safeId(code)}`),
+    code,
+    status: readInlineWord('status', text) ?? 'not-claimed',
+    summary: readInlineQuoted('summary', text) ?? readInlineQuoted('message', text),
+    failClosed: true,
+    ...applicationFalseClaims(),
+    sourceSpan: parseSpan(readInlineWord('sourceSpan', text))
+  });
+}
+
+function parseEvidenceRows(body) {
+  const records = [];
+  for (const rawLine of body.split('\n')) {
+    const line = rawLine.trim();
+    const match = /^(?:evidence|proofEvidence)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    records.push(cleanRecord({
+      id: idFrom(match[2], `evidence_${match[1]}`),
+      kind: readInlineWord('kind', match[2]) ?? 'note',
+      status: readInlineWord('status', match[2]) ?? 'unknown',
+      path: readInlineWord('path', match[2]),
+      summary: readInlineQuoted('summary', match[2]),
+      metadata: { name: match[1] }
+    }));
+  }
+  return records;
+}
+
+function summarizeApplicationSurface(tree) {
+  return {
+    recordCount: tree.records.length,
+    mountCount: count(tree.records, 'mount'),
+    providedSurfaceCount: count(tree.records, 'provided-surface'),
+    requiredCapabilityCount: count(tree.records, 'required-capability'),
+    routeCount: count(tree.records, 'route'),
+    eventCount: count(tree.records, 'event'),
+    assetCount: count(tree.records, 'asset'),
+    gateCount: count(tree.records, 'gate'),
+    evidenceCount: tree.evidence.length,
+    proofGapCount: tree.proofGaps.length,
+    parseErrors: tree.parser.errors.length
+  };
+}
+
+function applicationFalseClaims() {
+  return {
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    abiCompatibilityClaim: false,
+    projectionEquivalenceClaim: false,
+    pluginCompatibilityClaim: false,
+    sandboxSafetyClaim: false
+  };
+}
+
+function hashableRecord(record) {
+  return {
+    recordKind: record.recordKind,
+    name: record.name,
+    identityKey: record.identityKey,
+    capability: record.capability,
+    path: record.path,
+    viewId: record.viewId,
+    actionId: record.actionId,
+    proofGaps: record.proofGaps?.map((gap) => gap.code)
+  };
+}
+
+function normalizeRowKind(kind) {
+  if (kind === 'provide' || kind === 'provides') return 'provided-surface';
+  if (kind === 'require' || kind === 'requires' || kind === 'required') return 'required-capability';
+  return kind;
+}
+
+function surfaceKindFrom(kind) {
+  if (kind === 'appHost') return 'host';
+  if (kind === 'plugin' || kind === 'pluginSurface' || kind === 'pluginContract') return 'plugin';
+  return 'application';
+}
+
+function defaultRole(surfaceKind) {
+  if (surfaceKind === 'host') return 'host';
+  if (surfaceKind === 'plugin') return 'plugin';
+  return 'application';
+}
+
+function count(records, kind) { return records.filter((record) => record.recordKind === kind).length; }
+function ids(records = []) { return records.map((record) => record?.id).filter(Boolean); }
+function idsByRecordKind(records = [], kind) { return ids(records.filter((record) => record?.recordKind === kind)); }
+function isPropertyLine(line) { return /^(role|host|hostId|sourcePath|path|sourceHash|evidence|proofEvidence)\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] ?? 'ApplicationSurface'; }
+function readLine(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\n]+)', 'm').exec(body)?.[1]?.trim(); }
+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 parseSpan(value) {
+  if (!value) return undefined;
+  const match = /^(.+?):(\d+):(\d+)-(\d+):(\d+)$/.exec(value);
+  if (!match) return { path: value };
+  return { path: match[1], startLine: Number(match[2]), startColumn: Number(match[3]), endLine: Number(match[4]), endColumn: Number(match[5]) };
+}
+function cleanRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0) && (!value || typeof value !== 'object' || Object.keys(value).length > 0)));
+}
+function safeId(value) {
+  return String(value ?? 'unknown').replace(/[^A-Za-z0-9_$-]+/g, '_');
+}

package/dist/index.js

@@ -1,6 +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 { parseApplicationSurfaceBlock } from './application-surface.js';
 import { parseCanvasSurfaceBlock } from './canvas-surface.js';
 import { parseDecisionGraphBlock } from './decision-graph.js';
 import { parseDialectRegistryBlock } from './dialect-registry.js';
@@ -29,6 +30,7 @@ export function parseFrontierSource(source, options = {}) {
   const nativeSourceBlocks = [];
   const packageManifestBlocks = [];
   const canvasSurfaceBlocks = [];
+  const applicationSurfaceBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
   for (const block of readBlocks(source)) {
@@ -59,8 +61,9 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'resourceGraph' || block.kind === 'semanticResourceGraph') resourceGraphBlocks.push(parseResourceGraphBlock(block));
     if (block.kind === 'packageManifest' || block.kind === 'packageGraph' || block.kind === 'packageSurface') packageManifestBlocks.push(parsePackageManifestBlock(block));
     if (block.kind === 'canvasSurface' || block.kind === 'canvasGraph') canvasSurfaceBlocks.push(parseCanvasSurfaceBlock(block));
+    if (block.kind === 'applicationSurface' || block.kind === 'appHost' || block.kind === 'plugin' || block.kind === 'pluginSurface' || block.kind === 'pluginContract') applicationSurfaceBlocks.push(parseApplicationSurfaceBlock(block));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -70,7 +73,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)\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|dialectRegistry|universalDialectRegistry|interlingua|universalInterlingua|resourceGraph|semanticResourceGraph|packageManifest|packageGraph|packageSurface|canvasSurface|canvasGraph|applicationSurface|appHost|plugin|pluginSurface|pluginContract)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -1,4 +1,5 @@
 import { mergeDialectRegistryBlocks } from './dialect-registry.js';
+import { mergeApplicationSurfaceBlocks } from './application-surface.js';
 
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
@@ -23,7 +24,7 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -36,8 +37,9 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);
   if (packageManifestBlocks.length) metadata.packageManifests = mergePackageManifestBlocks(packageManifestBlocks);
   if (canvasSurfaceBlocks.length) metadata.canvasSurfaces = mergeCanvasSurfaceBlocks(canvasSurfaceBlocks);
-  if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length) || packageManifestBlocks.length || canvasSurfaceBlocks.length) {
-    metadata.universalAst = mergeUniversalAstBlocks(nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks);
+  if (applicationSurfaceBlocks.length) metadata.applicationSurfaces = mergeApplicationSurfaceBlocks(applicationSurfaceBlocks);
+  if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length) || packageManifestBlocks.length || canvasSurfaceBlocks.length || applicationSurfaceBlocks.length) {
+    metadata.universalAst = mergeUniversalAstBlocks(nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks, applicationSurfaceBlocks);
   }
   return Object.keys(metadata).length ? metadata : undefined;
 }
@@ -108,7 +110,7 @@ function mergeConstraintSpaceBlocks(blocks) {
   };
 }
 
-function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfaceBlocks = []) {
+function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfaceBlocks = [], applicationSurfaceBlocks = []) {
   return {
     id: blocks.length === 1 ? `universalAst:${blocks[0].node.id}` : 'universalAst:source',
     nativeSourceIds: blocks.map((block) => block.node.id),
@@ -118,12 +120,15 @@ function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfa
     losses: blocks.flatMap((block) => block.losses ?? []),
     packageManifests: packageManifestBlocks,
     canvasSurfaces: canvasSurfaceBlocks,
+    applicationSurfaces: applicationSurfaceBlocks,
     packageManifestIds: ids(packageManifestBlocks),
     canvasSurfaceIds: ids(canvasSurfaceBlocks),
+    applicationSurfaceIds: ids(applicationSurfaceBlocks),
     metadata: {
       authoredNativeSourceIds: blocks.map((block) => block.node.id),
       authoredPackageManifestIds: ids(packageManifestBlocks),
-      authoredCanvasSurfaceIds: ids(canvasSurfaceBlocks)
+      authoredCanvasSurfaceIds: ids(canvasSurfaceBlocks),
+      authoredApplicationSurfaceIds: ids(applicationSurfaceBlocks)
     }
   };
 }

package/package.json

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