@shapeshift-labs/frontier-lang-parser 0.3.21 → 0.3.23

package/README.md

@@ -220,6 +220,23 @@ 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 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.
+
+```frontier
+target rust @id("target_rust") {
+  language rust
+  package example_todo
+  emitPath src/generated/todo.rs
+  moduleFormat crate
+  projection rustAdapter @id("target_projection_rust") disposition target-adapter readiness needs-review represented semantic-symbol|source-map missing semantic-ownership evidence artifact_todo_title_probe proof artifact_todo_title_probe loss loss_borrow_scope missingEvidence translation-borrow-scope:borrow-across-await
+  layer ownership @id("target_layer_rust_ownership") kind semantic-ownership status missing missingEvidence translation-borrow-scope:borrow-across-await
+}
+```
+
+The parser stores these rows on the target node metadata as `projectionContracts` and `projectionLayers`. They are target-lowering evidence, not proof of equivalence: `autoMergeClaim` and `semanticEquivalenceClaim` remain false.
+
 ## Authored decision graph syntax
 
 `.frontier` files can carry semantic merge admission evidence directly in `decisionGraph` or `admissionGraph` blocks. These blocks preserve the causal review shape around a candidate edit: semantic changes, gates, evidence records, patch events, admission decisions, merge decisions, graph nodes, and graph edges.

package/dist/index.js

@@ -9,6 +9,7 @@ import { parseParadigmBlock } from './paradigm.js';
 import { parseProofBlock } from './proof.js';
 import { parseResourceGraphBlock } from './resource-graph.js';
 import { parseNativeSourceBlock } from './source-evidence.js';
+import { parseTargetProjectionMetadata } from './target-projection.js';
 import { parseViewBlock } from './view.js';
 
 export function parseFrontierSource(source, options = {}) {
@@ -193,6 +194,7 @@ function parseLattice(block) {
 }
 function parseTarget(block) {
   const name = nameFrom(block.header);
+  const metadata = parseTargetProjectionMetadata(block.body, name);
   return targetNode({
     id: idFrom(block.header, `target_${name}`),
     name,
@@ -201,7 +203,8 @@ function parseTarget(block) {
       packageName: readWord('package', block.body),
       emitPath: readWord('emitPath', block.body),
       moduleFormat: readWord('moduleFormat', block.body)
-    }
+    },
+    ...(metadata ? { metadata } : {})
   });
 }
 function readList(label, body) { const line = new RegExp('^\\s*' + label + '\\s+([^\\n]+)', 'm').exec(body)?.[1]; return line ? line.split(',').map((item) => item.trim()).filter(Boolean) : undefined; }

package/dist/metadata.js

@@ -168,7 +168,7 @@ function mergeInterlinguaBlocks(blocks) {
     obligationIds: blocks.flatMap((block) => ids(block.record?.obligations)),
     loweringIds: blocks.flatMap((block) => ids(block.record?.loweringRecords)),
     liftIds: blocks.flatMap((block) => ids(block.record?.liftRecords)),
-    evidenceIds: [...new Set(blocks.flatMap((block) => block.record?.query?.proofEvidenceIds ?? []).concat(blocks.flatMap((block) => block.record?.query?.constraintEvidenceIds ?? [])))],
+    evidenceIds: [...new Set(blocks.flatMap((block) => block.record?.lowering?.evidenceIds ?? []).concat(blocks.flatMap((block) => block.record?.query?.proofEvidenceIds ?? []), blocks.flatMap((block) => block.record?.query?.constraintEvidenceIds ?? [])))],
     routeIds: [...new Set(interlinguaRecords.map((record) => record.routeId).filter(Boolean))],
     summary: {
       interlinguaCount: interlinguaRecords.length,

package/dist/target-projection.js

@@ -0,0 +1,84 @@
+export function parseTargetProjectionMetadata(body, targetName) {
+  const projectionContracts = readTargetProjectionContracts(body, targetName);
+  const projectionLayers = readTargetProjectionLayers(body, targetName);
+  if (!projectionContracts.length && !projectionLayers.length) return undefined;
+  return cleanObject({
+    authoredTargetProjection: true,
+    projectionContracts,
+    projectionLayers,
+    projectionContractIds: projectionContracts.map((entry) => entry.id),
+    projectionLayerIds: projectionLayers.map((entry) => entry.id),
+    evidenceIds: uniqueStrings([...projectionContracts.flatMap((entry) => entry.evidenceIds ?? []), ...projectionLayers.flatMap((entry) => entry.evidenceIds ?? [])]),
+    proofEvidenceIds: uniqueStrings(projectionContracts.flatMap((entry) => entry.proofEvidenceIds ?? [])),
+    lossIds: uniqueStrings(projectionContracts.flatMap((entry) => entry.lossIds ?? [])),
+    missingEvidence: uniqueStrings([...projectionContracts.flatMap((entry) => entry.missingEvidence ?? []), ...projectionLayers.flatMap((entry) => entry.missingEvidence ?? [])]),
+    semanticEquivalenceClaim: false,
+    autoMergeClaim: false
+  });
+}
+
+function readTargetProjectionContracts(body, targetName) {
+  const rows = [];
+  const re = /^\s*(projection|lowering)\s+([A-Za-z_$][\w$-]*)([^\n]*)$/gm;
+  let match;
+  while ((match = re.exec(body))) {
+    const [, rowKind, name, text] = match;
+    rows.push(cleanObject({
+      id: idFrom(text, `target_projection_${targetName}_${name}`),
+      kind: 'frontier.lang.targetProjectionContract',
+      name,
+      rowKind,
+      disposition: readInlineWord('disposition', text) ?? readInlineWord('mode', text),
+      readiness: readInlineWord('readiness', text),
+      adapterId: readInlineWord('adapter', text) ?? readInlineWord('adapterId', text),
+      sourceLanguage: readInlineWord('sourceLanguage', text) ?? readInlineWord('source', text),
+      representedLayerKinds: readInlineList(text, 'represented', 'representedLayerKinds'),
+      missingLayerKinds: readInlineList(text, 'missing', 'missingLayerKinds'),
+      requiredLayerKinds: readInlineList(text, 'requires', 'required', 'requiredLayerKinds'),
+      evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+      proofEvidenceIds: readInlineList(text, 'proof', 'proofEvidence', 'proofEvidenceIds'),
+      lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds'),
+      missingEvidence: readInlineList(text, 'missingEvidence'),
+      review: readInlineList(text, 'review'),
+      blockers: readInlineList(text, 'blocker', 'blockers'),
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }));
+  }
+  return rows;
+}
+
+function readTargetProjectionLayers(body, targetName) {
+  const rows = [];
+  const re = /^\s*layer\s+([A-Za-z_$][\w$-]*)([^\n]*)$/gm;
+  let match;
+  while ((match = re.exec(body))) {
+    const [, name, text] = match;
+    rows.push(cleanObject({
+      id: idFrom(text, `target_layer_${targetName}_${name}`),
+      kind: 'frontier.lang.targetProjectionLayer',
+      name,
+      layerKind: readInlineWord('kind', text) ?? readInlineWord('layerKind', text) ?? name,
+      status: readInlineWord('status', text) ?? 'represented',
+      evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds'),
+      missingEvidence: readInlineList(text, 'missingEvidence'),
+      review: readInlineList(text, 'review'),
+      blockers: readInlineList(text, 'blocker', 'blockers'),
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }));
+  }
+  return rows;
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\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 uniqueStrings(values) { return [...new Set(values.filter(Boolean))]; }
+function cleanObject(object) { return Object.fromEntries(Object.entries(object).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }

package/package.json

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