@lokascript/framework 4.8.0 → 5.1.0

package/src/api/create-dsl.ts

@@ -13,10 +13,9 @@ import type {
 } from '../core/types';
 import { extractRoleValue } from '../core/types';
 import type { CommandSchema } from '../schema';
-import { PatternMatcher } from '../core/pattern-matching';
 import { MatchSkeleton, createStockReader, stockConfidenceModel } from '../core/matching';
-import { generatePattern, type PatternGenLanguageProfile } from '../generation/pattern-generator';
-import { createDomainRenderer, type DomainRenderFn } from '../generation/renderer';
+import type { PatternGenLanguageProfile } from '../generation/profile';
+import type { DomainRenderFn } from '../generation/renderer';
 import {
   createSchemaPatternGenerator,
   type SchemaPatternProfile,
@@ -186,18 +185,17 @@ export interface DSLConfig {
   readonly customPatterns?: LanguagePattern[];
 
   /**
-   * What reads and writes the DSL (domains rethink Phase 4.7). `'classic'`, the
-   * default: framework's first pattern generator, matcher and schema renderer.
-   * `'core'`: the core semantic's hyperscript parser runs — patterns from
+   * What reads and writes the DSL. `'core'`, the only engine (and the
+   * default): the core semantic's hyperscript parser runs — patterns from
    * `createSchemaPatternGenerator` (positions descending, as a domain's schemas
    * read), matched by `MatchSkeleton` with the stock reader and confidence
    * model, and rendered through those patterns where the domain's own renderer
-   * declines. Parsing's whole-input rule, the refusals, translation's
-   * read-back, compile, explicit syntax and extensions are the same on both.
-   * The domains move to `'core'` one at a time against their gate (Phase 5);
-   * `'classic'` is removed in a later major, once no domain uses it.
+   * declines. The option stays so a config written for framework 4.7–4.8
+   * (`engine: 'core'`) builds unchanged; `'classic'`, framework's first
+   * generator and matcher, was removed in 5.0 (domains rethink Phase 6) and
+   * throws.
    */
-  readonly engine?: 'classic' | 'core';
+  readonly engine?: 'core';
 }
 
 /**
@@ -888,10 +886,10 @@ export function createMultilingualDSL(config: DSLConfig): MultilingualDSL {
 // =============================================================================
 
 /**
- * What differs between the engines {@link DSLConfig.engine} names: how each
- * command's pattern is generated, how input is matched against it, and the
- * renderer `render()` falls back to. Parsing's whole-input rule, refusals,
- * translation's read-back, compile, explicit syntax and extensions are shared.
+ * What reads and writes a DSL: how each command's pattern is generated, how
+ * input is matched against it, and the renderer `render()` falls back to.
+ * Parsing's whole-input rule, refusals, translation's read-back, compile,
+ * explicit syntax and extensions sit above it.
  */
 interface DSLEngine {
   generate(schema: CommandSchema, profile: PatternGenLanguageProfile): LanguagePattern;
@@ -900,29 +898,20 @@ interface DSLEngine {
 }
 
 /**
- * The engine `config.engine` names. An unknown name throws rather than reading
- * with the default: a domain that misspells `'core'` would otherwise measure
- * the classic engine against its gate and take the result for the core's.
+ * The engine `config.engine` names: the core, the only one since 5.0. An
+ * unknown name throws rather than reading with the default, and `'classic'`
+ * says what replaced it.
  */
 function engineFor(config: DSLConfig): DSLEngine {
-  const name = config.engine ?? 'classic';
-  if (name === 'classic') return classicEngine();
+  const name: string = config.engine ?? 'core';
   if (name === 'core') return coreEngine();
-  throw new Error(`Unknown DSL engine "${String(name)}" (expected "classic" or "core")`);
-}
-
-/** framework's first generator and matcher, and its schema renderer (`engine: 'classic'`). */
-function classicEngine(): DSLEngine {
-  const matcher = new PatternMatcher();
-  return {
-    generate: (schema, profile) => generatePattern(schema, profile),
-    match: (tokens, pattern, language) => matcher.matchPattern(tokens, pattern, { code: language }),
-    fallbackRenderer: config =>
-      createDomainRenderer({
-        schemas: config.schemas,
-        profiles: config.languages.map(l => l.patternProfile),
-      }),
-  };
+  if (name === 'classic') {
+    throw new Error(
+      'The "classic" DSL engine was removed in @lokascript/framework 5.0. ' +
+        'Omit `engine` (or pass "core"): every domain reads on the core.'
+    );
+  }
+  throw new Error(`Unknown DSL engine "${name}" (expected "core")`);
 }
 
 /**

package/src/core/index.ts

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

package/src/core/matching/index.ts

@@ -10,3 +10,5 @@ export type { ConfidenceBreakdown, ConfidenceContext, ConfidenceModel } from './
 export { StockValueReader, createStockReader, greedyStopMarkers, readGreedy } from './stock-reader';
 export { readRoleValue, type ReadingProfile } from './stock-reading';
 export { stockConfidenceModel } from './stock-confidence';
+export * from './type-validation';
+export * from './possessive-keywords';

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

@@ -1,8 +1,7 @@
 /**
- * The stock confidence model: how framework's old matcher scored a domain
- * pattern's match (`core/pattern-matching/`), moved here as a `ConfidenceModel`
- * for the matcher's skeleton (domains rethink Phase 4.7); the old matcher calls
- * it too until Phase 6.
+ * The stock confidence model: how framework's first matcher scored a domain
+ * pattern's match, moved here as a `ConfidenceModel` for the matcher's
+ * skeleton (domains rethink Phase 4.7).
  *
  * Role coverage (a required slot 1, an optional one 0.8, an absent optional one
  * with a default 60% of that), a stem-match penalty (up to 15%, floor 0.5), and

package/src/core/matching/stock-reading.ts

@@ -1,8 +1,8 @@
 /**
- * Reading a domain value at a role slot: the value reading framework's old
- * matcher (`core/pattern-matching/`) did, moved here so the stock reader on the
- * matcher's skeleton (`stock-reader.ts`, domains rethink Phase 4.7) and the old
- * matcher run the same code until Phase 6 deletes the old one.
+ * Reading a domain value at a role slot: the value reading framework's first
+ * matcher did, moved here for the stock reader on the matcher's skeleton
+ * (`stock-reader.ts`, domains rethink Phase 4.7). The first matcher was
+ * deleted in 5.0 (Phase 6).
  *
  * In order: an English noise word before a selector (`the`), then the
  * multi-token forms (a possessive, `my value`; a method call,
@@ -22,8 +22,8 @@ import type {
   LanguageToken,
 } from '../types';
 import { createSelector, createLiteral, createReference, createPropertyPath } from '../types';
-import { isTypeCompatible } from '../pattern-matching/utils/type-validation';
-import { getPossessiveReference } from '../pattern-matching/utils/possessive-keywords';
+import { isTypeCompatible } from './type-validation';
+import { getPossessiveReference } from './possessive-keywords';
 
 /** What value reading needs of a language profile: its code, and its possessive words. */
 export interface ReadingProfile {

package/src/core/{pattern-matching/utils → matching}/type-validation.test.ts

@@ -1,7 +1,7 @@
 /**
  * Type Validation Tests
  *
- * Tests the type compatibility and validation utilities used by PatternMatcher.
+ * Tests the type compatibility and validation utilities the stock reader uses.
  */
 
 import { describe, it, expect } from 'vitest';
@@ -17,7 +17,7 @@ import {
   isVariableRef,
   isBuiltInReference,
 } from './type-validation';
-import type { SemanticValue } from '../../types';
+import type { SemanticValue } from '../types';
 
 describe('Type Validation', () => {
   describe('isTypeCompatible', () => {

package/src/core/{pattern-matching/utils → matching}/type-validation.ts

@@ -5,7 +5,7 @@
  * Used by pattern-matcher to validate captured role values.
  */
 
-import type { SemanticValue } from '../../types';
+import type { SemanticValue } from '../types';
 
 /**
  * Semantic value type strings.

package/src/generation/domain-renderer.test.ts

@@ -12,7 +12,7 @@ import { createDomainRenderer, createSchemaRenderer } 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';
 
 function makeNode(action: string, roles: Record<string, string>): SemanticNode {
   const rolesMap = new Map<string, { type: 'expression'; raw: string }>();

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.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';
 }

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/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"}