@lokascript/language-server 2.8.0 → 2.9.0

package/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+All notable changes to `@lokascript/language-server` will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-02-05
+
+### Added
+
+- **Go to Definition**: Jump to behavior and function definitions with Ctrl+Click or F12
+- **Find References**: Find all usages of a symbol with Shift+F12
+- **Document Formatting**: Format hyperscript code with consistent indentation
+- **Single-quote support**: HTML attributes with `_='...'` now work correctly
+- **CRLF support**: Windows line endings are handled correctly in position mapping
+- **Error logging**: All catch blocks now log errors for easier debugging
+
+### Improved
+
+- HTML extraction now supports both double and single quoted attributes
+- Position mapping correctly handles all line ending types (LF, CRLF, CR)
+- Better error messages in diagnostics
+- Comprehensive test coverage (138 tests)
+
+### Fixed
+
+- Position mapping for multiline hyperscript attributes
+- Cursor position calculation with different line endings
+
+## [0.1.0] - Initial Release
+
+### Added
+
+- **Diagnostics**: Real-time error detection and warnings
+- **Completions**: Context-aware keyword and selector suggestions
+- **Hover**: Documentation on hover for commands and keywords
+- **Document Symbols**: Outline view showing event handlers, behaviors, and functions
+- **Code Actions**: Quick fixes for common issues
+- **Multilingual support**: Works with 21 human languages via `@lokascript/semantic`
+- **HTML support**: Extracts hyperscript from `_="..."` attributes and `<script type="text/hyperscript">` tags

package/dist/{dist-6KATWM5A.js → dist-LIFKYPGW.js}

@@ -184,6 +184,26 @@ function filterBySeverity(diagnostics, severity) {
   return diagnostics.filter((d) => d.severity === severity);
 }
 function defineCommand(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    throw new TypeError(`defineCommand: expected a schema object, got ${describeValue(schema)}.`);
+  }
+  if (typeof schema.action !== "string" || schema.action.length === 0) {
+    throw new TypeError(
+      `defineCommand: 'action' must be a non-empty string (got ${describeValue(schema.action)}).`
+    );
+  }
+  if (!Array.isArray(schema.roles)) {
+    throw new TypeError(
+      `defineCommand("${schema.action}"): 'roles' must be an array of RoleSpec (got ${describeValue(schema.roles)}). Build entries with defineRole().`
+    );
+  }
+  for (const [index, role] of schema.roles.entries()) {
+    if (typeof role !== "object" || role === null || typeof role.role !== "string") {
+      throw new TypeError(
+        `defineCommand("${schema.action}"): roles[${index}] must be a RoleSpec with a string 'role' field (got ${describeValue(role)}). Build it with defineRole().`
+      );
+    }
+  }
   return {
     description: schema.description || `${schema.action} command`,
     category: schema.category || "general",
@@ -203,8 +223,16 @@ function defineRole(role) {
   };
 }
 function getRoleSpec(schema, role) {
+  if (!schema || !Array.isArray(schema.roles)) return void 0;
   return schema.roles.find((r) => r.role === role);
 }
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `an array of length ${value.length}`;
+  if (typeof value === "string") return `the string ${JSON.stringify(value)}`;
+  if (typeof value === "object") return "an object";
+  return typeof value === "undefined" ? "undefined" : String(value);
+}
 var DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
   "me",
   "you",
@@ -2645,10 +2673,12 @@ function buildTokens(schema, profile, keyword, alternatives) {
       addRoleWithMarker(tokens, role, profile);
     }
   } else if (profile.wordOrder === "SOV") {
+    const preVerb = [];
+    const postVerb = [];
     for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
+      addRoleWithMarker(role.sovSlot === "postVerb" ? postVerb : preVerb, role, profile);
     }
-    tokens.push(keywordToken);
+    tokens.push(...preVerb, keywordToken, ...postVerb);
   } else if (profile.wordOrder === "VSO") {
     tokens.push(keywordToken);
     for (const role of sortedRoles) {
@@ -2731,35 +2761,145 @@ function buildExtractionRules(schema, profile) {
   return rules;
 }
 function buildFormatString(schema, profile, keyword) {
-  const parts = [];
-  if (profile.wordOrder === "SVO" || profile.wordOrder === "VSO") {
-    parts.push(keyword);
-  }
+  const isSOV = profile.wordOrder === "SOV";
+  const preVerb = [];
+  const postVerb = [];
   const sortedRoles = sortRolesByWordOrder(schema.roles, profile.wordOrder);
   for (const role of sortedRoles) {
     const marker = getMarkerForRole(role, profile);
     const roleName = `{${role.role}}`;
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
     if (marker) {
       const markerInfo = profile.roleMarkers?.[role.role];
       if (markerInfo?.position === "after") {
-        parts.push(`${roleName} ${marker}`);
+        bucket.push(`${roleName} ${marker}`);
       } else {
-        parts.push(`${marker} ${roleName}`);
+        bucket.push(`${marker} ${roleName}`);
       }
     } else {
-      parts.push(roleName);
+      bucket.push(roleName);
     }
   }
-  if (profile.wordOrder === "SOV") {
-    parts.push(keyword);
-  }
-  return parts.join(" ");
+  return (isSOV ? [...preVerb, keyword, ...postVerb] : [keyword, ...preVerb, ...postVerb]).join(
+    " "
+  );
 }
 function generatePatternVariants(schema, profile, config = defaultConfig) {
   const patterns = [];
   patterns.push(generatePattern(schema, profile, config));
   return patterns;
 }
+function lookupKeyword(keywords, action, language) {
+  return keywords[action]?.[language] ?? action;
+}
+function lookupMarker(markers, marker, language) {
+  return markers[marker]?.[language] ?? marker;
+}
+function buildPhrase(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function buildTablesFromProfiles(schemas, profiles) {
+  const keywords = {};
+  const markers = {};
+  for (const profile of profiles) {
+    for (const [action, kw] of Object.entries(profile.keywords)) {
+      if (!keywords[action]) keywords[action] = {};
+      keywords[action][profile.code] = kw.primary;
+    }
+  }
+  for (const schema of schemas) {
+    for (const role of schema.roles) {
+      if (role.markerOverride) {
+        const markerKey = role.role;
+        if (!markers[markerKey]) markers[markerKey] = {};
+        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
+          markers[markerKey][lang] = markerText;
+        }
+      }
+    }
+  }
+  for (const profile of profiles) {
+    if (profile.roleMarkers) {
+      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
+        if (!markers[markerKey]) markers[markerKey] = {};
+        markers[markerKey][profile.code] = markerDef.primary;
+      }
+    }
+  }
+  return { keywords, markers };
+}
+function detectWordOrders(profiles) {
+  const sovLanguages = /* @__PURE__ */ new Set();
+  const vsoLanguages = /* @__PURE__ */ new Set();
+  for (const profile of profiles) {
+    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
+    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
+  }
+  return { sovLanguages, vsoLanguages };
+}
+function createSchemaRenderer(schemas, profiles) {
+  const tables = buildRenderTables(schemas, profiles);
+  return {
+    render(node, language) {
+      return renderFromSchema(node, language, tables) ?? node.action;
+    }
+  };
+}
+function createDomainRenderer(config) {
+  const { schemas, profiles, overrides } = config;
+  let tables;
+  return (node, language) => {
+    const override = overrides?.[node.action];
+    if (override) return override(node, language);
+    tables ?? (tables = buildRenderTables(schemas, profiles));
+    return renderFromSchema(node, language, tables);
+  };
+}
+function buildRenderTables(schemas, profiles) {
+  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles);
+  const { sovLanguages } = detectWordOrders(profiles);
+  const markerPositions = {};
+  for (const profile of profiles) {
+    for (const [role, markerDef] of Object.entries(profile.roleMarkers ?? {})) {
+      if (!markerDef.position) continue;
+      markerPositions[role] ?? (markerPositions[role] = {});
+      markerPositions[role][profile.code] = markerDef.position;
+    }
+  }
+  const schemaMap = /* @__PURE__ */ new Map();
+  for (const s of schemas) schemaMap.set(s.action, s);
+  return { keywords, markers, markerPositions, sovLanguages, schemaMap };
+}
+function renderFromSchema(node, language, tables) {
+  const schema = tables.schemaMap.get(node.action);
+  if (!schema) return null;
+  const keyword = lookupKeyword(tables.keywords, node.action, language);
+  const isSOV = tables.sovLanguages.has(language);
+  const ordered = sortRolesByWordOrder([...schema.roles], isSOV ? "SOV" : "SVO");
+  const preVerb = [];
+  const postVerb = [];
+  for (const role of ordered) {
+    let value = extractRoleValue(node, role.role);
+    if (!value && role.default !== void 0) {
+      value = String(extractValue(role.default));
+    }
+    if (!value) continue;
+    if (role.quoteMultiword && /\s/.test(value) && !/^(["']).*\1$/.test(value)) {
+      value = `"${value}"`;
+    }
+    const markerText = role.renderOverride?.[language] ?? role.markerOverride?.[language] ?? role.renderOverride?.["*"] ?? tables.markers[role.role]?.[language];
+    const markerPosition = role.markerPositionOverride?.[language] ?? role.markerPosition ?? tables.markerPositions[role.role]?.[language] ?? (isSOV ? "after" : "before");
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
+    if (markerText && markerPosition === "before") {
+      bucket.push(markerText, value);
+    } else if (markerText) {
+      bucket.push(value, markerText);
+    } else {
+      bucket.push(value);
+    }
+  }
+  return isSOV ? buildPhrase(...preVerb, keyword, ...postVerb) : buildPhrase(keyword, ...preVerb, ...postVerb);
+}
 function reorderRoles(roles, targetOrder) {
   const result = [];
   const usedRoles = /* @__PURE__ */ new Set();
@@ -3187,6 +3327,31 @@ var LatinExtendedIdentifierExtractor = class {
     return { value: input.slice(position, end), length: end - position };
   }
 };
+var SELECTOR_BODY_CHAR = /[\p{L}\p{N}_-]/u;
+var PARTICLE_SCRIPT_CHAR = /[\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}\p{sc=Hangul}]/u;
+function isSelectorBodyChar(char) {
+  return SELECTOR_BODY_CHAR.test(char) && !PARTICLE_SCRIPT_CHAR.test(char);
+}
+var CssSelectorExtractor = class {
+  constructor() {
+    this.name = "css-selector";
+  }
+  canExtract(input, position) {
+    const char = input[position];
+    if (char !== "#" && char !== ".") return false;
+    const next = input[position + 1];
+    if (next === void 0) return false;
+    return next === "_" || next === "-" || /\p{L}/u.test(next) && !PARTICLE_SCRIPT_CHAR.test(next);
+  }
+  extract(input, position) {
+    let end = position + 1;
+    while (end < input.length && isSelectorBodyChar(input[end])) {
+      end++;
+    }
+    if (end === position + 1) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
 var WhitespaceExtractor = class {
   constructor() {
     this.name = "whitespace";
@@ -3906,10 +4071,17 @@ function semanticValueToAST(value) {
   }
 }
 var DSLRegistry = class {
-  constructor(config) {
+  /**
+   * @param partiallyTranslatedActions Actions permitted to lack a keyword in
+   *   some configured languages — extension commands, which may be added for a
+   *   subset of the DSL's languages. A built-in command missing a keyword stays
+   *   an error, since that is a domain-authoring mistake.
+   */
+  constructor(config, partiallyTranslatedActions = /* @__PURE__ */ new Set()) {
     this.patterns = /* @__PURE__ */ new Map();
     this.tokenizers = /* @__PURE__ */ new Map();
     this.schemas = config.schemas;
+    this.partiallyTranslatedActions = partiallyTranslatedActions;
     for (const lang of config.languages) {
       this.registerLanguage(lang);
     }
@@ -3918,6 +4090,9 @@ var DSLRegistry = class {
     this.tokenizers.set(lang.code, lang.tokenizer);
     const patterns = [];
     for (const schema of this.schemas) {
+      if (this.partiallyTranslatedActions.has(schema.action) && !lang.patternProfile.keywords[schema.action]) {
+        continue;
+      }
       const pattern = generatePattern(schema, lang.patternProfile);
       patterns.push(pattern);
     }
@@ -3934,13 +4109,25 @@ var DSLRegistry = class {
   }
 };
 var MultilingualDSLImpl = class {
-  constructor(config, registry, transformer) {
+  constructor(config, registry, transformer, profileProvider) {
     this.registry = registry;
     this.matcher = new PatternMatcher();
     this.transformer = transformer;
+    this.profileProvider = profileProvider;
     if (config.codeGenerator) {
       this.codeGenerator = config.codeGenerator;
     }
+    if (config.renderer) {
+      this.domainRenderer = config.renderer;
+    }
+    this.extensionRenderers = /* @__PURE__ */ new Map();
+    for (const extension of config.extensions ?? []) {
+      if (extension.render) this.extensionRenderers.set(extension.schema.action, extension.render);
+    }
+    this.schemaFallbackRenderer = createDomainRenderer({
+      schemas: config.schemas,
+      profiles: config.languages.map((l) => l.patternProfile)
+    });
     const schemaMap = new Map(config.schemas.map((s) => [s.action, s]));
     this.schemaLookup = {
       getSchema: (action) => schemaMap.get(action)
@@ -4002,6 +4189,13 @@ var MultilingualDSLImpl = class {
   }
   translate(input, fromLanguage, toLanguage) {
     if (isExplicitSyntax(input)) return input;
+    for (const language of [fromLanguage, toLanguage]) {
+      if (!this.profileProvider.getProfile(language)) {
+        throw new Error(
+          `translate() requires a grammar profile for language "${language}", but none is configured. Set 'grammarProfile' on the LanguageConfig for "${language}" in createMultilingualDSL() (parse/validate/compile do not need it), or inject a custom 'profileProvider'.`
+        );
+      }
+    }
     return this.transformer.transform(input, fromLanguage, toLanguage);
   }
   compile(input, language) {
@@ -4030,6 +4224,18 @@ var MultilingualDSLImpl = class {
       };
     }
   }
+  render(node, language) {
+    const extensionRenderer = this.extensionRenderers.get(node.action);
+    if (extensionRenderer) {
+      const rendered = extensionRenderer(node, language);
+      if (rendered != null) return rendered;
+    }
+    if (this.domainRenderer) {
+      const rendered = this.domainRenderer(node, language);
+      if (rendered != null) return rendered;
+    }
+    return this.schemaFallbackRenderer(node, language);
+  }
   getSupportedLanguages() {
     return this.registry.getSupportedLanguages();
   }
@@ -4054,15 +4260,80 @@ function createDefaultProfileProvider(config) {
   }
   return new InMemoryProfileProvider(profiles);
 }
+function applyExtensions(config) {
+  const extensions = config.extensions;
+  if (!extensions || extensions.length === 0) return config;
+  const configuredLanguages = new Set(config.languages.map((l) => l.code));
+  const actions = new Set(config.schemas.map((s) => s.action));
+  for (const extension of extensions) {
+    const { action } = extension.schema;
+    if (actions.has(action)) {
+      throw new Error(
+        `Extension command "${action}" collides with a command this DSL already defines. Pick a different action name.`
+      );
+    }
+    actions.add(action);
+    for (const code of Object.keys(extension.vocabulary)) {
+      if (!configuredLanguages.has(code)) {
+        throw new Error(
+          `Extension command "${action}" supplies vocabulary for language "${code}", which is not configured on this DSL. Configured languages: ${[...configuredLanguages].join(", ")}.`
+        );
+      }
+    }
+  }
+  const schemas = [...config.schemas, ...extensions.map((e) => e.schema)];
+  const languages = config.languages.map((lang) => {
+    const keywords = { ...lang.patternProfile.keywords };
+    let roleMarkers = lang.patternProfile.roleMarkers;
+    for (const extension of extensions) {
+      const vocabulary = extension.vocabulary[lang.code];
+      if (!vocabulary) continue;
+      keywords[extension.schema.action] = { ...vocabulary.keyword };
+      if (vocabulary.roleMarkers) {
+        roleMarkers = { ...roleMarkers, ...vocabulary.roleMarkers };
+      }
+    }
+    return {
+      ...lang,
+      patternProfile: {
+        ...lang.patternProfile,
+        keywords,
+        ...roleMarkers !== void 0 && { roleMarkers }
+      }
+    };
+  });
+  const extensionGenerators = new Map(
+    extensions.filter((e) => e.generate).map((e) => [e.schema.action, e.generate])
+  );
+  const baseGenerator = config.codeGenerator;
+  const codeGenerator = extensionGenerators.size > 0 ? {
+    generate(node) {
+      const generate = extensionGenerators.get(node.action);
+      if (generate) return generate(node);
+      if (!baseGenerator) {
+        throw new Error(`No code generator for action "${node.action}"`);
+      }
+      return baseGenerator.generate(node);
+    }
+  } : baseGenerator;
+  return {
+    ...config,
+    schemas,
+    languages,
+    ...codeGenerator !== void 0 && { codeGenerator }
+  };
+}
 function createMultilingualDSL(config) {
-  const dictionary = config.dictionary ?? createDefaultDictionary(config);
-  const profileProvider = config.profileProvider ?? createDefaultProfileProvider(config);
+  const effectiveConfig = applyExtensions(config);
+  const extensionActions = new Set((config.extensions ?? []).map((e) => e.schema.action));
+  const dictionary = effectiveConfig.dictionary ?? createDefaultDictionary(effectiveConfig);
+  const profileProvider = effectiveConfig.profileProvider ?? createDefaultProfileProvider(effectiveConfig);
   const transformer = new GrammarTransformer({
     dictionary,
     profileProvider
   });
-  const registry = new DSLRegistry(config);
-  return new MultilingualDSLImpl(config, registry, transformer);
+  const registry = new DSLRegistry(effectiveConfig, extensionActions);
+  return new MultilingualDSLImpl(effectiveConfig, registry, transformer, profileProvider);
 }
 function generatePrompt(config) {
   const outputFormat = config.outputFormat ?? "both";
@@ -5025,6 +5296,11 @@ var DomainRegistry = class {
         rendered = typeof renderer === "function" ? renderer(node, to) : renderer.render(node, to);
       } catch {
       }
+    } else if (dsl.render) {
+      try {
+        rendered = dsl.render(node, to);
+      } catch {
+      }
     }
     const roles = {};
     for (const [key, value] of node.roles) {
@@ -5570,94 +5846,6 @@ async function registryToAOTBackends(registry) {
   }
   return backends;
 }
-function lookupKeyword(keywords, action, language) {
-  return keywords[action]?.[language] ?? action;
-}
-function lookupMarker(markers, marker, language) {
-  return markers[marker]?.[language] ?? marker;
-}
-function buildPhrase(...parts) {
-  return parts.filter(Boolean).join(" ");
-}
-function buildTablesFromProfiles(schemas, profiles) {
-  const keywords = {};
-  const markers = {};
-  for (const profile of profiles) {
-    for (const [action, kw] of Object.entries(profile.keywords)) {
-      if (!keywords[action]) keywords[action] = {};
-      keywords[action][profile.code] = kw.primary;
-    }
-  }
-  for (const schema of schemas) {
-    for (const role of schema.roles) {
-      if (role.markerOverride) {
-        const markerKey = role.role;
-        if (!markers[markerKey]) markers[markerKey] = {};
-        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
-          markers[markerKey][lang] = markerText;
-        }
-      }
-    }
-  }
-  for (const profile of profiles) {
-    if (profile.roleMarkers) {
-      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
-        if (!markers[markerKey]) markers[markerKey] = {};
-        markers[markerKey][profile.code] = markerDef.primary;
-      }
-    }
-  }
-  return { keywords, markers };
-}
-function detectWordOrders(profiles) {
-  const sovLanguages = /* @__PURE__ */ new Set();
-  const vsoLanguages = /* @__PURE__ */ new Set();
-  for (const profile of profiles) {
-    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
-    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
-  }
-  return { sovLanguages, vsoLanguages };
-}
-function createSchemaRenderer(schemas, profiles) {
-  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles);
-  const { sovLanguages } = detectWordOrders(profiles);
-  const schemaMap = /* @__PURE__ */ new Map();
-  for (const s of schemas) schemaMap.set(s.action, s);
-  return {
-    render(node, language) {
-      const schema = schemaMap.get(node.action);
-      if (!schema) return node.action;
-      const keyword = lookupKeyword(keywords, node.action, language);
-      const isSOV = sovLanguages.has(language);
-      const roleParts = [];
-      for (const role of schema.roles) {
-        const value = extractRoleValue(node, role.role);
-        if (!value && !role.required) continue;
-        const markerText = role.markerOverride?.[language] ?? markers[role.role]?.[language] ?? void 0;
-        roleParts.push({
-          ...markerText != null && { marker: markerText },
-          value: value || "",
-          role
-        });
-      }
-      const parts = [];
-      if (isSOV) {
-        for (const rp of roleParts) {
-          if (rp.value) parts.push(rp.value);
-          if (rp.marker) parts.push(rp.marker);
-        }
-        parts.push(keyword);
-      } else {
-        parts.push(keyword);
-        for (const rp of roleParts) {
-          if (rp.marker) parts.push(rp.marker);
-          if (rp.value) parts.push(rp.value);
-        }
-      }
-      return buildPhrase(...parts);
-    }
-  };
-}
 var TokenStreamImpl = class {
   constructor(tokens, language) {
     this.pos = 0;
@@ -5763,6 +5951,9 @@ function isQuote(char) {
 function isDigit(char) {
   return /\d/.test(char);
 }
+function stripOptionalDiacritics(word) {
+  return word.replace(/[ً-ْٰ]/g, "");
+}
 function isAsciiLetter(char) {
   return /[a-zA-Z]/.test(char);
 }
@@ -6468,7 +6659,7 @@ var _BaseTokenizer = class _BaseTokenizer2 {
    * @returns Word without diacritics
    */
   removeDiacritics(word) {
-    return word.replace(/[\u064B-\u0652\u0670]/g, "");
+    return stripOptionalDiacritics(word);
   }
   /**
    * Try to match a keyword from profile at the current position.
@@ -6559,24 +6750,40 @@ var _BaseTokenizer = class _BaseTokenizer2 {
     });
   }
   /**
-   * Look up a keyword by native word (case-insensitive).
+   * Look up a keyword by native word (case-insensitive, diacritic-insensitive).
    * O(1) lookup using the keyword map.
    *
+   * The map is INDEXED both with and without diacritics (see
+   * `initializeKeywordsFromProfile`), so a stripped QUERY is the other half of
+   * that: it lets a surface form carrying harakat the profile does not happen to
+   * spell still find its entry. Only consulted after the exact lookup misses, so
+   * every previously-matching word resolves byte-identically.
+   *
+   * Half-implementing this — indexing stripped but querying exact — is what made
+   * diacritized `بَدِّل` (toggle) tokenize as `kind=particle normalized=with`:
+   * `isKeyword` returned false, so the guard in `ArabicProcliticExtractor` that
+   * exists to prevent exactly that handed the word on, and the single-char `ب`
+   * bi- proclitic claimed it. A wrong CONCEPT, not a failed parse.
+   *
    * @param native - Native word to look up
    * @returns KeywordEntry if found, undefined otherwise
    */
   lookupKeyword(native) {
-    return this.profileKeywordMap.get(native.toLowerCase());
+    const exact = this.profileKeywordMap.get(native.toLowerCase());
+    if (exact) return exact;
+    const stripped = this.removeDiacritics(native);
+    if (stripped === native) return void 0;
+    return this.profileKeywordMap.get(stripped.toLowerCase());
   }
   /**
-   * Check if a word is a known keyword (case-insensitive).
-   * O(1) lookup using the keyword map.
+   * Check if a word is a known keyword (case-insensitive, diacritic-insensitive).
+   * O(1) lookup using the keyword map. See {@link lookupKeyword}.
    *
    * @param native - Native word to check
    * @returns true if the word is a keyword
    */
   isKeyword(native) {
-    return this.profileKeywordMap.has(native.toLowerCase());
+    return this.lookupKeyword(native) !== void 0;
   }
   /**
    * Set the morphological normalizer for this tokenizer.
@@ -7527,6 +7734,7 @@ export {
   BaseMorphologicalNormalizer,
   BaseTokenizer,
   CrossDomainDispatcher,
+  CssSelectorExtractor,
   DEFAULT_OPERATORS,
   DEFAULT_PUNCTUATION,
   DEFAULT_REFERENCES,
@@ -7563,6 +7771,7 @@ export {
   createCompoundNode,
   createConditionalNode,
   createDiagnosticCollector,
+  createDomainRenderer,
   createEventHandlerNode,
   createExpression,
   createFlag,
@@ -7654,6 +7863,8 @@ export {
   semanticNodeToJSON,
   semanticNodeToRuntimeAST,
   semanticValueToAST,
+  sortRolesByWordOrder,
+  stripOptionalDiacritics,
   synthesizeFromSchemas,
   toEnvelopeJSON,
   toJSONL,

package/dist/server.js

@@ -1134,7 +1134,7 @@ try {
 }
 var frameworkIR = null;
 try {
-  const fw = await import("./dist-6KATWM5A.js");
+  const fw = await import("./dist-LIFKYPGW.js");
   frameworkIR = { fromInterchangeNode: fw.fromInterchangeNode, renderExplicit: fw.renderExplicit };
   console.error(
     "[lokascript-ls] @lokascript/framework loaded \u2014 LSE bracket notation in hover enabled"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/language-server",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "Language Server Protocol implementation for LokaScript/hyperscript with 21 language support",
   "type": "module",
   "main": "dist/server.js",
@@ -31,8 +31,8 @@
     "vscode-languageserver-textdocument": "^1.0.11"
   },
   "peerDependencies": {
-    "@hyperfixi/core": "^2.8.0",
-    "@lokascript/semantic": "^2.8.0"
+    "@hyperfixi/core": "^2.9.0",
+    "@lokascript/semantic": "^2.9.0"
   },
   "peerDependenciesMeta": {
     "@lokascript/semantic": {
@@ -43,8 +43,8 @@
     }
   },
   "devDependencies": {
-    "@hyperfixi/core": "^2.8.0",
-    "@lokascript/semantic": "^2.8.0",
+    "@hyperfixi/core": "^2.9.0",
+    "@lokascript/semantic": "^2.9.0",
     "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "^4.0.0",
     "tsup": "^8.0.0",
@@ -53,7 +53,8 @@
     "vitest": "^4.1.5"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"