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

package/README.md

@@ -260,6 +260,98 @@ 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 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`,
+`abiCompatibilityClaim`, `projectionEquivalenceClaim`,
+`pluginCompatibilityClaim`, and `sandboxSafetyClaim` remain false until a
+higher layer supplies source-bound runtime, ABI, projection, and sandbox
+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,303 @@
+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 ?? []);
+  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: 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: 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) ?? readInlineWord('path', 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/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,14 @@
 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';
 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 +28,9 @@ export function parseFrontierSource(source, options = {}) {
   const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
   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)) {
@@ -53,8 +59,11 @@ 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));
+    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 });
+  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 } : {}) });
 }
 
@@ -64,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)\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 = [] } = {}) {
+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);
@@ -34,8 +35,11 @@ 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 (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;
 }
@@ -106,7 +110,7 @@ function mergeConstraintSpaceBlocks(blocks) {
   };
 }
 
-function mergeNativeSourceBlocks(blocks) {
+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),
@@ -114,7 +118,74 @@ 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,
+    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),
+      authoredApplicationSurfaceIds: ids(applicationSurfaceBlocks)
+    }
+  };
+}
+
+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.29",
   "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",