@xylex-group/athena 2.8.2 → 2.10.0

package/dist/browser.js

@@ -660,8 +660,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;
   }
@@ -681,8 +681,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;
@@ -800,7 +800,7 @@ var getCookieCache = async (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.8.2"
+  version: "2.10.0"
 };
 
 // src/sdk-version.ts
@@ -813,6 +813,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 };
@@ -831,6 +832,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]);
@@ -989,6 +993,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 ?? {}
@@ -1042,11 +1047,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) {
@@ -1507,6 +1516,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) {
@@ -1736,6 +1784,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(/\/$/, "");
 }
@@ -1745,6 +1794,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 };
@@ -1800,6 +1852,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 {
@@ -1815,6 +1959,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
@@ -1828,16 +1973,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) {
@@ -2043,7 +2202,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(
@@ -2056,7 +2215,7 @@ function createAuthClient(config = {}) {
   };
   const postGeneric = (endpoint, input, options) => {
     const { payload, fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "POST",
@@ -2068,7 +2227,7 @@ function createAuthClient(config = {}) {
   };
   const getGeneric = (endpoint, input, options) => {
     const { fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "GET",
@@ -2080,7 +2239,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",
@@ -2098,11 +2257,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",
@@ -2264,6 +2508,7 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    requirePermission: (input, options) => requirePermission("/organization/has-permission", input, options),
     invitation: {
       cancel: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -2459,6 +2704,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,
@@ -2553,6 +2800,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)
       },
@@ -2597,7 +2845,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: {
@@ -2613,7 +2869,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: {
@@ -2653,7 +2917,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: {
@@ -2667,7 +2931,7 @@ function createAuthClient(config = {}) {
   };
   return {
     baseUrl: normalizedBaseUrl,
-    request,
+    request: request2,
     signIn: {
       email: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -2704,6 +2968,8 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    getUser,
+    requireSession,
     listSessions: (input, options) => executeGetWithCompatibleInput(
       resolvedConfig,
       { endpoint: "/list-sessions", method: "GET" },
@@ -3406,16 +3672,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) => {
@@ -3426,13 +3692,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,
@@ -5407,113 +5673,636 @@ function createStorageModule(gateway, runtimeOptions) {
   };
 }
 
-// src/client-builder.ts
-var DEFAULT_BACKEND = { type: "athena" };
-function toBackendConfig(value) {
-  if (!value) return DEFAULT_BACKEND;
-  return typeof value === "string" ? { type: value } : value;
-}
-function mergeHeaders(current, next) {
-  return {
-    ...current ?? {},
-    ...next
-  };
-}
-function mergeAuthClientConfig(current, next) {
-  const merged = {
-    ...current ?? {},
-    ...next
-  };
-  if (current?.headers || next.headers) {
-    merged.headers = mergeHeaders(current?.headers, next.headers ?? {});
+// 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;
   }
-  return merged;
+};
+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 mergeExperimentalOptions(current, next) {
-  const merged = {
-    ...current ?? {},
-    ...next
-  };
-  if (current?.traceQueries && typeof current.traceQueries === "object" && next.traceQueries && typeof next.traceQueries === "object") {
-    merged.traceQueries = {
-      ...current.traceQueries,
-      ...next.traceQueries
-    };
+function normalizeWsUrl(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
   }
-  if (current?.storage || next.storage) {
-    merged.storage = {
-      ...current?.storage ?? {},
-      ...next.storage ?? {}
-    };
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    throw new Error(`${label} must be a valid absolute ws(s) URL.`);
   }
-  return merged;
+  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 resolveBuilderReturn(builder, storageEnabled, strictEnabled) {
-  return builder;
+function isRecord7(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-var AthenaClientBuilderImpl = class {
-  constructor(buildClient) {
-    this.buildClient = buildClient;
+function normalizeHeaderValue3(value) {
+  return value ? value : void 0;
+}
+function parseResponseBody4(rawText, contentType) {
+  if (!rawText) {
+    return { parsed: null, parseFailed: false };
   }
-  rootUrl;
-  apiKey;
-  backendConfig = DEFAULT_BACKEND;
-  clientName;
-  defaultHeaders;
-  authConfig;
-  dbUrlOverride;
-  gatewayUrlOverride;
-  authUrlOverride;
-  storageUrlOverride;
-  experimentalOptions;
-  url(url) {
-    this.rootUrl = url;
-    return this;
+  const contentTypeSuggestsJson = contentType?.toLowerCase().includes("application/json") ?? false;
+  const looksJson = contentTypeSuggestsJson || rawText.startsWith("{") || rawText.startsWith("[");
+  if (!looksJson) {
+    return { parsed: rawText, parseFailed: false };
   }
-  key(apiKey) {
-    this.apiKey = apiKey;
-    return this;
+  try {
+    return { parsed: JSON.parse(rawText), parseFailed: false };
+  } catch {
+    return { parsed: rawText, parseFailed: true };
   }
-  backend(backend) {
-    this.backendConfig = toBackendConfig(backend);
-    return this;
+}
+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();
+      }
+    }
   }
-  client(clientName) {
-    this.clientName = clientName;
-    return this;
+  if (typeof payload === "string" && payload.trim().length > 0) {
+    return payload.trim();
   }
-  headers(headers) {
-    this.defaultHeaders = headers;
-    return this;
+  return fallback;
+}
+function encodePathSegment(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`${label} is required.`);
   }
-  auth(config) {
-    this.authConfig = mergeAuthClientConfig(this.authConfig, config);
-    return this;
+  return encodeURIComponent(normalized);
+}
+function encodeQuery(query) {
+  if (!query) {
+    return "";
   }
-  experimental(options) {
-    this.experimentalOptions = mergeExperimentalOptions(this.experimentalOptions, options);
-    if (options.athenaStorageBackend && options.typecheckColumns) {
-      return resolveBuilderReturn(this);
-    }
-    if (options.athenaStorageBackend) {
-      return resolveBuilderReturn(this);
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
     }
-    if (options.typecheckColumns) {
-      return resolveBuilderReturn(this);
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+      continue;
     }
-    return this;
+    params.set(key, String(value));
   }
-  options(options) {
-    if (options.client !== void 0) {
-      this.clientName = options.client;
+  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);
     }
-    if (options.backend !== void 0) {
-      this.backendConfig = toBackendConfig(options.backend);
+    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;
+      }
     }
-    if (options.headers !== void 0) {
-      this.defaultHeaders = mergeHeaders(this.defaultHeaders, options.headers);
+  }
+  return headers;
+}
+function withJsonBody(init, body) {
+  return {
+    ...init,
+    body: body === void 0 ? void 0 : JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...init.headers
     }
-    if (options.auth !== void 0) {
+  };
+}
+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) {
+  if (!value) return DEFAULT_BACKEND;
+  return typeof value === "string" ? { type: value } : value;
+}
+function mergeHeaders(current, next) {
+  return {
+    ...current ?? {},
+    ...next
+  };
+}
+function mergeAuthClientConfig(current, next) {
+  const merged = {
+    ...current ?? {},
+    ...next
+  };
+  if (current?.headers || next.headers) {
+    merged.headers = mergeHeaders(current?.headers, next.headers ?? {});
+  }
+  return merged;
+}
+function mergeExperimentalOptions(current, next) {
+  const merged = {
+    ...current ?? {},
+    ...next
+  };
+  if (current?.traceQueries && typeof current.traceQueries === "object" && next.traceQueries && typeof next.traceQueries === "object") {
+    merged.traceQueries = {
+      ...current.traceQueries,
+      ...next.traceQueries
+    };
+  }
+  if (current?.storage || next.storage) {
+    merged.storage = {
+      ...current?.storage ?? {},
+      ...next.storage ?? {}
+    };
+  }
+  return merged;
+}
+function resolveBuilderReturn(builder, storageEnabled, strictEnabled) {
+  return builder;
+}
+var AthenaClientBuilderImpl = class {
+  constructor(buildClient) {
+    this.buildClient = buildClient;
+  }
+  rootUrl;
+  apiKey;
+  backendConfig = DEFAULT_BACKEND;
+  clientName;
+  defaultUserId;
+  defaultOrganizationId;
+  forceNoCacheEnabled = false;
+  defaultHeaders;
+  authConfig;
+  dbUrlOverride;
+  gatewayUrlOverride;
+  authUrlOverride;
+  storageUrlOverride;
+  experimentalOptions;
+  url(url) {
+    this.rootUrl = url;
+    return this;
+  }
+  key(apiKey) {
+    this.apiKey = apiKey;
+    return this;
+  }
+  backend(backend) {
+    this.backendConfig = toBackendConfig(backend);
+    return this;
+  }
+  client(clientName) {
+    this.clientName = clientName;
+    return this;
+  }
+  headers(headers) {
+    this.defaultHeaders = headers;
+    return this;
+  }
+  auth(config) {
+    this.authConfig = mergeAuthClientConfig(this.authConfig, config);
+    return this;
+  }
+  experimental(options) {
+    this.experimentalOptions = mergeExperimentalOptions(this.experimentalOptions, options);
+    if (options.athenaStorageBackend && options.typecheckColumns) {
+      return resolveBuilderReturn(this);
+    }
+    if (options.athenaStorageBackend) {
+      return resolveBuilderReturn(this);
+    }
+    if (options.typecheckColumns) {
+      return resolveBuilderReturn(this);
+    }
+    return this;
+  }
+  options(options) {
+    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);
+    }
+    if (options.headers !== void 0) {
+      this.defaultHeaders = mergeHeaders(this.defaultHeaders, options.headers);
+    }
+    if (options.auth !== void 0) {
       this.authConfig = mergeAuthClientConfig(this.authConfig, options.auth);
     }
     if (options.db?.url !== void 0 && options.db.url !== null) {
@@ -5561,6 +6350,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,
@@ -5604,7 +6396,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) {
@@ -5617,7 +6409,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();
@@ -5673,7 +6465,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 = [];
@@ -5697,7 +6489,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)) {
@@ -5715,7 +6507,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 = [];
@@ -5743,7 +6535,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);
@@ -5752,7 +6544,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);
@@ -5776,7 +6568,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 = [];
@@ -5826,7 +6618,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) {
@@ -6001,11 +6793,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
     };
@@ -6029,7 +6821,7 @@ function normalizeFindManyAstBooleanOperand(clause) {
   return normalized;
 }
 function normalizeFindManyAstWhere(where) {
-  if (!where || !isRecord8(where)) {
+  if (!where || !isRecord9(where)) {
     return where;
   }
   const normalized = {};
@@ -6043,7 +6835,7 @@ function normalizeFindManyAstWhere(where) {
       );
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       normalized.not = normalizeFindManyAstBooleanOperand(
         value
       );
@@ -6054,7 +6846,7 @@ function normalizeFindManyAstWhere(where) {
   return normalized;
 }
 function predicateRequiresUuidQueryFallback(column, value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return shouldUseUuidTextComparison(column, value);
   }
   const eqValue = value.eq;
@@ -6072,7 +6864,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)) {
@@ -6087,7 +6879,7 @@ function findManyAstWhereRequiresLegacyTransport(where) {
       }
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       if (booleanOperandRequiresUuidQueryFallback(value)) {
         return true;
       }
@@ -6636,6 +7428,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,
@@ -6712,7 +7505,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) {
@@ -6724,8 +7517,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)) {
@@ -6741,7 +7534,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,
@@ -6804,6 +7597,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;
@@ -8103,6 +8933,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;
@@ -8113,6 +9022,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);
 }
@@ -8121,6 +9039,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)
   };
 }
@@ -8145,6 +9065,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;
@@ -8154,6 +9157,8 @@ function normalizeAuthClientConfig(auth, defaultBaseUrl) {
     baseUrl,
     apiKey,
     bearerToken,
+    cookie,
+    sessionToken,
     ...rest
   } = auth ?? {};
   const normalized = {
@@ -8172,6 +9177,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) {
@@ -8185,31 +9196,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) {
@@ -8257,17 +9290,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 ? {
@@ -8283,38 +9459,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
@@ -8345,7 +9529,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) {
@@ -8354,7 +9538,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";
@@ -8680,6 +9864,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);
     }
@@ -8731,6 +9918,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;
@@ -8782,12 +10022,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;
@@ -8802,9 +10052,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,
@@ -8865,6 +10152,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/env.ts
 function readEnvStringValue(key) {
   if (typeof process === "undefined" || !process.env) {
@@ -9130,15 +10488,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,
@@ -9148,7 +10506,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) {
@@ -9171,23 +10529,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;
   }
@@ -9196,12 +10554,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;
   }
@@ -9211,7 +10569,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) {
@@ -9224,16 +10582,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
@@ -9358,9 +10716,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."
@@ -9371,17 +10729,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,
@@ -9394,8 +10752,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(
         {
@@ -9416,7 +10774,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,
@@ -9523,6 +10881,6 @@ async function runSchemaGenerator(options = {}) {
   return throwBrowserUnsupported("runSchemaGenerator");
 }
 
-export { ATHENA_AUTH_BASE_ERROR_CODES, AthenaClient, AthenaError, AthenaErrorCategory, AthenaErrorCode, AthenaErrorKind, AthenaGatewayError, AthenaStorageError, AthenaStorageErrorCode, Backend, DEFAULT_POSTGRES_SCHEMAS, assertInt, athenaAuth, boolean, coerceInt, createAthenaStorageError, createAuthClient, createAuthReactEmailInput, createClient, createModelFormAdapter, createPostgresIntrospectionProvider, createTypedClient, defineAthenaAuthConfig, defineAuthEmailTemplate, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, enumeration, findGeneratorConfigPath, generateArtifactsFromSnapshot, generatorEnv, getAthenaDebugAst, identifier, isAthenaGatewayError, isOk, json, loadGeneratorConfig, normalizeAthenaError, normalizeAthenaGatewayBaseUrl, normalizeGeneratorConfig, normalizeSchemaSelection, number, parseBooleanFlag2 as parseBooleanFlag, renderAthenaReactEmail, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, resolveProviderSchemas, runSchemaGenerator, storageSdkManifest, string, table, toModelFormDefaults, toModelPayload, unwrap, unwrapOne, unwrapRows, verifyAthenaGatewayUrl, withRetry };
+export { ATHENA_AUTH_ADMIN_LIMITS, ATHENA_AUTH_BASE_ERROR_CODES, ATHENA_AUTH_MAX_ADMIN_JSON_BYTES, ATHENA_AUTH_MAX_ADMIN_JSON_DEPTH, ATHENA_AUTH_MAX_TEMPLATE_VARIABLES, ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH, AthenaChatError, AthenaClient, AthenaError, AthenaErrorCategory, AthenaErrorCode, AthenaErrorKind, AthenaGatewayError, AthenaStorageError, AthenaStorageErrorCode, Backend, DEFAULT_POSTGRES_SCHEMAS, assertInt, athenaAuth, boolean, chatSdkManifest, coerceInt, createAthenaStorageError, createAuthClient, createAuthReactEmailInput, createClient, createModelFormAdapter, createPostgresIntrospectionProvider, createTypedClient, defineAthenaAuthConfig, defineAuthEmailTemplate, defineDatabase, defineGeneratorConfig, defineModel, defineRegistry, defineSchema, enumeration, filterIntrospectionSnapshot, findGeneratorConfigPath, generateArtifactsFromSnapshot, generatorEnv, getAthenaDebugAst, identifier, isAthenaGatewayError, isOk, json, loadGeneratorConfig, normalizeAthenaError, normalizeAthenaGatewayBaseUrl, normalizeGeneratorConfig, normalizeSchemaSelection, normalizeTableSelection, number, parseBooleanFlag2 as parseBooleanFlag, renderAthenaReactEmail, requireAffected, requireSuccess, resolveGeneratorProvider, resolvePostgresColumnType, resolveProviderSchemas, runSchemaGenerator, storageSdkManifest, string, table, toModelFormDefaults, toModelPayload, unwrap, unwrapChatMessage, unwrapChatRoom, unwrapOne, unwrapRows, verifyAthenaGatewayUrl, withRetry };
 //# sourceMappingURL=browser.js.map
 //# sourceMappingURL=browser.js.map