@shapeshift-labs/frontier-lang-parser 0.3.26 → 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.
@@ -368,12 +417,20 @@ conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
   constraint memory-model todoMemory @id("memory_model_todo") role source kind stable-reference resource TodoDb.todos memoryKind shared-memory memoryOrder acquire lockId lock:todo shared evidence artifact_todo_title_probe
   constraint effect-constraint todoWrite @id("effect_constraint_todo_write") role source kind storage-write capability storage.write resource TodoDb.todos adapterRequired evidence artifact_todo_title_probe
   constraint host-environment browserFetch @id("host_environment_fetch") role source kind browser-api capability fetch apiName fetch globalName window permission network adapterRequired evidence artifact_todo_title_probe
+  constraint callable-boundary saveUser @id("callable_boundary_save_user") role source kind method-call callableKind function functionName saveUser parameterCount 2 parameterOrder user|options returnKind promise asyncKind async evidence artifact_todo_title_probe
+  constraint adt-pattern resultShape @id("adt_pattern_result") role source kind tagged-union adtKind union typeName UserResult variantNames Ok|Err payloadFieldNames value|error exhaustivenessKinds total evidence artifact_todo_title_probe
+  constraint numeric-semantics amountNumber @id("numeric_semantics_amount") role source kind integer numericKind int width 53 overflowMode safe-integer specialValues nan|infinity evidence artifact_todo_title_probe
+  constraint text-semantics titleText @id("text_semantics_title") role source kind string encoding utf-16 normalizationForm nfc boundaryKinds grapheme|word evidence artifact_todo_title_probe
+  constraint collection-semantics todoList @id("collection_semantics_todos") role source kind array collectionKind array elementKind Todo iterationOrder insertion duplicatePolicy allow evidence artifact_todo_title_probe
+  constraint serialization-semantics todoJson @id("serialization_semantics_todo_json") role source kind json format json codec JSON.stringify schemaName TodoPayload deterministic evidence artifact_todo_title_probe
+  constraint dependency-semantics npmReact @id("dependency_semantics_react") role source kind package packageManager npm packageName react versionRange ^19.0.0 lockfile package-lock.json integrity sha512-demo evidence artifact_todo_title_probe
+  constraint protocol serializable @id("protocol_serializable") role target kind trait-bound protocolKind trait traitName Serializable requirementNames serialize|deserialize evidence artifact_todo_title_probe
 }
 ```
 
 `sourceRuntime` and `targetRuntime` become runtime maps. `runtimeRequirement` rows become proof obligations for host/runtime capabilities, including authored `requiredSignals` denominators such as source hashes, target hashes, probe ids, runtime commands, telemetry hashes, and capability-specific trace hashes. `proofEvidence` and `evidence` attach evidence ids, but the compiler still requires bound evidence records before a proof obligation is satisfied. `dialect` and `extern` rows preserve dialect-specific constructs, projection readiness, loss/evidence ids, and binding metadata without requiring the authored Frontier file to drop down to raw JSON.
 
-`constraint` rows accept every universal conversion constraint family used by route admission, including hyphenated spellings such as `module-constraint`, `scope-binding`, `memory-model`, `effect-constraint`, `control-flow`, `borrow-scope`, `borrow-checker`, `host-environment`, `data-layout`, and `object-model`. The parser preserves family-specific fields such as module specifiers, package conditions, binding/reference ids, memory ordering, locks, capabilities, host permissions, ABI/layout hints, and effect adapters as authored evidence inputs. Record-level targets use explicit labels such as `effectTarget` so `role target` rows cannot be mistaken for an authored target field. These rows do not prove translation equivalence; they make the required proof surface explicit for downstream gates and admission records.
+`constraint` rows accept every universal conversion constraint family used by route admission, including hyphenated spellings such as `module-constraint`, `scope-binding`, `memory-model`, `effect-constraint`, `control-flow`, `borrow-scope`, `borrow-checker`, `host-environment`, `callable-boundary`, `adt-pattern`, `data-layout`, `numeric-semantics`, `text-semantics`, `collection-semantics`, `serialization-semantics`, `dependency-semantics`, `object-model`, and `protocol`. The parser preserves family-specific fields such as module specifiers, package conditions, binding/reference ids, memory ordering, locks, capabilities, host permissions, callable signatures, pattern exhaustiveness, ABI/layout hints, numeric/text/collection behavior, wire formats, dependency lockfile evidence, and effect adapters as authored evidence inputs. Record-level targets use explicit labels such as `effectTarget` so `role target` rows cannot be mistaken for an authored target field. These rows do not prove translation equivalence; they make the required proof surface explicit for downstream gates and admission records.
 
 ## Authored dialect registry syntax
 

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/conversion-constraint-record.js

@@ -47,14 +47,75 @@ const WORD_FIELDS = [
   ['dropKind'], ['resourceKind'], ['scopeKind'], ['typeKind'], ['signatureHash'], ['contractHash'], ['typeHash'], ['flowKind'],
   ['controlFlowKind'], ['sourceControlFlowId'], ['sourceId', 'from', 'sourceId'], ['targetId', 'to', 'targetId'], ['label'],
   ['conditionHash'], ['orderingKey', 'orderingKey', 'orderKey'], ['lifetimeKind'], ['lifetimeRegionId', 'lifetimeRegion', 'lifetimeRegionId'],
-  ['regionKind'], ['resourceId', 'resource', 'resourceId'], ['sourcePath', 'sourcePath', 'path'], ['sourceHash'], ['target', 'effectTarget', 'targetResource']
+  ['regionKind'], ['resourceId', 'resource', 'resourceId'],
+  ['functionName'], ['methodName'], ['callableName'], ['callableKind'], ['callSignatureHash'],
+  ['receiverKind', 'receiverKind', 'receiver'], ['thisBinding'], ['selfBinding'], ['returnKind', 'returnKind', 'returnType'],
+  ['asyncKind', 'asyncKind', 'asyncMode'], ['generatorKind', 'generatorKind', 'yieldKind'], ['callbackKind'],
+  ['closureCapture', 'closureCapture', 'captureKind'], ['overloadSet', 'overloadSet', 'overloads'],
+  ['dispatchKind', 'dispatchKind', 'dispatchMode'], ['constructorKind'], ['abiKind'], ['ffiBoundary', 'ffiBoundary', 'foreignFunction'],
+  ['exceptionModel'], ['adtKind'], ['patternKind', 'patternKind', 'matchKind', 'caseKind'], ['typeName'], ['enumName'], ['unionName'],
+  ['symbolKind'], ['relationKind'], ['representationKind'], ['typeId', 'typeId', 'nodeId'], ['nodeId'], ['structId'], ['unionId'],
+  ['enumId'], ['fieldId'], ['bitfieldId'], ['endianness', 'endianness', 'endian'], ['repr', 'repr', 'reprAttribute'],
+  ['numericKind', 'numericKind', 'numberKind'], ['numberKind'], ['numericTypeName'], ['signedness'], ['overflowMode', 'overflowMode', 'overflowBehavior'],
+  ['divisionMode', 'divisionMode', 'integerDivisionMode'], ['moduloMode', 'moduloMode', 'remainderMode'], ['floatPrecision'], ['roundingMode'],
+  ['separatorPolicy'], ['coercionKind', 'coercionKind', 'conversionKind'], ['conversionKind'], ['literalKind'],
+  ['textKind', 'textKind', 'stringKind'], ['stringKind'], ['stringTypeName'], ['encoding', 'encoding', 'charset', 'codepage'],
+  ['charset'], ['codepage'], ['codeUnit', 'codeUnit', 'codeUnitWidth'], ['indexingUnit', 'indexingUnit', 'indexUnit'],
+  ['normalizationForm', 'normalizationForm', 'normalization'], ['locale', 'locale', 'localePolicy'], ['collation', 'collation', 'collationPolicy'],
+  ['caseMapping', 'caseMapping', 'caseFolding'], ['regexEngine', 'regexEngine', 'regexFlavor'], ['escapeMode', 'escapeMode', 'escaping'],
+  ['interpolationMode', 'interpolationMode', 'interpolation'], ['termination', 'termination', 'nullTermination'], ['boundaryKind', 'boundaryKind', 'byteBoundary'],
+  ['collectionKind', 'collectionKind', 'containerKind'], ['containerKind'], ['collectionTypeName'], ['elementKind', 'elementKind', 'elementType'],
+  ['keyKind', 'keyKind', 'keyType'], ['valueKind', 'valueKind', 'valueType'], ['orderKind'], ['iterationOrder', 'iterationOrder', 'traversalOrder'],
+  ['duplicatePolicy', 'duplicatePolicy', 'duplicates'], ['equality', 'equality', 'equalitySemantics'], ['hash', 'hash', 'hashSemantics'],
+  ['comparator', 'comparator', 'comparison'], ['boundsBehavior', 'boundsBehavior', 'bounds'], ['lengthSemantics', 'lengthSemantics', 'sizeSemantics'],
+  ['sparseSemantics', 'sparseSemantics', 'holes'], ['mutability', 'mutability', 'collectionMutability', 'stringMutability'],
+  ['persistence', 'persistence', 'persistent'], ['iteratorInvalidation', 'iteratorInvalidation', 'invalidation'],
+  ['traversal', 'traversal', 'laziness'], ['capacityGrowth', 'capacityGrowth', 'growth'], ['concurrency', 'concurrency', 'threadSafety'],
+  ['format', 'format', 'wireFormat', 'serializationFormat'], ['wireFormat'], ['serializationFormat'], ['codec', 'codec', 'runtimeCodec'],
+  ['schemaName', 'schemaName', 'schemaId', 'schema'], ['schemaId'], ['fieldNaming', 'fieldNaming', 'naming'], ['fieldOrder', 'fieldOrder', 'order'],
+  ['omissionPolicy'], ['defaultValueSemantics'], ['nullSemantics', 'nullSemantics', 'nullability'], ['unknownFieldPolicy'],
+  ['enumEncoding', 'enumEncoding', 'tagEncoding'], ['varint', 'varint', 'varintEncoding'], ['schemaVersion', 'schemaVersion', 'version'],
+  ['compatibility'], ['canonicalization'], ['precision', 'precision', 'precisionLoss'], ['roundtrip', 'roundtrip', 'roundtripStability'],
+  ['validation'], ['securityEscaping'], ['packageManager', 'packageManager', 'manager'], ['manager'], ['manifestSchema', 'manifestSchema', 'manifestKind'],
+  ['manifestKind'], ['versionRange', 'versionRange', 'range'], ['resolvedVersion', 'resolvedVersion', 'version'], ['lockfile', 'lockfile', 'lockfilePath'],
+  ['integrity', 'integrity', 'lockfileIntegrity'], ['dependencyClass', 'dependencyClass', 'dependencyType'], ['dependencyType'],
+  ['workspace', 'workspace', 'workspaceBoundary'], ['registry', 'registry', 'registrySource'], ['sourceUrl'], ['nativeAbi', 'nativeAbi', 'abi'],
+  ['buildTool', 'buildTool', 'builder'], ['packageManagerVersion', 'packageManagerVersion', 'managerVersion'],
+  ['offlineCache', 'offlineCache', 'cachePolicy'], ['dedupeHoist', 'dedupeHoist', 'hoistPolicy'], ['provenance', 'provenance', 'sourceProvenance'],
+  ['trust', 'trust', 'supplyChainTrust'], ['concurrencyKind'], ['constructId', 'constructId', 'taskId', 'threadId', 'actorId', 'channelId'],
+  ['taskId'], ['threadId'], ['executor', 'executor', 'queue', 'runtime'], ['executorId'], ['isolationKey'], ['cancellationKey', 'cancellationKey', 'signalId', 'contextId'],
+  ['signalId'], ['contextId'], ['errorKind'], ['errorType', 'errorType', 'exceptionType', 'resultType'], ['exceptionType'], ['resultType'],
+  ['boundaryId', 'boundaryId', 'catchId', 'handlerId'], ['catchId'], ['handlerId'], ['evaluationKind', 'evaluationKind', 'expressionKind'],
+  ['expressionKind'], ['expressionId', 'expressionId', 'nodeId'], ['operator'], ['evaluationOrder', 'evaluationOrder', 'order'],
+  ['expansionKind', 'expansionKind', 'macroKind', 'templateKind', 'decoratorKind', 'generatorKind'], ['macroKind'], ['templateKind'],
+  ['decoratorKind'], ['expansionId'], ['generatorId'], ['generatedSourcePath'], ['expandedHash', 'expandedHash', 'generatedHash'],
+  ['generatedHash'], ['classId'], ['classKind'], ['prototypeId'], ['mixinId'], ['constructorId'], ['inheritanceKind'], ['referenceSemantics'],
+  ['valueSemantics'], ['protocolKind'], ['protocolName'], ['traitName'], ['interfaceName'], ['subjectName', 'subjectName', 'receiverName', 'implementedFor'],
+  ['implementedFor'], ['sourcePath', 'sourcePath', 'path'], ['sourceHash'], ['target', 'effectTarget', 'targetResource']
 ];
 const LIST_FIELDS = [
   ['factKinds', 'fact', 'facts', 'factKind', 'factKinds'], ['importAttributes', 'importAttribute', 'importAttributes', 'assertion', 'assertions'],
-  ['reads', 'read', 'reads'], ['writes', 'write', 'writes'], ['evidenceIds', 'evidence', 'evidenceIds']
+  ['reads', 'read', 'reads'], ['writes', 'write', 'writes'],
+  ['requiredParameters'], ['optionalParameters'], ['parameterOrder', 'parameterOrder', 'orderedParameters'], ['defaultParameters', 'defaultParameters', 'defaults'],
+  ['namedArguments', 'namedArguments', 'keywordArguments'], ['effects'], ['variantNames', 'variantNames', 'variants', 'caseNames', 'cases', 'members'],
+  ['constructorNames', 'constructorNames', 'constructors', 'caseConstructors'], ['payloadFieldNames', 'payloadFieldNames', 'payloadFields', 'fields', 'tupleFields', 'recordFields'],
+  ['tagFieldNames', 'tagFieldNames', 'tagFields', 'discriminatorFields', 'discriminants'], ['matchArmNames', 'matchArmNames', 'matchArms', 'arms', 'switchCases'],
+  ['guardKinds', 'guardKinds', 'guards', 'whereClauses', 'conditions'], ['destructuringKinds', 'destructuringKinds', 'destructuring', 'bindingPatterns', 'deconstruction'],
+  ['exhaustivenessKinds', 'exhaustivenessKinds', 'exhaustiveness', 'coverageKinds'], ['fallbackKinds', 'fallbackKinds', 'fallbacks', 'defaultCases', 'wildcards'],
+  ['genericParameterNames', 'genericParameterNames', 'typeParameters', 'genericParameters'], ['specialValues', 'specialValues', 'floatSpecialValues'],
+  ['coercionKinds', 'coercionKinds', 'coercions'], ['literalKinds'], ['boundaryKinds', 'boundaryKinds', 'boundaries'],
+  ['omittedFields', 'omittedFields', 'unknownFields'], ['defaultValues'], ['peerDependencies', 'peerDependencies', 'peers'], ['optionalDependencies'],
+  ['devDependencies'], ['features', 'features', 'extras', 'flags'], ['lifecycleScripts', 'lifecycleScripts', 'scripts'],
+  ['requirementNames', 'requirementNames', 'requirements', 'methods', 'members'], ['associatedTypeNames', 'associatedTypeNames', 'associatedTypes'],
+  ['boundNames', 'boundNames', 'bounds', 'traitBounds', 'protocolBounds', 'whereBounds'], ['implementationKinds', 'implementationKinds', 'implKinds', 'implementations'],
+  ['dispatchKinds', 'dispatchKinds', 'dispatchModes'], ['coherenceKinds', 'coherenceKinds', 'coherenceRules'], ['evidenceIds', 'evidence', 'evidenceIds']
 ];
-const NUMBER_FIELDS = [['arity'], ['size'], ['alignment']];
-const FLAG_FIELDS = ['nullable', 'optional', 'publicContract', 'closure', 'captured', 'writeExpr', 'mutable', 'shadowed', 'hoisted', 'typeOnly', 'isTypeReference', 'isValueReference', 'shared', 'volatile', 'atomic', 'adapterRequired', 'async', 'generator', 'exceptional', 'cancellable'];
+const NUMBER_FIELDS = [
+  ['arity'], ['size'], ['alignment'], ['parameterCount'], ['requiredParameterCount'], ['optionalParameterCount'],
+  ['sizeBytes'], ['alignmentBytes'], ['offsetBytes'], ['pointerWidth'], ['integerWidth'], ['bitWidth'], ['width'],
+  ['codeUnitWidth'], ['indexBase']
+];
+const FLAG_FIELDS = ['nullable', 'optional', 'publicContract', 'closure', 'captured', 'writeExpr', 'mutable', 'shadowed', 'hoisted', 'typeOnly', 'isTypeReference', 'isValueReference', 'shared', 'volatile', 'atomic', 'adapterRequired', 'async', 'generator', 'exceptional', 'cancellable', 'variadic', 'signed', 'nan', 'infinity', 'deterministic', 'streaming', 'framing', 'copyOnWrite', 'multipleInheritance', 'reflection', 'staticDispatch', 'virtual', 'spawn', 'await', 'structured', 'reentrant', 'cancelable'];
 
 export const FAMILIES = Object.freeze(Object.fromEntries(FAMILY_ROWS.flatMap(([name, field, sourceKey, targetKey, aliases = [], extra = {}]) => {
   const config = { field, sourceKey, targetKey, ...extra };

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.26",
+  "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",