skuba 14.0.0-replace-global-vars-20251121010036 → 14.0.0-test-private-templates-20260103062459

package/lib/utils/wait.js

@@ -1,15 +1,39 @@
-import { createTerseError } from "./error.js";
-import { pluralise } from "./logging.js";
-import { sleep } from "./sleep.js";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wait_exports = {};
+__export(wait_exports, {
+  throwOnTimeout: () => throwOnTimeout,
+  withTimeout: () => withTimeout
+});
+module.exports = __toCommonJS(wait_exports);
+var import_error = require("./error.js");
+var import_logging = require("./logging.js");
+var import_sleep = require("./sleep.js");
 const throwOnTimeout = async (promise, { s }) => {
   const result = await withTimeout(promise, { s });
   if (!result.ok) {
-    throw createTerseError(`Timed out after ${pluralise(s, "second")}`);
+    throw (0, import_error.createTerseError)(`Timed out after ${(0, import_logging.pluralise)(s, "second")}`);
   }
   return result.value;
 };
 const withTimeout = async (promise, { s }) => {
-  const timeout = sleep(s * 1e3);
+  const timeout = (0, import_sleep.sleep)(s * 1e3);
   try {
     return await Promise.race([
       Promise.resolve(promise).then((value) => ({ ok: true, value })),
@@ -19,8 +43,9 @@ const withTimeout = async (promise, { s }) => {
     timeout.clear?.();
   }
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   throwOnTimeout,
   withTimeout
-};
+});
 //# sourceMappingURL=wait.js.map

package/lib/utils/wait.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/utils/wait.ts"],
   "sourcesContent": ["import { createTerseError } from './error.js';\nimport { pluralise } from './logging.js';\nimport { sleep } from './sleep.js';\n\nexport const throwOnTimeout = async <T>(\n  promise: PromiseLike<T>,\n  { s }: { s: number },\n): Promise<T> => {\n  const result = await withTimeout(promise, { s });\n\n  if (!result.ok) {\n    throw createTerseError(`Timed out after ${pluralise(s, 'second')}`);\n  }\n\n  return result.value;\n};\n\ntype TimeoutResult<T> = { ok: true; value: T } | { ok: false };\n\nexport const withTimeout = async <T>(\n  promise: T | PromiseLike<T>,\n  { s }: { s: number },\n): Promise<TimeoutResult<T>> => {\n  const timeout = sleep(s * 1_000);\n\n  try {\n    return await Promise.race<TimeoutResult<T>>([\n      Promise.resolve(promise).then((value) => ({ ok: true, value })),\n      timeout.then(() => ({ ok: false })),\n    ]);\n  } finally {\n    timeout.clear?.();\n  }\n};\n"],
-  "mappings": "AAAA,SAAS,wBAAwB;AACjC,SAAS,iBAAiB;AAC1B,SAAS,aAAa;AAEf,MAAM,iBAAiB,OAC5B,SACA,EAAE,EAAE,MACW;AACf,QAAM,SAAS,MAAM,YAAY,SAAS,EAAE,EAAE,CAAC;AAE/C,MAAI,CAAC,OAAO,IAAI;AACd,UAAM,iBAAiB,mBAAmB,UAAU,GAAG,QAAQ,CAAC,EAAE;AAAA,EACpE;AAEA,SAAO,OAAO;AAChB;AAIO,MAAM,cAAc,OACzB,SACA,EAAE,EAAE,MAC0B;AAC9B,QAAM,UAAU,MAAM,IAAI,GAAK;AAE/B,MAAI;AACF,WAAO,MAAM,QAAQ,KAAuB;AAAA,MAC1C,QAAQ,QAAQ,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,IAAI,MAAM,MAAM,EAAE;AAAA,MAC9D,QAAQ,KAAK,OAAO,EAAE,IAAI,MAAM,EAAE;AAAA,IACpC,CAAC;AAAA,EACH,UAAE;AACA,YAAQ,QAAQ;AAAA,EAClB;AACF;",
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAiC;AACjC,qBAA0B;AAC1B,mBAAsB;AAEf,MAAM,iBAAiB,OAC5B,SACA,EAAE,EAAE,MACW;AACf,QAAM,SAAS,MAAM,YAAY,SAAS,EAAE,EAAE,CAAC;AAE/C,MAAI,CAAC,OAAO,IAAI;AACd,cAAM,+BAAiB,uBAAmB,0BAAU,GAAG,QAAQ,CAAC,EAAE;AAAA,EACpE;AAEA,SAAO,OAAO;AAChB;AAIO,MAAM,cAAc,OACzB,SACA,EAAE,EAAE,MAC0B;AAC9B,QAAM,cAAU,oBAAM,IAAI,GAAK;AAE/B,MAAI;AACF,WAAO,MAAM,QAAQ,KAAuB;AAAA,MAC1C,QAAQ,QAAQ,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,IAAI,MAAM,MAAM,EAAE;AAAA,MAC9D,QAAQ,KAAK,OAAO,EAAE,IAAI,MAAM,EAAE;AAAA,IACpC,CAAC;AAAA,EACH,UAAE;AACA,YAAQ,QAAQ;AAAA,EAClB;AACF;",
   "names": []
 }

package/lib/utils/worker.js

@@ -1,11 +1,35 @@
-import { inspect } from "util";
-import { Worker, parentPort, workerData } from "worker_threads";
-import { log } from "./logging.js";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var worker_exports = {};
+__export(worker_exports, {
+  execWorkerThread: () => execWorkerThread,
+  postWorkerOutput: () => postWorkerOutput
+});
+module.exports = __toCommonJS(worker_exports);
+var import_util = require("util");
+var import_worker_threads = require("worker_threads");
+var import_logging = require("./logging.js");
 const execWorkerThread = async (filepath, input) => {
   let output;
   let messageReceived = false;
   return new Promise(
-    (resolve, reject) => new Worker(filepath, {
+    (resolve, reject) => new import_worker_threads.Worker(filepath, {
       workerData: input
     }).on("error", reject).on(
       "exit",
@@ -20,19 +44,20 @@ const execWorkerThread = async (filepath, input) => {
     }).on("messageerror", (err) => reject(err))
   );
 };
-const postWorkerOutput = (fn, logger = log) => {
-  const port = parentPort;
+const postWorkerOutput = (fn, logger = import_logging.log) => {
+  const port = import_worker_threads.parentPort;
   if (!port) {
     logger.err("`postWorkerOutput` called outside of a worker thread context");
     process.exit(1);
   }
-  fn(workerData).then((output) => port.postMessage(output)).catch((err) => {
-    logger.err(inspect(err));
+  fn(import_worker_threads.workerData).then((output) => port.postMessage(output)).catch((err) => {
+    logger.err((0, import_util.inspect)(err));
     process.exit(1);
   });
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   execWorkerThread,
   postWorkerOutput
-};
+});
 //# sourceMappingURL=worker.js.map

package/lib/utils/worker.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/utils/worker.ts"],
   "sourcesContent": ["import { inspect } from 'util';\nimport { Worker, parentPort, workerData } from 'worker_threads';\n\nimport { log } from './logging.js';\n\n/**\n * Executes a script at `filepath` in a Node.js worker thread.\n */\nexport const execWorkerThread = async <Input, Output>(\n  filepath: string,\n  input: Input,\n) => {\n  let output: Output;\n  let messageReceived = false;\n\n  return new Promise<Output>((resolve, reject) =>\n    new Worker(filepath, {\n      workerData: input,\n    })\n      .on('error', reject)\n      .on('exit', (code) =>\n        messageReceived\n          ? resolve(output)\n          : reject(\n              new Error(\n                code\n                  ? `Worker thread failed with exit code ${code}`\n                  : 'Worker thread exited without posting a message',\n              ),\n            ),\n      )\n      .on('message', (message: Output) => {\n        // Defer promise resolution to `exit` so stdio can settle.\n        output = message;\n        messageReceived = true;\n      })\n      .on('messageerror', (err) => reject(err)),\n  );\n};\n\n/**\n * Runs a function in a Node.js worker thread context, forwarding the result\n * to the parent thread.\n */\nexport const postWorkerOutput = <Input, Output>(\n  fn: (input: Input) => Promise<Output>,\n  logger = log,\n) => {\n  const port = parentPort;\n\n  if (!port) {\n    logger.err('`postWorkerOutput` called outside of a worker thread context');\n\n    process.exit(1);\n  }\n\n  fn(workerData as Input)\n    .then((output) => port.postMessage(output))\n    .catch((err) => {\n      logger.err(inspect(err));\n\n      process.exit(1);\n    });\n};\n"],
-  "mappings": "AAAA,SAAS,eAAe;AACxB,SAAS,QAAQ,YAAY,kBAAkB;AAE/C,SAAS,WAAW;AAKb,MAAM,mBAAmB,OAC9B,UACA,UACG;AACH,MAAI;AACJ,MAAI,kBAAkB;AAEtB,SAAO,IAAI;AAAA,IAAgB,CAAC,SAAS,WACnC,IAAI,OAAO,UAAU;AAAA,MACnB,YAAY;AAAA,IACd,CAAC,EACE,GAAG,SAAS,MAAM,EAClB;AAAA,MAAG;AAAA,MAAQ,CAAC,SACX,kBACI,QAAQ,MAAM,IACd;AAAA,QACE,IAAI;AAAA,UACF,OACI,uCAAuC,IAAI,KAC3C;AAAA,QACN;AAAA,MACF;AAAA,IACN,EACC,GAAG,WAAW,CAAC,YAAoB;AAElC,eAAS;AACT,wBAAkB;AAAA,IACpB,CAAC,EACA,GAAG,gBAAgB,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,EAC5C;AACF;AAMO,MAAM,mBAAmB,CAC9B,IACA,SAAS,QACN;AACH,QAAM,OAAO;AAEb,MAAI,CAAC,MAAM;AACT,WAAO,IAAI,8DAA8D;AAEzE,YAAQ,KAAK,CAAC;AAAA,EAChB;AAEA,KAAG,UAAmB,EACnB,KAAK,CAAC,WAAW,KAAK,YAAY,MAAM,CAAC,EACzC,MAAM,CAAC,QAAQ;AACd,WAAO,IAAI,QAAQ,GAAG,CAAC;AAEvB,YAAQ,KAAK,CAAC;AAAA,EAChB,CAAC;AACL;",
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAwB;AACxB,4BAA+C;AAE/C,qBAAoB;AAKb,MAAM,mBAAmB,OAC9B,UACA,UACG;AACH,MAAI;AACJ,MAAI,kBAAkB;AAEtB,SAAO,IAAI;AAAA,IAAgB,CAAC,SAAS,WACnC,IAAI,6BAAO,UAAU;AAAA,MACnB,YAAY;AAAA,IACd,CAAC,EACE,GAAG,SAAS,MAAM,EAClB;AAAA,MAAG;AAAA,MAAQ,CAAC,SACX,kBACI,QAAQ,MAAM,IACd;AAAA,QACE,IAAI;AAAA,UACF,OACI,uCAAuC,IAAI,KAC3C;AAAA,QACN;AAAA,MACF;AAAA,IACN,EACC,GAAG,WAAW,CAAC,YAAoB;AAElC,eAAS;AACT,wBAAkB;AAAA,IACpB,CAAC,EACA,GAAG,gBAAgB,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,EAC5C;AACF;AAMO,MAAM,mBAAmB,CAC9B,IACA,SAAS,uBACN;AACH,QAAM,OAAO;AAEb,MAAI,CAAC,MAAM;AACT,WAAO,IAAI,8DAA8D;AAEzE,YAAQ,KAAK,CAAC;AAAA,EAChB;AAEA,KAAG,gCAAmB,EACnB,KAAK,CAAC,WAAW,KAAK,YAAY,MAAM,CAAC,EACzC,MAAM,CAAC,QAAQ;AACd,WAAO,QAAI,qBAAQ,GAAG,CAAC;AAEvB,YAAQ,KAAK,CAAC;AAAA,EAChB,CAAC;AACL;",
   "names": []
 }

package/lib/wrapper/function-arguments.d.js

@@ -1 +1,2 @@
+"use strict";
 //# sourceMappingURL=function-arguments.d.js.map

package/lib/wrapper/functionHandler.js

@@ -1,32 +1,63 @@
-import fnArgs from "function-arguments";
-import { log } from "../utils/logging.js";
-import { isFunction, isObject } from "../utils/validation.js";
-import {
-  createRequestListenerFromFunction,
-  serveRequestListener
-} from "./http.js";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var functionHandler_exports = {};
+__export(functionHandler_exports, {
+  runFunctionHandler: () => runFunctionHandler
+});
+module.exports = __toCommonJS(functionHandler_exports);
+var import_function_arguments = __toESM(require("function-arguments"));
+var import_logging = require("../utils/logging.js");
+var import_validation = require("../utils/validation.js");
+var import_http = require("./http.js");
 const runFunctionHandler = async ({
   availablePort,
   entryPoint,
   functionName
 }) => {
-  if (!isObject(entryPoint)) {
-    log.subtle(log.bold(functionName), "is not exported");
+  if (!(0, import_validation.isObject)(entryPoint)) {
+    import_logging.log.subtle(import_logging.log.bold(functionName), "is not exported");
     return;
   }
   const fn = entryPoint[functionName];
-  if (!isFunction(fn)) {
-    log.subtle(log.bold(functionName), "is not a function");
+  if (!(0, import_validation.isFunction)(fn)) {
+    import_logging.log.subtle(import_logging.log.bold(functionName), "is not a function");
     return;
   }
-  log.warn(
-    log.bold(functionName),
-    `(${fnArgs(fn).map((arg) => arg || "?").join(", ")})`
+  import_logging.log.warn(
+    import_logging.log.bold(functionName),
+    `(${(0, import_function_arguments.default)(fn).map((arg) => arg || "?").join(", ")})`
   );
-  const requestListener = createRequestListenerFromFunction(fn);
-  return serveRequestListener(requestListener, availablePort);
+  const requestListener = (0, import_http.createRequestListenerFromFunction)(fn);
+  return (0, import_http.serveRequestListener)(requestListener, availablePort);
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   runFunctionHandler
-};
+});
 //# sourceMappingURL=functionHandler.js.map

package/lib/wrapper/functionHandler.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/wrapper/functionHandler.ts"],
   "sourcesContent": ["import fnArgs from 'function-arguments';\n\nimport { log } from '../utils/logging.js';\nimport { isFunction, isObject } from '../utils/validation.js';\n\nimport {\n  createRequestListenerFromFunction,\n  serveRequestListener,\n} from './http.js';\n\ninterface Args {\n  availablePort?: number;\n  entryPoint: unknown;\n  functionName: string;\n}\n\n/**\n * Create an HTTP server that calls into an exported function.\n */\nexport const runFunctionHandler = async ({\n  availablePort,\n  entryPoint,\n  functionName,\n}: Args): Promise<void> => {\n  if (!isObject(entryPoint)) {\n    log.subtle(log.bold(functionName), 'is not exported');\n    return;\n  }\n\n  const fn = entryPoint[functionName];\n\n  if (!isFunction(fn)) {\n    log.subtle(log.bold(functionName), 'is not a function');\n    return;\n  }\n\n  log.warn(\n    log.bold(functionName),\n    `(${fnArgs(fn)\n      // Add a `?` placeholder for unnamed arguments.\n      .map((arg) => arg || '?')\n      .join(', ')})`,\n  );\n\n  const requestListener = createRequestListenerFromFunction(fn);\n\n  return serveRequestListener(requestListener, availablePort);\n};\n"],
-  "mappings": "AAAA,OAAO,YAAY;AAEnB,SAAS,WAAW;AACpB,SAAS,YAAY,gBAAgB;AAErC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAWA,MAAM,qBAAqB,OAAO;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF,MAA2B;AACzB,MAAI,CAAC,SAAS,UAAU,GAAG;AACzB,QAAI,OAAO,IAAI,KAAK,YAAY,GAAG,iBAAiB;AACpD;AAAA,EACF;AAEA,QAAM,KAAK,WAAW,YAAY;AAElC,MAAI,CAAC,WAAW,EAAE,GAAG;AACnB,QAAI,OAAO,IAAI,KAAK,YAAY,GAAG,mBAAmB;AACtD;AAAA,EACF;AAEA,MAAI;AAAA,IACF,IAAI,KAAK,YAAY;AAAA,IACrB,IAAI,OAAO,EAAE,EAEV,IAAI,CAAC,QAAQ,OAAO,GAAG,EACvB,KAAK,IAAI,CAAC;AAAA,EACf;AAEA,QAAM,kBAAkB,kCAAkC,EAAE;AAE5D,SAAO,qBAAqB,iBAAiB,aAAa;AAC5D;",
-  "names": []
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAAmB;AAEnB,qBAAoB;AACpB,wBAAqC;AAErC,kBAGO;AAWA,MAAM,qBAAqB,OAAO;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF,MAA2B;AACzB,MAAI,KAAC,4BAAS,UAAU,GAAG;AACzB,uBAAI,OAAO,mBAAI,KAAK,YAAY,GAAG,iBAAiB;AACpD;AAAA,EACF;AAEA,QAAM,KAAK,WAAW,YAAY;AAElC,MAAI,KAAC,8BAAW,EAAE,GAAG;AACnB,uBAAI,OAAO,mBAAI,KAAK,YAAY,GAAG,mBAAmB;AACtD;AAAA,EACF;AAEA,qBAAI;AAAA,IACF,mBAAI,KAAK,YAAY;AAAA,IACrB,QAAI,0BAAAA,SAAO,EAAE,EAEV,IAAI,CAAC,QAAQ,OAAO,GAAG,EACvB,KAAK,IAAI,CAAC;AAAA,EACf;AAEA,QAAM,sBAAkB,+CAAkC,EAAE;AAE5D,aAAO,kCAAqB,iBAAiB,aAAa;AAC5D;",
+  "names": ["fnArgs"]
 }

package/lib/wrapper/http.js

@@ -1,6 +1,40 @@
-import http from "http";
-import util from "util";
-import { startServer } from "./server.js";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  createRequestListenerFromFunction: () => createRequestListenerFromFunction,
+  serveRequestListener: () => serveRequestListener
+});
+module.exports = __toCommonJS(http_exports);
+var import_http = __toESM(require("http"));
+var import_util = __toESM(require("util"));
+var import_server = require("./server.js");
 const createRequestListenerFromFunction = (fn) => async (req, res) => {
   const writeResponse = (response) => new Promise(
     (resolve, reject) => response === void 0 ? res.end(resolve) : res.write(
@@ -21,15 +55,16 @@ const createRequestListenerFromFunction = (fn) => async (req, res) => {
     await writeResponse(JSON.stringify(response, null, 2));
   } catch (err) {
     res.writeHead(500);
-    await writeResponse(util.inspect(err));
+    await writeResponse(import_util.default.inspect(err));
   }
 };
 const serveRequestListener = (requestListener, port) => {
-  const server = http.createServer(requestListener);
-  return startServer(server, port);
+  const server = import_http.default.createServer(requestListener);
+  return (0, import_server.startServer)(server, port);
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   createRequestListenerFromFunction,
   serveRequestListener
-};
+});
 //# sourceMappingURL=http.js.map

package/lib/wrapper/http.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/wrapper/http.ts"],
   "sourcesContent": ["import http from 'http';\nimport util from 'util';\n\nimport { startServer } from './server.js';\n\n/**\n * Create an HTTP request listener based on the supplied function.\n *\n * - The request body is JSON parsed and passed into the function as parameters.\n * - The function's return value is JSON stringified into the response body.\n */\nexport const createRequestListenerFromFunction =\n  (fn: (...args: unknown[]) => Promise<unknown>): http.RequestListener =>\n  async (req, res) => {\n    const writeResponse = (response: unknown) =>\n      new Promise<void>((resolve, reject) =>\n        response === undefined\n          ? res.end(resolve)\n          : res.write(response, 'utf8', (err) =>\n              err ? reject(err) : res.end(resolve),\n            ),\n      );\n\n    try {\n      const requestBody = await new Promise<string>((resolve, reject) => {\n        const data: Buffer[] = [];\n\n        req\n          .on('data', (chunk: Buffer) => data.push(chunk))\n          .on('end', () => resolve(Buffer.concat(data).toString()))\n          .on('error', (err) => reject(err));\n      });\n\n      // Treat an empty body as no arguments\n      const jsonRequest: unknown = requestBody ? JSON.parse(requestBody) : [];\n\n      // Pass a non-array request body as the first parameter\n      const args: unknown[] = Array.isArray(jsonRequest)\n        ? jsonRequest\n        : [jsonRequest];\n\n      const response: unknown = await fn(...args);\n\n      res.writeHead(200, { 'Content-Type': 'application/json' });\n\n      await writeResponse(JSON.stringify(response, null, 2));\n    } catch (err) {\n      res.writeHead(500);\n\n      await writeResponse(util.inspect(err));\n    }\n  };\n\n/**\n * Create a HTTP server based on the supplied `http.RequestListener`.\n *\n * This function resolves when the server is closed.\n */\nexport const serveRequestListener = (\n  requestListener: http.RequestListener,\n  port?: number,\n) => {\n  const server = http.createServer(requestListener);\n  return startServer(server, port);\n};\n"],
-  "mappings": "AAAA,OAAO,UAAU;AACjB,OAAO,UAAU;AAEjB,SAAS,mBAAmB;AAQrB,MAAM,oCACX,CAAC,OACD,OAAO,KAAK,QAAQ;AAClB,QAAM,gBAAgB,CAAC,aACrB,IAAI;AAAA,IAAc,CAAC,SAAS,WAC1B,aAAa,SACT,IAAI,IAAI,OAAO,IACf,IAAI;AAAA,MAAM;AAAA,MAAU;AAAA,MAAQ,CAAC,QAC3B,MAAM,OAAO,GAAG,IAAI,IAAI,IAAI,OAAO;AAAA,IACrC;AAAA,EACN;AAEF,MAAI;AACF,UAAM,cAAc,MAAM,IAAI,QAAgB,CAAC,SAAS,WAAW;AACjE,YAAM,OAAiB,CAAC;AAExB,UACG,GAAG,QAAQ,CAAC,UAAkB,KAAK,KAAK,KAAK,CAAC,EAC9C,GAAG,OAAO,MAAM,QAAQ,OAAO,OAAO,IAAI,EAAE,SAAS,CAAC,CAAC,EACvD,GAAG,SAAS,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,IACrC,CAAC;AAGD,UAAM,cAAuB,cAAc,KAAK,MAAM,WAAW,IAAI,CAAC;AAGtE,UAAM,OAAkB,MAAM,QAAQ,WAAW,IAC7C,cACA,CAAC,WAAW;AAEhB,UAAM,WAAoB,MAAM,GAAG,GAAG,IAAI;AAE1C,QAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AAEzD,UAAM,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,EACvD,SAAS,KAAK;AACZ,QAAI,UAAU,GAAG;AAEjB,UAAM,cAAc,KAAK,QAAQ,GAAG,CAAC;AAAA,EACvC;AACF;AAOK,MAAM,uBAAuB,CAClC,iBACA,SACG;AACH,QAAM,SAAS,KAAK,aAAa,eAAe;AAChD,SAAO,YAAY,QAAQ,IAAI;AACjC;",
-  "names": []
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AACjB,kBAAiB;AAEjB,oBAA4B;AAQrB,MAAM,oCACX,CAAC,OACD,OAAO,KAAK,QAAQ;AAClB,QAAM,gBAAgB,CAAC,aACrB,IAAI;AAAA,IAAc,CAAC,SAAS,WAC1B,aAAa,SACT,IAAI,IAAI,OAAO,IACf,IAAI;AAAA,MAAM;AAAA,MAAU;AAAA,MAAQ,CAAC,QAC3B,MAAM,OAAO,GAAG,IAAI,IAAI,IAAI,OAAO;AAAA,IACrC;AAAA,EACN;AAEF,MAAI;AACF,UAAM,cAAc,MAAM,IAAI,QAAgB,CAAC,SAAS,WAAW;AACjE,YAAM,OAAiB,CAAC;AAExB,UACG,GAAG,QAAQ,CAAC,UAAkB,KAAK,KAAK,KAAK,CAAC,EAC9C,GAAG,OAAO,MAAM,QAAQ,OAAO,OAAO,IAAI,EAAE,SAAS,CAAC,CAAC,EACvD,GAAG,SAAS,CAAC,QAAQ,OAAO,GAAG,CAAC;AAAA,IACrC,CAAC;AAGD,UAAM,cAAuB,cAAc,KAAK,MAAM,WAAW,IAAI,CAAC;AAGtE,UAAM,OAAkB,MAAM,QAAQ,WAAW,IAC7C,cACA,CAAC,WAAW;AAEhB,UAAM,WAAoB,MAAM,GAAG,GAAG,IAAI;AAE1C,QAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AAEzD,UAAM,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,EACvD,SAAS,KAAK;AACZ,QAAI,UAAU,GAAG;AAEjB,UAAM,cAAc,YAAAA,QAAK,QAAQ,GAAG,CAAC;AAAA,EACvC;AACF;AAOK,MAAM,uBAAuB,CAClC,iBACA,SACG;AACH,QAAM,SAAS,YAAAC,QAAK,aAAa,eAAe;AAChD,aAAO,2BAAY,QAAQ,IAAI;AACjC;",
+  "names": ["util", "http"]
 }

package/lib/wrapper/index.js

@@ -1,15 +1,16 @@
-import { handleCliError } from "../utils/error.js";
-import { log } from "../utils/logging.js";
-import { main } from "./main.js";
+"use strict";
+var import_error = require("../utils/error.js");
+var import_logging = require("../utils/logging.js");
+var import_main = require("./main.js");
 const ENTRY_POINT_VAR = "__SKUBA_ENTRY_POINT";
 const PORT_VAR = "__SKUBA_PORT";
 const rawEntryPoint = process.env[ENTRY_POINT_VAR];
 if (!rawEntryPoint) {
-  throw new Error(`Missing environment variable: ${log.bold(ENTRY_POINT_VAR)}`);
+  throw new Error(`Missing environment variable: ${import_logging.log.bold(ENTRY_POINT_VAR)}`);
 }
 const rawPort = process.env[PORT_VAR];
 if (!rawPort) {
-  throw new Error(`Missing environment variable: ${log.bold(PORT_VAR)}`);
+  throw new Error(`Missing environment variable: ${import_logging.log.bold(PORT_VAR)}`);
 }
-main(rawEntryPoint, rawPort).catch(handleCliError);
+(0, import_main.main)(rawEntryPoint, rawPort).catch(import_error.handleCliError);
 //# sourceMappingURL=index.js.map

package/lib/wrapper/index.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/wrapper/index.ts"],
   "sourcesContent": ["/**\n * Wrapper around an entry point provided to `skuba node` or `skuba start`.\n *\n * Beyond simply loading the entry point, it supports the following features:\n *\n * - If you set the entry point to an exported function like `src/app#handler`,\n *   it will spin up a local HTTP server that calls into the function.\n *\n * - If you `export =` or `export default` an Express or Koa application,\n *   it will spin up a local HTTP server based on the request listener.\n */\n\nimport { handleCliError } from '../utils/error.js';\nimport { log } from '../utils/logging.js';\n\nimport { main } from './main.js';\n\nconst ENTRY_POINT_VAR = '__SKUBA_ENTRY_POINT';\nconst PORT_VAR = '__SKUBA_PORT';\n\nconst rawEntryPoint = process.env[ENTRY_POINT_VAR];\nif (!rawEntryPoint) {\n  throw new Error(`Missing environment variable: ${log.bold(ENTRY_POINT_VAR)}`);\n}\n\nconst rawPort = process.env[PORT_VAR];\nif (!rawPort) {\n  throw new Error(`Missing environment variable: ${log.bold(PORT_VAR)}`);\n}\n\nmain(rawEntryPoint, rawPort).catch(handleCliError);\n"],
-  "mappings": "AAYA,SAAS,sBAAsB;AAC/B,SAAS,WAAW;AAEpB,SAAS,YAAY;AAErB,MAAM,kBAAkB;AACxB,MAAM,WAAW;AAEjB,MAAM,gBAAgB,QAAQ,IAAI,eAAe;AACjD,IAAI,CAAC,eAAe;AAClB,QAAM,IAAI,MAAM,iCAAiC,IAAI,KAAK,eAAe,CAAC,EAAE;AAC9E;AAEA,MAAM,UAAU,QAAQ,IAAI,QAAQ;AACpC,IAAI,CAAC,SAAS;AACZ,QAAM,IAAI,MAAM,iCAAiC,IAAI,KAAK,QAAQ,CAAC,EAAE;AACvE;AAEA,KAAK,eAAe,OAAO,EAAE,MAAM,cAAc;",
+  "mappings": ";AAYA,mBAA+B;AAC/B,qBAAoB;AAEpB,kBAAqB;AAErB,MAAM,kBAAkB;AACxB,MAAM,WAAW;AAEjB,MAAM,gBAAgB,QAAQ,IAAI,eAAe;AACjD,IAAI,CAAC,eAAe;AAClB,QAAM,IAAI,MAAM,iCAAiC,mBAAI,KAAK,eAAe,CAAC,EAAE;AAC9E;AAEA,MAAM,UAAU,QAAQ,IAAI,QAAQ;AACpC,IAAI,CAAC,SAAS;AACZ,QAAM,IAAI,MAAM,iCAAiC,mBAAI,KAAK,QAAQ,CAAC,EAAE;AACvE;AAAA,IAEA,kBAAK,eAAe,OAAO,EAAE,MAAM,2BAAc;",
   "names": []
 }

package/lib/wrapper/main.js

@@ -1,13 +1,47 @@
-import path from "path";
-import { runFunctionHandler } from "./functionHandler.js";
-import { runRequestListener } from "./requestListener.js";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var main_exports = {};
+__export(main_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(main_exports);
+var import_path = __toESM(require("path"));
+var import_functionHandler = require("./functionHandler.js");
+var import_requestListener = require("./requestListener.js");
 const main = async (rawEntryPoint, rawPort) => {
   const availablePort = Number(rawPort) || void 0;
-  const [modulePath, functionName] = path.join(process.cwd(), rawEntryPoint).split("#", 2);
-  const entryPoint = await import(modulePath);
-  return functionName ? runFunctionHandler({ availablePort, entryPoint, functionName }) : runRequestListener({ availablePort, entryPoint });
+  const [modulePath, functionName] = import_path.default.join(process.cwd(), rawEntryPoint).split("#", 2);
+  const entryPoint = require(modulePath);
+  return functionName ? (0, import_functionHandler.runFunctionHandler)({ availablePort, entryPoint, functionName }) : (0, import_requestListener.runRequestListener)({ availablePort, entryPoint });
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   main
-};
+});
 //# sourceMappingURL=main.js.map

package/lib/wrapper/main.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/wrapper/main.ts"],
-  "sourcesContent": ["import path from 'path';\n\nimport { runFunctionHandler } from './functionHandler.js';\nimport { runRequestListener } from './requestListener.js';\n\nexport const main = async (rawEntryPoint: string, rawPort: string) => {\n  const availablePort = Number(rawPort) || undefined;\n\n  // Support exported function targeting, e.g. `src/module.ts#callMeMaybe`\n  const [modulePath, functionName] = path\n    .join(process.cwd(), rawEntryPoint)\n    .split('#', 2);\n\n  // Load entry point as module\n\n  const entryPoint = (await import(modulePath as string)) as unknown;\n\n  return functionName\n    ? runFunctionHandler({ availablePort, entryPoint, functionName })\n    : runRequestListener({ availablePort, entryPoint });\n};\n"],
-  "mappings": "AAAA,OAAO,UAAU;AAEjB,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AAE5B,MAAM,OAAO,OAAO,eAAuB,YAAoB;AACpE,QAAM,gBAAgB,OAAO,OAAO,KAAK;AAGzC,QAAM,CAAC,YAAY,YAAY,IAAI,KAChC,KAAK,QAAQ,IAAI,GAAG,aAAa,EACjC,MAAM,KAAK,CAAC;AAIf,QAAM,aAAc,MAAM,OAAO;AAEjC,SAAO,eACH,mBAAmB,EAAE,eAAe,YAAY,aAAa,CAAC,IAC9D,mBAAmB,EAAE,eAAe,WAAW,CAAC;AACtD;",
-  "names": []
+  "sourcesContent": ["import path from 'path';\n\nimport { runFunctionHandler } from './functionHandler.js';\nimport { runRequestListener } from './requestListener.js';\n\nexport const main = async (rawEntryPoint: string, rawPort: string) => {\n  const availablePort = Number(rawPort) || undefined;\n\n  // Support exported function targeting, e.g. `src/module.ts#callMeMaybe`\n  const [modulePath, functionName] = path\n    .join(process.cwd(), rawEntryPoint)\n    .split('#', 2);\n\n  // Load entry point as module\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const entryPoint = require(modulePath as string) as unknown;\n\n  return functionName\n    ? runFunctionHandler({ availablePort, entryPoint, functionName })\n    : runRequestListener({ availablePort, entryPoint });\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,6BAAmC;AACnC,6BAAmC;AAE5B,MAAM,OAAO,OAAO,eAAuB,YAAoB;AACpE,QAAM,gBAAgB,OAAO,OAAO,KAAK;AAGzC,QAAM,CAAC,YAAY,YAAY,IAAI,YAAAA,QAChC,KAAK,QAAQ,IAAI,GAAG,aAAa,EACjC,MAAM,KAAK,CAAC;AAIf,QAAM,aAAa,QAAQ,UAAoB;AAE/C,SAAO,mBACH,2CAAmB,EAAE,eAAe,YAAY,aAAa,CAAC,QAC9D,2CAAmB,EAAE,eAAe,WAAW,CAAC;AACtD;",
+  "names": ["path"]
 }

package/lib/wrapper/requestListener.js

@@ -1,8 +1,41 @@
-import http from "http";
-import { isFunction, isIpPort, isObject } from "../utils/validation.js";
-import { serveRequestListener } from "./http.js";
-import { startServer } from "./server.js";
-const isConfig = (data) => isFunction(data) || isObject(data);
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requestListener_exports = {};
+__export(requestListener_exports, {
+  runRequestListener: () => runRequestListener
+});
+module.exports = __toCommonJS(requestListener_exports);
+var import_http = __toESM(require("http"));
+var import_validation = require("../utils/validation.js");
+var import_http2 = require("./http.js");
+var import_server = require("./server.js");
+const isConfig = (data) => (0, import_validation.isFunction)(data) || (0, import_validation.isObject)(data);
 const runRequestListener = async ({
   availablePort,
   entryPoint
@@ -17,20 +50,21 @@ const runRequestListener = async ({
   if (Object.keys(config).length === 0) {
     return;
   }
-  const port = isIpPort(config.port) ? config.port : availablePort;
-  if (typeof config !== "function" && config instanceof http.Server) {
-    return startServer(config, port);
+  const port = (0, import_validation.isIpPort)(config.port) ? config.port : availablePort;
+  if (typeof config !== "function" && config instanceof import_http.default.Server) {
+    return (0, import_server.startServer)(config, port);
   }
-  if (typeof config !== "function" && config.server && config.server instanceof http.Server) {
-    return startServer(config.server, port);
+  if (typeof config !== "function" && config.server && config.server instanceof import_http.default.Server) {
+    return (0, import_server.startServer)(config.server, port);
   }
   const requestListener = typeof config === "function" ? config : config.requestListener ?? config.callback?.();
   if (typeof requestListener !== "function") {
     return;
   }
-  return serveRequestListener(requestListener, port);
+  return (0, import_http2.serveRequestListener)(requestListener, port);
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   runRequestListener
-};
+});
 //# sourceMappingURL=requestListener.js.map

package/lib/wrapper/requestListener.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/wrapper/requestListener.ts"],
   "sourcesContent": ["import http from 'http';\n\nimport { isFunction, isIpPort, isObject } from '../utils/validation.js';\n\nimport { serveRequestListener } from './http.js';\nimport { startServer } from './server.js';\n\n// Express compatibility\ninterface FunctionConfig extends http.RequestListener {\n  port?: number;\n}\n\ninterface ObjectConfig {\n  // Koa compatibility\n  callback?: () => http.RequestListener;\n\n  requestListener?: http.RequestListener;\n\n  // Fastify compatibility\n  server?: http.Server;\n\n  default?: Promise<unknown>;\n  port?: unknown;\n}\n\nconst isConfig = (\n  data: unknown,\n): data is Promise<FunctionConfig> | Promise<ObjectConfig> =>\n  isFunction(data) || isObject(data);\n\ninterface Args {\n  availablePort?: number;\n  entryPoint: unknown;\n}\n\n/**\n * Create an HTTP server that calls into an exported `http.RequestListener`.\n *\n * This supports Express and Koa applications out of the box.\n */\nexport const runRequestListener = async ({\n  availablePort,\n  entryPoint,\n}: Args): Promise<void> => {\n  if (!isConfig(entryPoint)) {\n    // Assume an executable script with weird exports\n    return;\n  }\n\n  let config: FunctionConfig | ObjectConfig = await entryPoint;\n\n  if (typeof config === 'object' && isConfig(config.default)) {\n    // Prefer `export default` over `export =`\n    config = await config.default;\n  }\n\n  if (Object.keys(config).length === 0) {\n    // Assume an executable script with no exports\n    return;\n  }\n\n  const port = isIpPort(config.port) ? config.port : availablePort;\n\n  // http.Server support\n  if (typeof config !== 'function' && config instanceof http.Server) {\n    return startServer(config, port);\n  }\n\n  // Fastify workaround\n  if (\n    typeof config !== 'function' &&\n    config.server &&\n    config.server instanceof http.Server\n  ) {\n    return startServer(config.server, port);\n  }\n\n  const requestListener =\n    typeof config === 'function'\n      ? config\n      : (config.requestListener ?? config.callback?.());\n\n  if (typeof requestListener !== 'function') {\n    // Assume an executable script with non-request listener exports\n    return;\n  }\n\n  return serveRequestListener(requestListener, port);\n};\n"],
-  "mappings": "AAAA,OAAO,UAAU;AAEjB,SAAS,YAAY,UAAU,gBAAgB;AAE/C,SAAS,4BAA4B;AACrC,SAAS,mBAAmB;AAoB5B,MAAM,WAAW,CACf,SAEA,WAAW,IAAI,KAAK,SAAS,IAAI;AAY5B,MAAM,qBAAqB,OAAO;AAAA,EACvC;AAAA,EACA;AACF,MAA2B;AACzB,MAAI,CAAC,SAAS,UAAU,GAAG;AAEzB;AAAA,EACF;AAEA,MAAI,SAAwC,MAAM;AAElD,MAAI,OAAO,WAAW,YAAY,SAAS,OAAO,OAAO,GAAG;AAE1D,aAAS,MAAM,OAAO;AAAA,EACxB;AAEA,MAAI,OAAO,KAAK,MAAM,EAAE,WAAW,GAAG;AAEpC;AAAA,EACF;AAEA,QAAM,OAAO,SAAS,OAAO,IAAI,IAAI,OAAO,OAAO;AAGnD,MAAI,OAAO,WAAW,cAAc,kBAAkB,KAAK,QAAQ;AACjE,WAAO,YAAY,QAAQ,IAAI;AAAA,EACjC;AAGA,MACE,OAAO,WAAW,cAClB,OAAO,UACP,OAAO,kBAAkB,KAAK,QAC9B;AACA,WAAO,YAAY,OAAO,QAAQ,IAAI;AAAA,EACxC;AAEA,QAAM,kBACJ,OAAO,WAAW,aACd,SACC,OAAO,mBAAmB,OAAO,WAAW;AAEnD,MAAI,OAAO,oBAAoB,YAAY;AAEzC;AAAA,EACF;AAEA,SAAO,qBAAqB,iBAAiB,IAAI;AACnD;",
-  "names": []
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,wBAA+C;AAE/C,IAAAA,eAAqC;AACrC,oBAA4B;AAoB5B,MAAM,WAAW,CACf,aAEA,8BAAW,IAAI,SAAK,4BAAS,IAAI;AAY5B,MAAM,qBAAqB,OAAO;AAAA,EACvC;AAAA,EACA;AACF,MAA2B;AACzB,MAAI,CAAC,SAAS,UAAU,GAAG;AAEzB;AAAA,EACF;AAEA,MAAI,SAAwC,MAAM;AAElD,MAAI,OAAO,WAAW,YAAY,SAAS,OAAO,OAAO,GAAG;AAE1D,aAAS,MAAM,OAAO;AAAA,EACxB;AAEA,MAAI,OAAO,KAAK,MAAM,EAAE,WAAW,GAAG;AAEpC;AAAA,EACF;AAEA,QAAM,WAAO,4BAAS,OAAO,IAAI,IAAI,OAAO,OAAO;AAGnD,MAAI,OAAO,WAAW,cAAc,kBAAkB,YAAAC,QAAK,QAAQ;AACjE,eAAO,2BAAY,QAAQ,IAAI;AAAA,EACjC;AAGA,MACE,OAAO,WAAW,cAClB,OAAO,UACP,OAAO,kBAAkB,YAAAA,QAAK,QAC9B;AACA,eAAO,2BAAY,OAAO,QAAQ,IAAI;AAAA,EACxC;AAEA,QAAM,kBACJ,OAAO,WAAW,aACd,SACC,OAAO,mBAAmB,OAAO,WAAW;AAEnD,MAAI,OAAO,oBAAoB,YAAY;AAEzC;AAAA,EACF;AAEA,aAAO,mCAAqB,iBAAiB,IAAI;AACnD;",
+  "names": ["import_http", "http"]
 }

package/lib/wrapper/server.js

@@ -1,11 +1,35 @@
-import { log } from "../utils/logging.js";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_logging = require("../utils/logging.js");
 const startServer = (server, port) => new Promise(
   (resolve, reject) => server.listen(port).on("close", resolve).on("error", reject).on("listening", () => {
     const address = server.address();
-    log.ok("listening on port", log.bold(String(address.port)));
+    import_logging.log.ok("listening on port", import_logging.log.bold(String(address.port)));
   })
 );
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   startServer
-};
+});
 //# sourceMappingURL=server.js.map

package/lib/wrapper/server.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/wrapper/server.ts"],
   "sourcesContent": ["import type http from 'http';\nimport type { AddressInfo } from 'net';\n\nimport { log } from '../utils/logging.js';\n\n/**\n * Returns a HTTP server wrapped in a promise\n *\n * This function resolves when the server is closed.\n */\nexport const startServer = (server: http.Server, port?: number) =>\n  new Promise<void>((resolve, reject) =>\n    server\n      .listen(port)\n      .on('close', resolve)\n      .on('error', reject)\n      .on('listening', () => {\n        const address = server.address() as AddressInfo;\n\n        log.ok('listening on port', log.bold(String(address.port)));\n      }),\n  );\n"],
-  "mappings": "AAGA,SAAS,WAAW;AAOb,MAAM,cAAc,CAAC,QAAqB,SAC/C,IAAI;AAAA,EAAc,CAAC,SAAS,WAC1B,OACG,OAAO,IAAI,EACX,GAAG,SAAS,OAAO,EACnB,GAAG,SAAS,MAAM,EAClB,GAAG,aAAa,MAAM;AACrB,UAAM,UAAU,OAAO,QAAQ;AAE/B,QAAI,GAAG,qBAAqB,IAAI,KAAK,OAAO,QAAQ,IAAI,CAAC,CAAC;AAAA,EAC5D,CAAC;AACL;",
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,qBAAoB;AAOb,MAAM,cAAc,CAAC,QAAqB,SAC/C,IAAI;AAAA,EAAc,CAAC,SAAS,WAC1B,OACG,OAAO,IAAI,EACX,GAAG,SAAS,OAAO,EACnB,GAAG,SAAS,MAAM,EAClB,GAAG,aAAa,MAAM;AACrB,UAAM,UAAU,OAAO,QAAQ;AAE/B,uBAAI,GAAG,qBAAqB,mBAAI,KAAK,OAAO,QAAQ,IAAI,CAAC,CAAC;AAAA,EAC5D,CAAC;AACL;",
   "names": []
 }