@lokascript/domain-learn 2.1.0

package/dist/profiles/ar.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const arProfile: LearnLanguageProfile;

package/dist/profiles/de.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const deProfile: LearnLanguageProfile;

package/dist/profiles/en.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const enProfile: LearnLanguageProfile;

package/dist/profiles/es.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const esProfile: LearnLanguageProfile;

package/dist/profiles/fr.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const frProfile: LearnLanguageProfile;

package/dist/profiles/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Language Profiles Index
+ *
+ * Re-exports all 10 language profiles and provides a registry lookup.
+ */
+import type { LearnLanguageProfile } from '../types';
+import { enProfile } from './en';
+import { jaProfile } from './ja';
+import { esProfile } from './es';
+import { arProfile } from './ar';
+import { zhProfile } from './zh';
+import { koProfile } from './ko';
+import { frProfile } from './fr';
+import { trProfile } from './tr';
+import { deProfile } from './de';
+import { ptProfile } from './pt';
+export { enProfile, jaProfile, esProfile, arProfile, zhProfile };
+export { koProfile, frProfile, trProfile, deProfile, ptProfile };
+/** All profiles indexed by language code */
+export declare const ALL_PROFILES: Record<string, LearnLanguageProfile>;

package/dist/profiles/ja.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const jaProfile: LearnLanguageProfile;

package/dist/profiles/ko.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const koProfile: LearnLanguageProfile;

package/dist/profiles/pt.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const ptProfile: LearnLanguageProfile;

package/dist/profiles/tr.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const trProfile: LearnLanguageProfile;

package/dist/profiles/zh.d.ts

@@ -0,0 +1,2 @@
+import type { LearnLanguageProfile } from '../types';
+export declare const zhProfile: LearnLanguageProfile;

package/dist/schemas/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Learn Domain Command Schemas
+ *
+ * 15 core verbs formalized as CommandSchemas using the framework's
+ * defineCommand/defineRole helpers. Each schema defines the semantic
+ * roles and per-language marker overrides for sentence rendering.
+ *
+ * Role markers are the RESOLVED values combining:
+ *   - @lokascript/semantic schema markerOverrides (Tiers 1-2)
+ *   - lokascript-learn LEARNING_OVERRIDES (Tier 3)
+ *   - LANGUAGE_RENDERING_OVERRIDES (Tier 4)
+ *   - Profile defaults (Tier 5)
+ *
+ * This collapses the 5-tier resolution into flat markerOverride maps.
+ */
+export declare const addSchema: import("@lokascript/framework").CommandSchema;
+export declare const removeSchema: import("@lokascript/framework").CommandSchema;
+export declare const toggleSchema: import("@lokascript/framework").CommandSchema;
+export declare const putSchema: import("@lokascript/framework").CommandSchema;
+export declare const setSchema: import("@lokascript/framework").CommandSchema;
+export declare const showSchema: import("@lokascript/framework").CommandSchema;
+export declare const hideSchema: import("@lokascript/framework").CommandSchema;
+export declare const getSchema: import("@lokascript/framework").CommandSchema;
+export declare const waitSchema: import("@lokascript/framework").CommandSchema;
+export declare const fetchSchema: import("@lokascript/framework").CommandSchema;
+export declare const sendSchema: import("@lokascript/framework").CommandSchema;
+export declare const goSchema: import("@lokascript/framework").CommandSchema;
+export declare const incrementSchema: import("@lokascript/framework").CommandSchema;
+export declare const decrementSchema: import("@lokascript/framework").CommandSchema;
+export declare const takeSchema: import("@lokascript/framework").CommandSchema;
+export declare const allSchemas: import("@lokascript/framework").CommandSchema[];

package/dist/tokenizers/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Learn Domain Tokenizers
+ *
+ * Language-specific tokenizers for learning domain input (10 languages).
+ * Created via the framework's createSimpleTokenizer factory.
+ *
+ * These tokenizers handle:
+ * - Command verb keyword classification
+ * - Role marker particle/preposition classification
+ * - CSS selector recognition (#id, .class)
+ * - Non-Latin script handling (Japanese, Arabic, Korean, Chinese)
+ */
+import type { LanguageTokenizer } from '@lokascript/framework';
+export declare const EnglishLearnTokenizer: LanguageTokenizer;
+export declare const JapaneseLearnTokenizer: LanguageTokenizer;
+export declare const SpanishLearnTokenizer: LanguageTokenizer;
+export declare const ArabicLearnTokenizer: LanguageTokenizer;
+export declare const ChineseLearnTokenizer: LanguageTokenizer;
+export declare const KoreanLearnTokenizer: LanguageTokenizer;
+export declare const FrenchLearnTokenizer: LanguageTokenizer;
+export declare const TurkishLearnTokenizer: LanguageTokenizer;
+export declare const GermanLearnTokenizer: LanguageTokenizer;
+export declare const PortugueseLearnTokenizer: LanguageTokenizer;

package/dist/types.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Domain-Learn Types
+ *
+ * Types for the learning domain DSL, extending the framework with
+ * communicative functions, morphology tables, and sentence rendering.
+ */
+/** The 7 communicative functions that exercises can target */
+export type CommunicativeFunction = 'commanding' | 'describing' | 'narrating' | 'questioning' | 'negating' | 'planning' | 'progressing';
+export declare const ALL_FUNCTIONS: readonly CommunicativeFunction[];
+/** The 15 core verbs in the learning domain */
+export type CoreVerb = 'add' | 'remove' | 'toggle' | 'put' | 'set' | 'show' | 'hide' | 'get' | 'wait' | 'fetch' | 'send' | 'go' | 'increment' | 'decrement' | 'take';
+export declare const ALL_VERBS: readonly CoreVerb[];
+export type SemanticRole = 'patient' | 'destination' | 'source' | 'instrument' | 'possessive' | 'manner' | 'style';
+export type VerbValence = 'intransitive' | 'transitive' | 'ditransitive';
+export interface CommandProfile {
+    verb: CoreVerb;
+    valence: VerbValence;
+    targetRole: SemanticRole | null;
+    hasPatient: boolean;
+}
+export interface SentenceFrame {
+    function: CommunicativeFunction;
+    template: string;
+    verbForm: string;
+    example: string;
+}
+export interface LanguageFrames {
+    code: string;
+    wordOrder: 'SVO' | 'SOV' | 'VSO';
+    frames: SentenceFrame[];
+}
+export interface RenderedSentence {
+    language: string;
+    function: CommunicativeFunction;
+    sentence: string;
+    verbForm: string;
+    verbValue: string;
+}
+export interface InterlinearGloss {
+    tokens: string[];
+    roles: string[];
+    english: string[];
+}
+export interface EnglishForms {
+    base: string;
+    thirdPerson: string;
+    past: string;
+    pastParticiple: string;
+    presentParticiple: string;
+}
+export interface JapaneseForms {
+    dictionary: string;
+    verbClass: 'godan' | 'ichidan' | 'suru' | 'kuru' | 'special';
+    stem: string;
+    masu: string;
+    mashita: string;
+    ta: string;
+    te: string;
+    nai: string;
+    masen: string;
+    potential: string;
+    volitional: string;
+    ba: string;
+    tara: string;
+}
+export interface SpanishPersonForms {
+    yo: string;
+    tu: string;
+    el: string;
+    nosotros: string;
+    vosotros: string;
+    ellos: string;
+}
+export interface SpanishForms {
+    infinitive: string;
+    verbClass: 'ar' | 'er' | 'ir';
+    irregular: boolean;
+    present: SpanishPersonForms;
+    preterite: SpanishPersonForms;
+    imperfect: SpanishPersonForms;
+    future: SpanishPersonForms;
+    imperative: {
+        tu: string;
+        usted: string;
+        ustedes: string;
+    };
+    gerund: string;
+    pastParticiple: {
+        ms: string;
+        fs: string;
+        mp: string;
+        fp: string;
+    };
+}
+export interface ArabicPersonForms {
+    howa: string;
+    hiya: string;
+    anta: string;
+    anti: string;
+    ana: string;
+    hum: string;
+    nahnu: string;
+}
+export interface ArabicForms {
+    root: string;
+    form: 'I' | 'II' | 'III' | 'IV' | 'V' | 'VI' | 'VII' | 'VIII' | 'X';
+    past: ArabicPersonForms;
+    present: ArabicPersonForms;
+    imperative: {
+        ms: string;
+        fs: string;
+        mp: string;
+    };
+    activeParticiple: string;
+    passiveParticiple: string;
+    masdar: string;
+}
+export interface ChineseForms {
+    base: string;
+    pinyin: string;
+    patterns: {
+        completed: string;
+        experience: string;
+        progressive: string;
+        future: string;
+        negPresent: string;
+        negPast: string;
+    };
+}
+export interface KoreanForms {
+    dictionary: string;
+    verbClass: 'hada' | 'native' | 'special';
+    stem: string;
+    hapnida: string;
+    haesseumnida: string;
+    haeyo: string;
+    haesseoyo: string;
+    imperative: string;
+    past: string;
+    negative: string;
+    progressive: string;
+    future: string;
+}
+export interface FrenchPersonForms {
+    je: string;
+    tu: string;
+    il: string;
+    nous: string;
+    vous: string;
+    ils: string;
+}
+export interface FrenchForms {
+    infinitive: string;
+    imperative: {
+        tu: string;
+        vous: string;
+    };
+    present: FrenchPersonForms;
+    passeCompose: {
+        il: string;
+        je: string;
+    };
+    imparfait: {
+        il: string;
+    };
+    futur: {
+        il: string;
+    };
+    gerondif: string;
+}
+export interface TurkishForms {
+    dictionary: string;
+    imperative: {
+        sen: string;
+        siz: string;
+    };
+    present: {
+        ben: string;
+        sen: string;
+        o: string;
+        biz: string;
+        siz: string;
+        onlar: string;
+    };
+    past: {
+        o: string;
+        ben: string;
+    };
+    future: {
+        o: string;
+    };
+    negative: {
+        o: string;
+    };
+    progressive: {
+        o: string;
+    };
+    gerund: string;
+}
+export interface GermanPersonForms {
+    ich: string;
+    du: string;
+    er: string;
+    wir: string;
+    ihr: string;
+    sie: string;
+}
+export interface GermanForms {
+    infinitive: string;
+    separablePrefix: string;
+    imperative: {
+        du: string;
+        Sie: string;
+    };
+    present: GermanPersonForms;
+    past: {
+        ich: string;
+        er: string;
+    };
+    perfect: {
+        er: string;
+    };
+    future: {
+        er: string;
+    };
+    presentParticiple: string;
+}
+export interface PortuguesePersonForms {
+    eu: string;
+    voce: string;
+    ele: string;
+    nos: string;
+    voces: string;
+    eles: string;
+}
+export interface PortugueseForms {
+    infinitive: string;
+    imperative: {
+        voce: string;
+        voces: string;
+    };
+    present: PortuguesePersonForms;
+    preterite: {
+        ele: string;
+        eu: string;
+    };
+    imperfect: {
+        ele: string;
+    };
+    future: {
+        ele: string;
+    };
+    gerund: string;
+}
+export type AnyForms = EnglishForms | JapaneseForms | SpanishForms | ArabicForms | ChineseForms | KoreanForms | FrenchForms | TurkishForms | GermanForms | PortugueseForms;
+import type { PatternGenLanguageProfile } from '@lokascript/framework';
+export interface LearnLanguageProfile {
+    /** Base framework profile for pattern generation */
+    patternProfile: PatternGenLanguageProfile;
+    /** Morphology table: verb → conjugation forms */
+    morphologyTable: Record<string, AnyForms>;
+    /** Sentence frames per communicative function */
+    frames: LanguageFrames;
+    /** Default sentence subject */
+    defaultSubject: string;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@lokascript/domain-learn",
+  "version": "2.1.0",
+  "description": "Multilingual learning domain DSL — morphology, sentence generation, and exercise support for 15 verbs × 10 languages × 7 communicative functions",
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup && npm run build:types",
+    "build:types": "tsc --emitDeclarationOnly --outDir dist --noEmit false",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:check": "vitest run --reporter=dot 2>&1 | tail -5",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@lokascript/framework": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE"
+  ],
+  "keywords": [
+    "learning",
+    "morphology",
+    "multilingual",
+    "dsl",
+    "i18n",
+    "exercises",
+    "conjugation",
+    "lokascript",
+    "framework"
+  ],
+  "author": "LokaScript Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codetalcott/hyperfixi.git",
+    "directory": "packages/domain-learn"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/__tests__/schemas.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Schema Tests — Verify all 15 verbs parse in all 10 languages
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { createLearnDSL, ALL_VERBS } from '../index';
+import type { MultilingualDSL } from '@lokascript/framework';
+import { extractRoleValue } from '@lokascript/framework';
+
+describe('Learn Domain Schemas', () => {
+  let learn: MultilingualDSL;
+
+  beforeAll(() => {
+    learn = createLearnDSL();
+  });
+
+  describe('Language Support', () => {
+    it('should support 10 languages', () => {
+      const languages = learn.getSupportedLanguages();
+      expect(languages).toHaveLength(10);
+      expect(languages).toContain('en');
+      expect(languages).toContain('ja');
+      expect(languages).toContain('es');
+      expect(languages).toContain('ar');
+      expect(languages).toContain('zh');
+      expect(languages).toContain('ko');
+      expect(languages).toContain('fr');
+      expect(languages).toContain('tr');
+      expect(languages).toContain('de');
+      expect(languages).toContain('pt');
+    });
+
+    it('should have all 15 verbs defined', () => {
+      expect(ALL_VERBS).toHaveLength(15);
+    });
+  });
+
+  describe('English Parsing (SVO)', () => {
+    it('should parse "add active to button"', () => {
+      const node = learn.parse('add active to button', 'en');
+      expect(node.action).toBe('add');
+    });
+
+    it('should parse "remove active from button"', () => {
+      const node = learn.parse('remove active from button', 'en');
+      expect(node.action).toBe('remove');
+    });
+
+    it('should parse "toggle active on button"', () => {
+      const node = learn.parse('toggle active on button', 'en');
+      expect(node.action).toBe('toggle');
+    });
+
+    it('should parse "show message"', () => {
+      const node = learn.parse('show message', 'en');
+      expect(node.action).toBe('show');
+    });
+
+    it('should parse "hide menu"', () => {
+      const node = learn.parse('hide menu', 'en');
+      expect(node.action).toBe('hide');
+    });
+
+    it('should parse "get data"', () => {
+      const node = learn.parse('get data', 'en');
+      expect(node.action).toBe('get');
+    });
+
+    it('should parse "send event to target"', () => {
+      const node = learn.parse('send event to target', 'en');
+      expect(node.action).toBe('send');
+    });
+
+    it('should parse "increment counter"', () => {
+      const node = learn.parse('increment counter', 'en');
+      expect(node.action).toBe('increment');
+    });
+  });
+
+  describe('Explicit Syntax', () => {
+    it('should parse explicit syntax for add', () => {
+      const node = learn.parse('[add patient:.active destination:#button]', 'explicit');
+      expect(node.action).toBe('add');
+      expect(extractRoleValue(node, 'patient')).toBe('.active');
+      expect(extractRoleValue(node, 'destination')).toBe('#button');
+    });
+
+    it('should parse explicit syntax for ditransitive verbs', () => {
+      const ditransitive = [
+        { verb: 'add', roles: 'patient:.active destination:#btn' },
+        { verb: 'remove', roles: 'patient:.active source:#btn' },
+        { verb: 'toggle', roles: 'patient:.active destination:#btn' },
+        { verb: 'put', roles: 'patient:.item destination:#box' },
+        { verb: 'set', roles: 'destination:#prop patient:value' },
+        { verb: 'send', roles: 'patient:.event destination:#target' },
+        { verb: 'take', roles: 'patient:.item source:#shelf' },
+      ];
+      for (const { verb, roles } of ditransitive) {
+        const node = learn.parse(`[${verb} ${roles}]`, 'explicit');
+        expect(node.action).toBe(verb);
+      }
+    });
+
+    it('should parse explicit syntax for transitive verbs', () => {
+      const transitive = [
+        { verb: 'show', roles: 'patient:.msg' },
+        { verb: 'hide', roles: 'patient:.msg' },
+        { verb: 'get', roles: 'source:#data' },
+        { verb: 'wait', roles: 'patient:1000' },
+        { verb: 'fetch', roles: 'source:#api' },
+        { verb: 'go', roles: 'destination:#page' },
+        { verb: 'increment', roles: 'patient:.counter' },
+        { verb: 'decrement', roles: 'patient:.counter' },
+      ];
+      for (const { verb, roles } of transitive) {
+        const node = learn.parse(`[${verb} ${roles}]`, 'explicit');
+        expect(node.action).toBe(verb);
+      }
+    });
+  });
+
+  describe('Code Generation', () => {
+    it('should generate English commanding form', () => {
+      const result = learn.compile('[add patient:.active destination:#button]', 'explicit');
+      expect(result.ok).toBe(true);
+      expect(result.code).toContain('add');
+    });
+
+    it('should compile all verbs from explicit syntax', () => {
+      const testCases = [
+        '[add patient:.active destination:#button]',
+        '[remove patient:.active source:#button]',
+        '[show patient:.message]',
+        '[hide patient:.menu]',
+        '[get source:#data]',
+        '[go destination:#page]',
+        '[increment patient:.counter]',
+      ];
+      for (const input of testCases) {
+        const result = learn.compile(input, 'explicit');
+        expect(result.ok).toBe(true);
+      }
+    });
+  });
+});