@lokascript/framework 2.11.0 → 3.0.0

package/dist/prompts/prompt-generator.d.ts

@@ -22,7 +22,7 @@ import type { PromptGeneratorConfig, GeneratedPrompt } from './types';
  * @example
  * ```typescript
  * import { generatePrompt } from '@lokascript/framework';
- * import { allSchemas } from '@lokascript/domain-flow';
+ * import { allSchemas } from '@lokascript/domains/flow';
  *
  * const prompt = generatePrompt({
  *   domain: 'flow',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/framework",
-  "version": "2.11.0",
+  "version": "3.0.0",
   "description": "Generic framework for building multilingual DSLs with semantic parsing and grammar transformation",
   "type": "module",
   "main": "dist/index.cjs",
@@ -96,7 +96,7 @@
   "author": "LokaScript Contributors",
   "license": "MIT",
   "dependencies": {
-    "@lokascript/intent": "^2.11.0"
+    "@lokascript/intent": "^3.0.0"
   },
   "devDependencies": {
     "@lokascript/domains": "^2.11.1",

package/src/api/domain-registry.ts

@@ -18,8 +18,8 @@
  *   languages: ['en', 'es', 'ja', 'ar'],
  *   inputLabel: 'query',
  *   inputDescription: 'SQL query in natural language',
- *   getDSL: () => import('@lokascript/domain-sql').then(m => m.createSQLDSL()),
- *   getRenderer: () => import('@lokascript/domain-sql').then(m => m.renderSQL),
+ *   getDSL: () => import('@lokascript/domains/sql').then(m => m.createSQLDSL()),
+ *   getRenderer: () => import('@lokascript/domains/sql').then(m => m.renderSQL),
  * });
  *
  * // Auto-generate MCP tool definitions

package/src/core/tokenization/apostrophe-possessive.test.ts

@@ -0,0 +1,42 @@
+/**
+ * A word-glued apostrophe is the possessive marker, not a string opener.
+ *
+ * `(#price's value * #qty's value)` used to lex `'s value * #qty'` as ONE
+ * string literal — the first apostrophe opened a string that the second closed
+ * — which swallowed the operator and hid the property noun from translation in
+ * every language that renders the `'s` fallback (hi `#price's मान`, pl
+ * `#price's wartość`, …), so their English renders carried a non-ASCII
+ * identifier the canonical parser rejects ("Unknown token: ś"). A quote that
+ * opens a string always follows whitespace, punctuation, or the start of input.
+ */
+import { describe, it, expect } from 'vitest';
+import { StringLiteralExtractor } from '../../interfaces/value-extractor';
+
+const extractor = new StringLiteralExtractor();
+
+describe('StringLiteralExtractor: apostrophe after a word character', () => {
+  it.each([
+    ["#price's value", 6],
+    ["it's value", 2],
+    ["(#qty's value)", 5],
+    ["items[0]'s value", 8],
+  ])('does not open a string at the possessive in %s', (input, position) => {
+    expect(input[position]).toBe("'");
+    expect(extractor.canExtract(input, position)).toBe(false);
+  });
+
+  it.each([
+    ["put 'hello' into me", 4],
+    ["log 'a' + 'b'", 4],
+    ["log 'a' + 'b'", 10],
+    ["'leading'", 0],
+    ["items['a']", 6],
+    ["call f('x')", 7],
+  ])('still opens a string after whitespace/punctuation/start in %s', (input, position) => {
+    expect(extractor.canExtract(input, position)).toBe(true);
+  });
+
+  it('extracts the whole quoted string once opened', () => {
+    expect(extractor.extract("'hello' rest", 0)).toEqual({ value: "'hello'", length: 7 });
+  });
+});

package/src/core/tokenization/base-tokenizer.ts

@@ -88,6 +88,15 @@ const MARKER_CONCEPT_NORMALIZEDS: ReadonlySet<string> = new Set([
   'without',
 ]);
 
+/**
+ * A hyphen-JOINED keyword surface (`na-żywo`, `ao-vivo`): letters on both sides
+ * of every hyphen. A leading/trailing hyphen (qu's `-kama` / `-manta` suffix
+ * alternatives) or a bare `-` is not one — those stay with the word walk.
+ */
+function isHyphenatedWord(native: string): boolean {
+  return native.includes('-') && /^[\p{L}\p{N}_]+(-[\p{L}\p{N}_]+)+$/u.test(native);
+}
+
 // =============================================================================
 // Types
 // =============================================================================
@@ -561,8 +570,15 @@ export abstract class BaseTokenizer implements LanguageTokenizer {
       (a, b) => b.native.length - a.native.length
     );
 
-    // Multi-word (space-containing) keywords, for longest-phrase matching at a
-    // token boundary. Already longest-first (profileKeywords is sorted above).
+    // Multi-word keywords — space-containing (hi `मेल खाता`, vi `chuyển đổi`)
+    // or HYPHENATED (pl `na-żywo`, pt `ao-vivo`, fr `point-arrêt`) — for
+    // longest-phrase matching at a token boundary. Already longest-first
+    // (profileKeywords is sorted above). Hyphenated ones were left to the word
+    // walk, which stops at the `-` and hands the parts to whatever they happen
+    // to be: pl `na-żywo` (live) read as `na`(→destination) + `-` + `żywo`, so
+    // every pl `live … koniec` render parsed back as a handler with the `live`
+    // action gone; es `en-vivo` / pt `ao-vivo` survived only because their
+    // second half is a `live` alternative.
     // Marker/modifier concepts are EXCLUDED: those are matched positionally by
     // the pattern matcher (role markers), and greedily consuming a multi-word
     // marker phrase shadows the single-word marker patterns rely on — e.g. id
@@ -572,7 +588,9 @@ export abstract class BaseTokenizer implements LanguageTokenizer {
     // keydown, bn `তৈরি করুন`=make) are kept — the pattern matcher treats those
     // as keyword literals, so one-token matching is strictly better.
     this.multiWordKeywords = this.profileKeywords.filter(
-      k => k.native.includes(' ') && !MARKER_CONCEPT_NORMALIZEDS.has(k.normalized)
+      k =>
+        (k.native.includes(' ') || isHyphenatedWord(k.native)) &&
+        !MARKER_CONCEPT_NORMALIZEDS.has(k.normalized)
     );
 
     // Build Map for O(1) lookups (case-insensitive + diacritic-insensitive)

package/src/interfaces/value-extractor.ts

@@ -85,6 +85,16 @@ export class StringLiteralExtractor implements ValueExtractor {
 
   canExtract(input: string, position: number): boolean {
     const char = input[position];
+    // An ASCII apostrophe glued to the END of a word is the possessive marker
+    // (`#price's value`, `my's` never occurs but `it's`/`#qty's` do), not a
+    // string opener. Reading it as a quote paired it with the NEXT possessive:
+    // `(#price's value * #qty's value)` lexed `'s value * #qty'` as one string
+    // literal, which swallowed the operator and hid the property noun from
+    // translation in every language that renders `'s`. A quote that opens a
+    // string always follows whitespace, punctuation, or the start of input.
+    if (char === "'" && position > 0 && /[\p{L}\p{N}_)\]]/u.test(input[position - 1])) {
+      return false;
+    }
     return (
       char === '"' ||
       char === "'" ||

package/src/prompts/prompt-generator.ts

@@ -35,7 +35,7 @@ import type {
  * @example
  * ```typescript
  * import { generatePrompt } from '@lokascript/framework';
- * import { allSchemas } from '@lokascript/domain-flow';
+ * import { allSchemas } from '@lokascript/domains/flow';
  *
  * const prompt = generatePrompt({
  *   domain: 'flow',