equipped 5.2.9 → 5.3.0

package/dist/types/chunk-YTY3EFNB.js

@@ -0,0 +1,2034 @@
+import {
+  EventBus
+} from "./chunk-KZKFYO4V.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/validations/index.ts
+export * from "valleyed";
+
+// src/validations/valleyed.ts
+var valleyed_exports = {};
+__export(valleyed_exports, {
+  incomingFile: () => incomingFile,
+  incomingFiles: () => incomingFiles,
+  requestLocalStorage: () => requestLocalStorage,
+  responseLocalStorage: () => responseLocalStorage,
+  withRequest: () => withRequest,
+  withResponse: () => withResponse
+});
+import { AsyncLocalStorage } from "async_hooks";
+import { PipeError as PipeError2, v as v6 } from "valleyed";
+
+// src/instance/index.ts
+import pino from "pino";
+import { ulid } from "ulid";
+import { v as v5 } from "valleyed";
+
+// 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
+import "http";
+import "@fastify/cors";
+import "cors";
+import { Server as SocketServer } from "socket.io";
+import supertest from "supertest";
+import { PipeError, v as v3 } from "valleyed";
+
+// src/server/openapi.ts
+import { convert } from "@openapi-contrib/json-schema-to-openapi-schema";
+import { capitalize } from "valleyed";
+
+// src/server/routes.ts
+import { v } from "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
+};
+function makeMiddlewareHandler(cb, onSetup) {
+  return { cb, onSetup };
+}
+var makeMiddleware = (...args) => makeMiddlewareHandler(...args);
+var makeResponseMiddleware = (...args) => makeMiddlewareHandler(...args);
+var makeErrorMiddleware = (...args) => makeMiddlewareHandler(...args);
+
+// 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 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 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 convert(visit(resp.schema)) };
+      }
+    }
+    if (def.request.body)
+      methodObj.requestBody = {
+        required: true,
+        content: {
+          "application/json": { schema: await 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 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 = 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/authProviders.ts
+var authProviders_exports = {};
+__export(authProviders_exports, {
+  signinWithApple: () => signinWithApple,
+  signinWithFacebook: () => signinWithFacebook,
+  signinWithGoogle: () => signinWithGoogle
+});
+import axios from "axios";
+import jwt from "jsonwebtoken";
+import jwksClient from "jwks-rsa";
+var signinWithGoogle = async (idToken) => {
+  const authUrl = `https://oauth2.googleapis.com/tokeninfo?id_token=${idToken}`;
+  const { data } = await axios.get(authUrl).catch((err) => {
+    throw new EquippedError("Failed to sign in with google", { idToken }, err);
+  });
+  data.first_name = data.given_name;
+  data.last_name = data.family_name;
+  return data;
+};
+var signinWithApple = async (idToken) => {
+  try {
+    const APPLE_BASE = "https://appleid.apple.com";
+    const json = jwt.decode(idToken, { complete: true });
+    if (!json?.header) throw new EquippedError("Missing JWT header", { idToken, json });
+    const { kid, alg } = json.header;
+    const publicKey = await jwksClient({ jwksUri: `${APPLE_BASE}/auth/keys`, cache: true }).getSigningKey(kid).then((key) => key.getPublicKey()).catch(() => null);
+    if (!publicKey) throw new EquippedError("no publicKey", { idToken, publicKey, json });
+    const data = jwt.verify(idToken, publicKey, { algorithms: [alg] });
+    if (!data) throw new EquippedError("no data", { idToken, data });
+    if (data.iss !== APPLE_BASE) throw new EquippedError("iss doesnt match", { idToken, data });
+    if (data.exp * 1e3 < Date.now()) throw new EquippedError("expired idToken", { idToken, data });
+    return data;
+  } catch (err) {
+    throw new EquippedError("Failed to sign in with apple", { idToken }, err);
+  }
+};
+var signinWithFacebook = async (accessToken, fields = []) => {
+  fields = [.../* @__PURE__ */ new Set([...fields, "name", "picture", "email"])];
+  const { data } = await axios.request({
+    method: "get",
+    url: "https://graph.facebook.com/v15.0/me",
+    params: {
+      fields: fields.join(","),
+      access_token: accessToken
+    }
+  }).catch((err) => {
+    throw new EquippedError("Failed to sign in with facebook", { accessToken, fields }, err);
+  });
+  const isValidData = fields.every((key) => key in data);
+  if (!isValidData) throw new EquippedError("Incomplete scope for access token", { accessToken, fields, data });
+  data.email_verified = "true";
+  return data;
+};
+
+// src/utilities/configurable.ts
+import { v as v2 } from "valleyed";
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  v2.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = v2.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 } = await 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/hash.ts
+var hash_exports = {};
+__export(hash_exports, {
+  compare: () => compare2,
+  hash: () => hash2
+});
+import * as bcrypt from "bcryptjs";
+var hash2 = async (password) => {
+  password = password.trim();
+  if (!password) return "";
+  return await bcrypt.hash(password, Instance.get().settings.utils.hashSaltRounds);
+};
+var compare2 = async (plainPassword, hashed) => {
+  plainPassword = plainPassword.trim();
+  if (!plainPassword && plainPassword === hashed) return true;
+  return await bcrypt.compare(plainPassword, hashed);
+};
+
+// 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
+import { parseBuffer } from "music-metadata";
+var getMediaDuration = async (buffer) => {
+  try {
+    const meta = await parseBuffer(buffer);
+    return meta.format.duration ?? 0;
+  } catch {
+    return 0;
+  }
+};
+
+// src/utilities/random.ts
+var random_exports = {};
+__export(random_exports, {
+  number: () => number,
+  string: () => string
+});
+import crypto from "crypto";
+function string(length = 20) {
+  return crypto.randomBytes(length).toString("hex").slice(0, length);
+}
+function number(min = 0, max = 2 ** 48 - 1) {
+  return crypto.randomInt(min, max);
+}
+
+// src/utilities/retry.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var retry = async (cb, tries, waitTimeInMs) => {
+  if (tries <= 0) throw new EquippedError("out of tries", { tries, waitTimeInMs });
+  const result = await cb();
+  if (result.done === true) return result.value;
+  await sleep(waitTimeInMs);
+  return await retry(cb, tries - 1, waitTimeInMs);
+};
+
+// 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
+import "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/requests-auth-methods/apiKeys.ts
+var BaseApiKeyRequestAuthMethod = class extends BaseRequestAuthMethod {
+  headerName;
+  constructor(headerName) {
+    super();
+    this.headerName = headerName;
+  }
+  async parse(headers) {
+    const headerValue = headers[this.headerName];
+    if (!headerValue || typeof headerValue !== "string") throw new NotAuthenticatedError();
+    return this.verify(headerValue);
+  }
+  routeSecuritySchemeName() {
+    return this.headerName;
+  }
+};
+
+// src/server/requests-auth-methods/jwt.ts
+import cookie from "@fastify/cookie";
+import jwt2 from "jsonwebtoken";
+var BaseJwtRequestAuthMethod = class extends BaseRequestAuthMethod {
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  #getKey(userId) {
+    return `${this.options.storagePrefix ?? ""}${userId}`;
+  }
+  async createToken(payload) {
+    const token = jwt2.sign(payload, this.options.signingKey, { expiresIn: this.options.storageTTL });
+    await this.store(this.#getKey(payload.id), token, this.options.storageTTL);
+    return token;
+  }
+  async parse(headers) {
+    try {
+      const token = await this.parseHeader(headers);
+      const user = jwt2.verify(token, this.options.signingKey);
+      if (!user) throw new NotAuthenticatedError();
+      if (this.options.enforceSingleSession) {
+        const cachedToken = await this.retrieve(this.#getKey(user.id));
+        if (token && token !== cachedToken) throw new TokenExpired();
+      }
+      return user;
+    } catch (err) {
+      if (err instanceof TokenExpired) throw err;
+      if (err instanceof jwt2.TokenExpiredError) throw new TokenExpired(void 0, err);
+      else throw new NotAuthenticatedError(void 0, err);
+    }
+  }
+  async retrieveFor(userId) {
+    return this.retrieve(this.#getKey(userId));
+  }
+  async deleteFor(userId) {
+    await this.delete(this.#getKey(userId));
+  }
+};
+var BaseJwtHeaderRequestAuthMethod = class extends BaseJwtRequestAuthMethod {
+  options;
+  constructor(options) {
+    super(options);
+    this.options = options;
+  }
+  async parseHeader(headers) {
+    const value = headers[this.options.headerName];
+    if (!value || typeof value !== "string") throw new NotAuthenticatedError();
+    return value.startsWith("Bearer ") ? value.slice(7) : value;
+  }
+  routeSecuritySchemeName() {
+    return this.options.headerName;
+  }
+};
+var BaseJwtCookieRequestAuthMethod = class extends BaseJwtRequestAuthMethod {
+  options;
+  constructor(options) {
+    super(options);
+    this.options = options;
+  }
+  async parseHeader(headers) {
+    const cookies = cookie.parse(headers.cookie || "") ?? {};
+    const value = cookies[this.options.cookieName];
+    if (!value || typeof value !== "string") throw new NotAuthenticatedError();
+    return value;
+  }
+  routeSecuritySchemeName() {
+    return `cookie:${this.options.cookieName}`;
+  }
+};
+
+// src/server/sockets.ts
+import { match as Match } from "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) => 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 = () => v3.object({
+  port: v3.number(),
+  cors: v3.optional(
+    v3.object({
+      origin: v3.optional(v3.or([v3.array(v3.string()), v3.is(true)])),
+      methods: v3.optional(v3.array(v3.in(Object.values(Methods)))),
+      credentials: v3.optional(v3.boolean())
+    })
+  ),
+  eventBus: v3.optional(v3.instanceOf(EventBus)),
+  publicPath: v3.optional(v3.string()),
+  healthPath: v3.optional(v3.string()),
+  openapi: v3.defaults(
+    v3.object({
+      docsVersion: v3.defaults(v3.string(), "1.0.0"),
+      docsBaseUrl: v3.defaults(v3.array(v3.string()), ["/"]),
+      docsPath: v3.defaults(v3.string(), "/__docs")
+    }),
+    {}
+  ),
+  requests: v3.defaults(
+    v3.object({
+      log: v3.defaults(v3.boolean(), true),
+      rateLimit: v3.defaults(
+        v3.object({
+          enabled: v3.defaults(v3.boolean(), false),
+          periodInMs: v3.defaults(v3.number(), 60 * 60 * 1e3),
+          limit: v3.defaults(v3.number(), 5e3)
+        }),
+        {}
+      ),
+      slowdown: v3.defaults(
+        v3.object({
+          enabled: v3.defaults(v3.boolean(), false),
+          periodInMs: v3.defaults(v3.number(), 10 * 60 * 1e3),
+          delayAfter: v3.defaults(v3.number(), 2e3),
+          delayInMs: v3.defaults(v3.number(), 500)
+        }),
+        {}
+      )
+    }),
+    {}
+  ),
+  socketsAuthMethods: v3.defaults(v3.array(v3.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: v3.meta(v3.array(v3.object({ message: v3.string(), field: v3.optional(v3.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 SocketServer(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 supertest(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] ?? v3.any();
+      if (def.skip) return;
+      if (def.type === "request") {
+        requestPipeDefs[def.key] = pipe;
+        jsonSchema.request[def.key] = v3.schema(pipe);
+      }
+      if (def.type === "response") {
+        const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
+        responsePipeDefs[def.key] = v3.any().pipe((input) => {
+          const p = pipeRecords.find((rec) => rec.status === status)?.pipe;
+          if (!p) throw PipeError.root(`schema not defined for status code: ${status}`, input);
+          const r = v3.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: v3.schema(record.pipe)
+        }));
+      }
+    });
+    const requestPipe = v3.object(requestPipeDefs);
+    v3.compile(requestPipe, { allErrors: true });
+    const responsePipe = v3.object(responsePipeDefs);
+    v3.compile(responsePipe, { allErrors: true });
+    const validateRequest = async (request) => {
+      if (!Object.keys(requestPipeDefs)) return request;
+      const validity = requestLocalStorage.run(
+        request,
+        () => v3.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,
+        () => v3.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/server/middlewares/requireAuthUser.ts
+var requireAuthUser = (methods) => makeMiddleware(
+  async (request) => {
+    request.authUser = await BaseRequestAuthMethod.process(methods, request.headers);
+    if (!request.authUser) throw new NotAuthenticatedError();
+  },
+  (route) => {
+    route.security ??= [];
+    for (const method of methods) {
+      const schemeName = method.routeSecuritySchemeName();
+      if (schemeName) route.security.push({ [schemeName]: [] });
+    }
+    route.descriptions ??= [];
+    route.descriptions.push("Requires a valid means of authentication.");
+  }
+);
+
+// src/errors/types/badRequestError.ts
+var BadRequestError = class extends RequestError {
+  statusCode = StatusCodes.BadRequest;
+  constructor(message, cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/notAuthenticatedError.ts
+var NotAuthenticatedError = class extends RequestError {
+  statusCode = StatusCodes.NotAuthenticated;
+  constructor(message = "Not authenticated", cause) {
+    super(message, [{ message }], cause);
+  }
+};
+
+// src/errors/types/notAuthorizedError.ts
+var NotAuthorizedError = class extends RequestError {
+  statusCode = StatusCodes.NotAuthorized;
+  constructor(message = "Not authorized", 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/tokenExpired.ts
+var TokenExpired = class extends RequestError {
+  statusCode = StatusCodes.TokenExpired;
+  constructor(message = "Token expired", 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/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
+import { v as v4 } from "valleyed";
+var instanceSettingsPipe = () => v4.object({
+  app: v4.object({
+    name: v4.string()
+  }),
+  log: v4.defaults(
+    v4.object({
+      level: v4.defaults(v4.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  utils: v4.defaults(
+    v4.object({
+      hashSaltRounds: v4.defaults(v4.number(), 10),
+      paginationDefaultLimit: v4.defaults(v4.number(), 100),
+      maxFileUploadSizeInMb: v4.defaults(v4.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 = pino({
+      level: this.settings.log.level,
+      serializers: {
+        err: pino.stdSerializers.err,
+        error: pino.stdSerializers.err,
+        req: pino.stdSerializers.req,
+        res: pino.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 = v5.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 = v5.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 ?? ""}${ulid(opts?.time?.getTime())}`;
+  }
+};
+
+// src/validations/valleyed.ts
+var filePipe = (err) => v6.array(
+  v6.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 PipeError2.root(err2, input);
+  })
+);
+var incomingFile = (err) => v6.define(
+  v6.compile(
+    filePipe(err).pipe(v6.min(1, "no file provided")).pipe((files) => files[0])
+  ),
+  { schema: () => ({ type: "string", format: "binary" }) }
+);
+var incomingFiles = (err) => v6.define(v6.compile(filePipe(err)), {
+  schema: () => ({ type: "string", format: "binary" })
+});
+var requestLocalStorage = new AsyncLocalStorage();
+var responseLocalStorage = new AsyncLocalStorage();
+var withRequest = (fn) => v6.define((input) => {
+  const req = requestLocalStorage.getStore();
+  if (!req) throw new Error("Request not found in context");
+  const validated = v6.validate(fn(req), input);
+  return validated.valid ? validated.value : validated.error;
+});
+var withResponse = (fn) => v6.define((input) => {
+  const res = responseLocalStorage.getStore();
+  if (!res) throw new Error("Response not found in context");
+  const validated = v6.validate(fn(res), input);
+  return validated.valid ? validated.value : validated.error;
+});
+
+// src/validations/index.ts
+import { v as v7 } from "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 = v7.validate(pipe, value);
+  if (validity.valid) return validity.value;
+  throw pipeErrorToValidationError(validity.error);
+}
+
+export {
+  EquippedError,
+  RequestError,
+  valleyed_exports,
+  pipeErrorToValidationError,
+  validate,
+  Methods,
+  StatusCodes,
+  makeMiddleware,
+  makeResponseMiddleware,
+  makeErrorMiddleware,
+  Router,
+  authProviders_exports,
+  configurable,
+  hash_exports,
+  parseJSONValue,
+  parseJSONObject,
+  getMediaDuration,
+  random_exports,
+  sleep,
+  retry,
+  Request,
+  Response,
+  BaseRequestAuthMethod,
+  BaseApiKeyRequestAuthMethod,
+  BaseJwtRequestAuthMethod,
+  BaseJwtHeaderRequestAuthMethod,
+  BaseJwtCookieRequestAuthMethod,
+  serverConfigPipe,
+  Server,
+  requireAuthUser,
+  BadRequestError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  TokenExpired,
+  ValidationError,
+  Instance
+};