@boperators/plugin-ts-language-server 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# @boperators/plugin-ts-language-server
+
+TypeScript Language Server plugin for [boperators](https://www.npmjs.com/package/boperators) - provides IDE support with source mapping.
+
+This plugin transforms operator overloads in the background and remaps positions between original and transformed source, so IDE features (hover, go-to-definition, diagnostics, completions, etc.) work correctly even though the language server sees the transformed code.
+
+## Installation
+
+```sh
+npm install -D boperators @boperators/plugin-ts-language-server
+```
+
+## Setup
+
+### 1. Add the plugin to your `tsconfig.json`
+
+```json
+{
+    "compilerOptions": {
+        "plugins": [
+            { "name": "@boperators/plugin-ts-language-server" }
+        ]
+    }
+}
+```
+
+### 2. Configure your editor
+
+TypeScript Language Service plugins are loaded by `tsserver`, which resolves them relative to the TypeScript installation it's using. If your editor uses its own bundled TypeScript (the default in VS Code), it won't find plugins installed in your project's `node_modules`.
+
+#### VS Code
+
+**1.** Add to your project's `.vscode/settings.json`:
+
+```json
+{
+    "typescript.tsdk": "./node_modules/typescript/lib"
+}
+```
+
+This tells VS Code where to find the workspace TypeScript installation.
+
+**2.** Select the workspace TypeScript version: open the command palette (Ctrl/Cmd+Shift+P) → "TypeScript: Select TypeScript Version" → "Use Workspace Version".
+
+This is the critical step. VS Code defaults to its own bundled TypeScript, which resolves plugins relative to VS Code's installation directory — not your project's `node_modules`. Switching to the workspace version makes tsserver resolve plugins from your project's `node_modules`, where `@boperators/plugin-ts-language-server` is installed.
+
+> This choice is remembered per-workspace, so you only need to do it once.
+
+#### Other editors
+
+Ensure your editor's TypeScript integration uses the `typescript` package from your project's `node_modules` rather than a bundled version. The plugin must be resolvable via `require("@boperators/plugin-ts-language-server")` from the TypeScript installation directory.
+
+### Troubleshooting
+
+If the plugin isn't loading, enable verbose tsserver logging to diagnose:
+
+```json
+{
+    "typescript.tsserver.log": "verbose"
+}
+```
+
+Restart the TS server, then check the log output (shown in the VS Code Output panel → "TypeScript") for lines like:
+
+- `Enabling plugin @boperators/plugin-ts-language-server from candidate paths: ...` — shows where tsserver is looking
+- `Couldn't find @boperators/plugin-ts-language-server` — the plugin wasn't found in any candidate path
+- `[boperators] Plugin loaded` — the plugin loaded successfully
+
+## Features
+
+- **Hover info**: Hovering over an overloaded operator shows the overload signature and JSDoc
+- **Diagnostics remapping**: Errors and warnings point to the correct positions in your original source
+- **Go-to-definition**: Works correctly across transformed files
+- **Completions**: Autocomplete positions are remapped
+- **References and rename**: Find references and rename work across transformed boundaries
+- **Signature help**: Parameter hints are position-remapped
+
+## How It Works
+
+The plugin intercepts `getScriptSnapshot` to transform each file on the fly, building a source map between original and transformed code. All Language Service methods that accept or return positions are proxied to remap through this source map. Overload definitions are cached and invalidated when files change.
+
+## License
+
+MIT

package/dist/SourceMap.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMap = void 0;
+/**
+ * Bidirectional position mapping between original and transformed source text.
+ *
+ * Computes a list of edit records by diffing the two texts, then provides
+ * O(edits) position and span mapping in both directions.
+ */
+class SourceMap {
+    constructor(original, transformed) {
+        this.edits = computeEdits(original, transformed);
+    }
+    /** Returns true if no edits were detected (original === transformed). */
+    get isEmpty() {
+        return this.edits.length === 0;
+    }
+    /** Map a position from original source to transformed source. */
+    originalToTransformed(pos) {
+        let delta = 0;
+        for (const edit of this.edits) {
+            if (pos < edit.origStart) {
+                // Before this edit — just apply accumulated delta
+                break;
+            }
+            if (pos < edit.origEnd) {
+                // Inside an edited region — map to start of the transformed replacement
+                return edit.transStart;
+            }
+            // Past this edit — accumulate the delta
+            delta = edit.transEnd - edit.origEnd;
+        }
+        return pos + delta;
+    }
+    /** Map a position from transformed source to original source. */
+    transformedToOriginal(pos) {
+        let delta = 0;
+        for (const edit of this.edits) {
+            if (pos < edit.transStart) {
+                break;
+            }
+            if (pos < edit.transEnd) {
+                // Inside a transformed region — map to start of the original span
+                return edit.origStart;
+            }
+            delta = edit.origEnd - edit.transEnd;
+        }
+        return pos + delta;
+    }
+    /** Map a text span { start, length } from transformed positions to original positions. */
+    remapSpan(span) {
+        const origStart = this.transformedToOriginal(span.start);
+        const origEnd = this.transformedToOriginal(span.start + span.length);
+        return { start: origStart, length: origEnd - origStart };
+    }
+    /** Check if an original-source position falls inside an edited region. */
+    isInsideEdit(originalPos) {
+        for (const edit of this.edits) {
+            if (originalPos < edit.origStart)
+                return false;
+            if (originalPos < edit.origEnd)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * For a position inside an edited region (in original coords),
+     * return the EditRecord it falls in, or undefined.
+     */
+    getEditAt(originalPos) {
+        for (const edit of this.edits) {
+            if (originalPos < edit.origStart)
+                return undefined;
+            if (originalPos < edit.origEnd)
+                return edit;
+        }
+        return undefined;
+    }
+}
+exports.SourceMap = SourceMap;
+/**
+ * Compute edit records by scanning both texts for mismatches.
+ *
+ * Uses character-level comparison with anchor-based convergence:
+ * identical characters are skipped, mismatches start an edit region,
+ * and convergence is found by searching for a matching anchor substring
+ * in the remaining text.
+ */
+function computeEdits(original, transformed) {
+    if (original === transformed)
+        return [];
+    const edits = [];
+    let i = 0; // index in original
+    let j = 0; // index in transformed
+    while (i < original.length && j < transformed.length) {
+        // Skip matching characters
+        if (original[i] === transformed[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        // Mismatch — start of an edit
+        const origEditStart = i;
+        const transEditStart = j;
+        // Find where the texts converge again.
+        // Search for an anchor: a substring from `original` that also
+        // appears at the corresponding position in `transformed`.
+        const ANCHOR_LEN = 8;
+        let found = false;
+        // Scan ahead in original from the mismatch point
+        for (let oi = origEditStart + 1; oi <= original.length - ANCHOR_LEN; oi++) {
+            const anchor = original.substring(oi, oi + ANCHOR_LEN);
+            const transPos = transformed.indexOf(anchor, transEditStart);
+            if (transPos >= 0) {
+                // Verify the anchor actually converges by checking a few more chars
+                let valid = true;
+                const verifyLen = Math.min(ANCHOR_LEN * 2, original.length - oi, transformed.length - transPos);
+                for (let k = ANCHOR_LEN; k < verifyLen; k++) {
+                    if (original[oi + k] !== transformed[transPos + k]) {
+                        valid = false;
+                        break;
+                    }
+                }
+                if (valid) {
+                    edits.push({
+                        origStart: origEditStart,
+                        origEnd: oi,
+                        transStart: transEditStart,
+                        transEnd: transPos,
+                    });
+                    i = oi;
+                    j = transPos;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            // No convergence — remaining text is all part of the edit.
+            // Use common suffix to tighten the bounds.
+            let suffixLen = 0;
+            while (suffixLen < original.length - origEditStart &&
+                suffixLen < transformed.length - transEditStart &&
+                original[original.length - 1 - suffixLen] ===
+                    transformed[transformed.length - 1 - suffixLen]) {
+                suffixLen++;
+            }
+            edits.push({
+                origStart: origEditStart,
+                origEnd: original.length - suffixLen,
+                transStart: transEditStart,
+                transEnd: transformed.length - suffixLen,
+            });
+            i = original.length;
+            j = transformed.length;
+        }
+    }
+    // Handle remaining text at the end
+    if (i < original.length || j < transformed.length) {
+        edits.push({
+            origStart: i,
+            origEnd: original.length,
+            transStart: j,
+            transEnd: transformed.length,
+        });
+    }
+    return edits;
+}

package/dist/index.js

@@ -0,0 +1,694 @@
+"use strict";
+const boperators_1 = require("boperators");
+// ----- Overload edit scanner -----
+/**
+ * Before transformation, find all expressions (binary, prefix unary, postfix unary)
+ * that match registered overloads and record their operator token positions.
+ * This is used to provide hover info for overloaded operators.
+ */
+/**
+ * Recursively resolve the effective type of an expression, accounting for
+ * operator overloads. For sub-expressions that match a registered overload,
+ * uses the overload's declared return type instead of what TypeScript infers
+ * (since TS doesn't know about operator overloading).
+ */
+function resolveOverloadedType(node, overloadStore) {
+    if (boperators_1.Node.isParenthesizedExpression(node)) {
+        return resolveOverloadedType(node.getExpression(), overloadStore);
+    }
+    if (boperators_1.Node.isBinaryExpression(node)) {
+        const operatorKind = node.getOperatorToken().getKind();
+        if ((0, boperators_1.isOperatorSyntaxKind)(operatorKind)) {
+            const leftType = resolveOverloadedType(node.getLeft(), overloadStore);
+            const rightType = resolveOverloadedType(node.getRight(), overloadStore);
+            const overload = overloadStore.findOverload(operatorKind, leftType, rightType);
+            if (overload)
+                return overload.returnType;
+        }
+    }
+    if (boperators_1.Node.isPrefixUnaryExpression(node)) {
+        const operatorKind = node.getOperatorToken();
+        if ((0, boperators_1.isPrefixUnaryOperatorSyntaxKind)(operatorKind)) {
+            const operandType = resolveOverloadedType(node.getOperand(), overloadStore);
+            const overload = overloadStore.findPrefixUnaryOverload(operatorKind, operandType);
+            if (overload)
+                return overload.returnType;
+        }
+    }
+    if (boperators_1.Node.isPostfixUnaryExpression(node)) {
+        const operatorKind = node.getOperatorToken();
+        if ((0, boperators_1.isPostfixUnaryOperatorSyntaxKind)(operatorKind)) {
+            const operandType = resolveOverloadedType(node.getOperand(), overloadStore);
+            const overload = overloadStore.findPostfixUnaryOverload(operatorKind, operandType);
+            if (overload)
+                return overload.returnType;
+        }
+    }
+    return (0, boperators_1.resolveExpressionType)(node);
+}
+function findOverloadEdits(sourceFile, overloadStore) {
+    const edits = [];
+    const binaryExpressions = sourceFile.getDescendantsOfKind(boperators_1.SyntaxKind.BinaryExpression);
+    for (const expression of binaryExpressions) {
+        const operatorToken = expression.getOperatorToken();
+        const operatorKind = operatorToken.getKind();
+        if (!(0, boperators_1.isOperatorSyntaxKind)(operatorKind))
+            continue;
+        const leftType = resolveOverloadedType(expression.getLeft(), overloadStore);
+        const rightType = resolveOverloadedType(expression.getRight(), overloadStore);
+        const overloadDesc = overloadStore.findOverload(operatorKind, leftType, rightType);
+        if (!overloadDesc)
+            continue;
+        edits.push({
+            operatorStart: operatorToken.getStart(),
+            operatorEnd: operatorToken.getEnd(),
+            hoverStart: expression.getLeft().getEnd(),
+            hoverEnd: expression.getRight().getStart(),
+            exprStart: expression.getStart(),
+            exprEnd: expression.getEnd(),
+            className: overloadDesc.className,
+            classFilePath: overloadDesc.classFilePath,
+            operatorString: overloadDesc.operatorString,
+            index: overloadDesc.index,
+            isStatic: overloadDesc.isStatic,
+            kind: "binary",
+        });
+    }
+    // Scan prefix unary expressions
+    const prefixExpressions = sourceFile.getDescendantsOfKind(boperators_1.SyntaxKind.PrefixUnaryExpression);
+    for (const expression of prefixExpressions) {
+        const operatorKind = expression.getOperatorToken();
+        if (!(0, boperators_1.isPrefixUnaryOperatorSyntaxKind)(operatorKind))
+            continue;
+        const operandType = resolveOverloadedType(expression.getOperand(), overloadStore);
+        const overloadDesc = overloadStore.findPrefixUnaryOverload(operatorKind, operandType);
+        if (!overloadDesc)
+            continue;
+        const exprStart = expression.getStart();
+        const operand = expression.getOperand();
+        edits.push({
+            operatorStart: exprStart,
+            operatorEnd: operand.getStart(),
+            hoverStart: exprStart,
+            hoverEnd: operand.getStart(),
+            exprStart,
+            exprEnd: expression.getEnd(),
+            className: overloadDesc.className,
+            classFilePath: overloadDesc.classFilePath,
+            operatorString: overloadDesc.operatorString,
+            index: overloadDesc.index,
+            isStatic: overloadDesc.isStatic,
+            kind: "prefixUnary",
+        });
+    }
+    // Scan postfix unary expressions
+    const postfixExpressions = sourceFile.getDescendantsOfKind(boperators_1.SyntaxKind.PostfixUnaryExpression);
+    for (const expression of postfixExpressions) {
+        const operatorKind = expression.getOperatorToken();
+        if (!(0, boperators_1.isPostfixUnaryOperatorSyntaxKind)(operatorKind))
+            continue;
+        const operandType = resolveOverloadedType(expression.getOperand(), overloadStore);
+        const overloadDesc = overloadStore.findPostfixUnaryOverload(operatorKind, operandType);
+        if (!overloadDesc)
+            continue;
+        const operand = expression.getOperand();
+        const operatorStart = operand.getEnd();
+        edits.push({
+            operatorStart,
+            operatorEnd: expression.getEnd(),
+            hoverStart: operatorStart,
+            hoverEnd: expression.getEnd(),
+            exprStart: expression.getStart(),
+            exprEnd: expression.getEnd(),
+            className: overloadDesc.className,
+            classFilePath: overloadDesc.classFilePath,
+            operatorString: overloadDesc.operatorString,
+            index: overloadDesc.index,
+            isStatic: overloadDesc.isStatic,
+            kind: "postfixUnary",
+        });
+    }
+    return edits;
+}
+// ----- Overload hover info -----
+/**
+ * Build a QuickInfo response for hovering over an operator token
+ * that corresponds to an overloaded operator. Extracts the function
+ * signature and JSDoc from the overload definition.
+ */
+function getOverloadHoverInfo(ts, project, edit) {
+    try {
+        const classSourceFile = project.getSourceFile(edit.classFilePath);
+        if (!classSourceFile)
+            return undefined;
+        const classDecl = classSourceFile.getClass(edit.className);
+        if (!classDecl)
+            return undefined;
+        // Find the property with the matching operator string
+        const prop = classDecl.getProperties().find((p) => {
+            if (!boperators_1.Node.isPropertyDeclaration(p))
+                return false;
+            return (0, boperators_1.getOperatorStringFromProperty)(p) === edit.operatorString;
+        });
+        if (!prop || !boperators_1.Node.isPropertyDeclaration(prop))
+            return undefined;
+        // Extract param types and return type from either the initializer (regular
+        // .ts files) or the type annotation (.d.ts files where initializers are
+        // stripped by TypeScript's declaration emit).
+        let params = [];
+        let returnTypeName;
+        let docText;
+        const initializer = (0, boperators_1.unwrapInitializer)(prop.getInitializer());
+        if (initializer && boperators_1.Node.isArrayLiteralExpression(initializer)) {
+            const element = initializer.getElements()[edit.index];
+            if (!element ||
+                (!boperators_1.Node.isFunctionExpression(element) && !boperators_1.Node.isArrowFunction(element)))
+                return undefined;
+            const nonThisParams = element
+                .getParameters()
+                .filter((p) => p.getName() !== "this");
+            params = nonThisParams.map((p) => ({
+                typeName: p.getType().getText(element),
+            }));
+            returnTypeName = element.getReturnType().getText(element);
+            const jsDocs = element.getJsDocs();
+            if (jsDocs.length > 0) {
+                const raw = jsDocs[0].getText();
+                docText = raw
+                    .replace(/^\/\*\*\s*/, "")
+                    .replace(/\s*\*\/$/, "")
+                    .replace(/^\s*\* ?/gm, "")
+                    .trim();
+            }
+        }
+        else {
+            // Type-annotation fallback for .d.ts files
+            const propertyType = prop.getType();
+            if (!propertyType.isTuple())
+                return undefined;
+            const tupleElements = propertyType.getTupleElements();
+            if (edit.index >= tupleElements.length)
+                return undefined;
+            const elementType = tupleElements[edit.index];
+            const callSigs = elementType.getCallSignatures();
+            if (callSigs.length === 0)
+                return undefined;
+            const sig = callSigs[0];
+            for (const sym of sig.getParameters()) {
+                if (sym.getName() === "this")
+                    continue;
+                const decl = sym.getValueDeclaration();
+                if (!decl)
+                    continue;
+                params.push({ typeName: decl.getType().getText(prop) });
+            }
+            returnTypeName = sig.getReturnType().getText(prop);
+        }
+        // Build display signature parts based on overload kind
+        const displayParts = [];
+        if (edit.kind === "prefixUnary") {
+            // Prefix unary: "-Vector3 = Vector3"
+            displayParts.push({
+                text: edit.operatorString,
+                kind: "operator",
+            });
+            const operandType = params.length >= 1 ? params[0].typeName : edit.className;
+            displayParts.push({ text: operandType, kind: "className" });
+            if (returnTypeName !== "void") {
+                displayParts.push({ text: " = ", kind: "punctuation" });
+                displayParts.push({
+                    text: returnTypeName,
+                    kind: "className",
+                });
+            }
+        }
+        else if (edit.kind === "postfixUnary") {
+            // Postfix unary: "Vector3++"
+            displayParts.push({ text: edit.className, kind: "className" });
+            displayParts.push({
+                text: edit.operatorString,
+                kind: "operator",
+            });
+        }
+        else if (edit.isStatic && params.length >= 2) {
+            // Binary static: "LhsType + RhsType = ReturnType"
+            const lhsType = params[0].typeName;
+            const rhsType = params[1].typeName;
+            displayParts.push({ text: lhsType, kind: "className" });
+            displayParts.push({ text: " ", kind: "space" });
+            displayParts.push({
+                text: edit.operatorString,
+                kind: "operator",
+            });
+            displayParts.push({ text: " ", kind: "space" });
+            displayParts.push({ text: rhsType, kind: "className" });
+            if (returnTypeName !== "void") {
+                displayParts.push({ text: " = ", kind: "punctuation" });
+                displayParts.push({
+                    text: returnTypeName,
+                    kind: "className",
+                });
+            }
+        }
+        else {
+            // Binary instance: "ClassName += RhsType"
+            const rhsType = params.length >= 1 ? params[0].typeName : "unknown";
+            displayParts.push({ text: edit.className, kind: "className" });
+            displayParts.push({ text: " ", kind: "space" });
+            displayParts.push({
+                text: edit.operatorString,
+                kind: "operator",
+            });
+            displayParts.push({ text: " ", kind: "space" });
+            displayParts.push({ text: rhsType, kind: "className" });
+            if (returnTypeName !== "void") {
+                displayParts.push({ text: " = ", kind: "punctuation" });
+                displayParts.push({
+                    text: returnTypeName,
+                    kind: "className",
+                });
+            }
+        }
+        return {
+            kind: ts.ScriptElementKind.functionElement,
+            kindModifiers: edit.isStatic ? "static" : "",
+            textSpan: {
+                start: edit.operatorStart,
+                length: edit.operatorEnd - edit.operatorStart,
+            },
+            displayParts,
+            documentation: docText ? [{ text: docText, kind: "text" }] : undefined,
+            tags: [],
+        };
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+// ----- LanguageService proxy -----
+function getSourceMapForFile(cache, fileName) {
+    const entry = cache.get(fileName);
+    if (!entry || entry.sourceMap.isEmpty)
+        return undefined;
+    return entry.sourceMap;
+}
+function remapDiagnosticSpan(diag, sourceMap) {
+    if (diag.start !== undefined && diag.length !== undefined) {
+        const remapped = sourceMap.remapSpan({
+            start: diag.start,
+            length: diag.length,
+        });
+        diag.start = remapped.start;
+        diag.length = remapped.length;
+    }
+}
+function createProxy(ts, ls, cache, project) {
+    // Copy all methods from the underlying language service
+    const proxy = Object.create(null);
+    for (const key of Object.keys(ls)) {
+        proxy[key] = ls[key];
+    }
+    // --- Diagnostics: remap output spans + suppress overload errors ---
+    const isOverloadSuppressed = (code, start, entry) => {
+        if (!(entry === null || entry === void 0 ? void 0 : entry.overloadEdits.length) || start === undefined)
+            return false;
+        // TS2588: "Cannot assign to 'x' because it is a constant."
+        if (code === 2588) {
+            return entry.overloadEdits.some((e) => !e.isStatic && start >= e.exprStart && start < e.exprEnd);
+        }
+        return false;
+    };
+    proxy.getSemanticDiagnostics = (fileName) => {
+        const result = ls.getSemanticDiagnostics(fileName);
+        const entry = cache.get(fileName);
+        const sourceMap = (entry === null || entry === void 0 ? void 0 : entry.sourceMap.isEmpty) === false ? entry.sourceMap : undefined;
+        if (sourceMap) {
+            for (const diag of result) {
+                remapDiagnosticSpan(diag, sourceMap);
+                if (diag.relatedInformation) {
+                    for (const related of diag.relatedInformation) {
+                        const relatedMap = related.file
+                            ? getSourceMapForFile(cache, related.file.fileName)
+                            : undefined;
+                        if (relatedMap)
+                            remapDiagnosticSpan(related, relatedMap);
+                    }
+                }
+            }
+        }
+        return result.filter((diag) => !isOverloadSuppressed(diag.code, diag.start, entry));
+    };
+    proxy.getSyntacticDiagnostics = (fileName) => {
+        const result = ls.getSyntacticDiagnostics(fileName);
+        const entry = cache.get(fileName);
+        const sourceMap = (entry === null || entry === void 0 ? void 0 : entry.sourceMap.isEmpty) === false ? entry.sourceMap : undefined;
+        if (sourceMap) {
+            for (const diag of result) {
+                remapDiagnosticSpan(diag, sourceMap);
+                if (diag.relatedInformation) {
+                    for (const related of diag.relatedInformation) {
+                        const relatedMap = related.file
+                            ? getSourceMapForFile(cache, related.file.fileName)
+                            : undefined;
+                        if (relatedMap)
+                            remapDiagnosticSpan(related, relatedMap);
+                    }
+                }
+            }
+        }
+        return result.filter((diag) => !isOverloadSuppressed(diag.code, diag.start, entry));
+    };
+    proxy.getSuggestionDiagnostics = (fileName) => {
+        const result = ls.getSuggestionDiagnostics(fileName);
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        if (!sourceMap)
+            return result;
+        for (const diag of result) {
+            remapDiagnosticSpan(diag, sourceMap);
+        }
+        return result;
+    };
+    // --- Hover: remap input position + output span, custom operator hover ---
+    proxy.getQuickInfoAtPosition = (fileName, position) => {
+        // Check if hovering over an overloaded operator
+        const entry = cache.get(fileName);
+        if (entry) {
+            const operatorEdit = entry.overloadEdits.find((e) => position >= e.hoverStart && position < e.hoverEnd);
+            if (operatorEdit) {
+                const hoverInfo = getOverloadHoverInfo(ts, project, operatorEdit);
+                if (hoverInfo)
+                    return hoverInfo;
+            }
+        }
+        const sourceMap = (entry === null || entry === void 0 ? void 0 : entry.sourceMap.isEmpty) === false ? entry.sourceMap : undefined;
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getQuickInfoAtPosition(fileName, transformedPos);
+        if (!result || !sourceMap)
+            return result;
+        result.textSpan = sourceMap.remapSpan(result.textSpan);
+        return result;
+    };
+    // --- Go-to-definition: remap input position + output spans ---
+    proxy.getDefinitionAndBoundSpan = (fileName, position) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getDefinitionAndBoundSpan(fileName, transformedPos);
+        if (!result)
+            return result;
+        // Remap the bound span (in the current file)
+        if (sourceMap) {
+            result.textSpan = sourceMap.remapSpan(result.textSpan);
+        }
+        // Remap definition spans (may be in other files)
+        if (result.definitions) {
+            for (const def of result.definitions) {
+                const defMap = getSourceMapForFile(cache, def.fileName);
+                if (defMap) {
+                    def.textSpan = defMap.remapSpan(def.textSpan);
+                    if (def.contextSpan) {
+                        def.contextSpan = defMap.remapSpan(def.contextSpan);
+                    }
+                }
+            }
+        }
+        return result;
+    };
+    proxy.getDefinitionAtPosition = (fileName, position) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getDefinitionAtPosition(fileName, transformedPos);
+        if (!result)
+            return result;
+        return result.map((def) => {
+            const defMap = getSourceMapForFile(cache, def.fileName);
+            if (!defMap)
+                return def;
+            return Object.assign(Object.assign({}, def), { textSpan: defMap.remapSpan(def.textSpan), contextSpan: def.contextSpan
+                    ? defMap.remapSpan(def.contextSpan)
+                    : undefined });
+        });
+    };
+    proxy.getTypeDefinitionAtPosition = (fileName, position) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getTypeDefinitionAtPosition(fileName, transformedPos);
+        if (!result)
+            return result;
+        return result.map((def) => {
+            const defMap = getSourceMapForFile(cache, def.fileName);
+            if (!defMap)
+                return def;
+            return Object.assign(Object.assign({}, def), { textSpan: defMap.remapSpan(def.textSpan), contextSpan: def.contextSpan
+                    ? defMap.remapSpan(def.contextSpan)
+                    : undefined });
+        });
+    };
+    // --- Completions: remap input position ---
+    proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getCompletionsAtPosition(fileName, transformedPos, options, formattingSettings);
+        if (!result || !sourceMap)
+            return result;
+        // Remap replacement spans in completion entries
+        if (result.optionalReplacementSpan) {
+            result.optionalReplacementSpan = sourceMap.remapSpan(result.optionalReplacementSpan);
+        }
+        for (const entry of result.entries) {
+            if (entry.replacementSpan) {
+                entry.replacementSpan = sourceMap.remapSpan(entry.replacementSpan);
+            }
+        }
+        return result;
+    };
+    // --- References: remap input + output ---
+    proxy.getReferencesAtPosition = (fileName, position) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getReferencesAtPosition(fileName, transformedPos);
+        if (!result)
+            return result;
+        return result.map((ref) => {
+            const refMap = getSourceMapForFile(cache, ref.fileName);
+            if (!refMap)
+                return ref;
+            return Object.assign(Object.assign({}, ref), { textSpan: refMap.remapSpan(ref.textSpan), contextSpan: ref.contextSpan
+                    ? refMap.remapSpan(ref.contextSpan)
+                    : undefined });
+        });
+    };
+    proxy.findReferences = (fileName, position) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.findReferences(fileName, transformedPos);
+        if (!result)
+            return result;
+        return result.map((group) => (Object.assign(Object.assign({}, group), { references: group.references.map((ref) => {
+                const refMap = getSourceMapForFile(cache, ref.fileName);
+                if (!refMap)
+                    return ref;
+                return Object.assign(Object.assign({}, ref), { textSpan: refMap.remapSpan(ref.textSpan), contextSpan: ref.contextSpan
+                        ? refMap.remapSpan(ref.contextSpan)
+                        : undefined });
+            }) })));
+    };
+    // --- Classifications: remap output spans for syntax coloring ---
+    proxy.getEncodedSemanticClassifications = (fileName, span, format) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedSpan = sourceMap
+            ? {
+                start: sourceMap.originalToTransformed(span.start),
+                length: sourceMap.originalToTransformed(span.start + span.length) -
+                    sourceMap.originalToTransformed(span.start),
+            }
+            : span;
+        const result = ls.getEncodedSemanticClassifications(fileName, transformedSpan, format);
+        if (!sourceMap)
+            return result;
+        // spans are triples: [start, length, classification, ...]
+        for (let i = 0; i < result.spans.length; i += 3) {
+            const remapped = sourceMap.remapSpan({
+                start: result.spans[i],
+                length: result.spans[i + 1],
+            });
+            result.spans[i] = remapped.start;
+            result.spans[i + 1] = remapped.length;
+        }
+        return result;
+    };
+    proxy.getEncodedSyntacticClassifications = (fileName, span) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedSpan = sourceMap
+            ? {
+                start: sourceMap.originalToTransformed(span.start),
+                length: sourceMap.originalToTransformed(span.start + span.length) -
+                    sourceMap.originalToTransformed(span.start),
+            }
+            : span;
+        const result = ls.getEncodedSyntacticClassifications(fileName, transformedSpan);
+        if (!sourceMap)
+            return result;
+        for (let i = 0; i < result.spans.length; i += 3) {
+            const remapped = sourceMap.remapSpan({
+                start: result.spans[i],
+                length: result.spans[i + 1],
+            });
+            result.spans[i] = remapped.start;
+            result.spans[i + 1] = remapped.length;
+        }
+        return result;
+    };
+    // --- Signature help: remap input position + applicableSpan ---
+    proxy.getSignatureHelpItems = (fileName, position, options) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getSignatureHelpItems(fileName, transformedPos, options);
+        if (!result || !sourceMap)
+            return result;
+        result.applicableSpan = sourceMap.remapSpan(result.applicableSpan);
+        return result;
+    };
+    // --- Rename: remap input + output ---
+    proxy.findRenameLocations = (fileName, position, findInStrings, findInComments, preferences) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.findRenameLocations(fileName, transformedPos, findInStrings, findInComments, preferences);
+        if (!result)
+            return result;
+        return result.map((loc) => {
+            const locMap = getSourceMapForFile(cache, loc.fileName);
+            if (!locMap)
+                return loc;
+            return Object.assign(Object.assign({}, loc), { textSpan: locMap.remapSpan(loc.textSpan), contextSpan: loc.contextSpan
+                    ? locMap.remapSpan(loc.contextSpan)
+                    : undefined });
+        });
+    };
+    proxy.getRenameInfo = (fileName, position, preferences) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getRenameInfo(fileName, transformedPos, preferences);
+        if (!sourceMap)
+            return result;
+        if ("triggerSpan" in result && result.triggerSpan) {
+            result.triggerSpan = sourceMap.remapSpan(result.triggerSpan);
+        }
+        return result;
+    };
+    // --- Implementation location: remap input + output ---
+    proxy.getImplementationAtPosition = (fileName, position) => {
+        const sourceMap = getSourceMapForFile(cache, fileName);
+        const transformedPos = sourceMap
+            ? sourceMap.originalToTransformed(position)
+            : position;
+        const result = ls.getImplementationAtPosition(fileName, transformedPos);
+        if (!result)
+            return result;
+        return result.map((impl) => {
+            const implMap = getSourceMapForFile(cache, impl.fileName);
+            if (!implMap)
+                return impl;
+            return Object.assign(Object.assign({}, impl), { textSpan: implMap.remapSpan(impl.textSpan), contextSpan: impl.contextSpan
+                    ? implMap.remapSpan(impl.contextSpan)
+                    : undefined });
+        });
+    };
+    return proxy;
+}
+module.exports = function init(modules) {
+    const ts = modules.typescript;
+    function create(info) {
+        var _a, _b;
+        const tsServerLogger = {
+            debug: (msg) => info.project.projectService.logger.info(`[boperators] [debug] ${msg}`),
+            info: (msg) => info.project.projectService.logger.info(`[boperators] ${msg}`),
+            warn: (msg) => info.project.projectService.logger.info(`[boperators] [warn] ${msg}`),
+            error: (msg) => info.project.projectService.logger.info(`[boperators] [error] ${msg}`),
+        };
+        const config = (0, boperators_1.loadConfig)({ logger: tsServerLogger });
+        config.logger.info(`Creating language service plugin for project: ${info.project.getProjectName()}`);
+        const host = info.languageServiceHost;
+        // Set up ts-morph transformation pipeline
+        const project = new boperators_1.Project({ skipFileDependencyResolution: true });
+        const errorManager = new boperators_1.ErrorManager(config);
+        const overloadStore = new boperators_1.OverloadStore(project, errorManager, config.logger);
+        const overloadInjector = new boperators_1.OverloadInjector(project, overloadStore, config.logger);
+        const originalGetSnapshot = (_a = host.getScriptSnapshot) === null || _a === void 0 ? void 0 : _a.bind(host);
+        const originalGetVersion = (_b = host.getScriptVersion) === null || _b === void 0 ? void 0 : _b.bind(host);
+        const cache = new Map();
+        host.getScriptSnapshot = (fileName) => {
+            var _a;
+            const snap = originalGetSnapshot === null || originalGetSnapshot === void 0 ? void 0 : originalGetSnapshot(fileName);
+            if (!snap || !fileName.endsWith(".ts") || fileName.endsWith(".d.ts"))
+                return snap;
+            const version = (_a = originalGetVersion === null || originalGetVersion === void 0 ? void 0 : originalGetVersion(fileName)) !== null && _a !== void 0 ? _a : "0";
+            const cached = cache.get(fileName);
+            if ((cached === null || cached === void 0 ? void 0 : cached.version) === version) {
+                return ts.ScriptSnapshot.fromString(cached.text);
+            }
+            const source = snap.getText(0, snap.getLength());
+            try {
+                // Invalidate this file's old overload entries before overwriting.
+                const hadOverloads = overloadStore.invalidateFile(fileName);
+                if (hadOverloads)
+                    cache.clear();
+                // Add/update the file in our ts-morph project
+                project.createSourceFile(fileName, source, { overwrite: true });
+                // Resolve any new dependencies and scan for overloads.
+                const deps = project.resolveSourceFileDependencies();
+                for (const dep of deps)
+                    overloadStore.addOverloadsFromFile(dep);
+                overloadStore.addOverloadsFromFile(fileName);
+                errorManager.throwIfErrorsElseLogWarnings();
+                // Before transforming, scan for overloaded expressions
+                // so we can record their operator positions for hover info.
+                const sourceFile = project.getSourceFileOrThrow(fileName);
+                const overloadEdits = findOverloadEdits(sourceFile, overloadStore);
+                // Transform expressions (returns text + source map)
+                const result = overloadInjector.overloadFile(fileName);
+                cache.set(fileName, {
+                    version,
+                    text: result.text,
+                    sourceMap: result.sourceMap,
+                    overloadEdits,
+                });
+                return ts.ScriptSnapshot.fromString(result.text);
+            }
+            catch (e) {
+                config.logger.error(`Error transforming ${fileName}: ${e}`);
+                cache.set(fileName, {
+                    version,
+                    text: source,
+                    sourceMap: new boperators_1.SourceMap(source, source),
+                    overloadEdits: [],
+                });
+                return snap;
+            }
+        };
+        // Create the language service proxy with position remapping
+        const proxy = createProxy(ts, info.languageService, cache, project);
+        config.logger.info("Plugin loaded");
+        return proxy;
+    }
+    return { create };
+};

package/license.txt

@@ -0,0 +1,8 @@
+Copyright 2025 Dief Bell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@boperators/plugin-ts-language-server",
+	"version": "0.1.0",
+	"license": "MIT",
+	"description": "TypeScript Language Server plugin for boperators - IDE support with source mapping.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/DiefBell/boperators",
+		"directory": "plugins/ts-language-server"
+	},
+	"homepage": "https://github.com/DiefBell/boperators/tree/main/plugins/ts-language-server",
+	"type": "commonjs",
+	"main": "./dist/index.js",
+	"keywords": [
+		"boperators",
+		"typescript",
+		"operator",
+		"overload",
+		"operator-overloading",
+		"language-server",
+		"tsserver",
+		"ide"
+	],
+	"scripts": {
+		"build": "tsc",
+		"watch": "tsc --watch",
+		"prepublish": "bun run build"
+	},
+	"files": [
+		"package.json",
+		"README.md",
+		"license.txt",
+		"dist"
+	],
+	"peerDependencies": {
+		"boperators": "0.1.0",
+		"typescript": ">=5.0.0 <5.10.0"
+	}
+}