@tui-sandbox/library 3.0.0 → 4.1.0

package/dist/browser/assets/index-Bf37MeF1.css

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2014 The xterm.js authors. All rights reserved.
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * https://github.com/chjj/term.js
+ * @license MIT
+ *
+ * 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.
+ *
+ * Originally forked from (with the author's permission):
+ *   Fabrice Bellard's javascript vt100 for jslinux:
+ *   http://bellard.org/jslinux/
+ *   Copyright (c) 2011 Fabrice Bellard
+ *   The original design remains. The terminal itself
+ *   has been extended to include xterm CSI codes, among
+ *   other features.
+ */.xterm{cursor:text;position:relative;user-select:none;-ms-user-select:none;-webkit-user-select:none}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{position:absolute;top:0;z-index:5}.xterm .xterm-helper-textarea{padding:0;border:0;margin:0;position:absolute;opacity:0;left:-9999em;top:0;width:0;height:0;z-index:-5;white-space:nowrap;overflow:hidden;resize:none}.xterm .composition-view{background:#000;color:#fff;display:none;position:absolute;white-space:nowrap;z-index:1}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{background-color:#000;overflow-y:scroll;cursor:default;position:absolute;right:0;left:0;top:0;bottom:0}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;left:0;top:0}.xterm .xterm-scroll-area{visibility:hidden}.xterm-char-measure-element{display:inline-block;visibility:hidden;position:absolute;top:0;left:-9999em;line-height:normal}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility:not(.debug),.xterm .xterm-message{position:absolute;left:0;top:0;bottom:0;right:0;z-index:10;color:transparent;pointer-events:none}.xterm .xterm-accessibility-tree:not(.debug) *::selection{color:transparent}.xterm .xterm-accessibility-tree{-webkit-user-select:text;user-select:text;white-space:pre}.xterm .live-region{position:absolute;left:-9999px;width:1px;height:1px;overflow:hidden}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{text-decoration:double underline}.xterm-underline-3{text-decoration:wavy underline}.xterm-underline-4{text-decoration:dotted underline}.xterm-underline-5{text-decoration:dashed underline}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:overline underline}.xterm-overline.xterm-underline-2{text-decoration:overline double underline}.xterm-overline.xterm-underline-3{text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;position:absolute;top:0;right:0;pointer-events:none}.xterm-decoration-top{z-index:2;position:relative}@font-face{font-family:DejaVuSansMNerdFontMono;src:url(/assets/DejaVuSansMNerdFontMono-Regular-CRJgiq0O.ttf);font-weight:400;font-style:normal}:root{color-scheme:dark;background-color:#000}#app{display:flex;height:100vh;width:100vw}*{font-family:DejaVuSansMNerdFontMono,monospace}body{overflow-y:hidden;overflow-x:hidden}

package/dist/browser/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>tui-sandbox integration tests</title>
+    <script type="module" crossorigin src="/assets/index-BckJD5M_.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bf37MeF1.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

package/dist/src/browser/neovim-client.d.ts

@@ -0,0 +1,7 @@
+import type { StartNeovimGenericArguments } from "../server/neovim/NeovimApplication.js";
+import type { TestDirectory } from "../server/types.js";
+declare global {
+    interface Window {
+        startNeovim(startArguments?: StartNeovimGenericArguments): Promise<TestDirectory>;
+    }
+}

package/dist/src/browser/neovim-client.js

@@ -0,0 +1,14 @@
+import { NeovimClient } from "../client/index.js";
+const app = document.querySelector("#app");
+if (!app) {
+    throw new Error("No app element found");
+}
+const client = new NeovimClient(app);
+/** Entrypoint for the test runner (cypress) */
+window.startNeovim = async function (startArgs) {
+    const testDirectory = await client.startNeovim({
+        filename: startArgs?.filename ?? "initial-file.txt",
+        startupScriptModifications: startArgs?.startupScriptModifications ?? [],
+    });
+    return testDirectory;
+};

package/dist/src/client/color-utilities.d.ts

@@ -0,0 +1,6 @@
+import type { flavors } from "@catppuccin/palette";
+type RgbColor = (typeof flavors.macchiato.colors)["surface0"]["rgb"];
+/** Convert a catppuccin RGB color to a CSS color string. This way you can
+ * assert that text that's visible on the screen has a specific color. */
+export declare function rgbify(color: RgbColor): string;
+export {};

package/dist/src/client/color-utilities.js

@@ -0,0 +1,5 @@
+/** Convert a catppuccin RGB color to a CSS color string. This way you can
+ * assert that text that's visible on the screen has a specific color. */
+export function rgbify(color) {
+    return `rgb(${color.r.toString()}, ${color.g.toString()}, ${color.b.toString()})`;
+}

package/dist/src/client/color-utilities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/client/color-utilities.test.js

@@ -0,0 +1,7 @@
+import { rgbify } from "./color-utilities.js";
+describe("rgbify", () => {
+    it("converts a catppuccin RGB color to a CSS color string", () => {
+        const color = { r: 1, g: 2, b: 3 };
+        expect(rgbify(color)).toEqual("rgb(1, 2, 3)");
+    });
+});

package/dist/src/client/index.d.ts

@@ -1 +1,2 @@
-export { NeovimClient } from "./neovim-client";
+export { rgbify } from "./color-utilities.js";
+export { NeovimClient } from "./neovim-client.js";

package/dist/src/client/index.js

@@ -1,2 +1,3 @@
 // This is the public client api. Semantic versioning will be applied to this.
-export { NeovimClient } from "./neovim-client";
+export { rgbify } from "./color-utilities.js";
+export { NeovimClient } from "./neovim-client.js";

package/dist/src/client/neovim-client.js

@@ -13,10 +13,10 @@ export class NeovimClient {
                 splitLink({
                     condition: operation => operation.type === "subscription",
                     true: unstable_httpSubscriptionLink({
-                        url: "http://localhost:3000",
+                        url: "/trpc",
                     }),
                     false: httpBatchLink({
-                        url: "http://localhost:3000",
+                        url: "/trpc",
                     }),
                 }),
             ],
@@ -54,7 +54,7 @@ export class NeovimClient {
     }
     async startNeovim(args) {
         await this.ready;
-        const neovim = await this.trpc.neovim.start.mutate({
+        const testDirectory = await this.trpc.neovim.start.mutate({
             startNeovimArguments: {
                 ...args,
                 terminalDimensions: {
@@ -64,6 +64,6 @@ export class NeovimClient {
             },
             tabId: this.tabId,
         });
-        return neovim;
+        return testDirectory;
     }
 }

package/dist/src/client/websocket-client.js

@@ -4,7 +4,7 @@ import { Terminal } from "@xterm/xterm";
 import "@xterm/xterm/css/xterm.css";
 import z from "zod";
 import "./style.css";
-import { validateMouseEvent } from "./validateMouseEvent";
+import { validateMouseEvent } from "./validateMouseEvent.js";
 export function startTerminal(app, options) {
     const terminal = new Terminal({
         cursorBlink: false,

package/dist/src/scripts/tui.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/scripts/tui.js

@@ -0,0 +1,25 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { startTestServer } from "../server/index.js";
+//
+// This is the main entrypoint to tui-sandbox
+//
+// the arguments passed to this script start at index 2
+const args = process.argv.slice(2);
+if (args[0] !== "start") {
+    throw new Error(`Usage: tui start`);
+}
+/** The cwd in the user's directory when they are running this script. Not the
+ * cwd of the script itself. */
+const cwd = process.cwd();
+console.log(`🚀 Starting test server in ${cwd}`);
+await stat(path.join(cwd, "MyTestDirectory.ts"));
+try {
+    await startTestServer({
+        testEnvironmentPath: path.join(cwd, "test-environment/"),
+        outputFilePath: path.join(cwd, "MyTestDirectory.ts"),
+    });
+}
+catch (e) {
+    console.error(e);
+}

package/dist/src/server/TestServer.d.ts

@@ -1,8 +1,10 @@
 import type { AnyTRPCRouter } from "@trpc/server";
-import "core-js/proposals/async-explicit-resource-management";
-import type { TestServerConfig } from "./updateTestdirectorySchemaFile";
+import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js";
+export type TestServerSettings = {
+    port: number;
+};
 export declare class TestServer {
-    private readonly port;
-    constructor(port: number);
+    private readonly settings;
+    constructor(settings: TestServerSettings);
     startAndRun(appRouter: AnyTRPCRouter, config: TestServerConfig): Promise<void>;
 }

package/dist/src/server/TestServer.js

@@ -1,31 +1,55 @@
-import { createHTTPServer } from "@trpc/server/adapters/standalone";
-import "core-js/proposals/async-explicit-resource-management";
+import * as trpcExpress from "@trpc/server/adapters/express";
 import cors from "cors";
 import { once } from "events";
-import { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile";
+import express from "express";
+import { accessSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export class TestServer {
-    port;
-    constructor(port) {
-        this.port = port;
+    settings;
+    constructor(settings) {
+        this.settings = settings;
     }
     async startAndRun(appRouter, config) {
         console.log("🚀 Server starting");
         await updateTestdirectorySchemaFile(config);
-        const server = createHTTPServer({
+        const app = express();
+        app.use("/trpc", trpcExpress.createExpressMiddleware({
             router: appRouter,
             createContext: () => ({}),
             middleware: cors({
                 origin: "*",
             }),
+        }));
+        {
+            const publicPath = path.resolve(__dirname, "..", "..", "browser");
+            try {
+                accessSync(publicPath);
+            }
+            catch (e) {
+                // This is normal when developing the tui-sandbox library locally. It
+                // should always exist when using it as an npm package, however.
+                console.log(`⚠️ Warning: the tui-sandbox root contents directory is not accessible at: ${publicPath}`);
+            }
+            // eslint-disable-next-line import-x/no-named-as-default-member
+            app.use(express.static(publicPath));
+        }
+        app.use("/ping", (_, res) => {
+            console.log("🏓 received /ping");
+            res.send("pong");
         });
-        server.listen(this.port);
+        const server = app.listen(this.settings.port, "0.0.0.0");
         server.on("connection", socket => {
-            console.log(`➕➕ Connection`);
+            const connectionInfo = `${socket.remoteAddress}:${socket.remotePort}`;
+            console.log(`➕➕ Connection from ${connectionInfo}`);
             socket.once("close", () => {
-                console.log(`➖➖ Connection`);
+                console.log(`➖➖ Connection from ${connectionInfo}`);
             });
         });
-        console.log(`✅ Server listening on ws://localhost:${this.port}`);
+        console.log(`✅ Server listening on port ${this.settings.port}`);
         await Promise.race([once(process, "SIGTERM"), once(process, "SIGINT")]);
         console.log("Shutting down...");
         server.close(error => {

package/dist/src/server/dirtree/index.js

@@ -2,7 +2,7 @@ import assert from "assert";
 import { scan, Type } from "dree";
 import { format, resolveConfig } from "prettier";
 import { fileURLToPath } from "url";
-import { jsonToZod } from "./json-to-zod";
+import { jsonToZod } from "./json-to-zod.js";
 /** Convert a directory tree to a TypeScript type. This is useful for testing
  * as the initial state of the test directory is fully known in tests. */
 export function getDirectoryTree(path) {

package/dist/src/server/dirtree/index.test.js

@@ -1,8 +1,8 @@
 import assert from "assert";
 import path from "path";
 import { describe, expect, it } from "vitest";
-import { buildSchemaForDirectoryTree, getDirectoryTree } from ".";
-import { Lazy } from "../utilities/Lazy";
+import { Lazy } from "../utilities/Lazy.js";
+import { buildSchemaForDirectoryTree, getDirectoryTree } from "./index.js";
 describe("dirtree", () => {
     const output = new Lazy(() => getDirectoryTree(path.join(__dirname, "..", "..", "..", "..", "integration-tests", "test-environment")));
     it("can get a list of all the files", () => {

package/dist/src/server/index.d.ts

@@ -1,4 +1,4 @@
-import "core-js/proposals/async-explicit-resource-management";
-export { startTestServer } from "./server";
-export { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile";
-export type { TestServerConfig } from "./updateTestdirectorySchemaFile";
+export { startTestServer } from "./server.js";
+export { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile.js";
+export type { TestServerConfig } from "./updateTestdirectorySchemaFile.js";
+import "core-js/proposals/async-explicit-resource-management.js";

package/dist/src/server/index.js

@@ -1,4 +1,4 @@
-import "core-js/proposals/async-explicit-resource-management";
 // This is the public server api. Semantic versioning will be applied to this.
-export { startTestServer } from "./server";
-export { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile";
+export { startTestServer } from "./server.js";
+export { updateTestdirectorySchemaFile } from "./updateTestdirectorySchemaFile.js";
+import "core-js/proposals/async-explicit-resource-management.js";

package/dist/src/server/neovim/NeovimApplication.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from "events";
-import type { TestDirectory } from "../types";
-import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication";
+import type { TestDirectory } from "../types.js";
+import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication.js";
 export type StdoutMessage = "stdout";
 export type StartNeovimGenericArguments = {
     terminalDimensions: {

package/dist/src/server/neovim/NeovimApplication.js

@@ -4,9 +4,9 @@ import EventEmitter from "events";
 import { access } from "fs/promises";
 import { tmpdir } from "os";
 import path from "path";
-import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication";
-import { TerminalApplication } from "../utilities/TerminalApplication";
-import { connectNeovimApi } from "./NeovimJavascriptApiClient";
+import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication.js";
+import { TerminalApplication } from "../utilities/TerminalApplication.js";
+import { connectNeovimApi } from "./NeovimJavascriptApiClient.js";
 export class NeovimApplication {
     testEnvironmentPath;
     application;

package/dist/src/server/neovim/NeovimJavascriptApiClient.d.ts

@@ -1,5 +1,5 @@
 import type { NeovimClient as NeovimApiClient } from "neovim";
-import { Lazy } from "../utilities/Lazy";
+import { Lazy } from "../utilities/Lazy.js";
 export type NeovimJavascriptApiClient = NeovimApiClient;
 export type PollingInterval = 100;
 export declare function connectNeovimApi(socketPath: string): Lazy<Promise<NeovimJavascriptApiClient>>;

package/dist/src/server/neovim/NeovimJavascriptApiClient.js

@@ -1,6 +1,6 @@
 import { access } from "fs/promises";
 import { attach } from "neovim";
-import { Lazy } from "../utilities/Lazy";
+import { Lazy } from "../utilities/Lazy.js";
 export function connectNeovimApi(socketPath) {
     // it takes about 100ms for the socket file to be created - best make this
     // Lazy so that we don't wait for it unnecessarily.

package/dist/src/server/neovim/NeovimJavascriptApiClient.test.js

@@ -1,6 +1,6 @@
 import { access } from "fs/promises";
 import { attach } from "neovim";
-import { connectNeovimApi } from "./NeovimJavascriptApiClient";
+import { connectNeovimApi } from "./NeovimJavascriptApiClient.js";
 vi.mock("neovim");
 vi.mock("fs/promises");
 const mocked = {

package/dist/src/server/neovim/environment/createTempDir.d.ts

@@ -1,4 +1,4 @@
-import type { TestDirectory } from "../../types";
-import type { TestServerConfig } from "../../updateTestdirectorySchemaFile";
+import type { TestDirectory } from "../../types.js";
+import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js";
 export declare function createTempDir(config: TestServerConfig): Promise<TestDirectory>;
 export type TestDirsPath = "testdirs";

package/dist/src/server/neovim/environment/createTempDir.js

@@ -4,8 +4,8 @@ import { Type } from "dree";
 import { constants, readdirSync } from "fs";
 import { access, mkdir, mkdtemp } from "fs/promises";
 import path from "path";
-import { convertDree, getDirectoryTree } from "../../dirtree";
-import { updateTestdirectorySchemaFile } from "../../updateTestdirectorySchemaFile";
+import { convertDree, getDirectoryTree } from "../../dirtree/index.js";
+import { updateTestdirectorySchemaFile } from "../../updateTestdirectorySchemaFile.js";
 export async function createTempDir(config) {
     try {
         const dir = await createUniqueDirectory(config.testEnvironmentPath);

package/dist/src/server/neovim/environment/createTempDir.test.js

@@ -1,7 +1,59 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import fs, { rmdirSync } from "fs";
 import nodePath from "path";
 import { expect, it } from "vitest";
-import { createTempDir } from "./createTempDir";
+import { createTempDir } from "./createTempDir.js";
 vi.spyOn(console, "log").mockImplementation(vi.fn());
 class TempDirectory {
     path;
@@ -17,14 +69,26 @@ class TempDirectory {
     }
 }
 it("should create a temp dir with no contents", async () => {
-    // typically the user will want to have contents, but this should not be an error
-    await using dir = TempDirectory.create();
-    const result = await createTempDir({
-        testEnvironmentPath: dir.path,
-        outputFilePath: nodePath.join(dir.path, "MyTestDirectory.ts"),
-    });
-    expect(result.contents).toEqual({});
-    expect(result.testEnvironmentPath).toEqual(dir.path);
-    expect(result.testEnvironmentPath.startsWith("test-temp-dir-")).toBeTruthy();
-    expect(result.testEnvironmentPathRelative.startsWith("testdirs")).toBeTruthy();
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        // typically the user will want to have contents, but this should not be an error
+        const dir = __addDisposableResource(env_1, TempDirectory.create(), true);
+        const result = await createTempDir({
+            testEnvironmentPath: dir.path,
+            outputFilePath: nodePath.join(dir.path, "MyTestDirectory.ts"),
+        });
+        expect(result.contents).toEqual({});
+        expect(result.testEnvironmentPath).toEqual(dir.path);
+        expect(result.testEnvironmentPath.startsWith("test-temp-dir-")).toBeTruthy();
+        expect(result.testEnvironmentPathRelative.startsWith("testdirs")).toBeTruthy();
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
 });

package/dist/src/server/neovim/index.d.ts

@@ -1,7 +1,7 @@
-import type { TestDirectory } from "../types";
-import type { TestServerConfig } from "../updateTestdirectorySchemaFile";
-import type { TabId } from "../utilities/tabId";
-import type { StartNeovimGenericArguments } from "./NeovimApplication";
+import type { TestDirectory } from "../types.js";
+import type { TestServerConfig } from "../updateTestdirectorySchemaFile.js";
+import type { TabId } from "../utilities/tabId.js";
+import type { StartNeovimGenericArguments } from "./NeovimApplication.js";
 export declare function onStdout(options: {
     client: TabId;
 }, signal: AbortSignal | undefined, testEnvironmentPath: string): Promise<AsyncGenerator<string, void, unknown>>;

package/dist/src/server/neovim/index.js

@@ -1,7 +1,7 @@
 import assert from "assert";
-import { convertEventEmitterToAsyncGenerator } from "../utilities/generator";
-import { createTempDir } from "./environment/createTempDir";
-import { NeovimApplication } from "./NeovimApplication";
+import { convertEventEmitterToAsyncGenerator } from "../utilities/generator.js";
+import { createTempDir } from "./environment/createTempDir.js";
+import { NeovimApplication } from "./NeovimApplication.js";
 const neovims = new Map();
 export async function onStdout(options, signal, testEnvironmentPath) {
     const tabId = options.client.tabId;

package/dist/src/server/server.d.ts

@@ -1,6 +1,7 @@
 import type { inferRouterInputs } from "@trpc/server";
-import { TestServer } from "./TestServer";
-import type { TestServerConfig } from "./updateTestdirectorySchemaFile";
+import "core-js/proposals/async-explicit-resource-management.js";
+import { TestServer } from "./TestServer.js";
+import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js";
 /** Stack for managing resources that need to be disposed of when the server
  * shuts down */
 declare const autocleanup: AsyncDisposableStack;
@@ -34,7 +35,7 @@ export declare function createAppRouter(config: TestServerConfig): Promise<impor
                     startupScriptModifications?: string[] | undefined;
                 };
             };
-            output: import("./types").TestDirectory;
+            output: import("./types.js").TestDirectory;
         }>;
         onStdout: import("@trpc/server").TRPCSubscriptionProcedure<{
             input: {

package/dist/src/server/server.js

@@ -1,15 +1,62 @@
-import { z } from "zod";
-import { trpc } from "./connection/trpc";
-import * as neovim from "./neovim";
-import { TestServer } from "./TestServer";
-import { applicationAvailable } from "./utilities/applicationAvailable";
-import { tabIdSchema } from "./utilities/tabId";
-/** Stack for managing resources that need to be disposed of when the server
- * shuts down */
-await using autocleanup = new AsyncDisposableStack();
-autocleanup.defer(() => {
-    console.log("Closing any open test applications");
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import "core-js/proposals/async-explicit-resource-management.js";
+import { z } from "zod";
+import { trpc } from "./connection/trpc.js";
+import * as neovim from "./neovim/index.js";
+import { TestServer } from "./TestServer.js";
+import { applicationAvailable } from "./utilities/applicationAvailable.js";
+import { tabIdSchema } from "./utilities/tabId.js";
 export { autocleanup };
 /** @private */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
@@ -50,8 +97,29 @@ export async function createAppRouter(config) {
     return appRouter;
 }
 export async function startTestServer(config) {
-    const testServer = new TestServer(3000);
+    const testServer = new TestServer({
+        port: 3000,
+    });
     const appRouter = await createAppRouter(config);
     await testServer.startAndRun(appRouter, config);
     return testServer;
 }
+var autocleanup;
+const env_1 = { stack: [], error: void 0, hasError: false };
+try {
+    /** Stack for managing resources that need to be disposed of when the server
+     * shuts down */
+    autocleanup = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+    autocleanup.defer(() => {
+        console.log("Closing any open test applications");
+    });
+}
+catch (e_1) {
+    env_1.error = e_1;
+    env_1.hasError = true;
+}
+finally {
+    const result_1 = __disposeResources(env_1);
+    if (result_1)
+        await result_1;
+}