@brokr/sdk 1.0.0 → 2.1.0

package/dist/index.mjs

@@ -1,6 +1,8 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -8,29 +10,3164 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/headers.js
+var require_headers = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/headers.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var headers_exports = {};
+    __export(headers_exports, {
+      CITY_HEADER_NAME: () => CITY_HEADER_NAME,
+      COUNTRY_HEADER_NAME: () => COUNTRY_HEADER_NAME,
+      EMOJI_FLAG_UNICODE_STARTING_POSITION: () => EMOJI_FLAG_UNICODE_STARTING_POSITION,
+      IP_HEADER_NAME: () => IP_HEADER_NAME,
+      LATITUDE_HEADER_NAME: () => LATITUDE_HEADER_NAME,
+      LONGITUDE_HEADER_NAME: () => LONGITUDE_HEADER_NAME,
+      POSTAL_CODE_HEADER_NAME: () => POSTAL_CODE_HEADER_NAME,
+      REGION_HEADER_NAME: () => REGION_HEADER_NAME,
+      REQUEST_ID_HEADER_NAME: () => REQUEST_ID_HEADER_NAME,
+      geolocation: () => geolocation2,
+      ipAddress: () => ipAddress2
+    });
+    module.exports = __toCommonJS(headers_exports);
+    var CITY_HEADER_NAME = "x-vercel-ip-city";
+    var COUNTRY_HEADER_NAME = "x-vercel-ip-country";
+    var IP_HEADER_NAME = "x-real-ip";
+    var LATITUDE_HEADER_NAME = "x-vercel-ip-latitude";
+    var LONGITUDE_HEADER_NAME = "x-vercel-ip-longitude";
+    var REGION_HEADER_NAME = "x-vercel-ip-country-region";
+    var POSTAL_CODE_HEADER_NAME = "x-vercel-ip-postal-code";
+    var REQUEST_ID_HEADER_NAME = "x-vercel-id";
+    var EMOJI_FLAG_UNICODE_STARTING_POSITION = 127397;
+    function getHeader(headers, key) {
+      return headers.get(key) ?? void 0;
+    }
+    function getHeaderWithDecode(request, key) {
+      const header = getHeader(request.headers, key);
+      return header ? decodeURIComponent(header) : void 0;
+    }
+    function getFlag(countryCode) {
+      const regex = new RegExp("^[A-Z]{2}$").test(countryCode);
+      if (!countryCode || !regex)
+        return void 0;
+      return String.fromCodePoint(
+        ...countryCode.split("").map((char) => EMOJI_FLAG_UNICODE_STARTING_POSITION + char.charCodeAt(0))
+      );
+    }
+    function ipAddress2(input) {
+      const headers = "headers" in input ? input.headers : input;
+      return getHeader(headers, IP_HEADER_NAME);
+    }
+    function getRegionFromRequestId(requestId) {
+      if (!requestId) {
+        return "dev1";
+      }
+      return requestId.split(":")[0];
+    }
+    function geolocation2(request) {
+      return {
+        // city name may be encoded to support multi-byte characters
+        city: getHeaderWithDecode(request, CITY_HEADER_NAME),
+        country: getHeader(request.headers, COUNTRY_HEADER_NAME),
+        flag: getFlag(getHeader(request.headers, COUNTRY_HEADER_NAME)),
+        countryRegion: getHeader(request.headers, REGION_HEADER_NAME),
+        region: getRegionFromRequestId(
+          getHeader(request.headers, REQUEST_ID_HEADER_NAME)
+        ),
+        latitude: getHeader(request.headers, LATITUDE_HEADER_NAME),
+        longitude: getHeader(request.headers, LONGITUDE_HEADER_NAME),
+        postalCode: getHeader(request.headers, POSTAL_CODE_HEADER_NAME)
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/get-env.js
+var require_get_env = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/get-env.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var get_env_exports = {};
+    __export(get_env_exports, {
+      getEnv: () => getEnv2
+    });
+    module.exports = __toCommonJS(get_env_exports);
+    var getEnv2 = (env = process.env) => ({
+      /**
+       * An indicator to show that System Environment Variables have been exposed to your project's Deployments.
+       * @example "1"
+       */
+      VERCEL: get(env, "VERCEL"),
+      /**
+       * An indicator that the code is running in a Continuous Integration environment.
+       * @example "1"
+       */
+      CI: get(env, "CI"),
+      /**
+       * The Environment that the app is deployed and running on.
+       * @example "production"
+       */
+      VERCEL_ENV: get(env, "VERCEL_ENV"),
+      /**
+       * The domain name of the generated deployment URL. The value does not include the protocol scheme https://.
+       * NOTE: This Variable cannot be used in conjunction with Standard Deployment Protection.
+       * @example "*.vercel.app"
+       */
+      VERCEL_URL: get(env, "VERCEL_URL"),
+      /**
+       * The domain name of the generated Git branch URL. The value does not include the protocol scheme https://.
+       * @example "*-git-*.vercel.app"
+       */
+      VERCEL_BRANCH_URL: get(env, "VERCEL_BRANCH_URL"),
+      /**
+       * A production domain name of the project. This is useful to reliably generate links that point to production such as OG-image URLs.
+       * The value does not include the protocol scheme https://.
+       * @example "myproject.vercel.app"
+       */
+      VERCEL_PROJECT_PRODUCTION_URL: get(env, "VERCEL_PROJECT_PRODUCTION_URL"),
+      /**
+       * The ID of the Region where the app is running.
+       *
+       * Possible values:
+       * - arn1 (Stockholm, Sweden)
+       * - bom1 (Mumbai, India)
+       * - cdg1 (Paris, France)
+       * - cle1 (Cleveland, USA)
+       * - cpt1 (Cape Town, South Africa)
+       * - dub1 (Dublin, Ireland)
+       * - fra1 (Frankfurt, Germany)
+       * - gru1 (São Paulo, Brazil)
+       * - hkg1 (Hong Kong)
+       * - hnd1 (Tokyo, Japan)
+       * - iad1 (Washington, D.C., USA)
+       * - icn1 (Seoul, South Korea)
+       * - kix1 (Osaka, Japan)
+       * - lhr1 (London, United Kingdom)
+       * - pdx1 (Portland, USA)
+       * - sfo1 (San Francisco, USA)
+       * - sin1 (Singapore)
+       * - syd1 (Sydney, Australia)
+       * - dev1 (Development Region)
+       *
+       * @example "iad1"
+       */
+      VERCEL_REGION: get(env, "VERCEL_REGION"),
+      /**
+       * The unique identifier for the deployment, which can be used to implement Skew Protection.
+       * @example "dpl_7Gw5ZMBpQA8h9GF832KGp7nwbuh3"
+       */
+      VERCEL_DEPLOYMENT_ID: get(env, "VERCEL_DEPLOYMENT_ID"),
+      /**
+       * When Skew Protection is enabled in Project Settings, this value is set to 1.
+       * @example "1"
+       */
+      VERCEL_SKEW_PROTECTION_ENABLED: get(env, "VERCEL_SKEW_PROTECTION_ENABLED"),
+      /**
+       * The Protection Bypass for Automation value, if the secret has been generated in the project's Deployment Protection settings.
+       */
+      VERCEL_AUTOMATION_BYPASS_SECRET: get(env, "VERCEL_AUTOMATION_BYPASS_SECRET"),
+      /**
+       * The Git Provider the deployment is triggered from.
+       * @example "github"
+       */
+      VERCEL_GIT_PROVIDER: get(env, "VERCEL_GIT_PROVIDER"),
+      /**
+       * The origin repository the deployment is triggered from.
+       * @example "my-site"
+       */
+      VERCEL_GIT_REPO_SLUG: get(env, "VERCEL_GIT_REPO_SLUG"),
+      /**
+       * The account that owns the repository the deployment is triggered from.
+       * @example "acme"
+       */
+      VERCEL_GIT_REPO_OWNER: get(env, "VERCEL_GIT_REPO_OWNER"),
+      /**
+       * The ID of the repository the deployment is triggered from.
+       * @example "117716146"
+       */
+      VERCEL_GIT_REPO_ID: get(env, "VERCEL_GIT_REPO_ID"),
+      /**
+       * The git branch of the commit the deployment was triggered by.
+       * @example "improve-about-page"
+       */
+      VERCEL_GIT_COMMIT_REF: get(env, "VERCEL_GIT_COMMIT_REF"),
+      /**
+       * The git SHA of the commit the deployment was triggered by.
+       * @example "fa1eade47b73733d6312d5abfad33ce9e4068081"
+       */
+      VERCEL_GIT_COMMIT_SHA: get(env, "VERCEL_GIT_COMMIT_SHA"),
+      /**
+       * The message attached to the commit the deployment was triggered by.
+       * @example "Update about page"
+       */
+      VERCEL_GIT_COMMIT_MESSAGE: get(env, "VERCEL_GIT_COMMIT_MESSAGE"),
+      /**
+       * The username attached to the author of the commit that the project was deployed by.
+       * @example "johndoe"
+       */
+      VERCEL_GIT_COMMIT_AUTHOR_LOGIN: get(env, "VERCEL_GIT_COMMIT_AUTHOR_LOGIN"),
+      /**
+       * The name attached to the author of the commit that the project was deployed by.
+       * @example "John Doe"
+       */
+      VERCEL_GIT_COMMIT_AUTHOR_NAME: get(env, "VERCEL_GIT_COMMIT_AUTHOR_NAME"),
+      /**
+       * The git SHA of the last successful deployment for the project and branch.
+       * NOTE: This Variable is only exposed when an Ignored Build Step is provided.
+       * @example "fa1eade47b73733d6312d5abfad33ce9e4068080"
+       */
+      VERCEL_GIT_PREVIOUS_SHA: get(env, "VERCEL_GIT_PREVIOUS_SHA"),
+      /**
+       * The pull request id the deployment was triggered by. If a deployment is created on a branch before a pull request is made, this value will be an empty string.
+       * @example "23"
+       */
+      VERCEL_GIT_PULL_REQUEST_ID: get(env, "VERCEL_GIT_PULL_REQUEST_ID")
+    });
+    var get = (env, key) => {
+      const value = env[key];
+      return value === "" ? void 0 : value;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/get-context.js
+var require_get_context = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/get-context.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var get_context_exports = {};
+    __export(get_context_exports, {
+      SYMBOL_FOR_REQ_CONTEXT: () => SYMBOL_FOR_REQ_CONTEXT,
+      getContext: () => getContext
+    });
+    module.exports = __toCommonJS(get_context_exports);
+    var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+    function getContext() {
+      const fromSymbol = globalThis;
+      return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/wait-until.js
+var require_wait_until = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/wait-until.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var wait_until_exports = {};
+    __export(wait_until_exports, {
+      waitUntil: () => waitUntil2
+    });
+    module.exports = __toCommonJS(wait_until_exports);
+    var import_get_context = require_get_context();
+    var waitUntil2 = (promise) => {
+      if (promise === null || typeof promise !== "object" || typeof promise.then !== "function") {
+        throw new TypeError(
+          `waitUntil can only be called with a Promise, got ${typeof promise}`
+        );
+      }
+      return (0, import_get_context.getContext)().waitUntil?.(promise);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/middleware.js
+var require_middleware = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/middleware.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var middleware_exports = {};
+    __export(middleware_exports, {
+      next: () => next2,
+      rewrite: () => rewrite2
+    });
+    module.exports = __toCommonJS(middleware_exports);
+    function handleMiddlewareField(init, headers) {
+      if (init?.request?.headers) {
+        if (!(init.request.headers instanceof Headers)) {
+          throw new Error("request.headers must be an instance of Headers");
+        }
+        const keys = [];
+        for (const [key, value] of init.request.headers) {
+          headers.set("x-middleware-request-" + key, value);
+          keys.push(key);
+        }
+        headers.set("x-middleware-override-headers", keys.join(","));
+      }
+    }
+    function rewrite2(destination, init) {
+      const headers = new Headers(init?.headers ?? {});
+      headers.set("x-middleware-rewrite", String(destination));
+      handleMiddlewareField(init, headers);
+      return new Response(null, {
+        ...init,
+        headers
+      });
+    }
+    function next2(init) {
+      const headers = new Headers(init?.headers ?? {});
+      headers.set("x-middleware-next", "1");
+      handleMiddlewareField(init, headers);
+      return new Response(null, {
+        ...init,
+        headers
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/cache/in-memory-cache.js
+var require_in_memory_cache = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/cache/in-memory-cache.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var in_memory_cache_exports = {};
+    __export(in_memory_cache_exports, {
+      InMemoryCache: () => InMemoryCache
+    });
+    module.exports = __toCommonJS(in_memory_cache_exports);
+    var InMemoryCache = class {
+      constructor() {
+        this.cache = {};
+      }
+      async get(key) {
+        const entry = this.cache[key];
+        if (entry) {
+          if (entry.ttl && entry.lastModified + entry.ttl * 1e3 < Date.now()) {
+            await this.delete(key);
+            return null;
+          }
+          return JSON.parse(entry.value);
+        }
+        return null;
+      }
+      async set(key, value, options) {
+        const serialized = JSON.stringify(value ?? null);
+        this.cache[key] = {
+          value: serialized,
+          lastModified: Date.now(),
+          ttl: options?.ttl,
+          tags: new Set(options?.tags || [])
+        };
+      }
+      async delete(key) {
+        delete this.cache[key];
+      }
+      async expireTag(tag) {
+        const tags = Array.isArray(tag) ? tag : [tag];
+        for (const key in this.cache) {
+          if (Object.prototype.hasOwnProperty.call(this.cache, key)) {
+            const entry = this.cache[key];
+            if (tags.some((t) => entry.tags.has(t))) {
+              delete this.cache[key];
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/cache/build-client.js
+var require_build_client = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/cache/build-client.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var build_client_exports = {};
+    __export(build_client_exports, {
+      BuildCache: () => BuildCache
+    });
+    module.exports = __toCommonJS(build_client_exports);
+    var import_index = require_cache();
+    var BuildCache = class {
+      constructor({
+        endpoint,
+        headers,
+        onError,
+        timeout = 500
+      }) {
+        this.get = async (key) => {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+          try {
+            const res = await fetch(`${this.endpoint}${key}`, {
+              headers: this.headers,
+              method: "GET",
+              signal: controller.signal
+            });
+            if (res.status === 404) {
+              clearTimeout(timeoutId);
+              return null;
+            }
+            if (res.status === 200) {
+              const cacheState = res.headers.get(
+                import_index.HEADERS_VERCEL_CACHE_STATE
+              );
+              if (cacheState !== import_index.PkgCacheState.Fresh) {
+                res.body?.cancel?.();
+                clearTimeout(timeoutId);
+                return null;
+              }
+              const result = await res.json();
+              clearTimeout(timeoutId);
+              return result;
+            } else {
+              clearTimeout(timeoutId);
+              throw new Error(`Failed to get cache: ${res.statusText}`);
+            }
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === "AbortError") {
+              const timeoutError = new Error(
+                `Cache request timed out after ${this.timeout}ms`
+              );
+              timeoutError.stack = error.stack;
+              this.onError?.(timeoutError);
+            } else {
+              this.onError?.(error);
+            }
+            return null;
+          }
+        };
+        this.set = async (key, value, options) => {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+          try {
+            const optionalHeaders = {};
+            if (options?.ttl) {
+              optionalHeaders[import_index.HEADERS_VERCEL_REVALIDATE] = options.ttl.toString();
+            }
+            if (options?.tags && options.tags.length > 0) {
+              optionalHeaders[import_index.HEADERS_VERCEL_CACHE_TAGS] = options.tags.join(",");
+            }
+            if (options?.name) {
+              optionalHeaders[import_index.HEADERS_VERCEL_CACHE_ITEM_NAME] = options.name;
+            }
+            const res = await fetch(`${this.endpoint}${key}`, {
+              method: "POST",
+              headers: {
+                ...this.headers,
+                ...optionalHeaders
+              },
+              body: JSON.stringify(value),
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (res.status !== 200) {
+              throw new Error(`Failed to set cache: ${res.status} ${res.statusText}`);
+            }
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === "AbortError") {
+              const timeoutError = new Error(
+                `Cache request timed out after ${this.timeout}ms`
+              );
+              timeoutError.stack = error.stack;
+              this.onError?.(timeoutError);
+            } else {
+              this.onError?.(error);
+            }
+          }
+        };
+        this.delete = async (key) => {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+          try {
+            const res = await fetch(`${this.endpoint}${key}`, {
+              method: "DELETE",
+              headers: this.headers,
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (res.status !== 200) {
+              throw new Error(`Failed to delete cache: ${res.statusText}`);
+            }
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === "AbortError") {
+              const timeoutError = new Error(
+                `Cache request timed out after ${this.timeout}ms`
+              );
+              timeoutError.stack = error.stack;
+              this.onError?.(timeoutError);
+            } else {
+              this.onError?.(error);
+            }
+          }
+        };
+        this.expireTag = async (tag) => {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+          try {
+            if (Array.isArray(tag)) {
+              tag = tag.join(",");
+            }
+            const res = await fetch(`${this.endpoint}revalidate?tags=${tag}`, {
+              method: "POST",
+              headers: this.headers,
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (res.status !== 200) {
+              throw new Error(`Failed to revalidate tag: ${res.statusText}`);
+            }
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === "AbortError") {
+              const timeoutError = new Error(
+                `Cache request timed out after ${this.timeout}ms`
+              );
+              timeoutError.stack = error.stack;
+              this.onError?.(timeoutError);
+            } else {
+              this.onError?.(error);
+            }
+          }
+        };
+        this.endpoint = endpoint;
+        this.headers = headers;
+        this.onError = onError;
+        this.timeout = timeout;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/cache/index.js
+var require_cache = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/cache/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var cache_exports = {};
+    __export(cache_exports, {
+      HEADERS_VERCEL_CACHE_ITEM_NAME: () => HEADERS_VERCEL_CACHE_ITEM_NAME,
+      HEADERS_VERCEL_CACHE_STATE: () => HEADERS_VERCEL_CACHE_STATE,
+      HEADERS_VERCEL_CACHE_TAGS: () => HEADERS_VERCEL_CACHE_TAGS,
+      HEADERS_VERCEL_REVALIDATE: () => HEADERS_VERCEL_REVALIDATE,
+      PkgCacheState: () => PkgCacheState,
+      getCache: () => getCache2
+    });
+    module.exports = __toCommonJS(cache_exports);
+    var import_get_context = require_get_context();
+    var import_in_memory_cache = require_in_memory_cache();
+    var import_build_client = require_build_client();
+    var defaultKeyHashFunction = (key) => {
+      let hash = 5381;
+      for (let i = 0; i < key.length; i++) {
+        hash = hash * 33 ^ key.charCodeAt(i);
+      }
+      return (hash >>> 0).toString(16);
+    };
+    var defaultNamespaceSeparator = "$";
+    var inMemoryCacheInstance = null;
+    var buildCacheInstance = null;
+    var getCache2 = (cacheOptions) => {
+      const resolveCache = () => {
+        let cache;
+        if ((0, import_get_context.getContext)().cache) {
+          cache = (0, import_get_context.getContext)().cache;
+        } else {
+          cache = getCacheImplementation(
+            process.env.SUSPENSE_CACHE_DEBUG === "true"
+          );
+        }
+        return cache;
+      };
+      return wrapWithKeyTransformation(
+        resolveCache,
+        createKeyTransformer(cacheOptions)
+      );
+    };
+    function createKeyTransformer(cacheOptions) {
+      const hashFunction = cacheOptions?.keyHashFunction || defaultKeyHashFunction;
+      return (key) => {
+        if (!cacheOptions?.namespace)
+          return hashFunction(key);
+        const separator = cacheOptions.namespaceSeparator || defaultNamespaceSeparator;
+        return `${cacheOptions.namespace}${separator}${hashFunction(key)}`;
+      };
+    }
+    function wrapWithKeyTransformation(resolveCache, makeKey) {
+      return {
+        get: (key) => {
+          return resolveCache().get(makeKey(key));
+        },
+        set: (key, value, options) => {
+          return resolveCache().set(makeKey(key), value, options);
+        },
+        delete: (key) => {
+          return resolveCache().delete(makeKey(key));
+        },
+        expireTag: (tag) => {
+          return resolveCache().expireTag(tag);
+        }
+      };
+    }
+    var warnedCacheUnavailable = false;
+    function getCacheImplementation(debug) {
+      if (!inMemoryCacheInstance) {
+        inMemoryCacheInstance = new import_in_memory_cache.InMemoryCache();
+      }
+      if (process.env.RUNTIME_CACHE_DISABLE_BUILD_CACHE === "true") {
+        debug && console.log("Using InMemoryCache as build cache is disabled");
+        return inMemoryCacheInstance;
+      }
+      const { RUNTIME_CACHE_ENDPOINT, RUNTIME_CACHE_HEADERS } = process.env;
+      if (debug) {
+        console.log("Runtime cache environment variables:", {
+          RUNTIME_CACHE_ENDPOINT,
+          RUNTIME_CACHE_HEADERS
+        });
+      }
+      if (!RUNTIME_CACHE_ENDPOINT || !RUNTIME_CACHE_HEADERS) {
+        if (!warnedCacheUnavailable) {
+          console.warn(
+            "Runtime Cache unavailable in this environment. Falling back to in-memory cache."
+          );
+          warnedCacheUnavailable = true;
+        }
+        return inMemoryCacheInstance;
+      }
+      if (!buildCacheInstance) {
+        let parsedHeaders = {};
+        try {
+          parsedHeaders = JSON.parse(RUNTIME_CACHE_HEADERS);
+        } catch (e) {
+          console.error("Failed to parse RUNTIME_CACHE_HEADERS:", e);
+          return inMemoryCacheInstance;
+        }
+        let timeout = 500;
+        if (process.env.RUNTIME_CACHE_TIMEOUT) {
+          const parsed = parseInt(process.env.RUNTIME_CACHE_TIMEOUT, 10);
+          if (!isNaN(parsed) && parsed > 0) {
+            timeout = parsed;
+          } else {
+            console.warn(
+              `Invalid RUNTIME_CACHE_TIMEOUT value: "${process.env.RUNTIME_CACHE_TIMEOUT}". Using default: ${timeout}ms`
+            );
+          }
+        }
+        buildCacheInstance = new import_build_client.BuildCache({
+          endpoint: RUNTIME_CACHE_ENDPOINT,
+          headers: parsedHeaders,
+          onError: (error) => console.error(error),
+          timeout
+        });
+      }
+      return buildCacheInstance;
+    }
+    var PkgCacheState = /* @__PURE__ */ ((PkgCacheState2) => {
+      PkgCacheState2["Fresh"] = "fresh";
+      PkgCacheState2["Stale"] = "stale";
+      PkgCacheState2["Expired"] = "expired";
+      PkgCacheState2["NotFound"] = "notFound";
+      PkgCacheState2["Error"] = "error";
+      return PkgCacheState2;
+    })(PkgCacheState || {});
+    var HEADERS_VERCEL_CACHE_STATE = "x-vercel-cache-state";
+    var HEADERS_VERCEL_REVALIDATE = "x-vercel-revalidate";
+    var HEADERS_VERCEL_CACHE_TAGS = "x-vercel-cache-tags";
+    var HEADERS_VERCEL_CACHE_ITEM_NAME = "x-vercel-cache-item-name";
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/db-connections/index.js
+var require_db_connections = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/db-connections/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var db_connections_exports = {};
+    __export(db_connections_exports, {
+      attachDatabasePool: () => attachDatabasePool2,
+      experimental_attachDatabasePool: () => experimental_attachDatabasePool2
+    });
+    module.exports = __toCommonJS(db_connections_exports);
+    var import_get_context = require_get_context();
+    var DEBUG = !!process.env.DEBUG;
+    function getIdleTimeout(dbPool) {
+      if ("options" in dbPool && dbPool.options) {
+        if ("idleTimeoutMillis" in dbPool.options) {
+          return typeof dbPool.options.idleTimeoutMillis === "number" ? dbPool.options.idleTimeoutMillis : 1e4;
+        }
+        if ("maxIdleTimeMS" in dbPool.options) {
+          return typeof dbPool.options.maxIdleTimeMS === "number" ? dbPool.options.maxIdleTimeMS : 0;
+        }
+        if ("status" in dbPool) {
+          return 5e3;
+        }
+        if ("connect" in dbPool && "execute" in dbPool) {
+          return 3e4;
+        }
+      }
+      if ("config" in dbPool && dbPool.config) {
+        if ("connectionConfig" in dbPool.config && dbPool.config.connectionConfig) {
+          return dbPool.config.connectionConfig.idleTimeout || 6e4;
+        }
+        if ("idleTimeout" in dbPool.config) {
+          return typeof dbPool.config.idleTimeout === "number" ? dbPool.config.idleTimeout : 6e4;
+        }
+      }
+      if ("poolTimeout" in dbPool) {
+        return typeof dbPool.poolTimeout === "number" ? dbPool.poolTimeout : 6e4;
+      }
+      if ("idleTimeout" in dbPool) {
+        return typeof dbPool.idleTimeout === "number" ? dbPool.idleTimeout : 0;
+      }
+      return 1e4;
+    }
+    var idleTimeout = null;
+    var idleTimeoutResolve = () => {
+    };
+    var bootTime = Date.now();
+    var maximumDuration = 15 * 60 * 1e3 - 1e3;
+    function waitUntilIdleTimeout(dbPool) {
+      if (!process.env.VERCEL_URL || // This is not set during builds where we don't need to wait for idle connections using the mechanism
+      !process.env.VERCEL_REGION) {
+        return;
+      }
+      if (idleTimeout) {
+        clearTimeout(idleTimeout);
+        idleTimeoutResolve();
+      }
+      const promise = new Promise((resolve) => {
+        idleTimeoutResolve = resolve;
+      });
+      const waitTime = Math.min(
+        getIdleTimeout(dbPool) + 100,
+        Math.max(100, maximumDuration - (Date.now() - bootTime))
+      );
+      idleTimeout = setTimeout(() => {
+        idleTimeoutResolve?.();
+        if (DEBUG) {
+          console.log("Database pool idle timeout reached. Releasing connections.");
+        }
+      }, waitTime);
+      const requestContext = (0, import_get_context.getContext)();
+      if (requestContext?.waitUntil) {
+        requestContext.waitUntil(promise);
+      } else {
+        console.warn("Pool release event triggered outside of request scope.");
+      }
+    }
+    function attachDatabasePool2(dbPool) {
+      if (idleTimeout) {
+        idleTimeoutResolve?.();
+        clearTimeout(idleTimeout);
+      }
+      if ("on" in dbPool && dbPool.on && "options" in dbPool && "idleTimeoutMillis" in dbPool.options) {
+        const pgPool = dbPool;
+        pgPool.on("release", () => {
+          if (DEBUG) {
+            console.log("Client released from pool");
+          }
+          waitUntilIdleTimeout(dbPool);
+        });
+        return;
+      } else if ("on" in dbPool && dbPool.on && "config" in dbPool && dbPool.config && "connectionConfig" in dbPool.config) {
+        const mysqlPool = dbPool;
+        mysqlPool.on("release", () => {
+          if (DEBUG) {
+            console.log("MySQL client released from pool");
+          }
+          waitUntilIdleTimeout(dbPool);
+        });
+        return;
+      } else if ("on" in dbPool && dbPool.on && "config" in dbPool && dbPool.config && "idleTimeout" in dbPool.config) {
+        const mysql2Pool = dbPool;
+        mysql2Pool.on("release", () => {
+          if (DEBUG) {
+            console.log("MySQL2/MariaDB client released from pool");
+          }
+          waitUntilIdleTimeout(dbPool);
+        });
+        return;
+      }
+      if ("on" in dbPool && dbPool.on && "options" in dbPool && dbPool.options && "maxIdleTimeMS" in dbPool.options) {
+        const mongoPool = dbPool;
+        mongoPool.on("connectionCheckedOut", () => {
+          if (DEBUG) {
+            console.log("MongoDB connection checked out");
+          }
+          waitUntilIdleTimeout(dbPool);
+        });
+        return;
+      }
+      if ("on" in dbPool && dbPool.on && "options" in dbPool && dbPool.options && "socket" in dbPool.options) {
+        const redisPool = dbPool;
+        redisPool.on("end", () => {
+          if (DEBUG) {
+            console.log("Redis connection ended");
+          }
+          waitUntilIdleTimeout(dbPool);
+        });
+        return;
+      }
+      throw new Error("Unsupported database pool type");
+    }
+    var experimental_attachDatabasePool2 = attachDatabasePool2;
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/purge/index.js
+var require_purge = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/purge/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var purge_exports = {};
+    __export(purge_exports, {
+      dangerouslyDeleteBySrcImage: () => dangerouslyDeleteBySrcImage2,
+      dangerouslyDeleteByTag: () => dangerouslyDeleteByTag2,
+      invalidateBySrcImage: () => invalidateBySrcImage2,
+      invalidateByTag: () => invalidateByTag2
+    });
+    module.exports = __toCommonJS(purge_exports);
+    var import_get_context = require_get_context();
+    var invalidateByTag2 = (tag) => {
+      const api = (0, import_get_context.getContext)().purge;
+      if (api) {
+        return api.invalidateByTag(tag);
+      }
+      return Promise.resolve();
+    };
+    var dangerouslyDeleteByTag2 = (tag, options) => {
+      const api = (0, import_get_context.getContext)().purge;
+      if (api) {
+        return api.dangerouslyDeleteByTag(tag, options);
+      }
+      return Promise.resolve();
+    };
+    var invalidateBySrcImage2 = (src) => {
+      const api = (0, import_get_context.getContext)().purge;
+      return api ? api.invalidateBySrcImage(src) : Promise.resolve();
+    };
+    var dangerouslyDeleteBySrcImage2 = (src, options) => {
+      const api = (0, import_get_context.getContext)().purge;
+      return api ? api.dangerouslyDeleteBySrcImage(src, options) : Promise.resolve();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/addcachetag/index.js
+var require_addcachetag = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/addcachetag/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var addcachetag_exports = {};
+    __export(addcachetag_exports, {
+      addCacheTag: () => addCacheTag2
+    });
+    module.exports = __toCommonJS(addcachetag_exports);
+    var import_get_context = require_get_context();
+    var addCacheTag2 = (tag) => {
+      const addCacheTag22 = (0, import_get_context.getContext)().addCacheTag;
+      if (addCacheTag22) {
+        return addCacheTag22(tag);
+      }
+      return Promise.resolve();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/index.js
+var require_functions = __commonJS({
+  "../../node_modules/.pnpm/@vercel+functions@3.4.3_@aws-sdk+credential-provider-web-identity@3.972.20/node_modules/@vercel/functions/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export(src_exports, {
+      addCacheTag: () => import_addcachetag.addCacheTag,
+      attachDatabasePool: () => import_db_connections.attachDatabasePool,
+      dangerouslyDeleteBySrcImage: () => import_purge.dangerouslyDeleteBySrcImage,
+      dangerouslyDeleteByTag: () => import_purge.dangerouslyDeleteByTag,
+      experimental_attachDatabasePool: () => import_db_connections.experimental_attachDatabasePool,
+      geolocation: () => import_headers.geolocation,
+      getCache: () => import_cache.getCache,
+      getEnv: () => import_get_env.getEnv,
+      invalidateBySrcImage: () => import_purge.invalidateBySrcImage,
+      invalidateByTag: () => import_purge.invalidateByTag,
+      ipAddress: () => import_headers.ipAddress,
+      next: () => import_middleware.next,
+      rewrite: () => import_middleware.rewrite,
+      waitUntil: () => import_wait_until.waitUntil
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_headers = require_headers();
+    var import_get_env = require_get_env();
+    var import_wait_until = require_wait_until();
+    var import_middleware = require_middleware();
+    var import_cache = require_cache();
+    var import_db_connections = require_db_connections();
+    var import_purge = require_purge();
+    var import_addcachetag = require_addcachetag();
+  }
+});
+
+// src/fix-registry.ts
+var FIX_REGISTRY = {
+  AUTH_TOKEN_INVALID: [
+    "\u2192 Run `brokr env pull --stack <name>` to refresh your token",
+    "\u2192 Or run `brokr link account` to re-authenticate"
+  ].join("\n"),
+  AUTH_SESSION_EXPIRED: [
+    "\u2192 Run `brokr link account` to re-authenticate"
+  ].join("\n"),
+  BROKR_TOKEN_MISSING: [
+    "\u2192 Run `brokr env pull --stack <name>` to sync your environment",
+    "\u2192 Or add BROKR_TOKEN to your .env.local manually"
+  ].join("\n"),
+  DATABASE_PROVISION_FAILED: [
+    "\u2192 Run `brokr status <stack>` to check current state",
+    "\u2192 Run `brokr retry <stack>` to re-trigger provisioning"
+  ].join("\n"),
+  DATABASE_QUOTA_REACHED: [
+    "\u2192 Upgrade your plan or delete unused databases",
+    "\u2192 Check usage at brokr.sh/billing"
+  ].join("\n"),
+  DATABASE_HEALTH_TIMEOUT: [
+    "\u2192 Run `brokr status <stack>` to check database state",
+    "\u2192 If persistent, check provider status page"
+  ].join("\n"),
+  DEPLOYMENT_FAILED: [
+    "\u2192 Run `brokr logs --stack <name>` to see build logs",
+    "\u2192 Fix the build error and run `brokr deploy`"
+  ].join("\n"),
+  DEPLOYMENT_RATE_LIMITED: [
+    "\u2192 Wait a minute and retry",
+    "\u2192 Vercel rate limits apply per project"
+  ].join("\n"),
+  REPO_ALREADY_EXISTS: [
+    "\u2192 Use a different stack name",
+    "\u2192 Or run `brokr status <stack>` to check the existing stack"
+  ].join("\n"),
+  REPO_CREATE_FAILED: [
+    "\u2192 Check your GitHub connection: `brokr link account`",
+    "\u2192 Ensure the Brokr GitHub App is installed"
+  ].join("\n"),
+  EMAIL_DOMAIN_FAILED: [
+    "\u2192 Check DNS records are propagated",
+    "\u2192 Run `brokr status <stack>` for details"
+  ].join("\n"),
+  DNS_RECORD_FAILED: [
+    "\u2192 Check Cloudflare dashboard for zone status",
+    "\u2192 Retry with `brokr retry <stack>`"
+  ].join("\n"),
+  INSUFFICIENT_CREDITS: [
+    "\u2192 Top up credits at brokr.sh/billing",
+    "\u2192 Or run `brokr billing topup`"
+  ].join("\n"),
+  AI_BUDGET_EXCEEDED: [
+    "\u2192 Top up credits at brokr.sh/billing",
+    "\u2192 Or run `brokr billing topup`"
+  ].join("\n"),
+  AI_PROVIDER_UNAVAILABLE: [
+    "\u2192 The AI provider is temporarily down",
+    "\u2192 Retry in a few seconds \u2014 this is usually transient"
+  ].join("\n"),
+  AI_MODEL_NOT_FOUND: [
+    "\u2192 Check the model name in your configuration",
+    "\u2192 See available models at brokr.sh/docs/ai-models"
+  ].join("\n"),
+  ENV_VAR_MISSING: [
+    "\u2192 Run `brokr env pull --stack <name>` to sync environment",
+    "\u2192 Check required vars in your template README"
+  ].join("\n"),
+  STACK_LIMIT_REACHED: [
+    "\u2192 Delete unused stacks with `brokr delete <stack>`",
+    "\u2192 Or upgrade your plan at brokr.sh/billing"
+  ].join("\n"),
+  STACK_NOT_FOUND: [
+    "\u2192 Check the stack name: `brokr list`",
+    "\u2192 Create a new stack: `brokr create --name <name>`"
+  ].join("\n"),
+  RATE_LIMITED: [
+    "\u2192 Wait a moment and retry",
+    "\u2192 If persistent, check brokr.sh/status"
+  ].join("\n"),
+  GATEWAY_AUTH_FAILED: [
+    "\u2192 Your BROKR_TOKEN may be expired",
+    "\u2192 Run `brokr env pull --stack <name>` to refresh"
+  ].join("\n"),
+  BROKR_TOKEN_INVALID: [
+    "\u2192 Your BROKR_TOKEN has expired or been revoked",
+    "\u2192 Run `brokr env pull --stack <name>` to get a fresh token"
+  ].join("\n"),
+  AI_STREAM_ERROR: [
+    "\u2192 The AI stream was interrupted",
+    "\u2192 Retry the request \u2014 this is usually transient"
+  ].join("\n"),
+  EMAIL_SEND_FAILED: [
+    "\u2192 Email delivery failed",
+    "\u2192 Check that your domain DNS is verified: `brokr status <stack>`"
+  ].join("\n"),
+  EMAIL_NOT_CONFIGURED: [
+    "\u2192 Email is not set up for this stack",
+    "\u2192 Add email capability: `brokr add email --stack <name>`"
+  ].join("\n"),
+  EMAIL_INVALID_FROM: [
+    "\u2192 The from address must match your verified domain",
+    "\u2192 Check your domain: `brokr status <stack>`"
+  ].join("\n"),
+  STORAGE_UPLOAD_FAILED: [
+    "\u2192 File upload failed",
+    "\u2192 Check file size limits and retry"
+  ].join("\n"),
+  STORAGE_NOT_FOUND: [
+    "\u2192 The requested file does not exist",
+    "\u2192 Check the key and try again"
+  ].join("\n"),
+  PAYMENTS_NOT_CONFIGURED: [
+    "\u2192 Payments are not set up for this stack",
+    "\u2192 Run `brokr payments sync` to configure Stripe"
+  ].join("\n"),
+  PAYMENTS_FAILED: [
+    "\u2192 Payment processing failed",
+    "\u2192 Check your Stripe dashboard for details"
+  ].join("\n"),
+  GATEWAY_INTERNAL: [
+    "\u2192 The Brokr gateway encountered an internal error",
+    "\u2192 Check brokr.sh/status for service health"
+  ].join("\n"),
+  UPSTREAM_ERROR: [
+    "\u2192 An upstream service is temporarily unavailable",
+    "\u2192 Retry in a few seconds \u2014 this is usually transient"
+  ].join("\n"),
+  NETWORK_ERROR: [
+    "\u2192 Could not reach the Brokr gateway",
+    "\u2192 Check your internet connection",
+    "\u2192 Check brokr.sh/status for service health"
+  ].join("\n"),
+  TIMEOUT: [
+    "\u2192 Request timed out",
+    "\u2192 Retry \u2014 if persistent, check brokr.sh/status"
+  ].join("\n")
+};
+
+// src/errors.ts
+var BrokrError = class extends Error {
+  constructor(message, code, capability, retryable = false, errorCode, requestId, hint) {
+    super(message);
+    this.code = code;
+    this.capability = capability;
+    this.retryable = retryable;
+    this.errorCode = errorCode;
+    this.requestId = requestId;
+    this.hint = hint;
+    this.name = "BrokrError";
+  }
+  /** Multi-line terminal fix block — looked up from error code. */
+  get fix() {
+    if (!this.errorCode) return void 0;
+    return FIX_REGISTRY[this.errorCode];
+  }
+  /** Documentation URL for this error code. */
+  get docsUrl() {
+    if (!this.errorCode) return void 0;
+    return `https://brokr.sh/errors/${this.errorCode.toLowerCase().replace(/_/g, "-")}`;
+  }
+  /** Safe message for end users — zero technical language. */
+  toUserMessage() {
+    switch (this.code) {
+      case "RATE_LIMITED":
+        return "Please wait a moment and try again.";
+      case "TIMEOUT":
+        return "The request took too long. Please try again.";
+      case "NETWORK_ERROR":
+        return "Connection issue. Check your internet and try again.";
+      case "BROKR_TOKEN_MISSING":
+        return "App is not connected to Brokr. Contact the developer.";
+      case "BROKR_TOKEN_INVALID":
+        return "Session expired. Please refresh.";
+      case "AI_BUDGET_EXCEEDED":
+        return "AI usage limit reached. The developer needs to add credits.";
+      case "AI_PROVIDER_UNAVAILABLE":
+        return "AI service is temporarily down. Please retry shortly.";
+      case "AI_PROVIDER_RATE_LIMITED":
+        return "Too many AI requests. Please wait a moment.";
+      case "INSUFFICIENT_CREDITS":
+        return "Not enough credits. Please top up your balance.";
+      case "STORAGE_UPLOAD_FAILED":
+        return "File upload failed. Please try again.";
+      case "STORAGE_NOT_FOUND":
+        return "File not found.";
+      case "EMAIL_SEND_FAILED":
+        return "Email could not be sent. Please try again.";
+      case "EMAIL_NOT_CONFIGURED":
+        return "Email is not set up for this app.";
+      case "PAYMENTS_NOT_CONFIGURED":
+        return "Payments are not configured. Contact the developer.";
+      case "PAYMENTS_FAILED":
+        return "Payment processing failed. Please try again.";
+      case "NOT_FOUND":
+        return "The requested resource was not found.";
+      case "VALIDATION_ERROR":
+        return "Invalid input. Please check your data and try again.";
+      default:
+        return "Something went wrong. We're looking into it.";
+    }
+  }
+  toString() {
+    return `${this.name} [${this.errorCode ?? this.code}]: ${this.message}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      errorCode: this.errorCode,
+      message: this.message,
+      capability: this.capability,
+      retryable: this.retryable,
+      requestId: this.requestId,
+      hint: this.hint,
+      component: this.component
+    };
+  }
+};
+var BrokrAuthError = class extends BrokrError {
+  constructor(message, code) {
+    super(message, code, "auth", false);
+    this.name = "BrokrAuthError";
+  }
+};
+var BrokrRateLimitError = class extends BrokrError {
+  constructor(message, retryAfter, capability) {
+    super(message, "RATE_LIMITED", capability, true);
+    this.retryAfter = retryAfter;
+    this.name = "BrokrRateLimitError";
+  }
+};
+var BrokrNetworkError = class extends BrokrError {
+  constructor(message, capability) {
+    super(message, "NETWORK_ERROR", capability, true);
+    this.name = "BrokrNetworkError";
+  }
+};
+var BrokrTimeoutError = class extends BrokrError {
+  constructor(message, capability) {
+    super(message, "TIMEOUT", capability, true);
+    this.name = "BrokrTimeoutError";
+  }
+};
+var BrokrNotFoundError = class extends BrokrError {
+  constructor(message, capability) {
+    super(message, "NOT_FOUND", capability, false);
+    this.name = "BrokrNotFoundError";
+  }
+};
+var BrokrValidationError = class extends BrokrError {
+  constructor(message, capability) {
+    super(message, "VALIDATION_ERROR", capability, false);
+    this.name = "BrokrValidationError";
+  }
+};
+
+// src/gateway.ts
+var GATEWAY_URL = "https://api.brokr.sh";
+var FETCH_TIMEOUT_MS = 3e4;
+function resolveToken() {
+  return typeof process !== "undefined" ? process.env.BROKR_TOKEN : void 0;
+}
+function requireToken(token, capability) {
+  if (!token) {
+    let hint = "brokr env pull --stack <name>";
+    try {
+      if (typeof process !== "undefined") {
+        const fs = __require("fs");
+        const path = __require("path");
+        const brokrFile = path.join(process.cwd(), ".brokr");
+        if (fs.existsSync(brokrFile)) {
+          const data = JSON.parse(fs.readFileSync(brokrFile, "utf8"));
+          if (data?.stackName) hint = `brokr env pull --stack ${data.stackName}`;
+        }
+      }
+    } catch {
+    }
+    throw new BrokrAuthError(
+      `BROKR_TOKEN is not set. Run: ${hint}`,
+      "BROKR_TOKEN_MISSING"
+    );
+  }
+}
+async function gatewayFetch(gatewayUrl, token, path, body, capability) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(`${gatewayUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new BrokrTimeoutError(
+        `Request timed out after ${FETCH_TIMEOUT_MS / 1e3}s`,
+        capability
+      );
+    }
+    throw new BrokrNetworkError(
+      "Could not reach Brokr gateway. Check your network.",
+      capability
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (res.status === 429) {
+    const rawRetryAfter = parseInt(res.headers.get("Retry-After") ?? "60", 10);
+    const retryAfter = Number.isFinite(rawRetryAfter) ? rawRetryAfter : 60;
+    const data = await res.json().catch(() => ({}));
+    const errorMsg = typeof data.error === "string" ? data.error : `Rate limited (retry after ${retryAfter}s)`;
+    throw new BrokrRateLimitError(
+      errorMsg,
+      retryAfter,
+      capability
+    );
+  }
+  if (res.status === 401) {
+    throw new BrokrAuthError("Invalid or expired BROKR_TOKEN.", "BROKR_TOKEN_INVALID");
+  }
+  if (!res.ok) {
+    const body2 = await res.json().catch(() => ({}));
+    const errObj = typeof body2.error === "object" && body2.error !== null ? body2.error : void 0;
+    const errorData = body2.data ?? errObj?.data ?? body2;
+    const errorCode = errorData.errorCode ?? body2.code;
+    const hint = errorData.hint;
+    const requestId = errorData.requestId ?? res.headers.get("x-request-id");
+    const retryable = errorData.retryable;
+    const errorStr = typeof body2.error === "string" ? body2.error : void 0;
+    const message = body2.message ?? errObj?.message ?? errorStr ?? `${capability} request failed (HTTP ${res.status})`;
+    throw new BrokrError(
+      message,
+      errorCode ?? `${capability.toUpperCase()}_FAILED`,
+      capability,
+      retryable ?? false,
+      errorCode ?? void 0,
+      requestId ?? void 0,
+      hint ?? void 0
+    );
+  }
+  try {
+    return await res.json();
+  } catch {
+    throw new BrokrError(
+      `${capability} returned invalid response (expected JSON).`,
+      `${capability.toUpperCase()}_INVALID_RESPONSE`,
+      capability,
+      true
+    );
+  }
+}
+async function gatewayStream(gatewayUrl, token, path, body, capability) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(`${gatewayUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timeout);
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new BrokrTimeoutError(
+        `Stream request timed out after ${FETCH_TIMEOUT_MS / 1e3}s`,
+        capability
+      );
+    }
+    throw new BrokrNetworkError(
+      "Could not reach Brokr gateway. Check your network.",
+      capability
+    );
+  }
+  clearTimeout(timeout);
+  if (res.status === 429) {
+    const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60", 10);
+    throw new BrokrRateLimitError("Rate limited.", retryAfter, capability);
+  }
+  if (res.status === 401) {
+    throw new BrokrAuthError("Invalid or expired BROKR_TOKEN.", "BROKR_TOKEN_INVALID");
+  }
+  if (!res.ok || !res.body) {
+    throw new BrokrError(
+      `${capability} stream failed (HTTP ${res.status})`,
+      `${capability.toUpperCase()}_STREAM_FAILED`,
+      capability
+    );
+  }
+  return res;
+}
+
+// src/env-detect.ts
+var cached = null;
+function detectEnv() {
+  if (cached) return cached;
+  cached = _detect();
+  return cached;
+}
+function _detect() {
+  if (typeof process !== "undefined" && process.env) {
+    const vercel = process.env.VERCEL;
+    const vercelEnv = process.env.VERCEL_ENV;
+    if (vercel === "1" || vercel === "true") {
+      if (vercelEnv === "preview") return "staging";
+      if (vercelEnv === "production") return "production";
+      return "production";
+    }
+    return "development";
+  }
+  if (typeof window !== "undefined" && window.location) {
+    const host = window.location.hostname;
+    if (host === "localhost" || host === "127.0.0.1" || host === "::1") {
+      return "development";
+    }
+    if (host.includes("-staging.brokr.sh") || host.includes(".preview.brokr.sh")) {
+      return "staging";
+    }
+    if (host.endsWith(".brokr.sh") || host === "brokr.sh") {
+      return "production";
+    }
+    return "production";
+  }
+  return "production";
+}
+
+// src/dev-console.ts
+var BrokrDevConsole = class _BrokrDevConsole {
+  static {
+    this.installed = false;
+  }
+  static {
+    this.env = "production";
+  }
+  static install() {
+    if (_BrokrDevConsole.installed) return;
+    const env = detectEnv();
+    if (env === "production") return;
+    _BrokrDevConsole.installed = true;
+    _BrokrDevConsole.env = env;
+    if (typeof process !== "undefined" && process.on) {
+      process.on("unhandledRejection", (err) => {
+        if (err instanceof BrokrError) {
+          try {
+            _BrokrDevConsole.print(err);
+          } catch {
+          }
+        }
+      });
+    }
+  }
+  static print(err) {
+    if (_BrokrDevConsole.env === "staging") {
+      const hint = err.hint ?? err.message;
+      console.error(`[brokr] ${err.errorCode ?? err.code}: ${hint}`);
+      return;
+    }
+    const lines = [
+      "",
+      "\u2501".repeat(41),
+      "",
+      `  Brokr${err.component ? ` \u2014 ${err.component}` : ""}`,
+      "",
+      `  ${err.message}`
+    ];
+    if (err.fix) {
+      lines.push("", "  Fix it:");
+      for (const line of err.fix.split("\n")) lines.push(`  ${line}`);
+    }
+    if (err.docsUrl) {
+      lines.push("", `  Still broken? \u2192 ${err.docsUrl}`);
+    }
+    lines.push("", "\u2501".repeat(41), "");
+    console.error(lines.join("\n"));
+  }
+};
+
+// src/logs/capture.ts
+var DEFAULT_BATCH_SIZE = 20;
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var buffer = [];
+var flushTimer = null;
+var config = null;
+var intercepted = false;
+function initCapture(opts = {}) {
+  if (config) return;
+  const token = opts.token ?? (typeof process !== "undefined" ? process.env.BROKR_TOKEN : void 0);
+  const stackId = opts.stackId ?? resolveStackId();
+  if (!token || !stackId) {
+    if (typeof process !== "undefined") {
+      console.log(`[brokr] Log capture skipped: token=${token ? "present" : "MISSING"} stackId=${stackId ?? "MISSING"}`);
+    }
+    return;
+  }
+  const apiUrl = opts.apiUrl ?? opts.gatewayUrl ?? (typeof process !== "undefined" ? process.env.BROKR_GATEWAY_URL : void 0) ?? "https://api.brokr.sh";
+  config = {
+    token,
+    stackId,
+    apiUrl: apiUrl.replace(/\/+$/, ""),
+    batchSize: opts.batchSize ?? DEFAULT_BATCH_SIZE,
+    flushIntervalMs: opts.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS
+  };
+  if (typeof process !== "undefined") {
+    console.log(`[brokr] Log capture initialized \u2192 ${apiUrl}/v1/logs/ingest (stack: ${stackId.slice(0, 8)}...)`);
+  }
+  if (flushTimer) clearInterval(flushTimer);
+  flushTimer = setInterval(() => flush(), config.flushIntervalMs);
+  if (typeof process !== "undefined" && process.on) {
+    process.on("beforeExit", () => flush());
+  }
+  if (typeof process !== "undefined" && !intercepted) {
+    intercepted = true;
+    const origError = console.error;
+    const origWarn = console.warn;
+    console.error = (...args) => {
+      origError.apply(console, args);
+      try {
+        const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+        if (!msg.startsWith("[brokr]")) capture("error", msg, "console.error");
+      } catch {
+      }
+    };
+    console.warn = (...args) => {
+      origWarn.apply(console, args);
+      try {
+        const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+        if (!msg.startsWith("[brokr]")) capture("warn", msg, "console.warn");
+      } catch {
+      }
+    };
+  }
+}
+function capture(level, message, source, stackTrace) {
+  if (!config) return;
+  buffer.push({
+    level,
+    message: message.slice(0, 1e4),
+    source: source ?? "app",
+    stackTrace: stackTrace?.slice(0, 5e4),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (buffer.length >= (config.batchSize ?? DEFAULT_BATCH_SIZE)) {
+    flush();
+  }
+}
+function captureRequest(method, path, statusCode, durationMs) {
+  const level = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+  const dur = durationMs != null ? ` ${durationMs}ms` : "";
+  capture(level, `${method} ${path} ${statusCode}${dur}`, path);
+}
+function flush() {
+  if (!config || buffer.length === 0) return;
+  const entries = buffer.splice(0);
+  const { token, stackId, apiUrl } = config;
+  fetch(`${apiUrl}/v1/logs/ingest`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ stackId, entries })
+  }).catch((err) => {
+    if (typeof console !== "undefined") {
+      console.warn("[brokr] Log flush failed:", err instanceof Error ? err.message : err);
+    }
+  });
+}
+function resolveStackId() {
+  if (typeof process === "undefined") return void 0;
+  if (process.env.BROKR_STACK_ID) return process.env.BROKR_STACK_ID;
+  try {
+    const fs = __require("fs");
+    const path = __require("path");
+    const brokrFile = path.join(process.cwd(), ".brokr");
+    if (fs.existsSync(brokrFile)) {
+      const content = fs.readFileSync(brokrFile, "utf8");
+      const match = content.match(/BROKR_STACK_ID=(.+)/);
+      if (match) return match[1].trim();
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/ai/client.ts
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return [{ role: "user", content: input }];
+  }
+  return input;
+}
+var BrokrAIClient = class {
+  constructor(_token, _gatewayUrl) {
+    this._token = _token;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  // ---------------------------------------------------------------------------
+  // Core chat
+  // ---------------------------------------------------------------------------
+  /**
+   * Send a chat completion request.
+   * Accepts a string (auto-wrapped as user message) or a message array.
+   */
+  async chat(input, options) {
+    requireToken(this._token, "ai");
+    const messages = normalizeInput(input);
+    try {
+      const data = await gatewayFetch(this._gatewayUrl, this._token, "/v1/chat/completions", {
+        messages,
+        model: options?.model,
+        max_tokens: options?.maxTokens,
+        temperature: options?.temperature
+      }, "ai");
+      return {
+        content: data.choices?.[0]?.message?.content ?? "",
+        model: data.model ?? "",
+        usage: {
+          promptTokens: data.usage?.prompt_tokens ?? 0,
+          completionTokens: data.usage?.completion_tokens ?? 0
+        }
+      };
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AIChat";
+      const msg = err instanceof Error ? err.message : String(err);
+      capture("error", `AI chat failed: ${msg}`, "brokr.ai.chat", err instanceof Error ? err.stack : void 0);
+      throw err;
+    }
+  }
+  /**
+   * Stream a chat completion. Yields text strings directly.
+   * Accepts a string (auto-wrapped as user message) or a message array.
+   */
+  /**
+   * Stream a chat completion. Yields text strings directly.
+   * Tries streaming first — if the gateway or provider doesn't support it,
+   * falls back to a non-streaming call and yields the full response at once.
+   */
+  async *stream(input, options) {
+    requireToken(this._token, "ai");
+    const messages = normalizeInput(input);
+    let res;
+    try {
+      res = await gatewayStream(
+        this._gatewayUrl,
+        this._token,
+        "/v1/chat/completions",
+        {
+          messages,
+          stream: true,
+          model: options?.model,
+          max_tokens: options?.maxTokens,
+          temperature: options?.temperature
+        },
+        "ai"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AIStream";
+      const msg = err instanceof Error ? err.message : String(err);
+      capture("error", `AI stream failed: ${msg}`, "brokr.ai.stream", err instanceof Error ? err.stack : void 0);
+      try {
+        const fallback = await this.chat(input, options);
+        yield fallback.content;
+      } catch (fallbackErr) {
+        throw err;
+      }
+      return;
+    }
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct.includes("text/event-stream")) {
+      try {
+        const data = await res.json();
+        const content = data.choices?.[0]?.message?.content ?? "";
+        if (content) yield content;
+      } catch {
+        const fallback = await this.chat(input, options);
+        yield fallback.content;
+      }
+      return;
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer2 = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer2 += decoder.decode(value, { stream: true });
+      const lines = buffer2.split("\n");
+      buffer2 = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const payload = line.slice(6).trim();
+        if (payload === "[DONE]") return;
+        try {
+          const parsed = JSON.parse(payload);
+          const delta = parsed.choices?.[0]?.delta?.content ?? "";
+          if (delta) yield delta;
+        } catch {
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Higher-level primitives
+  // ---------------------------------------------------------------------------
+  /**
+   * Extract structured data from a prompt using JSON mode.
+   * Returns a parsed object matching the provided schema shape.
+   */
+  async structured(params) {
+    requireToken(this._token, "ai");
+    const schemaStr = JSON.stringify(params.schema, null, 2);
+    const messages = [
+      {
+        role: "system",
+        content: `You are a structured data extraction assistant. Return ONLY valid JSON matching this schema:
+${schemaStr}
+Do not include any other text, markdown, or explanation.`
+      },
+      { role: "user", content: params.prompt }
+    ];
+    try {
+      const data = await gatewayFetch(this._gatewayUrl, this._token, "/v1/chat/completions", {
+        messages,
+        model: params.model,
+        temperature: params.temperature ?? 0,
+        response_format: { type: "json_object" }
+      }, "ai");
+      const raw = data.choices?.[0]?.message?.content ?? "{}";
+      try {
+        return JSON.parse(raw);
+      } catch {
+        throw new BrokrError(
+          "[brokr] AI returned invalid JSON for structured extraction.",
+          "AI_STRUCTURED_PARSE_ERROR",
+          "ai"
+        );
+      }
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AIStructured";
+      throw err;
+    }
+  }
+  /**
+   * Extract fields from unstructured text.
+   * Semantic alias for structured() — same behavior, clearer intent.
+   */
+  async extract(prompt, schema) {
+    return this.structured({ prompt, schema });
+  }
+  /**
+   * Summarize text using AI.
+   */
+  async summarize(text, options) {
+    try {
+      const lengthHint = options?.maxLength ? ` Keep it under ${options.maxLength}.` : "";
+      const response = await this.chat(
+        [
+          {
+            role: "system",
+            content: `You are a summarization assistant. Provide a concise, accurate summary of the following text.${lengthHint} Return only the summary, no preamble.`
+          },
+          { role: "user", content: text }
+        ],
+        { model: options?.model }
+      );
+      return { summary: response.content };
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AISummarize";
+      throw err;
+    }
+  }
+  /**
+   * Classify text into one of the provided labels.
+   */
+  async classify(text, labels, options) {
+    try {
+      const labelsStr = labels.map((l) => `"${l}"`).join(", ");
+      const result = await this.structured({
+        prompt: `Classify the following text into exactly one of these labels: [${labelsStr}]
+
+Text: ${text}`,
+        schema: {
+          type: "object",
+          properties: {
+            label: { type: "string", enum: labels },
+            confidence: { type: "number", minimum: 0, maximum: 1 }
+          },
+          required: ["label", "confidence"]
+        },
+        model: options?.model,
+        temperature: 0
+      });
+      return result;
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AIClassify";
+      throw err;
+    }
+  }
+  /**
+   * Generate an embedding vector for the given text.
+   */
+  async embed(text) {
+    requireToken(this._token, "ai");
+    try {
+      const data = await gatewayFetch(this._gatewayUrl, this._token, "/v1/embeddings", {
+        input: text,
+        model: "text-embedding-3-small"
+      }, "ai");
+      return {
+        vector: data.data?.[0]?.embedding ?? []
+      };
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AIEmbed";
+      throw err;
+    }
+  }
+  /**
+   * Generate an image from a text prompt.
+   */
+  async image(prompt, options) {
+    requireToken(this._token, "ai");
+    try {
+      const data = await gatewayFetch(this._gatewayUrl, this._token, "/v1/images/generate", {
+        prompt,
+        size: options?.size ?? "1024x1024",
+        n: options?.n ?? 1,
+        model: options?.model
+      }, "ai");
+      const url = data.data?.[0]?.url;
+      if (!url) {
+        throw new BrokrError("[brokr] Image generation returned no URL.", "AI_IMAGE_FAILED", "ai");
+      }
+      return { url };
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "AIImage";
+      throw err;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // OpenAI-SDK compatibility
+  // ---------------------------------------------------------------------------
+  /** OpenAI-SDK compatible base URL. */
+  get baseURL() {
+    return `${this._gatewayUrl}/v1`;
+  }
+  /** Use as `apiKey` with the official OpenAI SDK to route through Brokr's gateway. */
+  get apiKey() {
+    requireToken(this._token, "ai");
+    return this._token;
+  }
+};
+
+// src/storage/client.ts
+var MULTIPART_THRESHOLD = 100 * 1024 * 1024;
+var DEFAULT_PART_SIZE = 100 * 1024 * 1024;
+var PART_UPLOAD_RETRIES = 3;
+var BrokrStorageClient = class {
+  constructor(_token, _gatewayUrl) {
+    this._token = _token;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  async upload(paramsOrData, filename, contentTypeArg) {
+    try {
+      let data;
+      let filePath;
+      let contentType;
+      if (typeof paramsOrData === "object" && paramsOrData !== null && "file" in paramsOrData) {
+        data = paramsOrData.file;
+        filePath = paramsOrData.path ?? `upload-${Date.now()}`;
+        contentType = paramsOrData.contentType ?? "application/octet-stream";
+      } else {
+        data = paramsOrData;
+        filePath = filename ?? `upload-${Date.now()}`;
+        contentType = contentTypeArg ?? "application/octet-stream";
+      }
+      const size = getUploadSize(data);
+      if (size !== void 0 && size > MULTIPART_THRESHOLD) {
+        return await this._uploadMultipart(data, filePath, contentType, size);
+      }
+      const { url, key } = await this.signUpload({ fileName: filePath, contentType });
+      const uploadHeaders = { "Content-Type": contentType };
+      if (typeof window === "undefined") {
+        const origin = process.env.BETTER_AUTH_URL ?? process.env.NEXT_PUBLIC_APP_URL ?? process.env.APP_URL ?? process.env.BROKR_AUTH_URL ?? (process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : void 0) ?? "http://localhost:3000";
+        uploadHeaders.Origin = origin;
+      }
+      const putRes = await fetch(url, {
+        method: "PUT",
+        headers: uploadHeaders,
+        body: data
+      });
+      if (!putRes.ok) {
+        throw new BrokrError(
+          `[brokr] Upload failed (HTTP ${putRes.status})`,
+          "STORAGE_UPLOAD_FAILED",
+          "storage"
+        );
+      }
+      const gatewayBase = this._gatewayUrl.replace(/\/+$/, "");
+      const permanentUrl = `${gatewayBase}/v1/storage/file/${encodeURI(key)}`;
+      return {
+        key,
+        url: permanentUrl,
+        name: filePath,
+        size,
+        type: contentType
+      };
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  /**
+   * Get a presigned download URL for a stored object.
+   */
+  async signedUrl(key, options) {
+    requireToken(this._token, "storage");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/sign-download",
+        { key, expiresIn: options?.expiresIn },
+        "storage"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  /** Low-level escape hatch. Most apps should call upload() instead. */
+  async signUpload(params) {
+    requireToken(this._token, "storage");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/sign-upload",
+        { filename: params.fileName, contentType: params.contentType ?? "application/octet-stream" },
+        "storage"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Multipart upload — handles files > 100MB, up to 20GB
+  // ---------------------------------------------------------------------------
+  /**
+   * Initiate a multipart upload via the gateway.
+   */
+  async _initiateMultipart(params) {
+    requireToken(this._token, "storage");
+    return gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/storage/multipart/initiate",
+      {
+        filename: params.fileName,
+        contentType: params.contentType,
+        totalSize: params.totalSize,
+        partCount: params.partCount
+      },
+      "storage"
+    );
+  }
+  /**
+   * Get a presigned URL for uploading a single part.
+   */
+  async _signPartUpload(params) {
+    requireToken(this._token, "storage");
+    return gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/storage/multipart/sign-part",
+      params,
+      "storage"
+    );
+  }
+  /**
+   * Complete a multipart upload with part ETags.
+   */
+  async _completeMultipart(params) {
+    requireToken(this._token, "storage");
+    return gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/storage/multipart/complete",
+      params,
+      "storage"
+    );
+  }
+  /**
+   * Abort a multipart upload, cleaning up uploaded parts.
+   */
+  async _abortMultipart(params) {
+    requireToken(this._token, "storage");
+    await gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/storage/multipart/abort",
+      params,
+      "storage"
+    );
+  }
+  /**
+   * Upload a large file using multipart upload.
+   * Splits the file into parts, uploads each with retry, then completes.
+   */
+  async _uploadMultipart(data, filePath, contentType, totalSize) {
+    const bytes = await toUint8Array(data);
+    const partSize = Math.max(DEFAULT_PART_SIZE, Math.ceil(totalSize / MAX_PARTS_PER_UPLOAD));
+    const partCount = Math.ceil(totalSize / partSize);
+    const { uploadId, key } = await this._initiateMultipart({
+      fileName: filePath,
+      contentType,
+      totalSize,
+      partCount
+    });
+    try {
+      const completedParts = [];
+      for (let i = 0; i < partCount; i++) {
+        const partNumber = i + 1;
+        const start = i * partSize;
+        const end = Math.min(start + partSize, totalSize);
+        const partData = bytes.slice(start, end);
+        const { url } = await this._signPartUpload({ key, uploadId, partNumber });
+        let lastError;
+        for (let attempt = 0; attempt < PART_UPLOAD_RETRIES; attempt++) {
+          try {
+            const putRes = await fetch(url, {
+              method: "PUT",
+              body: partData
+            });
+            if (!putRes.ok) {
+              throw new Error(`Part ${partNumber} upload failed (HTTP ${putRes.status})`);
+            }
+            const etag = putRes.headers.get("ETag");
+            if (!etag) {
+              throw new Error(`Part ${partNumber} upload returned no ETag`);
+            }
+            completedParts.push({ partNumber, etag });
+            lastError = void 0;
+            break;
+          } catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+          }
+        }
+        if (lastError) {
+          throw new BrokrError(
+            `[brokr] Multipart upload failed at part ${partNumber} after ${PART_UPLOAD_RETRIES} retries: ${lastError.message}`,
+            "STORAGE_UPLOAD_FAILED",
+            "storage"
+          );
+        }
+      }
+      completedParts.sort((a, b) => a.partNumber - b.partNumber);
+      await this._completeMultipart({ key, uploadId, parts: completedParts });
+      const gatewayBase = this._gatewayUrl.replace(/\/+$/, "");
+      const permanentUrl = `${gatewayBase}/v1/storage/file/${encodeURI(key)}`;
+      return {
+        key,
+        url: permanentUrl,
+        name: filePath,
+        size: totalSize,
+        type: contentType
+      };
+    } catch (err) {
+      try {
+        await this._abortMultipart({ key, uploadId });
+      } catch {
+      }
+      throw err;
+    }
+  }
+  /**
+   * List objects by prefix with pagination.
+   */
+  async list(params) {
+    requireToken(this._token, "storage");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/list",
+        {
+          prefix: params?.prefix,
+          maxKeys: params?.maxKeys,
+          cursor: params?.cursor
+        },
+        "storage"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  /**
+   * Delete an object by key.
+   */
+  async delete(key) {
+    requireToken(this._token, "storage");
+    try {
+      await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/delete",
+        { key },
+        "storage"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  /**
+   * Copy an object from one key to another.
+   */
+  async copy(from, to) {
+    requireToken(this._token, "storage");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/copy",
+        { from, to },
+        "storage"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  /**
+   * Move an object (copy then delete source).
+   */
+  async move(from, to) {
+    try {
+      const copied = await this.copy(from, to);
+      await this.delete(from);
+      return copied;
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  /**
+   * Check if an object exists.
+   */
+  /**
+   * Check if an object exists.
+   *
+   * Returns `false` on any error (not-found, rate-limit, network).
+   * This preserves backwards compatibility — `if (await brokr.storage.exists(key))`
+   * must never throw in user code that doesn't wrap it in try-catch.
+   *
+   * If you need to distinguish "doesn't exist" from "couldn't check",
+   * use `metadata()` instead and catch the error.
+   */
+  async exists(key) {
+    requireToken(this._token, "storage");
+    try {
+      const result = await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/exists",
+        { key },
+        "storage"
+      );
+      return result.exists;
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      return false;
+    }
+  }
+  /**
+   * Get file metadata without downloading the file.
+   */
+  async metadata(key) {
+    requireToken(this._token, "storage");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/storage/metadata",
+        { key },
+        "storage"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Storage";
+      throw err;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Deprecated aliases (backward compat)
+  // ---------------------------------------------------------------------------
+  /** @deprecated Use signedUrl() instead. */
+  async url(key, options) {
+    return this.signedUrl(key, options);
+  }
+  /** @deprecated Use signedUrl() instead. */
+  async getUrl(key, options) {
+    return this.signedUrl(key, options);
+  }
+  /** @deprecated Use signUpload() instead. */
+  async getUploadUrl(filename, contentType) {
+    return this.signUpload({ fileName: filename, contentType });
+  }
 };
-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 });
+var MAX_PARTS_PER_UPLOAD = 1e4;
+async function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error("Unsupported data type for multipart upload");
+}
+function getUploadSize(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data).length;
+  }
+  if (data instanceof Uint8Array) {
+    return data.byteLength;
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return data.size;
+  }
+  return void 0;
+}
+
+// src/email/templates.ts
+function interpolate(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+function wrapHtml(body) {
+  return `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head>
+<body style="margin:0;padding:0;background:#f5f5f5;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;">
+  <div style="max-width:560px;margin:40px auto;background:#ffffff;border-radius:8px;border:1px solid #e5e5e5;overflow:hidden;">
+    ${body}
+  </div>
+  <div style="text-align:center;padding:20px;color:#999;font-size:12px;">
+    Sent via Brokr
+  </div>
+</body>
+</html>`;
+}
+function section(content) {
+  return `<div style="padding:32px 40px;">${content}</div>`;
+}
+function button(text, urlVar) {
+  return `<a href="{{${urlVar}}}" style="display:inline-block;padding:12px 24px;background:#000;color:#fff;text-decoration:none;border-radius:6px;font-weight:600;font-size:14px;">${text}</a>`;
+}
+var welcomeTemplate = {
+  name: "welcome",
+  subject: "Welcome to {{appName}}",
+  html: (vars) => interpolate(wrapHtml(section(`
+    <h1 style="margin:0 0 16px;font-size:24px;color:#111;">Welcome to {{appName}}</h1>
+    <p style="margin:0 0 24px;color:#555;font-size:15px;line-height:1.6;">
+      Your account is ready. You can start using {{appName}} right away.
+    </p>
+    ${button("Get Started", "actionUrl")}
+  `)), vars)
+};
+var magicLinkTemplate = {
+  name: "magicLink",
+  subject: "Your sign-in link",
+  html: (vars) => interpolate(wrapHtml(section(`
+    <h1 style="margin:0 0 16px;font-size:24px;color:#111;">Sign in to {{appName}}</h1>
+    <p style="margin:0 0 24px;color:#555;font-size:15px;line-height:1.6;">
+      Click the button below to sign in. This link expires in 10 minutes.
+    </p>
+    ${button("Sign In", "magicLinkUrl")}
+    <p style="margin:24px 0 0;color:#999;font-size:13px;">
+      If you didn't request this, you can safely ignore this email.
+    </p>
+  `)), vars)
+};
+var passwordResetTemplate = {
+  name: "passwordReset",
+  subject: "Reset your password",
+  html: (vars) => interpolate(wrapHtml(section(`
+    <h1 style="margin:0 0 16px;font-size:24px;color:#111;">Reset your password</h1>
+    <p style="margin:0 0 24px;color:#555;font-size:15px;line-height:1.6;">
+      We received a request to reset your password for {{appName}}.
+      Click the button below to choose a new password.
+    </p>
+    ${button("Reset Password", "resetUrl")}
+    <p style="margin:24px 0 0;color:#999;font-size:13px;">
+      This link expires in 1 hour. If you didn't request this, ignore this email.
+    </p>
+  `)), vars)
+};
+var invoiceTemplate = {
+  name: "invoice",
+  subject: "Invoice #{{invoiceNumber}}",
+  html: (vars) => interpolate(wrapHtml(section(`
+    <h1 style="margin:0 0 16px;font-size:24px;color:#111;">Invoice #{{invoiceNumber}}</h1>
+    <p style="margin:0 0 8px;color:#555;font-size:15px;line-height:1.6;">
+      Amount: <strong>{{amount}}</strong>
+    </p>
+    <p style="margin:0 0 24px;color:#555;font-size:15px;line-height:1.6;">
+      {{description}}
+    </p>
+    ${button("View Invoice", "invoiceUrl")}
+  `)), vars)
+};
+var notificationTemplate = {
+  name: "notification",
+  subject: "{{title}}",
+  html: (vars) => interpolate(wrapHtml(section(`
+    <h1 style="margin:0 0 16px;font-size:24px;color:#111;">{{title}}</h1>
+    <p style="margin:0 0 24px;color:#555;font-size:15px;line-height:1.6;">
+      {{body}}
+    </p>
+  `)), vars)
+};
+var builtinTemplates = {
+  welcome: welcomeTemplate,
+  magicLink: magicLinkTemplate,
+  passwordReset: passwordResetTemplate,
+  invoice: invoiceTemplate,
+  notification: notificationTemplate
+};
+
+// src/email/client.ts
+function interpolate2(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+var BrokrEmailClient = class {
+  constructor(_token, _gatewayUrl) {
+    this._token = _token;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  /**
+   * Send an email. The from address and API credentials are resolved server-side.
+   */
+  async send(params) {
+    requireToken(this._token, "email");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/email/send",
+        params,
+        "email"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Email";
+      throw err;
+    }
+  }
+  /**
+   * Send an email using a built-in template.
+   *
+   * @example
+   * ```typescript
+   * await brokr.email.sendTemplate({
+   *   template: 'welcome',
+   *   to: 'user@example.com',
+   *   variables: { appName: 'MyApp', actionUrl: 'https://myapp.com/dashboard' },
+   * });
+   * ```
+   */
+  async sendTemplate(params) {
+    try {
+      const template = builtinTemplates[params.template];
+      if (!template) {
+        throw new BrokrError(
+          `[brokr] Unknown email template "${params.template}". Available: ${Object.keys(builtinTemplates).join(", ")}`,
+          "EMAIL_TEMPLATE_NOT_FOUND",
+          "email"
+        );
+      }
+      const subject = interpolate2(template.subject, params.variables);
+      const html = template.html(params.variables);
+      return await this.send({
+        to: params.to,
+        subject,
+        html,
+        from: params.from
+      });
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Email";
+      throw err;
+    }
+  }
+};
+
+// src/files/client.ts
+var BrokrFilesClient = class {
+  constructor(_token, _gatewayUrl, _storage) {
+    this._token = _token;
+    this._gatewayUrl = _gatewayUrl;
+    this._storage = _storage;
+  }
+  /**
+   * Upload a file and trigger server-side AI processing.
+   * Returns the storage key plus any extracted description/text.
+   */
+  async process(params) {
+    requireToken(this._token, "files");
+    const uploaded = await this._storage.upload({
+      file: params.file,
+      path: params.fileName,
+      contentType: params.purpose === "text-extraction" ? "application/pdf" : void 0
+    });
+    const result = await gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/files/process",
+      { key: uploaded.key, purpose: params.purpose ?? "general" },
+      "files"
+    );
+    return {
+      key: uploaded.key,
+      description: result.description,
+      text: result.text
+    };
+  }
+  /**
+   * Get an AI-generated description of an already-uploaded file.
+   */
+  async describe(key) {
+    requireToken(this._token, "files");
+    return gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/files/describe",
+      { key },
+      "files"
+    );
+  }
+  /**
+   * Extract text from a PDF or image (OCR).
+   */
+  async getText(key) {
+    requireToken(this._token, "files");
+    return gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/files/text",
+      { key },
+      "files"
+    );
+  }
+};
+
+// src/payments/client.ts
+var BrokrPaymentsClient = class {
+  constructor(_token, _gatewayUrl) {
+    this._token = _token;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  /**
+   * Create a Stripe Checkout session for a plan.
+   * Returns a URL to redirect the end user to.
+   *
+   * @example
+   * ```ts
+   * const user = await brokr.auth.requireUser(request.headers);
+   * const { checkoutUrl } = await brokr.payments.checkout({
+   *   plan: 'pro',
+   *   userId: user.id,
+   * });
+   * // Redirect user to checkoutUrl
+   * ```
+   */
+  /**
+   * Create a Stripe Checkout session for a plan.
+   *
+   * @param params.plan - Plan slug (e.g. 'pro')
+   * @param params.userId - End user's ID from your auth system
+   * @param params.returnUrl - Where to redirect after checkout. Defaults to your stack's URL.
+   *   Pass explicitly for localhost or non-Brokr deployments.
+   */
+  async checkout(params) {
+    requireToken(this._token, "payments");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/payments/checkout",
+        { planSlug: params.plan, appUserId: params.userId, returnUrl: params.returnUrl },
+        "payments"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Payments";
+      throw err;
+    }
+  }
+  /**
+   * Create a Stripe Customer Portal session.
+   * Returns a URL where the end user can manage their subscription.
+   */
+  /**
+   * Create a Stripe Customer Portal session.
+   *
+   * @param params.userId - End user's ID
+   * @param params.returnUrl - Where to redirect when they're done. Defaults to your stack's URL.
+   */
+  async portal(params) {
+    requireToken(this._token, "payments");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/payments/portal",
+        { appUserId: params.userId, returnUrl: params.returnUrl },
+        "payments"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Payments";
+      throw err;
+    }
+  }
+  /**
+   * Get the end user's current plan.
+   * Returns null if the user has no subscription.
+   */
+  async currentPlan(params) {
+    requireToken(this._token, "payments");
+    try {
+      return await gatewayFetch(
+        this._gatewayUrl,
+        this._token,
+        "/v1/payments/plan",
+        { appUserId: params.userId },
+        "payments"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Payments";
+      throw err;
+    }
+  }
+};
+
+// src/payments/entitlements.ts
+var BrokrEntitlementsClient = class {
+  constructor(_token, _gatewayUrl) {
+    this._token = _token;
+    this._gatewayUrl = _gatewayUrl;
+  }
+  /**
+   * Check if an end user is entitled to a feature.
+   * Returns true/false without throwing.
+   *
+   * @example
+   * ```ts
+   * const user = await brokr.auth.requireUser(request.headers);
+   * const canChat = await brokr.entitlements.check({ feature: 'ai.chat', userId: user.id });
+   * ```
+   */
+  async check(params) {
+    requireToken(this._token, "payments");
+    const result = await gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/payments/entitlements/check",
+      { feature: params.feature, appUserId: params.userId },
+      "payments"
+    );
+    return result.allowed;
+  }
+  /**
+   * Require that an end user is entitled to a feature.
+   * Throws BrokrError if not entitled.
+   */
+  async require(params) {
+    const allowed = await this.check(params);
+    if (!allowed) {
+      throw new BrokrError(
+        `[brokr] Feature "${params.feature}" is not available on the user's current plan. Upgrade at the billing portal.`,
+        "ENTITLEMENT_DENIED",
+        "payments"
+      );
+    }
+  }
+  /**
+   * Get usage stats for a metered feature.
+   * This is a READ — does NOT increment the counter.
+   * Use `increment()` to record usage.
+   */
+  async usage(params) {
+    requireToken(this._token, "payments");
+    return gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/payments/entitlements/usage",
+      { feature: params.feature, appUserId: params.userId },
+      "payments"
+    );
+  }
+  /**
+   * Record a usage event for a metered feature.
+   * This is a WRITE — increments the counter.
+   */
+  async increment(params) {
+    requireToken(this._token, "payments");
+    await gatewayFetch(
+      this._gatewayUrl,
+      this._token,
+      "/v1/payments/entitlements/increment",
+      { feature: params.feature, appUserId: params.userId, amount: params.amount ?? 1 },
+      "payments"
+    );
+  }
+};
+
+// src/notifications/client.ts
+var BrokrNotificationsClient = class {
+  constructor(token, gatewayUrl) {
+    this.token = token;
+    this.gatewayUrl = gatewayUrl;
+  }
+  /**
+   * Send a notification to a user. Delivered via WebSocket in real-time
+   * and persisted in the notification history.
+   */
+  async send(params) {
+    requireToken(this.token, "notifications");
+    try {
+      return await gatewayFetch(
+        this.gatewayUrl,
+        this.token,
+        "/v1/notifications/push",
+        params,
+        "notifications"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Notifications";
+      throw err;
+    }
+  }
+  /**
+   * Fetch notification history for a user. Reads from the DO's SQLite
+   * storage via a gateway REST endpoint.
+   */
+  async list(params) {
+    requireToken(this.token, "notifications");
+    try {
+      return await gatewayFetch(
+        this.gatewayUrl,
+        this.token,
+        "/v1/notifications/list",
+        params,
+        "notifications"
+      );
+    } catch (err) {
+      if (err instanceof BrokrError) err.component = "Notifications";
+      throw err;
+    }
   }
-  return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/auth.ts
-var auth_exports = {};
-__export(auth_exports, {
-  BrokrAuthClient: () => BrokrAuthClient,
-  authMiddleware: () => authMiddleware
-});
+function resolveAppUrl(appUrl) {
+  if (appUrl) return appUrl;
+  throw new BrokrError(
+    "[brokr] BROKR_AUTH_URL is not set. Auth may not be provisioned.",
+    "AUTH_NOT_CONFIGURED",
+    "auth"
+  );
+}
+function mapSessionUser(raw) {
+  return {
+    id: raw.id,
+    email: raw.email,
+    name: raw.name ?? null,
+    image: raw.image ?? null,
+    emailVerified: raw.emailVerified ? /* @__PURE__ */ new Date() : null
+  };
+}
+function pluralizeResource(resource) {
+  if (resource.endsWith("s")) return resource;
+  if (resource.endsWith("y") && !/[aeiou]y$/i.test(resource)) return resource.slice(0, -1) + "ies";
+  return resource + "s";
+}
+function validateSqlIdentifier(name, label) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new BrokrError(
+      `[brokr] Invalid ${label}: "${name}". Must be alphanumeric with underscores only.`,
+      "INVALID_IDENTIFIER",
+      "auth"
+    );
+  }
+}
+var _ownershipPool = null;
+async function getOwnershipPool(dbUrl) {
+  let Pool;
+  try {
+    const mod = await import("@neondatabase/serverless");
+    Pool = mod.Pool;
+  } catch {
+    throw new BrokrError(
+      "[brokr] @neondatabase/serverless is required for ownership checks. Run: npm install @neondatabase/serverless",
+      "MISSING_DEPENDENCY",
+      "auth"
+    );
+  }
+  if (_ownershipPool && _ownershipPool.dbUrl === dbUrl) {
+    return _ownershipPool.pool;
+  }
+  const pool = new Pool({ connectionString: dbUrl, max: 3 });
+  _ownershipPool = { pool, dbUrl };
+  return pool;
+}
+async function authApiFetch(appUrl, path, options) {
+  const headers = { "Content-Type": "application/json" };
+  if (options?.cookies) headers.cookie = options.cookies;
+  if (typeof window === "undefined") {
+    headers.Origin = process.env.BETTER_AUTH_URL ?? process.env.NEXT_PUBLIC_APP_URL ?? process.env.APP_URL ?? process.env.BROKR_AUTH_URL ?? (process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : void 0) ?? appUrl;
+  }
+  const res = await fetch(`${appUrl}${path}`, {
+    method: options?.method ?? "GET",
+    headers,
+    body: options?.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new BrokrError(
+      data.message ?? `[brokr] Auth API call failed (HTTP ${res.status})`,
+      "AUTH_API_FAILED",
+      "auth"
+    );
+  }
+  return res.json();
+}
+var BrokrAuthClient = class {
+  constructor(_token, _gatewayUrl, appUrl) {
+    this._appUrl = appUrl ?? (typeof process !== "undefined" ? process.env.BROKR_AUTH_URL : void 0);
+  }
+  // -------------------------------------------------------------------------
+  // Identity — read user/session from incoming request
+  // -------------------------------------------------------------------------
+  /**
+   * Get user from request headers. Returns null if not authenticated.
+   * Calls the app's own Better Auth API.
+   */
+  async user(headers) {
+    const session = await this.session(headers);
+    return session?.user ?? null;
+  }
+  /**
+   * Get user from request headers. Throws 401 if not authenticated.
+   */
+  async requireUser(headers) {
+    const u = await this.user(headers);
+    if (!u) {
+      throw new BrokrError("[brokr] Authentication required. The request has no valid session. Check that cookies are being forwarded.", "UNAUTHORIZED", "auth");
+    }
+    return u;
+  }
+  /**
+   * Get full session from request headers. Returns null if not authenticated.
+   */
+  async session(headers) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const cookieHeader = headers.get("cookie") ?? "";
+    if (!cookieHeader) return null;
+    const res = await fetch(`${appUrl}/api/auth/get-session`, {
+      method: "GET",
+      headers: { cookie: cookieHeader }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data?.user || !data?.session) return null;
+    return {
+      user: mapSessionUser(data.user),
+      sessionId: data.session.id,
+      expiresAt: new Date(data.session.expiresAt)
+    };
+  }
+  /**
+   * Get full session. Throws 401 if not authenticated.
+   */
+  async requireSession(headers) {
+    const s = await this.session(headers);
+    if (!s) {
+      throw new BrokrError("[brokr] Authentication required. The request has no valid session. Check that cookies are being forwarded.", "UNAUTHORIZED", "auth");
+    }
+    return s;
+  }
+  // -------------------------------------------------------------------------
+  // Legacy aliases (backward compat)
+  // -------------------------------------------------------------------------
+  /** @deprecated Use user(request.headers) instead. */
+  async currentUser(request) {
+    return this.user(request.headers);
+  }
+  /** @deprecated Use session(request.headers) instead. */
+  async getSession(request) {
+    return this.session(request.headers);
+  }
+  // -------------------------------------------------------------------------
+  // Auth actions — call Better Auth endpoints on the stack's app
+  // -------------------------------------------------------------------------
+  /**
+   * Sign in with email and password.
+   */
+  async signIn(params) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const data = await authApiFetch(appUrl, "/api/auth/sign-in/email", {
+      method: "POST",
+      body: params
+    });
+    return {
+      user: mapSessionUser(data.user),
+      sessionId: data.session.id,
+      expiresAt: new Date(data.session.expiresAt)
+    };
+  }
+  /**
+   * Sign in with OAuth provider. Returns redirect URL.
+   */
+  async signInWithProvider(provider, options) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const redirectTo = options?.redirectTo ?? "/";
+    if (!redirectTo.startsWith("/") || redirectTo.startsWith("//")) {
+      throw new BrokrError("[brokr] redirectTo must be a relative path (start with /)", "INVALID_REDIRECT", "auth");
+    }
+    if (!/^[a-z][a-z0-9_-]*$/.test(provider)) {
+      throw new BrokrError(`[brokr] Invalid provider name: "${provider}". Must be lowercase alphanumeric.`, "INVALID_PROVIDER", "auth");
+    }
+    const params = new URLSearchParams({ provider, callbackURL: redirectTo });
+    return { redirectUrl: `${appUrl}/api/auth/sign-in/social?${params}` };
+  }
+  /**
+   * Sign up with email and password.
+   */
+  async signUp(params) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const data = await authApiFetch(appUrl, "/api/auth/sign-up/email", {
+      method: "POST",
+      body: params
+    });
+    return {
+      user: mapSessionUser(data.user),
+      sessionId: data.session.id,
+      expiresAt: new Date(data.session.expiresAt)
+    };
+  }
+  /**
+   * Sign out the current user.
+   */
+  async signOut(headers) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const cookies = headers?.get("cookie") ?? "";
+    await authApiFetch(appUrl, "/api/auth/sign-out", {
+      method: "POST",
+      cookies
+    });
+  }
+  /**
+   * Send a magic link email.
+   */
+  async sendMagicLink(email, options) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    await authApiFetch(appUrl, "/api/auth/magic-link/send", {
+      method: "POST",
+      body: { email, callbackURL: options?.redirectTo ?? "/" }
+    });
+  }
+  /**
+   * Send a password reset email.
+   */
+  async sendPasswordReset(params) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    await authApiFetch(appUrl, "/api/auth/forget-password", {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Reset password with token from email.
+   */
+  async resetPassword(params) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    await authApiFetch(appUrl, "/api/auth/reset-password", {
+      method: "POST",
+      body: { token: params.token, newPassword: params.password }
+    });
+  }
+  /**
+   * Verify email with token from email.
+   */
+  async verifyEmail(params) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    await authApiFetch(appUrl, "/api/auth/verify-email", {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Update the current user's profile.
+   */
+  async updateUser(params, headers) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const cookies = headers?.get("cookie") ?? "";
+    await authApiFetch(appUrl, "/api/auth/update-user", {
+      method: "POST",
+      body: params,
+      cookies
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Session management
+  // -------------------------------------------------------------------------
+  /** Session management sub-client. */
+  get sessions() {
+    if (!this._sessions) {
+      this._sessions = new BrokrSessionsClient(this._appUrl);
+    }
+    return this._sessions;
+  }
+  // -------------------------------------------------------------------------
+  // Ownership — queries the stack's own DB via gateway → server
+  // -------------------------------------------------------------------------
+  /**
+   * Check if the current user owns a resource. Throws 403 if not.
+   *
+   * Queries the developer's own database directly via DATABASE_URL.
+   * Convention: pluralizes resource name → table, assumes `id` PK + `user_id` owner column.
+   * Override with `opts.table` and `opts.ownerColumn` for non-standard schemas.
+   *
+   * @example
+   * ```ts
+   * await brokr.auth.requireOwner('conversation', conversationId, request.headers);
+   * // Under the hood: SELECT 1 FROM conversations WHERE id = $1 AND user_id = $2
+   * ```
+   */
+  async requireOwner(resource, id, headers, opts) {
+    const isOwner = await this.isOwner(resource, id, headers, opts);
+    if (!isOwner) {
+      throw new BrokrError(
+        `[brokr] Access denied \u2014 current user does not own this ${resource}. Verify the resource ID and that the user is the owner.`,
+        "FORBIDDEN",
+        "auth"
+      );
+    }
+  }
+  /**
+   * Check if the current user owns a resource. Returns boolean.
+   *
+   * Runs a direct query against the developer's database (DATABASE_URL).
+   * No gateway round-trip — this is a local DB operation.
+   */
+  async isOwner(resource, id, headers, opts) {
+    const user = await this.requireUser(headers);
+    const dbUrl = typeof process !== "undefined" ? process.env.DATABASE_URL : void 0;
+    if (!dbUrl) {
+      throw new BrokrError(
+        "[brokr] DATABASE_URL is not set. Cannot check ownership without a database.",
+        "DB_NOT_CONFIGURED",
+        "auth"
+      );
+    }
+    const tableName = opts?.table ?? pluralizeResource(resource);
+    const ownerCol = opts?.ownerColumn ?? "user_id";
+    validateSqlIdentifier(tableName, "table name");
+    validateSqlIdentifier(ownerCol, "owner column");
+    const pool = await getOwnershipPool(dbUrl);
+    try {
+      const result = await pool.query(
+        `SELECT 1 FROM "${tableName}" WHERE id = $1 AND "${ownerCol}" = $2 LIMIT 1`,
+        [id, user.id]
+      );
+      return (result.rowCount ?? 0) > 0;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error("[brokr] Ownership check error:", msg);
+      if (msg.includes("does not exist")) {
+        throw new BrokrError(
+          `[brokr] Table "${tableName}" does not exist. Check your resource name or provide { table: '...' }.`,
+          "TABLE_NOT_FOUND",
+          "auth"
+        );
+      }
+      throw new BrokrError(
+        "[brokr] Ownership check failed. Check your DATABASE_URL and that the database is accessible.",
+        "DB_QUERY_FAILED",
+        "auth"
+      );
+    }
+  }
+  /**
+   * Check if the current user matches a specific userId. Throws 403 if not.
+   */
+  async requireCurrentUser(userId, headers) {
+    const user = await this.requireUser(headers);
+    if (user.id !== userId) {
+      throw new BrokrError("[brokr] Access denied.", "FORBIDDEN", "auth");
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Legacy alias
+  // -------------------------------------------------------------------------
+  /** @deprecated Use signInWithProvider() instead. */
+  async getOAuthUrl(provider, options) {
+    return this.signInWithProvider(provider, options);
+  }
+};
+var BrokrSessionsClient = class {
+  constructor(appUrl) {
+    this._appUrl = appUrl;
+  }
+  /**
+   * List all active sessions for the current user.
+   */
+  async list(headers) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const cookies = headers.get("cookie") ?? "";
+    const data = await authApiFetch(appUrl, "/api/auth/list-sessions", { cookies });
+    const sessionToken = parseCookieValue(cookies, "better-auth.session_token") ?? parseCookieValue(cookies, "__Secure-better-auth.session_token");
+    return data.map((s) => ({
+      id: s.id,
+      createdAt: new Date(s.createdAt),
+      expiresAt: new Date(s.expiresAt),
+      userAgent: s.userAgent,
+      ipAddress: s.ipAddress,
+      isCurrent: s.token === sessionToken
+    }));
+  }
+  /**
+   * Revoke a specific session by ID.
+   */
+  async revoke(sessionId, headers) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const cookies = headers.get("cookie") ?? "";
+    await authApiFetch(appUrl, "/api/auth/revoke-session", {
+      method: "POST",
+      body: { id: sessionId },
+      cookies
+    });
+  }
+  /**
+   * Revoke all sessions except the current one.
+   */
+  async revokeOthers(headers) {
+    const appUrl = resolveAppUrl(this._appUrl);
+    const cookies = headers.get("cookie") ?? "";
+    await authApiFetch(appUrl, "/api/auth/revoke-other-sessions", {
+      method: "POST",
+      cookies
+    });
+  }
+};
 function parseCookies(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();
   for (const pair of cookieHeader.split(";")) {
@@ -42,6 +3179,9 @@ function parseCookies(cookieHeader) {
   }
   return cookies;
 }
+function parseCookieValue(cookieHeader, name) {
+  return parseCookies(cookieHeader).get(name);
+}
 function authMiddleware(options) {
   const { protectedRoutes = [], publicOnlyRoutes = [] } = options;
   return async function middleware(request) {
@@ -52,7 +3192,7 @@ function authMiddleware(options) {
     if (!isProtected && !isPublicOnly) return void 0;
     const cookieHeader = request.headers.get("cookie") ?? "";
     const cookies = parseCookies(cookieHeader);
-    const hasSession = cookies.has("better-auth.session_token");
+    const hasSession = cookies.has("better-auth.session_token") || cookies.has("__Secure-better-auth.session_token");
     if (isProtected && !hasSession) {
       return Response.redirect(new URL("/sign-in", request.url).toString(), 302);
     }
@@ -61,498 +3201,950 @@ function authMiddleware(options) {
     }
     return void 0;
   };
-}
-var BrokrAuthClient;
-var init_auth = __esm({
-  "src/auth.ts"() {
-    "use strict";
-    init_runtime();
-    BrokrAuthClient = class {
-      constructor(token, gatewayUrl, appUrl) {
-        this._token = token;
-        this._gatewayUrl = gatewayUrl;
-        this._appUrl = appUrl ?? (typeof process !== "undefined" ? process.env.BETTER_AUTH_URL : void 0);
-      }
-      /**
-       * Get current user from an incoming request's cookies.
-       * Calls the local Better Auth API (runs inside your app).
-       */
-      async currentUser(request) {
-        const session = await this.getSession(request);
-        return session?.user ?? null;
-      }
-      /**
-       * Get the full session (user + metadata) from an incoming request.
-       * Calls the local Better Auth API.
-       */
-      async getSession(request) {
-        const appUrl = this._appUrl;
-        if (!appUrl) {
-          throw new BrokrError(
-            "[brokr] BETTER_AUTH_URL is not set. Auth may not be provisioned.",
-            "AUTH_NOT_CONFIGURED",
-            "auth"
-          );
-        }
-        const cookieHeader = request.headers.get("cookie") ?? "";
-        if (!cookieHeader) return null;
-        const res = await fetch(`${appUrl}/api/auth/get-session`, {
-          method: "GET",
-          headers: { cookie: cookieHeader }
-        });
-        if (!res.ok) return null;
-        const data = await res.json();
-        if (!data?.user || !data?.session) return null;
-        return {
-          user: {
-            id: data.user.id,
-            email: data.user.email,
-            name: data.user.name ?? null,
-            avatarUrl: data.user.image ?? null,
-            emailVerified: data.user.emailVerified ? /* @__PURE__ */ new Date() : null
-          },
-          sessionId: data.session.id,
-          expiresAt: new Date(data.session.expiresAt)
-        };
-      }
-      /**
-       * Generate an OAuth authorization URL.
-       */
-      async getOAuthUrl(provider, options) {
-        const appUrl = this._appUrl;
-        if (!appUrl) {
-          throw new BrokrError("[brokr] BETTER_AUTH_URL is not set.", "AUTH_NOT_CONFIGURED", "auth");
-        }
-        const redirectTo = options?.redirectTo ?? "/";
-        if (!redirectTo.startsWith("/") || redirectTo.startsWith("//")) {
-          throw new BrokrError("[brokr] redirectTo must be a relative path (start with /)", "INVALID_REDIRECT", "auth");
-        }
-        const params = new URLSearchParams({ callbackURL: redirectTo });
-        return { redirectUrl: `${appUrl}/api/auth/sign-in/social?provider=${provider}&${params}` };
-      }
-      /**
-       * Send a magic link email (requires email capability).
-       */
-      async sendMagicLink(email, options) {
-        const appUrl = this._appUrl;
-        if (!appUrl) {
-          throw new BrokrError("[brokr] BETTER_AUTH_URL is not set.", "AUTH_NOT_CONFIGURED", "auth");
-        }
-        const res = await fetch(`${appUrl}/api/auth/magic-link/send`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email, callbackURL: options?.redirectTo ?? "/" })
-        });
-        if (!res.ok) {
-          const data = await res.json().catch(() => ({}));
-          throw new BrokrError(
-            data.message ?? `[brokr] Failed to send magic link (HTTP ${res.status})`,
-            "AUTH_MAGIC_LINK_FAILED",
-            "auth"
-          );
-        }
-      }
-    };
-  }
-});
+}
 
-// src/runtime.ts
-function resolveToken() {
-  return typeof process !== "undefined" ? process.env.BROKR_TOKEN : void 0;
+// src/models.ts
+var models = {
+  /** Cheapest and fastest model (Deepseek Chat). */
+  FAST: "deepseek-chat",
+  /** Most capable model. */
+  SMART: "claude-sonnet-4-6",
+  /** Default balanced model (Deepseek Chat). */
+  BALANCED: "deepseek-chat"
+};
+var providers = [
+  { id: "deepseek", label: "Deepseek", model: "deepseek-chat", color: "#0EA5E9", free: true, logo: "https://assets.brokr.sh/sdk/deepseek_logo.png" },
+  { id: "openai", label: "ChatGPT", model: "gpt-5.4-mini", color: "#10B981", free: false, logo: "https://assets.brokr.sh/sdk/gpt_logo.png" },
+  { id: "anthropic", label: "Claude", model: "claude-sonnet-4-6", color: "#F59E0B", free: false, logo: "https://assets.brokr.sh/sdk/claude_logo.png" },
+  { id: "kimi", label: "Kimi", model: "fireworks/kimi-k2p5", color: "#8B5CF6", free: false, logo: "https://assets.brokr.sh/sdk/kimi_logo.png" },
+  { id: "minimax", label: "Minimax", model: "MiniMaxAI/MiniMax-M2.5", color: "#EC4899", free: false, logo: "https://assets.brokr.sh/sdk/minimax_logo.png" }
+];
+function resolveProviderByModel(model) {
+  return providers.find((p) => p.model === model) ?? providers.find((p) => model.toLowerCase().includes(p.id));
 }
-function assertToken(token, capability) {
-  if (!token) {
-    let hint = "brokr env pull --stack <name>";
-    try {
-      if (typeof process !== "undefined") {
-        const fs = __require("fs");
-        const path = __require("path");
-        const brokrFile = path.join(process.cwd(), ".brokr");
-        if (fs.existsSync(brokrFile)) {
-          const data = JSON.parse(fs.readFileSync(brokrFile, "utf8"));
-          if (data?.stackName) hint = `brokr env pull --stack ${data.stackName}`;
-        }
-      }
-    } catch {
+
+// src/runtime.ts
+var BrokrRuntime = class {
+  constructor(options) {
+    this._token = options?.token ?? resolveToken();
+    this._gatewayUrl = options?.gatewayUrl ?? GATEWAY_URL;
+    this.ai = new BrokrAIClient(this._token, this._gatewayUrl);
+    this.storage = new BrokrStorageClient(this._token, this._gatewayUrl);
+    this.email = new BrokrEmailClient(this._token, this._gatewayUrl);
+  }
+  // -------------------------------------------------------------------------
+  // Lazy namespace getters
+  // -------------------------------------------------------------------------
+  /** Files client (upload + AI processing). */
+  get files() {
+    if (!this._files) {
+      this._files = new BrokrFilesClient(this._token, this._gatewayUrl, this.storage);
     }
-    throw new BrokrAuthError(
-      `[brokr] BROKR_TOKEN is not set.
-Run: ${hint}`,
-      "BROKR_TOKEN_MISSING"
-    );
+    return this._files;
   }
-}
-async function gatewayFetch(gatewayUrl, token, path, body, capability) {
-  let res;
-  try {
-    res = await fetch(`${gatewayUrl}${path}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
-      body: JSON.stringify(body)
-    });
-  } catch (err) {
-    throw new BrokrNetworkError(
-      `[brokr] Could not reach Brokr gateway. Check your network.
-${err instanceof Error ? err.message : String(err)}`,
-      capability
-    );
+  /** Payments client (checkout, portal, plan queries). */
+  get payments() {
+    if (!this._payments) {
+      this._payments = new BrokrPaymentsClient(this._token, this._gatewayUrl);
+    }
+    return this._payments;
   }
-  if (res.status === 429) {
-    const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60", 10);
-    const data = await res.json().catch(() => ({}));
-    throw new BrokrRateLimitError(
-      data.error ?? `[brokr] Rate limited (retry after ${retryAfter}s)`,
-      retryAfter,
-      capability
-    );
+  /** Notifications client (send + list notifications). */
+  get notifications() {
+    if (!this._notifications) {
+      this._notifications = new BrokrNotificationsClient(this._token, this._gatewayUrl);
+    }
+    return this._notifications;
   }
-  if (res.status === 401) {
-    throw new BrokrAuthError("[brokr] Invalid or expired BROKR_TOKEN.", "BROKR_TOKEN_INVALID");
+  /** Entitlements client (feature checks, usage queries). */
+  get entitlements() {
+    if (!this._entitlements) {
+      this._entitlements = new BrokrEntitlementsClient(this._token, this._gatewayUrl);
+    }
+    return this._entitlements;
   }
-  if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new BrokrError(
-      data.error ?? `[brokr] ${capability} request failed (HTTP ${res.status})`,
-      data.code ?? `${capability.toUpperCase()}_FAILED`,
-      capability
-    );
+  /** Auth client — lazily initialized. */
+  get auth() {
+    if (!this._auth) {
+      this._auth = new BrokrAuthClient(this._token, this._gatewayUrl);
+    }
+    return this._auth;
   }
-  return res.json();
-}
+  // -------------------------------------------------------------------------
+  // Root aliases — one-liner DX for the most common operations
+  // -------------------------------------------------------------------------
+  /** Send a chat message. Alias for `brokr.ai.chat()`. */
+  chat(input, options) {
+    return this.ai.chat(input, options);
+  }
+  /** Upload a file. Alias for `brokr.storage.upload()`. */
+  upload(params) {
+    return this.storage.upload(params);
+  }
+  /** Start a checkout flow. Alias for `brokr.payments.checkout()`. */
+  checkout(params) {
+    return this.payments.checkout(params);
+  }
+  /** Start a checkout flow. Alias for `brokr.checkout()` — north star one-liner. */
+  purchase(params) {
+    return this.payments.checkout(params);
+  }
+};
 function createBrokr(options) {
+  BrokrDevConsole.install();
+  initCapture({
+    token: options?.token,
+    gatewayUrl: options?.gatewayUrl
+  });
   return new BrokrRuntime(options);
 }
-var GATEWAY_URL, BrokrError, BrokrAuthError, BrokrRateLimitError, BrokrNetworkError, BrokrAIClient, BrokrStorageClient, BrokrEmailClient, BrokrRuntime;
-var init_runtime = __esm({
-  "src/runtime.ts"() {
-    "use strict";
-    GATEWAY_URL = "https://api.brokr.sh";
-    BrokrError = class extends Error {
-      constructor(message, code, capability, retryable = false) {
-        super(message);
-        this.code = code;
-        this.capability = capability;
-        this.retryable = retryable;
-        this.name = "BrokrError";
-      }
-    };
-    BrokrAuthError = class extends BrokrError {
-      constructor(message, code) {
-        super(message, code, "auth", false);
-        this.name = "BrokrAuthError";
-      }
-    };
-    BrokrRateLimitError = class extends BrokrError {
-      constructor(message, retryAfter, capability) {
-        super(message, "RATE_LIMITED", capability, true);
-        this.retryAfter = retryAfter;
-        this.name = "BrokrRateLimitError";
-      }
-    };
-    BrokrNetworkError = class extends BrokrError {
-      constructor(message, capability) {
-        super(message, "NETWORK_ERROR", capability, true);
-        this.name = "BrokrNetworkError";
-      }
-    };
-    BrokrAIClient = class {
-      constructor(_token, _gatewayUrl) {
-        this._token = _token;
-        this._gatewayUrl = _gatewayUrl;
-      }
-      /**
-       * Send a chat completion request.
-       *
-       * @example
-       * ```typescript
-       * const reply = await brokr.ai.chat([
-       *   { role: 'user', content: 'Explain quantum computing in one sentence.' }
-       * ]);
-       * console.log(reply.content);
-       * ```
-       */
-      async chat(messages, options) {
-        assertToken(this._token, "ai");
-        const data = await gatewayFetch(this._gatewayUrl, this._token, "/v1/chat/completions", {
-          messages,
-          model: options?.model,
-          max_tokens: options?.maxTokens,
-          temperature: options?.temperature
-        }, "ai");
-        return {
-          content: data.choices?.[0]?.message?.content ?? "",
-          model: data.model ?? "",
-          usage: {
-            promptTokens: data.usage?.prompt_tokens ?? 0,
-            completionTokens: data.usage?.completion_tokens ?? 0
-          }
-        };
-      }
-      /**
-       * Stream a chat completion. Yields text strings directly.
-       *
-       * @example
-       * ```typescript
-       * for await (const text of brokr.ai.stream(messages)) {
-       *   process.stdout.write(text);
-       * }
-       * ```
-       */
-      async *stream(messages, options) {
-        assertToken(this._token, "ai");
-        let res;
-        try {
-          res = await fetch(`${this._gatewayUrl}/v1/chat/completions`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: `Bearer ${this._token}` },
-            body: JSON.stringify({ messages, stream: true, model: options?.model, max_tokens: options?.maxTokens })
-          });
-        } catch (err) {
-          throw new BrokrNetworkError(
-            `[brokr] Could not reach Brokr gateway.
-${err instanceof Error ? err.message : String(err)}`,
-            "ai"
-          );
-        }
-        if (res.status === 429) {
-          const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60", 10);
-          throw new BrokrRateLimitError("[brokr] AI rate limited.", retryAfter, "ai");
-        }
-        if (res.status === 401) {
-          throw new BrokrAuthError("[brokr] Invalid or expired BROKR_TOKEN.", "BROKR_TOKEN_INVALID");
-        }
-        if (!res.ok || !res.body) {
-          throw new BrokrError(`[brokr] AI stream failed (HTTP ${res.status})`, "AI_STREAM_FAILED", "ai");
-        }
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const payload = line.slice(6).trim();
-            if (payload === "[DONE]") return;
-            try {
-              const parsed = JSON.parse(payload);
-              const delta = parsed.choices?.[0]?.delta?.content ?? "";
-              if (delta) yield delta;
-            } catch {
-            }
-          }
-        }
-      }
-      /**
-       * OpenAI-SDK compatible base URL.
-       *
-       * @example
-       * ```typescript
-       * const openai = new OpenAI({ baseURL: brokr.ai.baseURL, apiKey: brokr.ai.apiKey });
-       * ```
-       */
-      get baseURL() {
-        return `${this._gatewayUrl}/v1`;
-      }
-      /** Use as `apiKey` with the official OpenAI SDK to route through Brokr's gateway. */
-      get apiKey() {
-        assertToken(this._token, "ai");
-        return this._token;
-      }
-    };
-    BrokrStorageClient = class {
-      constructor(_token, _gatewayUrl) {
-        this._token = _token;
-        this._gatewayUrl = _gatewayUrl;
-      }
-      /**
-       * Get a presigned upload URL for browser-direct or streaming uploads.
-       *
-       * @example
-       * ```typescript
-       * const { url, key } = await brokr.storage.getUploadUrl('avatar.png', 'image/png');
-       * await fetch(url, { method: 'PUT', body: file });
-       * ```
-       */
-      async getUploadUrl(filename, contentType = "application/octet-stream") {
-        assertToken(this._token, "storage");
-        return gatewayFetch(
-          this._gatewayUrl,
-          this._token,
-          "/v1/storage/sign-upload",
-          { filename, contentType },
-          "storage"
-        );
-      }
-      /**
-       * Upload data to R2. Returns the stable object key.
-       *
-       * @example
-       * ```typescript
-       * const { key } = await brokr.storage.upload(fileBuffer, 'photo.jpg', 'image/jpeg');
-       * ```
-       */
-      async upload(data, filename, contentType = "application/octet-stream") {
-        const { url, key } = await this.getUploadUrl(filename, contentType);
-        const putRes = await fetch(url, {
-          method: "PUT",
-          headers: { "Content-Type": contentType },
-          body: data
-        });
-        if (!putRes.ok) {
-          throw new BrokrError(`[brokr] Upload failed (HTTP ${putRes.status})`, "STORAGE_UPLOAD_FAILED", "storage");
-        }
-        return { key };
-      }
-      /**
-       * Get a presigned download URL for a stored object.
-       *
-       * @example
-       * ```typescript
-       * const { url } = await brokr.storage.url('photos/avatar.jpg');
-       * // use url in <img src={url} /> or redirect
-       * ```
-       */
-      async url(key, options) {
-        assertToken(this._token, "storage");
-        return gatewayFetch(
-          this._gatewayUrl,
-          this._token,
-          "/v1/storage/sign-download",
-          { key, expiresIn: options?.expiresIn },
-          "storage"
-        );
-      }
-      /** @deprecated Use `url()` instead. */
-      async getUrl(key, options) {
-        return this.url(key, options);
-      }
-    };
-    BrokrEmailClient = class {
-      constructor(_token, _gatewayUrl) {
-        this._token = _token;
-        this._gatewayUrl = _gatewayUrl;
-      }
-      /**
-       * Send an email. The from address and API credentials are resolved server-side.
-       *
-       * @example
-       * ```typescript
-       * await brokr.email.send({
-       *   to: 'user@example.com',
-       *   subject: 'Welcome!',
-       *   html: '<h1>Welcome to the app</h1>',
-       * });
-       * ```
-       */
-      async send(params) {
-        assertToken(this._token, "email");
-        return gatewayFetch(
-          this._gatewayUrl,
-          this._token,
-          "/v1/email/send",
-          params,
-          "email"
-        );
-      }
-    };
-    BrokrRuntime = class {
-      constructor(options) {
-        this._token = options?.token ?? resolveToken();
-        this._gatewayUrl = options?.gatewayUrl ?? GATEWAY_URL;
-        this.ai = new BrokrAIClient(this._token, this._gatewayUrl);
-        this.storage = new BrokrStorageClient(this._token, this._gatewayUrl);
-        this.email = new BrokrEmailClient(this._token, this._gatewayUrl);
-      }
-      /** Auth client — lazily initialized to avoid pulling in auth deps when not needed. */
-      get auth() {
-        if (!this._auth) {
-          const { BrokrAuthClient: BrokrAuthClient2 } = (init_auth(), __toCommonJS(auth_exports));
-          this._auth = new BrokrAuthClient2(this._token, this._gatewayUrl);
-        }
-        return this._auth;
-      }
-    };
-  }
-});
 
-// index.ts
-init_runtime();
-init_auth();
+// src/ai/conversation-title.ts
+function titleCaseWord(word) {
+  if (!word) return word;
+  if (/[A-Z]{2,}/.test(word) || /\d/.test(word)) return word;
+  return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`;
+}
+function buildFallbackConversationTitle(message) {
+  const words = message.replace(/\s+/g, " ").trim().split(" ").filter(Boolean).slice(0, 5).map((word) => word.replace(/^[^\w]+|[^\w]+$/g, "")).filter(Boolean).map(titleCaseWord);
+  return words.length > 0 ? words.join(" ") : "New Chat";
+}
+function sanitizeConversationTitle(input, fallback = "New Chat") {
+  const cleaned = input.replace(/^['"`]+|['"`]+$/g, "").replace(/[.!?]+$/g, "").replace(/[:/\\]+/g, " ").replace(/\s+/g, " ").trim();
+  if (!cleaned) return fallback;
+  const words = cleaned.split(" ").filter(Boolean).slice(0, 5).map(titleCaseWord);
+  if (words.length === 0) return fallback;
+  const title = words.join(" ").slice(0, 80).trim();
+  return title || fallback;
+}
+async function generateConversationTitle(ai, firstUserMessage, options = {}) {
+  const fallback = sanitizeConversationTitle(
+    options.fallback ?? buildFallbackConversationTitle(firstUserMessage),
+    "New Chat"
+  );
+  const prompt = [
+    "Generate a short conversation title for an AI chat thread.",
+    "The title must describe the user intent from the first user message, not the assistant response.",
+    'Return JSON with one field: "title".',
+    "Rules:",
+    "- 2 to 5 words.",
+    "- Plain Title Case.",
+    "- Specific and concrete.",
+    "- No quotes, emojis, colons, slashes, or trailing punctuation.",
+    "- Do not use filler like New Chat, Help, Question, Support, General, or Conversation unless there is truly no better option.",
+    "- Preserve product names, framework names, and acronyms when they matter.",
+    "",
+    "First user message:",
+    firstUserMessage.trim()
+  ].join("\n");
+  try {
+    const result = await ai.structured({
+      prompt,
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          title: { type: "string" }
+        },
+        required: ["title"]
+      },
+      model: options.model,
+      temperature: 0.15
+    });
+    return sanitizeConversationTitle(result.title ?? "", fallback);
+  } catch {
+    return fallback;
+  }
+}
 
 // src/management.ts
-async function trpcRequest(config, procedure, input) {
-  const url = new URL(`${config.apiUrl}/api/trpc/${procedure}`);
+async function orpcRequest(config2, procedure, input) {
+  const path = procedure.replace(/^v1\./, "").replace(/\./g, "/");
+  const url = new URL(`${config2.apiUrl}/api/orpc/${path}`);
   const response = await fetch(url.toString(), {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      "Authorization": `Bearer ${config.accessToken}`,
-      ...config.headers
+      "Authorization": `Bearer ${config2.accessToken}`,
+      ...config2.headers
     },
-    body: JSON.stringify(input),
-    signal: config.timeout ? AbortSignal.timeout(config.timeout) : void 0
+    body: JSON.stringify({ json: input }),
+    signal: config2.timeout ? AbortSignal.timeout(config2.timeout) : void 0
   });
   if (!response.ok) {
     const error = await response.json().catch(() => ({ message: "Request failed" }));
-    throw new Error(error.message || `HTTP ${response.status}`);
+    throw new Error(error?.json?.message || error?.message || `HTTP ${response.status}`);
   }
-  const result = await response.json();
-  return result.data;
+  const envelope = await response.json();
+  return envelope.json;
 }
 var BrokrClient = class {
-  constructor(config) {
-    this.config = config;
+  constructor(config2) {
+    this.config = config2;
   }
   /** Create a new stack with default providers. */
   async create(input) {
-    return trpcRequest(this.config, "v1.stack.create", input);
+    return orpcRequest(this.config, "v1.stack.create", input);
   }
   /** List all stacks for the current user. */
   async listStacks() {
-    return trpcRequest(this.config, "v1.stack.list", {});
+    return orpcRequest(this.config, "v1.stack.list", {});
   }
   /** Get a specific stack by ID. */
   async getStack(id) {
-    return trpcRequest(this.config, "v1.stack.get", { id });
+    return orpcRequest(this.config, "v1.stack.get", { id });
   }
   /** Update a stack. */
   async updateStack(id, input) {
-    return trpcRequest(this.config, "v1.stack.update", { id, ...input });
+    return orpcRequest(this.config, "v1.stack.update", { id, ...input });
   }
   /** Delete a stack. */
   async deleteStack(id) {
-    return trpcRequest(this.config, "v1.stack.delete", { id });
+    return orpcRequest(this.config, "v1.stack.delete", { id });
   }
   /** Add a provider to a stack. */
   async add(provider, input) {
-    return trpcRequest(this.config, "v1.provider.add", { provider, ...input });
+    return orpcRequest(this.config, "v1.provider.add", { provider, ...input });
   }
   /** Refresh the access token. */
   async refreshToken(refreshToken) {
-    return trpcRequest(this.config, "v1.auth.refresh", { refreshToken });
+    return orpcRequest(this.config, "v1.auth.refresh", { refreshToken });
   }
   /** Update the access token. */
   setAccessToken(accessToken) {
     this.config.accessToken = accessToken;
   }
 };
-function createBrokrClient(config) {
-  return new BrokrClient(config);
+function createBrokrClient(config2) {
+  return new BrokrClient(config2);
 }
 var create = createBrokrClient;
+
+// src/next/notifications.ts
+var DEFAULT_TABLE = "brokr_notifications";
+async function getNeonSql() {
+  const url = process.env.DATABASE_URL;
+  if (!url) {
+    throw new Error(
+      "[brokr] DATABASE_URL is not set. Notification persistence requires a Postgres database.\nRun: brokr add database"
+    );
+  }
+  try {
+    const { neon } = await import("@neondatabase/serverless");
+    return neon(url);
+  } catch {
+    throw new Error(
+      "[brokr] @neondatabase/serverless is not installed.\nRun: npm install @neondatabase/serverless"
+    );
+  }
+}
+var _sql = null;
+var _ensuredTables = /* @__PURE__ */ new Set();
+async function getDb() {
+  if (!_sql) _sql = await getNeonSql();
+  return _sql;
+}
+function validateTableName(name) {
+  if (!/^[a-z_][a-z0-9_]{0,62}$/.test(name)) {
+    throw new Error(`[brokr] Invalid table name: "${name}". Use lowercase letters, digits, and underscores only.`);
+  }
+  return name;
+}
+async function ensureNotificationTable(tableName = DEFAULT_TABLE) {
+  const table = validateTableName(tableName);
+  if (_ensuredTables.has(table)) return;
+  const sql = await getDb();
+  await sql`
+    CREATE TABLE IF NOT EXISTS brokr_notifications (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      type TEXT NOT NULL DEFAULT 'default',
+      title TEXT NOT NULL,
+      message TEXT NOT NULL,
+      variant TEXT NOT NULL DEFAULT 'default',
+      href TEXT,
+      image_url TEXT,
+      image_alt TEXT,
+      read BOOLEAN NOT NULL DEFAULT false,
+      read_at TIMESTAMPTZ,
+      data JSONB,
+      expires_at TIMESTAMPTZ,
+      created_at TIMESTAMPTZ DEFAULT NOW()
+    )
+  `;
+  await sql`ALTER TABLE brokr_notifications ADD COLUMN IF NOT EXISTS type TEXT NOT NULL DEFAULT 'default'`.catch(() => {
+  });
+  await sql`ALTER TABLE brokr_notifications ADD COLUMN IF NOT EXISTS href TEXT`.catch(() => {
+  });
+  await sql`ALTER TABLE brokr_notifications ADD COLUMN IF NOT EXISTS image_url TEXT`.catch(() => {
+  });
+  await sql`ALTER TABLE brokr_notifications ADD COLUMN IF NOT EXISTS image_alt TEXT`.catch(() => {
+  });
+  await sql`ALTER TABLE brokr_notifications ADD COLUMN IF NOT EXISTS read_at TIMESTAMPTZ`.catch(() => {
+  });
+  await sql`ALTER TABLE brokr_notifications ADD COLUMN IF NOT EXISTS expires_at TIMESTAMPTZ`.catch(() => {
+  });
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_brokr_notifications_user
+      ON brokr_notifications(user_id, created_at DESC)
+  `;
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_brokr_notifications_type
+      ON brokr_notifications(user_id, type, created_at DESC)
+  `;
+  if (table !== DEFAULT_TABLE) {
+    const exists = await sql`
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = ${table}
+    `;
+    if (exists.length === 0) {
+      throw new Error(
+        `[brokr] Custom notification table "${table}" does not exist.
+Create it with the same schema as brokr_notifications, or remove the tableName config.`
+      );
+    }
+  }
+  _ensuredTables.add(table);
+}
+async function persistNotification(params, opts) {
+  await ensureNotificationTable(opts?.tableName);
+  const sql = await getDb();
+  await sql`
+    INSERT INTO brokr_notifications (id, user_id, type, title, message, variant, href, image_url, image_alt, data, expires_at, created_at)
+    VALUES (
+      ${params.id},
+      ${params.userId},
+      ${params.type ?? "default"},
+      ${params.title},
+      ${params.message},
+      ${params.variant},
+      ${params.href ?? null},
+      ${params.imageUrl ?? null},
+      ${params.imageAlt ?? null},
+      ${params.data ? JSON.stringify(params.data) : null}::jsonb,
+      ${params.expiresAt?.toISOString() ?? null},
+      NOW()
+    )
+    ON CONFLICT (id) DO NOTHING
+  `;
+}
+async function listPersistedNotifications(userId, params, opts) {
+  await ensureNotificationTable(opts?.tableName);
+  const sql = await getDb();
+  const limit = Math.min(params?.limit ?? 50, 100);
+  const typeFilter = params?.type ?? null;
+  const skipUnreadFilter = !(params?.unreadOnly ?? false);
+  const rows = await sql`
+    SELECT id, user_id, type, title, message, variant, href, image_url, image_alt, read, read_at, data, expires_at, created_at
+    FROM brokr_notifications
+    WHERE user_id = ${userId}
+      AND (expires_at IS NULL OR expires_at > NOW())
+      AND (${typeFilter}::text IS NULL OR type = ${typeFilter})
+      AND (${skipUnreadFilter}::boolean OR read = false)
+    ORDER BY created_at DESC
+    LIMIT ${limit}
+  `;
+  return rows.map((r) => ({
+    id: r.id,
+    userId: r.user_id,
+    type: r.type ?? "default",
+    title: r.title,
+    message: r.message,
+    variant: r.variant,
+    href: r.href ?? null,
+    imageUrl: r.image_url ?? null,
+    imageAlt: r.image_alt ?? null,
+    read: r.read,
+    readAt: r.read_at ? r.read_at.toISOString() : null,
+    data: r.data,
+    expiresAt: r.expires_at ? r.expires_at.toISOString() : null,
+    createdAt: r.created_at.toISOString()
+  }));
+}
+async function markNotificationRead(notificationId, userId, opts) {
+  await ensureNotificationTable(opts?.tableName);
+  const sql = await getDb();
+  await sql`
+    UPDATE brokr_notifications SET read = true, read_at = NOW()
+    WHERE id = ${notificationId} AND user_id = ${userId}
+  `;
+}
+
+// src/ai/types.ts
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+
+// src/next/chat.ts
+initCapture();
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_TOKEN_BUDGET = 2e4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function trimToTokenBudget(msgs, budget = DEFAULT_TOKEN_BUDGET) {
+  if (msgs.length === 0) return msgs;
+  const system = msgs.filter((m) => m.role === "system");
+  const rest = msgs.filter((m) => m.role !== "system");
+  if (rest.length === 0) return system;
+  const systemCost = system.reduce((s, m) => s + estimateTokens(contentToText(m.content)), 0);
+  const latest = rest[rest.length - 1];
+  const latestCost = estimateTokens(contentToText(latest.content));
+  const remaining = budget - systemCost - latestCost;
+  if (remaining <= 0) return [...system, latest];
+  const kept = [];
+  let used = 0;
+  for (let i = rest.length - 2; i >= 0; i--) {
+    const cost = estimateTokens(contentToText(rest[i].content));
+    if (used + cost > remaining) break;
+    used += cost;
+    kept.unshift(rest[i]);
+  }
+  return [...system, ...kept, latest];
+}
+async function getNeonSql2() {
+  const url = process.env.DATABASE_URL;
+  if (!url) {
+    throw new Error(
+      "[brokr] DATABASE_URL is not set. Thread persistence requires a Postgres database.\nSet DATABASE_URL in your environment variables."
+    );
+  }
+  try {
+    const { neon } = await import("@neondatabase/serverless");
+    return neon(url);
+  } catch {
+    throw new Error(
+      "[brokr] @neondatabase/serverless is not installed.\nRun: npm install @neondatabase/serverless"
+    );
+  }
+}
+var _sql2 = null;
+var _tablesEnsured = false;
+async function getDb2() {
+  if (!_sql2) _sql2 = await getNeonSql2();
+  return _sql2;
+}
+async function ensureTables(sql) {
+  if (_tablesEnsured) return;
+  await sql`CREATE SCHEMA IF NOT EXISTS brokr_ai`;
+  const oldTablesExist = await sql`
+    SELECT EXISTS (
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name = 'brokr_ai_threads'
+    ) AS exists
+  `;
+  if (oldTablesExist[0]?.exists) {
+    await sql`ALTER TABLE public.brokr_ai_threads SET SCHEMA brokr_ai`.catch(() => {
+    });
+    await sql`ALTER TABLE public.brokr_ai_messages SET SCHEMA brokr_ai`.catch(() => {
+    });
+    await sql`ALTER TABLE brokr_ai.brokr_ai_threads RENAME TO threads`.catch(() => {
+    });
+    await sql`ALTER TABLE brokr_ai.brokr_ai_messages RENAME TO messages`.catch(() => {
+    });
+  }
+  await sql`
+    CREATE TABLE IF NOT EXISTS brokr_ai.threads (
+      id TEXT PRIMARY KEY,
+      surface TEXT NOT NULL DEFAULT 'default',
+      subject TEXT,
+      title TEXT NOT NULL DEFAULT 'New chat',
+      created_at TIMESTAMPTZ DEFAULT NOW(),
+      updated_at TIMESTAMPTZ DEFAULT NOW()
+    )
+  `;
+  await sql`
+    CREATE TABLE IF NOT EXISTS brokr_ai.messages (
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL REFERENCES brokr_ai.threads(id) ON DELETE CASCADE,
+      role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+      content TEXT NOT NULL,
+      model TEXT,
+      created_at TIMESTAMPTZ DEFAULT NOW()
+    )
+  `;
+  await sql`
+    ALTER TABLE brokr_ai.messages ADD COLUMN IF NOT EXISTS model TEXT
+  `.catch(() => {
+  });
+  await sql`
+    ALTER TABLE brokr_ai.messages ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'complete'
+  `.catch(() => {
+  });
+  await sql`
+    ALTER TABLE brokr_ai.messages ADD COLUMN IF NOT EXISTS provider TEXT
+  `.catch(() => {
+  });
+  await sql`
+    CREATE INDEX IF NOT EXISTS brokr_ai_threads_surface_subject
+      ON brokr_ai.threads(surface, subject, updated_at DESC)
+  `;
+  await sql`
+    CREATE INDEX IF NOT EXISTS brokr_ai_messages_thread_id
+      ON brokr_ai.messages(thread_id, created_at ASC)
+  `;
+  _tablesEnsured = true;
+}
+function parsePath(url) {
+  const segments = new URL(url).pathname.split("/").filter(Boolean);
+  const last = segments[segments.length - 1];
+  const secondLast = segments[segments.length - 2];
+  if (last === "chat") return { action: "chat" };
+  if (last === "threads") return { action: "threads" };
+  if (last === "ws-token") return { action: "ws-token" };
+  if (last === "notifications") return { action: "notifications" };
+  if (last === "read" && secondLast === "notifications") return { action: "notifications-read" };
+  if (last === "messages" && secondLast) return { action: "messages", id: secondLast };
+  if (last === "rename" && secondLast) return { action: "rename", id: secondLast };
+  if (secondLast === "threads" && last) return { action: "thread", id: last };
+  return { action: "unknown" };
+}
+function makeThreadTitle(content) {
+  const cleaned = content.trim().replace(/\s+/g, " ");
+  return cleaned.length > 48 ? `${cleaned.slice(0, 48).trimEnd()}\u2026` : cleaned || "New chat";
+}
+async function handleListThreads(request, opts) {
+  if (!opts.persist) {
+    return Response.json({ threads: [] });
+  }
+  const url = new URL(request.url);
+  const surface = url.searchParams.get("surface") ?? "default";
+  const subject = url.searchParams.get("subject");
+  const sql = await getDb2();
+  await ensureTables(sql);
+  const rows = subject ? await sql`
+        SELECT t.id, t.surface, t.subject, t.title, t.created_at, t.updated_at,
+               (SELECT COUNT(*) FROM brokr_ai.messages WHERE thread_id = t.id) AS message_count
+        FROM brokr_ai.threads t
+        WHERE t.surface = ${surface} AND t.subject = ${subject}
+        ORDER BY t.updated_at DESC
+        LIMIT 50
+      ` : await sql`
+        SELECT t.id, t.surface, t.subject, t.title, t.created_at, t.updated_at,
+               (SELECT COUNT(*) FROM brokr_ai.messages WHERE thread_id = t.id) AS message_count
+        FROM brokr_ai.threads t
+        WHERE t.surface = ${surface}
+        ORDER BY t.updated_at DESC
+        LIMIT 50
+      `;
+  return Response.json({
+    threads: rows.map((r) => ({
+      id: r.id,
+      surface: r.surface,
+      subject: r.subject,
+      title: r.title,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at,
+      messageCount: Number(r.message_count)
+    }))
+  });
+}
+async function handleGetMessages(request, threadId, opts) {
+  if (!opts.persist) {
+    return Response.json({ messages: [], hasMore: false });
+  }
+  const url = new URL(request.url);
+  const limit = Math.min(Number(url.searchParams.get("limit")) || 30, 100);
+  const offset = Math.max(Number(url.searchParams.get("offset")) || 0, 0);
+  const sql = await getDb2();
+  const countResult = await sql`
+    SELECT COUNT(*) AS total FROM brokr_ai.messages WHERE thread_id = ${threadId}
+  `;
+  const total = Number(countResult[0]?.total ?? 0);
+  const rows = await sql`
+    SELECT id, role, content, model, status, provider FROM (
+      SELECT id, role, content, model, status, provider, created_at
+      FROM brokr_ai.messages
+      WHERE thread_id = ${threadId}
+      ORDER BY created_at DESC, id DESC
+      LIMIT ${limit} OFFSET ${offset}
+    ) sub ORDER BY created_at ASC, id ASC
+  `;
+  return Response.json({
+    messages: rows.map((r) => ({
+      id: r.id,
+      role: r.role,
+      content: r.content,
+      model: r.model ?? void 0,
+      status: r.status ?? "complete",
+      provider: r.provider ?? void 0
+    })),
+    hasMore: offset + limit < total
+  });
+}
+async function handleRenameThread(request, threadId, opts) {
+  if (!opts.persist) {
+    return Response.json({ success: false }, { status: 400 });
+  }
+  const body = await request.json();
+  const title = (body.title ?? "").trim();
+  if (!title) {
+    return Response.json({ error: "Title is required" }, { status: 400 });
+  }
+  const safeTitle = title.length > 100 ? `${title.slice(0, 100).trimEnd()}\u2026` : title;
+  const sql = await getDb2();
+  await ensureTables(sql);
+  await sql`UPDATE brokr_ai.threads SET title = ${safeTitle}, updated_at = NOW() WHERE id = ${threadId}`;
+  return Response.json({ success: true, title: safeTitle });
+}
+async function handleDeleteThread(_request, threadId, opts) {
+  if (!opts.persist) {
+    return Response.json({ success: true });
+  }
+  const sql = await getDb2();
+  await sql`DELETE FROM brokr_ai.threads WHERE id = ${threadId}`;
+  return Response.json({ success: true });
+}
+async function backgroundTask(promise) {
+  try {
+    const mod = await Promise.resolve().then(() => __toESM(require_functions()));
+    if (typeof mod.waitUntil === "function") {
+      mod.waitUntil(promise);
+      return;
+    }
+  } catch {
+  }
+  promise.catch((err) => console.error("[brokr] Background task failed:", err));
+}
+async function handleChat(request, opts) {
+  const body = await request.json();
+  const gatewayUrl = process.env.BROKR_GATEWAY_URL ?? GATEWAY_URL;
+  const token = process.env.BROKR_TOKEN;
+  if (!token) {
+    return Response.json(
+      { error: "BROKR_TOKEN is not configured. Run: brokr env pull --stack <name>" },
+      { status: 500 }
+    );
+  }
+  const ai = new BrokrAIClient(token, gatewayUrl);
+  const model = body.model;
+  const systemPrompt = opts.systemPrompt ?? body.systemPrompt;
+  const resolvedProvider = model ? resolveProviderByModel(model) : void 0;
+  let messages;
+  let threadId;
+  let isNewThread = false;
+  let userMsgId;
+  let assistantMsgId;
+  let threadTitle;
+  if (opts.persist && body.content !== void 0) {
+    threadId = body.thread_id ?? void 0;
+    const sql = await getDb2();
+    await ensureTables(sql);
+    let history = [];
+    if (threadId) {
+      const [historyRows, titleRows] = await Promise.all([
+        sql`
+          SELECT role, content FROM brokr_ai.messages
+          WHERE thread_id = ${threadId} AND status = 'complete'
+          ORDER BY created_at ASC
+        `,
+        sql`SELECT title FROM brokr_ai.threads WHERE id = ${threadId} LIMIT 1`
+      ]);
+      history = historyRows;
+      threadTitle = titleRows[0]?.title || void 0;
+    } else {
+      threadId = crypto.randomUUID();
+      isNewThread = true;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const assistantNow = new Date(Date.parse(now) + 1).toISOString();
+    if (!threadTitle) {
+      threadTitle = makeThreadTitle(body.content ?? "");
+    }
+    userMsgId = crypto.randomUUID();
+    assistantMsgId = crypto.randomUUID();
+    if (isNewThread) {
+      await sql`
+        INSERT INTO brokr_ai.threads (id, surface, subject, title, created_at, updated_at)
+        VALUES (
+          ${threadId},
+          ${body.surface ?? "default"},
+          ${body.subject ?? null},
+          ${threadTitle},
+          ${now},
+          ${now}
+        )
+      `;
+    } else {
+      await sql`
+        UPDATE brokr_ai.threads SET updated_at = ${now} WHERE id = ${threadId}
+      `;
+    }
+    await sql`
+      INSERT INTO brokr_ai.messages (id, thread_id, role, content, status, created_at)
+      VALUES (${userMsgId}, ${threadId}, 'user', ${body.content ?? ""}, 'complete', ${now})
+    `;
+    await sql`
+      INSERT INTO brokr_ai.messages (id, thread_id, role, content, model, provider, status, created_at)
+      VALUES (${assistantMsgId}, ${threadId}, 'assistant', '', ${model ?? null}, ${resolvedProvider?.id ?? null}, 'pending', ${assistantNow})
+    `;
+    messages = trimToTokenBudget([
+      ...systemPrompt ? [{ role: "system", content: systemPrompt }] : [],
+      ...history.map((h) => ({ role: h.role, content: h.content })),
+      { role: "user", content: body.content }
+    ]);
+  } else {
+    const clientMessages = body.messages ?? [];
+    messages = systemPrompt ? [{ role: "system", content: systemPrompt }, ...clientMessages] : clientMessages;
+  }
+  const chunks = [];
+  let chunkIndex = 0;
+  let generationDone = false;
+  let generationError = null;
+  let fullResponse = "";
+  let metadataSent = false;
+  let resolveChunk = null;
+  function notifyChunk() {
+    if (resolveChunk) {
+      const fn = resolveChunk;
+      resolveChunk = null;
+      fn();
+    }
+  }
+  function waitForChunk() {
+    if (generationDone || generationError || chunkIndex < chunks.length) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      resolveChunk = resolve;
+    });
+  }
+  const generationTask = (async () => {
+    try {
+      const aiStream = ai.stream(messages, { model });
+      for await (const delta of aiStream) {
+        fullResponse += delta;
+        chunks.push(delta);
+        notifyChunk();
+      }
+      if (opts.persist && threadId && assistantMsgId) {
+        const sql = await getDb2();
+        await sql`
+          UPDATE brokr_ai.messages
+          SET content = ${fullResponse}, status = 'complete'
+          WHERE id = ${assistantMsgId}
+        `;
+      }
+      if (opts.persist && body.userId && threadId && assistantMsgId) {
+        const notifId = crypto.randomUUID();
+        const preview = fullResponse.length > 120 ? `${fullResponse.slice(0, 120)}...` : fullResponse;
+        const notifData = {
+          type: "ai_response",
+          threadId,
+          assistantMessageId: assistantMsgId,
+          model: model ?? null,
+          provider: resolvedProvider?.id ?? null,
+          providerLogo: resolvedProvider?.logo ?? null,
+          surface: body.surface ?? "default",
+          href: `/chat?thread=${threadId}`
+        };
+        await Promise.allSettled([
+          persistNotification({
+            id: notifId,
+            userId: body.userId,
+            type: "ai_response",
+            title: threadTitle ?? "AI Response",
+            message: preview,
+            variant: "default",
+            href: `/chat?thread=${threadId}`,
+            imageUrl: resolvedProvider?.logo ?? void 0,
+            imageAlt: resolvedProvider?.label ?? void 0,
+            data: notifData
+          }, { tableName: opts.notifications?.tableName }).catch((err) => {
+            console.error("[brokr] Notification DB persist failed:", err);
+          }),
+          new BrokrNotificationsClient(token, gatewayUrl).send({
+            userId: body.userId,
+            title: threadTitle ?? "AI Response",
+            message: preview,
+            variant: "default",
+            data: notifData,
+            dedup: `ai_response:${assistantMsgId}`
+          }).catch((err) => {
+            console.error("[brokr] Notification push failed:", err);
+          })
+        ]);
+      }
+    } catch (err) {
+      console.error("[brokr] AI generation error:", err);
+      generationError = "Something went wrong generating a reply.";
+      if (opts.persist && threadId && assistantMsgId) {
+        try {
+          const sql = await getDb2();
+          await sql`
+            UPDATE brokr_ai.messages
+            SET status = 'error', content = ''
+            WHERE id = ${assistantMsgId}
+          `;
+        } catch (dbErr) {
+          console.error("[brokr] Failed to mark message as error:", dbErr);
+        }
+      }
+    } finally {
+      generationDone = true;
+      notifyChunk();
+    }
+  })();
+  void backgroundTask(generationTask);
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async pull(controller) {
+      const enqueue = (event) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}
+
+`));
+      };
+      await waitForChunk();
+      if (!metadataSent && opts.persist && threadId) {
+        metadataSent = true;
+        enqueue({
+          type: "conversation",
+          id: threadId,
+          assistantMessageId: assistantMsgId,
+          isNewThread
+        });
+      }
+      while (chunkIndex < chunks.length) {
+        enqueue({ type: "delta", delta: chunks[chunkIndex] });
+        chunkIndex++;
+      }
+      if (generationDone || generationError) {
+        if (generationError) {
+          enqueue({ type: "error", message: generationError });
+        } else {
+          enqueue({ type: "done" });
+        }
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function handleListNotifications(request, opts) {
+  const url = new URL(request.url);
+  const userId = url.searchParams.get("userId");
+  if (!userId) {
+    return Response.json({ error: "userId is required" }, { status: 400 });
+  }
+  const tableName = opts.notifications?.tableName;
+  try {
+    const notifications = await listPersistedNotifications(
+      userId,
+      {
+        limit: Math.min(Number(url.searchParams.get("limit")) || 50, 100),
+        unreadOnly: url.searchParams.get("unreadOnly") === "true",
+        type: url.searchParams.get("type") ?? void 0
+      },
+      { tableName }
+    );
+    return Response.json({ notifications });
+  } catch (err) {
+    console.error("[brokr] List notifications failed:", err);
+    return Response.json({ notifications: [] });
+  }
+}
+async function handleMarkNotificationRead(request, opts) {
+  const body = await request.json();
+  if (!body.notificationId || !body.userId) {
+    return Response.json({ error: "notificationId and userId are required" }, { status: 400 });
+  }
+  const tableName = opts.notifications?.tableName;
+  try {
+    await markNotificationRead(body.notificationId, body.userId, { tableName });
+    return Response.json({ success: true });
+  } catch (err) {
+    console.error("[brokr] Mark notification read failed:", err);
+    return Response.json({ error: "Failed to mark as read" }, { status: 500 });
+  }
+}
+function handleWsToken() {
+  const token = process.env.BROKR_TOKEN;
+  if (!token) {
+    return Response.json(
+      { error: "BROKR_TOKEN not configured" },
+      { status: 500 }
+    );
+  }
+  return Response.json({ token });
+}
+function createBrokrHandlers(options) {
+  const opts = { persist: false, ...options };
+  function withLogging(method, handler) {
+    return async (request) => {
+      const start = Date.now();
+      const urlPath = new URL(request.url).pathname;
+      try {
+        const response = await handler(request);
+        const dur = Date.now() - start;
+        captureRequest(method, urlPath, response.status, dur);
+        return response;
+      } catch (err) {
+        const dur = Date.now() - start;
+        capture("error", `${method} ${urlPath} FAILED ${dur}ms \u2014 ${err instanceof Error ? err.message : "unknown"}`, urlPath);
+        throw err;
+      }
+    };
+  }
+  return {
+    GET: withLogging("GET", async (request) => {
+      const path = parsePath(request.url);
+      if (path.action === "threads") return handleListThreads(request, opts);
+      if (path.action === "messages" && path.id) return handleGetMessages(request, path.id, opts);
+      if (path.action === "ws-token") return handleWsToken();
+      if (path.action === "notifications") return handleListNotifications(request, opts);
+      return new Response("Not found", { status: 404 });
+    }),
+    POST: withLogging("POST", async (request) => {
+      const path = parsePath(request.url);
+      if (path.action === "chat") return handleChat(request, opts);
+      if (path.action === "notifications-read") return handleMarkNotificationRead(request, opts);
+      return new Response("Not found", { status: 404 });
+    }),
+    PATCH: withLogging("PATCH", async (request) => {
+      const path = parsePath(request.url);
+      if (path.action === "rename" && path.id) return handleRenameThread(request, path.id, opts);
+      if (path.action === "thread" && path.id) return handleRenameThread(request, path.id, opts);
+      return new Response("Not found", { status: 404 });
+    }),
+    DELETE: withLogging("DELETE", async (request) => {
+      const path = parsePath(request.url);
+      if (path.action === "thread" && path.id) return handleDeleteThread(request, path.id, opts);
+      return new Response("Not found", { status: 404 });
+    })
+  };
+}
 export {
   BrokrAIClient,
+  BrokrAuthError,
   BrokrClient,
   BrokrEmailClient,
+  BrokrEntitlementsClient,
   BrokrError,
+  BrokrFilesClient,
+  BrokrNetworkError,
+  BrokrNotFoundError,
+  BrokrPaymentsClient,
+  BrokrRateLimitError,
   BrokrRuntime,
   BrokrStorageClient,
+  BrokrTimeoutError,
+  BrokrValidationError,
   authMiddleware,
+  buildFallbackConversationTitle,
   create,
   createBrokr,
-  createBrokrClient
+  createBrokrClient,
+  createBrokrHandlers,
+  generateConversationTitle,
+  models,
+  providers,
+  resolveProviderByModel,
+  sanitizeConversationTitle
 };