equipped 5.3.0 → 5.3.2

package/dist/cjs/server/adapters/express/index.cjs

@@ -46,7 +46,7 @@ var import_pino_http = require("pino-http");
 // src/instance/index.ts
 var import_pino = __toESM(require("pino"), 1);
 var import_ulid = require("ulid");
-var import_valleyed9 = require("valleyed");
+var import_valleyed8 = require("valleyed");
 
 // src/errors/equippedError.ts
 var EquippedError = class extends Error {
@@ -73,7 +73,7 @@ var import_cors = require("@fastify/cors");
 var import_cors2 = require("cors");
 var import_socket = require("socket.io");
 var import_supertest = __toESM(require("supertest"), 1);
-var import_valleyed6 = require("valleyed");
+var import_valleyed5 = require("valleyed");
 
 // src/events/adapters/base.ts
 var EventBus = class {
@@ -426,170 +426,6 @@ var openapi = (config) => {
   };
 };
 
-// src/utilities/configurable.ts
-var import_valleyed5 = require("valleyed");
-function configurable(pipeFn, base) {
-  const pipe = pipeFn();
-  import_valleyed5.v.compile(pipe);
-  class Configurable extends base {
-    constructor(config, ...baseArgs) {
-      super(...baseArgs);
-      this.config = config;
-    }
-    static create(input, ...args) {
-      const r = import_valleyed5.v.validate(pipe, input);
-      if (!r.valid) throw r.error;
-      return new this(r.value, ...args);
-    }
-  }
-  return Configurable;
-}
-if (void 0) {
-  const { describe, test, expect, expectTypeOf } = void 0;
-  const { v: v8 } = null;
-  const testPipe = () => v8.object({
-    host: v8.string(),
-    port: v8.number()
-  });
-  class TestBase {
-    baseValue;
-    constructor() {
-      this.baseValue = "base";
-    }
-  }
-  class TestBaseWithArgs {
-    label;
-    constructor(label) {
-      this.label = label;
-    }
-  }
-  describe("configurable", () => {
-    test("validation runs in static create before constructor body executes", () => {
-      let constructorRan = false;
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-          constructorRan = true;
-        }
-      }
-      expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
-      expect(constructorRan).toBe(false);
-      MyClass.create({ host: "localhost", port: 3e3 });
-      expect(constructorRan).toBe(true);
-    });
-    test("constructor receives validated value", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      let receivedConfig;
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-          receivedConfig = this.config;
-        }
-      }
-      MyClass.create({ host: "localhost", port: 3e3 });
-      expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
-    });
-    test("external new is a compile error", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-      }
-      void (() => new MyClass({ host: "localhost", port: 3e3 }));
-    });
-    test("static Config resolves to PipeOutput<P> at the type level", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-      }
-      expectTypeOf().toEqualTypeOf();
-      expect(MyClass.create).toBeTypeOf("function");
-    });
-    test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        extra;
-        constructor(config, extra) {
-          super(config);
-          this.extra = extra;
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
-      expect(instance.extra).toBe(42);
-      expectTypeOf(instance).toHaveProperty("extra");
-      expectTypeOf(instance.extra).toEqualTypeOf();
-      void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
-    });
-    test("base-args forwarding works for non-zero-arg bases", () => {
-      const Wrapped = configurable(testPipe, TestBaseWithArgs);
-      class MyClass extends Wrapped {
-        constructor(config, label) {
-          super(config, label);
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
-      expect(instance.label).toBe("test-label");
-    });
-    test("config is accessible as protected readonly on instances", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-        getHost() {
-          return this.config.host;
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 });
-      expect(instance.getHost()).toBe("localhost");
-    });
-    test("accepts an abstract base class", () => {
-      class AbstractBase {
-      }
-      const Wrapped = configurable(testPipe, AbstractBase);
-      class Concrete extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-        greet() {
-          return `hello from ${this.config.host}`;
-        }
-      }
-      const instance = Concrete.create({ host: "localhost", port: 3e3 });
-      expect(instance.greet()).toBe("hello from localhost");
-      expectTypeOf(instance).toHaveProperty("config");
-    });
-  });
-}
-
-// src/utilities/json.ts
-var parseJSONValue = (data) => {
-  try {
-    if (data?.constructor?.name !== "String") return data;
-    return JSON.parse(data);
-  } catch {
-    return data;
-  }
-};
-function parseJSONObject(data) {
-  return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, parseJSONValue(value)]));
-}
-
-// src/utilities/media.ts
-var import_music_metadata = require("music-metadata");
-var getMediaDuration = async (buffer) => {
-  try {
-    const meta = await (0, import_music_metadata.parseBuffer)(buffer);
-    return meta.format.duration ?? 0;
-  } catch {
-    return 0;
-  }
-};
-
 // src/server/requests.ts
 var Request = class {
   ip;
@@ -618,8 +454,10 @@ var Request = class {
     this.params = params;
     this.cookies = cookies;
     this.headers = headers;
-    this.query = parseJSONObject(query);
-    this.body = Object.assign(parseJSONObject(body), files);
+    const hasFiles = Object.keys(files).length > 0;
+    const bodyFields = body && typeof body === "object" && !Array.isArray(body) ? body : {};
+    this.query = query;
+    this.body = hasFiles ? Object.assign({}, bodyFields, files) : body;
   }
   pipe(stream, opts = {}) {
     return new Response({ ...opts, piped: true, body: stream });
@@ -665,6 +503,83 @@ var Response = class {
     });
   }
 };
+if (void 0) {
+  const { describe, expect, test } = void 0;
+  describe("Request", () => {
+    test("preserves adapter-provided query and body values without JSON normalization", () => {
+      const query = {
+        count: "10",
+        active: "true",
+        filter: '{"name":"test"}',
+        quoted: '"value"'
+      };
+      const body = {
+        count: "10",
+        active: "false",
+        payload: '{"nested":true}',
+        quoted: '"value"'
+      };
+      const request = new Request({
+        ip: void 0,
+        body,
+        cookies: {},
+        params: {},
+        query,
+        method: "post",
+        path: "/items",
+        headers: {},
+        files: {}
+      });
+      expect(request.query).toEqual(query);
+      expect(request.body).toEqual(body);
+    });
+    test("continues merging uploaded files into body fields without parsing string fields", () => {
+      const file = {
+        name: "avatar.png",
+        type: "image/png",
+        size: 4,
+        isTruncated: false,
+        data: Buffer.from("file"),
+        duration: 0
+      };
+      const body = { metadata: '{"alt":"avatar"}' };
+      const request = new Request({
+        ip: void 0,
+        body,
+        cookies: {},
+        params: {},
+        query: {},
+        method: "post",
+        path: "/upload",
+        headers: {},
+        files: { avatar: [file] }
+      });
+      expect(request.body).toEqual({ metadata: '{"alt":"avatar"}', avatar: [file] });
+    });
+    test("does not spread non-object body values when uploaded files are present", () => {
+      const file = {
+        name: "avatar.png",
+        type: "image/png",
+        size: 4,
+        isTruncated: false,
+        data: Buffer.from("file"),
+        duration: 0
+      };
+      const request = new Request({
+        ip: void 0,
+        body: "raw text body",
+        cookies: {},
+        params: {},
+        query: {},
+        method: "post",
+        path: "/upload",
+        headers: {},
+        files: { avatar: [file] }
+      });
+      expect(request.body).toEqual({ avatar: [file] });
+    });
+  });
+}
 
 // src/server/requests-auth-methods/base.ts
 var import_node_http2 = require("http2");
@@ -795,50 +710,50 @@ var SocketEmitter = class {
 };
 
 // src/server/adapters/base.ts
-var serverConfigPipe = () => import_valleyed6.v.object({
-  port: import_valleyed6.v.number(),
-  cors: import_valleyed6.v.optional(
-    import_valleyed6.v.object({
-      origin: import_valleyed6.v.optional(import_valleyed6.v.or([import_valleyed6.v.array(import_valleyed6.v.string()), import_valleyed6.v.is(true)])),
-      methods: import_valleyed6.v.optional(import_valleyed6.v.array(import_valleyed6.v.in(Object.values(Methods)))),
-      credentials: import_valleyed6.v.optional(import_valleyed6.v.boolean())
+var serverConfigPipe = () => import_valleyed5.v.object({
+  port: import_valleyed5.v.number(),
+  cors: import_valleyed5.v.optional(
+    import_valleyed5.v.object({
+      origin: import_valleyed5.v.optional(import_valleyed5.v.or([import_valleyed5.v.array(import_valleyed5.v.string()), import_valleyed5.v.is(true)])),
+      methods: import_valleyed5.v.optional(import_valleyed5.v.array(import_valleyed5.v.in(Object.values(Methods)))),
+      credentials: import_valleyed5.v.optional(import_valleyed5.v.boolean())
     })
   ),
-  eventBus: import_valleyed6.v.optional(import_valleyed6.v.instanceOf(EventBus)),
-  publicPath: import_valleyed6.v.optional(import_valleyed6.v.string()),
-  healthPath: import_valleyed6.v.optional(import_valleyed6.v.string()),
-  openapi: import_valleyed6.v.defaults(
-    import_valleyed6.v.object({
-      docsVersion: import_valleyed6.v.defaults(import_valleyed6.v.string(), "1.0.0"),
-      docsBaseUrl: import_valleyed6.v.defaults(import_valleyed6.v.array(import_valleyed6.v.string()), ["/"]),
-      docsPath: import_valleyed6.v.defaults(import_valleyed6.v.string(), "/__docs")
+  eventBus: import_valleyed5.v.optional(import_valleyed5.v.instanceOf(EventBus)),
+  publicPath: import_valleyed5.v.optional(import_valleyed5.v.string()),
+  healthPath: import_valleyed5.v.optional(import_valleyed5.v.string()),
+  openapi: import_valleyed5.v.defaults(
+    import_valleyed5.v.object({
+      docsVersion: import_valleyed5.v.defaults(import_valleyed5.v.string(), "1.0.0"),
+      docsBaseUrl: import_valleyed5.v.defaults(import_valleyed5.v.array(import_valleyed5.v.string()), ["/"]),
+      docsPath: import_valleyed5.v.defaults(import_valleyed5.v.string(), "/__docs")
     }),
     {}
   ),
-  requests: import_valleyed6.v.defaults(
-    import_valleyed6.v.object({
-      log: import_valleyed6.v.defaults(import_valleyed6.v.boolean(), true),
-      rateLimit: import_valleyed6.v.defaults(
-        import_valleyed6.v.object({
-          enabled: import_valleyed6.v.defaults(import_valleyed6.v.boolean(), false),
-          periodInMs: import_valleyed6.v.defaults(import_valleyed6.v.number(), 60 * 60 * 1e3),
-          limit: import_valleyed6.v.defaults(import_valleyed6.v.number(), 5e3)
+  requests: import_valleyed5.v.defaults(
+    import_valleyed5.v.object({
+      log: import_valleyed5.v.defaults(import_valleyed5.v.boolean(), true),
+      rateLimit: import_valleyed5.v.defaults(
+        import_valleyed5.v.object({
+          enabled: import_valleyed5.v.defaults(import_valleyed5.v.boolean(), false),
+          periodInMs: import_valleyed5.v.defaults(import_valleyed5.v.number(), 60 * 60 * 1e3),
+          limit: import_valleyed5.v.defaults(import_valleyed5.v.number(), 5e3)
         }),
         {}
       ),
-      slowdown: import_valleyed6.v.defaults(
-        import_valleyed6.v.object({
-          enabled: import_valleyed6.v.defaults(import_valleyed6.v.boolean(), false),
-          periodInMs: import_valleyed6.v.defaults(import_valleyed6.v.number(), 10 * 60 * 1e3),
-          delayAfter: import_valleyed6.v.defaults(import_valleyed6.v.number(), 2e3),
-          delayInMs: import_valleyed6.v.defaults(import_valleyed6.v.number(), 500)
+      slowdown: import_valleyed5.v.defaults(
+        import_valleyed5.v.object({
+          enabled: import_valleyed5.v.defaults(import_valleyed5.v.boolean(), false),
+          periodInMs: import_valleyed5.v.defaults(import_valleyed5.v.number(), 10 * 60 * 1e3),
+          delayAfter: import_valleyed5.v.defaults(import_valleyed5.v.number(), 2e3),
+          delayInMs: import_valleyed5.v.defaults(import_valleyed5.v.number(), 500)
         }),
         {}
       )
     }),
     {}
   ),
-  socketsAuthMethods: import_valleyed6.v.defaults(import_valleyed6.v.array(import_valleyed6.v.instanceOf(BaseRequestAuthMethod)), [])
+  socketsAuthMethods: import_valleyed5.v.defaults(import_valleyed5.v.array(import_valleyed5.v.instanceOf(BaseRequestAuthMethod)), [])
 });
 var rawResponseHandledSymbol = /* @__PURE__ */ Symbol("rawResponseHandled");
 var rawResponseHandled = Object.freeze({ [rawResponseHandledSymbol]: true });
@@ -859,7 +774,7 @@ function writeRawHandlerError(response, error) {
 var errorsSchemas = Object.entries(StatusCodes).filter(([, value]) => value > 399).map(([key, value]) => ({
   status: value,
   contentType: "application/json",
-  pipe: import_valleyed6.v.meta(import_valleyed6.v.array(import_valleyed6.v.object({ message: import_valleyed6.v.string(), field: import_valleyed6.v.optional(import_valleyed6.v.string()) })), {
+  pipe: import_valleyed5.v.meta(import_valleyed5.v.array(import_valleyed5.v.object({ message: import_valleyed5.v.string(), field: import_valleyed5.v.optional(import_valleyed5.v.string()) })), {
     $refId: `Errors.${key}Response`,
     description: `${key} Response`
   })
@@ -873,6 +788,7 @@ var Server = class {
   #queue = [];
   #routesByKey = /* @__PURE__ */ new Set();
   #started = false;
+  #beforeListenHandlers = [];
   #notFoundHandler = null;
   setup(httpServer, config) {
     this.#httpServer = httpServer;
@@ -928,6 +844,11 @@ var Server = class {
     this.#notFoundHandler = handler;
     return this;
   }
+  onBeforeListen(handler) {
+    if (this.#started) throw new EquippedError("Cannot add before-listen handler after server has started", {});
+    this.#beforeListenHandlers.push(handler);
+    return this;
+  }
   test() {
     return (0, import_supertest.default)(this.#httpServer);
   }
@@ -961,6 +882,7 @@ var Server = class {
       });
       return await this.handleResponse(res, response);
     });
+    for (const handler of this.#beforeListenHandlers) await handler({ httpServer: this.#httpServer, port: config.port });
     const started = await this.startServer(config.port);
     if (started) Instance.get().log.info(`${instance.id}(${app.name}) service listening on port ${config.port}`);
     return started;
@@ -1009,37 +931,37 @@ var Server = class {
       { key: "responseCookies", type: "response" }
     ];
     defs.forEach((def) => {
-      const pipe = schema[def.key] ?? import_valleyed6.v.any();
+      const pipe = schema[def.key] ?? import_valleyed5.v.any();
       if (def.skip) return;
       if (def.type === "request") {
         requestPipeDefs[def.key] = pipe;
-        jsonSchema.request[def.key] = import_valleyed6.v.schema(pipe);
+        jsonSchema.request[def.key] = import_valleyed5.v.schema(pipe);
       }
       if (def.type === "response") {
         const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
-        responsePipeDefs[def.key] = import_valleyed6.v.any().pipe((input) => {
+        responsePipeDefs[def.key] = import_valleyed5.v.any().pipe((input) => {
           const p = pipeRecords.find((rec) => rec.status === status)?.pipe;
-          if (!p) throw import_valleyed6.PipeError.root(`schema not defined for status code: ${status}`, input);
-          const r = import_valleyed6.v.validate(p, input);
+          if (!p) throw import_valleyed5.PipeError.root(`schema not defined for status code: ${status}`, input);
+          const r = import_valleyed5.v.validate(p, input);
           if (!r.valid) throw r.error;
           return r.value;
         });
         jsonSchema.response[def.key] = pipeRecords.map((record) => ({
           status: record.status,
           contentType: record.contentType,
-          schema: import_valleyed6.v.schema(record.pipe)
+          schema: import_valleyed5.v.schema(record.pipe)
         }));
       }
     });
-    const requestPipe = import_valleyed6.v.object(requestPipeDefs);
-    import_valleyed6.v.compile(requestPipe, { allErrors: true });
-    const responsePipe = import_valleyed6.v.object(responsePipeDefs);
-    import_valleyed6.v.compile(responsePipe, { allErrors: true });
+    const requestPipe = import_valleyed5.v.object(requestPipeDefs);
+    import_valleyed5.v.compile(requestPipe, { allErrors: true });
+    const responsePipe = import_valleyed5.v.object(responsePipeDefs);
+    import_valleyed5.v.compile(responsePipe, { allErrors: true });
     const validateRequest = async (request) => {
       if (!Object.keys(requestPipeDefs)) return request;
       const validity = requestLocalStorage.run(
         request,
-        () => import_valleyed6.v.validate(requestPipe, {
+        () => import_valleyed5.v.validate(requestPipe, {
           params: request.params,
           headers: request.headers,
           query: request.query,
@@ -1061,7 +983,7 @@ var Server = class {
       contentType = response.contentType;
       const validity = responseLocalStorage.run(
         response,
-        () => import_valleyed6.v.validate(responsePipe, {
+        () => import_valleyed5.v.validate(responsePipe, {
           responseHeaders: response.headers,
           responseCookies: Object.fromEntries(Object.entries(response.cookies).map(([key, val]) => [key, val.value])),
           response: response.body
@@ -1112,6 +1034,7 @@ if (void 0) {
   const testInstanceState = globalThis;
   class TestServer extends Server {
     handledResponse = null;
+    startedPorts = [];
     notFoundHandler = null;
     constructor() {
       super();
@@ -1156,7 +1079,8 @@ if (void 0) {
     registerNotFoundHandler(cb) {
       this.notFoundHandler = cb;
     }
-    async startServer() {
+    async startServer(port) {
+      this.startedPorts.push(port);
       return true;
     }
     async dispatchNotFound(path) {
@@ -1167,6 +1091,43 @@ if (void 0) {
       return { handledResponse: this.handledResponse, rawResponse };
     }
   }
+  describe("Server before-listen handlers", () => {
+    test("runs before-listen handlers before adapter listen in registration order", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      const calls = [];
+      let receivedServer = null;
+      server.onBeforeListen(({ httpServer, port }) => {
+        calls.push(`first:${port}`);
+        receivedServer = httpServer;
+        expect(server.startedPorts).toEqual([]);
+      }).onBeforeListen(({ httpServer, port }) => {
+        calls.push(`second:${port}`);
+        expect(httpServer).toBe(receivedServer);
+        expect(server.startedPorts).toEqual([]);
+      });
+      await server.start();
+      expect(calls).toEqual(["first:0", "second:0"]);
+      expect(receivedServer).toBeInstanceOf(http.Server);
+      expect(server.startedPorts).toEqual([0]);
+    });
+    test("rejects startup when a before-listen handler fails before adapter listen", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.onBeforeListen(async () => {
+        throw new Error("before-listen failed");
+      });
+      await expect(server.start()).rejects.toThrow("before-listen failed");
+      expect(server.startedPorts).toEqual([]);
+    });
+    test("rejects adding before-listen handlers after server startup", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      expect(() => server.onBeforeListen(() => {
+      })).toThrow("Cannot add before-listen handler after server has started");
+    });
+  });
   describe("Server not-found handler", () => {
     test("throws the default Equipped not-found error when no custom handler is set", async () => {
       ensureTestInstance();
@@ -1675,22 +1636,22 @@ if (void 0) {
 }
 
 // src/instance/settings.ts
-var import_valleyed8 = require("valleyed");
-var instanceSettingsPipe = () => import_valleyed8.v.object({
-  app: import_valleyed8.v.object({
-    name: import_valleyed8.v.string()
+var import_valleyed7 = require("valleyed");
+var instanceSettingsPipe = () => import_valleyed7.v.object({
+  app: import_valleyed7.v.object({
+    name: import_valleyed7.v.string()
   }),
-  log: import_valleyed8.v.defaults(
-    import_valleyed8.v.object({
-      level: import_valleyed8.v.defaults(import_valleyed8.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+  log: import_valleyed7.v.defaults(
+    import_valleyed7.v.object({
+      level: import_valleyed7.v.defaults(import_valleyed7.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
     }),
     {}
   ),
-  utils: import_valleyed8.v.defaults(
-    import_valleyed8.v.object({
-      hashSaltRounds: import_valleyed8.v.defaults(import_valleyed8.v.number(), 10),
-      paginationDefaultLimit: import_valleyed8.v.defaults(import_valleyed8.v.number(), 100),
-      maxFileUploadSizeInMb: import_valleyed8.v.defaults(import_valleyed8.v.number(), 500)
+  utils: import_valleyed7.v.defaults(
+    import_valleyed7.v.object({
+      hashSaltRounds: import_valleyed7.v.defaults(import_valleyed7.v.number(), 10),
+      paginationDefaultLimit: import_valleyed7.v.defaults(import_valleyed7.v.number(), 100),
+      maxFileUploadSizeInMb: import_valleyed7.v.defaults(import_valleyed7.v.number(), 500)
     }),
     {}
   )
@@ -1740,7 +1701,7 @@ var Instance = class _Instance {
     }
   }
   static envs(envsPipe) {
-    const envValidity = import_valleyed9.v.validate(envsPipe, process.env);
+    const envValidity = import_valleyed8.v.validate(envsPipe, process.env);
     if (!envValidity.valid) {
       _Instance.crash(
         new EquippedError(`Environment variables are not valid
@@ -1753,7 +1714,7 @@ ${envValidity.error.toString()}`, {
   }
   static create(settings) {
     if (_Instance.#instance) return _Instance.crash(new EquippedError("Instance has been initialized already", {}));
-    const settingsValidity = import_valleyed9.v.validate(instanceSettingsPipe(), settings);
+    const settingsValidity = import_valleyed8.v.validate(instanceSettingsPipe(), settings);
     if (!settingsValidity.valid) {
       _Instance.crash(
         new EquippedError(`Settings are not valid
@@ -1807,6 +1768,157 @@ ${settingsValidity.error.toString()}`, {
   }
 };
 
+// src/utilities/configurable.ts
+var import_valleyed9 = require("valleyed");
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed9.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed9.v.validate(pipe, input);
+      if (!r.valid) throw r.error;
+      return new this(r.value, ...args);
+    }
+  }
+  return Configurable;
+}
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  const { v: v8 } = null;
+  const testPipe = () => v8.object({
+    host: v8.string(),
+    port: v8.number()
+  });
+  class TestBase {
+    baseValue;
+    constructor() {
+      this.baseValue = "base";
+    }
+  }
+  class TestBaseWithArgs {
+    label;
+    constructor(label) {
+      this.label = label;
+    }
+  }
+  describe("configurable", () => {
+    test("validation runs in static create before constructor body executes", () => {
+      let constructorRan = false;
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+          constructorRan = true;
+        }
+      }
+      expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
+      expect(constructorRan).toBe(false);
+      MyClass.create({ host: "localhost", port: 3e3 });
+      expect(constructorRan).toBe(true);
+    });
+    test("constructor receives validated value", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      let receivedConfig;
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+          receivedConfig = this.config;
+        }
+      }
+      MyClass.create({ host: "localhost", port: 3e3 });
+      expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
+    });
+    test("external new is a compile error", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+      }
+      void (() => new MyClass({ host: "localhost", port: 3e3 }));
+    });
+    test("static Config resolves to PipeOutput<P> at the type level", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+      }
+      expectTypeOf().toEqualTypeOf();
+      expect(MyClass.create).toBeTypeOf("function");
+    });
+    test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        extra;
+        constructor(config, extra) {
+          super(config);
+          this.extra = extra;
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
+      expect(instance.extra).toBe(42);
+      expectTypeOf(instance).toHaveProperty("extra");
+      expectTypeOf(instance.extra).toEqualTypeOf();
+      void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
+    });
+    test("base-args forwarding works for non-zero-arg bases", () => {
+      const Wrapped = configurable(testPipe, TestBaseWithArgs);
+      class MyClass extends Wrapped {
+        constructor(config, label) {
+          super(config, label);
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
+      expect(instance.label).toBe("test-label");
+    });
+    test("config is accessible as protected readonly on instances", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+        getHost() {
+          return this.config.host;
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 });
+      expect(instance.getHost()).toBe("localhost");
+    });
+    test("accepts an abstract base class", () => {
+      class AbstractBase {
+      }
+      const Wrapped = configurable(testPipe, AbstractBase);
+      class Concrete extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+        greet() {
+          return `hello from ${this.config.host}`;
+        }
+      }
+      const instance = Concrete.create({ host: "localhost", port: 3e3 });
+      expect(instance.greet()).toBe("hello from localhost");
+      expectTypeOf(instance).toHaveProperty("config");
+    });
+  });
+}
+
+// src/utilities/media.ts
+var import_music_metadata = require("music-metadata");
+var getMediaDuration = async (buffer) => {
+  try {
+    const meta = await (0, import_music_metadata.parseBuffer)(buffer);
+    return meta.format.duration ?? 0;
+  } catch {
+    return 0;
+  }
+};
+
 // src/server/adapters/express/index.ts
 var ExpressServer = class extends configurable(serverConfigPipe, Server) {
   #app;