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

package/README.md

@@ -260,6 +260,55 @@ 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 package and canvas syntax
+
+`.frontier` files can describe package-management and canvas semantic surfaces
+directly, without requiring the source of truth to be a generated JSON tree.
+These blocks make dependency, script, export, draw-command, command-trace, and
+proof-gap records queryable as source-level evidence. They intentionally do not
+claim package install equivalence, canvas runtime equivalence, or visual
+equivalence.
+
+```frontier
+packageManifest AppPackage @id("pkg_manifest_app") {
+  sourcePath package.json
+  sourceHash sha256:package
+  packageManager npm@11.0.0
+  evidence packageProbe @id("evidence_package_probe") kind test status passed path reports/package.json
+  metadata name @id("pkg_meta_name") value "@example/app" evidence evidence_package_probe
+  dependency react @id("pkg_dep_react") section dependencies range ^19.0.0 evidence evidence_package_probe
+  dependency typescript @id("pkg_dep_typescript") section peerDependencies range ^5.9.0 proofGap package-peer-compatibility-boundary evidence evidence_package_probe
+  script test @id("pkg_script_test") command "vitest --run" proofGap package-script-runtime-boundary evidence evidence_package_probe
+  export root @id("pkg_export_root") section exports name . target ./dist/index.js proofGap package-conditional-resolution-boundary evidence evidence_package_probe
+  gap workspace @id("pkg_gap_workspace") code package-workspace-graph-boundary summary "Workspace expansion requires repository graph evidence."
+}
+
+canvasSurface PreviewCanvas @id("canvas_surface_preview") {
+  sourcePath src/draw.js
+  sourceHash sha256:draw
+  evidence canvasProbe @id("evidence_canvas_probe") kind browser-probe status passed path reports/canvas.json
+  element preview @id("canvas_element_preview") name canvas category html-canvas order 1 identity canvas:preview attributes data-frontier-key=preview|width=100 evidence evidence_canvas_probe
+  command context @id("canvas_command_context") name getContext category context context 2d order 2 proofGap canvas-context-runtime-boundary evidence evidence_canvas_probe
+  state fillStyle @id("canvas_state_fill_style") name fillStyle category state order 3 proofGap canvas-stateful-render-order-boundary evidence evidence_canvas_probe
+  command fill @id("canvas_command_fill") name fillRect category draw context 2d order 4 proofGap canvas-stateful-render-order-boundary evidence evidence_canvas_probe
+  command offscreen @id("canvas_command_offscreen") name transferControlToOffscreen category offscreen order 5 proofGap canvas-offscreen-worker-boundary evidence evidence_canvas_probe
+  trace drawFrame @id("canvas_trace_draw_frame") commands getContext|fillStyle|fillRect|transferControlToOffscreen evidence evidence_canvas_probe
+  gap image @id("canvas_gap_image") code canvas-image-resource-boundary summary "Image drawing needs bitmap/resource evidence."
+}
+```
+
+The parser stores package blocks in `metadata.packageManifests` and canvas
+blocks in `metadata.canvasSurfaces`, and mirrors both under
+`metadata.universalAst` so compiler and merge tooling can see them next to
+native-source source maps and merge candidates. Package records keep
+`packageInstallEquivalenceClaim`, `installEquivalenceClaim`, and
+`runtimeEquivalenceClaim` false. Canvas records keep
+`browserRuntimeEquivalenceClaim`, `canvasRuntimeEquivalenceClaim`, and
+`canvasVisualEquivalenceClaim` false.
+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 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/canvas-surface.js

@@ -0,0 +1,206 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function parseCanvasSurfaceBlock(block) {
+  const name = nameFrom(block.header);
+  const sourcePath = readLine('sourcePath', block.body) ?? readLine('path', block.body);
+  const sourceHash = readLine('sourceHash', block.body);
+  const evidence = parseEvidenceRows(block.body);
+  const records = [];
+  const commandTraces = [];
+  const proofGaps = [];
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || isPropertyLine(line)) continue;
+    const match = /^(element|command|state|stateWrite|trace|gap|proofGap)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, rest] = match;
+    if (rowKind === 'gap' || rowKind === 'proofGap') {
+      proofGaps.push(canvasProofGap(rowName, rest));
+      continue;
+    }
+    if (rowKind === 'trace') {
+      commandTraces.push(canvasTrace(rowName, rest, { sourcePath }));
+      continue;
+    }
+    records.push(canvasRecord(rowKind === 'stateWrite' ? 'state-write' : rowKind, rowName, rest, { sourcePath, sourceHash }));
+  }
+  const allGaps = [...records.flatMap((record) => record.proofGaps ?? []), ...proofGaps];
+  const tree = {
+    kind: 'frontier.lang.canvasSemanticTree',
+    version: 1,
+    id: idFrom(block.header, `canvas_surface_${name}`),
+    name,
+    sourcePath,
+    sourceHash,
+    records,
+    commandTraces,
+    proofGaps: allGaps,
+    evidence,
+    parser: { status: 'authored', errors: [] },
+    claims: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      browserRuntimeEquivalenceClaim: false,
+      canvasRuntimeEquivalenceClaim: false,
+      canvasVisualEquivalenceClaim: false
+    },
+    metadata: { authoredName: name }
+  };
+  tree.summary = summarizeCanvasSurface(tree);
+  tree.treeHash = hashSemanticValue({ kind: 'frontier.lang.canvas.authoredTree.v1', records: records.map(hashableRecord), proofGaps: allGaps.map((gap) => gap.code), commandTraces: commandTraces.map((trace) => trace.traceHash) });
+  return tree;
+}
+
+function canvasRecord(kind, name, text, context) {
+  const category = readInlineWord('category', text) ?? defaultCategory(kind);
+  const recordName = readInlineWord('name', text) ?? name;
+  const order = readInlineNumber('order', text) ?? readInlineNumber('renderOrder', text) ?? 0;
+  const proofGaps = readInlineList(text, 'proofGap', 'proofGaps', 'gap', 'gaps')?.map((code) => canvasProofGap(code, '')) ?? [];
+  const textValue = readInlineQuoted('text', text) ?? readInlineWord('text', text) ?? `${kind}:${category}:${recordName}:${order}`;
+  return cleanRecord({
+    kind,
+    id: idFrom(text, `canvas_${kind.replace(/-/g, '_')}_${safeId(recordName)}`),
+    name: recordName,
+    category,
+    contextKind: readInlineWord('context', text) ?? readInlineWord('contextKind', text),
+    renderOrder: order,
+    identityKey: readInlineWord('identity', text) ?? readInlineWord('identityKey', text) ?? `canvas:${kind}:${category}:${recordName}:${order || safeId(recordName)}`,
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? context.sourcePath,
+    sourceHash: readInlineWord('sourceHash', text) ?? context.sourceHash,
+    sourceSpan: parseSpan(readInlineWord('sourceSpan', text)),
+    textHash: hashSemanticValue({ kind: 'frontier.lang.canvas.authoredRecordText.v1', text: textValue }),
+    attributes: parsePairs(readInlineWord('attributes', text) ?? readInlineWord('attrs', text) ?? readInlineWord('attr', text)),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    proofGaps
+  });
+}
+
+function canvasTrace(name, text, context) {
+  const commands = readInlineList(text, 'command', 'commands') ?? [];
+  const records = commands.map((command, index) => ({
+    kind: 'trace-command',
+    name: command,
+    category: readInlineWord('category', text) ?? 'custom',
+    ordinal: index + 1,
+    commandHash: hashSemanticValue({ kind: 'frontier.lang.canvas.authoredTraceCommand.v1', command, index }),
+    argsHash: hashSemanticValue({ kind: 'frontier.lang.canvas.authoredTraceArgs.v1', command, index }),
+    proofGaps: []
+  }));
+  return cleanRecord({
+    kind: 'frontier.lang.canvasCommandTrace',
+    version: 1,
+    id: idFrom(text, `canvas_trace_${name}`),
+    name,
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? context.sourcePath,
+    traceHash: hashSemanticValue({ kind: 'frontier.lang.canvas.authoredTrace.v1', commands }),
+    records,
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    runtimeEquivalenceClaim: false,
+    visualEquivalenceClaim: false,
+    summary: {
+      commands: records.length,
+      drawCommands: records.filter((record) => ['draw', 'image', 'text', 'path'].includes(record.category)).length,
+      proofGaps: 0
+    }
+  });
+}
+
+function canvasProofGap(name, text) {
+  const code = readInlineWord('code', text) ?? name;
+  return cleanRecord({
+    id: idFrom(text, `canvas_gap_${safeId(code)}`),
+    code,
+    status: readInlineWord('status', text) ?? 'not-claimed',
+    summary: readInlineQuoted('summary', text) ?? readInlineQuoted('message', text),
+    failClosed: true,
+    semanticEquivalenceClaim: false,
+    browserRuntimeEquivalenceClaim: false,
+    canvasRuntimeEquivalenceClaim: false,
+    canvasVisualEquivalenceClaim: false,
+    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 summarizeCanvasSurface(tree) {
+  return {
+    elements: tree.records.filter((record) => record.kind === 'element').length,
+    commands: tree.records.filter((record) => record.kind === 'command').length,
+    stateWrites: tree.records.filter((record) => record.kind === 'state-write').length,
+    drawCommands: tree.records.filter((record) => ['draw', 'image', 'text', 'path'].includes(record.category)).length,
+    offscreenCommands: tree.records.filter((record) => record.category === 'offscreen').length,
+    gpuCommands: tree.records.filter((record) => record.contextKind === 'webgl' || record.contextKind === 'webgl2' || record.contextKind === 'webgpu').length,
+    commandTraces: tree.commandTraces.length,
+    proofGaps: tree.proofGaps.length,
+    parseErrors: tree.parser.errors.length
+  };
+}
+
+function defaultCategory(kind) {
+  if (kind === 'element') return 'html-canvas';
+  if (kind === 'state-write') return 'state';
+  return 'draw';
+}
+
+function parsePairs(value) {
+  if (!value) return undefined;
+  const pairs = Object.fromEntries(value.split(/[|,]/).map((item) => {
+    const [key, rawValue] = item.split('=');
+    return [key, rawValue ?? true];
+  }).filter(([key]) => key));
+  return Object.keys(pairs).length ? pairs : undefined;
+}
+
+function hashableRecord(record) {
+  return { kind: record.kind, name: record.name, category: record.category, contextKind: record.contextKind, renderOrder: record.renderOrder, proofGaps: record.proofGaps?.map((gap) => gap.code) };
+}
+
+function isPropertyLine(line) {
+  return /^(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] ?? 'CanvasSurface'; }
+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 readInlineNumber(label, text) {
+  const value = readInlineWord(label, text);
+  return value === undefined ? undefined : Number(value);
+}
+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,11 +1,13 @@
 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 { parseCanvasSurfaceBlock } from './canvas-surface.js';
 import { parseDecisionGraphBlock } from './decision-graph.js';
 import { parseDialectRegistryBlock } from './dialect-registry.js';
 import { parseInterlinguaBlock } from './interlingua.js';
 import { createParsedMetadata } from './metadata.js';
 import { parseSemanticOperationsBlock } from './operations.js';
+import { parsePackageManifestBlock } from './package-manifest.js';
 import { parseParadigmBlock } from './paradigm.js';
 import { parseProofBlock } from './proof.js';
 import { parseResourceGraphBlock } from './resource-graph.js';
@@ -25,6 +27,8 @@ export function parseFrontierSource(source, options = {}) {
   const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
   const nativeSourceBlocks = [];
+  const packageManifestBlocks = [];
+  const canvasSurfaceBlocks = [];
   const documentId = options.id ?? readId(source) ?? 'mod_frontier';
   const documentName = options.name ?? readName(source) ?? 'FrontierModule';
   for (const block of readBlocks(source)) {
@@ -53,8 +57,10 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'dialectRegistry' || block.kind === 'universalDialectRegistry') dialectRegistryBlocks.push(parseDialectRegistryBlock(block));
     if (block.kind === 'interlingua' || block.kind === 'universalInterlingua') interlinguaBlocks.push(parseInterlinguaBlock(block));
     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));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks, packageManifestBlocks, canvasSurfaceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -64,7 +70,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)\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)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -23,7 +23,7 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [], packageManifestBlocks = [], canvasSurfaceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -34,8 +34,10 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (dialectRegistryBlocks.length) metadata.dialects = mergeDialectRegistryBlocks(dialectRegistryBlocks);
   if (interlinguaBlocks.length) metadata.universalInterlingua = mergeInterlinguaBlocks(interlinguaBlocks);
   if (resourceGraphBlocks.length) metadata.semanticResourceGraphs = mergeResourceGraphBlocks(resourceGraphBlocks);
-  if (nativeSourceBlocks.some((block) => block.sourceMaps.length || block.mergeCandidates.length || block.evidence.length)) {
-    metadata.universalAst = mergeNativeSourceBlocks(nativeSourceBlocks);
+  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);
   }
   return Object.keys(metadata).length ? metadata : undefined;
 }
@@ -106,7 +108,7 @@ function mergeConstraintSpaceBlocks(blocks) {
   };
 }
 
-function mergeNativeSourceBlocks(blocks) {
+function mergeUniversalAstBlocks(blocks, packageManifestBlocks = [], canvasSurfaceBlocks = []) {
   return {
     id: blocks.length === 1 ? `universalAst:${blocks[0].node.id}` : 'universalAst:source',
     nativeSourceIds: blocks.map((block) => block.node.id),
@@ -114,7 +116,71 @@ function mergeNativeSourceBlocks(blocks) {
     mergeCandidates: blocks.flatMap((block) => block.mergeCandidates ?? []),
     evidence: blocks.flatMap((block) => block.evidence ?? []),
     losses: blocks.flatMap((block) => block.losses ?? []),
-    metadata: { authoredNativeSourceIds: blocks.map((block) => block.node.id) }
+    packageManifests: packageManifestBlocks,
+    canvasSurfaces: canvasSurfaceBlocks,
+    packageManifestIds: ids(packageManifestBlocks),
+    canvasSurfaceIds: ids(canvasSurfaceBlocks),
+    metadata: {
+      authoredNativeSourceIds: blocks.map((block) => block.node.id),
+      authoredPackageManifestIds: ids(packageManifestBlocks),
+      authoredCanvasSurfaceIds: ids(canvasSurfaceBlocks)
+    }
+  };
+}
+
+function mergePackageManifestBlocks(blocks) {
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'packageManifests:source',
+    manifests: blocks,
+    manifestIds: ids(blocks),
+    recordIds: blocks.flatMap((block) => ids(block.records)),
+    evidenceIds: blocks.flatMap((block) => ids(block.evidence)),
+    proofGapCodes: [...new Set(blocks.flatMap((block) => (block.proofGaps ?? []).map((gap) => gap.code).filter(Boolean)))],
+    summary: {
+      manifestCount: blocks.length,
+      recordCount: blocks.reduce((sum, block) => sum + (block.records?.length ?? 0), 0),
+      dependencyCount: blocks.reduce((sum, block) => sum + (block.summary?.dependencies ?? 0), 0),
+      scriptCount: blocks.reduce((sum, block) => sum + (block.summary?.scripts ?? 0), 0),
+      exportCount: blocks.reduce((sum, block) => sum + (block.summary?.exports ?? 0), 0),
+      proofGapCount: blocks.reduce((sum, block) => sum + (block.proofGaps?.length ?? 0), 0)
+    },
+    claims: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      packageInstallEquivalenceClaim: false,
+      installEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false
+    },
+    metadata: { authoredPackageManifestIds: ids(blocks) }
+  };
+}
+
+function mergeCanvasSurfaceBlocks(blocks) {
+  return {
+    id: blocks.length === 1 ? blocks[0].id : 'canvasSurfaces:source',
+    surfaces: blocks,
+    surfaceIds: ids(blocks),
+    recordIds: blocks.flatMap((block) => ids(block.records)),
+    commandTraceIds: blocks.flatMap((block) => ids(block.commandTraces)),
+    evidenceIds: blocks.flatMap((block) => ids(block.evidence)),
+    proofGapCodes: [...new Set(blocks.flatMap((block) => (block.proofGaps ?? []).map((gap) => gap.code).filter(Boolean)))],
+    summary: {
+      surfaceCount: blocks.length,
+      recordCount: blocks.reduce((sum, block) => sum + (block.records?.length ?? 0), 0),
+      commandTraceCount: blocks.reduce((sum, block) => sum + (block.commandTraces?.length ?? 0), 0),
+      drawCommandCount: blocks.reduce((sum, block) => sum + (block.summary?.drawCommands ?? 0), 0),
+      offscreenCommandCount: blocks.reduce((sum, block) => sum + (block.summary?.offscreenCommands ?? 0), 0),
+      gpuCommandCount: blocks.reduce((sum, block) => sum + (block.summary?.gpuCommands ?? 0), 0),
+      proofGapCount: blocks.reduce((sum, block) => sum + (block.proofGaps?.length ?? 0), 0)
+    },
+    claims: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      browserRuntimeEquivalenceClaim: false,
+      canvasRuntimeEquivalenceClaim: false,
+      canvasVisualEquivalenceClaim: false
+    },
+    metadata: { authoredCanvasSurfaceIds: ids(blocks) }
   };
 }
 

package/dist/package-manifest.js

@@ -0,0 +1,162 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function parsePackageManifestBlock(block) {
+  const name = nameFrom(block.header);
+  const sourcePath = readLine('sourcePath', block.body) ?? readLine('path', block.body) ?? 'package.json';
+  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 = /^(metadata|dependency|script|export|gap|proofGap)\s+([A-Za-z_$.*@/][\w$./@*-]*)(.*)$/.exec(line);
+    if (!match) continue;
+    const [, rowKind, rowName, rest] = match;
+    if (rowKind === 'gap' || rowKind === 'proofGap') {
+      proofGaps.push(packageProofGap(rowName, rest));
+      continue;
+    }
+    const record = packageRecord(rowKind, rowName, rest, { sourcePath, sourceHash, evidence });
+    if (record) records.push(record);
+  }
+  const recordGaps = records.flatMap((record) => record.proofGaps ?? []);
+  const allGaps = [...recordGaps, ...proofGaps];
+  const tree = {
+    kind: 'frontier.lang.packageManifestSemanticTree',
+    version: 1,
+    id: idFrom(block.header, `package_manifest_${name}`),
+    name,
+    sourcePath,
+    sourceHash,
+    packageManager: readLine('packageManager', block.body),
+    records,
+    proofGaps: allGaps,
+    evidence,
+    parser: { status: 'authored', errors: [] },
+    claims: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      packageInstallEquivalenceClaim: false,
+      installEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false
+    },
+    metadata: { authoredName: name }
+  };
+  tree.summary = summarizePackageManifest(tree);
+  tree.treeHash = hashSemanticValue({ kind: 'frontier.lang.package.authoredTree.v1', records: records.map(hashableRecord), proofGaps: allGaps.map((gap) => gap.code) });
+  return tree;
+}
+
+function packageRecord(kind, name, text, context) {
+  const section = readInlineWord('section', text) ?? defaultSection(kind);
+  const recordName = readInlineWord('name', text) ?? name;
+  const value = packageValue(kind, text);
+  const proofGaps = readInlineList(text, 'proofGap', 'proofGaps', 'gap', 'gaps')?.map((code) => packageProofGap(code, '')) ?? [];
+  return cleanRecord({
+    kind,
+    id: idFrom(text, `package_${kind}_${safeId(section)}_${safeId(recordName)}`),
+    section,
+    name: recordName,
+    value,
+    valueHash: hashSemanticValue({ kind: 'frontier.lang.package.authoredRecordValue.v1', value }),
+    identityKey: readInlineWord('identity', text) ?? readInlineWord('identityKey', text) ?? `${kind}:${section}:${recordName}`,
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? context.sourcePath,
+    sourceHash: readInlineWord('sourceHash', text) ?? context.sourceHash,
+    sourceSpan: parseSpan(readInlineWord('sourceSpan', text)),
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceIds'),
+    proofGaps
+  });
+}
+
+function packageValue(kind, text) {
+  if (kind === 'dependency') return readInlineQuoted('value', text) ?? readInlineWord('range', text) ?? readInlineWord('value', text) ?? '*';
+  if (kind === 'script') return readInlineQuoted('command', text) ?? readInlineQuoted('value', text) ?? readInlineWord('command', text) ?? readInlineWord('value', text);
+  if (kind === 'export') return readInlineQuoted('target', text) ?? readInlineQuoted('value', text) ?? readInlineWord('target', text) ?? readInlineWord('value', text);
+  return readInlineQuoted('value', text) ?? readInlineWord('value', text);
+}
+
+function defaultSection(kind) {
+  if (kind === 'dependency') return 'dependencies';
+  if (kind === 'script') return 'scripts';
+  if (kind === 'export') return 'exports';
+  return 'metadata';
+}
+
+function packageProofGap(name, text) {
+  const code = readInlineWord('code', text) ?? name;
+  return cleanRecord({
+    id: idFrom(text, `package_gap_${safeId(code)}`),
+    code,
+    status: readInlineWord('status', text) ?? 'not-claimed',
+    summary: readInlineQuoted('summary', text) ?? readInlineQuoted('message', text),
+    failClosed: true,
+    semanticEquivalenceClaim: false,
+    packageInstallEquivalenceClaim: false,
+    installEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    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 summarizePackageManifest(tree) {
+  return {
+    metadata: tree.records.filter((record) => record.kind === 'metadata').length,
+    dependencies: tree.records.filter((record) => record.kind === 'dependency').length,
+    scripts: tree.records.filter((record) => record.kind === 'script').length,
+    exports: tree.records.filter((record) => record.kind === 'export').length,
+    proofGaps: tree.proofGaps.length,
+    parseErrors: tree.parser.errors.length
+  };
+}
+
+function hashableRecord(record) {
+  return { kind: record.kind, section: record.section, name: record.name, value: record.value, proofGaps: record.proofGaps?.map((gap) => gap.code) };
+}
+
+function isPropertyLine(line) {
+  return /^(sourcePath|path|sourceHash|packageManager|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] ?? 'PackageManifest'; }
+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 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "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/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",
+    "test": "npm run build && node test/smoke.mjs && node test/conversion-constraint-fields-smoke.mjs && node test/package-canvas-surface-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",