@razdolbai/merls 0.1.0

package/dist/test/fixture-corpus.test.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFixtureCorpusTest = runFixtureCorpusTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const validFixturePaths = [
+    "test/fixtures/valid/merlin32-linkscript.asm",
+    "test/fixtures/valid/merlin32-main-6502.asm"
+];
+const invalidFixturePaths = [
+    "test/fixtures/invalid/65816-bank-ops.asm",
+    "test/fixtures/invalid/65816-long-addressing.asm"
+];
+function runFixtureCorpusTest() {
+    for (const fixturePath of validFixturePaths) {
+        const absolutePath = node_path_1.default.resolve(process.cwd(), fixturePath);
+        strict_1.default.equal(node_fs_1.default.existsSync(absolutePath), true, `${fixturePath} should exist`);
+        const content = node_fs_1.default.readFileSync(absolutePath, "utf8");
+        strict_1.default.match(content, /Source: apple2accumulator\/merlin32/);
+        strict_1.default.ok(content.trim().length > 0, `${fixturePath} should not be empty`);
+    }
+    for (const fixturePath of invalidFixturePaths) {
+        const absolutePath = node_path_1.default.resolve(process.cwd(), fixturePath);
+        strict_1.default.equal(node_fs_1.default.existsSync(absolutePath), true, `${fixturePath} should exist`);
+        const content = node_fs_1.default.readFileSync(absolutePath, "utf8");
+        strict_1.default.match(content, /Source: apple2accumulator\/merlin32/);
+        strict_1.default.match(content, /65816-only/);
+    }
+}

package/dist/test/hover.test.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHoverTest = runHoverTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+function decodeMessages(streamBuffer) {
+    const messages = [];
+    let buffer = streamBuffer;
+    for (;;) {
+        const separator = buffer.indexOf("\r\n\r\n");
+        if (separator === -1) {
+            return { messages, rest: buffer };
+        }
+        const header = buffer.slice(0, separator);
+        const match = /Content-Length: (\d+)/i.exec(header);
+        if (!match) {
+            throw new Error(`Missing Content-Length header: ${header}`);
+        }
+        const length = Number(match[1]);
+        const body = buffer.slice(separator + 4);
+        if (Buffer.byteLength(body, "utf8") < length) {
+            return { messages, rest: buffer };
+        }
+        messages.push(JSON.parse(body.slice(0, length)));
+        buffer = body.slice(length);
+    }
+}
+function positionOf(text, needle) {
+    const index = text.indexOf(needle);
+    strict_1.default.notEqual(index, -1, `expected to find ${needle}`);
+    const prefix = text.slice(0, index);
+    const lines = prefix.split("\n");
+    return {
+        line: lines.length - 1,
+        character: lines.at(-1)?.length ?? 0
+    };
+}
+function positionOfInMatch(text, needle, offset) {
+    const base = positionOf(text, needle);
+    return {
+        line: base.line,
+        character: base.character + offset
+    };
+}
+async function runHoverTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const mainPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const mainUri = `file://${mainPath.replace(/\\/g, "/")}`;
+    const text = node_fs_1.default.readFileSync(mainPath, "utf8");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let nextId = 1;
+    const pending = new Map();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        const decoded = decodeMessages(stdout);
+        stdout = decoded.rest;
+        for (const message of decoded.messages) {
+            if (message.id !== undefined) {
+                pending.get(message.id)?.(message);
+                pending.delete(message.id);
+            }
+        }
+    });
+    function sendRequest(method, params) {
+        const id = nextId++;
+        child.stdin.write(encodeMessage({
+            id,
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+        return new Promise((resolve) => {
+            pending.set(id, resolve);
+        });
+    }
+    function sendNotification(method, params) {
+        child.stdin.write(encodeMessage({
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+    }
+    try {
+        await sendRequest("initialize", {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: `file://${node_path_1.default.resolve(process.cwd()).replace(/\\/g, "/")}`
+        });
+        sendNotification("initialized", {});
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: mainUri,
+                languageId: "asm",
+                version: 1,
+                text
+            }
+        });
+        const opcodeHover = await sendRequest("textDocument/hover", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "adc (_tmp")
+        });
+        const opcodeResult = opcodeHover.result;
+        const opcodeText = typeof opcodeResult.contents === "string"
+            ? opcodeResult.contents
+            : opcodeResult.contents.value;
+        strict_1.default.equal(opcodeText.includes("adc"), true);
+        const directiveHover = await sendRequest("textDocument/hover", {
+            textDocument: { uri: mainUri },
+            position: positionOf(text, "DUM 0")
+        });
+        const directiveResult = directiveHover.result;
+        const directiveText = typeof directiveResult.contents === "string"
+            ? directiveResult.contents
+            : directiveResult.contents.value;
+        strict_1.default.equal(directiveText.includes("dum"), true);
+        const symbolHover = await sendRequest("textDocument/hover", {
+            textDocument: { uri: mainUri },
+            position: positionOfInMatch(text, "bpl GetKey", 4)
+        });
+        const symbolResult = symbolHover.result;
+        const symbolText = typeof symbolResult.contents === "string"
+            ? symbolResult.contents
+            : symbolResult.contents.value;
+        strict_1.default.equal(symbolText.includes("GetKey"), true);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/lexer.test.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLexerTest = runLexerTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const lexer_1 = require("../src/asm/lexer");
+function summarizeTokens(tokens) {
+    return tokens.map((token) => [token.kind, token.lexeme]);
+}
+function findLine(lines, source) {
+    const line = lines.find((candidate) => candidate.text === source);
+    strict_1.default.ok(line, `expected to find line: ${source}`);
+    return line;
+}
+function runLexerTest() {
+    const mainFixturePath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const linkFixturePath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-linkscript.asm");
+    const mainFixture = node_fs_1.default.readFileSync(mainFixturePath, "utf8");
+    const linkFixture = node_fs_1.default.readFileSync(linkFixturePath, "utf8");
+    const mainLines = (0, lexer_1.lexSource)(mainFixture).lines;
+    const linkLines = (0, lexer_1.lexSource)(linkFixture).lines;
+    strict_1.default.deepEqual(summarizeTokens(findLine(mainLines, "; Source: apple2accumulator/merlin32").tokens), [["comment", "; Source: apple2accumulator/merlin32"]]);
+    strict_1.default.deepEqual(summarizeTokens(findLine(mainLines, "TEXT    =   $FB39").tokens), [
+        ["label", "TEXT"],
+        ["expressionOperator", "="],
+        ["numericLiteral", "$FB39"]
+    ]);
+    strict_1.default.deepEqual(summarizeTokens(findLine(mainLines, "        DUM 0").tokens), [
+        ["directive", "DUM"],
+        ["numericLiteral", "0"]
+    ]);
+    strict_1.default.deepEqual(summarizeTokens(findLine(mainLines, "        adc ($80,x)").tokens), [
+        ["mnemonic", "adc"],
+        ["expressionOperator", "("],
+        ["numericLiteral", "$80"],
+        ["expressionOperator", ","],
+        ["identifier", "x"],
+        ["expressionOperator", ")"]
+    ]);
+    strict_1.default.deepEqual(summarizeTokens(findLine(mainLines, "GetKey  ldx $C000").tokens), [
+        ["label", "GetKey"],
+        ["mnemonic", "ldx"],
+        ["numericLiteral", "$C000"]
+    ]);
+    strict_1.default.deepEqual(summarizeTokens(findLine(linkLines, "    asm \"merlin32-main-6502.asm\"").tokens), [
+        ["directive", "asm"],
+        ["string", "\"merlin32-main-6502.asm\""]
+    ]);
+}

package/dist/test/line-parser.test.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLineParserTest = runLineParserTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const parser_1 = require("../src/asm/parser");
+function runLineParserTest() {
+    const source = [
+        "TEXT    =   $FB39",
+        "        adc (_tmp+dum1+1,x)",
+        "dum0    ds  1",
+        "        hex 2C",
+        "        adc ("
+    ].join("\n");
+    const lines = (0, parser_1.parseSourceLines)(source);
+    strict_1.default.deepEqual(lines[0], {
+        shape: "equate",
+        text: "TEXT    =   $FB39",
+        label: "TEXT",
+        expression: {
+            kind: "numericLiteral",
+            value: "$FB39"
+        }
+    });
+    strict_1.default.deepEqual(lines[1], {
+        shape: "instruction",
+        text: "        adc (_tmp+dum1+1,x)",
+        label: null,
+        mnemonic: "adc",
+        operand: {
+            immediate: false,
+            indirect: true,
+            indexRegister: "x",
+            expression: {
+                kind: "binary",
+                operator: "+",
+                left: {
+                    kind: "binary",
+                    operator: "+",
+                    left: { kind: "identifier", value: "_tmp" },
+                    right: { kind: "identifier", value: "dum1" }
+                },
+                right: { kind: "numericLiteral", value: "1" }
+            }
+        }
+    });
+    strict_1.default.deepEqual(lines[2], {
+        shape: "directive",
+        text: "dum0    ds  1",
+        label: "dum0",
+        directive: "ds",
+        operand: {
+            kind: "numericLiteral",
+            value: "1"
+        }
+    });
+    strict_1.default.deepEqual(lines[3], {
+        shape: "data",
+        text: "        hex 2C",
+        label: null,
+        directive: "hex",
+        payload: "2C"
+    });
+    strict_1.default.equal(lines[4]?.shape, "malformed");
+}

package/dist/test/local-labels.test.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLocalLabelScopeTest = runLocalLabelScopeTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const document_1 = require("../src/asm/document");
+const local_labels_1 = require("../src/asm/local-labels");
+function runLocalLabelScopeTest() {
+    const fixturePath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const source = node_fs_1.default.readFileSync(fixturePath, "utf8");
+    const document = (0, document_1.parseDocument)(source);
+    const scope = (0, local_labels_1.resolveLocalLabels)(document);
+    strict_1.default.deepEqual(scope.definitions.get("]loop@69"), {
+        name: "]loop",
+        line: 71,
+        anchor: "GetKey",
+        qualifiedName: "]loop@69"
+    });
+    strict_1.default.deepEqual(scope.references.get("]loop@73"), {
+        name: "]loop",
+        line: 73,
+        anchor: "GetKey",
+        qualifiedName: "]loop@69",
+        targetLine: 71
+    });
+    strict_1.default.deepEqual(scope.definitions.get(":err@69"), {
+        name: ":err",
+        line: 82,
+        anchor: "GetKey",
+        qualifiedName: ":err@69"
+    });
+    strict_1.default.deepEqual(scope.references.get(":good@81"), {
+        name: ":good",
+        line: 81,
+        anchor: "GetKey",
+        qualifiedName: ":good@69",
+        targetLine: 84
+    });
+}

package/dist/test/metadata.test.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMetadataTableTest = runMetadataTableTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const metadata_1 = require("../src/asm/metadata");
+function runMetadataTableTest() {
+    strict_1.default.equal(metadata_1.opcodeTable.size, 56);
+    strict_1.default.deepEqual(metadata_1.opcodeTable.get("lda")?.modes, [
+        "immediate",
+        "zeroPage",
+        "zeroPageX",
+        "absolute",
+        "absoluteX",
+        "absoluteY",
+        "indexedIndirect",
+        "indirectIndexed"
+    ]);
+    strict_1.default.equal(metadata_1.opcodeTable.has("mvn"), false);
+    strict_1.default.equal(metadata_1.directiveTable.get("org")?.supported, true);
+    strict_1.default.equal(metadata_1.directiveTable.get("dum")?.supported, true);
+    strict_1.default.equal(metadata_1.directiveTable.get("xc")?.supported, false);
+    strict_1.default.equal(metadata_1.directiveTable.get("mx")?.supported, false);
+    strict_1.default.equal(metadata_1.directiveTable.get("put")?.kind, "include");
+}

package/dist/test/publish-diagnostics.test.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPublishDiagnosticsTest = runPublishDiagnosticsTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+function decodeMessages(streamBuffer) {
+    const messages = [];
+    let buffer = streamBuffer;
+    for (;;) {
+        const separator = buffer.indexOf("\r\n\r\n");
+        if (separator === -1) {
+            return { messages, rest: buffer };
+        }
+        const header = buffer.slice(0, separator);
+        const match = /Content-Length: (\d+)/i.exec(header);
+        if (!match) {
+            throw new Error(`Missing Content-Length header: ${header}`);
+        }
+        const length = Number(match[1]);
+        const body = buffer.slice(separator + 4);
+        if (Buffer.byteLength(body, "utf8") < length) {
+            return { messages, rest: buffer };
+        }
+        messages.push(JSON.parse(body.slice(0, length)));
+        buffer = body.slice(length);
+    }
+}
+async function runPublishDiagnosticsTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const documentPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/invalid/publish-diagnostics.asm");
+    const documentUri = `file://${documentPath.replace(/\\/g, "/")}`;
+    const brokenText = ["dup     equ 1", "        lda missing", "dup     equ 2", "        adc ("].join("\n");
+    const fixedText = ["dup     equ 1", "        lda dup", "        adc #1"].join("\n");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let nextId = 1;
+    const pending = new Map();
+    const diagnosticWaiters = [];
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        const decoded = decodeMessages(stdout);
+        stdout = decoded.rest;
+        for (const message of decoded.messages) {
+            if (message.id !== undefined) {
+                pending.get(message.id)?.(message);
+                pending.delete(message.id);
+                continue;
+            }
+            if (message.method === "textDocument/publishDiagnostics") {
+                const params = message.params;
+                const waiter = diagnosticWaiters.shift();
+                waiter?.(params);
+            }
+        }
+    });
+    function sendRequest(method, params) {
+        const id = nextId++;
+        child.stdin.write(encodeMessage({
+            id,
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+        return new Promise((resolve) => {
+            pending.set(id, resolve);
+        });
+    }
+    function sendNotification(method, params) {
+        child.stdin.write(encodeMessage({
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+    }
+    function waitForDiagnostics() {
+        return new Promise((resolve) => {
+            diagnosticWaiters.push(resolve);
+        });
+    }
+    try {
+        await sendRequest("initialize", {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: `file://${node_path_1.default.resolve(process.cwd()).replace(/\\/g, "/")}`
+        });
+        sendNotification("initialized", {});
+        const openedDiagnostics = waitForDiagnostics();
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: documentUri,
+                languageId: "asm",
+                version: 1,
+                text: brokenText
+            }
+        });
+        const firstPublish = await openedDiagnostics;
+        strict_1.default.equal(firstPublish.uri, documentUri);
+        strict_1.default.equal(firstPublish.diagnostics.some((diagnostic) => diagnostic.message.includes("Unresolved reference missing") &&
+            diagnostic.severity === 1 &&
+            diagnostic.range.start.line === 1), true);
+        strict_1.default.equal(firstPublish.diagnostics.some((diagnostic) => diagnostic.message.includes("Duplicate symbol dup") &&
+            diagnostic.severity === 1 &&
+            diagnostic.range.start.line === 2), true);
+        strict_1.default.equal(firstPublish.diagnostics.some((diagnostic) => diagnostic.message.includes("expected expression token") &&
+            diagnostic.severity === 1 &&
+            diagnostic.range.start.line === 3), true);
+        const changedDiagnostics = waitForDiagnostics();
+        sendNotification("textDocument/didChange", {
+            textDocument: {
+                uri: documentUri,
+                version: 2
+            },
+            contentChanges: [
+                {
+                    text: fixedText
+                }
+            ]
+        });
+        const secondPublish = await changedDiagnostics;
+        strict_1.default.equal(secondPublish.uri, documentUri);
+        strict_1.default.deepEqual(secondPublish.diagnostics, []);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/run-tests.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bootstrap_test_1 = require("./bootstrap.test");
+const cli_contract_test_1 = require("./cli-contract.test");
+const coc_config_test_1 = require("./coc-config.test");
+const completion_test_1 = require("./completion.test");
+const definition_references_test_1 = require("./definition-references.test");
+const diagnostics_test_1 = require("./diagnostics.test");
+const document_model_test_1 = require("./document-model.test");
+const document_symbol_test_1 = require("./document-symbol.test");
+const expression_test_1 = require("./expression.test");
+const fixture_corpus_test_1 = require("./fixture-corpus.test");
+const hover_test_1 = require("./hover.test");
+const lexer_test_1 = require("./lexer.test");
+const line_parser_test_1 = require("./line-parser.test");
+const local_labels_test_1 = require("./local-labels.test");
+const metadata_test_1 = require("./metadata.test");
+const publish_diagnostics_test_1 = require("./publish-diagnostics.test");
+const server_initialize_test_1 = require("./server-initialize.test");
+const server_entrypoint_test_1 = require("./server-entrypoint.test");
+const symbols_test_1 = require("./symbols.test");
+const syntax_shape_test_1 = require("./syntax-shape.test");
+const workspace_test_1 = require("./workspace.test");
+const workspace_symbol_test_1 = require("./workspace-symbol.test");
+const tests = [
+    {
+        name: "workspace bootstrap exposes the project name",
+        run: bootstrap_test_1.runBootstrapTest
+    },
+    {
+        name: "cli contract exposes a packaged stdio entrypoint",
+        run: cli_contract_test_1.runCliContractTest
+    },
+    {
+        name: "coc.nvim example targets the packaged stdio CLI contract",
+        run: coc_config_test_1.runCocConfigTest
+    },
+    {
+        name: "server entrypoint exposes callable startup helpers",
+        run: server_entrypoint_test_1.runServerEntrypointTest
+    },
+    {
+        name: "server process answers initialize",
+        run: server_initialize_test_1.runInitializeHandshakeTest
+    },
+    {
+        name: "positive fixture corpus includes upstream Merlin32 samples",
+        run: fixture_corpus_test_1.runFixtureCorpusTest
+    },
+    {
+        name: "shared opcode and directive metadata covers 6502 and Merlin syntax",
+        run: metadata_test_1.runMetadataTableTest
+    },
+    {
+        name: "token kinds and line shapes cover Merlin syntax categories",
+        run: syntax_shape_test_1.runSyntaxShapeTest
+    },
+    {
+        name: "lexer tokenizes fixture comments labels mnemonics directives and literals",
+        run: lexer_test_1.runLexerTest
+    },
+    {
+        name: "expression parser handles numeric forms modifiers arithmetic and indexed operands",
+        run: expression_test_1.runExpressionTest
+    },
+    {
+        name: "line parser recognizes equates instructions directives data and malformed lines",
+        run: line_parser_test_1.runLineParserTest
+    },
+    {
+        name: "document model preserves line structure and tolerates malformed lines",
+        run: document_model_test_1.runDocumentModelTest
+    },
+    {
+        name: "symbol collection indexes labels equates and named data definitions",
+        run: symbols_test_1.runSymbolsTest
+    },
+    {
+        name: "local label scope resolves Merlin local definitions and references",
+        run: local_labels_test_1.runLocalLabelScopeTest
+    },
+    {
+        name: "workspace indexing follows Merlin include directives and merges symbols",
+        run: workspace_test_1.runWorkspaceGraphTest
+    },
+    {
+        name: "diagnostics report duplicates unresolved refs malformed lines and unsupported 65816 syntax",
+        run: diagnostics_test_1.runDiagnosticsTest
+    },
+    {
+        name: "server returns document symbols for Merlin labels equates and data definitions",
+        run: document_symbol_test_1.runDocumentSymbolTest
+    },
+    {
+        name: "server returns workspace symbols across open Merlin documents",
+        run: workspace_symbol_test_1.runWorkspaceSymbolTest
+    },
+    {
+        name: "server resolves definitions and references for Merlin symbols",
+        run: definition_references_test_1.runDefinitionReferencesTest
+    },
+    {
+        name: "server returns hover information for opcodes directives and symbols",
+        run: hover_test_1.runHoverTest
+    },
+    {
+        name: "server returns opcode directive and symbol completions",
+        run: completion_test_1.runCompletionTest
+    },
+    {
+        name: "server publishes and clears diagnostics for open Merlin documents",
+        run: publish_diagnostics_test_1.runPublishDiagnosticsTest
+    }
+];
+async function main() {
+    let failures = 0;
+    for (const test of tests) {
+        try {
+            await test.run();
+            console.log(`PASS ${test.name}`);
+        }
+        catch (error) {
+            failures += 1;
+            console.error(`FAIL ${test.name}`);
+            console.error(error);
+        }
+    }
+    if (failures > 0) {
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/test/server-entrypoint.test.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runServerEntrypointTest = runServerEntrypointTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const server_1 = require("../src/server");
+function runServerEntrypointTest() {
+    strict_1.default.equal(typeof server_1.startServer, "function");
+    const connection = (0, server_1.createServerConnection)();
+    strict_1.default.equal(typeof connection.listen, "function");
+    connection.dispose();
+}