@tui-sandbox/library 11.7.1 → 11.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tui-sandbox/library",
-  "version": "11.7.1",
+  "version": "11.8.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/mikavilpas/tui-sandbox"
@@ -12,17 +12,17 @@
   },
   "dependencies": {
     "@catppuccin/palette": "1.7.1",
-    "@trpc/client": "11.5.0",
-    "@trpc/server": "11.5.0",
+    "@trpc/client": "11.5.1",
+    "@trpc/server": "11.5.1",
     "@xterm/addon-fit": "0.10.0",
     "@xterm/addon-unicode11": "0.8.0",
     "@xterm/xterm": "5.5.0",
     "concurrently": "9.2.1",
     "cors": "2.8.5",
-    "cypress": "15.0.0",
+    "cypress": "15.1.0",
     "dree": "5.1.5",
     "express": "5.1.0",
-    "neovim": "5.3.0",
+    "neovim": "5.4.0",
     "node-pty": "1.0.0",
     "prettier": "3.6.2",
     "tsx": "4.20.5",
@@ -34,9 +34,9 @@
     "@types/command-exists": "1.2.3",
     "@types/cors": "2.8.19",
     "@types/express": "5.0.3",
-    "@types/node": "24.3.0",
+    "@types/node": "24.3.1",
     "nodemon": "3.1.10",
-    "vite": "7.1.3",
+    "vite": "7.1.5",
     "vitest": "3.2.4"
   },
   "peerDependencies": {

package/src/scripts/commands/commandTuiNeovimExec.ts

@@ -9,7 +9,7 @@ export async function commandTuiNeovimExec(command: NeovimExec, config: TestServ
   app.events.on("stdout" satisfies StdoutOrStderrMessage, data => {
     console.log(`  neovim output: ${data}`)
   })
-  const testDirectory = await prepareNewTestDirectory(config.directories)
+  const testDirectory = await prepareNewTestDirectory(config)
   await app.startNextAndKillCurrent(
     testDirectory,
     {

package/src/scripts/commands/commandTuiNeovimPrepare.ts

@@ -4,11 +4,7 @@ import type { TestServerConfig } from "../../server/updateTestdirectorySchemaFil
 export async function commandTuiNeovimPrepare(config: TestServerConfig): Promise<void> {
   const NVIM_APPNAME = process.env["NVIM_APPNAME"]
   console.log(`🚀 Installing neovim dependencies${NVIM_APPNAME ? ` for NVIM_APPNAME=${NVIM_APPNAME}` : ""}...`)
-  await installDependencies(
-    config.directories.testEnvironmentPath,
-    process.env["NVIM_APPNAME"],
-    config.directories
-  ).catch((err: unknown) => {
+  await installDependencies(process.env["NVIM_APPNAME"], config).catch((err: unknown) => {
     console.error("Error installing neovim dependencies", err)
     process.exit(1)
   })

package/src/scripts/commands/commandTuiStart.ts

@@ -18,7 +18,7 @@ export async function commandTuiStart(config: TestServerConfig): Promise<void> {
 
 async function updateSchemaFile(config: TestServerConfig): Promise<void> {
   try {
-    await updateTestdirectorySchemaFile(config.directories)
+    await updateTestdirectorySchemaFile(config)
   } catch (e) {
     console.error("Failed to updateTestdirectorySchemaFile", e)
   }

package/src/scripts/resolveConfig.test.ts

@@ -22,6 +22,7 @@ it("loads a custom configuration file if it exists", async () => {
       testEnvironmentPath: "./test-environment2/",
       outputFilePath: "./output.ts",
     },
+    integrations: { neovim: { NVIM_APPNAMEs: ["nvim", "nvim_2"] } },
     port: 12345,
   }
   {

package/src/server/applications/neovim/api.ts

@@ -10,7 +10,7 @@ import type {
   StartNeovimGenericArguments,
   TestDirectory,
 } from "../../types.js"
-import type { DirectoriesConfig } from "../../updateTestdirectorySchemaFile.js"
+import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
 import { convertEventEmitterToAsyncGenerator } from "../../utilities/generator.js"
 import { Lazy } from "../../utilities/Lazy.js"
 import type { TabId } from "../../utilities/tabId.js"
@@ -28,12 +28,8 @@ const resources: Lazy<AsyncDisposableStack> = new Lazy(() => {
 
 const log = debuglog("tui-sandbox.neovim.api")
 
-export async function installDependencies(
-  testEnvironmentPath: string,
-  NVIM_APPNAME: string | undefined,
-  config: DirectoriesConfig
-): Promise<void> {
-  await using app = new NeovimApplication(testEnvironmentPath)
+export async function installDependencies(NVIM_APPNAME: string | undefined, config: TestServerConfig): Promise<void> {
+  await using app = new NeovimApplication(config.directories.testEnvironmentPath)
   const testDirectory = await prepareNewTestDirectory(config)
   const prepareFilePath = path.join(testDirectory.rootPathAbsolute, ".config", NVIM_APPNAME ?? "nvim", "prepare.lua")
   try {
@@ -102,7 +98,7 @@ export async function start(
   options: StartNeovimGenericArguments,
   terminalDimensions: TerminalDimensions,
   tabId: TabId,
-  config: DirectoriesConfig
+  config: TestServerConfig
 ): Promise<TestDirectory> {
   const neovim = neovims.get(tabId.tabId)
   assert(neovim, `Neovim instance not found for client id ${tabId.tabId}`)

package/src/server/applications/neovim/environment/createTempDir.test.ts

@@ -1,5 +1,8 @@
 import nodePath from "path"
+import type { PartialDeep } from "type-fest"
 import { expect, it, vi } from "vitest"
+import { createDefaultConfig } from "../../../config.js"
+import type { TestServerConfig } from "../../../updateTestdirectorySchemaFile.js"
 import type { TestDirsPath } from "./createTempDir.js"
 import { createTempDir } from "./createTempDir.js"
 import type { TestTempDirPrefix } from "./TempDirectory.js"
@@ -11,9 +14,12 @@ 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
   using dir = TempDirectory.create()
   const result = await createTempDir({
-    testEnvironmentPath: dir.path,
-    outputFilePath: nodePath.join(dir.path, "MyTestDirectory.ts"),
-  })
+    ...createDefaultConfig("cwd", {}),
+    directories: {
+      testEnvironmentPath: dir.path,
+      outputFilePath: nodePath.join(dir.path, "MyTestDirectory.ts"),
+    },
+  } satisfies PartialDeep<TestServerConfig>)
 
   expect(result.contents).toEqual({})
   expect(result.testEnvironmentPath).toEqual(dir.path)

package/src/server/applications/neovim/environment/createTempDir.ts

@@ -7,22 +7,22 @@ import path from "path"
 import { debuglog } from "util"
 import { convertDree, getDirectoryTree } from "../../../dirtree/index.js"
 import type { TestDirectory } from "../../../types.js"
-import type { DirectoriesConfig } from "../../../updateTestdirectorySchemaFile.js"
+import type { TestServerConfig } from "../../../updateTestdirectorySchemaFile.js"
 import { updateTestdirectorySchemaFile } from "../../../updateTestdirectorySchemaFile.js"
 
 const log = debuglog("tui-sandbox.createTempDir")
 
-export async function createTempDir(config: DirectoriesConfig): Promise<TestDirectory> {
+export async function createTempDir(config: TestServerConfig): Promise<TestDirectory> {
   try {
     // before calling this function, the testEnvironmentPath should already exist
-    statSync(config.testEnvironmentPath)
-    const dir = await createUniqueDirectory(config.testEnvironmentPath)
+    statSync(config.directories.testEnvironmentPath)
+    const dir = await createUniqueDirectory(config.directories.testEnvironmentPath)
 
-    readdirSync(config.testEnvironmentPath).forEach(entry => {
+    readdirSync(config.directories.testEnvironmentPath).forEach(entry => {
       if (entry === ("testdirs" satisfies TestDirsPath)) return
       if (entry === ".repro") return
 
-      execSync(`cp -R '${path.join(config.testEnvironmentPath, entry)}' ${dir}/`)
+      execSync(`cp -R '${path.join(config.directories.testEnvironmentPath, entry)}' ${dir}/`)
     })
     log(`Created test directory at ${dir}`)
 
@@ -33,8 +33,8 @@ export async function createTempDir(config: DirectoriesConfig): Promise<TestDire
     return {
       rootPathAbsolute: dir,
       contents: tree.contents,
-      testEnvironmentPath: config.testEnvironmentPath,
-      testEnvironmentPathRelative: path.relative(config.testEnvironmentPath, dir),
+      testEnvironmentPath: config.directories.testEnvironmentPath,
+      testEnvironmentPathRelative: path.relative(config.directories.testEnvironmentPath, dir),
     }
   } catch (err) {
     console.error(err)

package/src/server/applications/neovim/neovimRouter.ts

@@ -3,7 +3,7 @@ import * as z from "zod"
 import { blockingCommandInputSchema } from "../../blockingCommandInputSchema.js"
 import { trpc } from "../../connection/trpc.js"
 import { serverTestDirectorySchema } from "../../types.js"
-import type { DirectoriesConfig } from "../../updateTestdirectorySchemaFile.js"
+import type { NeovimIntegrationDefaultAppName, TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
 import { tabIdSchema } from "../../utilities/tabId.js"
 import { timeoutable } from "../../utilities/timeoutable.js"
 import * as neovim from "./api.js"
@@ -37,7 +37,7 @@ export type RunLuaFileClientInput = Except<RunLuaFileInput, "tabId">
 
 // let trpc infer the type as that is what it is designed to do
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function createNeovimRouter(config: DirectoriesConfig) {
+export function createNeovimRouter(config: TestServerConfig) {
   return trpc.router({
     start: trpc.procedure
       .input(
@@ -52,7 +52,10 @@ export function createNeovimRouter(config: DirectoriesConfig) {
             ]),
             startupScriptModifications: z.array(z.string()).optional(),
             additionalEnvironmentVariables: z.record(z.string(), z.string()).optional(),
-            NVIM_APPNAME: z.string().optional().default("nvim"),
+            NVIM_APPNAME: z
+              .string()
+              .optional()
+              .default("nvim" satisfies NeovimIntegrationDefaultAppName),
           }),
           terminalDimensions: z.object({
             cols: z.number(),
@@ -61,7 +64,7 @@ export function createNeovimRouter(config: DirectoriesConfig) {
         })
       )
       .output(serverTestDirectorySchema)
-      .mutation(options => {
+      .mutation(async options => {
         return neovim.start(
           options.input.startNeovimArguments,
           options.input.terminalDimensions,
@@ -70,11 +73,11 @@ export function createNeovimRouter(config: DirectoriesConfig) {
         )
       }),
     onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
-      return neovim.initializeStdout(options.input, options.signal, config.testEnvironmentPath)
+      return neovim.initializeStdout(options.input, options.signal, config.directories.testEnvironmentPath)
     }),
 
     initializeStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
-      return neovim.initializeStdout(options.input, options.signal, config.testEnvironmentPath)
+      return neovim.initializeStdout(options.input, options.signal, config.directories.testEnvironmentPath)
     }),
     sendStdin: trpc.procedure.input(z.object({ tabId: tabIdSchema, data: z.string() })).mutation(options => {
       return neovim.sendStdin(options.input)

package/src/server/applications/neovim/prepareNewTestDirectory.test.ts

@@ -1,6 +1,9 @@
 import { rm } from "fs/promises"
 import path from "path"
+import type { PartialDeep } from "type-fest"
 import { assert, describe, expect, it } from "vitest"
+import { createDefaultConfig } from "../../config.js"
+import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
 import { prepareNewTestDirectory } from "./prepareNewTestDirectory.js"
 
 describe("prepareNewTestDirectory when the testEnvironmentPath does not exist", () => {
@@ -9,9 +12,12 @@ describe("prepareNewTestDirectory when the testEnvironmentPath does not exist",
     // has not been created yet
     const testEnvironmentPath = "/tmp/test"
     const testDirectory = await prepareNewTestDirectory({
-      outputFilePath: path.join(testEnvironmentPath, "foo.ts"),
-      testEnvironmentPath,
-    })
+      ...createDefaultConfig("cwd", {}),
+      directories: {
+        outputFilePath: path.join(testEnvironmentPath, "foo.ts"),
+        testEnvironmentPath,
+      },
+    } satisfies PartialDeep<TestServerConfig>)
 
     try {
       expect(testDirectory.contents).toEqual({})

package/src/server/applications/neovim/prepareNewTestDirectory.ts

@@ -1,21 +1,21 @@
 import { access, mkdir } from "fs/promises"
 import { debuglog } from "util"
 import type { TestDirectory } from "../../types.js"
-import type { DirectoriesConfig } from "../../updateTestdirectorySchemaFile.js"
+import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
 import { createTempDir, removeTestDirectories } from "./environment/createTempDir.js"
 
 const log = debuglog("tui-sandbox.neovim.prepareNewTestDirectory")
 
-export async function prepareNewTestDirectory(config: DirectoriesConfig): Promise<TestDirectory> {
+export async function prepareNewTestDirectory(config: TestServerConfig): Promise<TestDirectory> {
   try {
     // if the directory does not exist, create it
-    await access(config.testEnvironmentPath)
+    await access(config.directories.testEnvironmentPath)
   } catch {
-    log(`Creating testEnvironmentPath directory at ${config.testEnvironmentPath}`)
-    await mkdir(config.testEnvironmentPath, { recursive: true })
+    log(`Creating testEnvironmentPath directory at ${config.directories.testEnvironmentPath}`)
+    await mkdir(config.directories.testEnvironmentPath, { recursive: true })
   }
 
-  await removeTestDirectories(config.testEnvironmentPath)
+  await removeTestDirectories(config.directories.testEnvironmentPath)
   const testDirectory = await createTempDir(config)
   return testDirectory
 }

package/src/server/applications/terminal/api.ts

@@ -1,7 +1,7 @@
 import assert from "assert"
 import type { BlockingCommandInput } from "../../blockingCommandInputSchema.js"
 import type { BlockingShellCommandOutput, TestDirectory } from "../../types.js"
-import type { DirectoriesConfig } from "../../updateTestdirectorySchemaFile.js"
+import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
 import { convertEventEmitterToAsyncGenerator } from "../../utilities/generator.js"
 import { Lazy } from "../../utilities/Lazy.js"
 import type { TabId } from "../../utilities/tabId.js"
@@ -17,7 +17,7 @@ const resources: Lazy<AsyncDisposableStack> = new Lazy(() => {
 
 export async function start(
   { tabId, startTerminalArguments }: StartTerminalInput,
-  config: DirectoriesConfig
+  config: TestServerConfig
 ): Promise<TestDirectory> {
   const app = terminals.get(tabId.tabId)
   assert(app, `Terminal with tabId ${tabId.tabId} not found.`)

package/src/server/applications/terminal/terminalRouter.ts

@@ -2,7 +2,7 @@ import * as z from "zod"
 import { blockingCommandInputSchema } from "../../blockingCommandInputSchema.js"
 import { trpc } from "../../connection/trpc.js"
 import { serverTestDirectorySchema } from "../../types.js"
-import type { DirectoriesConfig } from "../../updateTestdirectorySchemaFile.js"
+import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
 import { tabIdSchema } from "../../utilities/tabId.js"
 import * as terminal from "./api.js"
 
@@ -21,7 +21,7 @@ export type StartTerminalInput = z.infer<typeof startTerminalInputSchema>
 
 // let trpc infer the type as that is what it is designed to do
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function createTerminalRouter(config: DirectoriesConfig) {
+export function createTerminalRouter(config: TestServerConfig) {
   const terminalRouter = trpc.router({
     onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
       return terminal.initializeStdout(options.input, options.signal)
@@ -30,7 +30,7 @@ export function createTerminalRouter(config: DirectoriesConfig) {
     start: trpc.procedure
       .input(startTerminalInputSchema)
       .output(serverTestDirectorySchema)
-      .mutation(options => {
+      .mutation(async options => {
         return terminal.start(options.input, config)
       }),
 

package/src/server/config.test.ts

@@ -0,0 +1,7 @@
+import { createDefaultConfig } from "./config.js"
+import { testServerConfigSchema } from "./updateTestdirectorySchemaFile.js"
+
+it("is possible not to customize anything", () => {
+  const defaultConfig = createDefaultConfig(process.cwd(), process.env)
+  testServerConfigSchema.parse(defaultConfig)
+})

package/src/server/config.ts

@@ -1,11 +1,17 @@
 import path from "path"
 import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js"
 
-export const createDefaultConfig = (cwd: string, environment: NodeJS.ProcessEnv): TestServerConfig =>
-  ({
+export const createDefaultConfig = (cwd: string, environment: NodeJS.ProcessEnv): TestServerConfig => {
+  return {
     directories: {
       testEnvironmentPath: path.join(cwd, "test-environment/"),
       outputFilePath: path.join(cwd, "MyTestDirectory.ts"),
     },
     port: environment["PORT"] ? parseInt(environment["PORT"]) : 3000,
-  }) satisfies TestServerConfig
+    integrations: {
+      neovim: {
+        NVIM_APPNAMEs: ["nvim"],
+      },
+    },
+  }
+}

package/src/server/cypress-support/contents.ts

@@ -33,7 +33,7 @@ import type {
 import type { StartTerminalGenericArguments } from "@tui-sandbox/library/src/server/applications/terminal/TerminalTestApplication"
 import type { BlockingCommandClientInput } from "@tui-sandbox/library/src/server/blockingCommandInputSchema"
 import type { OverrideProperties } from "type-fest"
-import type { MyTestDirectory, MyTestDirectoryFile } from "../../MyTestDirectory"
+import type { MyNeovimAppName, MyTestDirectory, MyTestDirectoryFile } from "../../MyTestDirectory"
 
 export type TerminalTestApplicationContext = {
   /** Types text into the terminal, making the terminal application receive the
@@ -93,6 +93,7 @@ export type NeovimContext = {
 export type MyStartNeovimServerArguments = OverrideProperties<
   StartNeovimGenericArguments,
   {
+    NVIM_APPNAME?: MyNeovimAppName
     filename?: MyTestDirectoryFile | { openInVerticalSplits: MyTestDirectoryFile[] }
     startupScriptModifications?: Array<MyNeovimConfigModification<MyTestDirectoryFile>>
   }

package/src/server/dirtree/index.test.ts

@@ -1,6 +1,8 @@
 import assert from "assert"
 import path from "path"
 import { describe, expect, it } from "vitest"
+import { createDefaultConfig } from "../config.js"
+import type { NeovimIntegrationDefaultAppName, TestServerConfig } from "../updateTestdirectorySchemaFile.js"
 import { Lazy } from "../utilities/Lazy.js"
 import { buildSchemaForDirectoryTree, getDirectoryTree } from "./index.js"
 
@@ -19,7 +21,15 @@ describe("dirtree", () => {
   })
 
   it("should be able to build a typescript type for the tree", async () => {
-    const result = await buildSchemaForDirectoryTree(output.get(), "MyDirectoryTree")
+    const config: TestServerConfig = {
+      ...createDefaultConfig("/my/root/path", {}),
+      integrations: {
+        neovim: {
+          NVIM_APPNAMEs: ["nvim" satisfies NeovimIntegrationDefaultAppName, "nvim_alt"],
+        },
+      },
+    }
+    const result = await buildSchemaForDirectoryTree(output.get(), "MyDirectoryTree", config)
 
     expect(result).toMatchInlineSnapshot(`
       "
@@ -201,13 +211,15 @@ describe("dirtree", () => {
         "symlink-test",
         "."
       ])
-      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>"
+      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
+      export type MyNeovimAppName = "nvim" | "nvim_alt""
     `)
   })
 
   it("creates an empty schema when the directory cannot be read", async () => {
+    const config: TestServerConfig = createDefaultConfig("/my/root/path", {})
     const tree = getDirectoryTree("nonexistent")
-    const result = await buildSchemaForDirectoryTree(tree, "MyDirectoryTree")
+    const result = await buildSchemaForDirectoryTree(tree, "MyDirectoryTree", config)
     expect(result).toMatchInlineSnapshot(`
       "
       // Note: This file is autogenerated. Do not edit it directly.
@@ -234,7 +246,107 @@ describe("dirtree", () => {
       export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
 
       export const testDirectoryFiles = z.enum([])
-      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>"
+      export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
+      export type MyNeovimAppName = "nvim""
     `)
   })
+
+  describe("provides type-safe access to NVIM_APPNAMEs", () => {
+    // the user can configure the NVIM_APPNAMEs they are using in their
+    // configuration. These should be available for them in a type-safe manner so
+    // that they have the least possible friction when coding.
+    //
+    const smallDirectory = path.resolve(__dirname, "../../../../integration-tests/test-environment/other-subdirectory/")
+
+    it("when there is a single name", async () => {
+      const config: TestServerConfig = createDefaultConfig("/my/root/path", {})
+      assert(config.integrations.neovim.NVIM_APPNAMEs.length === 1)
+      const tinytree = getDirectoryTree(smallDirectory)
+      const result = await buildSchemaForDirectoryTree(tinytree, "MyDirectoryTree", config)
+
+      expect(result).toMatchInlineSnapshot(`
+        "
+        // Note: This file is autogenerated. Do not edit it directly.
+        //
+        // Describes the contents of the test directory, which is a blueprint for
+        // files and directories. Tests can create a unique, safe environment for
+        // interacting with the contents of such a directory.
+        //
+        // Having strong typing for the test directory contents ensures that tests can
+        // be written with confidence that the files and directories they expect are
+        // actually found. Otherwise the tests are brittle and can break easily.
+
+        import * as z from "zod"
+
+        export const MyDirectoryTreeSchema = z.object({
+          name: z.literal("other-subdirectory/"),
+          type: z.literal("directory"),
+          contents: z.object({
+            "other-sub-file.txt": z.object({ name: z.literal("other-sub-file.txt"), type: z.literal("file") }),
+          }),
+        })
+
+        export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
+        export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
+
+        export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
+
+        export const testDirectoryFiles = z.enum([
+          "other-sub-file.txt",
+          "."
+        ])
+        export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
+        export type MyNeovimAppName = "nvim""
+      `)
+      //                               👆🏻 from the default config
+    })
+
+    it("when there are multiple names", async () => {
+      const config: TestServerConfig = {
+        ...createDefaultConfig("/my/root/path", {}),
+        integrations: {
+          neovim: {
+            NVIM_APPNAMEs: ["nvim" satisfies NeovimIntegrationDefaultAppName, "nvim_alt"],
+          },
+        },
+      }
+      const tinytree = getDirectoryTree(smallDirectory)
+      const result = await buildSchemaForDirectoryTree(tinytree, "MyDirectoryTree", config)
+
+      expect(result).toMatchInlineSnapshot(`
+        "
+        // Note: This file is autogenerated. Do not edit it directly.
+        //
+        // Describes the contents of the test directory, which is a blueprint for
+        // files and directories. Tests can create a unique, safe environment for
+        // interacting with the contents of such a directory.
+        //
+        // Having strong typing for the test directory contents ensures that tests can
+        // be written with confidence that the files and directories they expect are
+        // actually found. Otherwise the tests are brittle and can break easily.
+
+        import * as z from "zod"
+
+        export const MyDirectoryTreeSchema = z.object({
+          name: z.literal("other-subdirectory/"),
+          type: z.literal("directory"),
+          contents: z.object({
+            "other-sub-file.txt": z.object({ name: z.literal("other-sub-file.txt"), type: z.literal("file") }),
+          }),
+        })
+
+        export const MyDirectoryTreeContentsSchema = MyDirectoryTreeSchema.shape.contents
+        export type MyDirectoryTreeContentsSchemaType = z.infer<typeof MyDirectoryTreeSchema>
+
+        export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
+
+        export const testDirectoryFiles = z.enum([
+          "other-sub-file.txt",
+          "."
+        ])
+        export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>
+        export type MyNeovimAppName = "nvim" | "nvim_alt""
+      `)
+    })
+  })
 })

package/src/server/dirtree/index.ts

@@ -1,9 +1,11 @@
+import assert from "assert"
 import type { Dree } from "dree"
 import { scan, Type } from "dree"
 import { readlinkSync } from "fs"
 import { format, resolveConfig } from "prettier"
 import { fileURLToPath } from "url"
 import { debuglog } from "util"
+import type { TestServerConfig } from "../updateTestdirectorySchemaFile.js"
 import { jsonToZod } from "./json-to-zod.js"
 
 const log = debuglog("tui-sandbox.dirtree")
@@ -83,7 +85,11 @@ export function convertDree(root: Dree | undefined): TreeNode {
   return node
 }
 
-export async function buildSchemaForDirectoryTree(result: TreeResult, name: string): Promise<string> {
+export async function buildSchemaForDirectoryTree(
+  result: TreeResult,
+  name: string,
+  config: TestServerConfig
+): Promise<string> {
   const root = convertDree(result.dree)
 
   const schema = (await jsonToZod(root, `${name}Schema`)).split("\n")
@@ -103,6 +109,13 @@ export async function buildSchemaForDirectoryTree(result: TreeResult, name: stri
   const allFilePaths = result.allFiles.map(f => f.relativePath)
   const ContentsSchema = `${name}ContentsSchema`
   const ContentsSchemaType = `${name}ContentsSchemaType`
+
+  assert(config.integrations.neovim.NVIM_APPNAMEs.length > 0, "At least one NVIM_APPNAME must be configured")
+  const NVIM_APPNAMEsUnion =
+    config.integrations.neovim.NVIM_APPNAMEs.length > 1
+      ? config.integrations.neovim.NVIM_APPNAMEs.map(a => `"${a}"`).join(" | ")
+      : `"${config.integrations.neovim.NVIM_APPNAMEs[0]}"`
+
   return [
     ...lines,
     ...schema,
@@ -113,15 +126,16 @@ export async function buildSchemaForDirectoryTree(result: TreeResult, name: stri
     "",
     `export const testDirectoryFiles = z.enum(${JSON.stringify(allFilePaths, null, 2)})`,
     `export type MyTestDirectoryFile = z.infer<typeof testDirectoryFiles>`,
+    `export type MyNeovimAppName = ${NVIM_APPNAMEsUnion}`,
   ].join("\n")
 }
 
 const __filename = fileURLToPath(import.meta.url)
 
-export async function buildTestDirectorySchema(testDirectoryPath: string): Promise<string> {
-  log("Building schema for test directory", testDirectoryPath)
-  const dree = getDirectoryTree(testDirectoryPath)
-  let text = await buildSchemaForDirectoryTree(dree, "MyTestDirectory")
+export async function buildTestDirectorySchema(config: TestServerConfig): Promise<string> {
+  log("Building schema for test directory", config.directories.testEnvironmentPath)
+  const dree = getDirectoryTree(config.directories.testEnvironmentPath)
+  let text = await buildSchemaForDirectoryTree(dree, "MyTestDirectory", config)
 
   const options = await resolveConfig(__filename)
   text = await format(text, { ...options, parser: "typescript" })

package/src/server/server.ts

@@ -3,14 +3,13 @@ import { createNeovimRouter } from "./applications/neovim/neovimRouter.js"
 import { createTerminalRouter } from "./applications/terminal/terminalRouter.js"
 import { trpc } from "./connection/trpc.js"
 import { TestServer } from "./TestServer.js"
-import type { DirectoriesConfig, TestServerConfig } from "./updateTestdirectorySchemaFile.js"
+import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js"
 
 /** @private */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export async function createAppRouter(config: DirectoriesConfig) {
+export async function createAppRouter(config: TestServerConfig) {
   const appRouter = trpc.router({
     terminal: createTerminalRouter(config),
-
     neovim: createNeovimRouter(config),
   })
 
@@ -25,7 +24,7 @@ export async function startTestServer(config: TestServerConfig): Promise<void> {
     const testServer = new TestServer({
       port: config.port,
     })
-    const appRouter = await createAppRouter(config.directories)
+    const appRouter = await createAppRouter(config)
 
     await testServer.startAndRun(appRouter)
   } catch (err: unknown) {