@xylex-group/athena 2.8.2 → 2.10.0

package/dist/cli/index.cjs

@@ -688,6 +688,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 = [
@@ -698,13 +769,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",
@@ -723,6 +801,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",
@@ -741,10 +823,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"];
@@ -759,7 +844,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);
@@ -966,11 +1056,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: {
@@ -1050,6 +1148,10 @@ function normalizeGeneratorConfig(input) {
       ...DEFAULT_NAMING,
       ...input.naming ?? {}
     },
+    filter: {
+      ...DEFAULT_FILTER_CONFIG,
+      ...normalizeFilterConfig(input.filter)
+    },
     features: normalizeFeatureFlags(input.features),
     experimental: normalizeExperimentalFlags(input.experimental),
     internal: {
@@ -1110,16 +1212,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 } : {},
@@ -1129,6 +1233,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);
@@ -1204,6 +1319,7 @@ function createEnvironmentGeneratorConfig() {
     provider,
     output: buildEnvironmentOutputConfig(),
     naming: buildEnvironmentNamingConfig(),
+    filter: buildEnvironmentFilterConfig(),
     features: buildEnvironmentFeatureFlags(),
     experimental: buildEnvironmentExperimentalFlags()
   };
@@ -1365,7 +1481,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}'
@@ -1374,6 +1490,7 @@ export const __athena_schema_meta = {
   schemaVersion: ${schemaVersion},
   generatedAt: ${escapeStringLiteral(generatedAt)},
   database: ${escapeStringLiteral(databaseName)},
+  outputPreset: ${escapeStringLiteral(outputPreset)},
   outputFormat: ${escapeStringLiteral(outputFormat)},
 } as const
 
@@ -1543,6 +1660,7 @@ function composeGeneratorArtifacts(input) {
         toSafeIdentifier("registry", config.naming.registryConst, "registry"),
         databaseName,
         snapshot.generatedAt,
+        config.output.preset,
         config.output.format,
         config.internal.schemaVersion
       )
@@ -1648,7 +1766,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}>
@@ -1745,11 +1863,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 }) {
       const modelConstName = toSafeIdentifier(
@@ -1779,7 +1898,7 @@ function generateArtifactsFromSnapshot(snapshot, config) {
         table
       };
     },
-    renderModelArtifact: (descriptor) => renderModelArtifact2(snapshot.database, descriptor, normalizedConfig)
+    renderModelArtifact: (descriptor) => renderModelArtifact2(filteredSnapshot.database, descriptor, normalizedConfig)
   });
 }
 
@@ -1861,8 +1980,8 @@ function parseCookies(cookieHeader) {
   });
   return cookieMap;
 }
-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;
   }
@@ -1885,7 +2004,7 @@ var getSessionCookie = (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.8.2"
+  version: "2.10.0"
 };
 
 // src/sdk-version.ts
@@ -1898,6 +2017,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 };
@@ -1916,6 +2036,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]);
@@ -2074,6 +2197,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 ?? {}
@@ -2127,11 +2251,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) {
@@ -2571,6 +2699,35 @@ function quoteSelectColumnsExpression(columns) {
   }
   return tokens.map(quoteSelectToken).join(", ");
 }
+var ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = 64;
+var ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = 128;
+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;
@@ -2760,6 +2917,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(/\/$/, "");
 }
@@ -2769,6 +2927,9 @@ function isRecord4(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 };
@@ -2824,6 +2985,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 {
@@ -2839,6 +3092,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
@@ -2852,16 +3106,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) {
@@ -3067,7 +3335,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(
@@ -3080,7 +3348,7 @@ function createAuthClient(config = {}) {
   };
   const postGeneric = (endpoint, input, options) => {
     const { payload, fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "POST",
@@ -3092,7 +3360,7 @@ function createAuthClient(config = {}) {
   };
   const getGeneric = (endpoint, input, options) => {
     const { fetchOptions } = extractFetchOptions(input);
-    return request(
+    return request2(
       {
         endpoint,
         method: "GET",
@@ -3104,7 +3372,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",
@@ -3122,11 +3390,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",
@@ -3288,6 +3641,7 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    requirePermission: (input, options) => requirePermission("/organization/has-permission", input, options),
     invitation: {
       cancel: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -3483,6 +3837,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,
@@ -3577,6 +3933,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)
       },
@@ -3621,7 +3978,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: {
@@ -3637,7 +4002,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: {
@@ -3677,7 +4050,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: {
@@ -3691,7 +4064,7 @@ function createAuthClient(config = {}) {
   };
   return {
     baseUrl: normalizedBaseUrl,
-    request,
+    request: request2,
     signIn: {
       email: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -3728,6 +4101,8 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    getUser,
+    requireSession,
     listSessions: (input, options) => executeGetWithCompatibleInput(
       resolvedConfig,
       { endpoint: "/list-sessions", method: "GET" },
@@ -3891,16 +4266,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) => {
@@ -3911,13 +4286,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,
@@ -5878,6 +6253,484 @@ 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 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
+  };
+}
+
 // src/client-builder.ts
 var DEFAULT_BACKEND = { type: "athena" };
 function toBackendConfig(value) {
@@ -5912,7 +6765,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) {
@@ -5925,7 +6778,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();
@@ -5981,7 +6834,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 = [];
@@ -6005,7 +6858,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)) {
@@ -6023,7 +6876,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 = [];
@@ -6051,7 +6904,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);
@@ -6060,7 +6913,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);
@@ -6084,7 +6937,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 = [];
@@ -6134,7 +6987,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) {
@@ -6309,11 +7162,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
     };
@@ -6337,7 +7190,7 @@ function normalizeFindManyAstBooleanOperand(clause) {
   return normalized;
 }
 function normalizeFindManyAstWhere(where) {
-  if (!where || !isRecord8(where)) {
+  if (!where || !isRecord9(where)) {
     return where;
   }
   const normalized = {};
@@ -6351,7 +7204,7 @@ function normalizeFindManyAstWhere(where) {
       );
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       normalized.not = normalizeFindManyAstBooleanOperand(
         value
       );
@@ -6362,7 +7215,7 @@ function normalizeFindManyAstWhere(where) {
   return normalized;
 }
 function predicateRequiresUuidQueryFallback(column, value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return shouldUseUuidTextComparison(column, value);
   }
   const eqValue = value.eq;
@@ -6380,7 +7233,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)) {
@@ -6395,7 +7248,7 @@ function findManyAstWhereRequiresLegacyTransport(where) {
       }
       continue;
     }
-    if (key === "not" && isRecord8(value)) {
+    if (key === "not" && isRecord9(value)) {
       if (booleanOperandRequiresUuidQueryFallback(value)) {
         return true;
       }
@@ -6938,6 +7791,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,
@@ -7014,7 +7868,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) {
@@ -7026,8 +7880,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)) {
@@ -7043,7 +7897,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,
@@ -7106,6 +7960,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;
@@ -8405,6 +9296,59 @@ function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
     );
   };
 }
+function normalizeOptionalString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : void 0;
+}
+function readHeaderBagValue(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 resolveSessionContextOptions(session, options) {
+  const sessionToken = normalizeOptionalString2(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;
@@ -8415,6 +9359,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);
 }
@@ -8423,6 +9376,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: normalizeOptionalString2(config.chat?.wsUrl) ?? normalizeOptionalString2(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)
   };
 }
@@ -8447,6 +9402,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;
@@ -8456,6 +9494,8 @@ function normalizeAuthClientConfig(auth, defaultBaseUrl) {
     baseUrl,
     apiKey,
     bearerToken,
+    cookie,
+    sessionToken,
     ...rest
   } = auth ?? {};
   const normalized = {
@@ -8474,6 +9514,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) {
@@ -8487,31 +9533,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) {
@@ -8559,17 +9627,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 ? {
@@ -8584,13 +9795,13 @@ function createClientFromConfig(config) {
 }
 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/schema/postgres-introspection-core.ts
@@ -9146,16 +10357,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();
@@ -9169,12 +10389,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
   };
 }
 
@@ -9216,24 +10437,64 @@ function generateUsage() {
     "  athena-js generate --config ./athena.config.ts --dry-run"
   ].join("\n");
 }
-function usesSchemaScopedModelTarget(target) {
-  return /\{schema(?:_[a-z]+)?\}/.test(target);
+function normalizePath2(pathValue) {
+  return pathValue.replace(/\\/g, "/");
+}
+function isLegacyConfigRegistryTarget(target) {
+  return normalizePath2(target) === "athena/config.ts";
+}
+function isFlatSchemaTarget(target) {
+  return normalizePath2(target) === "athena/schema.ts";
+}
+function formatProviderLine(result) {
+  const { provider } = result.config;
+  if (provider.kind === "postgres") {
+    const schemaList = Array.isArray(provider.schemas) ? provider.schemas.join(",") : typeof provider.schemas === "string" ? provider.schemas : "public";
+    const database = provider.database ? ` database=${provider.database}` : "";
+    const backend = provider.mode === "gateway" && provider.backend ? ` backend=${provider.backend}` : "";
+    return `[provider] kind=${provider.kind} mode=${provider.mode}${database}${backend} schemas=${schemaList}`;
+  }
+  const datacenter = provider.datacenter ? ` datacenter=${provider.datacenter}` : "";
+  return `[provider] kind=${provider.kind} mode=${provider.mode} keyspace=${provider.keyspace} contactPoints=${provider.contactPoints.join(",")}${datacenter}`;
+}
+function formatFilterLine(result) {
+  const { includeTables, excludeTables } = result.config.filter;
+  if (includeTables.length === 0 && excludeTables.length === 0) {
+    return void 0;
+  }
+  return `[filter] include=${includeTables.length > 0 ? includeTables.join(",") : "-"} exclude=${excludeTables.length > 0 ? excludeTables.join(",") : "-"}`;
 }
 function formatGeneratorModeLines(result) {
   const lines = [
-    `[mode] format=${result.config.output.format} modelTarget=${result.config.output.targets.model}`
+    `[mode] preset=${result.config.output.preset} format=${result.config.output.format} modelTarget=${result.config.output.targets.model}`,
+    formatProviderLine(result),
+    `[targets] schema=${result.config.output.targets.schema} database=${result.config.output.targets.database} registry=${result.config.output.targets.registry}`
   ];
+  const filterLine = formatFilterLine(result);
+  if (filterLine) {
+    lines.push(filterLine);
+  }
   if (result.config.output.format === "define-model") {
     lines.push(
-      '[note] Zero-style table-builder files are not active. Set output.format="table-builder" or ATHENA_GENERATOR_OUTPUT_FORMAT=table-builder to emit table(...).schema(...).columns(...).primaryKey(...).'
+      '[note] Legacy define-model compatibility output is active. Set output.format="table-builder" or ATHENA_GENERATOR_OUTPUT_FORMAT=table-builder to emit table(...).schema(...).columns(...).primaryKey(...).'
+    );
+  }
+  if (result.config.output.preset === "legacy") {
+    lines.push(
+      '[note] Legacy preset is active. It keeps registry output on athena/config.ts for compatibility; prefer output.preset="athena-direct" for the default safe direct layout.'
     );
   }
   lines.push(
-    "[note] Table-builder generation is stable. experimental.findManyAst only affects runtime findMany(...) transport and does not enable generator table output."
+    "[note] Default generator mode is preset=athena-direct + format=table-builder. experimental.findManyAst only affects runtime findMany(...) transport and does not enable generator table output."
   );
-  if (usesSchemaScopedModelTarget(result.config.output.targets.model)) {
+  if (isLegacyConfigRegistryTarget(result.config.output.targets.registry)) {
+    lines.push(
+      '[warn] Registry target points at athena/config.ts. That file is often a handwritten runtime seam; prefer output.preset="athena-direct" or output.targets.registry="athena/registry.generated.ts" unless you intentionally need legacy compatibility.'
+    );
+  }
+  if (isFlatSchemaTarget(result.config.output.targets.schema)) {
     lines.push(
-      '[note] Flat athena/models/*.ts output is opt-in. Set output.targets.model="athena/models/{model_kebab}.ts" or ATHENA_GENERATOR_MODEL_TARGET=athena/models/{model_kebab}.ts; multi-schema collisions are still auto-scoped by schema when needed.'
+      "[warn] Schema target points at athena/schema.ts. Prefer schema-scoped output such as athena/schemas/{schema_kebab}.ts."
     );
   }
   return lines;
@@ -9320,6 +10581,12 @@ function formatGeneratorError(error, configPath) {
   }
   return new Error(normalizeErrorMessage(error));
 }
+function formatSkippedArtifactLine(artifact) {
+  if (artifact.reason === "protected-existing-file") {
+    return ` [skip] ${artifact.path} (existing ${artifact.kind} artifacts are protected from overwrite; delete or retarget the file to regenerate it)`;
+  }
+  return ` [skip] ${artifact.path}`;
+}
 async function runCLI(argv, runtime = {}) {
   const log = runtime.log ?? console.log;
   const runGenerator = runtime.runGenerator ?? runSchemaGenerator;
@@ -9354,6 +10621,9 @@ async function runCLI(argv, runtime = {}) {
   for (const filePath of result.writtenFiles) {
     log(` - ${filePath}`);
   }
+  for (const artifact of result.skippedFiles) {
+    log(formatSkippedArtifactLine(artifact));
+  }
 }
 
 exports.parseCommand = parseCommand;