@lokascript/language-server 2.7.2 → 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-MRVDB2YM.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",
@@ -212,7 +240,14 @@ var DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
   "result",
   "event",
   "target",
-  "body"
+  "body",
+  // DOM context globals — as reference-typed as `body`, and already advertised as
+  // references by core's REFERENCE_KEYWORDS and the parser's PROPERTY_ACCESS_BASES.
+  // Without them here, a foreign surface (ja ドキュメント, es documento) lexes as a
+  // keyword but fails isValidReference, degrades to a literal, and leaks verbatim.
+  "document",
+  "window",
+  "detail"
 ]);
 function isValidReference(value, referenceSet = DEFAULT_REFERENCES) {
   return referenceSet.has(value);
@@ -227,16 +262,6 @@ var STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
   "catch",
   "finally"
 ]);
-function isNestedCommand(value) {
-  const inner = value.slice(1, -1);
-  let depth = 0;
-  for (const ch of inner) {
-    if (ch === "[") depth++;
-    else if (ch === "]") depth--;
-    else if (depth === 0 && (ch === " " || ch === ":")) return true;
-  }
-  return false;
-}
 function parseExplicit(input, options = {}) {
   const trimmed = input.trim();
   const collect = options.collectDiagnostics === true;
@@ -324,7 +349,7 @@ function parseExplicit(input, options = {}) {
     }
     const role = roleName;
     const valueStr = token.slice(colonIndex + 1);
-    if (STRUCTURAL_ROLES.has(roleName) && valueStr.startsWith("[") && isNestedCommand(valueStr)) {
+    if (STRUCTURAL_ROLES.has(roleName) && valueStr.startsWith("[")) {
       const nestedEnd = findMatchingBracket(token, colonIndex + 1);
       const nestedSyntax = token.slice(colonIndex + 1, nestedEnd + 1);
       roles.set(role, { type: "expression", raw: nestedSyntax });
@@ -576,26 +601,63 @@ function extractStructuralBody(roles, roleName, options) {
   if (value.type === "expression") return [parseExplicit(value.raw, options)];
   return [];
 }
+function hasUnquotedCombinator(value) {
+  let quote = "";
+  for (const ch of value) {
+    if (quote) {
+      if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === " " || ch === ">" || ch === "+" || ch === "~" || ch === ",") return true;
+  }
+  return false;
+}
 function inferSelectorKind(value) {
   if (!value) return void 0;
+  if (hasUnquotedCombinator(value)) return "complex";
   if (value.startsWith("#")) return "id";
   if (value.startsWith(".")) return "class";
   if (value.startsWith("[")) return "attribute";
-  if (value.startsWith("<") || value.startsWith("*")) return "element";
-  if (/[>+~ ]/.test(value) && value.length > 1) return "complex";
+  if (value.startsWith("*")) return "element";
   return void 0;
 }
+function unescapeString(s) {
+  if (!s.includes("\\")) return s;
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\" && i + 1 < s.length) {
+      const next = s[i + 1];
+      const mapped = next === "\\" ? "\\" : next === '"' ? '"' : next === "'" ? "'" : next === "n" ? "\n" : next === "r" ? "\r" : next === "t" ? "	" : "";
+      if (mapped) {
+        out += mapped;
+        i++;
+        continue;
+      }
+    }
+    out += s[i];
+  }
+  return out;
+}
 function tokenizeExplicit(content) {
   const tokens = [];
   let current = "";
   let inString = false;
   let stringChar = "";
+  let inSelector = false;
   let bracketDepth = 0;
   for (let i = 0; i < content.length; i++) {
     const char = content[i];
     if (inString) {
       current += char;
-      if (char === stringChar && content[i - 1] !== "\\") inString = false;
+      if (char === stringChar) {
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && content[j] === "\\"; j--) backslashes++;
+        if (backslashes % 2 === 0) inString = false;
+      }
       continue;
     }
     if (char === '"' || char === "'") {
@@ -604,6 +666,16 @@ function tokenizeExplicit(content) {
       current += char;
       continue;
     }
+    if (inSelector) {
+      current += char;
+      if (char === ">" && current.endsWith("/>")) inSelector = false;
+      continue;
+    }
+    if (char === "<" && (current === "" || current.endsWith(":"))) {
+      inSelector = true;
+      current += char;
+      continue;
+    }
     if (char === "[") {
       bracketDepth++;
       current += char;
@@ -627,11 +699,19 @@ function tokenizeExplicit(content) {
   return tokens;
 }
 function parseExplicitValue(valueStr, referenceSet) {
+  if (valueStr.startsWith("<")) {
+    if (!valueStr.endsWith("/>")) {
+      throw new Error(`Unterminated selector literal: "${valueStr}". Expected a closing "/>"`);
+    }
+    const inner = valueStr.slice(1, -2);
+    if (!inner) throw new Error(`Empty selector literal: "${valueStr}"`);
+    return createSelector(inner, inferSelectorKind(inner));
+  }
   if (valueStr.startsWith("#") || valueStr.startsWith(".") || valueStr.startsWith("[") || valueStr.startsWith("@") || valueStr.startsWith("*")) {
     return createSelector(valueStr, inferSelectorKind(valueStr));
   }
   if (valueStr.startsWith('"') || valueStr.startsWith("'")) {
-    return createLiteral(valueStr.slice(1, -1), "string");
+    return createLiteral(unescapeString(valueStr.slice(1, -1)), "string");
   }
   if (valueStr === "true") return createLiteral(true, "boolean");
   if (valueStr === "false") return createLiteral(false, "boolean");
@@ -730,16 +810,23 @@ function renderBracketCommand(node) {
   }
   return `[${parts.join(" ")}]`;
 }
+function needsSelectorWrap(value) {
+  if (value.includes(" ")) return true;
+  const first = value[0];
+  return !(first === "#" || first === "." || first === "@" || first === "*");
+}
 function valueToString(value) {
   switch (value.type) {
     case "literal":
       if (typeof value.value === "string") {
-        if (value.dataType === "string" || /\s/.test(value.value)) return `"${value.value}"`;
+        if (value.dataType === "string" || /\s/.test(value.value))
+          return JSON.stringify(value.value);
         return value.value;
       }
       return String(value.value);
     case "selector":
-      return value.value;
+      if (!value.value) return value.value;
+      return needsSelectorWrap(value.value) ? `<${value.value}/>` : value.value;
     case "reference":
       return value.value;
     case "property-path":
@@ -837,6 +924,7 @@ function toProtocolJSON(node) {
   if (node.diagnostics && node.diagnostics.length > 0) {
     result.diagnostics = node.diagnostics.map((d) => {
       const json = { level: d.severity, message: d.message };
+      if (d.role) json.role = d.role;
       if (d.code) json.code = d.code;
       if (d.source) json.source = d.source;
       if (d.suggestions && d.suggestions.length > 0) json.suggestions = [...d.suggestions];
@@ -921,6 +1009,7 @@ function fromProtocolJSON(json) {
   const diagnostics = json.diagnostics?.map((d) => ({
     severity: d.level,
     message: d.message,
+    ...d.role ? { role: d.role } : {},
     ...d.code ? { code: d.code } : {},
     ...d.source ? { source: d.source } : {},
     ...d.suggestions && d.suggestions.length > 0 ? { suggestions: d.suggestions } : {}
@@ -2584,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) {
@@ -2670,34 +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);
-  }
-  for (const role of schema.roles) {
+  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();
@@ -3125,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";
@@ -3844,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);
     }
@@ -3856,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);
     }
@@ -3872,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)
@@ -3940,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) {
@@ -3968,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();
   }
@@ -3992,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";
@@ -4085,7 +4418,9 @@ function buildProtocolSection() {
 3. No spaces around the colon in role:value pairs
 4. Strings with spaces must be quoted: \`patient:"hello world"\`
 5. Selectors start with \`#\`, \`.\`, \`[\`, \`@\`, or \`*\`
-6. Output must be valid bracket syntax: \`[action role:value ...]\``;
+6. A selector containing a space, a combinator (\`>\` \`+\` \`~\`), or a comma must use a selector literal: \`patient:<ul > li/>\`, \`patient:<.a, .b/>\`
+7. Inside a structural role (\`body\`, \`then\`, \`else\`, \`condition\`, \`loop-body\`, \`variable\`, \`catch\`, \`finally\`) a \`[...]\` value is always a nested command. Write an attribute selector there as \`condition:<[data-active]/>\`
+8. Output must be valid bracket syntax: \`[action role:value ...]\``;
   return {
     id: "protocol",
     title: "LSE Protocol",
@@ -4098,6 +4433,7 @@ function buildValueTypeSection() {
 
 | Type | Syntax | Example |
 |------|--------|---------|
+| Selector literal | Delimited by \`<\` and \`/>\` | \`<ul > li/>\`, \`<.a, .b/>\`, \`<[data-id]/>\` |
 | Selector | Starts with \`#\` \`.\` \`[\` \`@\` \`*\` | \`#button\`, \`.active\`, \`[data-id]\` |
 | String | Quoted with \`"\` or \`'\` | \`"hello world"\`, \`'json'\` |
 | Boolean | Exact: \`true\` / \`false\` | \`visible:true\` |
@@ -4960,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) {
@@ -5505,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;
@@ -5698,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);
 }
@@ -6238,7 +6494,39 @@ var _BaseTokenizer = class _BaseTokenizer2 {
         pos++;
       }
     }
-    return new TokenStreamImpl(tokens, this.language);
+    return new TokenStreamImpl(this.mergeColonQualifiedNames(tokens), this.language);
+  }
+  /**
+   * Fuse `name` + `:qualifier` into ONE identifier (`draggable:start`).
+   *
+   * `:name` is hyperscript's local-variable sigil, but a colon IMMEDIATELY
+   * preceded by an identifier is a qualifier (custom event namespace), not a
+   * sigil. The English tokenizer already merges these inside
+   * EnglishKeywordExtractor; this post-pass gives the other 23 languages the
+   * same stream. Strict position adjacency is the discriminator: whitespace
+   * between the tokens (`trigger :start`) breaks `end === start`, so a spaced
+   * local-variable reference survives untouched.
+   *
+   * Self-gating for non-hyperscript tokenizers (domain DSLs): their extractor
+   * sets tokenize `:` as bare punctuation (length 1), which never matches
+   * COLON_QUALIFIER, so this pass is a no-op for them.
+   */
+  mergeColonQualifiedNames(tokens) {
+    const out = [];
+    for (const tok of tokens) {
+      const prev = out[out.length - 1];
+      if (prev && _BaseTokenizer2.ASCII_WORD.test(prev.value) && _BaseTokenizer2.COLON_QUALIFIER.test(tok.value) && prev.position.end === tok.position.start) {
+        const merged = prev.value + tok.value;
+        out[out.length - 1] = createToken(
+          merged,
+          this.classifyToken(merged),
+          createPosition(prev.position.start, tok.position.end)
+        );
+        continue;
+      }
+      out.push(tok);
+    }
+    return out;
   }
   /**
    * Classify an unknown character when no extractor matches.
@@ -6371,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.
@@ -6462,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.
@@ -6744,6 +7048,8 @@ var _BaseTokenizer = class _BaseTokenizer2 {
     return null;
   }
 };
+_BaseTokenizer.ASCII_WORD = /^[A-Za-z_][A-Za-z0-9_]*$/;
+_BaseTokenizer.COLON_QUALIFIER = /^:[A-Za-z_][A-Za-z0-9_]*$/;
 _BaseTokenizer.STANDARD_TIME_UNITS = [
   { pattern: "ms", suffix: "ms", length: 2 },
   { pattern: "s", suffix: "s", length: 1, checkBoundary: true },
@@ -7428,6 +7734,7 @@ export {
   BaseMorphologicalNormalizer,
   BaseTokenizer,
   CrossDomainDispatcher,
+  CssSelectorExtractor,
   DEFAULT_OPERATORS,
   DEFAULT_PUNCTUATION,
   DEFAULT_REFERENCES,
@@ -7464,6 +7771,7 @@ export {
   createCompoundNode,
   createConditionalNode,
   createDiagnosticCollector,
+  createDomainRenderer,
   createEventHandlerNode,
   createExpression,
   createFlag,
@@ -7555,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-MRVDB2YM.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.7.2",
+  "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.7.2",
-    "@lokascript/semantic": "^2.7.2"
+    "@hyperfixi/core": "^2.9.0",
+    "@lokascript/semantic": "^2.9.0"
   },
   "peerDependenciesMeta": {
     "@lokascript/semantic": {
@@ -43,17 +43,18 @@
     }
   },
   "devDependencies": {
-    "@hyperfixi/core": "^2.7.2",
-    "@lokascript/semantic": "^2.7.2",
+    "@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",
-    "tsx": "^4.0.0",
+    "tsx": "^4.23.1",
     "typescript": "^5.0.0",
     "vitest": "^4.1.5"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"