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

package/README.md

@@ -220,6 +220,46 @@ npm install @shapeshift-labs/frontier-lang-parser
 
 The parser projects text into `@shapeshift-labs/frontier-lang-kernel` documents. The syntax is intentionally small and experimental.
 
+## Authored view render graph syntax
+
+`.frontier` view blocks can describe UI render graphs directly. Nested `render`
+blocks are flattened into `view.renders`, and each parent stores stable child
+render IDs in `children`. This keeps authored UI structural and target-neutral:
+HTML, JSX, SwiftUI, or another target can lower the same semantic graph without
+the parser claiming browser or runtime equivalence.
+
+```frontier
+view TodoList @id("view_todo_list") {
+  reads TodoDb.todos
+  dispatches action_add
+  prop disabled @id("view_prop_disabled"): Boolean
+  event save @id("view_event_save") action action_add input TodoInput
+
+  render Article @id("render_todo_root") {
+    key todo-list-root
+
+    render Button @id("render_save_button") {
+      identity save
+      text "Save"
+      prop disabled disabled
+      on press save
+    }
+
+    render SaveIcon kind component @id("render_save_icon") {
+      component Icon
+      key save-icon
+      prop name "check"
+    }
+  }
+}
+```
+
+The root render becomes a graph node whose `children` reference
+`render_save_button` and `render_save_icon` in source order. Child props, text,
+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 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.
@@ -328,6 +368,21 @@ conversion TodoJavascriptToRust @id("conversion_todo_js_rust") {
 
 `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.
 
+## Authored dialect registry syntax
+
+`.frontier` files can carry reusable dialect registries with `dialectRegistry` or `universalDialectRegistry` blocks. These blocks describe language-specific constructs that should stay visible during translation instead of being silently collapsed into generic stubs.
+
+```frontier
+dialectRegistry RuntimeDialects @id("dialect_registry_runtime") {
+  language javascript
+  sourcePath src/runtime.ts
+  dialect nodeProcess @id("dialect_registry_node_process") dialect node.runtime kind runtime name process.env target rust disposition unsupported readiness blocked loss loss_node_process_projection evidence evidence_node_runtime sourceMap sourcemap_todo_ts
+  extern viteRoutes @id("dialect_registry_vite_routes") dialect vite.plugin.virtual-module externKind generatorArtifact target rust disposition runtime-required readiness needs-review evidence evidence_vite_routes_manifest bindingSymbol virtual:routes module vite
+}
+```
+
+The parser projects these rows into `metadata.dialects` as a `frontier.lang.universalDialectRegistry`-shaped object. `dialect` rows become universal dialect records, `extern` rows become universal extern records, and projection fields preserve target disposition, readiness, evidence ids, loss ids, source-map ids, and binding metadata. Registry records are evidence for route scoring, not proof of equivalent behavior: authored metadata keeps `autoMergeClaim` and `semanticEquivalenceClaim` false.
+
 ## Authored possibility spaces
 
 `.frontier` files can describe a governed space of valid implementations with `constraintSpace` or `possibilitySpace` blocks. These blocks are metadata-only: they do not add kernel nodes, but they preserve the variables, hard constraints, preferences, collapse strategies, and admission rules that let tools reason about semantic merge, translation, refactoring, and runtime projection as constraint satisfaction.

package/dist/dialect-registry.js

@@ -0,0 +1,184 @@
+export function parseDialectRegistryBlock(block) {
+  const name = nameFrom(block.header);
+  const registry = {
+    kind: 'frontier.lang.universalDialectRegistry',
+    version: 1,
+    id: idFrom(block.header, `dialect_registry_${name}`),
+    language: readWord('language', block.body),
+    dialect: readWord('dialect', block.body),
+    sourcePath: readWord('sourcePath', block.body) ?? readWord('path', block.body),
+    dialects: [],
+    externs: [],
+    metadata: {
+      authoredDialectRegistry: true,
+      authoredDialectRegistryBlockName: name,
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }
+  };
+  for (const rawLine of block.body.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const dialect = /^(?:dialect|record)\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    const extern = /^extern\s+([A-Za-z_$][\w$-]*)(.*)$/.exec(line);
+    if (dialect) registry.dialects.push(dialectRecord(registry, dialect[1], dialect[2]));
+    if (extern) registry.externs.push(externRecord(registry, extern[1], extern[2]));
+  }
+  return summarizeRegistry(registry);
+}
+
+export function mergeDialectRegistryBlocks(blocks = []) {
+  if (!blocks.length) return undefined;
+  return summarizeRegistry({
+    kind: 'frontier.lang.universalDialectRegistry',
+    version: 1,
+    id: blocks.length === 1 ? blocks[0].id : 'dialect_registry:source',
+    language: first(blocks.map((block) => block.language)),
+    dialects: uniqueById(blocks.flatMap((block) => block.dialects ?? [])),
+    externs: uniqueById(blocks.flatMap((block) => block.externs ?? [])),
+    metadata: {
+      authoredDialectRegistryBlockIds: blocks.map((block) => block.id),
+      semanticEquivalenceClaim: false,
+      autoMergeClaim: false
+    }
+  });
+}
+
+function dialectRecord(registry, name, text) {
+  return cleanRecord({
+    kind: 'frontier.lang.universalDialectRecord',
+    version: 1,
+    id: idFrom(text, `dialect_${name}`),
+    language: readInlineWord('language', text) ?? registry.language,
+    dialect: readInlineWord('dialect', text) ?? registry.dialect ?? name,
+    constructKind: readInlineWord('constructKind', text) ?? readInlineWord('kind', text) ?? 'runtime',
+    name: readInlineWord('name', text) ?? name,
+    nativeKind: readInlineWord('nativeKind', text),
+    sourcePath: readInlineWord('sourcePath', text) ?? readInlineWord('path', text) ?? registry.sourcePath,
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeId: readInlineWord('nativeAstNode', text) ?? readInlineWord('nativeAstNodeId', text),
+    semanticNodeId: readInlineWord('semanticNode', text) ?? readInlineWord('semanticNodeId', text),
+    semanticSymbolId: readInlineWord('symbol', text) ?? readInlineWord('semanticSymbol', text) ?? readInlineWord('semanticSymbolId', text),
+    semanticOccurrenceId: readInlineWord('semanticOccurrence', text) ?? readInlineWord('semanticOccurrenceId', text),
+    sourceMapId: readInlineWord('sourceMap', text) ?? readInlineWord('sourceMapId', text),
+    sourceMapMappingId: readInlineWord('sourceMapMapping', text) ?? readInlineWord('sourceMapMappingId', text),
+    externIds: readInlineList(text, 'extern', 'externId', 'externIds') ?? [],
+    lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds') ?? [],
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds') ?? [],
+    projection: projectionRecord(text),
+    metadata: { semanticEquivalenceClaim: false, autoMergeClaim: false }
+  });
+}
+
+function externRecord(registry, name, text) {
+  const binding = cleanRecord({
+    module: readInlineWord('module', text),
+    path: readInlineWord('bindingPath', text) ?? readInlineWord('path', text),
+    symbol: readInlineWord('bindingSymbol', text) ?? readInlineWord('symbol', text),
+    abi: readInlineWord('abi', text),
+    version: readInlineWord('version', text)
+  });
+  return cleanRecord({
+    kind: 'frontier.lang.universalExternRecord',
+    version: 1,
+    id: idFrom(text, `extern_${name}`),
+    language: readInlineWord('language', text) ?? registry.language,
+    dialect: readInlineWord('dialect', text) ?? registry.dialect ?? name,
+    externKind: readInlineWord('externKind', text) ?? readInlineWord('kind', text) ?? 'foreignSymbol',
+    name: readInlineWord('name', text) ?? name,
+    ...(Object.keys(binding).length ? { binding } : {}),
+    sourcePath: readInlineWord('sourcePath', text) ?? registry.sourcePath,
+    nativeSourceId: readInlineWord('nativeSource', text) ?? readInlineWord('nativeSourceId', text),
+    nativeAstId: readInlineWord('nativeAst', text) ?? readInlineWord('nativeAstId', text),
+    nativeAstNodeId: readInlineWord('nativeAstNode', text) ?? readInlineWord('nativeAstNodeId', text),
+    semanticNodeId: readInlineWord('semanticNode', text) ?? readInlineWord('semanticNodeId', text),
+    semanticSymbolId: readInlineWord('semanticSymbol', text) ?? readInlineWord('semanticSymbolId', text),
+    sourceMapId: readInlineWord('sourceMap', text) ?? readInlineWord('sourceMapId', text),
+    sourceMapMappingId: readInlineWord('sourceMapMapping', text) ?? readInlineWord('sourceMapMappingId', text),
+    lossIds: readInlineList(text, 'loss', 'lossId', 'lossIds') ?? [],
+    evidenceIds: readInlineList(text, 'evidence', 'evidenceId', 'evidenceIds') ?? [],
+    projection: projectionRecord(text),
+    metadata: { semanticEquivalenceClaim: false, autoMergeClaim: false }
+  });
+}
+
+function projectionRecord(text) {
+  const lossIds = readInlineList(text, 'projectionLoss', 'projectionLossIds', 'loss', 'lossId', 'lossIds') ?? [];
+  const disposition = readInlineWord('disposition', text) ?? (lossIds.length ? 'lossy' : 'review-required');
+  return cleanRecord({
+    disposition,
+    readiness: readInlineWord('readiness', text) ?? readinessForDisposition(disposition),
+    targets: readInlineList(text, 'target', 'targets', 'targetLanguage') ?? [],
+    lossIds,
+    evidenceIds: readInlineList(text, 'projectionEvidence', 'projectionEvidenceIds', 'evidence', 'evidenceId', 'evidenceIds') ?? [],
+    sourceMapIds: readInlineList(text, 'sourceMap', 'sourceMapId', 'sourceMapIds'),
+    sourceMapMappingIds: readInlineList(text, 'sourceMapMapping', 'sourceMapMappingId', 'sourceMapMappingIds'),
+    notes: readInlineList(text, 'note', 'notes')
+  });
+}
+
+function summarizeRegistry(registry) {
+  const dialects = uniqueById(registry.dialects ?? []);
+  const externs = uniqueById(registry.externs ?? []);
+  const records = [...dialects, ...externs];
+  return cleanRecord({
+    ...registry,
+    dialects,
+    externs,
+    summary: {
+      dialects: dialects.length,
+      externs: externs.length,
+      records: records.length,
+      languages: unique(records.map((record) => record.language)),
+      dialectNames: unique(records.map((record) => record.dialect)),
+      constructKinds: countBy(dialects.map((record) => record.constructKind)),
+      externKinds: countBy(externs.map((record) => record.externKind)),
+      lossIds: unique(records.flatMap((record) => record.lossIds ?? [])),
+      evidenceIds: unique(records.flatMap((record) => record.evidenceIds ?? [])),
+      sourceMapIds: unique(records.flatMap((record) => [record.sourceMapId, ...(record.projection?.sourceMapIds ?? [])])),
+      projectionDispositions: countBy(records.map((record) => record.projection?.disposition)),
+      projectionReadiness: records.reduce((readiness, record) => maxReadiness(readiness, record.projection?.readiness ?? 'ready'), 'ready'),
+      recordsWithLosses: records.filter((record) => (record.lossIds ?? []).length).length,
+      recordsWithProjectionEvidence: records.filter((record) => (record.projection?.evidenceIds ?? []).length).length
+    }
+  });
+}
+
+function readinessForDisposition(disposition) {
+  if (disposition === 'preserved' || disposition === 'lossless') return 'ready';
+  if (disposition === 'lossy' || disposition === 'declaration-only') return 'ready-with-losses';
+  if (disposition === 'stub-only' || disposition === 'unsupported') return 'blocked';
+  return 'needs-review';
+}
+
+function maxReadiness(left, right) {
+  const order = ['ready', 'ready-with-losses', 'needs-review', 'blocked'];
+  return order.indexOf(right) > order.indexOf(left) ? right : left;
+}
+
+function idFrom(text, fallback) { return /@id\(\s*["']([^"']+)["']\s*\)/.exec(text)?.[1] ?? fallback; }
+function nameFrom(header) { return /^([A-Za-z_$][\w$]*)/.exec(header)?.[1] ?? 'Unnamed'; }
+function readWord(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\s,]+)', 'm').exec(body)?.[1]?.trim(); }
+function readInlineWord(label, text) { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
+function readInlineList(text, ...labels) {
+  for (const label of labels) {
+    const value = readInlineWord(label, text);
+    if (value) return value.split(/[|,]/).map((item) => item.trim()).filter(Boolean);
+  }
+  return undefined;
+}
+function cleanRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function unique(values) { return [...new Set(values.filter(Boolean))]; }
+function first(values) { return values.find(Boolean); }
+function uniqueById(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    if (!record?.id || seen.has(record.id)) return false;
+    seen.add(record.id);
+    return true;
+  });
+}
+function countBy(values) {
+  return values.filter(Boolean).reduce((counts, value) => ({ ...counts, [value]: (counts[value] ?? 0) + 1 }), {});
+}

package/dist/index.js

@@ -2,6 +2,7 @@ import { actionNode, capabilityNode, createDocument, effectNode, entityNode, ext
 import { parseConstraintSpaceBlock } from './constraint-space.js';
 import { parseConversionBlock } from './conversion.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';
@@ -20,6 +21,7 @@ export function parseFrontierSource(source, options = {}) {
   const conversionBlocks = [];
   const constraintSpaceBlocks = [];
   const decisionGraphBlocks = [];
+  const dialectRegistryBlocks = [];
   const interlinguaBlocks = [];
   const resourceGraphBlocks = [];
   const nativeSourceBlocks = [];
@@ -48,10 +50,11 @@ export function parseFrontierSource(source, options = {}) {
     if (block.kind === 'conversion' || block.kind === 'universalConversionPlan') conversionBlocks.push(parseConversionBlock(block));
     if (block.kind === 'constraintSpace' || block.kind === 'possibilitySpace') constraintSpaceBlocks.push(parseConstraintSpaceBlock(block));
     if (block.kind === 'decisionGraph' || block.kind === 'admissionGraph') decisionGraphBlocks.push(parseDecisionGraphBlock(block));
+    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));
   }
-  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
+  const metadata = createParsedMetadata({ proofBlocks, paradigmBlocks, operationBlocks, conversionBlocks, constraintSpaceBlocks, decisionGraphBlocks, dialectRegistryBlocks, interlinguaBlocks, resourceGraphBlocks, nativeSourceBlocks });
   return createDocument({ id: documentId, name: documentName, nodes, ...(metadata ? { metadata } : {}) });
 }
 
@@ -61,7 +64,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|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)\s+([^{}]+)\{/g;
   let match;
   while ((match = header.exec(source))) {
     let depth = 1; let index = header.lastIndex;

package/dist/metadata.js

@@ -1,3 +1,5 @@
+import { mergeDialectRegistryBlocks } from './dialect-registry.js';
+
 const PROOF_GROUPS = ['contracts', 'refinements', 'invariants', 'termination', 'temporal', 'obligations', 'artifacts', 'assumptions'];
 const PARADIGM_GROUPS = [
   'bindingScopes',
@@ -21,7 +23,7 @@ const PARADIGM_GROUPS = [
   'loweringRecords'
 ];
 
-export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
+export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], operationBlocks = [], conversionBlocks = [], constraintSpaceBlocks = [], decisionGraphBlocks = [], dialectRegistryBlocks = [], interlinguaBlocks = [], resourceGraphBlocks = [], nativeSourceBlocks = [] } = {}) {
   const metadata = {};
   if (proofBlocks.length) metadata.proof = mergeProofBlocks(proofBlocks);
   if (paradigmBlocks.length) metadata.paradigmSemantics = mergeParadigmBlocks(paradigmBlocks);
@@ -29,6 +31,7 @@ export function createParsedMetadata({ proofBlocks = [], paradigmBlocks = [], op
   if (conversionBlocks.length) metadata.universalConversionPlan = mergeConversionBlocks(conversionBlocks);
   if (constraintSpaceBlocks.length) metadata.constraintSpaces = mergeConstraintSpaceBlocks(constraintSpaceBlocks);
   if (decisionGraphBlocks.length) metadata.decisionGraph = mergeDecisionGraphBlocks(decisionGraphBlocks);
+  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)) {

package/dist/view.js

@@ -34,20 +34,32 @@ function readViewEvents(body) {
 }
 
 function readRenderNodes(body) {
-  return readNestedBlocks('render', body).map((block) => {
-    const tagName = nameFrom(block.header);
-    const props = readRenderProps(block.body);
-    const events = readRenderEvents(block.body);
-    return {
-      id: idFrom(block.header, `render_${tagName}`),
-      kind: readInlineWord('kind', block.header) ?? 'element',
-      tagName,
-      identityKey: readLine('identity', block.body) ?? readLine('key', block.body),
-      text: readQuotedLine('text', block.body),
-      props: props.length ? props : undefined,
-      events: events.length ? events : undefined
-    };
-  });
+  const renders = [];
+  for (const block of readNestedBlocks('render', body)) pushRenderNode(block, renders);
+  return renders;
+}
+
+function pushRenderNode(block, renders) {
+  const headerName = nameFrom(block.header);
+  const ownBody = stripNestedBlocks('render', block.body);
+  const kind = readInlineWord('kind', block.header) ?? readLine('kind', ownBody) ?? 'element';
+  const props = readRenderProps(ownBody);
+  const events = readRenderEvents(ownBody);
+  const childBlocks = readNestedBlocks('render', block.body);
+  const explicitChildren = readList('children', ownBody) ?? readList('child', ownBody);
+  const nestedChildren = childBlocks.map((child) => idFrom(child.header, `render_${nameFrom(child.header)}`));
+  renders.push(compactRecord({
+    id: idFrom(block.header, `render_${headerName}`),
+    kind,
+    tagName: readLine('tag', ownBody) ?? readLine('tagName', ownBody) ?? (kind === 'component' || kind === 'text' ? undefined : headerName),
+    component: readLine('component', ownBody) ?? (kind === 'component' ? headerName : undefined),
+    identityKey: readLine('identity', ownBody) ?? readLine('key', ownBody),
+    text: readQuotedLine('text', ownBody),
+    props: props.length ? props : undefined,
+    events: events.length ? events : undefined,
+    children: uniqueStrings([...(explicitChildren ?? []), ...nestedChildren])
+  }));
+  for (const child of childBlocks) pushRenderNode(child, renders);
 }
 
 function readRenderProps(body) {
@@ -92,6 +104,8 @@ function readLine(label, body) { return new RegExp('^\\s*' + label + '\\s+([^\\n
 function readQuotedLine(label, body) { return new RegExp(`^\\s*${label}\\s+["']([^"']+)["']`, 'm').exec(body)?.[1]; }
 function readInlineWord(label, text = '') { return new RegExp('(?:^|\\s)' + label + '\\s+([^\\s,]+)').exec(text)?.[1]?.trim(); }
 function readRenderValue(value) { const quoted = /^["']([^"']+)["']$/.exec(value.trim()); return quoted ? { value: quoted[1] } : { expression: value.trim() }; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueStrings(values) { const result = []; for (const value of values) if (value && !result.includes(value)) result.push(value); return result.length ? result : undefined; }
 function parseOptionalTypeExpression(value) { return value ? parseTypeExpression(value.trim()) : undefined; }
 function parseTypeExpression(value) {
   const text = value.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-parser",
-  "version": "0.3.23",
+  "version": "0.3.25",
   "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/resource-graph-smoke.mjs && node test/interlingua-smoke.mjs",
+    "test": "npm run build && node test/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",