@lokascript/framework 4.7.0 → 5.0.0

package/src/generation/index.ts

@@ -2,7 +2,7 @@
  * Pattern generation, rendering, and diagnostics
  */
 
-export * from './pattern-generator';
+export * from './profile';
 export * from './renderer';
 export * from './diagnostics';
 export * from './schema-patterns';

package/src/generation/profile.ts

@@ -0,0 +1,41 @@
+/**
+ * A domain's language profile, and the role order its sentences use.
+ */
+
+import type { RoleSpec } from '../schema';
+
+/**
+ * A domain's language profile as framework reads it: word order, command
+ * keywords, and role markers (with the side of the value each attaches to).
+ */
+export interface PatternGenLanguageProfile {
+  readonly code: string;
+  readonly wordOrder: 'SVO' | 'SOV' | 'VSO' | 'VOS' | 'OSV' | 'OVS' | 'free';
+  readonly keywords: Record<string, { primary: string; alternatives?: string[] }>;
+  readonly roleMarkers?: Record<
+    string,
+    { primary: string; alternatives?: string[]; position?: 'before' | 'after' }
+  >;
+}
+
+/**
+ * Sort roles by word order: descending `svoPosition` (or `sovPosition` in an
+ * SOV language) — higher values come first. The schema renderer
+ * (`createSchemaRenderer`) orders roles with it, as the core's pattern
+ * generator does (`createSchemaPatternGenerator` with `positionOrder:
+ * 'descending'`), so a rendered surface re-parses.
+ */
+export function sortRolesByWordOrder(roles: RoleSpec[], wordOrder: string): RoleSpec[] {
+  const sorted = [...roles];
+
+  if (wordOrder === 'SVO') {
+    // Sort by svoPosition (higher = earlier)
+    sorted.sort((a, b) => (b.svoPosition ?? 0) - (a.svoPosition ?? 0));
+  } else if (wordOrder === 'SOV') {
+    // Sort by sovPosition (higher = earlier)
+    sorted.sort((a, b) => (b.sovPosition ?? 0) - (a.sovPosition ?? 0));
+  }
+  // VSO and others use SVO-style ordering
+
+  return sorted;
+}

package/src/generation/renderer.test.ts

@@ -11,7 +11,7 @@ import type { KeywordTable, MarkerTable } from './renderer';
 import type { SemanticNode } from '../core/types';
 import type { CommandSchema } from '../schema';
 import { defineCommand, defineRole } from '../schema';
-import type { PatternGenLanguageProfile } from './pattern-generator';
+import type { PatternGenLanguageProfile } from './profile';
 
 // =============================================================================
 // Test Data

package/src/generation/renderer.ts

@@ -11,7 +11,7 @@
 import type { SemanticNode } from '../core/types';
 import { extractRoleValue, extractValue } from '../core/types';
 import type { CommandSchema } from '../schema';
-import { sortRolesByWordOrder, type PatternGenLanguageProfile } from './pattern-generator';
+import { sortRolesByWordOrder, type PatternGenLanguageProfile } from './profile';
 
 // =============================================================================
 // Renderer Interface

package/src/generation/schema-patterns.test.ts

@@ -1,7 +1,7 @@
 /**
  * The schema-pattern generator semantic's hyperscript parser runs (domains
  * rethink Phase 4.4), on a schema of its own: the grammar's position order,
- * the variants, and a profile's optional markers.
+ * the variants, a profile's optional markers, and a role's word list.
  */
 import { describe, expect, it } from 'vitest';
 import { defineCommand, defineRole } from '../schema';
@@ -80,6 +80,46 @@ describe('createSchemaPatternGenerator', () => {
     ]);
   });
 
+  it("puts a role's word list for the pattern's language on its token, in every variant", () => {
+    const close = defineCommand({
+      action: 'send',
+      roles: [
+        defineRole({
+          role: 'patient',
+          required: true,
+          expectedTypes: ['expression'],
+          words: { '*': ['tab'], tr: ['sekme'] },
+        }),
+        defineRole({ role: 'destination', required: false, expectedTypes: ['selector'] }),
+      ],
+    });
+    const generator = createSchemaPatternGenerator({ positionOrder: 'ascending' });
+    const wordsOf = (tokens: readonly PatternToken[]): unknown[] =>
+      tokens.flatMap(t =>
+        t.type === 'role' ? [[t.role, t.words]] : t.type === 'group' ? wordsOf(t.tokens) : []
+      );
+    const at = (profile: SchemaPatternProfile) => {
+      const variants = generator.generatePatternVariants(close, profile, {
+        basePriority: 100,
+        generateSimpleVariants: true,
+      });
+      const roles = variants.flatMap(p => wordsOf(p.template.tokens)) as [string, unknown][];
+      return {
+        variants: variants.length,
+        patient: [
+          ...new Set(roles.filter(([r]) => r === 'patient').map(([, w]) => JSON.stringify(w))),
+        ],
+        destination: [
+          ...new Set(roles.filter(([r]) => r === 'destination').map(([, w]) => JSON.stringify(w))),
+        ],
+      };
+    };
+    expect(at(en)).toEqual({ variants: 2, patient: ['["tab"]'], destination: [undefined] });
+    expect(at(tr)).toEqual({ variants: 3, patient: ['["tab","sekme"]'], destination: [undefined] });
+    // No list, no field: the patterns of a grammar that lists no words are unchanged.
+    expect(JSON.stringify(generator.generatePattern(send, en))).not.toContain('words');
+  });
+
   it('drops variant-only roles', () => {
     const scroll = defineCommand({
       action: 'scroll',

package/src/generation/schema-patterns.ts

@@ -1,8 +1,8 @@
 /**
  * Patterns from command schemas: the generator semantic's hyperscript parser
  * runs (domains rethink Phase 4.4, `docs-internal/DOMAINS_RETHINK.md`), moved
- * here from `@lokascript/semantic` beside the domains' own `generatePattern`
- * (`pattern-generator.ts`), which `createMultilingualDSL` still uses.
+ * here from `@lokascript/semantic`; `createMultilingualDSL` generates every
+ * domain's patterns with it (the classic generator went in 5.0, Phase 6).
  *
  * Per command and language it builds the main pattern and its variants: the
  * simple variant (required roles only), the omit-role, widened-type and
@@ -21,7 +21,7 @@ export interface SchemaPatternGrammar {
   /**
    * How `svoPosition` / `sovPosition` sort: `'ascending'` puts the lowest first
    * (hyperscript's schemas, 1-based), `'descending'` the highest (a domain's
-   * schemas, as framework's `generatePattern` reads them).
+   * schemas, as `sortRolesByWordOrder` and the schema renderer read them).
    */
   readonly positionOrder: 'ascending' | 'descending';
 }
@@ -382,11 +382,13 @@ function generateVerbFirstPattern(
   // verb-first, which is exactly this shape (trailing particle tolerated).
   const roleTokens: PatternToken[] = requiredRoles.flatMap(r => {
     const prefix = r.valuePrefixLiteral?.[profile.code];
+    const words = wordsFor(r, profile.code);
     const roleToken: PatternToken = {
       type: 'role',
       role: r.role,
       optional: false,
       expectedTypes: r.expectedTypes,
+      ...(words ? { words } : {}),
     };
     return prefix ? [{ type: 'literal', value: prefix } as PatternToken, roleToken] : [roleToken];
   });
@@ -673,6 +675,13 @@ function buildRoleTokens(
  * use — a hand-rolled copy there is what let the two drift apart in the first
  * place (see `appendRemainingOptionalRoles` in event-handlers-sov.ts).
  */
+/** The words a role reads in `language` (`RoleSpec.words`: its `'*'` list and the language's own). */
+function wordsFor(roleSpec: RoleSpec, language: string): readonly string[] | undefined {
+  if (!roleSpec.words) return undefined;
+  const words = [...(roleSpec.words['*'] ?? []), ...(roleSpec.words[language] ?? [])];
+  return words.length > 0 ? words : undefined;
+}
+
 function buildRoleToken(roleSpec: RoleSpec, profile: SchemaPatternProfile): PatternToken[] {
   const tokens: PatternToken[] = [];
 
@@ -686,6 +695,7 @@ function buildRoleToken(roleSpec: RoleSpec, profile: SchemaPatternProfile): Patt
   // `fetch "/api"`). Tag the emitted marker literal so the renderer skips it;
   // the pattern matcher ignores the flag, so parsing is unchanged.
   const suppressMarker = roleSpec.renderOverride?.[profile.code] === '';
+  const words = wordsFor(roleSpec, profile.code);
 
   // Role value token
   const roleValueToken: PatternToken = {
@@ -700,6 +710,8 @@ function buildRoleToken(roleSpec: RoleSpec, profile: SchemaPatternProfile): Patt
     // A greedy role reads up to the next marker the pattern owes (a domain's
     // SQL condition); its value reader does the reading.
     ...(roleSpec.greedy ? { greedy: true } : {}),
+    // A role with a word list reads only one of its words.
+    ...(words ? { words } : {}),
   };
 
   // Required literal immediately before the role VALUE (rolePrefixLiteralVariants

package/src/multilingual/bridge.test.ts

@@ -14,9 +14,9 @@ import {
   deriveRoleMarkers,
 } from './builders';
 import type { GrammarProfileSlice, DomainVocabulary } from './types';
-import { generatePattern } from '../generation/pattern-generator';
 import { defineCommand, defineRole } from '../schema';
 import { createMultilingualDSL } from '../api/create-dsl';
+import { extractValue } from '../core/types';
 
 // =============================================================================
 // Fixture slices (mirror the shape of semantic KNOWN_PROFILES entries)
@@ -189,7 +189,7 @@ describe('buildPatternProfile', () => {
     expect(profile.keywords.select.alternatives).toEqual([...alternatives]);
   });
 
-  describe('generatePattern integration', () => {
+  describe('a DSL built from the profile (the core engine)', () => {
     const moveSchema = defineCommand({
       action: 'move',
       description: 'Move a thing',
@@ -212,37 +212,45 @@ describe('buildPatternProfile', () => {
         }),
       ],
     });
+    const dsl = createMultilingualDSL({
+      name: 'Move',
+      schemas: [moveSchema],
+      languages: [
+        buildLanguageConfig(EN_SLICE, { keywords: { move: { primary: 'move' } } }),
+        buildLanguageConfig(JA_SLICE, { keywords: { move: { primary: '移動' } } }),
+        buildLanguageConfig(AR_SLICE, { keywords: { move: { primary: 'انقل' } } }),
+      ],
+    });
+    const roles = (input: string, language: string) => {
+      const node = dsl.parse(input, language);
+      return [
+        node.action,
+        ...[...node.roles].map(([role, value]) => `${role}=${extractValue(value)}`),
+      ];
+    };
 
     it('SVO (en-like): keyword first, prepositional marker before its role', () => {
-      const vocab: DomainVocabulary = { keywords: { move: { primary: 'move' } } };
-      const pattern = generatePattern(moveSchema, buildPatternProfile(EN_SLICE, vocab));
-
-      expect(pattern.template.tokens).toEqual([
-        { type: 'literal', value: 'move' },
-        { type: 'role', role: 'patient', optional: false, expectedTypes: ['expression'] },
-        { type: 'literal', value: 'into' },
-        { type: 'role', role: 'destination', optional: false, expectedTypes: ['expression'] },
+      expect(roles('move box into shelf', 'en')).toEqual([
+        'move',
+        'patient=box',
+        'destination=shelf',
       ]);
     });
 
     it('SOV (ja-like): particles after their roles, verb last', () => {
-      const vocab: DomainVocabulary = { keywords: { move: { primary: '移動' } } };
-      const pattern = generatePattern(moveSchema, buildPatternProfile(JA_SLICE, vocab));
-
-      expect(pattern.template.tokens).toEqual([
-        { type: 'role', role: 'patient', optional: false, expectedTypes: ['expression'] },
-        { type: 'literal', value: 'を' },
-        { type: 'role', role: 'destination', optional: false, expectedTypes: ['expression'] },
-        { type: 'literal', value: 'に' },
-        { type: 'literal', value: '移動' },
+      expect(roles('box を shelf に 移動', 'ja')).toEqual([
+        'move',
+        'patient=box',
+        'destination=shelf',
       ]);
     });
 
     it('VSO (ar-like): verb first', () => {
-      const vocab: DomainVocabulary = { keywords: { move: { primary: 'انقل' } } };
-      const pattern = generatePattern(moveSchema, buildPatternProfile(AR_SLICE, vocab));
-
-      expect(pattern.template.tokens[0]).toEqual({ type: 'literal', value: 'انقل' });
+      expect(roles('انقل box في shelf', 'ar')).toEqual([
+        'move',
+        'patient=box',
+        'destination=shelf',
+      ]);
     });
   });
 });

package/src/multilingual/builders.ts

@@ -10,7 +10,7 @@
  */
 
 import type { LanguageTokenizer } from '../core/types';
-import type { PatternGenLanguageProfile } from '../generation/pattern-generator';
+import type { PatternGenLanguageProfile } from '../generation/profile';
 import type { LanguageConfig } from '../api/create-dsl';
 import type { LanguageProfile as GrammarProfile } from '../grammar';
 import { createSimpleTokenizer, type TokenizerProfile } from '../core/tokenization/base-tokenizer';
@@ -51,8 +51,8 @@ function mergeRoleMarkers(
 
 /**
  * Build a pattern-generation profile: domain keywords + slice grammar
- * (word order, role markers). The result feeds `generatePattern` /
- * `generatePatternVariants` and `LanguageConfig.patternProfile`.
+ * (word order, role markers). The result feeds `LanguageConfig.patternProfile`
+ * and the schema renderer.
  */
 export function buildPatternProfile(
   slice: GrammarProfileSlice,

package/src/parsing/index.ts

@@ -4,7 +4,6 @@
 
 // Re-export core parsing types
 export type { SemanticNode, TokenStream, LanguageTokenizer } from '../core/types';
-export { PatternMatcher } from '../core/pattern-matching';
 
 // Multi-statement parser
 export { createMultiStatementParser, accumulateBlocks } from './multi-statement';

package/src/testing/gate/lint/types.ts

@@ -4,7 +4,7 @@
 
 import type { CommandSchema } from '../../../schema';
 import type { LanguageTokenizer } from '../../../core/types';
-import type { PatternGenLanguageProfile } from '../../../generation/pattern-generator';
+import type { PatternGenLanguageProfile } from '../../../generation/profile';
 
 export type Severity = 'error' | 'warning' | 'note';
 

package/src/testing/gate/round-trip.test.ts

@@ -1,14 +1,17 @@
 /**
  * The round-trip gate kit on framework's SQL fixture DSL: the commands it writes,
- * the outcomes it reads, and the baseline and snapshot it compares with.
+ * the outcomes it reads (an unknown word read into a role among them), and the
+ * baseline and snapshot it compares with.
  */
 import { describe, expect, it } from 'vitest';
-import { createSQLDSL, selectCommand } from '../../__test__/fixtures/sql-dsl';
+import { createSQLDSL, selectCommand, sqlDSLConfig } from '../../__test__/fixtures/sql-dsl';
+import { createMultilingualDSL } from '../../api/create-dsl';
 import {
   commandsFor,
   compare,
   countsOf,
   listingOf,
+  readsWord,
   runRoundTrip,
   snapshotChanges,
   snapshotOf,
@@ -42,11 +45,19 @@ describe('runRoundTrip', () => {
     ]);
   });
 
+  it("writes a fixture's own commands after the generated ones, once each", () => {
+    const own = '[select columns:email source:users condition:age]';
+    expect(
+      commandsFor([selectCommand], { ...fixture, commands: [own, '[select columns:id source:t]'] })
+    ).toEqual([...commandsFor([selectCommand], fixture), '[select columns:id source:t]']);
+    expect(commandsFor([selectCommand], fixture)).toContain(own);
+  });
+
   it('reads every render back, in every language, and tries each with an unknown word after it', () => {
     expect(countsOf(results)).toEqual({
       roundTrip: { cases: 8, pass: 8, refused: 0, silent: 0 },
-      // The `where` condition is greedy: it takes the unknown word as text (an open-text role).
-      leftover: { cases: 8, pass: 0, refused: 4, silent: 4 },
+      // The `where` condition is greedy: it takes the unknown word as text, into the SQL (`pass`).
+      leftover: { cases: 8, pass: 4, refused: 4, silent: 0 },
     });
     expect(results.find(r => r.kind === 'roundTrip' && r.lang === 'es')).toMatchObject({
       text: 'seleccionar name de users',
@@ -65,12 +76,14 @@ describe('compare', () => {
   });
 
   it('reports a case worse than listed, one better, and a listed case that is gone', () => {
+    // Two leftover cases accepted that the baseline lists as refused.
+    const accepted = '[select columns:name source:users]';
+    const now = results.map(r =>
+      r.kind === 'leftover' && r.source === accepted ? { ...r, outcome: 'silent' as const } : r
+    );
     const listing = listingOf(results);
-    const accepted = Object.keys(listing.leftover)[0]!;
-    const better = { ...listing.leftover };
-    delete better[accepted];
-    const drift = compare('sql', results, {
-      ...baselineOf({ roundTrip: listing.roundTrip, leftover: better }),
+    const drift = compare('sql', now, {
+      ...baselineOf(listing),
       roundTrip: {
         sql: {
           '[select columns:name source:users]': {
@@ -97,6 +110,83 @@ describe('compare', () => {
   });
 });
 
+describe('an unknown word read into a role', () => {
+  const leftover = (rs: typeof results) =>
+    rs
+      .filter(r => r.kind === 'leftover' && r.source.includes('condition'))
+      .map(r => [r.lang, r.outcome, r.why]);
+
+  it('is read (`pass`) where it extends an open-text role and reaches the code', () => {
+    expect(leftover(results)).toEqual([
+      ['en', 'pass', undefined],
+      ['es', 'pass', undefined],
+      ['en', 'pass', undefined],
+      ['es', 'pass', undefined],
+    ]);
+    expect(results.find(r => r.kind === 'leftover' && r.source.includes('condition'))?.read).toBe(
+      'select columns:expression=name condition:expression="age zzqx" source:expression=users'
+    );
+  });
+
+  it('is accepted (`silent`) where it does not reach the code', () => {
+    const dropsCondition = createMultilingualDSL({
+      ...sqlDSLConfig(),
+      codeGenerator: { generate: () => 'SELECT name FROM users' },
+    });
+    const rs = runRoundTrip('sql', dropsCondition, [selectCommand], fixture);
+    expect(leftover(rs)[0]).toEqual([
+      'en',
+      'silent',
+      'accepted as select; the word does not reach the code',
+    ]);
+  });
+
+  it('is refused where the input stops compiling, unless the command never compiles on its own', () => {
+    const refusesTheWord = createMultilingualDSL({
+      ...sqlDSLConfig(),
+      codeGenerator: {
+        generate: n => {
+          const c = n.roles.get('condition') as { raw?: string } | undefined;
+          if (c?.raw?.includes('zzqx')) throw new Error('not a condition');
+          return 'SELECT';
+        },
+      },
+    });
+    const rs = runRoundTrip('sql', refusesTheWord, [selectCommand], fixture);
+    expect(leftover(rs)[0]).toEqual(['en', 'refused', 'does not compile']);
+    const alone = runRoundTrip('sql', refusesTheWord, [selectCommand], {
+      ...fixture,
+      englishDoesNotCompile: ['select'],
+    });
+    expect(leftover(alone)[0]).toEqual(['en', 'pass', undefined]);
+  });
+
+  const node = (action: string, roles: Record<string, string>) => ({
+    action,
+    roles: new Map(Object.entries(roles).map(([k, v]) => [k, { type: 'expression', raw: v }])),
+  });
+
+  it.each([
+    ['extends one role', { condition: 'age' }, { condition: 'age zzqx' }, true],
+    ['fills a role the text left empty', {}, { list: 'zzqx' }, true],
+    [
+      'moves a value to make room for it (`when clicks zzqx`)',
+      { action: 'clicks' },
+      { actor: 'clicks', action: 'zzqx' },
+      false,
+    ],
+    ['replaces a value', { quantity: '2' }, { quantity: 'zzqx' }, false],
+    ['is in two roles', {}, { a: 'zzqx', b: 'zzqx' }, false],
+    ['is not read at all', { a: 'x' }, { a: 'x' }, false],
+  ] as const)('a parse that %s is the text read with the word: %s', (_, was, now, want) => {
+    expect(readsWord(node('when', was), node('when', now), 'zzqx')).toBe(want);
+  });
+
+  it('a parse as another command is not', () => {
+    expect(readsWord(node('when', {}), node('given', { a: 'zzqx' }), 'zzqx')).toBe(false);
+  });
+});
+
 describe('the parse snapshot', () => {
   it('shows a parse that moved', () => {
     const parses = snapshotOf(results);

package/src/testing/gate/round-trip.ts

@@ -13,8 +13,13 @@
  *   generator normalizes: bdd ja `#box0 が 表示 前提` is `visible`). English is a lane like the others.
  *   `refused` when the render is null or the parse throws: the caller is told. `silent` otherwise: it
  *   reads, or compiles to, something else.
- * - **leftover**: the same render plus one unknown word. `refused` is the expected outcome; a parse
- *   that returns accepted input it did not read (`silent`).
+ * - **leftover**: the same render plus one unknown word. `refused` is the expected outcome: the parse
+ *   throws, or the input does not compile. `pass` where the word is READ: the parse is the text's own
+ *   with the word in one role (an open-text role extended by it, `where active zzqx`, or a role the
+ *   text left empty, `list zzqx`), and the word is in the code (for a command that never compiles on
+ *   its own, `englishDoesNotCompile`, the parse alone). `silent` otherwise: the input is accepted and
+ *   read as something else (`when clicks zzqx`: actor `clicks`, action `zzqx`), or the word goes
+ *   nowhere (voice `back zzqx` compiles as `back`).
  *
  * The outcomes are the command-shape gate's (hyperfixi `testing-framework`). A baseline lists every
  * case that is not at its best outcome; `compare` reports a case worse than listed and one better than
@@ -93,7 +98,16 @@ export interface GateFixture {
   oracle: 'compile' | 'node';
   /** Keys are `<action>.<role>` or `<role>` (every action). The first value is the one the other cases use. */
   values: Record<string, string[]>;
-  /** Actions that do not compile on their own (a gate may check every other one does). */
+  /**
+   * Commands (bracket syntax) written besides the generated ones, where one role's value depends on
+   * another's and no single list fits both: behaviorspec's `[given subject:#box value:visible]` beside
+   * `[given subject:viewport value:1024x768]`.
+   */
+  commands?: string[];
+  /**
+   * Actions that do not compile on their own (a gate may check every other one does). Leftover input
+   * in such a command is judged by its parse alone.
+   */
   englishDoesNotCompile?: string[];
 }
 
@@ -132,6 +146,7 @@ export function commandsFor(schemas: readonly GateSchema[], fixture: GateFixture
       });
     }
   }
+  for (const command of fixture.commands ?? []) out.add(command);
   return [...out];
 }
 
@@ -181,6 +196,35 @@ function describeRead(want: Record<string, string>, ref: GateNode, back: GateNod
 
 const message = (e: unknown) => String((e as Error)?.message ?? e).slice(0, 160);
 
+/** What `text` compiles to, or `undefined` when it does not compile. */
+function codeOf(dsl: GateDSL, text: string, lang: string): string | undefined {
+  try {
+    const c = dsl.compile(text, lang);
+    return c.ok && typeof c.code === 'string' ? c.code : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Whether `read`, the parse of a text plus `word`, is `back`, the text's own parse, with the word read
+ * into it: the same action and roles, except one role, whose value is its value in `back` followed by
+ * the word (an open-text role at the end: sql `where active zzqx`) or, where `back` has no such role,
+ * the word itself (todo `list zzqx`).
+ */
+export function readsWord(back: GateNode, read: GateNode, word: string): boolean {
+  if (read.action !== back.action) return false;
+  const was = roleValues(back);
+  const now = roleValues(read);
+  let changed = 0;
+  for (const role of new Set([...Object.keys(was), ...Object.keys(now)])) {
+    if (was[role] === now[role]) continue;
+    if (now[role] !== (role in was ? `${was[role]} ${word}` : word)) return false;
+    changed++;
+  }
+  return changed === 1;
+}
+
 /** What a command (bracket syntax) compiles to; null when it does not compile on its own. */
 export function referenceCode(dsl: GateDSL, source: string): string | null {
   try {
@@ -253,18 +297,39 @@ export function runRoundTrip(
 
       // Leftover input: only where the text itself reads, or a refusal would say nothing.
       const extended = `${text} ${UNKNOWN_WORD}`;
+      let read: GateNode;
       try {
-        const read = dsl.parse(extended, lang);
-        results.push({
-          ...at,
-          kind: 'leftover',
-          outcome: 'silent',
-          text: extended,
-          why: `accepted as ${read.action}`,
-        });
+        read = dsl.parse(extended, lang);
       } catch {
         results.push({ ...at, kind: 'leftover', outcome: 'refused', text: extended });
+        continue;
       }
+      // Read with the word, the word must reach the code. Where the input does not compile, compile
+      // tells the caller (`refused`), except for a command that never compiles on its own (bdd's
+      // `and`), where only the parse can say.
+      const kept = readsWord(back, read, UNKNOWN_WORD);
+      const code = kept ? codeOf(dsl, extended, lang) : undefined;
+      const alone = fixture.englishDoesNotCompile?.includes(read.action) ?? false;
+      const [left, leftWhy]: [Outcome, string | undefined] = !kept
+        ? [
+            'silent',
+            `accepted as ${read.action}; reads ${describeRead(roleValues(back), back, read)}`,
+          ]
+        : code !== undefined
+          ? code.includes(UNKNOWN_WORD)
+            ? ['pass', undefined]
+            : ['silent', `accepted as ${read.action}; the word does not reach the code`]
+          : alone
+            ? ['pass', undefined]
+            : ['refused', 'does not compile'];
+      results.push({
+        ...at,
+        kind: 'leftover',
+        outcome: left,
+        text: extended,
+        ...(leftWhy ? { why: leftWhy } : {}),
+        read: summarize(read),
+      });
     }
   }
   return results;

package/dist/core/pattern-matching/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Pattern matching infrastructure for semantic parsing
- */
-export * from './pattern-matcher';
-export * from './utils';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/pattern-matching/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/pattern-matching/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC"}