tailwint 1.0.0

package/dist/index.test.js

@@ -0,0 +1,410 @@
+/**
+ * Tests for applyEdits from tailwint/edits.ts
+ */
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { applyEdits } from "./edits.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Shorthand to build a TextEdit */
+function edit(startLine, startChar, endLine, endChar, newText) {
+    return {
+        range: {
+            start: { line: startLine, character: startChar },
+            end: { line: endLine, character: endChar },
+        },
+        newText,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("applyEdits", () => {
+    // ---- Basic operations ----
+    it("returns content unchanged for empty edits array", () => {
+        assert.equal(applyEdits("hello", []), "hello");
+    });
+    it("returns content unchanged for empty string input with no edits", () => {
+        assert.equal(applyEdits("", []), "");
+    });
+    it("replaces a single word", () => {
+        assert.equal(applyEdits("flex-shrink-0", [edit(0, 0, 0, 13, "shrink-0")]), "shrink-0");
+    });
+    it("inserts text at the beginning", () => {
+        assert.equal(applyEdits("world", [edit(0, 0, 0, 0, "hello ")]), "hello world");
+    });
+    it("inserts text at the end", () => {
+        assert.equal(applyEdits("hello", [edit(0, 5, 0, 5, " world")]), "hello world");
+    });
+    it("deletes text (empty newText)", () => {
+        assert.equal(applyEdits("hello world", [edit(0, 5, 0, 11, "")]), "hello");
+    });
+    // ---- Multiple edits on the same line ----
+    it("applies two non-overlapping edits on the same line", () => {
+        const content = "z-[1] flex-shrink-0";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 5, "z-1"),
+            edit(0, 6, 0, 19, "shrink-0"),
+        ]);
+        assert.equal(result, "z-1 shrink-0");
+    });
+    it("applies edits regardless of input order (unsorted)", () => {
+        const content = "z-[1] flex-shrink-0";
+        // Provide edits in reverse order — should still work
+        const result = applyEdits(content, [
+            edit(0, 6, 0, 19, "shrink-0"),
+            edit(0, 0, 0, 5, "z-1"),
+        ]);
+        assert.equal(result, "z-1 shrink-0");
+    });
+    it("applies three edits on the same line", () => {
+        const content = "z-[1] flex-shrink-0 min-w-[200px]";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 5, "z-1"),
+            edit(0, 6, 0, 19, "shrink-0"),
+            edit(0, 20, 0, 33, "min-w-50"),
+        ]);
+        assert.equal(result, "z-1 shrink-0 min-w-50");
+    });
+    // ---- Adjacent edits (shared boundary) ----
+    it("handles adjacent edits that share a boundary", () => {
+        const content = "aabbcc";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 2, "AA"),
+            edit(0, 2, 0, 4, "BB"),
+            edit(0, 4, 0, 6, "CC"),
+        ]);
+        assert.equal(result, "AABBCC");
+    });
+    it("handles adjacent insert-then-replace at same position", () => {
+        // Two edits at position 0: first is a zero-width insert, second replaces chars 0-2
+        // This is ambiguous — cursor advances past the first edit's end (0),
+        // so the second edit at start=0 would have start < cursor after the first.
+        // Current implementation: second edit's content replaces, but start <= cursor
+        // means the slice between them is empty.
+        const content = "abc";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 0, "X"), // insert X at position 0
+            edit(0, 0, 0, 1, "Y"), // replace 'a' with Y
+        ]);
+        // Both edits start at offset 0. After sorting, they're in input order (stable sort?).
+        // First edit: start=0, end=0 → inserts "X", cursor=0
+        // Second edit: start=0 >= cursor(0), end=1 → but start is NOT > cursor, so no gap slice
+        // Result: "X" + "Y" + "bc" = "XYbc"
+        // This might be surprising — the "a" is deleted by the second edit but "X" is also inserted.
+        // Let's just verify the actual behavior.
+        assert.equal(result, "XYbc");
+    });
+    // ---- Multi-line edits ----
+    it("replaces across multiple lines", () => {
+        const content = "line1\nline2\nline3";
+        const result = applyEdits(content, [
+            edit(0, 3, 2, 3, "REPLACED"),
+        ]);
+        assert.equal(result, "linREPLACEDe3");
+    });
+    it("applies edits on different lines", () => {
+        const content = "aaa\nbbb\nccc";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 3, "AAA"),
+            edit(2, 0, 2, 3, "CCC"),
+        ]);
+        assert.equal(result, "AAA\nbbb\nCCC");
+    });
+    it("deletes an entire line including newline", () => {
+        const content = "keep\ndelete\nkeep";
+        const result = applyEdits(content, [
+            edit(1, 0, 2, 0, ""),
+        ]);
+        assert.equal(result, "keep\nkeep");
+    });
+    it("inserts a new line", () => {
+        const content = "line1\nline3";
+        const result = applyEdits(content, [
+            edit(1, 0, 1, 0, "line2\n"),
+        ]);
+        assert.equal(result, "line1\nline2\nline3");
+    });
+    // ---- Edge cases: out-of-bounds ----
+    it("handles edit past end of file (line beyond last)", () => {
+        const content = "hello";
+        const result = applyEdits(content, [
+            edit(5, 0, 5, 0, " world"),
+        ]);
+        // Line 5 doesn't exist — toOffset clamps to content.length
+        assert.equal(result, "hello world");
+    });
+    it("handles edit with character past end of line", () => {
+        const content = "hi";
+        const result = applyEdits(content, [
+            edit(0, 100, 0, 100, "!"),
+        ]);
+        // Character 100 on a 2-char line clamps to position 2
+        assert.equal(result, "hi!");
+    });
+    // ---- Edge cases: empty content ----
+    it("inserts into empty string", () => {
+        assert.equal(applyEdits("", [edit(0, 0, 0, 0, "hello")]), "hello");
+    });
+    it("handles edit on empty string with out-of-bounds range", () => {
+        assert.equal(applyEdits("", [edit(0, 0, 0, 10, "hello")]), "hello");
+    });
+    // ---- CRLF line endings ----
+    it("handles CRLF line endings", () => {
+        const content = "line1\r\nline2\r\nline3";
+        // With CRLF, \r is a regular character — only \n triggers new line offset.
+        // So line 1 starts after the \n at position 7 (l-i-n-e-1-\r-\n = 7 chars).
+        // "line2" on line 1 starts at offset 7, char 0.
+        const result = applyEdits(content, [
+            edit(1, 0, 1, 5, "LINE2"),
+        ]);
+        assert.equal(result, "line1\r\nLINE2\r\nline3");
+    });
+    it("CRLF: replacing including \\r works correctly", () => {
+        const content = "aa\r\nbb";
+        // Line 0 is "aa\r", line 1 starts at offset 4
+        // Replace from (0,2) to (1,0) — should delete "\r\n"
+        const result = applyEdits(content, [
+            edit(0, 2, 1, 0, ""),
+        ]);
+        assert.equal(result, "aabb");
+    });
+    // ---- Unicode and emoji ----
+    it("handles unicode content correctly", () => {
+        const content = "café";
+        // "café" — the é is one JS char (U+00E9)
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 4, "CAFÉ"),
+        ]);
+        assert.equal(result, "CAFÉ");
+    });
+    it("handles emoji content", () => {
+        // "hi 👋 there" — 👋 is 2 JS chars (surrogate pair)
+        const content = "hi 👋 there";
+        // LSP character offsets use UTF-16 code units, same as JS string length
+        // "hi " = 3 chars, "👋" = 2 chars, " there" = 6 chars
+        // Replace "👋" (chars 3-5) with "🎉" (also 2 chars)
+        const result = applyEdits(content, [
+            edit(0, 3, 0, 5, "🎉"),
+        ]);
+        assert.equal(result, "hi 🎉 there");
+    });
+    // ---- Overlapping edits (potentially dangerous) ----
+    it("overlapping edits: second edit starts inside first edit's range", () => {
+        const content = "abcdef";
+        // Edit 1: replace chars 1-4 ("bcd") with "X"
+        // Edit 2: replace chars 2-5 ("cde") with "Y"
+        // After sorting: edit1 (start=1) comes first, cursor advances to 4
+        // edit2 (start=2) has start < cursor(4), so no gap, but edit2's
+        // newText "Y" is still pushed and cursor goes to 5.
+        // This produces: "a" + "X" + "Y" + "f" = "aXYf"
+        // The overlap means chars 2-4 are "deleted twice" — 'c' and 'd' appear
+        // in both edit ranges. The implementation doesn't detect this.
+        const result = applyEdits(content, [
+            edit(0, 1, 0, 4, "X"),
+            edit(0, 2, 0, 5, "Y"),
+        ]);
+        assert.equal(result, "aXYf");
+    });
+    // ---- Realistic Tailwind scenarios ----
+    it("fixes className with multiple bracket notations", () => {
+        const content = `<div className="w-[1200px] h-[630px] overflow-hidden">`;
+        // w-[1200px] = chars 16-26 (end exclusive), h-[630px] = chars 27-36 (end exclusive)
+        const result = applyEdits(content, [
+            edit(0, 16, 0, 26, "w-300"),
+            edit(0, 27, 0, 36, "h-157.5"),
+        ]);
+        assert.equal(result, `<div className="w-300 h-157.5 overflow-hidden">`);
+    });
+    it("fixes multi-line JSX with edits on different lines", () => {
+        const content = [
+            `<div`,
+            `  className="z-[1] flex-shrink-0"`,
+            `  style={{}}`,
+            `/>`,
+        ].join("\n");
+        // z-[1] starts at char 13 on line 1, flex-shrink-0 at char 19
+        const result = applyEdits(content, [
+            edit(1, 13, 1, 18, "z-1"),
+            edit(1, 19, 1, 32, "shrink-0"),
+        ]);
+        const expected = [
+            `<div`,
+            `  className="z-1 shrink-0"`,
+            `  style={{}}`,
+            `/>`,
+        ].join("\n");
+        assert.equal(result, expected);
+    });
+    // ---- Trailing newline ----
+    it("preserves trailing newline", () => {
+        const content = "hello\n";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 5, "world"),
+        ]);
+        assert.equal(result, "world\n");
+    });
+    it("edit on the empty last line after trailing newline", () => {
+        const content = "hello\n";
+        // Line 1 exists (empty, after the \n). Insert there.
+        const result = applyEdits(content, [
+            edit(1, 0, 1, 0, "world"),
+        ]);
+        assert.equal(result, "hello\nworld");
+    });
+    // ---- Stress: many edits ----
+    it("handles 50 edits across 50 lines", () => {
+        const lines = Array.from({ length: 50 }, (_, i) => `line-${i}-old`);
+        const content = lines.join("\n");
+        const edits = lines.map((_, i) => {
+            const old = `line-${i}-old`;
+            return edit(i, 0, i, old.length, `line-${i}-new`);
+        });
+        const result = applyEdits(content, edits);
+        const expected = Array.from({ length: 50 }, (_, i) => `line-${i}-new`).join("\n");
+        assert.equal(result, expected);
+    });
+    // ---- Zero-width replacements at various positions ----
+    it("multiple zero-width inserts at different positions", () => {
+        const content = "ac";
+        const result = applyEdits(content, [
+            edit(0, 1, 0, 1, "b"), // insert 'b' between 'a' and 'c'
+        ]);
+        assert.equal(result, "abc");
+    });
+    it("multiple zero-width inserts at the same position", () => {
+        // Two inserts at position 1 — both have start=end=1
+        // After sorting they're both at offset 1, first insert "X", cursor stays at 1,
+        // second insert "Y", cursor stays at 1
+        const content = "ac";
+        const result = applyEdits(content, [
+            edit(0, 1, 0, 1, "X"),
+            edit(0, 1, 0, 1, "Y"),
+        ]);
+        // Both inserts land at offset 1: "a" + "X" + "Y" + "c"
+        assert.equal(result, "aXYc");
+    });
+    // ---- Edit that replaces entire content ----
+    it("replaces entire content with single edit", () => {
+        const content = "old content\nwith multiple\nlines";
+        const result = applyEdits(content, [
+            edit(0, 0, 2, 5, "new"),
+        ]);
+        assert.equal(result, "new");
+    });
+    // ---- Only newlines ----
+    it("handles content that is only newlines", () => {
+        const content = "\n\n\n";
+        const result = applyEdits(content, [
+            edit(1, 0, 1, 0, "inserted"),
+        ]);
+        assert.equal(result, "\ninserted\n\n");
+    });
+    // ---- Probing for subtle bugs ----
+    it("edit where replacement is longer than original (grows the line)", () => {
+        const content = "ab";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 1, "AAAA"), // replace 'a' (1 char) with 'AAAA' (4 chars)
+        ]);
+        assert.equal(result, "AAAAb");
+    });
+    it("edit where replacement is shorter than original (shrinks the line)", () => {
+        const content = "aaaab";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 4, "X"), // replace 'aaaa' (4 chars) with 'X' (1 char)
+        ]);
+        assert.equal(result, "Xb");
+    });
+    it("two edits where first shrinks and second uses original offsets", () => {
+        // This is the key scenario: after first edit shrinks, do second edit's
+        // original offsets still work correctly?
+        const content = "aaa bbb ccc";
+        // Replace 'aaa' (0-3) with 'x', replace 'ccc' (8-11) with 'z'
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 3, "x"),
+            edit(0, 8, 0, 11, "z"),
+        ]);
+        // Since we use original offsets: "x" + content[3:8]=" bbb " + "z"
+        assert.equal(result, "x bbb z");
+    });
+    it("two edits where first grows and second uses original offsets", () => {
+        const content = "a b c";
+        const result = applyEdits(content, [
+            edit(0, 0, 0, 1, "XXXX"), // 'a' → 'XXXX'
+            edit(0, 4, 0, 5, "ZZZZ"), // 'c' → 'ZZZZ'
+        ]);
+        assert.equal(result, "XXXX b ZZZZ");
+    });
+    it("edit that deletes everything and inserts nothing", () => {
+        const content = "hello\nworld";
+        const result = applyEdits(content, [
+            edit(0, 0, 1, 5, ""),
+        ]);
+        assert.equal(result, "");
+    });
+    it("edit range with end before start (invalid range)", () => {
+        // Pathological: end offset < start offset after conversion
+        // toOffset(0,5) = 5, toOffset(0,2) = 2 → start=5, end=2
+        // After sort, this edit has start=5 > cursor=0, so we'd push content[0:5]
+        // then push newText, then cursor=2 which is < 5...
+        // This should behave oddly. Let's see what happens.
+        const content = "abcdef";
+        const result = applyEdits(content, [
+            edit(0, 5, 0, 2, "X"), // start > end
+        ]);
+        // start=5, end=2: push "abcde" (0-5), push "X", cursor=2
+        // cursor(2) < content.length(6), push content[2:] = "cdef"
+        // Result: "abcdeXcdef" — the reversed range causes duplication
+        assert.equal(result, "abcdeXcdef");
+    });
+    it("consecutive edits that delete and insert on multi-line content", () => {
+        const content = "line1\nline2\nline3\nline4\nline5";
+        // Delete line2, replace line4 with NEW4
+        const result = applyEdits(content, [
+            edit(1, 0, 2, 0, ""), // delete "line2\n"
+            edit(3, 0, 3, 5, "NEW4"), // replace "line4" with "NEW4"
+        ]);
+        assert.equal(result, "line1\nline3\nNEW4\nline5");
+    });
+    it("edit at exact end of content (no trailing newline)", () => {
+        const content = "end";
+        const result = applyEdits(content, [
+            edit(0, 3, 0, 3, "!"),
+        ]);
+        assert.equal(result, "end!");
+    });
+    it("many edits on the same line, varying replacement lengths", () => {
+        // Simulates what the LSP might do with a class like:
+        // "z-[1] flex-shrink-0 bg-primary/[0.06] min-w-[200px] h-[1px]"
+        const content = `className="z-[1] flex-shrink-0 bg-primary/[0.06] min-w-[200px] h-[1px]"`;
+        const result = applyEdits(content, [
+            edit(0, 11, 0, 16, "z-1"), // z-[1] → z-1
+            edit(0, 17, 0, 30, "shrink-0"), // flex-shrink-0 → shrink-0
+            edit(0, 31, 0, 48, "bg-primary/6"), // bg-primary/[0.06] → bg-primary/6
+            edit(0, 49, 0, 62, "min-w-50"), // min-w-[200px] → min-w-50
+            edit(0, 63, 0, 70, "h-px"), // h-[1px] → h-px
+        ]);
+        assert.equal(result, `className="z-1 shrink-0 bg-primary/6 min-w-50 h-px"`);
+    });
+    it("single char file with replacement", () => {
+        assert.equal(applyEdits("x", [edit(0, 0, 0, 1, "y")]), "y");
+    });
+    it("edit newText contains newlines (splitting a line)", () => {
+        const content = "before after";
+        const result = applyEdits(content, [
+            edit(0, 6, 0, 7, "\n"), // replace space with newline
+        ]);
+        assert.equal(result, "before\nafter");
+    });
+    it("edit that joins lines by replacing newline with space", () => {
+        const content = "before\nafter";
+        // The \n is at the end of line 0 (char 6 = the newline itself?).
+        // Actually, line 0 is "before", line 1 is "after".
+        // Range (0,6) to (1,0) covers just the \n character.
+        const result = applyEdits(content, [
+            edit(0, 6, 1, 0, " "),
+        ]);
+        assert.equal(result, "before after");
+    });
+});

package/dist/lsp.d.ts

@@ -0,0 +1,19 @@
+/**
+ * LSP client — spawns tailwindcss-language-server over stdio and speaks JSON-RPC.
+ */
+export declare const diagnosticsReceived: Map<string, any[]>;
+export declare let projectReady: boolean;
+/** Reset module state between runs (for programmatic multi-run usage). */
+export declare function resetState(): void;
+/** Returns a promise that resolves when @/tailwindCSS/projectInitialized fires. */
+export declare function waitForProjectReady(timeoutMs?: number): Promise<void>;
+/** Returns a promise that resolves when diagnosticsReceived.size >= count. */
+export declare function waitForDiagnosticCount(count: number, timeoutMs?: number): Promise<void>;
+/** Returns a promise that resolves when diagnostics are published for a specific URI. */
+export declare function waitForDiagnostic(uri: string, timeoutMs?: number): Promise<any[]>;
+export declare function startServer(root: string): void;
+export declare function send(method: string, params: object): Promise<any>;
+export declare function notify(method: string, params: object): void;
+export declare function shutdown(): Promise<void>;
+export declare function fileUri(absPath: string): string;
+export declare function langId(filePath: string): string;

package/dist/lsp.js

@@ -0,0 +1,239 @@
+/**
+ * LSP client — spawns tailwindcss-language-server over stdio and speaks JSON-RPC.
+ */
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { existsSync } from "fs";
+const DEBUG = process.env.DEBUG === "1";
+let server;
+let msgId = 0;
+const chunks = [];
+let chunksLen = 0;
+const pending = new Map();
+export const diagnosticsReceived = new Map();
+export let projectReady = false;
+// ---------------------------------------------------------------------------
+// Event-driven waiters — resolved by processMessages, no polling
+// ---------------------------------------------------------------------------
+let projectReadyResolve = null;
+let diagTarget = 0;
+let diagTargetResolve = null;
+const diagWaiters = new Map();
+/** Reset module state between runs (for programmatic multi-run usage). */
+export function resetState() {
+    msgId = 0;
+    chunks.length = 0;
+    chunksLen = 0;
+    pending.clear();
+    diagnosticsReceived.clear();
+    projectReady = false;
+    projectReadyResolve = null;
+    diagTarget = 0;
+    diagTargetResolve = null;
+    diagWaiters.clear();
+}
+/** Returns a promise that resolves when @/tailwindCSS/projectInitialized fires. */
+export function waitForProjectReady(timeoutMs = 15_000) {
+    if (projectReady)
+        return Promise.resolve();
+    return new Promise((res, rej) => {
+        projectReadyResolve = res;
+        const timer = setTimeout(() => {
+            projectReadyResolve = null;
+            res(); // resolve anyway — don't block forever
+        }, timeoutMs);
+        // Clean up timer if resolved early
+        const origRes = res;
+        projectReadyResolve = () => { clearTimeout(timer); origRes(); };
+    });
+}
+/** Returns a promise that resolves when diagnosticsReceived.size >= count. */
+export function waitForDiagnosticCount(count, timeoutMs = 30_000) {
+    if (diagnosticsReceived.size >= count)
+        return Promise.resolve();
+    return new Promise((res) => {
+        diagTarget = count;
+        const timer = setTimeout(() => {
+            diagTargetResolve = null;
+            res();
+        }, timeoutMs);
+        diagTargetResolve = () => { clearTimeout(timer); res(); };
+    });
+}
+/** Returns a promise that resolves when diagnostics are published for a specific URI. */
+export function waitForDiagnostic(uri, timeoutMs = 10_000) {
+    // Clear stale entry so we wait for the server to re-publish
+    diagnosticsReceived.delete(uri);
+    return new Promise((res) => {
+        diagWaiters.set(uri, res);
+        setTimeout(() => {
+            if (diagWaiters.has(uri)) {
+                diagWaiters.delete(uri);
+                res([]);
+            }
+        }, timeoutMs);
+    });
+}
+// ---------------------------------------------------------------------------
+// JSON-RPC framing
+// ---------------------------------------------------------------------------
+function encode(obj) {
+    const body = JSON.stringify(obj);
+    return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+}
+function getRawBuf() {
+    if (chunks.length === 0)
+        return Buffer.alloc(0);
+    if (chunks.length === 1)
+        return chunks[0];
+    const buf = Buffer.concat(chunks, chunksLen);
+    chunks.length = 0;
+    chunks.push(buf);
+    return buf;
+}
+function setRawBuf(buf) {
+    chunks.length = 0;
+    if (buf.length > 0) {
+        chunks.push(buf);
+        chunksLen = buf.length;
+    }
+    else {
+        chunksLen = 0;
+    }
+}
+function processMessages() {
+    while (true) {
+        const rawBuf = getRawBuf();
+        if (rawBuf.length === 0)
+            break;
+        const str = rawBuf.toString("ascii", 0, Math.min(rawBuf.length, 256));
+        const headerEnd = str.indexOf("\r\n\r\n");
+        if (headerEnd === -1) {
+            setRawBuf(rawBuf);
+            break;
+        }
+        const headerBlock = str.slice(0, headerEnd);
+        const clMatch = headerBlock.match(/Content-Length:\s*(\d+)/i);
+        if (!clMatch) {
+            setRawBuf(rawBuf.subarray(headerEnd + 4));
+            continue;
+        }
+        const len = parseInt(clMatch[1], 10);
+        const bodyStart = headerEnd + 4;
+        if (rawBuf.length < bodyStart + len) {
+            setRawBuf(rawBuf);
+            break;
+        }
+        const body = rawBuf.subarray(bodyStart, bodyStart + len).toString("utf-8");
+        setRawBuf(rawBuf.subarray(bodyStart + len));
+        let msg;
+        try {
+            msg = JSON.parse(body);
+        }
+        catch {
+            continue;
+        }
+        if (DEBUG)
+            console.error(`<- ${msg.method || `response#${msg.id}`}`);
+        // Response to our request
+        if (msg.id != null && !msg.method && pending.has(msg.id)) {
+            const p = pending.get(msg.id);
+            pending.delete(msg.id);
+            if (msg.error)
+                p.reject(msg.error);
+            else
+                p.resolve(msg.result);
+            continue;
+        }
+        // Server-initiated requests — must respond
+        if (msg.id != null && msg.method) {
+            let result = null;
+            if (msg.method === "workspace/configuration") {
+                result = (msg.params?.items || []).map(() => ({}));
+            }
+            server.stdin.write(encode({ jsonrpc: "2.0", id: msg.id, result }));
+            continue;
+        }
+        // Published diagnostics
+        if (msg.method === "textDocument/publishDiagnostics" && msg.params) {
+            const uri = msg.params.uri;
+            const diags = msg.params.diagnostics || [];
+            diagnosticsReceived.set(uri, diags);
+            // Resolve URI-specific waiter
+            if (diagWaiters.has(uri)) {
+                const resolve = diagWaiters.get(uri);
+                diagWaiters.delete(uri);
+                resolve(diags);
+            }
+            // Resolve count-based waiter
+            if (diagTargetResolve && diagnosticsReceived.size >= diagTarget) {
+                const resolve = diagTargetResolve;
+                diagTargetResolve = null;
+                resolve();
+            }
+        }
+        // Tailwind project initialized
+        if (msg.method === "@/tailwindCSS/projectInitialized") {
+            projectReady = true;
+            if (projectReadyResolve) {
+                const resolve = projectReadyResolve;
+                projectReadyResolve = null;
+                resolve();
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Server lifecycle
+// ---------------------------------------------------------------------------
+function findLanguageServer(cwd) {
+    const local = resolve(cwd, "node_modules/.bin/tailwindcss-language-server");
+    return existsSync(local) ? local : "tailwindcss-language-server";
+}
+export function startServer(root) {
+    const bin = findLanguageServer(root);
+    server = spawn(bin, ["--stdio"], { stdio: ["pipe", "pipe", "pipe"] });
+    server.on("error", (err) => {
+        if (err.code === "ENOENT") {
+            console.error("\n  \x1b[38;5;203m\x1b[1mERROR\x1b[0m @tailwindcss/language-server not found.\n");
+            console.error("  Install it: npm install -D @tailwindcss/language-server\n");
+            process.exit(2);
+        }
+    });
+    server.stdout.on("data", (chunk) => {
+        chunks.push(chunk);
+        chunksLen += chunk.length;
+        processMessages();
+    });
+    server.stderr.on("data", (chunk) => {
+        if (DEBUG)
+            process.stderr.write(chunk);
+    });
+}
+export function send(method, params) {
+    const id = ++msgId;
+    return new Promise((res, rej) => {
+        pending.set(id, { resolve: res, reject: rej });
+        server.stdin.write(encode({ jsonrpc: "2.0", id, method, params }));
+    });
+}
+export function notify(method, params) {
+    server.stdin.write(encode({ jsonrpc: "2.0", method, params }));
+}
+export async function shutdown() {
+    await send("shutdown", {}).catch(() => { });
+    notify("exit", {});
+    server.kill();
+}
+export function fileUri(absPath) {
+    return `file://${absPath}`;
+}
+export function langId(filePath) {
+    if (filePath.endsWith(".css"))
+        return "css";
+    if (filePath.endsWith(".html") || filePath.endsWith(".vue") || filePath.endsWith(".svelte"))
+        return "html";
+    if (filePath.endsWith(".jsx"))
+        return "javascriptreact";
+    return "typescriptreact";
+}