@lokascript/framework 4.5.0 → 4.7.0

package/src/api/domain-registry.ts

@@ -31,6 +31,9 @@
  */
 
 import type { MultilingualDSL, CompileResult, ValidationResult } from './create-dsl';
+import { UnreadInputError, TranslationReadBackError } from './create-dsl';
+import { readingDifference } from './reading';
+import type { SemanticNode } from '../core/types';
 import type { NaturalLanguageRenderer, DomainRenderFn } from '../generation/renderer';
 import type { CommandSchema } from '../schema/command-schema';
 import type { SchemaLookup } from '../ir/types';
@@ -244,6 +247,9 @@ export class DomainRegistry {
           return jsonResponse({ error: `Unknown operation: ${parsed.operation}` }, true);
       }
     } catch (error) {
+      // A refusal is not a tool failure: say what was refused and why, as translate_code does.
+      if (error instanceof UnreadInputError) return unreadInputResponse(error);
+      if (error instanceof TranslationReadBackError) return readBackResponse(error);
       const message = error instanceof Error ? error.message : String(error);
       return jsonResponse({ error: `${descriptor.name} tool error: ${message}` }, true);
     }
@@ -412,6 +418,9 @@ export class DomainRegistry {
       ok: result.ok,
       code: result.code,
       errors: result.errors,
+      ...(result.errorCode === 'unread-input'
+        ? { diagnostics: [UNREAD_INPUT(result.errors)] }
+        : {}),
       language,
       input,
     });
@@ -431,6 +440,9 @@ export class DomainRegistry {
     return jsonResponse({
       valid: result.valid,
       errors: result.errors,
+      ...(result.errorCode === 'unread-input'
+        ? { diagnostics: [UNREAD_INPUT(result.errors)] }
+        : {}),
       language,
       [descriptor.inputLabel]: input,
     });
@@ -478,7 +490,28 @@ export class DomainRegistry {
       roles[key] = value;
     }
 
+    // The rendering must read back as the source, by the rule `translate` uses: the same action and
+    // role values, or the same compiled code. A rendering that does not is refused, with the text under
+    // `partial`, never `rendered`.
+    if (rendered != null) {
+      let back: SemanticNode | null = null;
+      let why = '';
+      try {
+        back = dsl.parse(rendered, to);
+        why = readingDifference(node, back);
+        if (why && compiled.ok) {
+          const again = dsl.compile(rendered, to);
+          if (again.ok && again.code === compiled.code) why = '';
+        }
+      } catch (error) {
+        why = error instanceof Error ? error.message : String(error);
+      }
+      if (why)
+        return readBackResponse(new TranslationReadBackError(rendered, from, to, node, back, why));
+    }
+
     return jsonResponse({
+      ok: true,
       input: { [descriptor.inputLabel]: input, language: from },
       ...(rendered != null && { rendered: { text: rendered, language: to } }),
       semantic: { action: node.action, roles },
@@ -567,7 +600,7 @@ function generateToolDefinitions(desc: DomainDescriptor): MCPToolDefinition[] {
       case 'translate':
         tools.push({
           name: `translate_${desc.name}`,
-          description: `Translate ${desc.description} input between natural languages (requires 'from' and 'to' codes). Supports: ${langList}.`,
+          description: `Translate ${desc.description} input between natural languages (requires 'from' and 'to' codes). Supports: ${langList}. A rendering that does not read back as the source is REFUSED: ok is false, the diagnostic is TRANSLATION_DOES_NOT_READ_BACK, and its text is under \`partial\`, never \`rendered\`: do not present it as the translation. Input left unread is refused as UNREAD_INPUT.`,
           inputSchema: {
             type: 'object',
             properties: {
@@ -609,6 +642,54 @@ function getString(args: Record<string, unknown>, name: string, defaultValue = '
   return typeof value === 'string' ? value : defaultValue;
 }
 
+function readingOf(node: SemanticNode): { action: string; roles: Record<string, unknown> } {
+  const roles: Record<string, unknown> = {};
+  for (const [key, value] of node.roles) roles[key] = value;
+  return { action: node.action, roles };
+}
+
+const UNREAD_INPUT = (errors?: readonly string[]) => ({
+  severity: 'error',
+  code: 'UNREAD_INPUT',
+  message: errors?.[0] ?? 'part of the input was not read',
+  suggestion:
+    'Part of the input belongs to no role of the command it reads as: remove it, or quote a value of several words.',
+});
+
+/** A parse refused because it read the command only by leaving input unread. */
+function unreadInputResponse(error: UnreadInputError): MCPToolResponse {
+  return jsonResponse(
+    {
+      ok: false,
+      unread: error.unread,
+      reading: readingOf(error.reading),
+      diagnostics: [UNREAD_INPUT([error.message])],
+    },
+    true
+  );
+}
+
+/** A translation refused because it does not read back as the source; its text under `partial`. */
+function readBackResponse(error: TranslationReadBackError): MCPToolResponse {
+  return jsonResponse(
+    {
+      ok: false,
+      partial: error.partial,
+      ...(error.reading ? { reading: readingOf(error.reading) } : {}),
+      diagnostics: [
+        {
+          severity: 'error',
+          code: 'TRANSLATION_DOES_NOT_READ_BACK',
+          message: error.message,
+          suggestion:
+            'The rendering would not mean the source in the target language: do not present `partial` as the translation.',
+        },
+      ],
+    },
+    true
+  );
+}
+
 function jsonResponse(data: unknown, isError?: boolean): MCPToolResponse {
   return {
     content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],

package/src/api/index.ts

@@ -5,3 +5,4 @@
 export * from './create-dsl';
 export * from './domain-registry';
 export * from './dispatcher';
+export * from './translation-loss';

package/src/api/reading.ts

@@ -0,0 +1,29 @@
+/**
+ * How a read-back is compared (internal: not exported from the package). `translate` and the
+ * registry's translate tool both require a rendering to read back as its source; this is their rule.
+ */
+import type { SemanticNode } from '../core/types';
+
+/** A node's role values as strings, by role: what a read-back is compared on. */
+function roleValues(node: SemanticNode): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const [role, value] of node.roles) {
+    const v = value as { value?: unknown; raw?: unknown };
+    out.set(role, String(v?.value ?? v?.raw ?? value));
+  }
+  return out;
+}
+
+/** How `back` differs from `source`; empty when it reads the same. */
+export function readingDifference(source: SemanticNode, back: SemanticNode): string {
+  if (back.action !== source.action) return `reads as ${back.action}`;
+  const want = roleValues(source);
+  const got = roleValues(back);
+  const parts: string[] = [];
+  for (const [role, value] of want) {
+    if (!got.has(role)) parts.push(`${role} lost`);
+    else if (got.get(role) !== value) parts.push(`${role}: ${value} → ${got.get(role)}`);
+  }
+  for (const role of got.keys()) if (!want.has(role)) parts.push(`${role} added`);
+  return parts.join(', ');
+}

package/src/api/translation-loss.test.ts

@@ -0,0 +1,89 @@
+/**
+ * The translation-loss checks, with rules of a toy grammar: each check in its
+ * place in the order, and the error a refusing translation throws.
+ */
+import { describe, expect, it } from 'vitest';
+import {
+  findTranslationLoss,
+  LossyTranslationError,
+  unconsumedSpans,
+  type TranslationLossRules,
+} from './translation-loss';
+
+interface Node {
+  readonly action: string;
+  readonly diagnostics?: ReadonlyArray<{ readonly code?: string; readonly message: string }>;
+}
+
+const unread = (text: string): Node => ({
+  action: 'go',
+  diagnostics: [{ code: 'unconsumed-input', message: `input not read: "${text}"` }],
+});
+
+const rules: TranslationLossRules<Node> = {
+  unwritable: node => (node.action === 'legacy' ? ['legacy'] : []),
+  differences: [(written, back) => (written.action === back.action ? [] : [`-${written.action}`])],
+  missingValues: (input, output) => (input.includes('#a') && !output.includes('#a') ? ['#a'] : []),
+};
+
+describe('findTranslationLoss', () => {
+  const ok: Node = { action: 'go' };
+
+  it('finds nothing in a translation that reads back with its values', () => {
+    expect(findTranslationLoss('go #a', ok, 've #a', () => ok, rules)).toBeUndefined();
+  });
+
+  it('checks in order: truncation, core-only, read-back, invariant', () => {
+    expect(findTranslationLoss('go #a x', unread('x'), '', () => ok, rules)).toEqual({
+      kind: 'truncation',
+      lost: ['x'],
+    });
+    expect(findTranslationLoss('x', { action: 'legacy' }, '', () => ok, rules)?.kind).toBe(
+      'core-only'
+    );
+    expect(
+      findTranslationLoss(
+        'go #a',
+        ok,
+        '?',
+        () => {
+          throw new Error('no pattern');
+        },
+        rules
+      )
+    ).toEqual({ kind: 'read-back', lost: ['the output does not read: no pattern'] });
+    expect(findTranslationLoss('go #a', ok, 've #a y', () => unread('y'), rules)).toEqual({
+      kind: 'read-back',
+      lost: ['y'],
+    });
+    expect(findTranslationLoss('go #a', ok, 'stop #a', () => ({ action: 'stop' }), rules)).toEqual({
+      kind: 'read-back',
+      lost: ['-go'],
+    });
+    expect(findTranslationLoss('go #a', ok, 've', () => ok, rules)).toEqual({
+      kind: 'invariant',
+      lost: ['#a'],
+    });
+  });
+
+  it('compares the read-back with what was written', () => {
+    const written: TranslationLossRules<Node> = { ...rules, written: () => ({ action: 'stop' }) };
+    expect(
+      findTranslationLoss('go #a', ok, 'stop #a', () => ({ action: 'stop' }), written)
+    ).toBeUndefined();
+  });
+});
+
+describe('unconsumedSpans and LossyTranslationError', () => {
+  it('reads the unread text out of the diagnostics', () => {
+    expect(unconsumedSpans(unread('banana'))).toEqual(['banana']);
+    expect(unconsumedSpans({ action: 'go' })).toEqual([]);
+  });
+
+  it('says what the translation loses', () => {
+    const error = new LossyTranslationError('ve', { kind: 'invariant', lost: ['#a'] }, 'en', 'es');
+    expect(error.name).toBe('LossyTranslationError');
+    expect(error.partial).toBe('ve');
+    expect(error.message).toBe('translation en → es would lose part of the script (invariant): #a');
+  });
+});

package/src/api/translation-loss.ts

@@ -0,0 +1,128 @@
+/**
+ * Fail-loud translation: what a translation checks before it returns (domains
+ * rethink Phase 4.5, `docs-internal/DOMAINS_RETHINK.md`). Moved from
+ * `@lokascript/semantic`'s `explicit/lossy.ts`, whose `translate` runs it with
+ * hyperscript's rules; `createMultilingualDSL`'s `translate` keeps its own
+ * read-back (`TranslationReadBackError`).
+ *
+ * A parse that matches a prefix of a script and leaves the rest unread used to
+ * come back from `translate()` as though it were the whole: `toggle .a .b`
+ * became `toggle .a`. A surface that cannot carry a script now says so: the
+ * translation throws a {@link LossyTranslationError}, which carries the output
+ * it would have returned and what it loses. Four checks, cheapest first:
+ *
+ *   - `truncation`  the parse of the input left input bound to no role (its
+ *                   `unconsumed-input` diagnostics);
+ *   - `core-only`   the input holds a form the grammar's writer has no spelling
+ *                   for (hyperscript: a form only `@hyperfixi/core` ran, which
+ *                   upstream reads with another meaning) — `rules.unwritable`;
+ *   - `read-back`   the output, read in the target language, does not read,
+ *                   leaves input unread, or differs from what was written
+ *                   (`rules.differences`, in order);
+ *   - `invariant`   a value the translation must write verbatim is missing
+ *                   from the output (`rules.missingValues`).
+ *
+ * None of them can say a translation is right. Each says one way it is wrong.
+ */
+
+export type TranslationLossKind = 'truncation' | 'core-only' | 'read-back' | 'invariant';
+
+/** One way a translation loses part of its input. */
+export interface TranslationLoss {
+  kind: TranslationLossKind;
+  /**
+   * What is lost: the input left unread (`truncation`); the forms nothing
+   * writes (`core-only`, as `swap <strategy>`); the output left unread or what
+   * it reads back without or with in excess (`read-back`, as `-cmd` / `+cmd`);
+   * or the verbatim values missing from the output (`invariant`).
+   */
+  lost: string[];
+}
+
+export class LossyTranslationError extends Error {
+  override readonly name = 'LossyTranslationError';
+
+  constructor(
+    /** The output `translate()` would have returned: NOT the whole script. */
+    readonly partial: string,
+    readonly loss: TranslationLoss,
+    readonly from: string,
+    readonly to: string
+  ) {
+    super(
+      `translation ${from} → ${to} would lose part of the script (${loss.kind}): ` +
+        loss.lost.join(', ')
+    );
+  }
+}
+
+/** What the checks read of a parse: its diagnostics. */
+export interface LossCheckedNode {
+  readonly diagnostics?: ReadonlyArray<{ readonly code?: string; readonly message: string }>;
+}
+
+/** The spans a parse left bound to no role (its top node carries them all). */
+export function unconsumedSpans(node: LossCheckedNode): string[] {
+  const out: string[] = [];
+  for (const d of node.diagnostics ?? []) {
+    if (d.code !== 'unconsumed-input') continue;
+    out.push(/"(.*)"\s*$/s.exec(d.message)?.[1] ?? d.message);
+  }
+  return out;
+}
+
+/** A grammar's rules for `findTranslationLoss`, for its node type `N`. */
+export interface TranslationLossRules<N extends LossCheckedNode> {
+  /** The forms in `node` the grammar's writer has no spelling for (`core-only`). */
+  unwritable?(node: N): string[];
+  /**
+   * `node` as it was written into the target language, to compare its
+   * read-back with (hyperscript: in upstream's spelling for English). Default:
+   * `node` itself.
+   */
+  written?(node: N): N;
+  /**
+   * How the read-back differs from what was written, checked in order: the
+   * first that finds a difference is the loss (hyperscript: commands, then
+   * roles, then clauses kept as written).
+   */
+  readonly differences: ReadonlyArray<(written: N, back: N) => string[]>;
+  /** The values `input` holds that `output` must write verbatim and does not (`invariant`). */
+  missingValues?(input: string, output: string): string[];
+}
+
+/**
+ * How a translation of `input` (parsed as `node`) into `output` loses part of
+ * it, or undefined. `readBack` parses the output in the target language; it
+ * throws when the output does not read.
+ */
+export function findTranslationLoss<N extends LossCheckedNode>(
+  input: string,
+  node: N,
+  output: string,
+  readBack: (output: string) => N,
+  rules: TranslationLossRules<N>
+): TranslationLoss | undefined {
+  const unread = unconsumedSpans(node);
+  if (unread.length) return { kind: 'truncation', lost: unread };
+  const unwritable = rules.unwritable?.(node) ?? [];
+  if (unwritable.length) return { kind: 'core-only', lost: unwritable };
+
+  let back: N;
+  try {
+    back = readBack(output);
+  } catch (e) {
+    return { kind: 'read-back', lost: [`the output does not read: ${(e as Error).message}`] };
+  }
+  const misread = unconsumedSpans(back);
+  if (misread.length) return { kind: 'read-back', lost: misread };
+  const written = rules.written ? rules.written(node) : node;
+  for (const difference of rules.differences) {
+    const lost = difference(written, back);
+    if (lost.length) return { kind: 'read-back', lost };
+  }
+
+  const values = rules.missingValues?.(input, output) ?? [];
+  if (values.length) return { kind: 'invariant', lost: values };
+  return undefined;
+}

package/src/core/index.ts

@@ -5,3 +5,4 @@
 export * from './types';
 export * from './tokenization';
 export * from './pattern-matching';
+export * from './matching';

package/src/core/matching/confidence-model.ts

@@ -0,0 +1,58 @@
+/**
+ * The matcher's confidence model: an injectable score for a pattern's match
+ * (domains rethink Phase 4.3). The interface moved here with the skeleton
+ * (`match-skeleton.ts`), which calls `calculate` once per matched pattern;
+ * hyperscript's model is `@lokascript/semantic`'s `DefaultConfidenceModel`.
+ */
+
+import type { LanguagePattern, SemanticRole, SemanticValue } from '../types';
+
+/**
+ * Context passed to confidence model methods.
+ */
+export interface ConfidenceContext {
+  /** The pattern being matched */
+  readonly pattern: LanguagePattern;
+  /** Captured semantic roles */
+  readonly captured: ReadonlyMap<SemanticRole, SemanticValue>;
+  /** Number of stem (morphological) keyword matches */
+  readonly stemMatchCount: number;
+  /** Total keyword matches attempted */
+  readonly totalKeywordMatches: number;
+}
+
+/**
+ * Breakdown of confidence scoring factors (for diagnostics/debugging).
+ */
+export interface ConfidenceBreakdown {
+  /** Role coverage score (0-1) */
+  readonly roleCoverage: number;
+  /** Stem match penalty applied (0 to -0.15) */
+  readonly stemPenalty: number;
+  /** Language-specific boost (e.g., VSO verb-first) */
+  readonly languageBoost: number;
+  /** Language-specific adjustment (e.g., preposition disambiguation) */
+  readonly languageAdjustment: number;
+  /** Final clamped confidence (0-1) */
+  readonly final: number;
+}
+
+/**
+ * Injectable confidence scoring model.
+ *
+ * Each method computes one factor of the confidence score.
+ * Override individual methods to customize scoring without rewriting the pipeline.
+ */
+export interface ConfidenceModel {
+  /**
+   * Calculate the full confidence score.
+   * Default implementation calls each factor method and combines them.
+   */
+  calculate(ctx: ConfidenceContext): number;
+
+  /**
+   * Calculate confidence with a detailed breakdown.
+   * Useful for diagnostics and debugging.
+   */
+  calculateWithBreakdown(ctx: ConfidenceContext): ConfidenceBreakdown;
+}

package/src/core/matching/index.ts

@@ -0,0 +1,12 @@
+/**
+ * The pattern matcher's skeleton and its value-reader seam (domains rethink
+ * Phase 4.3): the matcher semantic's hyperscript parser runs, with
+ * hyperscript's reading behind `ValueReader`.
+ */
+
+export { MatchSkeleton } from './match-skeleton';
+export type { MatchView, RoleSlot, ValueReader } from './value-reader';
+export type { ConfidenceBreakdown, ConfidenceContext, ConfidenceModel } from './confidence-model';
+export { StockValueReader, createStockReader, greedyStopMarkers, readGreedy } from './stock-reader';
+export { readRoleValue, type ReadingProfile } from './stock-reading';
+export { stockConfidenceModel } from './stock-confidence';

package/src/core/matching/match-skeleton.test.ts

@@ -0,0 +1,179 @@
+/**
+ * The matcher's skeleton with a reader that knows no hyperscript: every role
+ * slot takes one token. What the skeleton does on its own — literals, group
+ * rollback, the speculative skip, spans, ranking — and that every value comes
+ * from the reader (domains rethink Phase 4.2-4.3).
+ */
+import { describe, expect, it } from 'vitest';
+import { MatchSkeleton } from './match-skeleton';
+import type { MatchView, RoleSlot, ValueReader } from './value-reader';
+import type { ConfidenceContext, ConfidenceModel } from './confidence-model';
+import { TokenStreamImpl } from '../tokenization/token-utils';
+import type {
+  LanguagePattern,
+  LanguageToken,
+  PatternMatchResult,
+  PatternToken,
+  SemanticRole,
+  SemanticValue,
+  TokenStream,
+} from '../types';
+
+class OneTokenReader implements ValueReader {
+  readonly began: string[] = [];
+  readonly owed: string[][] = [];
+
+  constructor(private readonly view: MatchView) {}
+
+  beginPattern(pattern: LanguagePattern): void {
+    this.began.push(pattern.id);
+  }
+
+  readRole(
+    tokens: TokenStream,
+    slot: RoleSlot,
+    captured: Map<SemanticRole, SemanticValue>
+  ): boolean {
+    this.owed.push(
+      this.view.patternRest().flatMap(pt => (pt.type === 'literal' ? [pt.value] : []))
+    );
+    const token = tokens.peek();
+    if (!token) return slot.optional ?? false;
+    captured.set(slot.role, { type: 'literal', value: token.value });
+    tokens.advance();
+    return true;
+  }
+
+  maySkipSlot(patternToken: PatternToken, token: LanguageToken | null): boolean {
+    return patternToken.type === 'role' && !!patternToken.optional && token?.value === 'now';
+  }
+
+  atClauseEnd(tokens: TokenStream): boolean {
+    return tokens.isAtEnd();
+  }
+
+  resultFields(): Partial<PatternMatchResult> {
+    return { eventSource: { type: 'literal', value: 'from-reader' } };
+  }
+}
+
+function model(score: (ctx: ConfidenceContext) => number): ConfidenceModel {
+  return {
+    calculate: score,
+    calculateWithBreakdown: ctx => ({
+      roleCoverage: score(ctx),
+      stemPenalty: 0,
+      languageBoost: 0,
+      languageAdjustment: 0,
+      final: score(ctx),
+    }),
+  };
+}
+
+const flat = model(() => 1);
+
+function matcher(confidence: ConfidenceModel = flat): {
+  skeleton: MatchSkeleton;
+  reader: () => OneTokenReader;
+} {
+  let reader: OneTokenReader | undefined;
+  const skeleton = new MatchSkeleton(view => (reader = new OneTokenReader(view)), confidence);
+  return { skeleton, reader: () => reader! };
+}
+
+function stream(text: string): TokenStream {
+  let offset = 0;
+  const tokens = text.split(' ').map(value => {
+    const token: LanguageToken = {
+      value,
+      kind: 'identifier',
+      position: { start: offset, end: offset + value.length },
+    };
+    offset += value.length + 1;
+    return token;
+  });
+  return new TokenStreamImpl(tokens, 'xx');
+}
+
+const lit = (value: string): PatternToken => ({ type: 'literal', value });
+const role = (name: string, optional = false): PatternToken => ({
+  type: 'role',
+  role: name as SemanticRole,
+  ...(optional ? { optional } : {}),
+});
+const group = (...tokens: PatternToken[]): PatternToken => ({
+  type: 'group',
+  optional: true,
+  tokens,
+});
+
+function pattern(id: string, tokens: PatternToken[], priority = 100): LanguagePattern {
+  return {
+    id,
+    language: 'xx',
+    command: 'go',
+    priority,
+    template: { format: id, tokens },
+    extraction: {},
+  };
+}
+
+const values = (result: PatternMatchResult | null) =>
+  Object.fromEntries(
+    [...(result?.captured ?? [])].map(([r, v]) => [r, (v as { value?: unknown }).value])
+  );
+
+describe('MatchSkeleton', () => {
+  it('matches literals itself and reads every role slot through the reader', () => {
+    const { skeleton, reader } = matcher();
+    const result = skeleton.matchPattern(
+      stream('go home now'),
+      pattern('p', [lit('go'), role('destination'), lit('now')])
+    );
+    expect(values(result)).toEqual({ destination: 'home' });
+    expect(result?.consumedTokens).toBe(3);
+    expect(result?.roleStarts?.get('destination' as SemanticRole)).toBe(1);
+    expect(reader().began).toEqual(['p']);
+    // The view shows the reader what the pattern still owes after the slot.
+    expect(reader().owed).toEqual([['now']]);
+  });
+
+  it("adds the reader's result fields", () => {
+    const { skeleton } = matcher();
+    const result = skeleton.matchPattern(stream('go home'), pattern('p', [lit('go'), role('x')]));
+    expect(result?.eventSource).toEqual({ type: 'literal', value: 'from-reader' });
+  });
+
+  it('rolls a failed group back, restoring a value it overwrote', () => {
+    const { skeleton } = matcher();
+    // The group reads `b` into destination, then fails on its marker.
+    const result = skeleton.matchPattern(
+      stream('a b c'),
+      pattern('p', [role('destination'), group(role('destination'), lit('に'))])
+    );
+    expect(values(result)).toEqual({ destination: 'a' });
+    expect(result?.consumedTokens).toBe(1);
+  });
+
+  it('skips an optional slot when the reader allows it and the rest reaches a clause end', () => {
+    const { skeleton } = matcher();
+    const result = skeleton.matchPattern(
+      stream('go now'),
+      pattern('p', [lit('go'), role('patient', true), lit('now')])
+    );
+    expect(values(result)).toEqual({});
+    expect(result?.consumedTokens).toBe(2);
+  });
+
+  it('ranks matches by priority, then confidence', () => {
+    const byId = model(ctx => (ctx.pattern.id === 'high' ? 0.9 : 0.5));
+    const { skeleton } = matcher(byId);
+    const tokens = [lit('go'), role('x')];
+    const best = skeleton.matchBest(stream('go home'), [
+      pattern('low', tokens),
+      pattern('high', tokens),
+      pattern('priority', tokens, 50),
+    ]);
+    expect(best?.pattern.id).toBe('high');
+  });
+});