@xylex-group/athena 2.8.2 → 2.10.0

package/dist/index.cjs

@@ -666,8 +666,8 @@ function deleteSessionCookie(ctx, skipDontRememberMe) {
     expireCookie(ctx, ctx.context.authCookies.dontRememberToken);
   }
 }
-var getSessionCookie = (request, config) => {
-  const cookies = (request instanceof Headers || !("headers" in request) ? request : request.headers).get("cookie");
+var getSessionCookie = (request2, config) => {
+  const cookies = (request2 instanceof Headers || !("headers" in request2) ? request2 : request2.headers).get("cookie");
   if (!cookies) {
     return null;
   }
@@ -687,8 +687,8 @@ var getSessionCookie = (request, config) => {
   }
   return null;
 };
-var getCookieCache = async (request, config) => {
-  const headers = request instanceof Headers || !("headers" in request) ? request : request.headers;
+var getCookieCache = async (request2, config) => {
+  const headers = request2 instanceof Headers || !("headers" in request2) ? request2 : request2.headers;
   const cookieHeader = headers.get("cookie");
   if (!cookieHeader) {
     return null;
@@ -806,7 +806,7 @@ var getCookieCache = async (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.8.2"
+  version: "2.10.0"
 };
 
 // src/sdk-version.ts
@@ -819,6 +819,7 @@ function buildSdkHeaderValue(sdkName) {
 var DEFAULT_CLIENT = "railway_direct";
 var SDK_NAME = "xylex-group/athena";
 var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+var NO_CACHE_HEADER_VALUE = "no-cache";
 function parseResponseBody(rawText, contentType) {
   if (!rawText) {
     return { parsed: null, parseFailed: false };
@@ -837,6 +838,9 @@ function parseResponseBody(rawText, contentType) {
 function normalizeHeaderValue(value) {
   return value ? value : void 0;
 }
+function isCacheControlHeaderName(name) {
+  return name.toLowerCase() === "cache-control";
+}
 function resolveHeaderValue(headers, candidates) {
   for (const candidate of candidates) {
     const direct = normalizeHeaderValue(headers[candidate]);
@@ -995,6 +999,7 @@ function buildRpcGetEndpoint(payload) {
 }
 function buildHeaders(config, options) {
   const mergedStripNulls = options?.stripNulls ?? true;
+  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
   const extraHeaders = {
     ...config.headers ?? {},
     ...options?.headers ?? {}
@@ -1048,11 +1053,15 @@ function buildHeaders(config, options) {
   const athenaClientKeys = ["x-athena-client", "X-Athena-Client"];
   Object.entries(extraHeaders).forEach(([key, value]) => {
     if (athenaClientKeys.includes(key)) return;
+    if (forceNoCache && isCacheControlHeaderName(key)) return;
     const normalized = normalizeHeaderValue(value);
     if (normalized) {
       headers[key] = normalized;
     }
   });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
+  }
   return headers;
 }
 function toInvalidUrlResponse(error, endpoint, method) {
@@ -1513,6 +1522,45 @@ function identifier(...segments) {
   return new SqlIdentifierPath(expandedSegments);
 }
 
+// src/auth/limits.ts
+var ATHENA_AUTH_MAX_ADMIN_JSON_BYTES = 32 * 1024;
+var ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH = 8;
+var ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = 64;
+var ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = 128;
+var ATHENA_AUTH_ADMIN_LIMITS = {
+  maxAdminJsonBytes: ATHENA_AUTH_MAX_ADMIN_JSON_BYTES,
+  maxAdminJsonDepth: ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH,
+  maxTemplateVariables: ATHENA_AUTH_MAX_TEMPLATE_VARIABLES,
+  maxTemplateVariableLength: ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH
+};
+function describeTemplateVariableTarget(target) {
+  const normalized = target?.trim();
+  return normalized && normalized.length > 0 ? normalized : "Athena auth admin email template variables";
+}
+function assertAthenaAuthTemplateVariables(variables, target) {
+  const label = describeTemplateVariableTarget(target);
+  if (!Array.isArray(variables)) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  if (variables.length > ATHENA_AUTH_MAX_TEMPLATE_VARIABLES) {
+    throw new Error(
+      `${label} cannot contain more than ${ATHENA_AUTH_MAX_TEMPLATE_VARIABLES} entries.`
+    );
+  }
+  variables.forEach((variable, index) => {
+    if (typeof variable !== "string") {
+      throw new Error(
+        `${label} must contain only strings. Received ${typeof variable} at index ${index}.`
+      );
+    }
+    if (variable.length > ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH) {
+      throw new Error(
+        `${label} cannot contain entries longer than ${ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH} characters. Received ${variable.length} characters at index ${index}.`
+      );
+    }
+  });
+}
+
 // src/auth/react-email.ts
 var reactEmailRenderModulePromise;
 function isRecord2(value) {
@@ -1742,6 +1790,7 @@ async function resolveReactEmailPayloadFields(input, fields, options) {
 var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
 var SDK_NAME2 = "xylex-group/athena-auth";
 var SDK_HEADER_VALUE2 = buildSdkHeaderValue(SDK_NAME2);
+var NO_CACHE_HEADER_VALUE2 = "no-cache";
 function normalizeBaseUrl(baseUrl) {
   return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
 }
@@ -1751,6 +1800,9 @@ function isRecord3(value) {
 function normalizeHeaderValue2(value) {
   return value ? value : void 0;
 }
+function isCacheControlHeaderName2(name) {
+  return name.toLowerCase() === "cache-control";
+}
 function parseResponseBody2(rawText, contentType) {
   if (!rawText) {
     return { parsed: null, parseFailed: false };
@@ -1806,6 +1858,98 @@ function mergeCallOptions(base, override) {
     }
   };
 }
+function copyDefinedField(target, source, targetKey, sourceKey) {
+  if (!(sourceKey in source)) {
+    return;
+  }
+  const value = source[sourceKey];
+  if (value !== void 0) {
+    target[targetKey] = value;
+  }
+}
+function normalizeAdminEmailTemplatePayload(payload) {
+  const normalized = { ...payload };
+  copyDefinedField(normalized, payload, "template_key", "templateKey");
+  copyDefinedField(normalized, payload, "event_type", "eventType");
+  copyDefinedField(normalized, payload, "subject_template", "subjectTemplate");
+  copyDefinedField(normalized, payload, "text_template", "textTemplate");
+  copyDefinedField(normalized, payload, "html_template", "htmlTemplate");
+  copyDefinedField(normalized, payload, "variable_bindings", "variableBindings");
+  copyDefinedField(normalized, payload, "attachment_failure_mode", "attachmentFailureMode");
+  copyDefinedField(normalized, payload, "is_active", "isActive");
+  return normalized;
+}
+function toReactEmailTemplateCompatibilityInput(input) {
+  const payload = input;
+  const compatibility = { ...payload };
+  copyDefinedField(compatibility, payload, "templateKey", "template_key");
+  copyDefinedField(compatibility, payload, "eventType", "event_type");
+  copyDefinedField(compatibility, payload, "subjectTemplate", "subject_template");
+  copyDefinedField(compatibility, payload, "textTemplate", "text_template");
+  copyDefinedField(compatibility, payload, "htmlTemplate", "html_template");
+  copyDefinedField(compatibility, payload, "variableBindings", "variable_bindings");
+  copyDefinedField(compatibility, payload, "attachmentFailureMode", "attachment_failure_mode");
+  copyDefinedField(compatibility, payload, "isActive", "is_active");
+  return compatibility;
+}
+function normalizeAdminEmailTemplateSendPayload(payload) {
+  const normalized = { ...payload };
+  copyDefinedField(normalized, payload, "template_id", "templateId");
+  copyDefinedField(normalized, payload, "recipient_email", "recipientEmail");
+  copyDefinedField(normalized, payload, "render_variables", "renderVariables");
+  copyDefinedField(normalized, payload, "user_id", "userId");
+  copyDefinedField(normalized, payload, "organization_id", "organizationId");
+  copyDefinedField(normalized, payload, "session_token", "sessionToken");
+  return normalized;
+}
+function toSessionGuardFailure(sessionResult) {
+  if (sessionResult.status === 401 || sessionResult.data == null) {
+    return {
+      ok: false,
+      reason: "unauthorized",
+      status: 401,
+      error: sessionResult.error ?? "Unauthorized",
+      sessionResult
+    };
+  }
+  return {
+    ok: false,
+    reason: "upstream_error",
+    status: sessionResult.status,
+    error: sessionResult.error ?? "Failed to resolve current session",
+    sessionResult
+  };
+}
+function toPermissionGuardFailure(permissionResult, sessionResult) {
+  if (permissionResult.status === 401) {
+    return {
+      ok: false,
+      reason: "unauthorized",
+      status: 401,
+      error: permissionResult.error ?? "Unauthorized",
+      sessionResult,
+      permissionResult
+    };
+  }
+  if (permissionResult.status === 403) {
+    return {
+      ok: false,
+      reason: "forbidden",
+      status: 403,
+      error: permissionResult.error ?? "Forbidden",
+      sessionResult,
+      permissionResult
+    };
+  }
+  return {
+    ok: false,
+    reason: "upstream_error",
+    status: permissionResult.status,
+    error: permissionResult.error ?? "Failed to resolve permission check",
+    sessionResult,
+    permissionResult
+  };
+}
 function extractFetchOptions(input) {
   if (!input) {
     return {
@@ -1821,6 +1965,7 @@ function extractFetchOptions(input) {
   };
 }
 function buildHeaders2(config, options) {
+  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
   const headers = {
     "Content-Type": "application/json",
     "X-Athena-Sdk": SDK_HEADER_VALUE2
@@ -1834,16 +1979,30 @@ function buildHeaders2(config, options) {
   if (bearerToken) {
     headers.Authorization = `Bearer ${bearerToken}`;
   }
+  const cookie = options?.cookie ?? config.cookie;
+  if (cookie) {
+    headers.Cookie = cookie;
+  }
+  const sessionToken = options?.sessionToken ?? config.sessionToken;
+  if (sessionToken) {
+    headers["X-Athena-Auth-Session-Token"] = sessionToken;
+  }
   const mergedExtraHeaders = {
     ...config.headers ?? {},
     ...options?.headers ?? {}
   };
   Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    if (forceNoCache && isCacheControlHeaderName2(key)) {
+      return;
+    }
     const normalized = normalizeHeaderValue2(value);
     if (normalized) {
       headers[key] = normalized;
     }
   });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE2;
+  }
   return headers;
 }
 function appendQueryParam(searchParams, key, value) {
@@ -2049,7 +2208,7 @@ function createAuthClient(config = {}) {
     ...config,
     baseUrl: normalizedBaseUrl
   };
-  const request = (input, options) => {
+  const request2 = (input, options) => {
     const method = input.method ?? (input.body !== void 0 ? "POST" : inferDefaultMethod(input.endpoint));
     const mergedOptions = mergeCallOptions(input.fetchOptions, options);
     return callAuthEndpoint(
@@ -2062,7 +2221,7 @@ function createAuthClient(config = {}) {
   };
   const postGeneric = (endpoint, input, options) => {
     const { payload, fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "POST",
@@ -2074,7 +2233,7 @@ function createAuthClient(config = {}) {
   };
   const getGeneric = (endpoint, input, options) => {
     const { fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "GET",
@@ -2086,7 +2245,7 @@ function createAuthClient(config = {}) {
   const getWithQuery = (endpoint, input, options) => {
     const { payload, fetchOptions } = extractFetchOptions(input);
     const query = payload?.query;
-    return request(
+    return request2(
       {
         endpoint,
         method: "GET",
@@ -2104,11 +2263,96 @@ function createAuthClient(config = {}) {
     htmlField: "htmlBody",
     textField: "textBody"
   }, withReactEmailRoute(route));
-  const resolveAdminEmailTemplatePayload = (route, input) => resolveReactEmailPayloadFields(input, {
+  const resolveAdminEmailTemplatePayload = (route, input) => resolveReactEmailPayloadFields(toReactEmailTemplateCompatibilityInput(input), {
     htmlField: "htmlTemplate",
     textField: "textTemplate",
     variablesField: "variables"
-  }, withReactEmailRoute(route));
+  }, withReactEmailRoute(route)).then((payload) => {
+    const normalizedPayload = normalizeAdminEmailTemplatePayload(payload);
+    if ("variables" in payload && payload.variables !== void 0 && payload.variables !== null) {
+      assertAthenaAuthTemplateVariables(
+        payload.variables,
+        `${route} variables`
+      );
+    }
+    return normalizedPayload;
+  });
+  const requireSession = async (input, options) => {
+    const sessionInput = input?.fetchOptions ? { fetchOptions: input.fetchOptions } : void 0;
+    const sessionResult = await getGeneric(
+      "/get-session",
+      sessionInput,
+      options
+    );
+    if (!sessionResult.ok || sessionResult.data == null) {
+      return toSessionGuardFailure(sessionResult);
+    }
+    return {
+      ok: true,
+      session: sessionResult.data
+    };
+  };
+  const getUser = async (input, options) => {
+    const sessionResult = await getGeneric(
+      "/get-session",
+      input,
+      options
+    );
+    if (!sessionResult.ok) {
+      return {
+        ...sessionResult,
+        data: null
+      };
+    }
+    return {
+      ...sessionResult,
+      data: {
+        user: sessionResult.data?.user ?? null
+      }
+    };
+  };
+  const requirePermission = async (endpoint, input, options) => {
+    const sessionGuard = await requireSession(
+      input?.fetchOptions ? { fetchOptions: input.fetchOptions } : void 0,
+      options
+    );
+    if (!sessionGuard.ok) {
+      return sessionGuard;
+    }
+    const permissionResult = await postGeneric(
+      endpoint,
+      input,
+      options
+    );
+    if (!permissionResult.ok) {
+      return toPermissionGuardFailure(permissionResult, {
+        ok: true,
+        status: 200,
+        data: sessionGuard.session,
+        error: null,
+        errorDetails: null,
+        raw: sessionGuard.session
+      });
+    }
+    if (!permissionResult.data?.success) {
+      return {
+        ok: false,
+        reason: "forbidden",
+        status: 403,
+        error: permissionResult.data?.error ?? "Forbidden",
+        sessionResult: {
+          ok: true,
+          status: 200,
+          data: sessionGuard.session,
+          error: null,
+          errorDetails: null,
+          raw: sessionGuard.session
+        },
+        permissionResult
+      };
+    }
+    return sessionGuard;
+  };
   const listUserEmailsWithFallback = async (input, options) => {
     const primary = await getWithQuery(
       "/email/list",
@@ -2270,6 +2514,7 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    requirePermission: (input, options) => requirePermission("/organization/has-permission", input, options),
     invitation: {
       cancel: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -2465,6 +2710,8 @@ function createAuthClient(config = {}) {
   };
   const auth = {
     getSession: (input, options) => getGeneric("/get-session", input, options),
+    getUser,
+    requireSession,
     signOut,
     forgetPassword: (input, options) => postGeneric("/forget-password", input, options),
     resetPassword: authResetPassword,
@@ -2559,6 +2806,7 @@ function createAuthClient(config = {}) {
         }
       },
       hasPermission: (input, options) => postGeneric("/admin/has-permission", input, options),
+      requirePermission: (input, options) => requirePermission("/admin/has-permission", input, options),
       apiKey: {
         create: (input, options) => postGeneric("/admin/api-key/create", input, options)
       },
@@ -2603,7 +2851,15 @@ function createAuthClient(config = {}) {
             await resolveAdminEmailTemplatePayload("/admin/email-template/update", input),
             options
           ),
-          delete: (input, options) => postGeneric("/admin/email-template/delete", input, options)
+          delete: (input, options) => postGeneric("/admin/email-template/delete", input, options),
+          send: (input, options) => postGeneric(
+            "/admin/email-template/send",
+            normalizeAdminEmailTemplateSendPayload(extractFetchOptions(input).payload),
+            options
+          )
+        },
+        eventType: {
+          list: (input, options) => getWithQuery("/admin/email-event-type/list", input, options)
         }
       },
       emailTemplate: {
@@ -2619,7 +2875,15 @@ function createAuthClient(config = {}) {
           "/admin/email-template/update",
           await resolveAdminEmailTemplatePayload("/admin/email-template/update", input),
           options
+        ),
+        send: (input, options) => postGeneric(
+          "/admin/email-template/send",
+          normalizeAdminEmailTemplateSendPayload(extractFetchOptions(input).payload),
+          options
         )
+      },
+      emailEventType: {
+        list: (input, options) => getWithQuery("/admin/email-event-type/list", input, options)
       }
     },
     apiKey: {
@@ -2659,7 +2923,7 @@ function createAuthClient(config = {}) {
           throw new Error("callback.provider requires non-empty code and state values");
         }
         const endpoint = `/callback/${encodeURIComponent(provider)}`;
-        return request({
+        return request2({
           endpoint,
           method: "GET",
           query: {
@@ -2673,7 +2937,7 @@ function createAuthClient(config = {}) {
   };
   return {
     baseUrl: normalizedBaseUrl,
-    request,
+    request: request2,
     signIn: {
       email: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -2710,6 +2974,8 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    getUser,
+    requireSession,
     listSessions: (input, options) => executeGetWithCompatibleInput(
       resolvedConfig,
       { endpoint: "/list-sessions", method: "GET" },
@@ -3412,16 +3678,16 @@ function createStorageFileModule(base, config = {}) {
       };
     });
     input.onProgress?.(createProgressSnapshot("preparing", sources, 0, 0, 0));
-    const uploadUrls = uploadRequests.length === 1 ? [await base.createStorageUploadUrl(uploadRequests[0].uploadRequest, options)] : (await base.createStorageUploadUrls({ files: uploadRequests.map((request) => request.uploadRequest) }, options)).files;
+    const uploadUrls = uploadRequests.length === 1 ? [await base.createStorageUploadUrl(uploadRequests[0].uploadRequest, options)] : (await base.createStorageUploadUrls({ files: uploadRequests.map((request2) => request2.uploadRequest) }, options)).files;
     const aggregateLoaded = new Array(uploadRequests.length).fill(0);
     const uploaded = [];
     for (let index = 0; index < uploadRequests.length; index += 1) {
-      const request = uploadRequests[index];
+      const request2 = uploadRequests[index];
       const uploadUrl = uploadUrls[index];
       const response = await putUploadBody(
         uploadUrl.upload.url,
         uploadUrl.upload.headers ?? {},
-        request.source,
+        request2.source,
         input,
         options,
         (progress) => {
@@ -3432,13 +3698,13 @@ function createStorageFileModule(base, config = {}) {
       uploaded.push({
         file: uploadUrl.file,
         upload: uploadUrl.upload,
-        source: request.source.source,
-        fileName: request.source.fileName,
-        storage_key: request.uploadRequest.storage_key,
+        source: request2.source.source,
+        fileName: request2.source.fileName,
+        storage_key: request2.uploadRequest.storage_key,
         response
       });
-      aggregateLoaded[index] = request.source.sizeBytes;
-      input.onProgress?.(createProgressSnapshot("complete", sources, index, request.source.sizeBytes, sum(aggregateLoaded)));
+      aggregateLoaded[index] = request2.source.sizeBytes;
+      input.onProgress?.(createProgressSnapshot("complete", sources, index, request2.source.sizeBytes, sum(aggregateLoaded)));
     }
     return {
       files: uploaded,
@@ -5413,6 +5679,517 @@ function createStorageModule(gateway, runtimeOptions) {
   };
 }
 
+// src/chat/module.ts
+var SDK_NAME3 = "xylex-group/athena-chat";
+var SDK_HEADER_VALUE3 = buildSdkHeaderValue(SDK_NAME3);
+var NO_CACHE_HEADER_VALUE3 = "no-cache";
+var AthenaChatError = class extends Error {
+  status;
+  endpoint;
+  method;
+  requestId;
+  body;
+  constructor(input) {
+    super(input.message);
+    this.name = "AthenaChatError";
+    this.status = input.status;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.requestId = input.requestId;
+    this.body = input.body;
+  }
+};
+function deriveRealtimeInfoUrl(wsUrl) {
+  if (!wsUrl) {
+    return void 0;
+  }
+  const parsed = new URL(normalizeWsUrl(wsUrl, "Athena chat WebSocket URL"));
+  parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
+  parsed.pathname = parsed.pathname.replace(/\/wss\/gateway$/, "/wss/info");
+  return parsed.toString();
+}
+function normalizeWsUrl(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
+  }
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error(`${label} must be a valid absolute ws(s) URL.`);
+  }
+  if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+    throw new Error(`${label} must use ws or wss.`);
+  }
+  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+  return parsed.toString().replace(/\/$/, "");
+}
+function isRecord7(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeHeaderValue3(value) {
+  return value ? value : void 0;
+}
+function parseResponseBody4(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
+  }
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
+  }
+}
+function resolveRequestId3(headers) {
+  return headers.get("x-request-id") ?? headers.get("x-correlation-id") ?? headers.get("x-athena-request-id") ?? void 0;
+}
+function resolveErrorMessage4(payload, fallback) {
+  if (isRecord7(payload)) {
+    for (const candidate of [payload.error, payload.message, payload.details]) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+    }
+  }
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function encodePathSegment(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
+  }
+  return encodeURIComponent(normalized);
+}
+function encodeQuery(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const encoded = params.toString();
+  return encoded ? `?${encoded}` : "";
+}
+function createSocket(factory, url, protocols) {
+  try {
+    return new factory(url, protocols);
+  } catch (error) {
+    if (error instanceof TypeError) {
+      return factory(url, protocols);
+    }
+    throw error;
+  }
+}
+function buildHeaders3(config, options) {
+  const headers = {
+    Accept: "application/json",
+    apikey: config.apiKey,
+    "x-api-key": config.apiKey,
+    "X-Athena-Sdk": SDK_HEADER_VALUE3
+  };
+  if (config.client || options?.client) {
+    headers["X-Athena-Client"] = options?.client ?? config.client ?? "";
+  }
+  const bearerToken = options?.bearerToken ?? config.bearerToken;
+  if (typeof bearerToken === "string" && bearerToken.trim()) {
+    headers.Authorization = bearerToken.startsWith("Bearer ") ? bearerToken : `Bearer ${bearerToken}`;
+  }
+  const cookie = options?.cookie ?? config.cookie;
+  if (typeof cookie === "string" && cookie.trim()) {
+    headers.Cookie = cookie;
+  }
+  const sessionToken = options?.sessionToken ?? config.sessionToken;
+  if (typeof sessionToken === "string" && sessionToken.trim()) {
+    headers["X-Athena-Auth-Session-Token"] = sessionToken;
+  }
+  if (config.forceNoCache || options?.forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE3;
+  }
+  for (const source of [config.headers, options?.headers]) {
+    for (const [key, value] of Object.entries(source ?? {})) {
+      const normalized = normalizeHeaderValue3(value);
+      if (normalized) {
+        headers[key] = normalized;
+      }
+    }
+  }
+  return headers;
+}
+function withJsonBody(init, body) {
+  return {
+    ...init,
+    body: body === void 0 ? void 0 : JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...init.headers
+    }
+  };
+}
+async function request(config, method, endpoint, options, body) {
+  if (!config.baseUrl) {
+    throw new Error(
+      "Athena chat base URL is not configured. Pass createClient({ url }) for unified routing or set chat.url / chatUrl explicitly."
+    );
+  }
+  const url = `${config.baseUrl}${endpoint}`;
+  const init = {
+    method,
+    headers: buildHeaders3(config, options),
+    signal: options?.signal
+  };
+  const finalInit = body === void 0 || method === "GET" ? init : withJsonBody(init, body);
+  const response = await fetch(url, finalInit);
+  const rawText = await response.text();
+  const { parsed } = parseResponseBody4(rawText, response.headers.get("content-type"));
+  if (!response.ok) {
+    throw new AthenaChatError({
+      message: resolveErrorMessage4(parsed, `Athena chat ${method} ${endpoint} failed with ${response.status}`),
+      status: response.status,
+      endpoint,
+      method,
+      requestId: resolveRequestId3(response.headers),
+      body: parsed
+    });
+  }
+  return parsed;
+}
+function unwrapEnvelopeData(payload) {
+  return payload.data;
+}
+function createRealtimeConnection(config, options) {
+  if (!config.wsUrl) {
+    throw new Error(
+      "Athena chat WebSocket URL is not configured. Pass createClient({ url }) for unified routing or set chat.wsUrl / chatWsUrl explicitly."
+    );
+  }
+  const wsFactory = config.webSocketFactory ?? globalThis.WebSocket;
+  if (!wsFactory) {
+    throw new Error(
+      "No WebSocket implementation is available. Provide chat.webSocketFactory in createClient(...) or run in a runtime with global WebSocket support."
+    );
+  }
+  const socket = createSocket(wsFactory, config.wsUrl, options?.protocols);
+  const send = (command) => {
+    socket.send(JSON.stringify(command));
+  };
+  if (options?.onMessage) {
+    const listener = (event) => {
+      const messageEvent = event;
+      const raw = messageEvent?.data;
+      if (typeof raw !== "string") {
+        return;
+      }
+      try {
+        options.onMessage?.(JSON.parse(raw));
+      } catch {
+        options.onMessage?.({ type: "error", error: "Invalid JSON message from Athena chat realtime gateway." });
+      }
+    };
+    if (typeof socket.addEventListener === "function") {
+      socket.addEventListener("message", listener);
+    } else {
+      socket.onmessage = listener;
+    }
+  }
+  const hello = (command) => {
+    send({
+      type: "auth.hello",
+      token: command?.token,
+      room_subscriptions: command?.room_subscriptions
+    });
+  };
+  if (options?.hello) {
+    const onOpen = () => hello({
+      token: options.hello?.token ?? void 0,
+      room_subscriptions: options.hello?.room_subscriptions ?? void 0
+    });
+    if (typeof socket.addEventListener === "function") {
+      socket.addEventListener("open", onOpen);
+    } else {
+      socket.onopen = onOpen;
+    }
+  }
+  return {
+    socket,
+    send,
+    hello,
+    subscribe(roomId, fromSeq) {
+      send({
+        type: "chat.subscribe",
+        room_id: roomId,
+        from_seq: fromSeq ?? void 0
+      });
+    },
+    unsubscribe(roomId) {
+      send({
+        type: "chat.unsubscribe",
+        room_id: roomId
+      });
+    },
+    resume(rooms) {
+      send({
+        type: "chat.resume",
+        rooms
+      });
+    },
+    typingStart(roomId) {
+      send({
+        type: "chat.typing.start",
+        room_id: roomId
+      });
+    },
+    typingStop(roomId) {
+      send({
+        type: "chat.typing.stop",
+        room_id: roomId
+      });
+    },
+    presenceHeartbeat(activeRoomId) {
+      send({
+        type: "chat.presence.heartbeat",
+        active_room_id: activeRoomId ?? void 0
+      });
+    },
+    readUpTo(roomId, input) {
+      send({
+        type: "chat.read.up_to",
+        room_id: roomId,
+        message_id: input?.message_id ?? void 0,
+        seq: input?.seq ?? void 0
+      });
+    },
+    ping(at = (/* @__PURE__ */ new Date()).toISOString()) {
+      send({
+        type: "ping",
+        at
+      });
+    },
+    close(code, reason) {
+      socket.close(code, reason);
+    }
+  };
+}
+function createChatModule(config) {
+  const realtime = {
+    info(options) {
+      const realtimeInfoUrl = config.realtimeInfoUrl ?? deriveRealtimeInfoUrl(config.wsUrl);
+      if (!realtimeInfoUrl) {
+        throw new Error(
+          "Athena chat realtime info URL is not configured. Pass createClient({ url }) for unified routing or set chat.wsUrl / chatWsUrl explicitly."
+        );
+      }
+      return request(
+        {
+          ...config,
+          baseUrl: realtimeInfoUrl
+        },
+        "GET",
+        "",
+        options
+      );
+    },
+    connect(options) {
+      return createRealtimeConnection(config, options);
+    }
+  };
+  return {
+    room: {
+      list(query, options) {
+        return request(
+          config,
+          "GET",
+          `/rooms${encodeQuery(query)}`,
+          options
+        );
+      },
+      create(input, options) {
+        return request(config, "POST", "/rooms", options, input);
+      },
+      get(roomId, options) {
+        return request(
+          config,
+          "GET",
+          `/rooms/${encodePathSegment(roomId, "chat room ID")}`,
+          options
+        );
+      },
+      update(roomId, input, options) {
+        return request(
+          config,
+          "PATCH",
+          `/rooms/${encodePathSegment(roomId, "chat room ID")}`,
+          options,
+          input
+        );
+      },
+      archive(roomId, options) {
+        return request(
+          config,
+          "POST",
+          `/rooms/${encodePathSegment(roomId, "chat room ID")}/archive`,
+          options
+        );
+      },
+      readCursor: {
+        upTo(roomId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/read-cursor`,
+            options,
+            input ?? {}
+          );
+        }
+      },
+      member: {
+        list(roomId, options) {
+          return request(
+            config,
+            "GET",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/members`,
+            options
+          );
+        },
+        add(roomId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/members`,
+            options,
+            input
+          );
+        },
+        remove(roomId, userId, options) {
+          return request(
+            config,
+            "DELETE",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/members/${encodePathSegment(userId, "chat user ID")}`,
+            options
+          );
+        }
+      },
+      message: {
+        list(roomId, query, options) {
+          return request(
+            config,
+            "GET",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages${encodeQuery(query)}`,
+            options
+          );
+        },
+        send(roomId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages`,
+            options,
+            input
+          );
+        },
+        update(roomId, messageId, input, options) {
+          return request(
+            config,
+            "PATCH",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages/${encodePathSegment(messageId, "chat message ID")}`,
+            options,
+            input
+          );
+        },
+        delete(roomId, messageId, options) {
+          return request(
+            config,
+            "DELETE",
+            `/rooms/${encodePathSegment(roomId, "chat room ID")}/messages/${encodePathSegment(messageId, "chat message ID")}`,
+            options
+          );
+        }
+      }
+    },
+    message: {
+      reaction: {
+        add(messageId, input, options) {
+          return request(
+            config,
+            "POST",
+            `/messages/${encodePathSegment(messageId, "chat message ID")}/reactions`,
+            options,
+            input
+          );
+        },
+        remove(messageId, emoji, options) {
+          return request(
+            config,
+            "DELETE",
+            `/messages/${encodePathSegment(messageId, "chat message ID")}/reactions/${encodePathSegment(emoji, "reaction emoji")}`,
+            options
+          );
+        }
+      },
+      search(input, options) {
+        return request(
+          config,
+          "POST",
+          "/messages/search",
+          options,
+          input
+        );
+      }
+    },
+    realtime
+  };
+}
+var chatSdkManifest = {
+  namespace: "chat",
+  basePath: "/chat",
+  methods: [
+    { name: "listRooms", method: "GET", path: "/chat/rooms" },
+    { name: "createRoom", method: "POST", path: "/chat/rooms" },
+    { name: "getRoom", method: "GET", path: "/chat/rooms/{room_id}" },
+    { name: "updateRoom", method: "PATCH", path: "/chat/rooms/{room_id}" },
+    { name: "archiveRoom", method: "POST", path: "/chat/rooms/{room_id}/archive" },
+    { name: "listRoomMessages", method: "GET", path: "/chat/rooms/{room_id}/messages" },
+    { name: "sendRoomMessage", method: "POST", path: "/chat/rooms/{room_id}/messages" },
+    { name: "updateRoomMessage", method: "PATCH", path: "/chat/rooms/{room_id}/messages/{message_id}" },
+    { name: "deleteRoomMessage", method: "DELETE", path: "/chat/rooms/{room_id}/messages/{message_id}" },
+    { name: "advanceReadCursor", method: "POST", path: "/chat/rooms/{room_id}/read-cursor" },
+    { name: "listRoomMembers", method: "GET", path: "/chat/rooms/{room_id}/members" },
+    { name: "addRoomMembers", method: "POST", path: "/chat/rooms/{room_id}/members" },
+    { name: "removeRoomMember", method: "DELETE", path: "/chat/rooms/{room_id}/members/{user_id}" },
+    { name: "addReaction", method: "POST", path: "/chat/messages/{message_id}/reactions" },
+    { name: "removeReaction", method: "DELETE", path: "/chat/messages/{message_id}/reactions/{emoji}" },
+    { name: "searchMessages", method: "POST", path: "/chat/messages/search" },
+    { name: "getRealtimeInfo", method: "GET", path: "/wss/info" },
+    { name: "connectRealtime", method: "GET", path: "/wss/gateway" }
+  ]
+};
+function unwrapChatRoom(payload) {
+  return unwrapEnvelopeData(payload);
+}
+function unwrapChatMessage(payload) {
+  return unwrapEnvelopeData(payload);
+}
+
 // src/client-builder.ts
 var DEFAULT_BACKEND = { type: "athena" };
 function toBackendConfig(value) {
@@ -5465,6 +6242,9 @@ var AthenaClientBuilderImpl = class {
   apiKey;
   backendConfig = DEFAULT_BACKEND;
   clientName;
+  defaultUserId;
+  defaultOrganizationId;
+  forceNoCacheEnabled = false;
   defaultHeaders;
   authConfig;
   dbUrlOverride;
@@ -5513,6 +6293,15 @@ var AthenaClientBuilderImpl = class {
     if (options.client !== void 0) {
       this.clientName = options.client;
     }
+    if (options.userId !== void 0) {
+      this.defaultUserId = options.userId;
+    }
+    if (options.organizationId !== void 0) {
+      this.defaultOrganizationId = options.organizationId;
+    }
+    if (options.forceNoCache !== void 0) {
+      this.forceNoCacheEnabled = options.forceNoCache;
+    }
     if (options.backend !== void 0) {
       this.backendConfig = toBackendConfig(options.backend);
     }
@@ -5567,6 +6356,9 @@ var AthenaClientBuilderImpl = class {
       url: this.rootUrl,
       key: this.apiKey,
       client: this.clientName,
+      userId: this.defaultUserId,
+      organizationId: this.defaultOrganizationId,
+      forceNoCache: this.forceNoCacheEnabled,
       backend: this.backendConfig,
       headers: this.defaultHeaders,
       db: this.dbUrlOverride ? { url: this.dbUrlOverride } : void 0,
@@ -5610,7 +6402,7 @@ var BOOLEAN_SAFE_OPERATORS = /* @__PURE__ */ new Set([
   "ilike",
   "is"
 ]);
-function isRecord7(value) {
+function isRecord8(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isUuidString(value) {
@@ -5623,7 +6415,7 @@ function shouldUseUuidTextComparison(column, value) {
   return typeof value === "string" && isUuidString(value) && isUuidIdentifierColumn(column);
 }
 function isRelationSelectNode(value) {
-  return isRecord7(value) && isRecord7(value.select);
+  return isRecord8(value) && isRecord8(value.select);
 }
 function normalizeIdentifier(value, label) {
   const normalized = value.trim();
@@ -5679,7 +6471,7 @@ function compileRelationToken(key, node) {
   return `${prefix}${relationToken}(${nested})`;
 }
 function compileSelectShape(select) {
-  if (!isRecord7(select)) {
+  if (!isRecord8(select)) {
     throw new Error("findMany select must be an object");
   }
   const tokens = [];
@@ -5703,7 +6495,7 @@ function compileSelectShape(select) {
   return tokens.join(",");
 }
 function selectShapeUsesRelationSchema(select) {
-  if (!isRecord7(select)) {
+  if (!isRecord8(select)) {
     return false;
   }
   for (const rawValue of Object.values(select)) {
@@ -5721,7 +6513,7 @@ function selectShapeUsesRelationSchema(select) {
 }
 function compileColumnWhere(column, input) {
   const normalizedColumn = normalizeIdentifier(column, "where column");
-  if (!isRecord7(input)) {
+  if (!isRecord8(input)) {
     return [buildGatewayCondition("eq", normalizedColumn, input)];
   }
   const conditions = [];
@@ -5749,7 +6541,7 @@ function compileColumnWhere(column, input) {
   return conditions;
 }
 function compileBooleanExpressionTerms(clause, label) {
-  if (!isRecord7(clause)) {
+  if (!isRecord8(clause)) {
     throw new Error(`findMany where.${label} clauses must be objects`);
   }
   const entries = Object.entries(clause).filter(([, value]) => value !== void 0);
@@ -5758,7 +6550,7 @@ function compileBooleanExpressionTerms(clause, label) {
   }
   const [rawColumn, rawValue] = entries[0];
   const column = normalizeIdentifier(rawColumn, `where.${label} column`);
-  if (!isRecord7(rawValue)) {
+  if (!isRecord8(rawValue)) {
     return [`${column}.eq.${stringifyFilterValue(rawValue)}`];
   }
   const operatorEntries = Object.entries(rawValue).filter(([, value]) => value !== void 0);
@@ -5782,7 +6574,7 @@ function compileWhere(where) {
   if (where === void 0) {
     return void 0;
   }
-  if (!isRecord7(where)) {
+  if (!isRecord8(where)) {
     throw new Error("findMany where must be an object");
   }
   const conditions = [];
@@ -5832,7 +6624,7 @@ function compileOrderBy(orderBy) {
   if (orderBy === void 0) {
     return void 0;
   }
-  if (!isRecord7(orderBy)) {
+  if (!isRecord8(orderBy)) {
     throw new Error("findMany orderBy must be an object");
   }
   if ("column" in orderBy) {
@@ -6007,11 +6799,11 @@ function toFindManyAstOrder(order) {
     ascending: order.direction !== "descending"
   };
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeFindManyAstColumnPredicate(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return {
       eq: value
     };
@@ -6035,7 +6827,7 @@ function normalizeFindManyAstBooleanOperand(clause) {
   return normalized;
 }
 function normalizeFindManyAstWhere(where) {
-  if (!where || !isRecord8(where)) {
+  if (!where || !isRecord9(where)) {
     return where;
   }
   const normalized = {};
@@ -6049,7 +6841,7 @@ function normalizeFindManyAstWhere(where) {
       );
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       normalized.not = normalizeFindManyAstBooleanOperand(
         value
       );
@@ -6060,7 +6852,7 @@ function normalizeFindManyAstWhere(where) {
   return normalized;
 }
 function predicateRequiresUuidQueryFallback(column, value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return shouldUseUuidTextComparison(column, value);
   }
   const eqValue = value.eq;
@@ -6078,7 +6870,7 @@ function booleanOperandRequiresUuidQueryFallback(clause) {
   return false;
 }
 function findManyAstWhereRequiresLegacyTransport(where) {
-  if (!where || !isRecord8(where)) {
+  if (!where || !isRecord9(where)) {
     return false;
   }
   for (const [key, value] of Object.entries(where)) {
@@ -6093,7 +6885,7 @@ function findManyAstWhereRequiresLegacyTransport(where) {
       }
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       if (booleanOperandRequiresUuidQueryFallback(value)) {
         return true;
       }
@@ -6642,6 +7434,7 @@ function resolveAthenaModelTargetTableName(target, options = {}) {
 var DEFAULT_COLUMNS = "*";
 var SAFE_CAST_PATTERN = /^[a-z_][a-z0-9_]*(?:\[\])?$/i;
 var ATHENA_NORMALIZED_ERROR_KEY = "__athenaNormalizedError";
+var SDK_NAME4 = "xylex-group/athena";
 function formatResult(response) {
   const result = {
     data: response.data ?? null,
@@ -6718,7 +7511,7 @@ async function executeExperimentalRead(experimental, runner) {
     throw error;
   }
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function firstNonEmptyString2(...values) {
@@ -6730,8 +7523,8 @@ function firstNonEmptyString2(...values) {
   return void 0;
 }
 function resolveStructuredErrorPayload2(raw) {
-  if (!isRecord9(raw)) return null;
-  return isRecord9(raw.error) ? raw.error : raw;
+  if (!isRecord10(raw)) return null;
+  return isRecord10(raw.error) ? raw.error : raw;
 }
 function resolveStructuredErrorDetails(payload, message) {
   if (!payload || !("details" in payload)) {
@@ -6747,7 +7540,7 @@ function resolveStructuredErrorDetails(payload, message) {
   return details;
 }
 function createResultError(response, result, normalized) {
-  const rawRecord = isRecord9(response.raw) ? response.raw : null;
+  const rawRecord = isRecord10(response.raw) ? response.raw : null;
   const payload = resolveStructuredErrorPayload2(response.raw);
   const message = firstNonEmptyString2(
     response.error,
@@ -6810,6 +7603,43 @@ function asAthenaJsonObject(value) {
 function asAthenaJsonObjectArray(values) {
   return values;
 }
+function parseArbitraryResponseBody(rawText, contentType) {
+  if (!rawText) {
+    return null;
+  }
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return rawText;
+  }
+  try {
+    return JSON.parse(rawText);
+  } catch {
+    return rawText;
+  }
+}
+function toRequestQueryString(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const encoded = params.toString();
+  return encoded ? `?${encoded}` : "";
+}
 function normalizeSelectColumnsInput(columns) {
   if (columns === void 0) {
     return void 0;
@@ -8109,6 +8939,85 @@ function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
     );
   };
 }
+var ATHENA_ENV_URL_KEYS = ["ATHENA_URL", "NEXT_PUBLIC_ATHENA_URL"];
+var ATHENA_ENV_GATEWAY_URL_KEYS = [
+  "ATHENA_DB_URL",
+  "ATHENA_GATEWAY_URL",
+  "NEXT_PUBLIC_ATHENA_DB_API_URL"
+];
+var ATHENA_ENV_AUTH_URL_KEYS = ["ATHENA_AUTH_URL", "NEXT_PUBLIC_ATHENA_AUTH_URL"];
+var ATHENA_ENV_CHAT_URL_KEYS = ["ATHENA_CHAT_URL", "NEXT_PUBLIC_ATHENA_CHAT_URL"];
+var ATHENA_ENV_CHAT_WS_URL_KEYS = ["ATHENA_CHAT_WS_URL", "NEXT_PUBLIC_ATHENA_CHAT_WS_URL"];
+var ATHENA_ENV_STORAGE_URL_KEYS = ["ATHENA_STORAGE_URL", "NEXT_PUBLIC_ATHENA_STORAGE_URL"];
+var ATHENA_ENV_KEY_KEYS = [
+  "ATHENA_API_KEY",
+  "NEXT_PUBLIC_ATHENA_API_KEY",
+  "ATHENA_GATEWAY_API_KEY",
+  "X_API_KEY"
+];
+var ATHENA_ENV_CLIENT_KEYS = ["ATHENA_CLIENT", "NEXT_PUBLIC_ATHENA_CLIENT"];
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : void 0;
+}
+function readFirstEnvValue(env, keys) {
+  for (const key of keys) {
+    const value = normalizeOptionalString(env[key]);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readHeaderBagValue(headers, targetKey) {
+  if (!headers) {
+    return void 0;
+  }
+  if (typeof headers.get === "function") {
+    return normalizeOptionalString(headers.get(targetKey));
+  }
+  const normalizedTargetKey = targetKey.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== normalizedTargetKey) {
+      continue;
+    }
+    if (typeof value === "string") {
+      return normalizeOptionalString(value);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function resolveSessionContextOptions(session, options) {
+  const sessionToken = normalizeOptionalString(session?.session?.token);
+  const requestCookie = readHeaderBagValue(options?.requestHeaders, "cookie") ?? readHeaderBagValue(options?.headers, "cookie");
+  const authInput = options?.auth;
+  const resolvedUserId = options?.userId !== void 0 ? options.userId : session?.user?.id;
+  const resolvedOrganizationId = options?.organizationId !== void 0 ? options.organizationId : session?.session?.activeOrganizationId;
+  const resolvedBearerToken = authInput?.bearerToken !== void 0 ? authInput.bearerToken : sessionToken;
+  const resolvedSessionToken = authInput?.sessionToken !== void 0 ? authInput.sessionToken : sessionToken;
+  const resolvedCookie = authInput?.cookie !== void 0 ? authInput.cookie : requestCookie;
+  const auth = authInput !== void 0 || resolvedBearerToken !== void 0 || resolvedSessionToken !== void 0 || resolvedCookie !== void 0 ? {
+    ...authInput ?? {},
+    ...resolvedBearerToken !== void 0 ? { bearerToken: resolvedBearerToken } : {},
+    ...resolvedSessionToken !== void 0 ? { sessionToken: resolvedSessionToken } : {},
+    ...resolvedCookie !== void 0 ? { cookie: resolvedCookie } : {},
+    headers: authInput?.headers ? { ...authInput.headers } : void 0
+  } : void 0;
+  if (resolvedUserId === void 0 && resolvedOrganizationId === void 0 && options?.forceNoCache === void 0 && !options?.headers && !auth) {
+    return void 0;
+  }
+  return {
+    userId: resolvedUserId,
+    organizationId: resolvedOrganizationId,
+    forceNoCache: options?.forceNoCache,
+    headers: options?.headers ? { ...options.headers } : void 0,
+    auth
+  };
+}
 function resolveClientServiceBaseUrl(value, label) {
   if (value === void 0 || value === null) {
     return void 0;
@@ -8119,6 +9028,15 @@ function appendServicePath(baseUrl, segment) {
   const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(baseUrl, { label: "Athena public base URL" });
   return `${normalizedBaseUrl}/${segment.replace(/^\/+/, "")}`;
 }
+function appendRealtimeGatewayPath(baseUrl) {
+  const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(baseUrl, { label: "Athena public base URL" });
+  const wsUrl = new URL(normalizedBaseUrl);
+  wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+  wsUrl.pathname = `${wsUrl.pathname.replace(/\/+$/, "")}/wss/gateway`;
+  wsUrl.search = "";
+  wsUrl.hash = "";
+  return wsUrl.toString();
+}
 function resolveServiceUrlOverride(value, label) {
   return resolveClientServiceBaseUrl(value, label);
 }
@@ -8127,6 +9045,8 @@ function resolveServiceUrls(config) {
   return {
     dbUrl: resolveServiceUrlOverride(config.db?.url, "Athena DB base URL") ?? resolveServiceUrlOverride(config.gateway?.url, "Athena gateway base URL") ?? resolveServiceUrlOverride(config.dbUrl, "Athena DB base URL") ?? resolveServiceUrlOverride(config.gatewayUrl, "Athena gateway base URL") ?? (baseUrl ? appendServicePath(baseUrl, "db") : void 0),
     authUrl: resolveServiceUrlOverride(config.auth?.url, "Athena auth base URL") ?? resolveServiceUrlOverride(config.auth?.baseUrl, "Athena auth base URL") ?? resolveServiceUrlOverride(config.authUrl, "Athena auth base URL") ?? (baseUrl ? appendServicePath(baseUrl, "auth") : void 0),
+    chatUrl: resolveServiceUrlOverride(config.chat?.url, "Athena chat base URL") ?? resolveServiceUrlOverride(config.chatUrl, "Athena chat base URL") ?? (baseUrl ? appendServicePath(baseUrl, "chat") : void 0),
+    chatWsUrl: normalizeOptionalString(config.chat?.wsUrl) ?? normalizeOptionalString(config.chatWsUrl) ?? (baseUrl ? appendRealtimeGatewayPath(baseUrl) : void 0),
     storageUrl: resolveServiceUrlOverride(config.storage?.url, "Athena storage base URL") ?? resolveServiceUrlOverride(config.storageUrl, "Athena storage base URL") ?? (baseUrl ? appendServicePath(baseUrl, "storage") : void 0)
   };
 }
@@ -8151,6 +9071,89 @@ function resolveRequiredClientApiKey(value) {
   }
   return normalizedValue;
 }
+function hasHeaderIgnoreCase(headers, targetKey) {
+  const normalizedTargetKey = targetKey.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalizedTargetKey);
+}
+function mergeClientHeaders(current, next) {
+  if (!current && !next) {
+    return void 0;
+  }
+  return {
+    ...current ?? {},
+    ...next ?? {}
+  };
+}
+function mergeDefinedObject(current, next) {
+  if (!current && !next) {
+    return void 0;
+  }
+  const merged = {
+    ...current ?? {}
+  };
+  const mutableMerged = merged;
+  for (const [key, value] of Object.entries(next ?? {})) {
+    if (value !== void 0) {
+      mutableMerged[key] = value;
+    }
+  }
+  return merged;
+}
+function mergeAuthClientOptions(current, next) {
+  const merged = mergeDefinedObject(current, next);
+  if (!merged) {
+    return void 0;
+  }
+  const mergedHeaders = mergeClientHeaders(current?.headers, next?.headers);
+  if (mergedHeaders) {
+    merged.headers = mergedHeaders;
+  }
+  return merged;
+}
+function mergeServiceUrlOverrides(current, next) {
+  return mergeDefinedObject(current, next);
+}
+function toClientContextOverrides(context) {
+  if (!context) {
+    return void 0;
+  }
+  return {
+    userId: context.userId,
+    organizationId: context.organizationId,
+    forceNoCache: context.forceNoCache,
+    headers: context.headers,
+    auth: context.auth ? {
+      ...context.auth,
+      headers: context.auth.headers ? { ...context.auth.headers } : void 0
+    } : void 0
+  };
+}
+function mergeClientOverrideOptions(base, overrides) {
+  if (!overrides) {
+    return {
+      ...base,
+      headers: base.headers ? { ...base.headers } : void 0,
+      auth: base.auth ? {
+        ...base.auth,
+        headers: base.auth.headers ? { ...base.auth.headers } : void 0
+      } : void 0,
+      db: base.db ? { ...base.db } : void 0,
+      gateway: base.gateway ? { ...base.gateway } : void 0,
+      chat: base.chat ? { ...base.chat } : void 0,
+      storage: base.storage ? { ...base.storage } : void 0
+    };
+  }
+  const merged = mergeDefinedObject(base, overrides) ?? { ...base };
+  return {
+    ...merged,
+    headers: mergeClientHeaders(base.headers, overrides.headers),
+    auth: mergeAuthClientOptions(base.auth, overrides.auth),
+    db: mergeServiceUrlOverrides(base.db, overrides.db),
+    gateway: mergeServiceUrlOverrides(base.gateway, overrides.gateway),
+    chat: mergeServiceUrlOverrides(base.chat, overrides.chat),
+    storage: mergeServiceUrlOverrides(base.storage, overrides.storage)
+  };
+}
 function normalizeAuthClientConfig(auth, defaultBaseUrl) {
   if (!auth && defaultBaseUrl === void 0) {
     return void 0;
@@ -8160,6 +9163,8 @@ function normalizeAuthClientConfig(auth, defaultBaseUrl) {
     baseUrl,
     apiKey,
     bearerToken,
+    cookie,
+    sessionToken,
     ...rest
   } = auth ?? {};
   const normalized = {
@@ -8178,6 +9183,12 @@ function normalizeAuthClientConfig(auth, defaultBaseUrl) {
   if (typeof bearerToken === "string") {
     normalized.bearerToken = bearerToken;
   }
+  if (typeof cookie === "string") {
+    normalized.cookie = cookie;
+  }
+  if (typeof sessionToken === "string") {
+    normalized.sessionToken = sessionToken;
+  }
   return normalized;
 }
 function resolveCreateClientConfig(config) {
@@ -8191,31 +9202,53 @@ function resolveCreateClientConfig(config) {
     baseUrl: resolvedUrls.dbUrl,
     apiKey: resolveRequiredClientApiKey(config.key),
     client: resolveOptionalClientName(config.client),
+    userId: config.userId,
+    organizationId: config.organizationId,
+    forceNoCache: config.forceNoCache,
     backend: toBackendConfig(config.backend),
     headers: config.headers,
     auth: config.auth,
     authUrl: resolvedUrls.authUrl,
+    chat: config.chat,
+    chatUrl: resolvedUrls.chatUrl,
+    chatWsUrl: resolvedUrls.chatWsUrl,
     storageUrl: resolvedUrls.storageUrl,
     experimental: config.experimental
   };
 }
-function createClientFromConfig(config) {
+function createClientFromInput(sourceConfig) {
+  return createClientFromConfig(resolveCreateClientConfig(sourceConfig), sourceConfig);
+}
+function createClientFromConfig(config, sourceConfig) {
+  const normalizedAuthConfig = normalizeAuthClientConfig(config.auth, config.authUrl);
   const gatewayHeaders = {
     ...config.headers ?? {}
   };
-  if (config.auth?.bearerToken && gatewayHeaders["X-Athena-Auth-Bearer-Token"] === void 0 && gatewayHeaders["x-athena-auth-bearer-token"] === void 0) {
-    gatewayHeaders["X-Athena-Auth-Bearer-Token"] = config.auth.bearerToken;
+  if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(gatewayHeaders, "X-Athena-Auth-Bearer-Token")) {
+    gatewayHeaders["X-Athena-Auth-Bearer-Token"] = normalizedAuthConfig.bearerToken;
+  }
+  if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(gatewayHeaders, "Cookie")) {
+    gatewayHeaders.Cookie = normalizedAuthConfig.cookie;
+  }
+  if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(gatewayHeaders, "X-Athena-Auth-Session-Token")) {
+    gatewayHeaders["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
   }
   const gateway = createAthenaGatewayClient({
     baseUrl: config.baseUrl,
     apiKey: config.apiKey,
     client: config.client,
+    userId: config.userId,
+    organizationId: config.organizationId,
+    forceNoCache: config.forceNoCache,
     backend: config.backend,
     headers: gatewayHeaders
   });
   const formatGatewayResult = createResultFormatter(config.experimental);
   const queryTracer = createQueryTracer(config.experimental);
-  const auth = createAuthClient(normalizeAuthClientConfig(config.auth, config.authUrl));
+  const auth = createAuthClient({
+    ...normalizedAuthConfig ?? {},
+    ...config.forceNoCache ? { forceNoCache: true } : {}
+  });
   function from(tableOrModel, options) {
     if (isAthenaModelTarget(tableOrModel)) {
       if (options?.schema !== void 0) {
@@ -8263,17 +9296,160 @@ function createClientFromConfig(config) {
     queryTracer
   );
   const db = createDbModule({ from, rpc, query });
+  const chat = createChatModule({
+    baseUrl: config.chatUrl,
+    apiKey: config.apiKey,
+    client: config.client,
+    headers: config.headers,
+    bearerToken: normalizedAuthConfig?.bearerToken,
+    cookie: normalizedAuthConfig?.cookie,
+    sessionToken: normalizedAuthConfig?.sessionToken,
+    forceNoCache: config.forceNoCache,
+    wsUrl: config.chatWsUrl,
+    webSocketFactory: config.chat?.webSocketFactory ?? void 0
+  });
+  const request2 = async (options) => {
+    const method = options.method ?? "GET";
+    const responseType = options.responseType ?? "json";
+    const service = options.service ?? "db";
+    const baseUrlByService = {
+      db: config.baseUrl,
+      auth: config.authUrl,
+      chat: config.chatUrl,
+      storage: config.storageUrl
+    };
+    const resolvedBaseUrl = options.url ?? baseUrlByService[service];
+    if (!resolvedBaseUrl) {
+      throw new Error(
+        `Athena ${service} base URL is not configured. Pass createClient({ url }) for unified routing or set the service-specific URL first.`
+      );
+    }
+    const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(resolvedBaseUrl, {
+      label: `Athena ${service} base URL`
+    });
+    const normalizedPath = options.url ? "" : (() => {
+      const path = options.path?.trim();
+      if (!path) {
+        throw new Error("client.request(...) requires either an absolute url or a non-empty path.");
+      }
+      return path.startsWith("/") ? path : `/${path}`;
+    })();
+    const targetUrl = options.url ? `${normalizedBaseUrl}${toRequestQueryString(options.query)}` : `${normalizedBaseUrl}${normalizedPath}${toRequestQueryString(options.query)}`;
+    const headers = {
+      "X-Athena-Sdk": buildSdkHeaderValue(SDK_NAME4),
+      ...config.headers ?? {},
+      ...options.headers ?? {}
+    };
+    if (service !== "auth") {
+      headers.apikey = headers.apikey ?? config.apiKey;
+      headers["x-api-key"] = headers["x-api-key"] ?? config.apiKey;
+      if (config.client && !hasHeaderIgnoreCase(headers, "X-Athena-Client")) {
+        headers["X-Athena-Client"] = config.client;
+      }
+      if (config.userId && !hasHeaderIgnoreCase(headers, "X-User-Id")) {
+        headers["X-User-Id"] = config.userId;
+      }
+      if (config.organizationId && !hasHeaderIgnoreCase(headers, "X-Organization-Id")) {
+        headers["X-Organization-Id"] = config.organizationId;
+      }
+      if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+        headers["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
+      }
+      if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Bearer-Token")) {
+        headers["X-Athena-Auth-Bearer-Token"] = normalizedAuthConfig.bearerToken;
+      }
+      if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+        headers.Cookie = normalizedAuthConfig.cookie;
+      }
+    } else {
+      const authApiKey = normalizedAuthConfig?.apiKey ?? config.apiKey;
+      if (authApiKey && !hasHeaderIgnoreCase(headers, "x-api-key")) {
+        headers.apikey = headers.apikey ?? authApiKey;
+        headers["x-api-key"] = headers["x-api-key"] ?? authApiKey;
+      }
+      if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(headers, "Authorization")) {
+        headers.Authorization = `Bearer ${normalizedAuthConfig.bearerToken}`;
+      }
+      if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(headers, "Cookie")) {
+        headers.Cookie = normalizedAuthConfig.cookie;
+      }
+      if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(headers, "X-Athena-Auth-Session-Token")) {
+        headers["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
+      }
+    }
+    const shouldSendJsonBody = options.body !== void 0 && options.body !== null && !(options.body instanceof FormData) && !(options.body instanceof Blob) && !(options.body instanceof URLSearchParams) && !(options.body instanceof ArrayBuffer) && !ArrayBuffer.isView(options.body) && typeof options.body !== "string";
+    if (shouldSendJsonBody && !hasHeaderIgnoreCase(headers, "Content-Type")) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(targetUrl, {
+      method,
+      headers,
+      body: options.body === void 0 || options.body === null ? void 0 : shouldSendJsonBody ? JSON.stringify(options.body) : options.body,
+      signal: options.signal,
+      credentials: options.credentials
+    });
+    if (responseType === "response") {
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: null,
+        raw: response
+      };
+    }
+    const rawText = await response.text();
+    const parsed = responseType === "text" ? rawText : parseArbitraryResponseBody(rawText, response.headers.get("content-type"));
+    return {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      data: parsed,
+      raw: response
+    };
+  };
+  const withContext = (context) => createClientFromInput(
+    mergeClientOverrideOptions(sourceConfig, toClientContextOverrides(context))
+  );
+  const withSession = (session, options) => createClientFromInput(
+    mergeClientOverrideOptions(
+      sourceConfig,
+      toClientContextOverrides(resolveSessionContextOptions(session, options))
+    )
+  );
+  const authWithOptions = (options) => createClientFromInput(mergeClientOverrideOptions(sourceConfig, options));
   const sdkClient = {
     from,
     db,
     rpc,
     query,
+    request: request2,
     verifyConnection: gateway.verifyConnection,
-    auth: auth.auth
+    auth: auth.auth,
+    chat,
+    withContext,
+    withSession,
+    withOptions: authWithOptions
   };
   if (config.experimental?.athenaStorageBackend) {
+    const storageWithContext = (context) => createClientFromInput(
+      mergeClientOverrideOptions(sourceConfig, toClientContextOverrides(context))
+    );
+    const storageWithSession = (session, options) => createClientFromInput(
+      mergeClientOverrideOptions(
+        sourceConfig,
+        toClientContextOverrides(resolveSessionContextOptions(session, options))
+      )
+    );
+    const storageWithOptions = (options) => createClientFromInput(
+      mergeClientOverrideOptions(sourceConfig, options)
+    );
     const storageClient = {
       ...sdkClient,
+      withContext: storageWithContext,
+      withSession: storageWithSession,
+      withOptions: storageWithOptions,
       storage: createStorageModule(gateway, {
         ...config.experimental.storage,
         ...config.storageUrl ? {
@@ -8289,38 +9465,46 @@ function createClientFromConfig(config) {
 var AthenaClient = class {
   /** Create a fluent builder for a strongly-typed Athena SDK client. */
   static builder() {
-    return createAthenaClientBuilder((config) => createClientFromConfig(resolveCreateClientConfig(config)));
-  }
-  /** Build a client from process environment variables. */
-  static fromEnvironment() {
-    const url = process.env.ATHENA_URL;
-    const gatewayUrl = process.env.ATHENA_DB_URL ?? process.env.ATHENA_GATEWAY_URL;
-    const authUrl = process.env.ATHENA_AUTH_URL;
-    const storageUrl = process.env.ATHENA_STORAGE_URL;
-    const key = process.env.ATHENA_API_KEY ?? process.env.ATHENA_GATEWAY_API_KEY;
+    return createAthenaClientBuilder((config) => createClientFromInput(config));
+  }
+  static fromEnvironment(options = {}) {
+    const env = options.env ?? process.env;
+    const url = options.url ?? readFirstEnvValue(env, ATHENA_ENV_URL_KEYS);
+    const gatewayUrl = options.gatewayUrl ?? readFirstEnvValue(env, ATHENA_ENV_GATEWAY_URL_KEYS);
+    const authUrl = options.authUrl ?? readFirstEnvValue(env, ATHENA_ENV_AUTH_URL_KEYS);
+    const chatUrl = options.chatUrl ?? readFirstEnvValue(env, ATHENA_ENV_CHAT_URL_KEYS);
+    const chatWsUrl = options.chatWsUrl ?? readFirstEnvValue(env, ATHENA_ENV_CHAT_WS_URL_KEYS);
+    const storageUrl = options.storageUrl ?? readFirstEnvValue(env, ATHENA_ENV_STORAGE_URL_KEYS);
+    const key = options.key ?? readFirstEnvValue(env, ATHENA_ENV_KEY_KEYS);
+    const client = options.client ?? readFirstEnvValue(env, ATHENA_ENV_CLIENT_KEYS);
     if (!url && !gatewayUrl || !key) {
       throw new Error(
-        "ATHENA_API_KEY plus ATHENA_URL or ATHENA_GATEWAY_URL (optionally ATHENA_DB_URL, ATHENA_AUTH_URL, ATHENA_STORAGE_URL) are required"
+        "AthenaClient.fromEnvironment() requires an API key plus a public or gateway URL. Supported aliases include ATHENA_API_KEY, NEXT_PUBLIC_ATHENA_API_KEY, ATHENA_GATEWAY_API_KEY, X_API_KEY, ATHENA_URL, NEXT_PUBLIC_ATHENA_URL, ATHENA_GATEWAY_URL, and ATHENA_DB_URL."
       );
     }
+    const { env: _env, ...clientOptions } = options;
     return createClient({
+      ...clientOptions,
       url,
       gatewayUrl,
       authUrl,
+      chatUrl,
+      chatWsUrl,
       storageUrl,
-      key
+      key,
+      client
     });
   }
 };
 function createClient(configOrUrl, apiKey, options) {
   if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
-    return createClientFromConfig(resolveCreateClientConfig({
+    return createClientFromInput({
       url: configOrUrl,
       key: apiKey ?? "",
       ...options
-    }));
+    });
   }
-  return createClientFromConfig(resolveCreateClientConfig(configOrUrl));
+  return createClientFromInput(configOrUrl);
 }
 
 // src/gateway/types.ts
@@ -8351,7 +9535,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -8360,7 +9544,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord10(source)) {
+  if (!isRecord11(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -8686,6 +9870,9 @@ function createColumnsBuilder(name, mappedName, schemaName, columns) {
       resolveTableTarget(name, mappedName, normalizedSchemaName);
       return createColumnsBuilder(name, mappedName, normalizedSchemaName, columns);
     },
+    withoutPrimaryKey() {
+      return finalizeTable(name, mappedName, schemaName, columns, []);
+    },
     primaryKey(...keys) {
       return finalizeTable(name, mappedName, schemaName, columns, keys);
     }
@@ -8737,6 +9924,59 @@ var TenantHeaderMapper = class {
     return Object.keys(headers).length > 0 ? headers : void 0;
   }
 };
+function normalizeOptionalString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : void 0;
+}
+function readHeaderBagValue2(headers, targetKey) {
+  if (!headers) {
+    return void 0;
+  }
+  if (typeof headers.get === "function") {
+    return normalizeOptionalString2(headers.get(targetKey));
+  }
+  const normalizedTargetKey = targetKey.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== normalizedTargetKey) {
+      continue;
+    }
+    if (typeof value === "string") {
+      return normalizeOptionalString2(value);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function resolveSessionContextOptions2(session, options) {
+  const sessionToken = normalizeOptionalString2(session?.session?.token);
+  const requestCookie = readHeaderBagValue2(options?.requestHeaders, "cookie") ?? readHeaderBagValue2(options?.headers, "cookie");
+  const authInput = options?.auth;
+  const resolvedUserId = options?.userId !== void 0 ? options.userId : session?.user?.id;
+  const resolvedOrganizationId = options?.organizationId !== void 0 ? options.organizationId : session?.session?.activeOrganizationId;
+  const resolvedBearerToken = authInput?.bearerToken !== void 0 ? authInput.bearerToken : sessionToken;
+  const resolvedSessionToken = authInput?.sessionToken !== void 0 ? authInput.sessionToken : sessionToken;
+  const resolvedCookie = authInput?.cookie !== void 0 ? authInput.cookie : requestCookie;
+  const auth = authInput !== void 0 || resolvedBearerToken !== void 0 || resolvedSessionToken !== void 0 || resolvedCookie !== void 0 ? {
+    ...authInput ?? {},
+    ...resolvedBearerToken !== void 0 ? { bearerToken: resolvedBearerToken } : {},
+    ...resolvedSessionToken !== void 0 ? { sessionToken: resolvedSessionToken } : {},
+    ...resolvedCookie !== void 0 ? { cookie: resolvedCookie } : {},
+    headers: authInput?.headers ? { ...authInput.headers } : void 0
+  } : void 0;
+  if (resolvedUserId === void 0 && resolvedOrganizationId === void 0 && options?.forceNoCache === void 0 && !options?.headers && !auth) {
+    return void 0;
+  }
+  return {
+    userId: resolvedUserId,
+    organizationId: resolvedOrganizationId,
+    forceNoCache: options?.forceNoCache,
+    headers: options?.headers ? { ...options.headers } : void 0,
+    auth
+  };
+}
 var RegistryNavigator = class {
   constructor(registry) {
     this.registry = registry;
@@ -8788,12 +10028,22 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
       backend: input.options?.backend,
       client: input.options?.client,
       headers: input.options?.headers,
+      forceNoCache: input.options?.forceNoCache,
+      userId: input.options?.userId,
+      organizationId: input.options?.organizationId,
+      auth: input.options?.auth,
+      tenantKeyMap,
+      tenantContext,
       experimental: input.options?.experimental
     };
     this.baseClient = createClient(this.url, this.apiKey, {
       backend: this.clientOptions.backend,
       client: this.clientOptions.client,
       headers: this.tenantHeaderMapper.apply(this.clientOptions.headers, tenantContext),
+      forceNoCache: this.clientOptions.forceNoCache,
+      userId: this.clientOptions.userId,
+      organizationId: this.clientOptions.organizationId,
+      auth: this.clientOptions.auth,
       experimental: this.clientOptions.experimental
     });
     this.db = this.baseClient.db;
@@ -8808,9 +10058,46 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
   query(query, options) {
     return this.baseClient.query(query, options);
   }
+  request(options) {
+    return this.baseClient.request(options);
+  }
   verifyConnection(options) {
     return this.baseClient.verifyConnection(options);
   }
+  withContext(context) {
+    const headers = {
+      ...this.clientOptions.headers ?? {},
+      ...context?.headers ?? {}
+    };
+    const auth = this.clientOptions.auth || context?.auth ? {
+      ...this.clientOptions.auth ?? {},
+      ...context?.auth ?? {},
+      headers: this.clientOptions.auth?.headers || context?.auth?.headers ? {
+        ...this.clientOptions.auth?.headers ?? {},
+        ...context?.auth?.headers ?? {}
+      } : void 0
+    } : void 0;
+    return new _TypedAthenaClientImpl({
+      registry: this.registry,
+      url: this.url,
+      apiKey: this.apiKey,
+      options: {
+        ...this.clientOptions,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        auth,
+        tenantKeyMap: this.tenantKeyMap,
+        tenantContext: {
+          ...this.tenantContext
+        },
+        ...context?.userId !== void 0 ? { userId: context.userId } : {},
+        ...context?.organizationId !== void 0 ? { organizationId: context.organizationId } : {},
+        ...context?.forceNoCache !== void 0 ? { forceNoCache: context.forceNoCache } : {}
+      }
+    });
+  }
+  withSession(session, options) {
+    return this.withContext(resolveSessionContextOptions2(session, options));
+  }
   withTenantContext(context) {
     return new _TypedAthenaClientImpl({
       registry: this.registry,
@@ -9306,6 +10593,77 @@ function resolveProviderSchemas(providerConfig) {
   return [...DEFAULT_POSTGRES_SCHEMAS];
 }
 
+// src/generator/table-selection.ts
+function normalizeTableSelector(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeTableSelection(value) {
+  if (typeof value === "string") {
+    return Array.from(
+      new Set(
+        value.split(",").map(normalizeTableSelector).filter((entry) => Boolean(entry))
+      )
+    );
+  }
+  if (Array.isArray(value)) {
+    return Array.from(
+      new Set(
+        value.map((entry) => typeof entry === "string" ? normalizeTableSelector(entry) : void 0).filter((entry) => Boolean(entry))
+      )
+    );
+  }
+  return [];
+}
+function matchesTableSelector(schemaName, tableName, selector) {
+  const separatorIndex = selector.indexOf(".");
+  if (separatorIndex < 0) {
+    return tableName === selector;
+  }
+  const selectorSchema = selector.slice(0, separatorIndex).trim();
+  const selectorTable = selector.slice(separatorIndex + 1).trim();
+  return selectorSchema === schemaName && selectorTable === tableName;
+}
+function shouldKeepTable(schemaName, tableName, filter) {
+  const included = filter.includeTables.length === 0 || filter.includeTables.some((selector) => matchesTableSelector(schemaName, tableName, selector));
+  if (!included) {
+    return false;
+  }
+  return !filter.excludeTables.some((selector) => matchesTableSelector(schemaName, tableName, selector));
+}
+function hasTableFilters(filter) {
+  return filter.includeTables.length > 0 || filter.excludeTables.length > 0;
+}
+function filterIntrospectionSnapshot(snapshot, filter) {
+  if (!hasTableFilters(filter)) {
+    return snapshot;
+  }
+  const schemas = {};
+  for (const [schemaName, schema] of Object.entries(snapshot.schemas)) {
+    const tables = Object.fromEntries(
+      Object.entries(schema.tables).filter(([tableName]) => shouldKeepTable(schemaName, tableName, filter))
+    );
+    if (Object.keys(tables).length === 0) {
+      continue;
+    }
+    schemas[schemaName] = {
+      ...schema,
+      tables
+    };
+  }
+  if (Object.keys(schemas).length === 0) {
+    const includeLabel = filter.includeTables.length > 0 ? ` includeTables=${filter.includeTables.join(", ")}` : "";
+    const excludeLabel = filter.excludeTables.length > 0 ? ` excludeTables=${filter.excludeTables.join(", ")}` : "";
+    throw new Error(
+      `Generator table filters matched no tables after schema selection.${includeLabel}${excludeLabel}`
+    );
+  }
+  return {
+    ...snapshot,
+    schemas
+  };
+}
+
 // src/generator/config.ts
 var POSTGRES_PROTOCOLS = /* @__PURE__ */ new Set(["postgres:", "postgresql:"]);
 var DEFAULT_CONFIG_CANDIDATES = [
@@ -9316,13 +10674,20 @@ var DEFAULT_CONFIG_CANDIDATES = [
   ".athena.config.ts",
   ".athena.config.js"
 ];
-var DEFAULT_TARGETS = {
+var LEGACY_DEFAULT_TARGETS = {
   model: "athena/models/{schema_kebab}/{model_kebab}.ts",
   schema: "athena/schemas/{schema_kebab}.ts",
   database: "athena/relations.ts",
   registry: "athena/config.ts"
 };
-var DEFAULT_OUTPUT_FORMAT = "define-model";
+var ATHENA_DIRECT_TARGETS = {
+  model: "athena/models/{schema_kebab}/{model_kebab}.ts",
+  schema: "athena/schemas/{schema_kebab}.ts",
+  database: "athena/relations.ts",
+  registry: "athena/registry.generated.ts"
+};
+var DEFAULT_OUTPUT_FORMAT = "table-builder";
+var DEFAULT_OUTPUT_PRESET = "athena-direct";
 var DEFAULT_NAMING = {
   modelType: "pascal",
   modelConst: "camel",
@@ -9341,6 +10706,10 @@ var DEFAULT_EXPERIMENTAL_FLAGS = {
 var DEFAULT_INTERNAL_CONFIG = {
   schemaVersion: 1
 };
+var DEFAULT_FILTER_CONFIG = {
+  includeTables: [],
+  excludeTables: []
+};
 var PROJECT_ENV_FILENAMES = [".env", ".env.local"];
 var DIRECT_CONNECTION_STRING_ENV_KEYS = [
   "ATHENA_GENERATOR_PG_URL",
@@ -9359,10 +10728,13 @@ var GATEWAY_API_KEY_ENV_KEYS = [
 ];
 var GENERATOR_SCHEMA_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMAS"];
 var OUTPUT_FORMAT_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_FORMAT"];
+var OUTPUT_PRESET_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_PRESET"];
 var MODEL_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_MODEL_TARGET"];
 var SCHEMA_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMA_TARGET"];
 var DATABASE_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_DATABASE_TARGET"];
 var REGISTRY_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_REGISTRY_TARGET"];
+var TABLES_ENV_KEYS = ["ATHENA_GENERATOR_TABLES"];
+var EXCLUDE_TABLES_ENV_KEYS = ["ATHENA_GENERATOR_EXCLUDE_TABLES"];
 var PLACEHOLDER_MAP_ENV_KEYS = ["ATHENA_GENERATOR_PLACEHOLDER_MAP"];
 var MODEL_TYPE_ENV_KEYS = ["ATHENA_GENERATOR_MODEL_TYPE", "ATHENA_GENERATOR_MODEL_STYLE"];
 var MODEL_CONST_ENV_KEYS = ["ATHENA_GENERATOR_MODEL_CONST"];
@@ -9377,7 +10749,12 @@ var SCYLLA_PROVIDER_CONTRACTS_ENV_KEYS = ["ATHENA_GENERATOR_SCYLLA_PROVIDER_CONT
 var ENV_ONLY_CONFIG_PATH = "[environment defaults]";
 var NAMING_STYLE_VALUES = ["preserve", "camel", "pascal", "snake", "kebab"];
 var OUTPUT_FORMAT_VALUES = ["define-model", "table-builder"];
+var OUTPUT_PRESET_VALUES = ["legacy", "athena-direct"];
 var BACKEND_TYPE_VALUES = ["athena", "postgrest", "postgresql", "scylladb"];
+var OUTPUT_PRESET_TARGETS = {
+  legacy: LEGACY_DEFAULT_TARGETS,
+  "athena-direct": ATHENA_DIRECT_TARGETS
+};
 function normalizeRawEnvValue(rawValue) {
   if (rawValue.startsWith('"') && rawValue.endsWith('"') && rawValue.length >= 2) {
     const inner = rawValue.slice(1, -1);
@@ -9513,7 +10890,7 @@ function deriveDatabaseNameFromConnectionString(connectionString) {
     return void 0;
   }
 }
-function normalizeOptionalString(value, fallbackKeys) {
+function normalizeOptionalString3(value, fallbackKeys) {
   if (typeof value === "string") {
     const trimmed = value.trim();
     if (trimmed.length > 0) {
@@ -9523,7 +10900,7 @@ function normalizeOptionalString(value, fallbackKeys) {
   return resolveFallbackValue(fallbackKeys);
 }
 function normalizeRequiredString(value, fieldLabel, fallbackKeys) {
-  const resolved = normalizeOptionalString(value, fallbackKeys);
+  const resolved = normalizeOptionalString3(value, fallbackKeys);
   if (resolved) {
     return resolved;
   }
@@ -9584,11 +10961,19 @@ function normalizeExperimentalFlags(input) {
     )
   };
 }
+function normalizeFilterConfig(input) {
+  return {
+    includeTables: normalizeTableSelection(input?.includeTables),
+    excludeTables: normalizeTableSelection(input?.excludeTables)
+  };
+}
 function normalizeOutputConfig(output) {
+  const preset = output?.preset ?? DEFAULT_OUTPUT_PRESET;
   return {
     format: output?.format ?? DEFAULT_OUTPUT_FORMAT,
+    preset,
     targets: {
-      ...DEFAULT_TARGETS,
+      ...OUTPUT_PRESET_TARGETS[preset],
       ...output?.targets ?? {}
     },
     placeholderMap: {
@@ -9603,7 +10988,7 @@ function normalizeProviderConfig(provider) {
       "provider.connectionString",
       DIRECT_CONNECTION_STRING_ENV_KEYS
     );
-    const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? deriveDatabaseNameFromConnectionString(connectionString);
+    const database = normalizeOptionalString3(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? deriveDatabaseNameFromConnectionString(connectionString);
     return {
       ...provider,
       connectionString: applyPostgresPasswordFallback(connectionString),
@@ -9622,7 +11007,7 @@ function normalizeProviderConfig(provider) {
       "provider.apiKey",
       GATEWAY_API_KEY_ENV_KEYS
     );
-    const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? "postgres";
+    const database = normalizeOptionalString3(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? "postgres";
     return {
       ...provider,
       gatewayUrl,
@@ -9637,7 +11022,7 @@ function normalizeProviderConfig(provider) {
         "Generator config is missing provider.contactPoints for scylla direct mode."
       );
     }
-    const keyspace = normalizeOptionalString(provider.keyspace, []);
+    const keyspace = normalizeOptionalString3(provider.keyspace, []);
     if (!keyspace) {
       throw new Error(
         "Generator config is missing provider.keyspace for scylla direct mode."
@@ -9648,7 +11033,7 @@ function normalizeProviderConfig(provider) {
       mode: "direct",
       contactPoints: provider.contactPoints.slice(),
       keyspace,
-      datacenter: normalizeOptionalString(provider.datacenter, [])
+      datacenter: normalizeOptionalString3(provider.datacenter, [])
     };
   }
   return provider;
@@ -9668,6 +11053,10 @@ function normalizeGeneratorConfig(input) {
       ...DEFAULT_NAMING,
       ...input.naming ?? {}
     },
+    filter: {
+      ...DEFAULT_FILTER_CONFIG,
+      ...normalizeFilterConfig(input.filter)
+    },
     features: normalizeFeatureFlags(input.features),
     experimental: normalizeExperimentalFlags(input.experimental),
     internal: {
@@ -9731,16 +11120,18 @@ function importConfigModule(moduleSpecifier) {
 }
 function buildEnvironmentOutputConfig() {
   const format = resolveOptionalOneOf(OUTPUT_FORMAT_ENV_KEYS, OUTPUT_FORMAT_VALUES);
+  const preset = resolveOptionalOneOf(OUTPUT_PRESET_ENV_KEYS, OUTPUT_PRESET_VALUES);
   const modelTarget = resolveFallbackValue(MODEL_TARGET_ENV_KEYS);
   const schemaTarget = resolveFallbackValue(SCHEMA_TARGET_ENV_KEYS);
   const databaseTarget = resolveFallbackValue(DATABASE_TARGET_ENV_KEYS);
   const registryTarget = resolveFallbackValue(REGISTRY_TARGET_ENV_KEYS);
   const placeholderMap = resolveOptionalJson(PLACEHOLDER_MAP_ENV_KEYS);
-  if (format === void 0 && modelTarget === void 0 && schemaTarget === void 0 && databaseTarget === void 0 && registryTarget === void 0 && placeholderMap === void 0) {
+  if (format === void 0 && preset === void 0 && modelTarget === void 0 && schemaTarget === void 0 && databaseTarget === void 0 && registryTarget === void 0 && placeholderMap === void 0) {
     return void 0;
   }
   return {
     format,
+    preset,
     targets: {
       ...modelTarget ? { model: modelTarget } : {},
       ...schemaTarget ? { schema: schemaTarget } : {},
@@ -9750,6 +11141,17 @@ function buildEnvironmentOutputConfig() {
     placeholderMap
   };
 }
+function buildEnvironmentFilterConfig() {
+  const includeTables = resolveFallbackValue(TABLES_ENV_KEYS);
+  const excludeTables = resolveFallbackValue(EXCLUDE_TABLES_ENV_KEYS);
+  if (includeTables === void 0 && excludeTables === void 0) {
+    return void 0;
+  }
+  return {
+    ...includeTables !== void 0 ? { includeTables } : {},
+    ...excludeTables !== void 0 ? { excludeTables } : {}
+  };
+}
 function buildEnvironmentNamingConfig() {
   const modelType = resolveOptionalOneOf(MODEL_TYPE_ENV_KEYS, NAMING_STYLE_VALUES);
   const modelConst = resolveOptionalOneOf(MODEL_CONST_ENV_KEYS, NAMING_STYLE_VALUES);
@@ -9796,7 +11198,7 @@ function buildEnvironmentProviderConfig() {
       kind: "postgres",
       mode: "direct",
       connectionString: directConnectionString,
-      database: normalizeOptionalString(void 0, POSTGRES_DATABASE_ENV_KEYS),
+      database: normalizeOptionalString3(void 0, POSTGRES_DATABASE_ENV_KEYS),
       schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS))
     };
   }
@@ -9809,7 +11211,7 @@ function buildEnvironmentProviderConfig() {
       mode: "gateway",
       gatewayUrl,
       apiKey,
-      database: normalizeOptionalString(void 0, POSTGRES_DATABASE_ENV_KEYS),
+      database: normalizeOptionalString3(void 0, POSTGRES_DATABASE_ENV_KEYS),
       schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS)),
       backend
     };
@@ -9825,6 +11227,7 @@ function createEnvironmentGeneratorConfig() {
     provider,
     output: buildEnvironmentOutputConfig(),
     naming: buildEnvironmentNamingConfig(),
+    filter: buildEnvironmentFilterConfig(),
     features: buildEnvironmentFeatureFlags(),
     experimental: buildEnvironmentExperimentalFlags()
   };
@@ -10310,7 +11713,7 @@ ${schemaEntries}
     content
   };
 }
-function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName, generatedAt, outputFormat, schemaVersion) {
+function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName, generatedAt, outputPreset, outputFormat, schemaVersion) {
   const databaseImportPath = toModuleImportPath(registryPath, databasePath);
   const content = `import { defineRegistry } from '@xylex-group/athena'
 import { ${databaseConstName} } from '${databaseImportPath}'
@@ -10319,6 +11722,7 @@ export const __athena_schema_meta = {
   schemaVersion: ${schemaVersion},
   generatedAt: ${escapeStringLiteral(generatedAt)},
   database: ${escapeStringLiteral(databaseName)},
+  outputPreset: ${escapeStringLiteral(outputPreset)},
   outputFormat: ${escapeStringLiteral(outputFormat)},
 } as const
 
@@ -10488,6 +11892,7 @@ function composeGeneratorArtifacts(input) {
         toSafeIdentifier("registry", config.naming.registryConst, "registry"),
         databaseName,
         snapshot.generatedAt,
+        config.output.preset,
         config.output.format,
         config.internal.schemaVersion
       )
@@ -10593,7 +11998,7 @@ export const ${descriptor.tableConstName} = table(${escapeStringLiteral(descript
   .columns({
 ${columnLines}
   })
-  .primaryKey(${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")})
+  ${descriptor.table.primaryKey.length > 0 ? `.primaryKey(${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")})` : ".withoutPrimaryKey()"}
 ${relationsAssignment ? `${relationsAssignment}` : ""}
 export type ${descriptor.rowTypeName} = RowOf<typeof ${descriptor.tableConstName}>
 export type ${descriptor.insertTypeName} = InsertOf<typeof ${descriptor.tableConstName}>
@@ -10690,11 +12095,12 @@ ${nullableLines}
 }
 function generateArtifactsFromSnapshot(snapshot, config) {
   const normalizedConfig = "internal" in config ? config : normalizeGeneratorConfig(config);
+  const filteredSnapshot = filterIntrospectionSnapshot(snapshot, normalizedConfig.filter);
   if (normalizedConfig.output.format === "table-builder") {
-    return generateTableBuilderArtifactsFromSnapshot(snapshot, normalizedConfig);
+    return generateTableBuilderArtifactsFromSnapshot(filteredSnapshot, normalizedConfig);
   }
   return composeGeneratorArtifacts({
-    snapshot,
+    snapshot: filteredSnapshot,
     config: normalizedConfig,
     createModelDescriptor({ providerName, databaseName, schemaName, tableName, table: table2 }) {
       const modelConstName = toSafeIdentifier(
@@ -10724,7 +12130,7 @@ function generateArtifactsFromSnapshot(snapshot, config) {
         table: table2
       };
     },
-    renderModelArtifact: (descriptor) => renderModelArtifact2(snapshot.database, descriptor, normalizedConfig)
+    renderModelArtifact: (descriptor) => renderModelArtifact2(filteredSnapshot.database, descriptor, normalizedConfig)
   });
 }
 
@@ -10844,16 +12250,25 @@ async function fileExists(path) {
 }
 async function writeArtifacts(files, cwd) {
   const writtenFiles = [];
+  const skippedFiles = [];
   for (const file of files) {
     const absolutePath = path.resolve(cwd, file.path);
     if (!canOverwriteArtifact(file) && await fileExists(absolutePath)) {
+      skippedFiles.push({
+        kind: file.kind,
+        path: file.path,
+        reason: "protected-existing-file"
+      });
       continue;
     }
     await promises.mkdir(path.dirname(absolutePath), { recursive: true });
     await promises.writeFile(absolutePath, file.content, "utf8");
     writtenFiles.push(file.path);
   }
-  return writtenFiles;
+  return {
+    writtenFiles,
+    skippedFiles
+  };
 }
 async function runSchemaGenerator(options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -10867,12 +12282,13 @@ async function runSchemaGenerator(options = {}) {
     schemas: resolveProviderSchemas(config.provider)
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
-  const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
+  const writeResult = options.dryRun ? { writtenFiles: [], skippedFiles: [] } : await writeArtifacts(generated.files, cwd);
   return {
     ...generated,
     configPath,
     config,
-    writtenFiles
+    writtenFiles: writeResult.writtenFiles,
+    skippedFiles: writeResult.skippedFiles
   };
 }
 
@@ -10941,15 +12357,15 @@ function readCookieFromHeaders(headers, name) {
   }
   return parseCookies(cookieHeader).get(name);
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveSessionCandidate(value) {
-  if (!isRecord11(value)) {
+  if (!isRecord12(value)) {
     return null;
   }
-  const session = isRecord11(value.session) ? value.session : void 0;
-  const user = isRecord11(value.user) ? value.user : void 0;
+  const session = isRecord12(value.session) ? value.session : void 0;
+  const user = isRecord12(value.user) ? value.user : void 0;
   if (session && typeof session.token === "string" && session.token.length > 0 && user) {
     return {
       session,
@@ -10959,7 +12375,7 @@ function resolveSessionCandidate(value) {
   return null;
 }
 function inferSessionPair(returned) {
-  return resolveSessionCandidate(returned) ?? (isRecord11(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord11(returned) ? resolveSessionCandidate(returned.session) : null);
+  return resolveSessionCandidate(returned) ?? (isRecord12(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord12(returned) ? resolveSessionCandidate(returned.session) : null);
 }
 function resolveResponseHeaders(ctx) {
   if (ctx.context.responseHeaders instanceof Headers) {
@@ -10982,23 +12398,23 @@ function normalizeBasePath(basePath) {
 function isDynamicBaseURLConfig2(baseURL) {
   return typeof baseURL === "object" && baseURL !== null && "allowedHosts" in baseURL && Array.isArray(baseURL.allowedHosts);
 }
-function getRequestUrl(request) {
+function getRequestUrl(request2) {
   try {
-    return new URL(request.url);
+    return new URL(request2.url);
   } catch {
     return new URL("http://localhost");
   }
 }
-function getRequestHost(request, url) {
-  const forwardedHost = request.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
-  const host = forwardedHost || request.headers.get("host") || url.host;
+function getRequestHost(request2, url) {
+  const forwardedHost = request2.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
+  const host = forwardedHost || request2.headers.get("host") || url.host;
   return host || null;
 }
-function getRequestProtocol(request, configuredProtocol, url) {
+function getRequestProtocol(request2, configuredProtocol, url) {
   if (configuredProtocol === "http" || configuredProtocol === "https") {
     return configuredProtocol;
   }
-  const forwardedProto = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
+  const forwardedProto = request2.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
   if (forwardedProto === "http" || forwardedProto === "https") {
     return forwardedProto;
   }
@@ -11007,12 +12423,12 @@ function getRequestProtocol(request, configuredProtocol, url) {
   }
   return "http";
 }
-function resolveRequestBaseURL(baseURL, request) {
+function resolveRequestBaseURL(baseURL, request2) {
   if (typeof baseURL === "string") {
     return normalizeBaseURL(baseURL);
   }
-  const requestUrl = getRequestUrl(request);
-  const host = getRequestHost(request, requestUrl);
+  const requestUrl = getRequestUrl(request2);
+  const host = getRequestHost(request2, requestUrl);
   if (!host) {
     return null;
   }
@@ -11022,7 +12438,7 @@ function resolveRequestBaseURL(baseURL, request) {
       return null;
     }
   }
-  const protocol = typeof baseURL === "object" && baseURL !== null ? getRequestProtocol(request, baseURL.protocol, requestUrl) : getRequestProtocol(request, void 0, requestUrl);
+  const protocol = typeof baseURL === "object" && baseURL !== null ? getRequestProtocol(request2, baseURL.protocol, requestUrl) : getRequestProtocol(request2, void 0, requestUrl);
   return `${protocol}://${host}`;
 }
 function getOrigin(baseURL) {
@@ -11035,16 +12451,16 @@ function getOrigin(baseURL) {
     return void 0;
   }
 }
-async function resolveTrustedOrigins(config, baseURL, request) {
-  const resolved = typeof config.trustedOrigins === "function" ? await config.trustedOrigins(request) : config.trustedOrigins ?? [];
+async function resolveTrustedOrigins(config, baseURL, request2) {
+  const resolved = typeof config.trustedOrigins === "function" ? await config.trustedOrigins(request2) : config.trustedOrigins ?? [];
   const values = [
     getOrigin(baseURL),
     ...resolved
   ];
   return Array.from(new Set(values.filter((value) => typeof value === "string" && value.length > 0)));
 }
-async function resolveTrustedProviders(config, request) {
-  const configured = typeof config.trustedProviders === "function" ? await config.trustedProviders(request) : config.trustedProviders ?? [];
+async function resolveTrustedProviders(config, request2) {
+  const configured = typeof config.trustedProviders === "function" ? await config.trustedProviders(request2) : config.trustedProviders ?? [];
   const values = [
     ...Object.keys(config.socialProviders ?? {}),
     ...configured
@@ -11169,9 +12585,9 @@ function athenaAuth(config) {
     }
     return ctx;
   };
-  const resolveRequestContext = async (request) => {
-    const requestUrl = getRequestUrl(request);
-    const resolvedBaseURL = resolveRequestBaseURL(config.baseURL, request);
+  const resolveRequestContext = async (request2) => {
+    const requestUrl = getRequestUrl(request2);
+    const resolvedBaseURL = resolveRequestBaseURL(config.baseURL, request2);
     if (!resolvedBaseURL) {
       throw new Error(
         isDynamicBaseURLConfig2(config.baseURL) ? "Could not resolve base URL from request. Check allowedHosts/baseURL." : "Could not resolve base URL from request."
@@ -11182,17 +12598,17 @@ function athenaAuth(config) {
       session: config.session,
       advanced: config.advanced
     });
-    const trustedOrigins = await resolveTrustedOrigins(config, resolvedBaseURL, request);
-    const trustedProviders = await resolveTrustedProviders(config, request);
+    const trustedOrigins = await resolveTrustedOrigins(config, resolvedBaseURL, request2);
+    const trustedProviders = await resolveTrustedProviders(config, request2);
     return {
       auth,
-      request,
+      request: request2,
       url: requestUrl,
       path: requestUrl.pathname,
       basePath: normalizedBasePath,
       baseURL: resolvedBaseURL,
       origin: getOrigin(resolvedBaseURL) ?? resolvedBaseURL,
-      headers: request.headers,
+      headers: request2.headers,
       cookies: requestCookies,
       trustedOrigins,
       trustedProviders,
@@ -11205,8 +12621,8 @@ function athenaAuth(config) {
       socialProviders: auth.socialProviders
     };
   };
-  const handler = async (request) => {
-    const requestContext = await resolveRequestContext(request);
+  const handler = async (request2) => {
+    const requestContext = await resolveRequestContext(request2);
     if (typeof config.handler !== "function") {
       return createJsonResponse(
         {
@@ -11227,7 +12643,7 @@ function athenaAuth(config) {
     const responseHeaders = new Headers(response.headers);
     await runAfterHooks({
       path: requestContext.path,
-      headers: request.headers,
+      headers: request2.headers,
       context: {
         responseHeaders,
         returned: result.returned,
@@ -11303,7 +12719,13 @@ function athenaAuth(config) {
   return auth;
 }
 
+exports.ATHENA_AUTH_ADMIN_LIMITS = ATHENA_AUTH_ADMIN_LIMITS;
 exports.ATHENA_AUTH_BASE_ERROR_CODES = ATHENA_AUTH_BASE_ERROR_CODES;
+exports.ATHENA_AUTH_MAX_ADMIN_JSON_BYTES = ATHENA_AUTH_MAX_ADMIN_JSON_BYTES;
+exports.ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH = ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH;
+exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = ATHENA_AUTH_MAX_TEMPLATE_VARIABLES;
+exports.ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH;
+exports.AthenaChatError = AthenaChatError;
 exports.AthenaClient = AthenaClient;
 exports.AthenaError = AthenaError;
 exports.AthenaErrorCategory = AthenaErrorCategory;
@@ -11317,6 +12739,7 @@ exports.DEFAULT_POSTGRES_SCHEMAS = DEFAULT_POSTGRES_SCHEMAS;
 exports.assertInt = assertInt;
 exports.athenaAuth = athenaAuth;
 exports.boolean = boolean;
+exports.chatSdkManifest = chatSdkManifest;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
 exports.createAuthClient = createAuthClient;
@@ -11333,6 +12756,7 @@ exports.defineModel = defineModel;
 exports.defineRegistry = defineRegistry;
 exports.defineSchema = defineSchema;
 exports.enumeration = enumeration;
+exports.filterIntrospectionSnapshot = filterIntrospectionSnapshot;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
@@ -11346,6 +12770,7 @@ exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeAthenaGatewayBaseUrl = normalizeAthenaGatewayBaseUrl;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
+exports.normalizeTableSelection = normalizeTableSelection;
 exports.number = number;
 exports.parseBooleanFlag = parseBooleanFlag2;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
@@ -11361,6 +12786,8 @@ exports.table = table;
 exports.toModelFormDefaults = toModelFormDefaults;
 exports.toModelPayload = toModelPayload;
 exports.unwrap = unwrap;
+exports.unwrapChatMessage = unwrapChatMessage;
+exports.unwrapChatRoom = unwrapChatRoom;
 exports.unwrapOne = unwrapOne;
 exports.unwrapRows = unwrapRows;
 exports.verifyAthenaGatewayUrl = verifyAthenaGatewayUrl;