@xylex-group/athena 2.12.1 → 2.13.0

package/dist/next/server.d.cts

@@ -1,7 +1,83 @@
-import { an as AthenaAuthSessionResponse, bI as AthenaClientSessionLike, cA as AthenaSdkClientWithStorage, cz as AthenaSdkClientWithAuth } from '../client-CMtx5P4D.cjs';
-import { A as AthenaAdapterBaseOptions, b as AthenaServerRequestOptions, a as AthenaAdapterExperimentalOptions } from '../shared-DZSGAmXs.cjs';
-import '../types-BRUHGXo2.cjs';
-import '../types-Bez4HSbI.cjs';
+import { al as AthenaClientSessionLike, aX as AthenaSdkClientWithStorage, aW as AthenaSdkClientWithAuth } from '../client-BJjUwDSg.cjs';
+import { ae as AthenaAuthSessionResponse } from '../types-eAKAh71s.cjs';
+import { i as AthenaAuthSessionBridgeOptions, j as AthenaAuthSessionBridgePathOptions, A as AthenaAdapterBaseOptions, k as AthenaServerRequestOptions, a as AthenaAdapterExperimentalOptions } from '../payload-BzVbUgY_.cjs';
+export { b as ATHENA_AUTH_SESSION_BRIDGE_ROUTE, c as ATHENA_AUTH_SESSION_COOKIE_NAME, d as ATHENA_AUTH_SESSION_COOKIE_NAMES, e as AthenaAuthSessionBridgeClientOptions, f as AthenaAuthSessionBridgePayload, g as AthenaAuthSessionBridgeSource, h as clearAthenaAuthSessionOnAppHost, p as persistAthenaAuthSessionOnAppHost, r as resolveSessionBridgePayload } from '../payload-BzVbUgY_.cjs';
+export { S as SESSION_COOKIE_PATTERNS, h as hasAuthSessionCookie } from '../session-cookie-detection-BqOp9mO6.cjs';
+import '../types-CH78O90i.cjs';
+import '../types-BU8uJH_b.cjs';
+
+/**
+ * Handle bridge `POST` — set an httpOnly session cookie from JSON body.
+ *
+ * Expected body: `{ "token": string, "expiresAt"?: string }`.
+ *
+ * @param request - Incoming request (JSON body)
+ * @param options - Cookie / route configuration
+ * @returns `200` on success, `400` when token is missing
+ */
+declare function handleAthenaAuthSessionBridgePost(request: Request, options?: AthenaAuthSessionBridgeOptions): Promise<Response>;
+/**
+ * Handle bridge `DELETE` — clear bridged session cookie name variants.
+ *
+ * @param request - Incoming request (used for Secure detection)
+ * @param options - Cookie / route configuration
+ * @returns `200` with clear `Set-Cookie` headers
+ */
+declare function handleAthenaAuthSessionBridgeDelete(request: Request, options?: AthenaAuthSessionBridgeOptions): Response;
+/**
+ * Create dedicated App Router handlers for the session bridge.
+ *
+ * Drop into a route file with no additional wiring:
+ *
+ * @example
+ * ```ts
+ * // app/api/athena-auth/session/route.ts
+ * import { createAthenaAuthSessionBridgeHandlers } from '@xylex-group/athena/next/server'
+ *
+ * export const { POST, DELETE } = createAthenaAuthSessionBridgeHandlers()
+ * ```
+ *
+ * @param options - Optional cookie name, path, SameSite, Secure overrides
+ * @returns Object with `POST` and `DELETE` route handlers
+ */
+declare function createAthenaAuthSessionBridgeHandlers(options?: AthenaAuthSessionBridgeOptions): {
+    POST: (request: Request) => Promise<Response>;
+    DELETE: (request: Request) => Response;
+};
+/**
+ * Whether this request should be handled as a session bridge call.
+ *
+ * Returns true when:
+ * - the pathname equals the configured `route`, or
+ * - the final path segment is listed in `matchPaths` (default `session`)
+ *
+ * @param request - Incoming request
+ * @param options - Route + matchPaths configuration
+ */
+declare function isAthenaAuthSessionBridgePath(request: Request, options?: AthenaAuthSessionBridgePathOptions): boolean;
+/**
+ * Create catch-all / `[path]` handlers that only service session-bridge paths.
+ *
+ * Non-matching paths return `404` with `{ error: 'Not found' }` so you can
+ * mount under `/api/auth/[...path]` without implementing a full auth proxy.
+ *
+ * @example
+ * ```ts
+ * // app/api/auth/[...path]/route.ts
+ * import { createAthenaAuthSessionBridgePathHandlers } from '@xylex-group/athena/next/server'
+ *
+ * export const { POST, DELETE } = createAthenaAuthSessionBridgePathHandlers({
+ *   route: '/api/auth/session',
+ * })
+ * ```
+ *
+ * @param options - Bridge options plus `matchPaths`
+ * @returns Object with `POST` and `DELETE` route handlers
+ */
+declare function createAthenaAuthSessionBridgePathHandlers(options?: AthenaAuthSessionBridgePathOptions): {
+    POST: (request: Request) => Promise<Response>;
+    DELETE: (request: Request) => Response;
+};
 
 interface AthenaServerClientOptions extends AthenaAdapterBaseOptions, AthenaServerRequestOptions {
     session?: AthenaClientSessionLike | AthenaAuthSessionResponse | null;
@@ -50,4 +126,4 @@ declare function resolveAthenaServerContext(options: AthenaServerContextOptionsW
 declare function resolveAthenaServerContext(options: AthenaServerContextOptionsWithTypecheckedColumns): Promise<AthenaResolvedServerContext<AthenaSdkClientWithAuth<true>>>;
 declare function resolveAthenaServerContext(options?: AthenaServerContextOptions): Promise<AthenaResolvedServerContext<AthenaSdkClientWithAuth<false>>>;
 
-export { type AthenaResolvedServerContext, type AthenaServerClientOptions, type AthenaServerContextOptions, createAthenaServerClient, resolveAthenaServerContext };
+export { AthenaAuthSessionBridgeOptions, AthenaAuthSessionBridgePathOptions, type AthenaResolvedServerContext, type AthenaServerClientOptions, type AthenaServerContextOptions, createAthenaAuthSessionBridgeHandlers, createAthenaAuthSessionBridgePathHandlers, createAthenaServerClient, handleAthenaAuthSessionBridgeDelete, handleAthenaAuthSessionBridgePost, isAthenaAuthSessionBridgePath, resolveAthenaServerContext };

package/dist/next/server.d.ts

@@ -1,7 +1,83 @@
-import { an as AthenaAuthSessionResponse, bI as AthenaClientSessionLike, cA as AthenaSdkClientWithStorage, cz as AthenaSdkClientWithAuth } from '../client-Dre8H24u.js';
-import { A as AthenaAdapterBaseOptions, b as AthenaServerRequestOptions, a as AthenaAdapterExperimentalOptions } from '../shared-MMnVBBfy.js';
-import '../types-BRUHGXo2.js';
-import '../types-kPaHUqUa.js';
+import { al as AthenaClientSessionLike, aX as AthenaSdkClientWithStorage, aW as AthenaSdkClientWithAuth } from '../client-DVOKSYDI.js';
+import { ae as AthenaAuthSessionResponse } from '../types-eAKAh71s.js';
+import { i as AthenaAuthSessionBridgeOptions, j as AthenaAuthSessionBridgePathOptions, A as AthenaAdapterBaseOptions, k as AthenaServerRequestOptions, a as AthenaAdapterExperimentalOptions } from '../payload-DEOWN_oo.js';
+export { b as ATHENA_AUTH_SESSION_BRIDGE_ROUTE, c as ATHENA_AUTH_SESSION_COOKIE_NAME, d as ATHENA_AUTH_SESSION_COOKIE_NAMES, e as AthenaAuthSessionBridgeClientOptions, f as AthenaAuthSessionBridgePayload, g as AthenaAuthSessionBridgeSource, h as clearAthenaAuthSessionOnAppHost, p as persistAthenaAuthSessionOnAppHost, r as resolveSessionBridgePayload } from '../payload-DEOWN_oo.js';
+export { S as SESSION_COOKIE_PATTERNS, h as hasAuthSessionCookie } from '../session-cookie-detection-BqOp9mO6.js';
+import '../types-CH78O90i.js';
+import '../types-BRP7sfSF.js';
+
+/**
+ * Handle bridge `POST` — set an httpOnly session cookie from JSON body.
+ *
+ * Expected body: `{ "token": string, "expiresAt"?: string }`.
+ *
+ * @param request - Incoming request (JSON body)
+ * @param options - Cookie / route configuration
+ * @returns `200` on success, `400` when token is missing
+ */
+declare function handleAthenaAuthSessionBridgePost(request: Request, options?: AthenaAuthSessionBridgeOptions): Promise<Response>;
+/**
+ * Handle bridge `DELETE` — clear bridged session cookie name variants.
+ *
+ * @param request - Incoming request (used for Secure detection)
+ * @param options - Cookie / route configuration
+ * @returns `200` with clear `Set-Cookie` headers
+ */
+declare function handleAthenaAuthSessionBridgeDelete(request: Request, options?: AthenaAuthSessionBridgeOptions): Response;
+/**
+ * Create dedicated App Router handlers for the session bridge.
+ *
+ * Drop into a route file with no additional wiring:
+ *
+ * @example
+ * ```ts
+ * // app/api/athena-auth/session/route.ts
+ * import { createAthenaAuthSessionBridgeHandlers } from '@xylex-group/athena/next/server'
+ *
+ * export const { POST, DELETE } = createAthenaAuthSessionBridgeHandlers()
+ * ```
+ *
+ * @param options - Optional cookie name, path, SameSite, Secure overrides
+ * @returns Object with `POST` and `DELETE` route handlers
+ */
+declare function createAthenaAuthSessionBridgeHandlers(options?: AthenaAuthSessionBridgeOptions): {
+    POST: (request: Request) => Promise<Response>;
+    DELETE: (request: Request) => Response;
+};
+/**
+ * Whether this request should be handled as a session bridge call.
+ *
+ * Returns true when:
+ * - the pathname equals the configured `route`, or
+ * - the final path segment is listed in `matchPaths` (default `session`)
+ *
+ * @param request - Incoming request
+ * @param options - Route + matchPaths configuration
+ */
+declare function isAthenaAuthSessionBridgePath(request: Request, options?: AthenaAuthSessionBridgePathOptions): boolean;
+/**
+ * Create catch-all / `[path]` handlers that only service session-bridge paths.
+ *
+ * Non-matching paths return `404` with `{ error: 'Not found' }` so you can
+ * mount under `/api/auth/[...path]` without implementing a full auth proxy.
+ *
+ * @example
+ * ```ts
+ * // app/api/auth/[...path]/route.ts
+ * import { createAthenaAuthSessionBridgePathHandlers } from '@xylex-group/athena/next/server'
+ *
+ * export const { POST, DELETE } = createAthenaAuthSessionBridgePathHandlers({
+ *   route: '/api/auth/session',
+ * })
+ * ```
+ *
+ * @param options - Bridge options plus `matchPaths`
+ * @returns Object with `POST` and `DELETE` route handlers
+ */
+declare function createAthenaAuthSessionBridgePathHandlers(options?: AthenaAuthSessionBridgePathOptions): {
+    POST: (request: Request) => Promise<Response>;
+    DELETE: (request: Request) => Response;
+};
 
 interface AthenaServerClientOptions extends AthenaAdapterBaseOptions, AthenaServerRequestOptions {
     session?: AthenaClientSessionLike | AthenaAuthSessionResponse | null;
@@ -50,4 +126,4 @@ declare function resolveAthenaServerContext(options: AthenaServerContextOptionsW
 declare function resolveAthenaServerContext(options: AthenaServerContextOptionsWithTypecheckedColumns): Promise<AthenaResolvedServerContext<AthenaSdkClientWithAuth<true>>>;
 declare function resolveAthenaServerContext(options?: AthenaServerContextOptions): Promise<AthenaResolvedServerContext<AthenaSdkClientWithAuth<false>>>;
 
-export { type AthenaResolvedServerContext, type AthenaServerClientOptions, type AthenaServerContextOptions, createAthenaServerClient, resolveAthenaServerContext };
+export { AthenaAuthSessionBridgeOptions, AthenaAuthSessionBridgePathOptions, type AthenaResolvedServerContext, type AthenaServerClientOptions, type AthenaServerContextOptions, createAthenaAuthSessionBridgeHandlers, createAthenaAuthSessionBridgePathHandlers, createAthenaServerClient, handleAthenaAuthSessionBridgeDelete, handleAthenaAuthSessionBridgePost, isAthenaAuthSessionBridgePath, resolveAthenaServerContext };

package/dist/next/server.js

@@ -136,6 +136,22 @@ function parseCookies(cookieHeader) {
   });
   return cookieMap;
 }
+
+// src/cookies/session-cookie-detection.ts
+var SESSION_COOKIE_PATTERNS = [
+  /(?:^|;\s*)(?:__Secure-)?better-auth\.session_token=/,
+  /(?:^|;\s*)(?:__Secure-)?better-auth-session_token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth\.session-token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth-session-token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth\.session_token=/,
+  /(?:^|;\s*)(?:__Secure-)?athena-auth-session_token=/
+];
+function hasAuthSessionCookie(cookieHeader) {
+  if (!cookieHeader) {
+    return false;
+  }
+  return SESSION_COOKIE_PATTERNS.some((pattern) => pattern.test(cookieHeader));
+}
 var getSessionCookie = (request2, config) => {
   const cookies = (request2 instanceof Headers || !("headers" in request2) ? request2 : request2.headers).get("cookie");
   if (!cookies) {
@@ -160,7 +176,7 @@ var getSessionCookie = (request2, config) => {
 
 // src/utils/athena-request-headers.ts
 var NO_CACHE_HEADER_VALUE = "no-cache";
-var API_KEY_HEADER_CANDIDATES = ["X-Api-Key", "x-api-key", "apikey"];
+var API_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key", "X-Api-Key", "x-api-key", "apikey"];
 var ATHENA_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key"];
 var SESSION_TOKEN_HEADER_CANDIDATES = ["X-Athena-Auth-Session-Token"];
 var BEARER_MIRROR_HEADER_CANDIDATES = ["X-Athena-Auth-Bearer-Token"];
@@ -262,17 +278,6 @@ function buildServiceRequestHeaders(profile, sdkHeaderValue, config, options, ex
   });
 }
 function applyAthenaApiKeyHeaders(headers, apiKey, athenaKey) {
-  if (apiKey) {
-    if (!hasHeaderIgnoreCase(headers, "apikey")) {
-      headers.apikey = apiKey;
-    }
-    if (!Object.hasOwn(headers, "x-api-key")) {
-      headers["x-api-key"] = apiKey;
-    }
-    if (!Object.hasOwn(headers, "X-Api-Key")) {
-      headers["X-Api-Key"] = apiKey;
-    }
-  }
   const resolvedAthenaKey = normalizeHeaderValue(athenaKey) ?? normalizeHeaderValue(apiKey);
   if (resolvedAthenaKey && !hasHeaderIgnoreCase(headers, "X-Athena-Key")) {
     headers["X-Athena-Key"] = resolvedAthenaKey;
@@ -398,7 +403,7 @@ function buildAthenaRequestHeaders(input) {
 
 // package.json
 var package_default = {
-  version: "2.12.1"
+  version: "2.13.0"
 };
 
 // src/sdk-version.ts
@@ -2827,38 +2832,6 @@ async function withRetry(config, fn) {
   throw new Error("withRetry reached an unexpected state");
 }
 
-// src/db/module.ts
-function createDbModule(input) {
-  const db = {
-    from: input.from,
-    select(table, first, second) {
-      if (first && typeof first === "object" && !Array.isArray(first)) {
-        return input.from(table).select(void 0, first);
-      }
-      return input.from(table).select(first, second);
-    },
-    insert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).insert(values, options) : input.from(table).insert(values, options);
-    },
-    upsert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).upsert(values, options) : input.from(table).upsert(values, options);
-    },
-    update(table, values, options) {
-      return input.from(table).update(values, options);
-    },
-    delete(table, options) {
-      return input.from(table).delete(options);
-    },
-    rpc(fn, args, options) {
-      return input.rpc(fn, args, options);
-    },
-    query(query, options) {
-      return input.query(query, options);
-    }
-  };
-  return db;
-}
-
 // src/storage/file.ts
 function createStorageFileModule(base, config = {}) {
   const upload = async (input, options) => {
@@ -8437,7 +8410,30 @@ function createClientFromConfig(config, sourceConfig) {
     config.experimental,
     queryTracer
   );
-  const db = createDbModule({ from, rpc, query });
+  const untypedDbFrom = from;
+  const db = {
+    from,
+    select(table, first, second) {
+      if (first && typeof first === "object" && !Array.isArray(first)) {
+        return untypedDbFrom(table).select(void 0, first);
+      }
+      return untypedDbFrom(table).select(first, second);
+    },
+    insert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).insert(values, options) : untypedDbFrom(table).insert(values, options);
+    },
+    upsert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).upsert(values, options) : untypedDbFrom(table).upsert(values, options);
+    },
+    update(table, values, options) {
+      return untypedDbFrom(table).update(values, options);
+    },
+    delete(table, options) {
+      return untypedDbFrom(table).delete(options);
+    },
+    rpc,
+    query
+  };
   const chat = createChatModule({
     baseUrl: config.chatUrl,
     apiKey: config.apiKey,
@@ -8588,7 +8584,9 @@ function createClientFromConfig(config, sourceConfig) {
 var AthenaClient = class {
   /** Create a fluent builder for a strongly-typed Athena SDK client. */
   static builder() {
-    return createAthenaClientBuilder((config) => createClientFromInput(config));
+    return createAthenaClientBuilder(
+      (config) => createClientFromInput(config)
+    );
   }
   static fromEnvironment(options = {}) {
     const env = options.env ?? process.env;
@@ -8619,11 +8617,12 @@ var AthenaClient = class {
     });
   }
 };
-function createClient(configOrUrl, apiKey, options) {
+function createClient(...args) {
+  const [configOrUrl, apiKey, options] = args;
   if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
     return createClientFromInput({
       url: configOrUrl,
-      key: "",
+      key: apiKey ?? "",
       ...options
     });
   }
@@ -8759,6 +8758,237 @@ function buildSessionClientOptions(context, options) {
   };
 }
 
+// src/next/session-bridge/constants.ts
+var ATHENA_AUTH_SESSION_BRIDGE_ROUTE = "/api/athena-auth/session";
+var ATHENA_AUTH_SESSION_COOKIE_NAME = "athena-auth.session-token";
+var ATHENA_AUTH_SESSION_COOKIE_NAMES = [
+  ATHENA_AUTH_SESSION_COOKIE_NAME,
+  "athena-auth.session_token"
+];
+
+// src/next/session-bridge/client.ts
+var JSON_CONTENT_TYPE = "application/json";
+function isBrowserRuntime() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+async function persistAthenaAuthSessionOnAppHost(payload, options) {
+  if (!(payload && isBrowserRuntime())) {
+    return;
+  }
+  const route = options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+  const fetchImpl = options?.fetch ?? fetch;
+  const response = await fetchImpl(route, {
+    body: JSON.stringify(payload),
+    credentials: "same-origin",
+    headers: {
+      "Content-Type": JSON_CONTENT_TYPE
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to persist the Athena Auth session on the app host");
+  }
+}
+async function clearAthenaAuthSessionOnAppHost(options) {
+  if (!isBrowserRuntime()) {
+    return;
+  }
+  const route = options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+  const fetchImpl = options?.fetch ?? fetch;
+  const response = await fetchImpl(route, {
+    credentials: "same-origin",
+    method: "DELETE"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to clear the Athena Auth session on the app host");
+  }
+}
+
+// src/next/session-bridge/payload.ts
+function resolveSessionBridgePayload(payload) {
+  const token = payload?.session?.token ?? payload?.token;
+  if (typeof token !== "string") {
+    return null;
+  }
+  const normalizedToken = token.trim();
+  if (!normalizedToken) {
+    return null;
+  }
+  return {
+    token: normalizedToken,
+    expiresAt: typeof payload?.session?.expiresAt === "string" ? payload.session.expiresAt : void 0
+  };
+}
+
+// src/next/session-bridge/cookie.ts
+var EXPIRED_AT = /* @__PURE__ */ new Date(0);
+function resolveRequestIsSecure(request2) {
+  const forwardedProto = request2.headers.get("x-forwarded-proto")?.trim();
+  if (forwardedProto) {
+    const first = forwardedProto.split(",")[0]?.trim().toLowerCase();
+    if (first === "https") return true;
+    if (first === "http") return false;
+  }
+  return new URL(request2.url).protocol === "https:";
+}
+function resolveSessionCookieExpiresAt(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const expiresAt = new Date(value);
+  return Number.isNaN(expiresAt.getTime()) ? void 0 : expiresAt;
+}
+function serializeCookie(name, value, options) {
+  const parts = [
+    `${encodeURIComponent(name)}=${encodeURIComponent(value)}`,
+    `Path=${options.path}`,
+    "HttpOnly",
+    `SameSite=${options.sameSite === "none" ? "None" : options.sameSite === "strict" ? "Strict" : "Lax"}`
+  ];
+  if (options.secure) {
+    parts.push("Secure");
+  }
+  if (options.expires) {
+    parts.push(`Expires=${options.expires.toUTCString()}`);
+  }
+  return parts.join("; ");
+}
+function resolveBridgeCookieConfig(options) {
+  return {
+    cookieName: options?.cookieName ?? ATHENA_AUTH_SESSION_COOKIE_NAME,
+    cookieNames: options?.cookieNames ?? ATHENA_AUTH_SESSION_COOKIE_NAMES,
+    cookiePath: options?.cookiePath ?? "/",
+    sameSite: options?.sameSite ?? "lax"
+  };
+}
+function appendSessionCookie(headers, request2, token, expiresAt, options) {
+  const config = resolveBridgeCookieConfig(options);
+  const secure = options?.secure ?? resolveRequestIsSecure(request2);
+  headers.append(
+    "set-cookie",
+    serializeCookie(config.cookieName, token, {
+      path: config.cookiePath,
+      sameSite: config.sameSite,
+      secure,
+      expires: expiresAt
+    })
+  );
+}
+function appendClearSessionCookies(headers, request2, options) {
+  const config = resolveBridgeCookieConfig(options);
+  const secure = options?.secure ?? resolveRequestIsSecure(request2);
+  const names = /* @__PURE__ */ new Set([config.cookieName, ...config.cookieNames]);
+  for (const name of names) {
+    headers.append(
+      "set-cookie",
+      serializeCookie(name, "", {
+        path: config.cookiePath,
+        sameSite: config.sameSite,
+        secure,
+        expires: EXPIRED_AT
+      })
+    );
+  }
+}
+
+// src/next/session-bridge/handlers.ts
+function json(body, init) {
+  const headers = init?.headers ?? new Headers();
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(body), {
+    status: init?.status ?? 200,
+    headers
+  });
+}
+function resolveRoute(options) {
+  return options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+}
+async function handleAthenaAuthSessionBridgePost(request2, options) {
+  const payload = await request2.json().catch(() => null);
+  const token = typeof payload?.token === "string" ? payload.token.trim() : "";
+  if (!token) {
+    return json(
+      {
+        error: "Missing Athena Auth session token"
+      },
+      { status: 400 }
+    );
+  }
+  const headers = new Headers();
+  appendSessionCookie(
+    headers,
+    request2,
+    token,
+    resolveSessionCookieExpiresAt(payload?.expiresAt),
+    options
+  );
+  return json(
+    {
+      ok: true,
+      route: resolveRoute(options)
+    },
+    { headers }
+  );
+}
+function handleAthenaAuthSessionBridgeDelete(request2, options) {
+  const headers = new Headers();
+  appendClearSessionCookies(headers, request2, options);
+  return json(
+    {
+      ok: true,
+      route: resolveRoute(options)
+    },
+    { headers }
+  );
+}
+function createAthenaAuthSessionBridgeHandlers(options) {
+  return {
+    POST: (request2) => handleAthenaAuthSessionBridgePost(request2, options),
+    DELETE: (request2) => handleAthenaAuthSessionBridgeDelete(request2, options)
+  };
+}
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+  return pathname || "/";
+}
+function isAthenaAuthSessionBridgePath(request2, options) {
+  const pathname = normalizePathname(new URL(request2.url).pathname);
+  const route = normalizePathname(resolveRoute(options));
+  if (pathname === route) {
+    return true;
+  }
+  const matchPaths = options?.matchPaths ?? ["session"];
+  const segments = pathname.split("/").filter(Boolean);
+  const tail = segments[segments.length - 1];
+  return typeof tail === "string" && matchPaths.includes(tail);
+}
+function createAthenaAuthSessionBridgePathHandlers(options) {
+  const notFound = () => json(
+    {
+      error: "Not found"
+    },
+    { status: 404 }
+  );
+  return {
+    POST: async (request2) => {
+      if (!isAthenaAuthSessionBridgePath(request2, options)) {
+        return notFound();
+      }
+      return handleAthenaAuthSessionBridgePost(request2, options);
+    },
+    DELETE: (request2) => {
+      if (!isAthenaAuthSessionBridgePath(request2, options)) {
+        return notFound();
+      }
+      return handleAthenaAuthSessionBridgeDelete(request2, options);
+    }
+  };
+}
+
 // src/next/server.ts
 function resolveUserId(session) {
   return session?.user?.id ?? null;
@@ -8797,6 +9027,6 @@ async function resolveAthenaServerContext(options) {
   };
 }
 
-export { createAthenaServerClient, resolveAthenaServerContext };
+export { ATHENA_AUTH_SESSION_BRIDGE_ROUTE, ATHENA_AUTH_SESSION_COOKIE_NAME, ATHENA_AUTH_SESSION_COOKIE_NAMES, SESSION_COOKIE_PATTERNS, clearAthenaAuthSessionOnAppHost, createAthenaAuthSessionBridgeHandlers, createAthenaAuthSessionBridgePathHandlers, createAthenaServerClient, handleAthenaAuthSessionBridgeDelete, handleAthenaAuthSessionBridgePost, hasAuthSessionCookie, isAthenaAuthSessionBridgePath, persistAthenaAuthSessionOnAppHost, resolveAthenaServerContext, resolveSessionBridgePayload };
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map