arri 0.58.0 → 0.59.0

package/dist/index.cjs

@@ -4,20 +4,574 @@ const codegenDart = require('@arrirpc/codegen-dart');
 const codegenKotlin = require('@arrirpc/codegen-kotlin');
 const codegenRust = require('@arrirpc/codegen-rust');
 const codegenTs = require('@arrirpc/codegen-ts');
-const dev = require('./shared/arri.09919c6d.cjs');
+const common = require('./shared/arri.7f2f73b2.cjs');
+const node_child_process = require('node:child_process');
+const fs = require('node:fs');
+const fs$1 = require('node:fs/promises');
+const path = require('node:path');
 const codegenUtils = require('@arrirpc/codegen-utils');
-require('node:fs');
-require('@joshmossas/listhen');
+const listhen = require('@joshmossas/listhen');
+const esbuild = require('esbuild');
+const esbuildPluginReplace = require('esbuild-plugin-replace');
+const h3 = require('h3');
+const prettier = require('prettier');
 require('c12');
 require('citty');
-require('esbuild');
-require('h3');
 require('pathe');
-require('node:fs/promises');
 require('@arrirpc/schema');
+require('@joshmossas/ofetch');
 require('consola');
-require('ofetch');
-require('prettier');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs$1);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const esbuild__default = /*#__PURE__*/_interopDefaultCompat(esbuild);
+const prettier__default = /*#__PURE__*/_interopDefaultCompat(prettier);
+
+function tsServer(serverConfig) {
+  return common.defineServerConfig({
+    devArgs: void 0,
+    async devFn(_, generators) {
+      const resolvedConfig = {
+        port: serverConfig?.port ?? defaultTsServerConfig.port,
+        entry: serverConfig?.entry ?? defaultTsServerConfig.entry,
+        serverEntry: serverConfig?.serverEntry ?? defaultTsServerConfig.serverEntry,
+        rootDir: serverConfig?.rootDir ?? defaultTsServerConfig.rootDir,
+        srcDir: serverConfig?.srcDir ?? defaultTsServerConfig.srcDir,
+        procedureDir: serverConfig?.procedureDir ?? defaultTsServerConfig.procedureDir,
+        procedureGlobPatterns: serverConfig?.procedureGlobPatterns ?? defaultTsServerConfig.procedureGlobPatterns,
+        buildDir: serverConfig?.buildDir ?? defaultTsServerConfig.buildDir,
+        esbuild: serverConfig?.esbuild ?? defaultTsServerConfig.esbuild,
+        https: serverConfig?.https ?? defaultTsServerConfig.https,
+        http2: serverConfig?.http2 ?? defaultTsServerConfig.http2,
+        devServer: serverConfig?.devServer ?? defaultTsServerConfig.devServer
+      };
+      await startDevServer(resolvedConfig, generators);
+    },
+    buildArgs: void 0,
+    async buildFn(args, generators) {
+      const resolvedConfig = {
+        port: serverConfig?.port ?? 3e3,
+        entry: serverConfig?.entry ?? "app.ts",
+        serverEntry: serverConfig?.serverEntry ?? defaultTsServerConfig.serverEntry,
+        rootDir: serverConfig?.rootDir ?? defaultTsServerConfig.rootDir,
+        srcDir: serverConfig?.srcDir ?? defaultTsServerConfig.srcDir,
+        procedureDir: serverConfig?.procedureDir ?? defaultTsServerConfig.procedureDir,
+        procedureGlobPatterns: serverConfig?.procedureGlobPatterns ?? defaultTsServerConfig.procedureGlobPatterns,
+        buildDir: serverConfig?.buildDir ?? defaultTsServerConfig.buildDir,
+        esbuild: serverConfig?.esbuild ?? defaultTsServerConfig.esbuild,
+        https: serverConfig?.https ?? defaultTsServerConfig.https,
+        http2: serverConfig?.http2 ?? defaultTsServerConfig.http2,
+        devServer: serverConfig?.devServer ?? defaultTsServerConfig.devServer
+      };
+      const appEntry = path__default.resolve(
+        resolvedConfig.rootDir,
+        resolvedConfig.srcDir,
+        resolvedConfig.entry
+      );
+      if (!fs.existsSync(appEntry)) {
+        throw new Error(`Unable to find entry at ${appEntry}`);
+      }
+      await startBuild(generators, resolvedConfig, args.skipCodegen);
+    }
+  });
+}
+const defaultTsServerConfig = {
+  port: 3e3,
+  entry: "app.ts",
+  serverEntry: "",
+  rootDir: ".",
+  srcDir: "src",
+  procedureDir: "procedures",
+  procedureGlobPatterns: ["**/*.rpc.ts"],
+  buildDir: ".arri",
+  esbuild: {},
+  https: false,
+  http2: false,
+  devServer: {
+    additionalWatchDirs: void 0,
+    httpWithHttps: void 0,
+    httpWithHttpsPort: void 0
+  }
+};
+async function startBuild(generators, serverConfig, skipCodeGen = false) {
+  common.logger.log("Bundling server....");
+  const appEntry = path__default.resolve(
+    serverConfig.rootDir,
+    serverConfig.srcDir,
+    serverConfig.entry
+  );
+  if (!fs.existsSync(
+    path__default.resolve(
+      serverConfig.rootDir,
+      serverConfig.srcDir,
+      serverConfig.entry
+    )
+  )) {
+    common.logger.error(`Unable to find entry at ${appEntry}`);
+    process.exit(1);
+  }
+  await setupWorkingDir(serverConfig);
+  await Promise.all([
+    createAppWithRoutesModule(serverConfig),
+    createServerEntryFile(serverConfig),
+    createCodegenEntryFile(serverConfig)
+  ]);
+  await bundleAppEntry(serverConfig);
+  common.logger.log("Finished bundling");
+  const clientCount = generators.length ?? 0;
+  const codegenModule = path__default.resolve(
+    serverConfig.rootDir,
+    ".output",
+    OUT_CODEGEN
+  );
+  if (!skipCodeGen) {
+    common.logger.log("Generating Arri app definition (__definition.json)");
+    node_child_process.execSync(`node ${codegenModule}`, { env: process.env });
+    const defJson = path__default.resolve(
+      serverConfig.rootDir,
+      ".output",
+      "__definition.json"
+    );
+    const def = JSON.parse(fs.readFileSync(defJson, { encoding: "utf-8" }));
+    if (codegenUtils.isAppDefinition(def) && clientCount > 0) {
+      const startTime = (/* @__PURE__ */ new Date()).getTime();
+      common.logger.log(`Generating ${clientCount} client(s)...`);
+      await Promise.all(
+        generators.map((plugin) => plugin.generator(def)) ?? []
+      );
+      common.logger.log(
+        `${clientCount} client(s) generated in ${( new Date()).getTime() - startTime}ms`
+      );
+    } else {
+      common.logger.warn(
+        "No client generators specified. Skipping client codegen."
+      );
+    }
+  } else {
+    common.logger.log("Skipping codegen");
+  }
+  common.logger.log("Cleaning up files");
+  await fs__namespace.rm(codegenModule);
+  common.logger.success(
+    `Build finished! You can start your server by running "node .output/${OUT_SERVER_ENTRY}"`
+  );
+}
+async function bundleAppEntry(config, _allowCodegen = true) {
+  const appEntry = path__default.resolve(
+    config.rootDir,
+    config.buildDir,
+    GEN_APP_FILE
+  );
+  await esbuild__default.build({
+    ...config.esbuild,
+    entryPoints: [appEntry],
+    platform: config.esbuild.platform ?? "node",
+    target: config.esbuild.target ?? "node20",
+    bundle: true,
+    packages: "external",
+    format: "esm",
+    sourcemap: config.esbuild.sourcemap ?? true,
+    minify: config.esbuild.minify ?? true,
+    banner: {
+      js: `import { createRequire as topLevelCreateRequire } from 'module';
+const require = topLevelCreateRequire(import.meta.url);`
+    },
+    allowOverwrite: true,
+    outfile: path__default.resolve(config.rootDir, ".output", OUT_APP_FILE)
+  });
+}
+async function createServerEntryFile(config) {
+  if (config.serverEntry) {
+    const buildEntry = path__default.resolve(
+      config.rootDir,
+      config.srcDir,
+      config.serverEntry
+    );
+    await esbuild__default.build({
+      ...config.esbuild,
+      entryPoints: [buildEntry],
+      platform: config.esbuild.platform ?? "node",
+      target: config.esbuild.target ?? "node20",
+      bundle: false,
+      packages: "external",
+      format: "esm",
+      sourcemap: true,
+      minifyWhitespace: true,
+      banner: {
+        js: `import { createRequire as topLevelCreateRequire } from 'module';
+const require = topLevelCreateRequire(import.meta.url);`
+      },
+      plugins: [esbuildPluginReplace.replace({ "virtual:arri/app": "./app.mjs" })],
+      allowOverwrite: true,
+      outfile: path__default.resolve(config.rootDir, ".output", OUT_SERVER_ENTRY)
+    });
+    return;
+  }
+  const appModule = path__default.resolve(config.rootDir, config.srcDir, config.entry);
+  const appImportParts = path__default.relative(path__default.resolve(config.rootDir, config.srcDir), appModule).split(".");
+  appImportParts.pop();
+  let httpsString = ``;
+  if (config.https === true) {
+    httpsString = `https: true,`;
+  } else if (typeof config.https === "object") {
+    httpsString = `https: { cert: '${config.https.cert}', key: '${config.https.key}', passphrase: ${config.https.passphrase ? `'${config.https.passphrase}'` : "undefined"}},`;
+  }
+  const virtualEntry = `import { toNodeListener } from '@arrirpc/server';
+import { listen } from '@joshmossas/listhen';
+import app from './${OUT_APP_FILE}';
+
+void listen(toNodeListener(app.h3App), {
+    port: process.env.PORT ?? ${config.port},
+    public: true,
+    ws: {
+        resolve(info) {
+            if (app.h3App.websocket?.resolve) {
+                return app.h3App.websocket.resolve(info);
+            }
+            return app.h3App.websocket?.hooks ?? app.h3App.handler?.__websocket__ ?? {};
+        }
+    },
+    http2: ${config.http2 ?? false},
+    ${httpsString}
+});`;
+  await fs__namespace.writeFile(
+    path__default.resolve(config.rootDir, ".output", OUT_SERVER_ENTRY),
+    virtualEntry
+  );
+}
+async function createCodegenEntryFile(config) {
+  const appModule = path__default.resolve(config.rootDir, config.srcDir, config.entry);
+  const appImportParts = path__default.relative(path__default.resolve(config.rootDir, config.srcDir), appModule).split(".");
+  appImportParts.pop();
+  const virtualModule = await prettier__default.format(
+    `
+    import { writeFileSync } from 'node:fs';
+    import path from 'pathe';
+    import app from './${OUT_APP_FILE}';
+
+    const __dirname = new URL(".", import.meta.url).pathname;
+    const def = app.getAppDefinition();
+    writeFileSync(
+        path.resolve(__dirname, "../.output", "__definition.json"),
+        JSON.stringify(def),
+    );
+    process.exit(0);`,
+    { tabWidth: 4, parser: "typescript" }
+  );
+  await fs__namespace.writeFile(
+    path__default.resolve(config.rootDir, ".output", OUT_CODEGEN),
+    virtualModule
+  );
+}
+async function bundleFilesContext(config) {
+  return await esbuild__default.context({
+    ...config.esbuild,
+    entryPoints: [
+      path__default.resolve(config.rootDir, config.buildDir, GEN_APP_FILE)
+    ],
+    outfile: path__default.resolve(config.rootDir, ".output", OUT_APP_FILE),
+    format: "esm",
+    bundle: true,
+    packages: "external",
+    sourcemap: config.esbuild.sourcemap ?? true,
+    target: config.esbuild.target ?? "node20",
+    platform: config.esbuild.platform ?? "node"
+  });
+}
+async function createDevServer(config) {
+  const h3$1 = await import('h3');
+  const app = h3$1.createApp();
+  const dynamicHandler = h3.dynamicEventHandler(
+    () => "<div>initializing server...</div>"
+  );
+  app.use(dynamicHandler);
+  let ws;
+  const listener = await listhen.listen(h3.toNodeListener(app), {
+    port: config.port,
+    https: config.https,
+    http2: config.http2,
+    public: true,
+    ws: {
+      resolve(info) {
+        if (ws?.resolve) {
+          return ws.resolve(info);
+        }
+        return {};
+      }
+    }
+  });
+  let secondaryListener;
+  if (config.devServer.httpWithHttps) {
+    secondaryListener = await listhen.listen(h3.toNodeListener(app), {
+      port: config.devServer.httpWithHttpsPort ?? config.port + 1,
+      https: false,
+      http2: config.http2,
+      public: true,
+      ws: {
+        resolve(info) {
+          if (ws?.resolve) {
+            return ws.resolve(info);
+          }
+          return {};
+        }
+      },
+      qr: false,
+      showURL: false
+    });
+    common.logger.info(
+      `Serving unencrypted traffic from port ${secondaryListener.address.port}`
+    );
+  }
+  async function reload() {
+    const appEntry = (await import(path__default.resolve(
+      config.rootDir,
+      ".output",
+      `${OUT_APP_FILE}?version=${Date.now()}`
+    ))).default;
+    dynamicHandler.set(h3.fromNodeMiddleware(appEntry.h3App.handler));
+    ws = appEntry.h3App.websocket;
+    return appEntry.getAppDefinition();
+  }
+  await reload();
+  return {
+    h3App: app,
+    listener,
+    secondaryListener,
+    reload,
+    ws
+  };
+}
+async function startDevServer(config, generators) {
+  await setupWorkingDir(config);
+  const watcher = await import('chokidar');
+  let fileWatcher;
+  await createAppWithRoutesModule(config);
+  const context = await bundleFilesContext(config);
+  await context.rebuild();
+  const devServer = await createDevServer(config);
+  let appDef = await devServer.reload();
+  let appDefStr = JSON.stringify(appDef);
+  if (generators.length) {
+    common.logger.info(`Running generators...`);
+    await generateClientsFromDefinition(appDef, generators);
+  } else {
+    common.logger.warn(`No generators specified in config. Skipping codegen.`);
+  }
+  const cleanExit = async () => {
+    process.exit();
+  };
+  process.on("exit", async () => {
+    await Promise.allSettled([fileWatcher?.close(), context.dispose()]);
+  });
+  process.on("SIGINT", cleanExit);
+  process.on("SIGTERM", cleanExit);
+  async function load(_isRestart, _reason) {
+    if (fileWatcher) {
+      await fileWatcher.close();
+    }
+    const srcDir = path__default.resolve(config.rootDir ?? "", config.srcDir);
+    const dirsToWatch = [srcDir];
+    if (config.esbuild.alias) {
+      for (const key of Object.keys(config.esbuild.alias)) {
+        const alias = config.esbuild.alias[key];
+        if (alias) {
+          if (!common.isInsideDir(alias, srcDir)) {
+            dirsToWatch.push(alias);
+          }
+        }
+      }
+    }
+    if (config.devServer.additionalWatchDirs?.length) {
+      for (const dir of config.devServer.additionalWatchDirs) {
+        dirsToWatch.push(dir);
+      }
+    }
+    const buildDir = path__default.resolve(config.rootDir, config.buildDir);
+    const outDir = path__default.resolve(config.rootDir, ".output");
+    fileWatcher = watcher.watch(dirsToWatch, {
+      ignoreInitial: true,
+      ignored: [
+        buildDir,
+        outDir,
+        "**/.output",
+        "**/dist/**",
+        "**/node_modules/**",
+        "**/.git/**"
+      ]
+    });
+    fileWatcher.on("all", async (eventName, _path) => {
+      if (eventName === "addDir" || eventName === "add") {
+        return;
+      }
+      await createAppWithRoutesModule(config);
+      try {
+        const reloadStart = (/* @__PURE__ */ new Date()).getTime();
+        common.logger.log(
+          "Change detected. Bundling files and restarting server...."
+        );
+        await context.rebuild();
+        const newAppDef = await devServer.reload();
+        const newAppDefStr = JSON.stringify(newAppDef);
+        common.logger.log(
+          `Server restarted in ${( new Date()).getTime() - reloadStart}ms`
+        );
+        if (generators.length && newAppDefStr !== appDefStr) {
+          common.logger.info(
+            `App Definition updated. Regenerating clients...`
+          );
+          await generateClientsFromDefinition(newAppDef, generators);
+          appDef = newAppDef;
+          appDefStr = newAppDefStr;
+        }
+      } catch (err) {
+        common.logger.error("ERROR", err);
+      }
+    });
+  }
+  await load();
+}
+async function generateClientsFromDefinition(appDef, generators) {
+  const startTime = (/* @__PURE__ */ new Date()).getTime();
+  try {
+    const clientCount = generators.length;
+    await Promise.allSettled(
+      generators.map((generator) => generator.generator(appDef, true))
+    );
+    common.logger.success(
+      `Generated ${clientCount} client${clientCount === 1 ? "" : "s"} in ${( new Date()).getTime() - startTime}ms`
+    );
+  } catch (err) {
+    common.logger.error(err);
+  }
+}
+const GEN_APP_FILE = "__arri_app.ts";
+const OUT_APP_FILE = "app.mjs";
+const OUT_SERVER_ENTRY = "server.mjs";
+const OUT_CODEGEN = "codegen.mjs";
+async function setupWorkingDir(config) {
+  const arriDir = path__default.resolve(config.rootDir, config.buildDir);
+  const outDir = path__default.resolve(config.rootDir, ".output");
+  if (fs.existsSync(arriDir)) {
+    await fs__namespace.rm(arriDir, { recursive: true, force: true });
+  }
+  if (fs.existsSync(outDir)) {
+    await fs__namespace.rm(outDir, { recursive: true, force: true });
+  }
+  await fs__namespace.mkdir(arriDir);
+  await fs__namespace.mkdir(outDir);
+}
+async function createAppWithRoutesModule(config) {
+  const glob = await import('globby');
+  const appModule = path__default.resolve(config.rootDir, config.srcDir, config.entry);
+  const appImportParts = path__default.relative(path__default.resolve(config.rootDir, config.buildDir), appModule).split(".");
+  appImportParts.pop();
+  const routes = [];
+  const existingRoutes = [];
+  await Promise.all(
+    config.procedureGlobPatterns.map(async (pattern) => {
+      const results = await getFsRouteBatch(glob.globby, pattern, config);
+      for (const result of results) {
+        if (!existingRoutes.includes(result.name)) {
+          routes.push(result);
+          existingRoutes.push(result.name);
+        }
+      }
+    })
+  );
+  routes.sort((a, b) => a.name < b.name ? -1 : 1);
+  const module = await prettier__default.format(
+    `import sourceMapSupport from 'source-map-support';
+        sourceMapSupport.install();
+        import app from '${appImportParts.join(".")}';
+        ${routes.map(
+      (route) => `import ${route.importName} from '${route.importPath}';`
+    ).join("\n")}
+
+        ${routes.map((route) => `app.rpc('${route.name}', ${route.importName});`).join("\n")}
+
+        export default app;`,
+    { parser: "typescript", tabWidth: 4 }
+  );
+  await fs__namespace.writeFile(
+    path__default.resolve(config.rootDir, config.buildDir, GEN_APP_FILE),
+    module
+  );
+}
+async function getFsRouteBatch(glob, globPattern, config) {
+  if (!config.procedureDir) {
+    return [];
+  }
+  const target = `${config.rootDir}/${config.srcDir}/${config.procedureDir}/${globPattern}`.split("//").join("/").split("//").join("/");
+  const files = await glob(target, {
+    onlyFiles: true
+  });
+  const routes = [];
+  for (const file of files) {
+    const meta = getRpcMetaFromPath(config, file);
+    if (meta) {
+      const importParts = path__default.relative(path__default.resolve(config.rootDir, config.buildDir), file).split(".");
+      importParts.pop();
+      routes.push({
+        name: meta.id,
+        importName: codegenUtils.camelCase(meta.id.split(".").join("_")),
+        importPath: `./${importParts.join(".")}`
+      });
+    }
+  }
+  return routes;
+}
+const disallowedNameChars = "~`!@#$%^&*()-+=[]{}\\|:;\"'<>,./";
+const getRpcMetaFromPath = (config, filePath) => {
+  if (!config.procedureDir) {
+    return void 0;
+  }
+  const resolvedFilePath = filePath.split("./").join("/");
+  const parts = resolvedFilePath.split("/");
+  const reversedParts = [...parts].reverse();
+  const nameParts = [];
+  for (const part of reversedParts) {
+    if (part === config.procedureDir) {
+      break;
+    }
+    nameParts.push(part);
+  }
+  const fileName = nameParts.reverse().pop() ?? "";
+  const serviceParts = nameParts.filter((part) => part.trim().length > 0).map((part) => codegenUtils.removeDisallowedChars(part, disallowedNameChars));
+  const fileNameParts = fileName.split(".");
+  if (!fileNameParts.length) {
+    return void 0;
+  }
+  const rpcName = codegenUtils.removeDisallowedChars(
+    fileNameParts[0],
+    disallowedNameChars
+  );
+  const httpParts = [
+    ...serviceParts.map((part) => codegenUtils.kebabCase(part)),
+    codegenUtils.kebabCase(rpcName)
+  ];
+  return {
+    id: [...serviceParts, rpcName].join("."),
+    httpPath: `/${httpParts.join("/")}`
+  };
+};
+
+const servers = {
+  tsServer
+};
 
 const generators = {
   dartClient: codegenDart.dartClientGenerator,
@@ -26,10 +580,11 @@ const generators = {
   typescriptClient: codegenTs.typescriptClientGenerator
 };
 
-exports.DEV_DEFINITION_ENDPOINT = dev.DEV_DEFINITION_ENDPOINT;
-exports.defaultConfig = dev.defaultConfig;
-exports.defineConfig = dev.defineConfig;
-exports.isArriConfig = dev.isArriConfig;
-exports.isResolvedArriConfig = dev.isResolvedArriConfig;
+exports.DEV_DEFINITION_ENDPOINT = common.DEV_DEFINITION_ENDPOINT;
+exports.defineConfig = common.defineConfig;
+exports.defineServerConfig = common.defineServerConfig;
+exports.isArriConfig = common.isArriConfig;
+exports.isServerConfig = common.isServerConfig;
 exports.createAppDefinition = codegenUtils.createAppDefinition;
 exports.generators = generators;
+exports.servers = servers;

package/dist/index.d.cts

@@ -5,11 +5,31 @@ import * as _arrirpc_codegen_utils from '@arrirpc/codegen-utils';
 import { Generator } from '@arrirpc/codegen-utils';
 export { AppDefinition, createAppDefinition } from '@arrirpc/codegen-utils';
 import * as _arrirpc_codegen_dart from '@arrirpc/codegen-dart';
-import { BuildOptions } from 'esbuild';
+import { ArgsDef, ParsedArgs } from 'citty';
+import esbuild from 'esbuild';
 
 declare const DEV_DEFINITION_ENDPOINT = "/__arri_dev__/__definition";
 
-interface ArriConfig {
+interface ServerConfig<TDevArgs extends ArgsDef | undefined = any, TBuildArgs extends ArgsDef | undefined = any> {
+    devArgs?: TDevArgs;
+    buildArgs?: TBuildArgs;
+    devFn: (args: TDevArgs extends ArgsDef ? ParsedArgs<TDevArgs> : {}, generators: Generator<any>[]) => any;
+    buildFn: (args: (TBuildArgs extends ArgsDef ? ParsedArgs<TBuildArgs> : {}) & {
+        skipCodegen?: boolean;
+    }, generators: Generator<any>[]) => any;
+}
+declare function isServerConfig(input: unknown): input is ServerConfig<any, any>;
+declare function defineServerConfig<DevArgs extends ArgsDef | undefined = any, BuildArgs extends ArgsDef | undefined = any>(config: ServerConfig<DevArgs, BuildArgs>): ServerConfig<DevArgs, BuildArgs>;
+
+interface ArriConfig<TDevArgs extends ArgsDef | undefined = any, TBuildArgs extends ArgsDef | undefined = any> {
+    server?: ServerConfig<TDevArgs, TBuildArgs>;
+    generators: Generator<any>[];
+}
+declare function isArriConfig(input: unknown): input is ArriConfig;
+declare function defineConfig(config: ArriConfig): ArriConfig;
+
+declare function tsServer(serverConfig?: TsServerConfig): ServerConfig<undefined, undefined>;
+interface TsServerConfig {
     port?: number;
     entry?: string;
     serverEntry?: string;
@@ -20,9 +40,8 @@ interface ArriConfig {
      * this defaults to ["***\/*\*.rpc.ts"]
      */
     procedureGlobPatterns?: string[];
-    generators?: Array<Generator<any>>;
     buildDir?: string;
-    esbuild?: Omit<BuildOptions, "bundle" | "format" | "outfile" | "outdir" | "entryNames" | "entryPoints" | "packages">;
+    esbuild?: Omit<esbuild.BuildOptions, "bundle" | "format" | "outfile" | "outdir" | "entryNames" | "entryPoints" | "packages">;
     https?: {
         cert: string;
         key: string;
@@ -41,11 +60,10 @@ interface ArriConfig {
         httpWithHttpsPort?: number;
     };
 }
-declare function isArriConfig(input: unknown): input is ArriConfig;
-declare function isResolvedArriConfig(input: unknown): input is ResolvedArriConfig;
-type ResolvedArriConfig = Required<ArriConfig>;
-declare const defaultConfig: Required<ArriConfig>;
-declare function defineConfig(config: ArriConfig): ResolvedArriConfig;
+
+declare const servers: {
+    readonly tsServer: typeof tsServer;
+};
 
 declare const generators: {
     readonly dartClient: _arrirpc_codegen_utils.GeneratorPlugin<_arrirpc_codegen_dart.DartClientGeneratorOptions>;
@@ -54,4 +72,4 @@ declare const generators: {
     readonly typescriptClient: _arrirpc_codegen_utils.GeneratorPlugin<_arrirpc_codegen_ts.TypescriptGeneratorOptions>;
 };
 
-export { type ArriConfig, DEV_DEFINITION_ENDPOINT, type ResolvedArriConfig, defaultConfig, defineConfig, generators, isArriConfig, isResolvedArriConfig };
+export { type ArriConfig, DEV_DEFINITION_ENDPOINT, type ServerConfig, type TsServerConfig, defineConfig, defineServerConfig, generators, isArriConfig, isServerConfig, servers };