@lokascript/language-server 2.5.1 → 2.7.0

package/dist/{dist-NRPF26M4.js → dist-MRVDB2YM.js}

@@ -3152,7 +3152,8 @@ function createTokenizerContext(tokenizer) {
     direction: tokenizer.direction,
     lookupKeyword: tokenizer.lookupKeyword.bind(tokenizer),
     isKeyword: tokenizer.isKeyword.bind(tokenizer),
-    isKeywordStart: tokenizer.isKeywordStart.bind(tokenizer)
+    isKeywordStart: tokenizer.isKeywordStart.bind(tokenizer),
+    ...tokenizer.isKeywordStartAtBoundary ? { isKeywordStartAtBoundary: tokenizer.isKeywordStartAtBoundary.bind(tokenizer) } : {}
   };
   if (tokenizer.normalizer) {
     return { ...ctx, normalizer: tokenizer.normalizer };
@@ -6053,27 +6054,74 @@ function withDefaultExtractors(tokenizer) {
   tokenizer.registerExtractors(getDefaultExtractors());
   return tokenizer;
 }
-function createUnicodeRangeClassifier(ranges) {
-  return (char) => {
-    const code = char.charCodeAt(0);
-    return ranges.some(([start, end]) => code >= start && code <= end);
-  };
-}
-function combineClassifiers(...classifiers) {
-  return (char) => classifiers.some((fn) => fn(char));
-}
-function createLatinCharClassifiers(letterPattern) {
-  const isLetter = (char) => letterPattern.test(char);
-  const isIdentifierChar = (char) => isLetter(char) || /[0-9_-]/.test(char);
-  return { isLetter, isIdentifierChar };
-}
 var SIMPLE_TOKENIZER_OPERATOR_SET = new Set(DEFAULT_OPERATORS);
+var MARKER_CONCEPT_NORMALIZEDS = /* @__PURE__ */ new Set([
+  // Role-marker role names (profile.roleMarkers normalizeds)
+  "patient",
+  "destination",
+  "source",
+  "style",
+  "event",
+  "eventMarker",
+  "agent",
+  "goal",
+  "manner",
+  // Prepositional / positional modifier concepts matched via the role mechanism
+  // (profile.keywords "Modifiers"). `before`/`after`/`until` are intentionally
+  // NOT here — they are pattern literals (see the note above).
+  "into",
+  "from",
+  "to",
+  "with",
+  "at",
+  "of",
+  "as",
+  "by",
+  "in",
+  "on",
+  "over",
+  "under",
+  "between",
+  "through",
+  "without"
+]);
+var ENGLISH_DOM_EVENT_NAMES = [
+  "click",
+  "dblclick",
+  "input",
+  "change",
+  "submit",
+  "keydown",
+  "keyup",
+  "keypress",
+  "mousedown",
+  "mouseup",
+  "mouseover",
+  "mouseout",
+  "mouseenter",
+  "mouseleave",
+  "mousemove",
+  "pointerdown",
+  "pointerup",
+  "pointermove",
+  "focus",
+  "blur",
+  "load",
+  "resize",
+  "scroll"
+];
 var _BaseTokenizer = class _BaseTokenizer2 {
   constructor() {
     this.profileKeywords = [];
+    this.multiWordKeywords = [];
     this.profileKeywordMap = /* @__PURE__ */ new Map();
+    this.rawExtraEntries = [];
     this.extractors = [];
   }
+  /** Raw extras as passed in, pre-dedup — for consistency tests. */
+  getExtraKeywordEntries() {
+    return this.rawExtraEntries;
+  }
   /**
    * Tokenize input string to token stream.
    * Delegates to extractor-based tokenization if extractors are registered,
@@ -6142,6 +6190,12 @@ var _BaseTokenizer = class _BaseTokenizer2 {
         pos++;
       }
       if (pos >= input.length) break;
+      const multiWord = this.tryMultiWordKeyword(input, pos);
+      if (multiWord) {
+        tokens.push(multiWord);
+        pos = multiWord.position.end;
+        continue;
+      }
       let extracted = false;
       for (const extractor of this.extractors) {
         if (extractor.canExtract(input, pos)) {
@@ -6241,6 +6295,7 @@ var _BaseTokenizer = class _BaseTokenizer2 {
    */
   initializeKeywordsFromProfile(profile, extras = []) {
     const keywordMap = /* @__PURE__ */ new Map();
+    this.rawExtraEntries = extras;
     if (profile.keywords) {
       for (const [normalized2, translation] of Object.entries(profile.keywords)) {
         keywordMap.set(translation.primary, {
@@ -6284,12 +6339,20 @@ var _BaseTokenizer = class _BaseTokenizer2 {
         keywordMap.set(native, { native, normalized: normalized2 });
       }
     }
+    for (const evt of ENGLISH_DOM_EVENT_NAMES) {
+      if (!keywordMap.has(evt)) {
+        keywordMap.set(evt, { native: evt, normalized: evt });
+      }
+    }
     for (const extra of extras) {
       keywordMap.set(extra.native, extra);
     }
     this.profileKeywords = Array.from(keywordMap.values()).sort(
       (a, b) => b.native.length - a.native.length
     );
+    this.multiWordKeywords = this.profileKeywords.filter(
+      (k) => k.native.includes(" ") && !MARKER_CONCEPT_NORMALIZEDS.has(k.normalized)
+    );
     this.profileKeywordMap = /* @__PURE__ */ new Map();
     for (const keyword of this.profileKeywords) {
       this.profileKeywordMap.set(keyword.native.toLowerCase(), keyword);
@@ -6331,6 +6394,35 @@ var _BaseTokenizer = class _BaseTokenizer2 {
     }
     return null;
   }
+  /**
+   * Match the longest multi-word (space-containing) profile keyword at `pos`,
+   * requiring the match to end at a word boundary. The profile-driven
+   * counterpart of the per-language hardcoded compound lists (the hindi and
+   * vietnamese keyword extractors). Returns a keyword token (with the normalized
+   * form) or null. Case-sensitive against the stored native form, mirroring
+   * `tryProfileKeyword`/`isKeywordStart` (the i18n dicts emit a fixed surface
+   * case). No-op when `multiWordKeywords` is empty (no-space/CJK languages).
+   *
+   * @param input - Input string
+   * @param pos - Current position (must be a token-start boundary)
+   * @param isWordChar - End-boundary predicate (defaults to Unicode letter/digit/_)
+   */
+  tryMultiWordKeyword(input, pos, isWordChar = (ch) => /[\p{L}\p{N}_]/u.test(ch)) {
+    if (this.multiWordKeywords.length === 0) return null;
+    const rest = input.slice(pos);
+    for (const entry of this.multiWordKeywords) {
+      if (!rest.startsWith(entry.native)) continue;
+      const after = input[pos + entry.native.length];
+      if (after !== void 0 && isWordChar(after)) continue;
+      return createToken(
+        entry.native,
+        "keyword",
+        createPosition(pos, pos + entry.native.length),
+        entry.normalized
+      );
+    }
+    return null;
+  }
   /**
    * Check if the remaining input starts with any known keyword.
    * Useful for non-space languages to detect word boundaries.
@@ -6343,6 +6435,32 @@ var _BaseTokenizer = class _BaseTokenizer2 {
     const remaining = input.slice(pos);
     return this.profileKeywords.some((entry) => remaining.startsWith(entry.native));
   }
+  /**
+   * Check if a known keyword starts at the given position AND ends at a word
+   * boundary (end of input or a non-word character).
+   *
+   * Space-delimited languages must use this (not `isKeywordStart`) for
+   * word-walk break checks: the keyword table includes English canonical
+   * fallbacks (me, it, you, …), so a raw `startsWith` check splits any native
+   * word with an embedded fallback mid-word (e.g. Quechua ñit'iy contains
+   * "it"). CJK/no-space tokenizers rely on mid-text keyword starts and must
+   * keep using `isKeywordStart`.
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @param isWordChar - Language-specific word-character predicate; pass the
+   *   tokenizer's letter classifier so e.g. the Quechua glottal apostrophe
+   *   counts as part of a word. Defaults to Unicode letters/digits/underscore.
+   * @returns true if a keyword starts here and is not followed by a word char
+   */
+  isKeywordStartAtBoundary(input, pos, isWordChar = (ch) => /[\p{L}\p{N}_]/u.test(ch)) {
+    const remaining = input.slice(pos);
+    return this.profileKeywords.some((entry) => {
+      if (!remaining.startsWith(entry.native)) return false;
+      const after = input[pos + entry.native.length];
+      return after === void 0 || !isWordChar(after);
+    });
+  }
   /**
    * Look up a keyword by native word (case-insensitive).
    * O(1) lookup using the keyword map.
@@ -6670,6 +6788,115 @@ function createSimpleTokenizer(config) {
   }
   return new SimpleTokenizer();
 }
+function mergeRoleMarkers(slice, vocab) {
+  const merged = {};
+  const add = (role, marker) => {
+    if (!marker?.primary) {
+      delete merged[role];
+      return;
+    }
+    merged[role] = {
+      primary: marker.primary,
+      ...marker.alternatives?.length && { alternatives: [...marker.alternatives] },
+      ...marker.position && { position: marker.position }
+    };
+  };
+  for (const [role, marker] of Object.entries(slice.roleMarkers ?? {})) add(role, marker);
+  for (const [role, marker] of Object.entries(vocab.roleMarkerOverrides ?? {})) add(role, marker);
+  return merged;
+}
+function buildPatternProfile(slice, vocab) {
+  const keywords = {};
+  for (const [action, translation] of Object.entries(vocab.keywords)) {
+    keywords[action] = {
+      primary: translation.primary,
+      ...translation.alternatives?.length && { alternatives: [...translation.alternatives] }
+    };
+  }
+  const roleMarkers = mergeRoleMarkers(slice, vocab);
+  return {
+    code: slice.code,
+    wordOrder: slice.wordOrder,
+    keywords,
+    ...Object.keys(roleMarkers).length > 0 && { roleMarkers }
+  };
+}
+function defaultCaseInsensitive(script) {
+  return script === void 0 || script === "latin" || script === "cyrillic";
+}
+function buildDomainTokenizer(slice, vocab, options = {}) {
+  const roleMarkers = mergeRoleMarkers(slice, vocab);
+  const keywords = /* @__PURE__ */ new Set();
+  for (const translation of Object.values(vocab.keywords)) {
+    keywords.add(translation.primary);
+    for (const alt of translation.alternatives ?? []) keywords.add(alt);
+  }
+  for (const marker of Object.values(roleMarkers)) {
+    keywords.add(marker.primary);
+    for (const alt of marker.alternatives ?? []) keywords.add(alt);
+  }
+  for (const particle of slice.tokenization?.particles ?? []) keywords.add(particle);
+  for (const extra of vocab.tokenizerKeywords ?? []) keywords.add(extra);
+  const profileKeywords = {};
+  for (const [action, translation] of Object.entries(vocab.keywords)) {
+    profileKeywords[action] = {
+      primary: translation.primary,
+      ...translation.alternatives?.length && { alternatives: [...translation.alternatives] },
+      normalized: translation.normalized ?? action
+    };
+  }
+  const keywordProfile = {
+    keywords: profileKeywords,
+    ...Object.keys(roleMarkers).length > 0 && { roleMarkers }
+  };
+  const customExtractors = [
+    ...options.customExtractors ?? [],
+    ...slice.script === "latin" ? [new LatinExtendedIdentifierExtractor()] : []
+  ];
+  return createSimpleTokenizer({
+    language: slice.code,
+    direction: slice.direction ?? "ltr",
+    keywords: [...keywords],
+    ...vocab.keywordExtras?.length && { keywordExtras: vocab.keywordExtras.map((e) => ({ ...e })) },
+    keywordProfile,
+    includeOperators: options.includeOperators ?? false,
+    caseInsensitive: options.caseInsensitive ?? defaultCaseInsensitive(slice.script),
+    ...customExtractors.length > 0 && { customExtractors }
+  });
+}
+function buildLanguageConfig(slice, vocab, meta = {}) {
+  const name = meta.name ?? slice.name ?? slice.code;
+  return {
+    code: slice.code,
+    name,
+    nativeName: meta.nativeName ?? slice.nativeName ?? name,
+    tokenizer: meta.tokenizer ?? buildDomainTokenizer(slice, vocab, meta.tokenizerOptions),
+    patternProfile: buildPatternProfile(slice, vocab),
+    ...meta.grammarProfile && { grammarProfile: meta.grammarProfile }
+  };
+}
+function deriveRoleMarkers(slice, roleMapping) {
+  const derived = {};
+  for (const [domainRole, semanticRole] of Object.entries(roleMapping)) {
+    const marker = slice.roleMarkers?.[semanticRole];
+    if (marker?.primary) derived[domainRole] = marker.primary;
+  }
+  return derived;
+}
+function createUnicodeRangeClassifier(ranges) {
+  return (char) => {
+    const code = char.charCodeAt(0);
+    return ranges.some(([start, end]) => code >= start && code <= end);
+  };
+}
+function combineClassifiers(...classifiers) {
+  return (char) => classifiers.some((fn) => fn(char));
+}
+function createLatinCharClassifiers(letterPattern) {
+  const isLetter = (char) => letterPattern.test(char);
+  const isIdentifierChar = (char) => isLetter(char) || /[0-9_-]/.test(char);
+  return { isLetter, isIdentifierChar };
+}
 function noChange(word) {
   return { stem: word, confidence: 1 };
 }
@@ -7224,7 +7451,10 @@ export {
   WhitespaceExtractor,
   accumulateBlocks,
   buildDisambiguation,
+  buildDomainTokenizer,
   buildFeedback,
+  buildLanguageConfig,
+  buildPatternProfile,
   buildPhrase,
   buildTablesFromProfiles,
   combineClassifiers,
@@ -7255,6 +7485,7 @@ export {
   createUnicodeRangeClassifier,
   defineCommand,
   defineRole,
+  deriveRoleMarkers,
   detectWordOrders,
   extractCssSelector,
   extractNumber,

package/dist/server.js

@@ -140,9 +140,6 @@ function detectLokascriptFeatures(code) {
   }
   return detected;
 }
-function getCommandsForMode(mode) {
-  return mode === "hyperscript" ? HYPERSCRIPT_COMMANDS : ALL_COMMANDS;
-}
 
 // src/extraction.ts
 function isHtmlDocument(uri, content) {
@@ -1137,7 +1134,7 @@ try {
 }
 var frameworkIR = null;
 try {
-  const fw = await import("./dist-NRPF26M4.js");
+  const fw = await import("./dist-MRVDB2YM.js");
   frameworkIR = { fromInterchangeNode: fw.fromInterchangeNode, renderExplicit: fw.renderExplicit };
   console.error(
     "[lokascript-ls] @lokascript/framework loaded \u2014 LSE bracket notation in hover enabled"
@@ -1441,7 +1438,7 @@ function getSemanticAnalyzer() {
   return cachedAnalyzer;
 }
 var globalSettings = envDefaultMode ? { ...defaultSettings, mode: envDefaultMode } : defaultSettings;
-connection.onInitialize((params) => {
+connection.onInitialize((_params) => {
   resolvedMode = resolveMode(globalSettings);
   const brand = getBranding(resolvedMode);
   connection.console.log(`${brand} Language Server initializing (mode: ${resolvedMode})...`);
@@ -1813,15 +1810,12 @@ function getContextualCompletions(context, language) {
     }
     return eng;
   };
-  const commandMode = isHyperscriptCompatMode(resolvedMode) ? "hyperscript" : "lokascript";
-  const availableCommands = getCommandsForMode(commandMode);
-  const isCommandAvailable = (cmd) => availableCommands.includes(cmd);
   const getDetail = (command, fallback) => {
     const desc = getCommandDescription(command, effectiveLanguage);
     return desc?.detail ?? fallback;
   };
   switch (context) {
-    case "event":
+    case "event": {
       const eventNames = lspMetadata?.EVENT_NAMES ?? FALLBACK_EVENT_NAMES;
       for (const eventName of eventNames) {
         completions.push({
@@ -1831,6 +1825,7 @@ function getContextualCompletions(context, language) {
         });
       }
       break;
+    }
     case "command":
       completions.push(
         {
@@ -2174,7 +2169,7 @@ ${doc.example}
 var translationCache = null;
 function buildTranslationCache() {
   const cache2 = /* @__PURE__ */ new Map();
-  if (!semanticPackage) return cache2;
+  if (!semanticPackage?.getKeywordTranslations) return cache2;
   const langMap = {
     es: "Spanish",
     ja: "Japanese",
@@ -2208,19 +2203,15 @@ function buildTranslationCache() {
     "result"
   ];
   for (const canonicalKey of canonicalKeywords) {
+    const byLang = semanticPackage.getKeywordTranslations(
+      canonicalKey,
+      Object.keys(langMap)
+    );
     const translations = [];
     for (const [lang, langName] of Object.entries(langMap)) {
-      try {
-        const profile = semanticPackage.tryGetProfile(lang);
-        const kw = profile?.keywords?.[canonicalKey];
-        if (kw) {
-          const trans = kw;
-          if (trans.primary && trans.primary !== canonicalKey) {
-            translations.push(`${langName}: \`${trans.primary}\``);
-          }
-        }
-      } catch (e) {
-        connection.console.log(`[lokascript-ls] Translation cache: profile '${lang}' not found`);
+      const primary = byLang[lang]?.primary;
+      if (primary && primary !== canonicalKey) {
+        translations.push(`${langName}: \`${primary}\``);
       }
     }
     if (translations.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/language-server",
-  "version": "2.5.1",
+  "version": "2.7.0",
   "description": "Language Server Protocol implementation for LokaScript/hyperscript with 21 language support",
   "type": "module",
   "main": "dist/server.js",
@@ -13,7 +13,7 @@
     "dev": "tsx src/server.ts --stdio",
     "test": "vitest",
     "typecheck": "tsc --noEmit",
-    "test:check": "vitest run --reporter=dot 2>&1 | tail -5"
+    "test:check": "VITEST_QUIET=1 bash ../../scripts/vitest-run.sh --reporter=dot"
   },
   "keywords": [
     "lsp",
@@ -31,8 +31,8 @@
     "vscode-languageserver-textdocument": "^1.0.11"
   },
   "peerDependencies": {
-    "@hyperfixi/core": "^2.5.1",
-    "@lokascript/semantic": "^2.5.1"
+    "@hyperfixi/core": "^2.7.0",
+    "@lokascript/semantic": "^2.7.0"
   },
   "peerDependenciesMeta": {
     "@lokascript/semantic": {
@@ -43,8 +43,8 @@
     }
   },
   "devDependencies": {
-    "@hyperfixi/core": "^2.5.1",
-    "@lokascript/semantic": "^2.5.1",
+    "@hyperfixi/core": "^2.7.0",
+    "@lokascript/semantic": "^2.7.0",
     "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "^4.0.0",
     "tsup": "^8.0.0",