equipped 5.2.9 → 5.3.0

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

@@ -0,0 +1,1974 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
+
+// src/server/adapters/fastify/index.ts
+var fastify_exports = {};
+__export(fastify_exports, {
+  FastifyServer: () => FastifyServer
+});
+module.exports = __toCommonJS(fastify_exports);
+var import_cookie = __toESM(require("@fastify/cookie"), 1);
+var import_cors3 = __toESM(require("@fastify/cors"), 1);
+var import_formbody = __toESM(require("@fastify/formbody"), 1);
+var import_helmet = __toESM(require("@fastify/helmet"), 1);
+var import_multipart = __toESM(require("@fastify/multipart"), 1);
+var import_rate_limit = __toESM(require("@fastify/rate-limit"), 1);
+var import_static = __toESM(require("@fastify/static"), 1);
+var import_fastify = __toESM(require("fastify"), 1);
+var import_qs = __toESM(require("qs"), 1);
+
+// src/errors/equippedError.ts
+var EquippedError = class extends Error {
+  constructor(message, context, cause) {
+    super(message, { cause });
+    this.message = message;
+    this.context = context;
+    this.cause = cause;
+  }
+};
+
+// src/errors/requestError.ts
+var RequestError = class extends EquippedError {
+  constructor(message, serializedErrors, cause) {
+    super(message, { serializedErrors }, cause);
+    this.message = message;
+    this.serializedErrors = serializedErrors;
+  }
+};
+
+// src/server/adapters/base.ts
+var import_node_http = require("http");
+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_valleyed8 = require("valleyed");
+
+// src/events/adapters/base.ts
+var EventBus = class {
+};
+
+// src/instance/index.ts
+var import_pino = __toESM(require("pino"), 1);
+var import_ulid = require("ulid");
+var import_valleyed2 = require("valleyed");
+
+// src/instance/hooks.ts
+function registerHook(hooks, record) {
+  for (const dep of record.after) {
+    if (!hooks.some((h) => h.class === dep)) {
+      const depName = dep.name || "unknown";
+      const ownerName = record.class?.name || "anonymous";
+      throw new Error(`Missing dependency: ${ownerName} declares after: [${depName}], but ${depName} is not registered`);
+    }
+  }
+  if (record.class) {
+    const tentative = [...hooks, record];
+    detectCycle(tentative);
+  }
+  hooks.push(record);
+}
+function detectCycle(hooks) {
+  const classToAfter = /* @__PURE__ */ new Map();
+  for (const h of hooks) {
+    if (!h.class) continue;
+    const existing = classToAfter.get(h.class);
+    if (existing) {
+      for (const dep of h.after) {
+        if (!existing.includes(dep)) existing.push(dep);
+      }
+    } else {
+      classToAfter.set(h.class, [...h.after]);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  function visit(cls, path) {
+    if (stack.has(cls)) {
+      const cycleStart = path.indexOf(cls);
+      const cycle = [...path.slice(cycleStart), cls];
+      const names = cycle.map((c) => c.name || "unknown");
+      throw new Error(`Cycle detected: ${names.join(" \u2192 ")}`);
+    }
+    if (visited.has(cls)) return;
+    stack.add(cls);
+    path.push(cls);
+    for (const dep of classToAfter.get(cls) ?? []) {
+      visit(dep, path);
+    }
+    path.pop();
+    stack.delete(cls);
+    visited.add(cls);
+  }
+  for (const cls of classToAfter.keys()) {
+    visit(cls, []);
+  }
+}
+function resolveHookDAG(hooks, invert = false) {
+  if (hooks.length === 0) return [];
+  const classToHooks = /* @__PURE__ */ new Map();
+  const anonymous = [];
+  for (const h of hooks) {
+    if (h.class) {
+      const list = classToHooks.get(h.class);
+      if (list) list.push(h);
+      else classToHooks.set(h.class, [h]);
+    } else {
+      anonymous.push(h);
+    }
+  }
+  const classes = [...classToHooks.keys()];
+  const inDegree = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  for (const cls of classes) {
+    inDegree.set(cls, 0);
+    graph.set(cls, []);
+  }
+  for (const h of hooks) {
+    if (!h.class) continue;
+    for (const dep of h.after) {
+      const [from, to] = invert ? [h.class, dep] : [dep, h.class];
+      const edges = graph.get(from);
+      if (!edges.includes(to)) {
+        edges.push(to);
+        inDegree.set(to, inDegree.get(to) + 1);
+      }
+    }
+  }
+  const layers = [];
+  let queue = classes.filter((c) => inDegree.get(c) === 0);
+  while (queue.length > 0) {
+    const layer = [];
+    const next = [];
+    for (const cls of queue) {
+      layer.push(...classToHooks.get(cls) ?? []);
+    }
+    layers.push(layer);
+    for (const cls of queue) {
+      for (const neighbor of graph.get(cls) ?? []) {
+        const d = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, d);
+        if (d === 0) next.push(neighbor);
+      }
+    }
+    queue = next;
+  }
+  if (anonymous.length > 0) {
+    const anonWithDeps = anonymous.filter((h) => h.after.length > 0);
+    const anonWithoutDeps = anonymous.filter((h) => h.after.length === 0);
+    if (anonWithDeps.length > 0) {
+      let maxLayer = -1;
+      for (const h of anonWithDeps) {
+        for (const dep of h.after) {
+          const depLayer = layers.findIndex((l) => l.some((r) => r.class === dep));
+          if (depLayer > maxLayer) maxLayer = depLayer;
+        }
+      }
+      const insertAt = maxLayer + 1;
+      if (insertAt < layers.length) {
+        layers[insertAt].push(...anonWithDeps);
+      } else {
+        layers.push(anonWithDeps);
+      }
+    }
+    if (anonWithoutDeps.length > 0) {
+      if (layers.length > 0) {
+        layers[layers.length - 1].push(...anonWithoutDeps);
+      } else {
+        layers.push(anonWithoutDeps);
+      }
+    }
+  }
+  return layers;
+}
+async function runHooks(hooks, onError = (error) => {
+  throw error;
+}, invert = false) {
+  const layers = resolveHookDAG(hooks, invert);
+  for (const layer of layers)
+    await Promise.all(
+      layer.map(async (h) => {
+        try {
+          if (typeof h.cb === "function") return await h.cb();
+          return await h.cb;
+        } catch (error) {
+          return onError(error instanceof Error ? error : new Error(`${error}`));
+        }
+      })
+    );
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  class A {
+  }
+  class B {
+  }
+  class C {
+  }
+  class D {
+  }
+  const noop = () => {
+  };
+  describe("registerHook", () => {
+    test("registers a hook with no dependencies", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      expect(hooks).toHaveLength(1);
+    });
+    test("throws on missing dependency", () => {
+      const hooks = [];
+      expect(() => registerHook(hooks, { cb: noop, class: B, after: [A] })).toThrow(/Missing dependency.*B.*A/);
+    });
+    test("throws on cycle: A\u2192B\u2192A", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      registerHook(hooks, { cb: noop, class: B, after: [A] });
+      expect(() => registerHook(hooks, { cb: noop, class: A, after: [B] })).toThrow(/Cycle detected/);
+    });
+    test("throws on transitive cycle: A\u2192B\u2192C\u2192A", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      registerHook(hooks, { cb: noop, class: B, after: [A] });
+      registerHook(hooks, { cb: noop, class: C, after: [B] });
+      expect(() => registerHook(hooks, { cb: noop, class: A, after: [C] })).toThrow(/Cycle detected/);
+    });
+    test("allows anonymous hooks with dependencies", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      registerHook(hooks, { cb: noop, after: [A] });
+      expect(hooks).toHaveLength(2);
+    });
+    test("anonymous hook throws on missing dependency", () => {
+      const hooks = [];
+      expect(() => registerHook(hooks, { cb: noop, after: [A] })).toThrow(/Missing dependency.*anonymous.*A/);
+    });
+  });
+  describe("resolveHookDAG", () => {
+    test("linear chain: A \u2192 B \u2192 C", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [B] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(3);
+      expect(layers[0].every((h) => h.class === A)).toBe(true);
+      expect(layers[1].every((h) => h.class === B)).toBe(true);
+      expect(layers[2].every((h) => h.class === C)).toBe(true);
+    });
+    test("fan-out: A \u2192 B, A \u2192 C (B and C are parallel)", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      expect(layers[0].every((h) => h.class === A)).toBe(true);
+      const secondClasses = layers[1].map((h) => h.class);
+      expect(secondClasses).toContain(B);
+      expect(secondClasses).toContain(C);
+    });
+    test("fan-in: B \u2192 D, C \u2192 D", () => {
+      const hooks = [
+        { cb: noop, class: B, after: [] },
+        { cb: noop, class: C, after: [] },
+        { cb: noop, class: D, after: [B, C] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      const firstClasses = layers[0].map((h) => h.class);
+      expect(firstClasses).toContain(B);
+      expect(firstClasses).toContain(C);
+      expect(layers[1].every((h) => h.class === D)).toBe(true);
+    });
+    test("diamond: A \u2192 B, A \u2192 C, B \u2192 D, C \u2192 D", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [A] },
+        { cb: noop, class: D, after: [B, C] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(3);
+      expect(layers[0][0].class).toBe(A);
+      const midClasses = layers[1].map((h) => h.class);
+      expect(midClasses).toContain(B);
+      expect(midClasses).toContain(C);
+      expect(layers[2][0].class).toBe(D);
+    });
+    test("close-event inversion reverses the graph", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [B] }
+      ];
+      const layers = resolveHookDAG(hooks, true);
+      expect(layers).toHaveLength(3);
+      expect(layers[0].every((h) => h.class === C)).toBe(true);
+      expect(layers[1].every((h) => h.class === B)).toBe(true);
+      expect(layers[2].every((h) => h.class === A)).toBe(true);
+    });
+    test("close inversion: fan-out becomes fan-in", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks, true);
+      expect(layers).toHaveLength(2);
+      const firstClasses = layers[0].map((h) => h.class);
+      expect(firstClasses).toContain(B);
+      expect(firstClasses).toContain(C);
+      expect(layers[1].every((h) => h.class === A)).toBe(true);
+    });
+    test("multiple hooks per class are all in the same layer", () => {
+      const cb1 = () => {
+      };
+      const cb2 = () => {
+      };
+      const hooks = [
+        { cb: cb1, class: A, after: [] },
+        { cb: cb2, class: A, after: [] },
+        { cb: noop, class: B, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      expect(layers[0]).toHaveLength(2);
+      expect(layers[0].every((h) => h.class === A)).toBe(true);
+    });
+    test("anonymous hooks without deps run at deepest level", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, after: [] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      const lastLayer = layers[layers.length - 1];
+      expect(lastLayer.some((h) => h.class === void 0)).toBe(true);
+    });
+    test("anonymous hooks with deps run after their dependencies", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [B] },
+        { cb: noop, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      const anonLayer = layers.findIndex((l) => l.some((h) => h.class === void 0));
+      const aLayer = layers.findIndex((l) => l.some((h) => h.class === A));
+      expect(anonLayer).toBeGreaterThan(aLayer);
+    });
+    test("empty hooks returns empty layers", () => {
+      expect(resolveHookDAG([])).toEqual([]);
+    });
+  });
+  describe("runHooks", () => {
+    test("same-depth siblings observably overlap", async () => {
+      const log = [];
+      const hooks = [
+        {
+          cb: async () => {
+            log.push("B-start");
+            await new Promise((r) => setTimeout(r, 20));
+            log.push("B-end");
+          },
+          class: B,
+          after: []
+        },
+        {
+          cb: async () => {
+            log.push("C-start");
+            await new Promise((r) => setTimeout(r, 20));
+            log.push("C-end");
+          },
+          class: C,
+          after: []
+        }
+      ];
+      await runHooks(hooks);
+      expect(log[0]).toBe("B-start");
+      expect(log[1]).toBe("C-start");
+    });
+    test("different depths run sequentially", async () => {
+      const log = [];
+      const hooks = [
+        {
+          cb: async () => {
+            log.push("A");
+          },
+          class: A,
+          after: []
+        },
+        {
+          cb: async () => {
+            log.push("B");
+          },
+          class: B,
+          after: [A]
+        }
+      ];
+      await runHooks(hooks);
+      expect(log).toEqual(["A", "B"]);
+    });
+    test("close inversion runs hooks in reverse dependency order", async () => {
+      const log = [];
+      const hooks = [
+        { cb: async () => log.push("A"), class: A, after: [] },
+        { cb: async () => log.push("B"), class: B, after: [A] },
+        { cb: async () => log.push("C"), class: C, after: [B] }
+      ];
+      await runHooks(hooks, void 0, true);
+      expect(log).toEqual(["C", "B", "A"]);
+    });
+    test("errors are routed to onError handler", async () => {
+      const errors = [];
+      const hooks = [
+        {
+          cb: () => {
+            throw new Error("boom");
+          },
+          class: A,
+          after: []
+        }
+      ];
+      await runHooks(hooks, (e) => {
+        errors.push(e);
+      });
+      expect(errors).toHaveLength(1);
+      expect(errors[0].message).toBe("boom");
+    });
+    test("raw promise callbacks are awaited", async () => {
+      const log = [];
+      const hooks = [
+        {
+          cb: Promise.resolve().then(() => log.push("resolved")),
+          class: A,
+          after: []
+        }
+      ];
+      await runHooks(hooks);
+      expect(log).toContain("resolved");
+    });
+  });
+}
+
+// src/instance/settings.ts
+var import_valleyed = require("valleyed");
+var instanceSettingsPipe = () => import_valleyed.v.object({
+  app: import_valleyed.v.object({
+    name: import_valleyed.v.string()
+  }),
+  log: import_valleyed.v.defaults(
+    import_valleyed.v.object({
+      level: import_valleyed.v.defaults(import_valleyed.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  utils: import_valleyed.v.defaults(
+    import_valleyed.v.object({
+      hashSaltRounds: import_valleyed.v.defaults(import_valleyed.v.number(), 10),
+      paginationDefaultLimit: import_valleyed.v.defaults(import_valleyed.v.number(), 100),
+      maxFileUploadSizeInMb: import_valleyed.v.defaults(import_valleyed.v.number(), 500)
+    }),
+    {}
+  )
+});
+
+// src/instance/index.ts
+var Instance = class _Instance {
+  static #id;
+  static #instance;
+  static #hooks = {};
+  settings;
+  log;
+  constructor(settings) {
+    _Instance.#instance = this;
+    this.settings = Object.freeze(settings);
+    this.log = (0, import_pino.default)({
+      level: this.settings.log.level,
+      serializers: {
+        err: import_pino.default.stdSerializers.err,
+        error: import_pino.default.stdSerializers.err,
+        req: import_pino.default.stdSerializers.req,
+        res: import_pino.default.stdSerializers.res
+      },
+      mixin: () => ({
+        instanceId: _Instance.#id
+      })
+    });
+    _Instance.#registerOnExitHandler();
+  }
+  alias(id) {
+    if (_Instance.#id !== void 0) return _Instance.crash(new EquippedError("Instance already has an alias", {}));
+    _Instance.#id = id;
+  }
+  get id() {
+    if (_Instance.#id === void 0) return _Instance.crash(new EquippedError("Instance doesnt have an alias yet", {}));
+    return _Instance.#id;
+  }
+  getScopedName(name, key = ".") {
+    return [this.settings.app.name, name].join(key);
+  }
+  async start() {
+    try {
+      await runHooks(_Instance.#hooks["setup"] ?? []);
+      await runHooks(_Instance.#hooks["start"] ?? []);
+    } catch (error) {
+      _Instance.crash(new EquippedError(`Error starting instance`, {}, error));
+    }
+  }
+  static envs(envsPipe) {
+    const envValidity = import_valleyed2.v.validate(envsPipe, process.env);
+    if (!envValidity.valid) {
+      _Instance.crash(
+        new EquippedError(`Environment variables are not valid
+${envValidity.error.toString()}`, {
+          messages: envValidity.error.messages
+        })
+      );
+    }
+    return envValidity.value;
+  }
+  static create(settings) {
+    if (_Instance.#instance) return _Instance.crash(new EquippedError("Instance has been initialized already", {}));
+    const settingsValidity = import_valleyed2.v.validate(instanceSettingsPipe(), settings);
+    if (!settingsValidity.valid) {
+      _Instance.crash(
+        new EquippedError(`Settings are not valid
+${settingsValidity.error.toString()}`, {
+          messages: settingsValidity.error.messages
+        })
+      );
+    }
+    return new _Instance(settingsValidity.value);
+  }
+  static get() {
+    if (!_Instance.#instance)
+      return _Instance.crash(
+        new EquippedError("Has not been initialized. Make sure an instance has been created before you get an instance", {})
+      );
+    return _Instance.#instance;
+  }
+  static maybeGet() {
+    return _Instance.#instance;
+  }
+  static on(event, cb, options) {
+    _Instance.#hooks[event] ??= [];
+    const record = { cb, class: options?.class, after: options?.after ?? [] };
+    registerHook(_Instance.#hooks[event], record);
+  }
+  static #registerOnExitHandler() {
+    const signals = {
+      SIGHUP: 1,
+      SIGINT: 2,
+      SIGTERM: 15
+    };
+    Object.entries(signals).forEach(([signal, code]) => {
+      process.on(signal, async () => {
+        await runHooks(_Instance.#hooks["close"] ?? [], () => {
+        }, true);
+        process.exit(128 + code);
+      });
+    });
+  }
+  static resolveBeforeCrash(cb) {
+    const value = cb();
+    _Instance.on("close", async () => await value);
+    return value;
+  }
+  static crash(error) {
+    console.error(error);
+    process.exit(1);
+  }
+  static createId(opts) {
+    return `${opts?.prefix ?? ""}${(0, import_ulid.ulid)(opts?.time?.getTime())}`;
+  }
+};
+
+// src/validations/index.ts
+var validations_exports = {};
+__export(validations_exports, {
+  pipeErrorToValidationError: () => pipeErrorToValidationError,
+  validate: () => validate,
+  ve: () => valleyed_exports
+});
+__reExport(validations_exports, require("valleyed"));
+
+// src/validations/valleyed.ts
+var valleyed_exports = {};
+__export(valleyed_exports, {
+  incomingFile: () => incomingFile,
+  incomingFiles: () => incomingFiles,
+  requestLocalStorage: () => requestLocalStorage,
+  responseLocalStorage: () => responseLocalStorage,
+  withRequest: () => withRequest,
+  withResponse: () => withResponse
+});
+var import_node_async_hooks = require("async_hooks");
+var import_valleyed3 = require("valleyed");
+var filePipe = (err) => import_valleyed3.v.array(
+  import_valleyed3.v.file(err).pipe((input) => {
+    const err2 = `is larger than allowed limit of ${Instance.get().settings.utils.maxFileUploadSizeInMb}mb`;
+    const valid = input ? !input.isTruncated : true;
+    if (valid) return input;
+    throw import_valleyed3.PipeError.root(err2, input);
+  })
+);
+var incomingFile = (err) => import_valleyed3.v.define(
+  import_valleyed3.v.compile(
+    filePipe(err).pipe(import_valleyed3.v.min(1, "no file provided")).pipe((files) => files[0])
+  ),
+  { schema: () => ({ type: "string", format: "binary" }) }
+);
+var incomingFiles = (err) => import_valleyed3.v.define(import_valleyed3.v.compile(filePipe(err)), {
+  schema: () => ({ type: "string", format: "binary" })
+});
+var requestLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+var responseLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+var withRequest = (fn) => import_valleyed3.v.define((input) => {
+  const req = requestLocalStorage.getStore();
+  if (!req) throw new Error("Request not found in context");
+  const validated = import_valleyed3.v.validate(fn(req), input);
+  return validated.valid ? validated.value : validated.error;
+});
+var withResponse = (fn) => import_valleyed3.v.define((input) => {
+  const res = responseLocalStorage.getStore();
+  if (!res) throw new Error("Response not found in context");
+  const validated = import_valleyed3.v.validate(fn(res), input);
+  return validated.valid ? validated.value : validated.error;
+});
+
+// src/validations/index.ts
+var import_valleyed4 = require("valleyed");
+function pipeErrorToValidationError(error) {
+  const errorsObject = error.messages.reduce((acc, { path = "", message }) => {
+    if (acc[path]) acc[path].messages.push(message);
+    else acc[path] = { field: path, messages: [message] };
+    return acc;
+  }, {});
+  return new ValidationError(Object.values(errorsObject));
+}
+function validate(pipe, value) {
+  const validity = import_valleyed4.v.validate(pipe, value);
+  if (validity.valid) return validity.value;
+  throw pipeErrorToValidationError(validity.error);
+}
+
+// src/server/openapi.ts
+var import_json_schema_to_openapi_schema = require("@openapi-contrib/json-schema-to-openapi-schema");
+var import_valleyed6 = require("valleyed");
+
+// src/server/routes.ts
+var import_valleyed5 = require("valleyed");
+
+// src/server/types.ts
+var Methods = {
+  head: "head",
+  get: "get",
+  post: "post",
+  put: "put",
+  patch: "patch",
+  delete: "delete",
+  options: "options"
+};
+var StatusCodes = {
+  Ok: 200,
+  Found: 302,
+  BadRequest: 400,
+  NotAuthenticated: 401,
+  NotAuthorized: 403,
+  NotFound: 404,
+  ValidationError: 422,
+  TooManyRequests: 429,
+  TokenExpired: 461
+};
+
+// src/server/routes.ts
+function mergeSchemas(...schemas) {
+  const k = {
+    params: "",
+    headers: "",
+    query: "",
+    body: "",
+    cookies: "",
+    response: "",
+    responseHeaders: "",
+    responseCookies: "",
+    defaultStatusCode: "",
+    defaultContentType: ""
+  };
+  function merge(acc, cur) {
+    if (!acc) return cur;
+    if (!cur) return acc;
+    if (typeof acc === "number") return cur;
+    if (typeof acc === "string") return cur;
+    if (typeof acc === "function") return cur;
+    return import_valleyed5.v.merge(acc, cur);
+  }
+  return Object.fromEntries(
+    Object.keys(k).map((key) => [
+      key,
+      schemas.map((s) => s[key]).reduce(merge, null)
+    ])
+  );
+}
+var groupRoutes = (config, routes) => routes.map((route) => ({
+  ...config,
+  ...route,
+  path: `${config.path}/${route.path}`,
+  groups: [...config.groups ?? [], ...route.groups ?? []],
+  middlewares: [...config.middlewares ?? [], ...route.middlewares ?? []],
+  responseMiddlewares: [...config.responseMiddlewares ?? [], ...route.responseMiddlewares ?? []],
+  schema: mergeSchemas(config.schema ?? {}, route.schema ?? {}),
+  security: [...config.security ?? [], ...route.security ?? []]
+}));
+var Router = class {
+  #config = { path: "" };
+  #routes = [];
+  #children = [];
+  constructor(config = { path: "" }) {
+    this.#config = config;
+  }
+  #wrap(method) {
+    return (path, config = {}) => (handler) => {
+      const route = groupRoutes(this.#config, [{ ...config, path, method, handler }])[0];
+      this.#routes.push(route);
+      return route;
+    };
+  }
+  head = this.#wrap(Methods.head);
+  get = this.#wrap(Methods.get);
+  post = this.#wrap(Methods.post);
+  put = this.#wrap(Methods.put);
+  patch = this.#wrap(Methods.patch);
+  delete = this.#wrap(Methods.delete);
+  options = this.#wrap(Methods.options);
+  nest(...routers) {
+    routers.forEach((router) => this.#children.push(router));
+  }
+  get routes() {
+    return [...this.#routes].concat(this.#children.flatMap((child) => groupRoutes(this.#config, child.routes)));
+  }
+};
+
+// src/server/openapi.ts
+var openapi = (config) => {
+  const instance = Instance.get();
+  const { app } = instance.settings;
+  const baseOpenapiDoc = {
+    openapi: "3.0.0",
+    info: {
+      title: `${app.name} ${instance.id}`,
+      version: config.openapi.docsVersion ?? ""
+    },
+    servers: config.openapi.docsBaseUrl?.map((url) => ({ url })),
+    paths: {},
+    components: {
+      schemas: {},
+      securitySchemes: {
+        Authorization: {
+          type: "apiKey",
+          name: "authorization",
+          in: "header"
+        },
+        RefreshToken: {
+          type: "apiKey",
+          name: "x-refresh-token",
+          in: "header"
+        },
+        ApiKey: {
+          type: "apiKey",
+          name: "x-api-key",
+          in: "header"
+        }
+      }
+    },
+    tags: [],
+    "x-tagGroups": []
+  };
+  const registeredTags = {};
+  const registeredTagGroups = {};
+  const flattenForParameters = (node) => {
+    const { allOf, oneOf, anyOf, ...schema } = node;
+    if (allOf) return allOf.flatMap((n) => flattenForParameters(n));
+    return [schema];
+  };
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return node;
+    if (typeof node.$refId === "string") {
+      const { $refId: id, ...rest } = node;
+      const res = visit(rest);
+      if (baseOpenapiDoc.components?.schemas) {
+        baseOpenapiDoc.components.schemas[id] = res;
+        return { $ref: `#/components/schemas/${id}` };
+      } else return res;
+    }
+    if (Array.isArray(node)) return node.map((n) => visit(n));
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, visit(value)]));
+  };
+  const buildTag = (groups) => {
+    if (!groups.length) return void 0;
+    const parsed = groups.map((g) => typeof g === "string" ? { name: g } : g);
+    const name = parsed.map((g) => g.name).join(" > ");
+    const displayName = parsed.at(-1)?.name ?? "";
+    const description = parsed.map((g) => g.description?.trim() ?? "").filter(Boolean).join("\n\n\n\n");
+    if (!registeredTags[name]) {
+      registeredTags[name] = true;
+      baseOpenapiDoc.tags.push({ name, "x-displayName": displayName, description });
+      const tagGroups = parsed.slice(0, -1);
+      const groupName = tagGroups.map((g) => g.name).join(" > ") || "default";
+      if (!registeredTagGroups[groupName]) {
+        const group = { name: groupName, tags: [] };
+        baseOpenapiDoc["x-tagGroups"].push(group);
+        registeredTagGroups[groupName] = group;
+      }
+      registeredTagGroups[groupName].tags = [.../* @__PURE__ */ new Set([...registeredTagGroups[groupName].tags, name])];
+    }
+    return name;
+  };
+  const addRouteToOpenApiDoc = async (path, method, def, methodObj) => {
+    if (def.response.response?.length) {
+      methodObj.responses ??= {};
+      for (const resp of def.response.response) {
+        methodObj.responses[resp.status] ??= { description: "", content: {} };
+        const res = methodObj.responses[resp.status];
+        res.content[resp.contentType] = { schema: await (0, import_json_schema_to_openapi_schema.convert)(visit(resp.schema)) };
+      }
+    }
+    if (def.response.responseHeaders?.length) {
+      methodObj.responses ??= {};
+      for (const resp of def.response.responseHeaders) {
+        methodObj.responses[resp.status] ??= { description: "", content: {} };
+        methodObj.responses[resp.status];
+        const res = methodObj.responses[resp.status];
+        res.headers = { schema: await (0, import_json_schema_to_openapi_schema.convert)(visit(resp.schema)) };
+      }
+    }
+    if (def.request.body)
+      methodObj.requestBody = {
+        required: true,
+        content: {
+          "application/json": { schema: await (0, import_json_schema_to_openapi_schema.convert)(visit(def.request.body)) }
+        }
+      };
+    const parameters = [];
+    const addParams = async (location, schema) => {
+      if (!schema) return;
+      const flat = flattenForParameters(schema);
+      for (const schema2 of flat) {
+        if (!schema2.properties) continue;
+        for (const [name, value] of Object.entries(schema2.properties))
+          parameters.push({
+            name,
+            in: location,
+            schema: await (0, import_json_schema_to_openapi_schema.convert)(visit(value)),
+            required: (schema2.required || []).includes(name)
+          });
+      }
+    };
+    await Promise.all([
+      addParams("query", def.request.query),
+      addParams("path", def.request.params),
+      addParams("header", def.request.headers)
+    ]);
+    if (parameters.length) methodObj.parameters = parameters;
+    if (!baseOpenapiDoc.paths) baseOpenapiDoc.paths = {};
+    if (!baseOpenapiDoc.paths[path]) baseOpenapiDoc.paths[path] = {};
+    baseOpenapiDoc.paths[path][method] = methodObj;
+  };
+  const html = (jsonPath2) => {
+    const title = (0, import_valleyed6.capitalize)(`${app.name} ${instance.id}`);
+    return `
+<!doctype html>
+<html>
+  <head>
+    <title>${title}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+	<style>
+      .darklight-reference {
+        display: none;
+      }
+    </style>
+  </head>
+  <body>
+    <script id="api-reference" data-url="${jsonPath2}"></script>
+    <script>
+      const configuration = { theme: 'purple' };
+      document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration);
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.38.0"></script>
+  </body>
+</html>
+`;
+  };
+  const cleanPath = (path) => {
+    let cleaned = path.replace(/(\/\s*)+/g, "/");
+    if (!cleaned.startsWith("/")) cleaned = `/${cleaned}`;
+    if (cleaned !== "/" && cleaned.endsWith("/")) cleaned = cleaned.slice(0, -1);
+    return cleaned;
+  };
+  const register = async (route, def) => {
+    if (route.hide) return;
+    const tag = buildTag(route.groups ?? []);
+    const cleanedPath = cleanPath(route.path);
+    const operationId = `(${route.method.toUpperCase()}) ${cleanedPath}`;
+    await addRouteToOpenApiDoc(cleanedPath, route.method.toLowerCase(), def, {
+      operationId,
+      summary: route.title ?? cleanedPath,
+      description: route.descriptions?.join("\n\n"),
+      tags: tag ? [tag] : void 0,
+      security: route.security
+    });
+  };
+  const jsonPath = "/openapi.json";
+  const router = new Router({ path: config.openapi.docsPath ?? "/", hide: true });
+  router.get("/index.html")((req) => req.res({ body: html(`.${jsonPath}`), contentType: "text/html" }));
+  router.get(jsonPath)((req) => req.res({ body: baseOpenapiDoc }));
+  return {
+    router,
+    register,
+    cleanPath
+  };
+};
+
+// src/utilities/configurable.ts
+var import_valleyed7 = require("valleyed");
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed7.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed7.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;
+  method;
+  path;
+  body;
+  params;
+  query;
+  headers;
+  cookies;
+  authUser = null;
+  constructor({
+    ip,
+    body,
+    cookies,
+    params,
+    query,
+    method,
+    path,
+    headers,
+    files
+  }) {
+    this.ip = ip;
+    this.method = method;
+    this.path = path;
+    this.params = params;
+    this.cookies = cookies;
+    this.headers = headers;
+    this.query = parseJSONObject(query);
+    this.body = Object.assign(parseJSONObject(body), files);
+  }
+  pipe(stream, opts = {}) {
+    return new Response({ ...opts, piped: true, body: stream });
+  }
+  res(params) {
+    return new Response({ ...params, piped: false });
+  }
+  error(params) {
+    return new Response({ ...params, piped: false });
+  }
+};
+var Response = class {
+  body;
+  headers;
+  cookies;
+  status;
+  contentType;
+  piped;
+  constructor({
+    body,
+    status = 200,
+    headers = {},
+    cookies = {},
+    piped = false,
+    contentType = "application/json"
+  }) {
+    this.body = body;
+    this.status = status;
+    this.contentType = contentType;
+    this.headers = headers;
+    this.cookies = cookies;
+    this.piped = piped;
+    if (!this.piped) {
+      this.headers["Content-Type"] = contentType;
+    }
+  }
+  get cookieValues() {
+    return Object.fromEntries(Object.entries(this.cookies).map(([key, val]) => [key, val]));
+  }
+  set cookieValues(values) {
+    Object.entries(values).forEach(([key, val]) => {
+      if (this.cookies[key]) this.cookies[key].value = val;
+    });
+  }
+};
+
+// src/server/requests-auth-methods/base.ts
+var import_node_http2 = require("http2");
+var BaseRequestAuthMethod = class {
+  static async process(methods, headers) {
+    if (methods.length === 0) return null;
+    let error;
+    for (const method of methods) {
+      try {
+        return await method.parse(headers);
+      } catch (err) {
+        error = err;
+      }
+    }
+    throw error instanceof RequestError ? error : new BadRequestError("failed to parse auth user", error);
+  }
+};
+
+// src/server/sockets.ts
+var import_path_to_regexp = require("path-to-regexp");
+var EmitterEvent = "__listener_emitter";
+var defaultTo = "*";
+var SocketEmitter = class {
+  constructor(socket, config) {
+    this.config = config;
+    this.socketInstance = socket;
+    this.#setupSocketConnection();
+    Instance.on("setup", () => {
+      const stream = config.eventBus?.stream(EmitterEvent, { fanout: true });
+      this.#publish = stream ? stream.publish : async (data) => {
+        socket.to(data.channel).emit(data.channel, data);
+      };
+      stream?.subscribe(async (data) => {
+        socket.to(data.channel).emit(data.channel, data);
+      });
+    });
+  }
+  socketInstance;
+  #connectionCallbacks = { onConnect: async () => {
+  }, onDisconnect: async () => {
+  } };
+  #routes = {};
+  #publish = async () => {
+  };
+  async created(channels, data, to) {
+    await this.#emit(channels, "created" /* created */, { after: data.toJSON(), before: null }, to);
+  }
+  async updated(channels, { after, before }, to) {
+    await this.#emit(channels, "updated" /* updated */, { after: after.toJSON(), before: before.toJSON() }, to);
+  }
+  async deleted(channels, data, to) {
+    await this.#emit(channels, "deleted" /* deleted */, { before: data.toJSON(), after: null }, to);
+  }
+  async #emit(channels, type, { before, after }, to) {
+    const toArray = Array.isArray(to) ? to : [to ?? defaultTo];
+    const channelMap = channels.flatMap((c) => toArray.map((to2) => `${to2}:${c}`));
+    await Promise.all(channelMap.map(async (channel) => this.#publish({ channel, type, before, after })));
+  }
+  set connectionCallbacks(callbacks) {
+    this.#connectionCallbacks = callbacks;
+    this.#setupSocketConnection();
+  }
+  register(channel, onJoin) {
+    this.#routes[channel] = onJoin;
+    this.#routes[channel + "/:id"] = onJoin;
+    return this;
+  }
+  #getConfig(channel) {
+    const matcher = (key) => (0, import_path_to_regexp.match)(key)(channel);
+    const matchedChannel = Object.keys(this.#routes).find(matcher) ?? null;
+    if (!matchedChannel) return null;
+    const match = matcher(matchedChannel);
+    if (!match) return null;
+    return {
+      config: this.#routes[matchedChannel],
+      params: match.params
+    };
+  }
+  #setupSocketConnection = () => {
+    this.socketInstance.removeAllListeners("connection");
+    this.socketInstance.on("connection", async (socket) => {
+      const socketId = socket.id;
+      const user = await BaseRequestAuthMethod.process(this.config.socketsAuthMethods, socket.handshake.headers).catch(() => null);
+      socket.on("leave", async (data, callback) => {
+        if (!data.channel)
+          return typeof callback === "function" && callback({
+            code: StatusCodes.ValidationError,
+            message: "channel is required",
+            channel: ""
+          });
+        socket.leave(data.channel);
+        return typeof callback === "function" && callback({
+          code: StatusCodes.Ok,
+          message: "",
+          channel: data.channel
+        });
+      });
+      socket.on("join", async (data, callback) => {
+        if (!data.channel)
+          return typeof callback === "function" && callback({
+            code: StatusCodes.ValidationError,
+            message: "channel is required",
+            channel: ""
+          });
+        const channel = data.channel;
+        const route = this.#getConfig(channel) ?? null;
+        if (!route)
+          return typeof callback === "function" && callback({
+            code: StatusCodes.BadRequest,
+            message: "unknown channel",
+            channel
+          });
+        const to = await route.config({ channel, user }, route.params, data.query ?? {});
+        const newChannel = `${to ?? defaultTo}:${channel}`;
+        socket.join(newChannel);
+        return typeof callback === "function" && callback({
+          code: StatusCodes.Ok,
+          message: "",
+          channel: newChannel
+        });
+      });
+      if (user) await this.#connectionCallbacks.onConnect(user.id, socketId);
+      socket.on("disconnect", async () => {
+        if (user) await this.#connectionCallbacks.onDisconnect(user.id, socketId);
+      });
+    });
+  };
+};
+
+// src/server/adapters/base.ts
+var serverConfigPipe = () => import_valleyed8.v.object({
+  port: import_valleyed8.v.number(),
+  cors: import_valleyed8.v.optional(
+    import_valleyed8.v.object({
+      origin: import_valleyed8.v.optional(import_valleyed8.v.or([import_valleyed8.v.array(import_valleyed8.v.string()), import_valleyed8.v.is(true)])),
+      methods: import_valleyed8.v.optional(import_valleyed8.v.array(import_valleyed8.v.in(Object.values(Methods)))),
+      credentials: import_valleyed8.v.optional(import_valleyed8.v.boolean())
+    })
+  ),
+  eventBus: import_valleyed8.v.optional(import_valleyed8.v.instanceOf(EventBus)),
+  publicPath: import_valleyed8.v.optional(import_valleyed8.v.string()),
+  healthPath: import_valleyed8.v.optional(import_valleyed8.v.string()),
+  openapi: import_valleyed8.v.defaults(
+    import_valleyed8.v.object({
+      docsVersion: import_valleyed8.v.defaults(import_valleyed8.v.string(), "1.0.0"),
+      docsBaseUrl: import_valleyed8.v.defaults(import_valleyed8.v.array(import_valleyed8.v.string()), ["/"]),
+      docsPath: import_valleyed8.v.defaults(import_valleyed8.v.string(), "/__docs")
+    }),
+    {}
+  ),
+  requests: import_valleyed8.v.defaults(
+    import_valleyed8.v.object({
+      log: import_valleyed8.v.defaults(import_valleyed8.v.boolean(), true),
+      rateLimit: import_valleyed8.v.defaults(
+        import_valleyed8.v.object({
+          enabled: import_valleyed8.v.defaults(import_valleyed8.v.boolean(), false),
+          periodInMs: import_valleyed8.v.defaults(import_valleyed8.v.number(), 60 * 60 * 1e3),
+          limit: import_valleyed8.v.defaults(import_valleyed8.v.number(), 5e3)
+        }),
+        {}
+      ),
+      slowdown: import_valleyed8.v.defaults(
+        import_valleyed8.v.object({
+          enabled: import_valleyed8.v.defaults(import_valleyed8.v.boolean(), false),
+          periodInMs: import_valleyed8.v.defaults(import_valleyed8.v.number(), 10 * 60 * 1e3),
+          delayAfter: import_valleyed8.v.defaults(import_valleyed8.v.number(), 2e3),
+          delayInMs: import_valleyed8.v.defaults(import_valleyed8.v.number(), 500)
+        }),
+        {}
+      )
+    }),
+    {}
+  ),
+  socketsAuthMethods: import_valleyed8.v.defaults(import_valleyed8.v.array(import_valleyed8.v.instanceOf(BaseRequestAuthMethod)), [])
+});
+var rawResponseHandledSymbol = /* @__PURE__ */ Symbol("rawResponseHandled");
+var rawResponseHandled = Object.freeze({ [rawResponseHandledSymbol]: true });
+var rawResponseNotStartedMessage = "Raw not-found handler did not start or complete a response";
+function isRawResponseHandled(input) {
+  return Boolean(input && typeof input === "object" && rawResponseHandledSymbol in input);
+}
+function hasRawResponseStarted(response) {
+  return response.headersSent || response.writableEnded;
+}
+function writeRawHandlerError(response, error) {
+  if (hasRawResponseStarted(response)) return;
+  response.statusCode = StatusCodes.BadRequest;
+  response.setHeader("Content-Type", "application/json");
+  const message = error instanceof Error ? error.message : `${error}`;
+  response.end(JSON.stringify([{ message }]));
+}
+var errorsSchemas = Object.entries(StatusCodes).filter(([, value]) => value > 399).map(([key, value]) => ({
+  status: value,
+  contentType: "application/json",
+  pipe: import_valleyed8.v.meta(import_valleyed8.v.array(import_valleyed8.v.object({ message: import_valleyed8.v.string(), field: import_valleyed8.v.optional(import_valleyed8.v.string()) })), {
+    $refId: `Errors.${key}Response`,
+    description: `${key} Response`
+  })
+}));
+var Server = class {
+  socket;
+  cors;
+  #httpServer;
+  #oai;
+  #serverConfig;
+  #queue = [];
+  #routesByKey = /* @__PURE__ */ new Set();
+  #started = false;
+  #notFoundHandler = null;
+  setup(httpServer, config) {
+    this.#httpServer = httpServer;
+    this.#serverConfig = config;
+    this.cors = {
+      origin: config.cors?.origin ? (_, cb) => cb(null, true) : config.cors?.origin,
+      methods: (config.cors?.methods ?? Object.values(Methods)).filter((m) => m !== Methods.options).map((m) => m.toUpperCase()),
+      credentials: config.cors?.credentials
+    };
+    this.#oai = openapi(config);
+    const socketInstance = new import_socket.Server(httpServer, { cors: this.cors });
+    this.socket = new SocketEmitter(socketInstance, config);
+    this.addRouter(this.#oai.router);
+  }
+  addRouter(...routers) {
+    routers.map((router) => router.routes).forEach((routes) => this.addRoute(...routes));
+  }
+  addRoute(...routes) {
+    routes.forEach((route) => {
+      this.#queue.push(async () => {
+        const { method, path, schema = {}, onError, middlewares = [], responseMiddlewares = [] } = route;
+        const key = `(${method.toUpperCase()}) ${this.#oai.cleanPath(path)}`;
+        if (this.#routesByKey.has(key))
+          throw new EquippedError(`Route key ${key} already registered. All route keys must be unique`, { route, key });
+        middlewares.forEach((m) => m.onSetup?.(route));
+        onError?.onSetup?.(route);
+        responseMiddlewares.forEach((m) => m.onSetup?.(route));
+        const { validateRequest, validateResponse, jsonSchema } = this.#resolveSchema(method, schema);
+        this.#routesByKey.add(key);
+        await this.#oai.register(route, jsonSchema);
+        this.registerRoute(method, this.#oai.cleanPath(path), async (req, res) => {
+          const request = await validateRequest(await this.parseRequest(req));
+          try {
+            for (const middleware of middlewares) await middleware.cb(request);
+            const rawRes = await route.handler(request);
+            const response = rawRes instanceof Response ? rawRes : new Response({ body: rawRes, status: StatusCodes.Ok, headers: {}, piped: false });
+            for (const middleware of responseMiddlewares) await middleware.cb(request, response);
+            return await this.handleResponse(res, await validateResponse(response));
+          } catch (error) {
+            if (onError?.cb) {
+              const rawResponse = await onError.cb(request, error);
+              const response = rawResponse instanceof Response ? rawResponse : new Response({ body: rawResponse, status: StatusCodes.BadRequest, headers: {} });
+              return await this.handleResponse(res, await validateResponse(response));
+            }
+            throw error;
+          }
+        });
+      });
+    });
+  }
+  setNotFoundHandler(handler) {
+    if (this.#started) throw new EquippedError("Cannot set not-found handler after server has started", {});
+    this.#notFoundHandler = handler;
+    return this;
+  }
+  test() {
+    return (0, import_supertest.default)(this.#httpServer);
+  }
+  async start() {
+    this.#started = true;
+    const config = this.#serverConfig;
+    const instance = Instance.get();
+    const { app } = instance.settings;
+    if (config.healthPath)
+      this.addRoute({
+        method: Methods.get,
+        path: config.healthPath,
+        handler: async (req) => req.res({
+          body: `${instance.id}(${app.name}) service running`,
+          contentType: "text/plain"
+        })
+      });
+    await Promise.all(this.#queue.map((cb) => cb()));
+    this.registerNotFoundHandler(async (req, res) => await this.#handleNotFound(req, res));
+    this.registerErrorHandler(async (error, _, res) => {
+      if (!(error instanceof EquippedError)) Instance.get().log.error({ error }, "Uncaught error in route handler");
+      const response = error instanceof RequestError ? new Response({
+        body: error.serializedErrors,
+        status: error.statusCode
+      }) : error instanceof EquippedError ? new Response({
+        body: [{ message: error.message }],
+        status: StatusCodes.BadRequest
+      }) : new Response({
+        body: [{ message: "Something went wrong", data: error.message }],
+        status: StatusCodes.BadRequest
+      });
+      return await this.handleResponse(res, response);
+    });
+    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;
+  }
+  createNodeRawResponder(input) {
+    return async (handler) => {
+      input.beforeHandle?.();
+      try {
+        await handler(input.request, input.response);
+      } catch (error) {
+        if (!hasRawResponseStarted(input.response)) {
+          writeRawHandlerError(input.response, error);
+          return rawResponseHandled;
+        }
+        throw error;
+      }
+      if (!hasRawResponseStarted(input.response))
+        writeRawHandlerError(input.response, new EquippedError(rawResponseNotStartedMessage, {}));
+      return rawResponseHandled;
+    };
+  }
+  async #handleNotFound(req, res) {
+    const request = await this.parseRequest(req);
+    if (!this.#notFoundHandler) throw new NotFoundError(`Route ${request.path} not found`);
+    const result = await this.#notFoundHandler({ request, respondWithRaw: this.createRawResponder(req, res) });
+    if (isRawResponseHandled(result)) return;
+    if (result instanceof Response) return await this.handleResponse(res, result);
+    throw new EquippedError("Not-found handler must return a Response or respondWithRaw(...)", {});
+  }
+  #resolveSchema(method, schema) {
+    const defaultStatusCode = schema?.defaultStatusCode ?? StatusCodes.Ok;
+    const defaultContentType = schema?.defaultContentType ?? "application/json";
+    let status = defaultStatusCode;
+    let contentType = defaultContentType;
+    const jsonSchema = { response: {}, request: {} };
+    const requestPipeDefs = {};
+    const responsePipeDefs = {};
+    const defs = [
+      { key: "params", type: "request" },
+      { key: "headers", type: "request" },
+      { key: "cookies", type: "request" },
+      { key: "query", type: "request" },
+      { key: "body", type: "request", skip: ![Methods.post, Methods.put, Methods.patch].includes(method) },
+      { key: "response", type: "response" },
+      { key: "responseHeaders", type: "response" },
+      { key: "responseCookies", type: "response" }
+    ];
+    defs.forEach((def) => {
+      const pipe = schema[def.key] ?? import_valleyed8.v.any();
+      if (def.skip) return;
+      if (def.type === "request") {
+        requestPipeDefs[def.key] = pipe;
+        jsonSchema.request[def.key] = import_valleyed8.v.schema(pipe);
+      }
+      if (def.type === "response") {
+        const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
+        responsePipeDefs[def.key] = import_valleyed8.v.any().pipe((input) => {
+          const p = pipeRecords.find((rec) => rec.status === status)?.pipe;
+          if (!p) throw import_valleyed8.PipeError.root(`schema not defined for status code: ${status}`, input);
+          const r = import_valleyed8.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_valleyed8.v.schema(record.pipe)
+        }));
+      }
+    });
+    const requestPipe = import_valleyed8.v.object(requestPipeDefs);
+    import_valleyed8.v.compile(requestPipe, { allErrors: true });
+    const responsePipe = import_valleyed8.v.object(responsePipeDefs);
+    import_valleyed8.v.compile(responsePipe, { allErrors: true });
+    const validateRequest = async (request) => {
+      if (!Object.keys(requestPipeDefs)) return request;
+      const validity = requestLocalStorage.run(
+        request,
+        () => import_valleyed8.v.validate(requestPipe, {
+          params: request.params,
+          headers: request.headers,
+          query: request.query,
+          body: request.body,
+          cookies: request.cookies
+        })
+      );
+      if (!validity.valid) throw pipeErrorToValidationError(validity.error);
+      request.params = validity.value.params;
+      request.headers = validity.value.headers;
+      request.query = validity.value.query;
+      request.body = validity.value.body;
+      request.cookies = validity.value.cookies;
+      return request;
+    };
+    const validateResponse = async (response) => {
+      if (!Object.keys(responsePipeDefs)) return response;
+      status = response.status;
+      contentType = response.contentType;
+      const validity = responseLocalStorage.run(
+        response,
+        () => import_valleyed8.v.validate(responsePipe, {
+          responseHeaders: response.headers,
+          responseCookies: Object.fromEntries(Object.entries(response.cookies).map(([key, val]) => [key, val.value])),
+          response: response.body
+        })
+      );
+      if (!validity.valid) throw pipeErrorToValidationError(validity.error);
+      response.body = validity.value.response;
+      response.headers = validity.value.responseHeaders;
+      response.cookieValues = validity.value.responseCookies;
+      return response;
+    };
+    return {
+      jsonSchema,
+      validateRequest,
+      validateResponse
+    };
+  }
+};
+if (void 0) {
+  let ensureTestInstance = function() {
+    const instance = Instance.maybeGet() ?? Instance.create({ app: { name: "equipped-test" }, log: { level: "silent" } });
+    if (!testInstanceState.__equippedTestInstanceAliased) {
+      instance.alias("equipped-test");
+      testInstanceState.__equippedTestInstanceAliased = true;
+    }
+  }, createRawResponse = function() {
+    const chunks = [];
+    return {
+      statusCode: 200,
+      headersSent: false,
+      writableEnded: false,
+      headers: {},
+      setHeader(key, value) {
+        this.headers[key] = value;
+      },
+      end(chunk) {
+        if (chunk !== void 0) chunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+        this.headersSent = true;
+        this.writableEnded = true;
+      },
+      body() {
+        return chunks.join("");
+      }
+    };
+  };
+  ensureTestInstance2 = ensureTestInstance, createRawResponse2 = createRawResponse;
+  const { describe, expect, test } = void 0;
+  const testInstanceState = globalThis;
+  class TestServer extends Server {
+    handledResponse = null;
+    notFoundHandler = null;
+    constructor() {
+      super();
+      this.setup(http.createServer(), {
+        port: 0,
+        cors: void 0,
+        eventBus: void 0,
+        publicPath: void 0,
+        healthPath: void 0,
+        openapi: { docsVersion: "1.0.0", docsBaseUrl: ["/"], docsPath: "/__docs" },
+        requests: {
+          log: false,
+          rateLimit: { enabled: false, periodInMs: 1, limit: 1 },
+          slowdown: { enabled: false, periodInMs: 1, delayAfter: 1, delayInMs: 1 }
+        },
+        socketsAuthMethods: []
+      });
+    }
+    async parseRequest(req) {
+      return new Request2({
+        ip: "127.0.0.1",
+        body: {},
+        cookies: {},
+        params: {},
+        query: {},
+        method: Methods.get,
+        path: req.path,
+        headers: {},
+        files: {}
+      });
+    }
+    async handleResponse(_, response) {
+      this.handledResponse = response;
+    }
+    createRawResponder(req, res) {
+      return this.createNodeRawResponder({ request: req.rawRequest, response: res.rawResponse });
+    }
+    registerRoute() {
+    }
+    registerErrorHandler() {
+    }
+    registerNotFoundHandler(cb) {
+      this.notFoundHandler = cb;
+    }
+    async startServer() {
+      return true;
+    }
+    async dispatchNotFound(path) {
+      if (!this.notFoundHandler) throw new Error("not-found handler was not registered");
+      this.handledResponse = null;
+      const rawResponse = createRawResponse();
+      await this.notFoundHandler({ path, rawRequest: {} }, { rawResponse });
+      return { handledResponse: this.handledResponse, rawResponse };
+    }
+  }
+  describe("Server not-found handler", () => {
+    test("throws the default Equipped not-found error when no custom handler is set", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      await expect(server.dispatchNotFound("/missing")).rejects.toBeInstanceOf(NotFoundError);
+    });
+    test("allows a custom not-found handler to return an Equipped response", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler(
+        ({ request }) => new Response({
+          body: [{ message: `No route for ${request.path}` }],
+          status: StatusCodes.NotFound,
+          headers: {},
+          cookies: {},
+          contentType: "application/json"
+        })
+      );
+      await server.start();
+      const result = await server.dispatchNotFound("/custom");
+      expect(result.handledResponse?.status).toBe(StatusCodes.NotFound);
+      expect(result.handledResponse?.body).toEqual([{ message: "No route for /custom" }]);
+    });
+    test("allows a custom not-found handler to complete the response through a raw Node listener", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler(
+        ({ respondWithRaw }) => respondWithRaw((_, response) => {
+          response.statusCode = 203;
+          response.end("raw fallback");
+        })
+      );
+      await server.start();
+      const result = await server.dispatchNotFound("/page");
+      expect(result.handledResponse).toBeNull();
+      expect(result.rawResponse.statusCode).toBe(203);
+      expect(result.rawResponse.body()).toBe("raw fallback");
+    });
+    test("writes a clear raw error when a raw not-found handler does not start a response", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler(({ respondWithRaw }) => respondWithRaw(() => {
+      }));
+      await server.start();
+      const result = await server.dispatchNotFound("/page");
+      expect(result.handledResponse).toBeNull();
+      expect(result.rawResponse.statusCode).toBe(StatusCodes.BadRequest);
+      expect(result.rawResponse.body()).toContain(rawResponseNotStartedMessage);
+    });
+    test("rejects a custom not-found handler result that is neither an Equipped response nor raw completion", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      server.setNotFoundHandler((() => void 0));
+      await server.start();
+      await expect(server.dispatchNotFound("/bad")).rejects.toThrow("Not-found handler must return a Response or respondWithRaw(...)");
+    });
+    test("rejects setting the custom not-found handler after server startup", async () => {
+      ensureTestInstance();
+      const server = new TestServer();
+      await server.start();
+      expect(
+        () => server.setNotFoundHandler(
+          () => new Response({
+            body: null,
+            status: StatusCodes.NotFound,
+            headers: {},
+            cookies: {},
+            contentType: "application/json"
+          })
+        )
+      ).toThrow("Cannot set not-found handler after server has started");
+    });
+  });
+}
+var ensureTestInstance2;
+var createRawResponse2;
+
+// src/errors/types/badRequestError.ts
+var BadRequestError = class extends RequestError {
+  statusCode = StatusCodes.BadRequest;
+  constructor(message, cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/notFoundError.ts
+var NotFoundError = class extends RequestError {
+  statusCode = StatusCodes.NotFound;
+  constructor(message = "Not found", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/validationError.ts
+var ValidationError = class extends RequestError {
+  statusCode = StatusCodes.ValidationError;
+  constructor(errors, cause) {
+    super(
+      "Unprocessable Entity",
+      errors.flatMap(({ field, messages }) => messages.map((message) => ({ message, field }))),
+      cause
+    );
+  }
+};
+
+// src/server/adapters/fastify/index.ts
+var FastifyServer = class extends configurable(serverConfigPipe, Server) {
+  #app;
+  constructor(config) {
+    super(config);
+    const instance = Instance.get();
+    const app = (0, import_fastify.default)({
+      disableRequestLogging: !config.requests.log,
+      loggerInstance: config.requests.log ? instance.log : void 0,
+      ajv: { customOptions: { coerceTypes: false } },
+      routerOptions: {
+        ignoreTrailingSlash: true,
+        caseSensitive: false
+      },
+      schemaErrorFormatter: (errors, data) => new ValidationError(
+        errors.map((error) => ({
+          messages: [error.message ?? ""],
+          field: `${data}${error.instancePath}`.replaceAll("/", ".")
+        }))
+      )
+    });
+    this.#app = app;
+    this.setup(app.server, config);
+    app.decorateRequest("savedReq", null);
+    app.setValidatorCompiler(() => () => true);
+    app.setSerializerCompiler(() => (data) => JSON.stringify(data));
+    if (config.publicPath) app.register(import_static.default, { root: config.publicPath });
+    app.register(import_cookie.default, {});
+    app.register(import_cors3.default, this.cors);
+    app.register(import_formbody.default, { parser: (str) => import_qs.default.parse(str) });
+    app.register(import_helmet.default, { crossOriginResourcePolicy: { policy: "cross-origin" }, contentSecurityPolicy: false });
+    app.register(import_multipart.default, {
+      attachFieldsToBody: "keyValues",
+      throwFileSizeLimit: false,
+      limits: { fileSize: instance.settings.utils.maxFileUploadSizeInMb * 1024 * 1024 },
+      onFile: async (f) => {
+        const buffer = await f.toBuffer();
+        const parsed = {
+          name: f.filename,
+          type: f.mimetype,
+          size: buffer.byteLength,
+          isTruncated: f.file.truncated,
+          data: buffer,
+          duration: await getMediaDuration(buffer)
+        };
+        f.value = parsed;
+      }
+    });
+    if (config.requests.rateLimit.enabled)
+      app.register(import_rate_limit.default, {
+        max: config.requests.rateLimit.limit,
+        timeWindow: config.requests.rateLimit.periodInMs,
+        errorResponseBuilder: (_, context) => ({
+          statusCode: StatusCodes.TooManyRequests,
+          message: JSON.stringify([{ message: `Too Many Requests. Retry in ${context.after}` }])
+        })
+      });
+  }
+  async parseRequest(req) {
+    const { body, files } = excludeBufferKeys(req.body ?? {});
+    return new Request({
+      ip: req.ip,
+      body,
+      cookies: req.cookies ?? {},
+      params: req.params ?? {},
+      query: req.query ?? {},
+      method: req.method,
+      path: req.url,
+      headers: req.headers,
+      files
+    });
+  }
+  async handleResponse(res, response) {
+    for (const [key, { value, ...opts }] of Object.entries(response.cookies)) res = res.setCookie(key, value, opts);
+    await res.status(response.status).headers(response.headers).send(response.body);
+  }
+  createRawResponder(req, res) {
+    return this.createNodeRawResponder({ request: req.raw, response: res.raw, beforeHandle: () => res.hijack() });
+  }
+  registerRoute(method, path, cb) {
+    this.#app.register(async (inst) => {
+      inst.route({ url: path, method, handler: cb });
+    });
+  }
+  registerErrorHandler(cb) {
+    this.#app.setErrorHandler(cb);
+  }
+  registerNotFoundHandler(cb) {
+    this.#app.setNotFoundHandler(cb);
+  }
+  async startServer(port) {
+    await this.#app.ready();
+    await this.#app.listen({ port, host: "0.0.0.0" });
+    Instance.on("close", this.#app.close);
+    return true;
+  }
+};
+function excludeBufferKeys(body) {
+  if (typeof body !== "object") return { body, files: {} };
+  const entries = Object.entries(body ?? {});
+  const isFile = (val) => Array.isArray(val) ? isFile(val.at(0)) : Buffer.isBuffer(val?.data);
+  const fileEntries = entries.filter(([_, value]) => isFile(value)).map(([key, value]) => [key, Array.isArray(value) ? value : [value]]);
+  const nonFileEntries = entries.filter(([_, value]) => !isFile(value));
+  return {
+    body: Object.fromEntries(nonFileEntries),
+    files: Object.fromEntries(fileEntries)
+  };
+}
+if (void 0) {
+  let ensureTestInstance = function() {
+    const instance = Instance.maybeGet() ?? Instance.create({ app: { name: "equipped-test" }, log: { level: "silent" } });
+    if (!testInstanceState.__equippedTestInstanceAliased) {
+      instance.alias("equipped-test");
+      testInstanceState.__equippedTestInstanceAliased = true;
+    }
+  }, createRawResponse = function() {
+    return {
+      statusCode: 200,
+      headersSent: false,
+      writableEnded: false,
+      setHeader: vi.fn(),
+      end(chunk) {
+        void chunk;
+        this.headersSent = true;
+        this.writableEnded = true;
+      }
+    };
+  };
+  ensureTestInstance2 = ensureTestInstance, createRawResponse2 = createRawResponse;
+  const { describe, expect, test, vi } = void 0;
+  const testInstanceState = globalThis;
+  class TestFastifyServer extends FastifyServer {
+    exposeRawResponder(req, res) {
+      return this.createRawResponder(req, res);
+    }
+  }
+  describe("FastifyServer raw responder", () => {
+    test("hijacks the Fastify reply before passing Node raw request and response to the handler", async () => {
+      ensureTestInstance();
+      const server = TestFastifyServer.create({ port: 0, requests: { log: false } });
+      const rawRequest = { marker: "request" };
+      const rawResponse = createRawResponse();
+      const reply = { raw: rawResponse, hijack: vi.fn() };
+      const request = { raw: rawRequest };
+      let received = null;
+      await server.exposeRawResponder(
+        request,
+        reply
+      )(async (req, res) => {
+        received = { request: req, response: res };
+        res.end("ok");
+      });
+      expect(reply.hijack).toHaveBeenCalledOnce();
+      expect(received).toEqual({ request: rawRequest, response: rawResponse });
+    });
+  });
+}
+var ensureTestInstance2;
+var createRawResponse2;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FastifyServer
+});
+//# sourceMappingURL=index.cjs.map