@web-ts-toolkit/express-runtime 0.26.0 → 0.28.0

package/cli.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,22 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli-utils.ts
-var import_node_url = require("url");
-var import_node_path = require("path");
-var import_node_fs = require("fs");
-var import_node_module = require("module");
-var import_node_child_process = require("child_process");
-
 // src/index.ts
-var import_node_http = __toESM(require("http"));
-var import_express = __toESM(require("express"));
-var import_serverless_http = __toESM(require("serverless-http"));
-var defaultLogger = {
-  log: (...args) => console.log(...args),
-  error: (...args) => console.error(...args),
-  debug: (...args) => console.debug(...args)
-};
 function applySettings(app, options) {
   if (options.disablePoweredBy !== false) {
     app.disable("x-powered-by");
@@ -83,8 +75,6 @@ function createExpressApp(options = {}) {
   }
   return app;
 }
-var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
-var DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
 function normalizePort(val) {
   if (val === void 0 || val === "") {
     const envPort = process.env.PORT;
@@ -194,10 +184,24 @@ function startLocalServer(app, options = {}) {
     shutdown
   };
 }
+var import_node_http, import_express, import_serverless_http, defaultLogger, DEFAULT_SIGNALS, DEFAULT_SHUTDOWN_TIMEOUT;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    import_node_http = __toESM(require("http"));
+    import_express = __toESM(require("express"));
+    import_serverless_http = __toESM(require("serverless-http"));
+    defaultLogger = {
+      log: (...args) => console.log(...args),
+      error: (...args) => console.error(...args),
+      debug: (...args) => console.debug(...args)
+    };
+    DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+    DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
+  }
+});
 
 // src/cli-utils.ts
-var import_meta = {};
-var CLI_VERSION = "0.0.0-PLACEHOLDER";
 function readValue(argv, index, name) {
   const value = argv[index + 1];
   if (value === void 0 || value.startsWith("--")) {
@@ -228,12 +232,14 @@ Dev options:
   --shutdown-timeout <ms>       Max ms to wait for in-flight requests (default: 5000)
   --require <module>            Module(s) to preload before app load (repeatable)
   --env <path>                  Env file(s) to load (repeatable; existing env vars are not overridden)
+  --tsconfig <path>             Tsconfig used by config-aware consumers for TS path resolution
   --watch <paths>               Comma-separated paths to watch for restart (repeatable; dev only)
   --ext <extensions>            Comma-separated extensions to watch (default: ts,js,mjs,cjs,json)
   --delay <ms>                  Debounce ms before restarting on change (default: 500)
 
 Build options:
   --init <path>                 Init hook module (default export, async function)
+  --tsconfig <path>             Use a custom tsconfig for bundling
   --out-dir <path>              Output directory (default: dist)
   --out-name <name>             Output filename without extension (default: app)
   --format <cjs|esm>            Output format (default: cjs)
@@ -251,6 +257,7 @@ Start options:
 
 Build-serverless options:
   --init <path>                 Init hook module (default export, async function)
+  --tsconfig <path>             Use a custom tsconfig for bundling
   --out-dir <path>              Output directory (default: dist)
   --out-name <name>             Output filename without extension (default: handler)
   --format <cjs|esm>            Output format (default: cjs)
@@ -307,8 +314,6 @@ function isHelp(arg) {
 function isSubcommand(arg) {
   return arg === "dev" || arg === "build" || arg === "start" || arg === "build-serverless" || arg === "start-serverless";
 }
-var DEFAULT_WATCH_EXTENSIONS = ["ts", "js", "mjs", "cjs", "json"];
-var DEFAULT_WATCH_DELAY = 500;
 function parseRepeatable(argv, index, arg, list) {
   const value = readValue(argv, index, arg);
   for (const part of value.split(",")) {
@@ -324,6 +329,7 @@ function parseDevArgs(argv) {
   const watchPaths = [];
   let watchExt;
   let watchDelay;
+  let tsconfigPath;
   let appPath;
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
@@ -390,6 +396,15 @@ function parseDevArgs(argv) {
       }
       continue;
     }
+    if (arg === "--tsconfig") {
+      tsconfigPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--tsconfig=")) {
+      tsconfigPath = arg.slice("--tsconfig=".length);
+      continue;
+    }
     if (arg === "--watch") {
       index = parseRepeatable(argv, index, arg, watchPaths);
       continue;
@@ -439,6 +454,7 @@ function parseDevArgs(argv) {
   return {
     appPath,
     options,
+    tsconfigPath,
     require: requireModules,
     env: envFiles,
     watch: watchPaths,
@@ -448,8 +464,8 @@ function parseDevArgs(argv) {
 }
 function parseStartLikeArgs(argv, subcommandName) {
   for (const arg of argv) {
-    if (arg === "--watch" || arg.startsWith("--watch=") || arg === "--ext" || arg.startsWith("--ext=") || arg === "--delay" || arg.startsWith("--delay=")) {
-      throw new Error(`--watch/--ext/--delay are not supported with the ${subcommandName} subcommand`);
+    if (arg === "--watch" || arg.startsWith("--watch=") || arg === "--tsconfig" || arg.startsWith("--tsconfig=") || arg === "--ext" || arg.startsWith("--ext=") || arg === "--delay" || arg.startsWith("--delay=")) {
+      throw new Error(`--watch/--tsconfig/--ext/--delay are not supported with the ${subcommandName} subcommand`);
     }
   }
   return parseDevArgs(argv);
@@ -477,6 +493,7 @@ function parseBuildArgs(argv, outNameDefault) {
   const external = [];
   const result = {
     initPath: void 0,
+    tsconfigPath: void 0,
     outDir: "dist",
     outName: outNameDefault,
     format: "cjs",
@@ -501,6 +518,15 @@ function parseBuildArgs(argv, outNameDefault) {
       result.initPath = arg.slice("--init=".length);
       continue;
     }
+    if (arg === "--tsconfig") {
+      result.tsconfigPath = readValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--tsconfig=")) {
+      result.tsconfigPath = arg.slice("--tsconfig=".length);
+      continue;
+    }
     if (arg === "--out-dir") {
       result.outDir = readValue(argv, index, arg);
       index += 1;
@@ -681,9 +707,6 @@ function loadEnvFiles(paths) {
     }
   }
 }
-var moduleRequire = (0, import_node_module.createRequire)(
-  typeof import_meta !== "undefined" && import_meta.url || (0, import_node_path.resolve)(process.cwd(), "x").replace(/x$/, "")
-);
 async function preloadModules(modules) {
   for (const mod of modules) {
     moduleRequire(mod);
@@ -696,6 +719,7 @@ function buildChildArgs(args) {
   if (args.options.signals === false) result.push("--no-signals");
   if (args.options.shutdownTimeout !== void 0)
     result.push("--shutdown-timeout", String(args.options.shutdownTimeout));
+  if (args.tsconfigPath !== void 0) result.push("--tsconfig", args.tsconfigPath);
   for (const r of args.require) result.push("--require", r);
   for (const e of args.env) result.push("--env", e);
   return result;
@@ -763,8 +787,6 @@ function runWithWatch(args) {
   process.on("SIGTERM", shutdown);
   spawnChild();
 }
-var TEMP_BUILD_ENTRY_FILENAME = ".express-runtime-build-entry.ts";
-var TEMP_SERVERLESS_ENTRY_FILENAME = ".express-runtime-build-serverless-entry.ts";
 function generateServerlessEntry(appPath, initPath) {
   const absAppPath = (0, import_node_path.resolve)(process.cwd(), appPath);
   const absInitPath = initPath ? (0, import_node_path.resolve)(process.cwd(), initPath) : void 0;
@@ -796,15 +818,16 @@ function generateRuntimeEntry(appPath, initPath) {
   }
   return lines.join("\n") + "\n";
 }
-async function buildBundle(args, tempEntryFilename, entryContent) {
+async function buildBundleFromEntryContent(args) {
   const tsupModule = await import("tsup");
   const { build } = tsupModule;
-  const tempEntryPath = (0, import_node_path.resolve)(process.cwd(), tempEntryFilename);
-  (0, import_node_fs.writeFileSync)(tempEntryPath, entryContent, "utf8");
+  const tempEntryPath = (0, import_node_path.resolve)(process.cwd(), args.tempEntryFilename);
+  (0, import_node_fs.writeFileSync)(tempEntryPath, args.entryContent, "utf8");
   try {
     await build({
       config: false,
       entry: { [args.outName]: tempEntryPath },
+      tsconfig: args.tsconfigPath,
       format: [args.format],
       target: args.target,
       outDir: args.outDir,
@@ -819,10 +842,18 @@ async function buildBundle(args, tempEntryFilename, entryContent) {
   }
 }
 async function buildRuntime(args) {
-  await buildBundle(args, TEMP_BUILD_ENTRY_FILENAME, generateRuntimeEntry(args.appPath, args.initPath));
+  const { runBuildEntryCommand: runBuildEntryCommand2 } = await Promise.resolve().then(() => (init_cli_api(), cli_api_exports));
+  await runBuildEntryCommand2(args, {
+    generateEntry: generateRuntimeEntry,
+    tempEntryFilename: TEMP_BUILD_ENTRY_FILENAME
+  });
 }
 async function buildServerless(args) {
-  await buildBundle(args, TEMP_SERVERLESS_ENTRY_FILENAME, generateServerlessEntry(args.appPath, args.initPath));
+  const { runBuildEntryCommand: runBuildEntryCommand2 } = await Promise.resolve().then(() => (init_cli_api(), cli_api_exports));
+  await runBuildEntryCommand2(args, {
+    generateEntry: generateServerlessEntry,
+    tempEntryFilename: TEMP_SERVERLESS_ENTRY_FILENAME
+  });
 }
 function collectBody(req) {
   return new Promise((resolve, reject) => {
@@ -913,36 +944,121 @@ async function loadHandler(handlerPath) {
   }
   return exported;
 }
+var import_node_url, import_node_path, import_node_fs, import_node_module, import_node_child_process, import_meta, CLI_VERSION, DEFAULT_WATCH_EXTENSIONS, DEFAULT_WATCH_DELAY, moduleRequire, TEMP_BUILD_ENTRY_FILENAME, TEMP_SERVERLESS_ENTRY_FILENAME;
+var init_cli_utils = __esm({
+  "src/cli-utils.ts"() {
+    "use strict";
+    import_node_url = require("url");
+    import_node_path = require("path");
+    import_node_fs = require("fs");
+    import_node_module = require("module");
+    import_node_child_process = require("child_process");
+    init_src();
+    import_meta = {};
+    CLI_VERSION = "0.0.0-PLACEHOLDER";
+    DEFAULT_WATCH_EXTENSIONS = ["ts", "js", "mjs", "cjs", "json"];
+    DEFAULT_WATCH_DELAY = 500;
+    moduleRequire = (0, import_node_module.createRequire)(
+      typeof import_meta !== "undefined" && import_meta.url || (0, import_node_path.resolve)(process.cwd(), "x").replace(/x$/, "")
+    );
+    TEMP_BUILD_ENTRY_FILENAME = ".express-runtime-build-entry.ts";
+    TEMP_SERVERLESS_ENTRY_FILENAME = ".express-runtime-build-serverless-entry.ts";
+  }
+});
 
-// src/cli.ts
-async function main() {
-  const parsedArgs = parseArgs(process.argv.slice(2));
-  if (!parsedArgs) {
+// src/cli-api.ts
+var cli_api_exports = {};
+__export(cli_api_exports, {
+  CLI_VERSION: () => CLI_VERSION,
+  applyServerlessResult: () => applyServerlessResult,
+  buildBundleFromEntryContent: () => buildBundleFromEntryContent,
+  buildChildArgs: () => buildChildArgs,
+  buildRuntime: () => buildRuntime,
+  buildServerless: () => buildServerless,
+  createServerlessAdapterApp: () => createServerlessAdapterApp,
+  extractExport: () => extractExport,
+  generateRuntimeEntry: () => generateRuntimeEntry,
+  generateServerlessEntry: () => generateServerlessEntry,
+  isExpressApp: () => isExpressApp,
+  loadApp: () => loadApp,
+  loadBuiltApp: () => loadBuiltApp,
+  loadEnvFiles: () => loadEnvFiles,
+  loadHandler: () => loadHandler,
+  parseArgs: () => parseArgs,
+  parseEnvFile: () => parseEnvFile,
+  preloadModules: () => preloadModules,
+  printHelp: () => printHelp,
+  readValue: () => readValue,
+  resolveExport: () => resolveExport,
+  runBuildEntryCommand: () => runBuildEntryCommand,
+  runCliCommand: () => runCliCommand,
+  runDevCommand: () => runDevCommand,
+  runExpressDevCommand: () => runExpressDevCommand,
+  runWithWatch: () => runWithWatch,
+  toServerlessEvent: () => toServerlessEvent
+});
+async function runDevCommand(args, runner) {
+  if (args.watch.length > 0) {
+    (runner.watch ?? runWithWatch)(args);
     return;
   }
+  if (args.env.length > 0) {
+    loadEnvFiles(args.env);
+  }
+  await preloadModules(args.require);
+  const loaded = await runner.load(args.appPath);
+  runner.start(loaded, { ...args.options, exitAfterShutdown: true });
+}
+async function runExpressDevCommand(args) {
+  await runDevCommand(args, {
+    load: loadApp,
+    start: (app, options) => {
+      startLocalServer(app, options);
+    }
+  });
+}
+async function runBuildEntryCommand(args, options) {
+  if (options.allowInit === false && args.initPath) {
+    throw new Error(options.initErrorMessage ?? "This build command manages init automatically. Remove --init.");
+  }
+  await buildBundleFromEntryContent({
+    entryContent: options.generateEntry(args.appPath, args.initPath),
+    tempEntryFilename: options.tempEntryFilename,
+    tsconfigPath: args.tsconfigPath,
+    outDir: args.outDir,
+    outName: args.outName,
+    format: args.format,
+    target: args.target,
+    external: args.external,
+    clean: args.clean
+  });
+}
+async function runCliCommand(parsedArgs) {
   if (parsedArgs.subcommand === "dev") {
-    const { dev } = parsedArgs;
-    if (dev.watch.length > 0) {
-      runWithWatch(dev);
-      return;
-    }
-    if (dev.env.length > 0) {
-      loadEnvFiles(dev.env);
-    }
-    await preloadModules(dev.require);
-    const app = await loadApp(dev.appPath);
-    startLocalServer(app, { ...dev.options, exitAfterShutdown: true });
-  } else if (parsedArgs.subcommand === "start") {
+    await runExpressDevCommand(parsedArgs.dev);
+    return;
+  }
+  if (parsedArgs.subcommand === "start") {
     const { start } = parsedArgs;
     if (start.env.length > 0) {
       loadEnvFiles(start.env);
     }
     await preloadModules(start.require);
     const { app, init } = await loadBuiltApp(start.appPath);
-    startLocalServer(app, { ...start.options, init, exitAfterShutdown: true });
-  } else if (parsedArgs.subcommand === "build") {
+    startLocalServer(app, {
+      ...start.options,
+      init: init ? async () => {
+        await init();
+      } : void 0,
+      exitAfterShutdown: true
+    });
+    return;
+  }
+  if (parsedArgs.subcommand === "build") {
     await buildRuntime(parsedArgs.build);
-  } else if (parsedArgs.subcommand === "start-serverless") {
+    return;
+  }
+  if (parsedArgs.subcommand === "start-serverless") {
     const { startServerless } = parsedArgs;
     if (startServerless.env.length > 0) {
       loadEnvFiles(startServerless.env);
@@ -951,9 +1067,26 @@ async function main() {
     const handler = await loadHandler(startServerless.handlerPath);
     const app = createServerlessAdapterApp(handler);
     startLocalServer(app, { ...startServerless.options, exitAfterShutdown: true });
-  } else {
-    await buildServerless(parsedArgs.buildServerless);
+    return;
+  }
+  await buildServerless(parsedArgs.buildServerless);
+}
+var init_cli_api = __esm({
+  "src/cli-api.ts"() {
+    "use strict";
+    init_src();
+    init_cli_utils();
+  }
+});
+
+// src/cli.ts
+init_cli_api();
+async function main() {
+  const parsedArgs = parseArgs(process.argv.slice(2));
+  if (!parsedArgs) {
+    return;
   }
+  await runCliCommand(parsedArgs);
 }
 main().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);

package/index.mjs

@@ -1,216 +1,10 @@
-// src/index.ts
-import http from "http";
-import express from "express";
-import serverless from "serverless-http";
-var defaultLogger = {
-  log: (...args) => console.log(...args),
-  error: (...args) => console.error(...args),
-  debug: (...args) => console.debug(...args)
-};
-function applySettings(app, options) {
-  if (options.disablePoweredBy !== false) {
-    app.disable("x-powered-by");
-  }
-  app.set("etag", options.etag ?? false);
-  app.set("trust proxy", options.trustProxy ?? false);
-}
-function applyMiddlewareList(app, list) {
-  if (list) {
-    for (const mw of list) {
-      app.use(mw);
-    }
-  }
-}
-function applyRouters(app, options) {
-  const mounts = [];
-  if (options.router) mounts.push(options.router);
-  if (options.routers) mounts.push(...options.routers);
-  for (const mount of mounts) {
-    const path = typeof mount.path === "function" ? mount.path() : mount.path;
-    app.use(path, mount.handler);
-  }
-}
-function createExpressApp(options = {}) {
-  const app = express();
-  applySettings(app, options);
-  applyMiddlewareList(app, options.preMiddleware);
-  if (options.json !== false) {
-    app.use(express.json(options.json ?? { limit: "1mb" }));
-  }
-  if (options.urlencoded !== false) {
-    app.use(express.urlencoded(options.urlencoded ?? { extended: false, limit: "1mb" }));
-  }
-  applyMiddlewareList(app, options.middleware);
-  applyRouters(app, options);
-  applyMiddlewareList(app, options.postMiddleware);
-  if (options.finalize) {
-    options.finalize(app);
-  }
-  if (options.errorHandler) {
-    app.use(options.errorHandler);
-  }
-  return app;
-}
-function defaultRequestHook(req, maxBodyBytes = 1024 * 1024, logger = defaultLogger) {
-  if (!req.body || !Buffer.isBuffer(req.body)) {
-    return;
-  }
-  if (req.body.length > maxBodyBytes) {
-    logger.debug?.(" Skipping oversized serverless body for content-type parsing");
-    return;
-  }
-  try {
-    const bodyStr = req.body.toString("utf8");
-    const contentType = (req.headers?.["content-type"] ?? "").toLowerCase();
-    if (contentType.startsWith("application/json")) {
-      req.body = JSON.parse(bodyStr);
-    } else {
-      req.body = bodyStr;
-    }
-  } catch (error) {
-    logger.error("Failed to parse serverless request body:", error);
-  }
-}
-function createServerlessHandler(app, options = {}) {
-  const logger = options.logger ?? defaultLogger;
-  const maxBodyBytes = options.maxBodyBytes ?? 1024 * 1024;
-  const requestHook = options.request ?? ((req) => defaultRequestHook(req, maxBodyBytes, logger));
-  const baseOptions = {
-    ...options.serverlessOptions ?? {},
-    request: requestHook
-  };
-  if (options.response) {
-    baseOptions.response = options.response;
-  }
-  const apiHandler = serverless(app, baseOptions);
-  let initialized = null;
-  const ensureInit = () => {
-    if (!initialized) {
-      logger.debug?.("Serverless cold start: running init");
-      initialized = options.init ? options.init() : Promise.resolve();
-    }
-    return initialized;
-  };
-  const handler = async (event, context) => {
-    await ensureInit();
-    return apiHandler(event, context);
-  };
-  handler.reset = () => {
-    initialized = null;
-  };
-  return handler;
-}
-var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
-var DEFAULT_SHUTDOWN_TIMEOUT = 5e3;
-function normalizePort(val) {
-  if (val === void 0 || val === "") {
-    const envPort = process.env.PORT;
-    if (envPort === void 0 || envPort === "") {
-      return 8080;
-    }
-    val = envPort;
-  }
-  if (typeof val === "string") {
-    const parsed = Number(val);
-    if (Number.isNaN(parsed)) {
-      return val;
-    }
-    val = parsed;
-  }
-  if (!Number.isFinite(val) || val < 0 || val > 65535) {
-    throw new Error(`Invalid port: ${String(val)}`);
-  }
-  return val;
-}
-function defaultOnError(error, port, logger) {
-  if (error.syscall !== "listen") {
-    throw error;
-  }
-  const bind = typeof port === "string" ? `Pipe ${port}` : `Port ${port}`;
-  if (error.code === "EACCES") {
-    logger.error(`${bind} requires elevated privileges`);
-    process.exit(1);
-  } else if (error.code === "EADDRINUSE") {
-    logger.error(`${bind} is already in use`);
-    process.exit(1);
-  } else {
-    throw error;
-  }
-}
-function startLocalServer(app, options = {}) {
-  const logger = options.logger ?? defaultLogger;
-  const port = normalizePort(options.port);
-  const host = options.host ?? process.env.HOST ?? "0.0.0.0";
-  const shutdownTimeout = options.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT;
-  const server = http.createServer(app);
-  app.set("port", port);
-  const onError = (error) => {
-    if (options.onError) {
-      options.onError(error);
-    } else {
-      defaultOnError(error, port, logger);
-    }
-  };
-  const onListening = () => {
-    const addr = server.address();
-    const bind = typeof addr === "string" ? `pipe ${addr}` : `port ${addr?.port}`;
-    logger.log(`Server running at http://${host}:${port}/ (${bind})`);
-    options.onListening?.();
-  };
-  server.on("error", onError);
-  server.on("listening", onListening);
-  const shutdown = async () => {
-    logger.log("Shutting down...");
-    try {
-      if (options.onShutdown) {
-        await options.onShutdown();
-      }
-    } catch (err) {
-      logger.error("onShutdown hook failed:", err);
-    }
-    await new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        server.closeAllConnections?.();
-        resolve();
-      }, shutdownTimeout);
-      server.close((err) => {
-        clearTimeout(timer);
-        if (err) {
-          logger.error("Server close error:", err);
-        }
-        resolve();
-      });
-    });
-    if (options.exitAfterShutdown) {
-      process.exit(0);
-    }
-  };
-  if (options.signals !== false) {
-    const list = options.signals === void 0 || options.signals === true ? DEFAULT_SIGNALS : options.signals;
-    for (const sig of list) {
-      process.once(sig, () => void shutdown());
-    }
-  }
-  const start = async () => {
-    try {
-      if (options.init) {
-        await options.init();
-      }
-      if (typeof port === "number") {
-        server.listen(port, host);
-      } else {
-        server.listen(port);
-      }
-    } catch (err) {
-      server.emit("error", err);
-    }
-  };
-  void start();
-  return {
-    server,
-    shutdown
-  };
-}
+import {
+  createExpressApp,
+  createServerlessHandler,
+  defaultRequestHook,
+  normalizePort,
+  startLocalServer
+} from "./chunk-SOW7OLVN.mjs";
 export {
   createExpressApp,
   createServerlessHandler,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@web-ts-toolkit/express-runtime",
   "description": "Express app factory plus serverless handler and local dev server helpers",
   "homepage": "https://web-ts-toolkit.pages.dev/docs/packages/express-runtime",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "sideEffects": false,
   "keywords": [
     "express",
@@ -24,6 +24,12 @@
       "import": "./index.mjs",
       "require": "./index.js",
       "default": "./index.js"
+    },
+    "./cli": {
+      "types": "./cli-api.d.ts",
+      "import": "./cli-api.mjs",
+      "require": "./cli-api.js",
+      "default": "./cli-api.js"
     }
   },
   "engines": {