@lokascript/language-server 3.2.0 → 4.0.0

package/README.md

@@ -15,7 +15,7 @@ The language server supports four operating modes:
 
 ### Mode Selection
 
-- **auto** (default): `lokascript` mode when the semantic package exposes its API; `hyperscript` mode in builds that replace it with a shim (the standalone `hyperscript-vscode` extension does this)
+- **auto** (default): `lokascript` mode when the semantic package exposes its API; `hyperscript` mode in builds that replace it with a shim
 - **hyperscript**: Enforces \_hyperscript-compatible syntax, English keywords only
 - **hyperscript-i18n**: Enforces \_hyperscript-compatible syntax with multilingual keyword support. Use this if you have original \_hyperscript with `@lokascript/hyperscript-adapter` for writing in non-English languages
 - **lokascript**: Enables all features including LokaScript extensions and multilingual support
@@ -117,8 +117,8 @@ require('lspconfig').lokascript.setup{}
 
 The server reads its settings three ways, and every field is optional (a partial object is merged over the defaults):
 
-1. `initializationOptions` on `initialize` (both VS Code extensions pass `{ language }` here);
-2. a `workspace/didChangeConfiguration` push carrying a `lokascript` or `hyperscript` section (vscode-languageclient only sends one when the client sets `synchronize.configurationSection`; both bundled extensions do);
+1. `initializationOptions` on `initialize` (the VS Code extension passes `{ language }` here);
+2. a `workspace/didChangeConfiguration` push carrying a `lokascript` or `hyperscript` section (vscode-languageclient only sends one when the client sets `synchronize.configurationSection`; the VS Code extension does);
 3. a `workspace/configuration` pull for the `lokascript` and `hyperscript` sections, made at startup and whenever a push arrives with no payload, for clients that advertise the capability.
 
 When both namespaces are present the `lokascript` one wins, unless the server was launched with `HYPERSCRIPT_LS_DEFAULT_MODE` set (the standalone hyperscript product), in which case `hyperscript` wins.
@@ -227,9 +227,10 @@ For users who prefer the `hyperscript` namespace:
 ## Dependencies
 
 - `@lokascript/semantic` and `@lokascript/framework` are **required** (regular dependencies): the semantic package registers the 24 languages at startup, and the framework renders the LSE bracket notation shown in hover. They used to be declared as optional peers while being imported statically, so a server installed without them crashed at startup instead of falling back.
-- `@hyperfixi/core` is an **optional** peer. With it the server surfaces real parse errors, complexity diagnostics and schema-inferred roles in hover; without it, diagnostics degrade to the pattern-based quote/bracket checks and hover uses built-in fallback docs.
+- `@hyperfixi/engine` is an **optional** peer: the engine that runs hyperscript. With it the server surfaces its parse errors (at the position the engine stopped) and gives the AST nodes their source positions for hover, symbols and completions.
+- `@hyperfixi/core` is an **optional** peer, for two of its entries: `/ast-utils` (complexity diagnostics, hover, symbols and completions on the interchange) and `/lsp-metadata` (keyword and hover docs). The AST nodes come from `@lokascript/semantic`, which names each command's roles itself. Without either, diagnostics degrade to the pattern-based quote/bracket checks and hover uses built-in fallback docs. (Until 4.0 the parse errors and nodes came from `@hyperfixi/core`'s parser.)
 
-A bundler that wants an English-only, dependency-free server (the standalone `hyperscript-vscode` extension) replaces the semantic, framework and core imports with throwing or empty shims at bundle time; the server's capability probes are written for that case.
+A bundler that wants an English-only, dependency-free server replaces the semantic, framework, engine and core imports with throwing or empty shims at bundle time; the server's capability probes are written for that case.
 
 ## Development
 

package/dist/server.js

@@ -24,13 +24,25 @@ var defaultSettings = {
 
 // src/command-tiers.ts
 var HYPERSCRIPT_COMMANDS = [
-  // Core commands
+  // The engine's commands.
   "add",
+  "answer",
   "append",
+  "ask",
+  "beep!",
+  "blur",
+  "break",
+  "breakpoint",
   "call",
+  "clear",
+  "close",
+  "continue",
+  "decrement",
   "default",
+  "empty",
   "exit",
   "fetch",
+  "focus",
   "for",
   "get",
   "go",
@@ -38,16 +50,27 @@ var HYPERSCRIPT_COMMANDS = [
   "hide",
   "if",
   "increment",
-  "decrement",
   "js",
   "log",
+  "make",
+  "measure",
+  "morph",
+  "open",
+  "pick",
   "put",
   "remove",
+  "render",
   "repeat",
+  "reset",
   "return",
+  "scroll",
+  "select",
   "send",
   "set",
+  "settle",
   "show",
+  "start",
+  "swap",
   "take",
   "tell",
   "throw",
@@ -55,203 +78,63 @@ var HYPERSCRIPT_COMMANDS = [
   "transition",
   "trigger",
   "wait",
+  // Continues a `repeat`; completed like a command.
   "while",
-  // Upstream commands this list omitted until Arc A step 4.1. Each was probed
-  // on hyperscript.org@0.9.93 in the form shown and produced the command node
-  // named beside it; none of them is a LokaScript invention.
-  "blur",
-  //           `blur #a`                        → BlurCommand
-  "break",
-  //          `repeat 3 times break end`       → controlflow.js BreakCommand
-  "breakpoint",
-  //     `breakpoint`                     → BreakpointCommand (core debug.js)
-  "clear",
-  //          `clear #a`                       → EmptyCommand — upstream spells the
-  "empty",
-  //          `empty #a`                         pair as ONE command with two keywords
-  "close",
-  //          `close #a`                       → CloseCommand
-  "continue",
-  //       `repeat 3 times continue end`    → controlflow.js ContinueCommand
-  "focus",
-  //          `focus #a`                       → FocusCommand
-  "open",
-  //           `open #a`                        → OpenCommand
-  "pick",
-  //           `pick items 1 to 3 from "hello"` → PickCommand
-  "render",
-  //         `render #tpl`                    → RenderCommand
-  "reset",
-  //          `reset #a`                       → ResetCommand
-  "scroll",
-  //         `scroll to #a`                   → ScrollCommand
-  "select",
-  //         `select #a`                      → SelectCommand
-  "start",
-  //          `start view transition end`      → ViewTransitionCommand
-  "swap",
-  //           `swap $a with $b`                → SwapCommand. The htmx-style
-  //                     `swap <content> into <target>` form is an EXTENSION of this same
-  //                     command, not a different one — `commands/dom/swap.ts` implements the
-  //                     upstream value-swap variant explicitly, under a `variant` discriminator.
-  // Never written by a user: `pseudo-command` is the internal registry name for
-  // method-call-as-command (`foo() on #a`), and `-` is not an identifier
-  // character, so no source text can contain the token. Listed so the
-  // partition is total. The mechanism is upstream — the probe above yields
-  // PseudoCommand from `parsetree/commands/pseudoCommand.js`, which the core
-  // `_hyperscript.js` bundle registers.
-  "pseudo-command",
-  // Moved OUT of LOKASCRIPT_ONLY_COMMANDS by the same 4.1 oracle run. Each was
-  // asserted to be a LokaScript extension and each parses on stock
-  // hyperscript.org@0.9.93, so the LSP was raising a spurious *error*
-  // diagnostic on portable code — the same defect as the omissions above, with
-  // the sign flipped.
-  "make",
-  //     `make a <div/>`             → MakeCommand      (basic.js)
-  "measure",
-  //  `measure #a`                → MeasureCommand   (dom.js)
-  "morph",
-  //    `morph #a to "<p>x</p>"`    → MorphCommand     (dom.js)
-  "settle",
-  //   `settle`                    → SettleCommand    (animations.js)
-  // `install` is upstream at the position it is actually written — `_="install
-  // Foo"` parses as InstallFeature. It is a FEATURE upstream and a registered
-  // command here, so `on click install Foo` works only in LokaScript. The
-  // lists are keyed by name and cannot express "upstream in feature position
-  // only"; classified by the canonical usage, which is portable.
-  "install",
-  // Definitions
+  // The engine's features (`set` and `js` are features too, listed above).
   "behavior",
+  "bind",
   "def",
   "init",
+  "install",
+  "live",
   "on",
+  "when",
+  // Upstream extensions (ext/eventsource.js, ext/socket.js, ext/worker.js); not in the engine.
   "eventsource",
   "socket",
   "worker"
 ];
-var LOKASCRIPT_ONLY_COMMANDS = [
-  // Upstream _hyperscript has no `prepend`; it offers only
-  // `put <content> at the start of <target>`.
-  "prepend",
-  // `prepend "x" to #a`      → Unexpected Token : prepend
-  "process",
-  // `process "<p>x</p>"`     → Unexpected Token : process
-  // Added by Arc A step 4.1 — the omissions that produced NO diagnostic.
-  "copy",
-  //    `copy "x"`               → Unexpected Token : copy
-  "push",
-  //    `push url "/x"`          → Unexpected Token : push
-  "replace",
-  // `replace url "/x"`       → Unexpected Token : replace
-  // Upstream spells this command `beep!`, with the bang as part of the token:
-  // `beep! me` parses (BeepCommand), `beep me` does not. hyperfixi registers it
-  // as `beep` and accepts both spellings, so the portable spelling is `beep!`
-  // and the bare one is the extension. Classified by the registered name,
-  // which is what these lists key on.
-  "beep",
-  //    `beep me`                → Unexpected Token : beep
-  // Upstream has `unless` only as a TRAILING statement modifier
-  // (`log "x" unless true` → UnlessStatementModifier, kernel.js
-  // parseIndirectStatement). The registered `unless` COMMAND — the leading
-  // block form, an alias of `if` — is the LokaScript addition.
-  "unless"
-  //  `unless true log "x" end` → Unexpected Token : unless
+var LOKASCRIPT_ONLY_COMMANDS = [];
+var ALL_COMMANDS = [
+  ...HYPERSCRIPT_COMMANDS,
+  ...LOKASCRIPT_ONLY_COMMANDS
 ];
-var ALL_COMMANDS = [...HYPERSCRIPT_COMMANDS, ...LOKASCRIPT_ONLY_COMMANDS];
-var LOKASCRIPT_SYNTAX_PATTERNS = {
-  /**
-   * Possessive dot notation on `its`: its.value
-   * Upstream resolves `my.x` and `your.x` (they are plain symbols), so only
-   * `its.` is non-portable; write `its value` for _hyperscript compatibility.
-   */
-  dotNotation: /\bits\.\w+/,
-  /**
-   * Optional chaining: my?.value
-   */
-  optionalChaining: /\b(my|your|its)\?\.\w+/,
-  /**
-   * Extended 'as' conversions
-   */
-  extendedAsConversion: /\bas\s+(Math|Values)\b/i,
-  /**
-   * Debounce/throttle modifiers with duration: .debounce(300), .throttle(1s)
-   */
-  temporalModifiers: /\.(debounce|throttle)\s*\(\s*\d+/i
-};
-function blankStringsAndComments(code) {
-  let out = "";
-  let i = 0;
-  while (i < code.length) {
-    const ch = code[i];
-    if (ch === "-" && code[i + 1] === "-") {
-      const eol = code.indexOf("\n", i);
-      const end = eol === -1 ? code.length : eol;
-      out += " ".repeat(end - i);
-      i = end;
-      continue;
-    }
-    const prev = i === 0 ? " " : code[i - 1];
-    const opensString = ch === '"' || ch === "`" || ch === "'" && /[\s(,\[=]/.test(prev);
-    if (opensString) {
-      let j = i + 1;
-      while (j < code.length && code[j] !== ch) {
-        if (code[j] === "\\") j++;
-        if (code[j] === "\n" && ch !== "`") break;
-        j++;
-      }
-      const end = Math.min(j + 1, code.length);
-      out += " ".repeat(end - i);
-      i = end;
-      continue;
-    }
-    out += ch;
-    i++;
+var ENGINE_ADDITIONS = {
+  newExpression: {
+    pattern: "new-expression",
+    description: "'new X()' is an @hyperfixi/engine addition; upstream reads `new` as a variable (use `make a X`)"
+  },
+  toggleElementCommand: {
+    pattern: "toggle-element",
+    description: "'toggle <element>' (open or close a dialog, details or popover) is an @hyperfixi/engine addition"
   }
-  return out;
-}
-function detectLokascriptFeatures(code) {
+};
+function detectLokascriptFeatures(engineTree) {
   const detected = [];
-  const scannable = blankStringsAndComments(code);
-  for (const cmd of LOKASCRIPT_ONLY_COMMANDS) {
-    const pattern = cmd === "unless" ? /(?<=^[ \t]*|\bthen\s+|\bend\s+|\belse\s+)unless(?![\w-])/im : new RegExp(`(?<![\\w.:$@^#-])${cmd}(?![\\w-])(?!\\s*\\()`, "i");
-    if (pattern.test(scannable)) {
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item);
+      return;
+    }
+    if (typeof node !== "object" || node === null) return;
+    const type = Reflect.get(node, "type");
+    const addition = typeof type === "string" ? ENGINE_ADDITIONS[type] : void 0;
+    if (addition) {
+      const start = Reflect.get(node, "start");
+      const end = Reflect.get(node, "end");
       detected.push({
-        feature: "command",
-        description: `'${cmd}' command is a LokaScript extension`,
-        pattern: cmd
+        feature: "syntax",
+        description: addition.description,
+        pattern: addition.pattern,
+        ...typeof start === "number" && { start },
+        ...typeof end === "number" && { end }
       });
     }
-  }
-  if (LOKASCRIPT_SYNTAX_PATTERNS.dotNotation.test(code)) {
-    detected.push({
-      feature: "syntax",
-      description: "Dot notation (my.property) is a LokaScript extension. Use 'my property' for _hyperscript compatibility",
-      pattern: "dot-notation"
-    });
-  }
-  if (LOKASCRIPT_SYNTAX_PATTERNS.optionalChaining.test(code)) {
-    detected.push({
-      feature: "syntax",
-      description: "Optional chaining (my?.property) is a LokaScript extension",
-      pattern: "optional-chaining"
-    });
-  }
-  const asMatch = code.match(LOKASCRIPT_SYNTAX_PATTERNS.extendedAsConversion);
-  if (asMatch) {
-    detected.push({
-      feature: "conversion",
-      description: `'as ${asMatch[1]}' is a LokaScript extension`,
-      pattern: `as-${asMatch[1].toLowerCase()}`
-    });
-  }
-  const temporalMatch = code.match(LOKASCRIPT_SYNTAX_PATTERNS.temporalModifiers);
-  if (temporalMatch) {
-    detected.push({
-      feature: "modifier",
-      description: `'.${temporalMatch[1]}()' modifier is a LokaScript extension`,
-      pattern: temporalMatch[1].toLowerCase()
-    });
-  }
+    for (const value of Object.values(node)) {
+      if (typeof value === "object" && value !== null) walk(value);
+    }
+  };
+  walk(engineTree);
   return detected;
 }
 
@@ -1355,28 +1238,21 @@ function getOtherLanguages() {
   return semanticPackage.getRegisteredLanguages().filter((l) => l !== "en");
 }
 var interchangeLSP = null;
-var fromCoreASTFn = null;
-var parseFunction = null;
+var engineParse = null;
 var lspMetadata = null;
 try {
-  const core = await import("@hyperfixi/core");
-  parseFunction = core.parse;
-  let inferRoles = null;
-  try {
-    ({ schemaRoleInferrer: inferRoles } = await import("@hyperfixi/core/multilingual"));
-  } catch {
-    console.error(
-      "[lokascript-ls] @hyperfixi/core/multilingual not available \u2014 hover shows roles for `set` and `go` only. Install a core build that ships the multilingual entry."
-    );
-  }
-  fromCoreASTFn = (node) => core.fromCoreAST(
-    node,
-    inferRoles ? { inferRoles } : void 0
-  );
+  const engine = await import("@hyperfixi/engine");
+  engine.register(...engine.everything);
+  engineParse = engine.parse;
+} catch {
+  console.error("[lokascript-ls] @hyperfixi/engine not available \u2014 parse errors disabled");
+}
+try {
   interchangeLSP = await import("@hyperfixi/core/ast-utils");
-  console.error("[lokascript-ls] @hyperfixi/core loaded \u2014 AST parsing + interchange LSP enabled");
 } catch {
-  console.error("[lokascript-ls] @hyperfixi/core not available \u2014 diagnostics and hover degraded");
+  console.error(
+    "[lokascript-ls] @hyperfixi/core/ast-utils not available \u2014 AST diagnostics disabled"
+  );
 }
 try {
   lspMetadata = await import("@hyperfixi/core/lsp-metadata");
@@ -1398,8 +1274,46 @@ try {
   );
 }
 console.error(
-  `[lokascript-ls] capabilities: core=${!!parseFunction}, interchange=${!!interchangeLSP}, metadata=${!!lspMetadata}, framework=${!!frameworkIR}`
+  `[lokascript-ls] capabilities: engine=${!!engineParse}, interchange=${!!interchangeLSP}, metadata=${!!lspMetadata}, framework=${!!frameworkIR}`
 );
+function parseToInterchange(code, language) {
+  const errors = [];
+  let engineTree = null;
+  if (engineParse && (language === "en" || language.startsWith("en-"))) {
+    try {
+      engineTree = engineParse(code);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      const token = typeof e === "object" && e !== null ? Reflect.get(e, "token") : void 0;
+      const start = typeof token === "object" && token !== null ? Reflect.get(token, "start") : void 0;
+      const before = typeof start === "number" ? code.slice(0, start) : null;
+      errors.push({
+        message: message.split("\n")[0] ?? message,
+        ...before !== null ? {
+          line: before.split("\n").length,
+          column: before.length - (before.lastIndexOf("\n") + 1)
+        } : {}
+      });
+    }
+  }
+  let nodes = [];
+  try {
+    const node = semanticPackage?.parseSemantic?.(code, language)?.node;
+    const ast = node ? semanticPackage.buildAST(node)?.ast : null;
+    if (ast) {
+      const converted = semanticPackage.fromSemanticAST(ast);
+      nodes = (Array.isArray(converted) ? converted : [converted]).filter(
+        (n) => n?.type !== "error"
+      );
+      if (engineTree && interchangeLSP?.withEnginePositions) {
+        nodes = interchangeLSP.withEnginePositions(nodes, code, engineTree);
+      }
+    }
+  } catch {
+    nodes = [];
+  }
+  return { nodes, errors };
+}
 var FALLBACK_KEYWORDS = [
   "toggle",
   "add",
@@ -1446,8 +1360,7 @@ var FALLBACK_KEYWORDS = [
   "not",
   "is",
   "exists",
-  "empty",
-  "has"
+  "empty"
 ];
 var FALLBACK_HOVER_DOCS = {
   toggle: {
@@ -1556,11 +1469,6 @@ var FALLBACK_HOVER_DOCS = {
     description: "Appends content to an element.",
     example: 'append "<li>item</li>" to #list'
   },
-  prepend: {
-    title: "prepend",
-    description: "Prepends content to an element.",
-    example: 'prepend "<li>first</li>" to #list'
-  },
   take: {
     title: "take",
     description: "Takes a class from sibling elements (exclusive toggle).",
@@ -1613,13 +1521,8 @@ var FALLBACK_HOVER_DOCS = {
   },
   tell: {
     title: "tell",
-    description: "Sets the default target for subsequent commands.",
-    example: "tell #modal then add .visible"
-  },
-  copy: {
-    title: "copy",
-    description: "Copies text to the clipboard.",
-    example: 'copy "Hello" to the clipboard'
+    description: "Runs commands with another element as `you` (and the implicit target).",
+    example: "tell #modal add .visible end"
   }
 };
 var FALLBACK_EVENT_NAMES = [
@@ -1854,13 +1757,17 @@ function nameCollisionDiagnostics(code, language, source) {
 async function getDiagnostics(code, language) {
   const diagnostics = [];
   const brand = getBranding(resolvedMode);
-  if (isHyperscriptCompatMode(resolvedMode)) {
-    const lokascriptFeatures = detectLokascriptFeatures(code);
-    for (const feature of lokascriptFeatures) {
+  if (isHyperscriptCompatMode(resolvedMode) && engineParse) {
+    let tree = null;
+    try {
+      tree = engineParse(code);
+    } catch {
+    }
+    for (const feature of detectLokascriptFeatures(tree)) {
       diagnostics.push({
         range: {
-          start: { line: 0, character: 0 },
-          end: { line: 0, character: code.split("\n")[0]?.length || code.length }
+          start: offsetToPosition(code, feature.start ?? 0),
+          end: offsetToPosition(code, feature.end ?? code.split("\n")[0]?.length ?? 0)
         },
         severity: DiagnosticSeverity2.Error,
         code: "lokascript-only",
@@ -1871,6 +1778,7 @@ async function getDiagnostics(code, language) {
   }
   const analyzer = isMultilingualEnabled(resolvedMode) ? getSemanticAnalyzer() : null;
   let semanticParsedForeign = false;
+  let detectedLanguage = "en";
   if (analyzer) {
     try {
       let result = analyzer.analyze(code, language);
@@ -1918,6 +1826,7 @@ async function getDiagnostics(code, language) {
         });
       }
       semanticParsedForeign = result.confidence >= 0.5 && usedLanguage !== "en";
+      if (semanticParsedForeign) detectedLanguage = usedLanguage;
       if (semanticParsedForeign) {
         diagnostics.push(...nameCollisionDiagnostics(code, usedLanguage, brand));
       }
@@ -1947,11 +1856,11 @@ async function getDiagnostics(code, language) {
       connection.console.log(`[${brand}-ls] Semantic parsing failed, trying fallback: ${e}`);
     }
   }
-  if (parseFunction && fromCoreASTFn) {
+  if (engineParse || interchangeLSP) {
     try {
-      const parseResult = parseFunction(code);
-      if (parseResult.errors?.length && !semanticParsedForeign) {
-        for (const err of parseResult.errors) {
+      const parsed = parseToInterchange(code, detectedLanguage);
+      if (parsed.errors.length && !semanticParsedForeign) {
+        for (const err of parsed.errors) {
           diagnostics.push({
             range: {
               start: {
@@ -1970,14 +1879,10 @@ async function getDiagnostics(code, language) {
           });
         }
       }
-      if (parseResult.node && interchangeLSP) {
-        const interchange = fromCoreASTFn(parseResult.node);
-        if (interchange && interchange.type !== "literal") {
-          const nodes = Array.isArray(interchange) ? interchange : [interchange];
-          const astDiagnostics = interchangeLSP.interchangeToLSPDiagnostics(nodes, {
-            source: brand
-          });
-          diagnostics.push(...astDiagnostics);
+      if (parsed.nodes.length && interchangeLSP) {
+        const nodes = parsed.nodes.filter((n) => n.type !== "literal");
+        if (nodes.length) {
+          diagnostics.push(...interchangeLSP.interchangeToLSPDiagnostics(nodes, { source: brand }));
         }
       }
     } catch (parseError) {
@@ -2418,19 +2323,18 @@ connection.onHover((params) => {
   }
 });
 function tryGetLSE(code) {
-  if (!interchangeLSP || !parseFunction || !fromCoreASTFn || !frameworkIR) return null;
+  if (!interchangeLSP || !frameworkIR) return null;
   try {
-    const parseResult = parseFunction(code);
-    if (!parseResult.node) return null;
-    const interchange = fromCoreASTFn(parseResult.node);
-    if (!interchange) return null;
-    const semanticNode = frameworkIR.fromInterchangeNode(interchange);
+    const [node] = parseToInterchange(code, globalSettings.language || "en").nodes;
+    if (!node) return null;
+    const semanticNode = frameworkIR.fromInterchangeNode(node);
     return frameworkIR.renderExplicit(semanticNode);
   } catch {
     return null;
   }
 }
 function expandSigilPrefix(line, word) {
+  if (line[word.end] === "!") return { text: word.text + "!", start: word.start };
   if (word.start === 0) return null;
   const prev = line[word.start - 1];
   if (prev !== "^" && prev !== "#") return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/language-server",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "description": "Language Server Protocol implementation for LokaScript/hyperscript with 24 language support",
   "type": "module",
   "main": "dist/server.js",
@@ -14,7 +14,7 @@
     "test": "vitest",
     "typecheck": "tsc --noEmit",
     "test:check": "npm run pretest --silent && VITEST_QUIET=1 bash ../../scripts/vitest-run.sh --reporter=dot",
-    "pretest": "bash ../../scripts/ensure-fresh.sh ../intent ../framework ../semantic ../core && npm run build --silent"
+    "pretest": "bash ../../scripts/ensure-fresh.sh ../intent ../framework ../semantic ../core ../engine && npm run build --silent"
   },
   "keywords": [
     "lsp",
@@ -28,21 +28,26 @@
   "author": "LokaScript Contributors",
   "license": "MIT",
   "dependencies": {
-    "@lokascript/framework": "^3.2.0",
-    "@lokascript/semantic": "^3.2.0",
+    "@lokascript/framework": "^4.0.0",
+    "@lokascript/semantic": "^4.0.0",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.15"
   },
   "peerDependencies": {
-    "@hyperfixi/core": "^3.2.0"
+    "@hyperfixi/core": "^4.0.0",
+    "@hyperfixi/engine": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "@hyperfixi/core": {
       "optional": true
+    },
+    "@hyperfixi/engine": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@hyperfixi/core": "^3.2.0",
+    "@hyperfixi/core": "^4.0.0",
+    "@hyperfixi/engine": "^4.0.0",
     "@types/node": "^26.6.3",
     "@vitest/coverage-v8": "^5.0.0",
     "tsup": "^8.0.0",