@brokr/sdk 1.0.0 → 2.0.0

package/dist/next.mjs

@@ -0,0 +1,2710 @@
+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]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 cache2;
+        if ((0, import_get_context.getContext)().cache) {
+          cache2 = (0, import_get_context.getContext)().cache;
+        } else {
+          cache2 = getCacheImplementation(
+            process.env.SUSPENSE_CACHE_DEBUG === "true"
+          );
+        }
+        return cache2;
+      };
+      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/next/auth.ts
+import { cache } from "react";
+
+// 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";
+  }
+};
+
+// src/next/auth.ts
+function resolveAppUrl() {
+  const localUrl = process.env.BETTER_AUTH_URL ?? process.env.NEXTAUTH_URL ?? process.env.NEXT_PUBLIC_APP_URL ?? (process.env.NODE_ENV !== "production" ? "http://localhost:3000" : void 0);
+  const url = localUrl ?? process.env.APP_URL ?? process.env.BROKR_AUTH_URL;
+  if (url) return url;
+  const vercelUrl = process.env.VERCEL_URL;
+  if (vercelUrl) return `https://${vercelUrl}`;
+  if (process.env.NODE_ENV === "production") {
+    throw new BrokrError(
+      "[brokr] Cannot resolve auth URL in production. Set BETTER_AUTH_URL or APP_URL in your environment.",
+      "AUTH_NOT_CONFIGURED",
+      "auth"
+    );
+  }
+  return "http://localhost:3000";
+}
+var getSessionFromCookies = cache(async function getSessionFromCookiesCached() {
+  const { cookies } = await import("next/headers");
+  const cookieStore = await cookies();
+  const cookieHeader = cookieStore.getAll().map((c) => `${c.name}=${c.value}`).join("; ");
+  if (!cookieHeader) return null;
+  const appUrl = resolveAppUrl();
+  const res = await fetch(`${appUrl}/api/auth/get-session`, {
+    method: "GET",
+    headers: { cookie: cookieHeader },
+    cache: "no-store"
+    // Don't cache across different users
+  });
+  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,
+      image: data.user.image ?? null,
+      emailVerified: data.user.emailVerified ? /* @__PURE__ */ new Date() : null
+    },
+    sessionId: data.session.id,
+    expiresAt: new Date(data.session.expiresAt)
+  };
+});
+async function protectApi() {
+  const session = await getSessionFromCookies();
+  if (!session) {
+    throw new BrokrError("[brokr] Authentication required.", "UNAUTHORIZED", "auth");
+  }
+  return session.user;
+}
+async function protectPage(redirectTo = "/sign-in") {
+  const session = await getSessionFromCookies();
+  if (!session) {
+    const { redirect } = await import("next/navigation");
+    redirect(redirectTo);
+    throw new Error("unreachable");
+  }
+  return session.user;
+}
+function withUser(fn) {
+  return async (request) => {
+    const user = await protectApi();
+    return fn(request, user);
+  };
+}
+
+// src/gateway.ts
+var GATEWAY_URL = "https://api.brokr.sh";
+var FETCH_TIMEOUT_MS = 3e4;
+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/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/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;
+    }
+  }
+};
+
+// src/models.ts
+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));
+}
+
+// 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 {
+  createBrokrHandlers,
+  ensureNotificationTable,
+  listPersistedNotifications,
+  markNotificationRead,
+  persistNotification,
+  protectApi,
+  protectPage,
+  withUser
+};