@xylex-group/athena 2.7.0 → 2.8.2

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var zod = require('zod');
 var fs = require('fs');
 var path = require('path');
 var url = require('url');
@@ -805,7 +806,7 @@ var getCookieCache = async (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.7.0"
+  version: "2.8.2"
 };
 
 // src/sdk-version.ts
@@ -3122,7 +3123,7 @@ function normalizeAthenaError(resultOrError, context) {
     const details = resultOrError.errorDetails;
     const message2 = messageFromUnknownError(resultOrError.error) ?? details?.message ?? `Athena ${context?.operation ?? operationFromDetails(details) ?? "request"} failed`;
     const operation = context?.operation ?? operationFromDetails(details);
-    const table = context?.table ?? extractTable(message2);
+    const table2 = context?.table ?? extractTable(message2);
     const constraint = extractConstraint(message2);
     const gatewayCode = details?.code ?? gatewayCodeFromUnknownError(resultOrError.error);
     const kind2 = classifyKind(resultOrError.status, gatewayCode, message2);
@@ -3135,7 +3136,7 @@ function normalizeAthenaError(resultOrError, context) {
       retryable: isRetryable(kind2, resultOrError.status),
       status: resultOrError.status,
       constraint,
-      table,
+      table: table2,
       operation,
       message: message2,
       raw: resultOrError.raw
@@ -3144,7 +3145,7 @@ function normalizeAthenaError(resultOrError, context) {
   if (isAthenaGatewayError(resultOrError)) {
     const details = resultOrError.toDetails();
     const operation = context?.operation ?? operationFromDetails(details);
-    const table = context?.table ?? extractTable(resultOrError.message);
+    const table2 = context?.table ?? extractTable(resultOrError.message);
     const constraint = extractConstraint(resultOrError.message);
     const kind2 = classifyKind(resultOrError.status, resultOrError.code, resultOrError.message);
     const code = toAthenaErrorCode(kind2, resultOrError.status, resultOrError.code);
@@ -3156,7 +3157,7 @@ function normalizeAthenaError(resultOrError, context) {
       retryable: isRetryable(kind2, resultOrError.status),
       status: resultOrError.status,
       constraint,
-      table,
+      table: table2,
       operation,
       message: resultOrError.message,
       raw: resultOrError
@@ -3352,23 +3353,24 @@ async function withRetry(config, fn) {
 // src/db/module.ts
 function createDbModule(input) {
   const db = {
-    from(table, options) {
-      return input.from(table, options);
-    },
-    select(table, columns, options) {
-      return input.from(table).select(columns, options);
+    from: input.from,
+    select(table2, first, second) {
+      if (first && typeof first === "object" && !Array.isArray(first)) {
+        return input.from(table2).select(void 0, first);
+      }
+      return input.from(table2).select(first, second);
     },
-    insert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).insert(values, options) : input.from(table).insert(values, options);
+    insert(table2, values, options) {
+      return Array.isArray(values) ? input.from(table2).insert(values, options) : input.from(table2).insert(values, options);
     },
-    upsert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).upsert(values, options) : input.from(table).upsert(values, options);
+    upsert(table2, values, options) {
+      return Array.isArray(values) ? input.from(table2).upsert(values, options) : input.from(table2).upsert(values, options);
     },
-    update(table, values, options) {
-      return input.from(table).update(values, options);
+    update(table2, values, options) {
+      return input.from(table2).update(values, options);
     },
-    delete(table, options) {
-      return input.from(table).delete(options);
+    delete(table2, options) {
+      return input.from(table2).delete(options);
     },
     rpc(fn, args, options) {
       return input.rpc(fn, args, options);
@@ -3400,7 +3402,12 @@ function createStorageFileModule(base, config = {}) {
           content_type: input.content_type ?? source.contentType,
           size_bytes: source.sizeBytes,
           public: input.public,
-          metadata: input.metadata
+          metadata: input.metadata,
+          server_side_encryption: input.server_side_encryption,
+          sse: input.sse,
+          ssekms_key_id: input.ssekms_key_id,
+          kms_key_id: input.kms_key_id,
+          bucket_key_enabled: input.bucket_key_enabled
         }
       };
     });
@@ -3411,10 +3418,17 @@ function createStorageFileModule(base, config = {}) {
     for (let index = 0; index < uploadRequests.length; index += 1) {
       const request = uploadRequests[index];
       const uploadUrl = uploadUrls[index];
-      const response = await putUploadBody(uploadUrl.upload.url, request.source, input, options, (progress) => {
-        aggregateLoaded[index] = progress.loaded;
-        input.onProgress?.(createProgressSnapshot("uploading", sources, index, progress.loaded, sum(aggregateLoaded)));
-      });
+      const response = await putUploadBody(
+        uploadUrl.upload.url,
+        uploadUrl.upload.headers ?? {},
+        request.source,
+        input,
+        options,
+        (progress) => {
+          aggregateLoaded[index] = progress.loaded;
+          input.onProgress?.(createProgressSnapshot("uploading", sources, index, progress.loaded, sum(aggregateLoaded)));
+        }
+      );
       uploaded.push({
         file: uploadUrl.file,
         upload: uploadUrl.upload,
@@ -3517,8 +3531,9 @@ function validateUploadConstraints(sources, input) {
     }
   }
 }
-async function putUploadBody(url, source, input, options, onProgress) {
-  const headers = new Headers(input.uploadHeaders);
+async function putUploadBody(url, uploadHeaders, source, input, options, onProgress) {
+  const headers = new Headers(uploadHeaders);
+  new Headers(input.uploadHeaders).forEach((value, key) => headers.set(key, value));
   if (source.contentType && !headers.has("Content-Type")) {
     headers.set("Content-Type", source.contentType);
   }
@@ -3843,6 +3858,23 @@ var storageSdkManifest = {
       responseEnvelope: "athena",
       responseType: "StorageFileMutationResponse"
     },
+    {
+      name: "postStorageFileVisibility",
+      method: "POST",
+      path: "/storage/files/{file_id}/visibility",
+      pathParams: ["file_id"],
+      requestType: "SetStorageFileVisibilityRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "setManyStorageFileVisibility",
+      method: "POST",
+      path: "/storage/files/visibility-many",
+      requestType: "SetManyStorageFileVisibilityRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationManyResponse"
+    },
     {
       name: "deleteStorageFolder",
       method: "POST",
@@ -3858,242 +3890,729 @@ var storageSdkManifest = {
       requestType: "MoveStorageFolderRequest",
       responseEnvelope: "athena",
       responseType: "StorageFolderMutationResponse"
-    }
-  ]
-};
-var AthenaStorageErrorCode = {
-  InvalidUrl: "INVALID_URL",
-  NetworkError: "NETWORK_ERROR",
-  HttpError: "HTTP_ERROR",
-  InvalidJson: "INVALID_JSON",
-  InvalidAthenaEnvelope: "INVALID_ATHENA_ENVELOPE",
-  UnknownError: "UNKNOWN_ERROR"
-};
-var AthenaStorageError = class extends Error {
-  code;
-  athenaCode;
-  kind;
-  category;
-  retryable;
-  status;
-  endpoint;
-  method;
-  requestId;
-  hint;
-  causeDetail;
-  raw;
-  normalized;
-  __athenaNormalizedError;
-  constructor(input) {
-    super(input.message, { cause: input.cause });
-    this.name = "AthenaStorageError";
-    this.code = input.code;
-    this.status = input.status;
-    this.endpoint = input.endpoint;
-    this.method = input.method;
-    this.requestId = input.requestId;
-    this.hint = input.hint;
-    this.causeDetail = causeToString(input.cause);
-    this.raw = input.raw ?? null;
-    this.normalized = normalizeStorageErrorInput(input);
-    this.__athenaNormalizedError = this.normalized;
-    this.athenaCode = this.normalized.code;
-    this.kind = this.normalized.kind;
-    this.category = this.normalized.category;
-    this.retryable = this.normalized.retryable;
-    Object.defineProperty(this, "__athenaNormalizedError", {
-      value: this.normalized,
-      enumerable: false,
-      configurable: false,
-      writable: false
-    });
-  }
-  toDetails() {
-    return {
-      code: this.code,
-      athenaCode: this.athenaCode,
-      kind: this.kind,
-      category: this.category,
-      retryable: this.retryable,
-      message: this.message,
-      status: this.status,
-      endpoint: this.endpoint,
-      method: this.method,
-      requestId: this.requestId,
-      hint: this.hint,
-      cause: this.causeDetail,
-      raw: this.raw
-    };
-  }
-};
-function isRecord6(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function causeToString(cause) {
-  if (cause === void 0 || cause === null) return void 0;
-  if (typeof cause === "string") return cause;
-  if (cause instanceof Error && cause.message.trim()) return cause.message.trim();
-  try {
-    return JSON.stringify(cause);
-  } catch {
-    return String(cause);
-  }
-}
-function storageGatewayCode(code) {
-  if (code === "INVALID_URL") return "INVALID_URL";
-  if (code === "NETWORK_ERROR") return "NETWORK_ERROR";
-  if (code === "INVALID_JSON" || code === "INVALID_ATHENA_ENVELOPE") return "INVALID_JSON";
-  if (code === "HTTP_ERROR") return "HTTP_ERROR";
-  return "UNKNOWN_ERROR";
-}
-function headerValue(headers, names) {
-  for (const name of names) {
-    const value = headers.get(name);
-    if (value?.trim()) return value.trim();
-  }
-  return void 0;
-}
-function storageOperationFromEndpoint(endpoint, method) {
-  const endpointPath = String(endpoint).split("?")[0];
-  for (const candidate of storageSdkManifest.methods) {
-    if (candidate.method !== method) continue;
-    const pattern = `^${candidate.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\{[^/]+\\\}/g, "[^/]+")}$`;
-    if (new RegExp(pattern).test(endpointPath)) {
-      return candidate.name;
-    }
-  }
-  return `storage:${method.toLowerCase()}`;
-}
-function normalizeStorageErrorInput(input) {
-  return normalizeAthenaError(
+    },
     {
-      data: null,
-      error: {
-        message: input.message,
-        gatewayCode: storageGatewayCode(input.code),
-        status: input.status,
-        raw: input.raw ?? input.cause ?? null
-      },
-      errorDetails: {
-        code: storageGatewayCode(input.code),
-        message: input.message,
-        status: input.status,
-        endpoint: input.endpoint,
-        method: input.method,
-        requestId: input.requestId,
-        hint: input.hint,
-        cause: causeToString(input.cause)
-      },
-      raw: input.raw ?? input.cause ?? null,
-      status: input.status
+      name: "searchStorageFiles",
+      method: "POST",
+      path: "/storage/files/search",
+      requestType: "SearchStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageListFilesResponse"
     },
-    { operation: storageOperationFromEndpoint(input.endpoint, input.method) }
-  );
-}
-function createAthenaStorageError(input) {
-  return new AthenaStorageError(input);
-}
-async function notifyStorageError(error, options, runtimeOptions) {
-  const handlers = [runtimeOptions?.onError, options?.onError].filter(
-    (handler) => typeof handler === "function"
-  );
-  for (const handler of handlers) {
-    try {
-      await handler(error);
-    } catch {
-    }
-  }
-}
-async function rejectStorageError(input, options, runtimeOptions) {
-  const error = createAthenaStorageError(input);
-  await notifyStorageError(error, options, runtimeOptions);
-  throw error;
-}
-function parseResponseBody3(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 appendQuery(path, query) {
-  if (!query) return path;
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (value === void 0 || value === null) continue;
-    params.set(key, String(value));
-  }
-  const queryText = params.toString();
-  return queryText ? `${path}?${queryText}` : path;
-}
-function storagePath(path) {
-  return path;
-}
-function withPathParam(path, name, value) {
-  return path.replace(`{${name}}`, encodeURIComponent(value));
-}
-function resolveErrorMessage3(payload, fallback) {
-  if (isRecord6(payload)) {
-    const message = payload.message ?? payload.error ?? payload.details;
-    if (typeof message === "string" && message.trim()) {
-      return message.trim();
-    }
-  }
-  if (typeof payload === "string" && payload.trim()) {
-    return payload.trim();
-  }
-  return fallback;
-}
-function resolveErrorHint2(payload) {
-  if (!isRecord6(payload)) return void 0;
-  const hint = payload.hint ?? payload.suggestion;
-  return typeof hint === "string" && hint.trim() ? hint.trim() : void 0;
-}
-function resolveErrorCause(payload) {
-  if (!isRecord6(payload)) return void 0;
-  const cause = payload.cause ?? payload.reason;
-  return typeof cause === "string" && cause.trim() ? cause.trim() : void 0;
-}
-function storageCodeFromUnknown(error) {
-  if (isAthenaGatewayError(error)) {
-    if (error.code === "INVALID_URL") return "INVALID_URL";
-    if (error.code === "NETWORK_ERROR") return "NETWORK_ERROR";
-    if (error.code === "INVALID_JSON") return "INVALID_JSON";
-    if (error.code === "HTTP_ERROR") return "HTTP_ERROR";
-  }
-  return "UNKNOWN_ERROR";
-}
-async function callStorageEndpoint(gateway, endpoint, method, envelope, payload, options, runtimeOptions) {
-  let url;
-  let headers;
-  try {
-    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : gateway.baseUrl;
-    url = buildAthenaGatewayUrl(baseUrl, endpoint);
-    headers = gateway.buildHeaders(options);
-  } catch (error) {
-    return rejectStorageError(
-      {
-        code: storageCodeFromUnknown(error),
-        message: error instanceof Error ? error.message : `Athena storage ${method} ${endpoint} failed before sending the request`,
-        status: isAthenaGatewayError(error) ? error.status : 0,
-        endpoint,
-        method,
-        raw: error,
-        requestId: isAthenaGatewayError(error) ? error.requestId : void 0,
-        hint: isAthenaGatewayError(error) ? error.hint : void 0,
-        cause: error
-      },
-      options,
-      runtimeOptions
-    );
+    {
+      name: "confirmStorageUpload",
+      method: "POST",
+      path: "/storage/files/{file_id}/confirm-upload",
+      pathParams: ["file_id"],
+      requestType: "ConfirmStorageUploadRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "uploadStorageFileBinary",
+      method: "PUT",
+      path: "/storage/files/{file_id}/upload",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse",
+      binary: true
+    },
+    {
+      name: "copyStorageFile",
+      method: "POST",
+      path: "/storage/files/{file_id}/copy",
+      pathParams: ["file_id"],
+      requestType: "CopyStorageFileRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "deleteManyStorageFiles",
+      method: "POST",
+      path: "/storage/files/delete-many",
+      requestType: "DeleteManyStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationManyResponse"
+    },
+    {
+      name: "updateManyStorageFiles",
+      method: "POST",
+      path: "/storage/files/update-many",
+      requestType: "UpdateManyStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationManyResponse"
+    },
+    {
+      name: "restoreStorageFile",
+      method: "POST",
+      path: "/storage/files/{file_id}/restore",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "purgeStorageFile",
+      method: "DELETE",
+      path: "/storage/files/{file_id}/purge",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "getStorageFilePublicUrl",
+      method: "GET",
+      path: "/storage/files/{file_id}/public-url",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageFileProxyUrl",
+      method: "GET",
+      path: "/storage/files/{file_id}/proxy-url",
+      pathParams: ["file_id"],
+      queryParams: ["purpose"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageFileVersions",
+      method: "GET",
+      path: "/storage/files/{file_id}/versions",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "restoreStorageFileVersion",
+      method: "POST",
+      path: "/storage/files/{file_id}/versions/{version_id}/restore",
+      pathParams: ["file_id", "version_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageFileVersion",
+      method: "DELETE",
+      path: "/storage/files/{file_id}/versions/{version_id}",
+      pathParams: ["file_id", "version_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageFileRetention",
+      method: "GET",
+      path: "/storage/files/{file_id}/retention",
+      pathParams: ["file_id"],
+      queryParams: ["version_id"],
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageFileRetention",
+      method: "POST",
+      path: "/storage/files/{file_id}/retention",
+      pathParams: ["file_id"],
+      requestType: "StorageFileRetentionRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageFolders",
+      method: "POST",
+      path: "/storage/folders/list",
+      requestType: "ListStorageFoldersRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "treeStorageFolders",
+      method: "POST",
+      path: "/storage/folders/tree",
+      requestType: "TreeStorageFoldersRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStoragePermissions",
+      method: "POST",
+      path: "/storage/permissions/list",
+      requestType: "StoragePermissionListRequest",
+      responseEnvelope: "athena",
+      responseType: "StoragePermissionListResponse"
+    },
+    {
+      name: "grantStoragePermission",
+      method: "POST",
+      path: "/storage/permissions/grant",
+      requestType: "StoragePermissionGrantRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "revokeStoragePermission",
+      method: "POST",
+      path: "/storage/permissions/revoke",
+      requestType: "StoragePermissionRevokeRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "checkStoragePermission",
+      method: "POST",
+      path: "/storage/permissions/check",
+      requestType: "StoragePermissionCheckRequest",
+      responseEnvelope: "athena",
+      responseType: "StoragePermissionCheckResponse"
+    },
+    {
+      name: "listStorageObjects",
+      method: "POST",
+      path: "/storage/objects",
+      requestType: "StorageListObjectsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "headStorageObject",
+      method: "POST",
+      path: "/storage/objects/head",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "existsStorageObject",
+      method: "POST",
+      path: "/storage/objects/exists",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "validateStorageObject",
+      method: "POST",
+      path: "/storage/objects/validate",
+      requestType: "StorageObjectValidateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "updateStorageObject",
+      method: "POST",
+      path: "/storage/objects/update",
+      requestType: "StorageUpdateObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "copyStorageObject",
+      method: "POST",
+      path: "/storage/objects/copy",
+      requestType: "StorageObjectCopyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageObjectUrl",
+      method: "POST",
+      path: "/storage/objects/url",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageObjectPublicUrl",
+      method: "POST",
+      path: "/storage/objects/public-url",
+      requestType: "StorageObjectPublicUrlRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageObject",
+      method: "POST",
+      path: "/storage/objects/delete",
+      requestType: "StorageObjectRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageObjectUploadUrl",
+      method: "POST",
+      path: "/storage/objects/upload-url",
+      requestType: "StoragePresignUploadRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageObjectPostPolicy",
+      method: "POST",
+      path: "/storage/objects/post-policy",
+      requestType: "StorageSignedPostPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageObjectVersions",
+      method: "POST",
+      path: "/storage/objects/versions",
+      requestType: "StorageObjectVersionListRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "restoreStorageObjectVersion",
+      method: "POST",
+      path: "/storage/objects/versions/restore",
+      requestType: "StorageObjectVersionMutationRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageObjectVersion",
+      method: "POST",
+      path: "/storage/objects/versions/delete",
+      requestType: "StorageObjectVersionMutationRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageObjectFolder",
+      method: "POST",
+      path: "/storage/objects/folder",
+      requestType: "StorageObjectFolderCreateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageObjectFolder",
+      method: "POST",
+      path: "/storage/objects/folder/delete",
+      requestType: "StorageObjectFolderDeleteRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "renameStorageObjectFolder",
+      method: "POST",
+      path: "/storage/objects/folder/rename",
+      requestType: "StorageObjectFolderRenameRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageBuckets",
+      method: "POST",
+      path: "/storage/buckets/list",
+      requestType: "Omit<StorageObjectBaseRequest, 'bucket'>",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageBucket",
+      method: "POST",
+      path: "/storage/buckets/create",
+      requestType: "StorageObjectBaseRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucket",
+      method: "POST",
+      path: "/storage/buckets/delete",
+      requestType: "StorageObjectBaseRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketLifecycle",
+      method: "POST",
+      path: "/storage/buckets/lifecycle",
+      requestType: "StorageBucketLifecycleRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketLifecycle",
+      method: "POST",
+      path: "/storage/buckets/lifecycle/set",
+      requestType: "StorageSetBucketLifecycleRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketLifecycle",
+      method: "POST",
+      path: "/storage/buckets/lifecycle/delete",
+      requestType: "StorageBucketLifecycleRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy",
+      requestType: "StorageBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy/set",
+      requestType: "StorageSetBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy/delete",
+      requestType: "StorageBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access",
+      requestType: "StoragePublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access/set",
+      requestType: "StorageSetPublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access/delete",
+      requestType: "StoragePublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "getStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors",
+      requestType: "StorageBucketCorsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "setStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors/set",
+      requestType: "StorageSetBucketCorsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "deleteStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors/delete",
+      requestType: "StorageBucketCorsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "createStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/create",
+      requestType: "StorageMultipartCreateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "signStorageMultipartPart",
+      method: "POST",
+      path: "/storage/multipart/sign-part",
+      requestType: "StorageMultipartSignPartRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "completeStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/complete",
+      requestType: "StorageMultipartCompleteRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "abortStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/abort",
+      requestType: "StorageMultipartAbortRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageMultipartParts",
+      method: "POST",
+      path: "/storage/multipart/list-parts",
+      requestType: "StorageMultipartListPartsRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
+    },
+    {
+      name: "listStorageAuditEvents",
+      method: "POST",
+      path: "/storage/audit/list",
+      requestType: "StorageAuditQueryRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageAuditListResponse"
+    }
+  ]
+};
+var AthenaStorageErrorCode = {
+  InvalidUrl: "INVALID_URL",
+  NetworkError: "NETWORK_ERROR",
+  HttpError: "HTTP_ERROR",
+  InvalidJson: "INVALID_JSON",
+  InvalidAthenaEnvelope: "INVALID_ATHENA_ENVELOPE",
+  UnknownError: "UNKNOWN_ERROR"
+};
+var AthenaStorageError = class extends Error {
+  code;
+  athenaCode;
+  kind;
+  category;
+  retryable;
+  status;
+  endpoint;
+  method;
+  requestId;
+  hint;
+  causeDetail;
+  raw;
+  normalized;
+  __athenaNormalizedError;
+  constructor(input) {
+    super(input.message, { cause: input.cause });
+    this.name = "AthenaStorageError";
+    this.code = input.code;
+    this.status = input.status;
+    this.endpoint = input.endpoint;
+    this.method = input.method;
+    this.requestId = input.requestId;
+    this.hint = input.hint;
+    this.causeDetail = causeToString(input.cause);
+    this.raw = input.raw ?? null;
+    this.normalized = normalizeStorageErrorInput(input);
+    this.__athenaNormalizedError = this.normalized;
+    this.athenaCode = this.normalized.code;
+    this.kind = this.normalized.kind;
+    this.category = this.normalized.category;
+    this.retryable = this.normalized.retryable;
+    Object.defineProperty(this, "__athenaNormalizedError", {
+      value: this.normalized,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+  }
+  toDetails() {
+    return {
+      code: this.code,
+      athenaCode: this.athenaCode,
+      kind: this.kind,
+      category: this.category,
+      retryable: this.retryable,
+      message: this.message,
+      status: this.status,
+      endpoint: this.endpoint,
+      method: this.method,
+      requestId: this.requestId,
+      hint: this.hint,
+      cause: this.causeDetail,
+      raw: this.raw
+    };
+  }
+};
+function isRecord6(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function causeToString(cause) {
+  if (cause === void 0 || cause === null) return void 0;
+  if (typeof cause === "string") return cause;
+  if (cause instanceof Error && cause.message.trim()) return cause.message.trim();
+  try {
+    return JSON.stringify(cause);
+  } catch {
+    return String(cause);
+  }
+}
+function storageGatewayCode(code) {
+  if (code === "INVALID_URL") return "INVALID_URL";
+  if (code === "NETWORK_ERROR") return "NETWORK_ERROR";
+  if (code === "INVALID_JSON" || code === "INVALID_ATHENA_ENVELOPE") return "INVALID_JSON";
+  if (code === "HTTP_ERROR") return "HTTP_ERROR";
+  return "UNKNOWN_ERROR";
+}
+function headerValue(headers, names) {
+  for (const name of names) {
+    const value = headers.get(name);
+    if (value?.trim()) return value.trim();
+  }
+  return void 0;
+}
+function storageOperationFromEndpoint(endpoint, method) {
+  const endpointPath = String(endpoint).split("?")[0];
+  for (const candidate of storageSdkManifest.methods) {
+    if (candidate.method !== method) continue;
+    const pattern = `^${candidate.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\{[^/]+\\\}/g, "[^/]+")}$`;
+    if (new RegExp(pattern).test(endpointPath)) {
+      return candidate.name;
+    }
+  }
+  return `storage:${method.toLowerCase()}`;
+}
+function normalizeStorageErrorInput(input) {
+  return normalizeAthenaError(
+    {
+      data: null,
+      error: {
+        message: input.message,
+        gatewayCode: storageGatewayCode(input.code),
+        status: input.status,
+        raw: input.raw ?? input.cause ?? null
+      },
+      errorDetails: {
+        code: storageGatewayCode(input.code),
+        message: input.message,
+        status: input.status,
+        endpoint: input.endpoint,
+        method: input.method,
+        requestId: input.requestId,
+        hint: input.hint,
+        cause: causeToString(input.cause)
+      },
+      raw: input.raw ?? input.cause ?? null,
+      status: input.status
+    },
+    { operation: storageOperationFromEndpoint(input.endpoint, input.method) }
+  );
+}
+function createAthenaStorageError(input) {
+  return new AthenaStorageError(input);
+}
+async function notifyStorageError(error, options, runtimeOptions) {
+  const handlers = [runtimeOptions?.onError, options?.onError].filter(
+    (handler) => typeof handler === "function"
+  );
+  for (const handler of handlers) {
+    try {
+      await handler(error);
+    } catch {
+    }
+  }
+}
+async function rejectStorageError(input, options, runtimeOptions) {
+  const error = createAthenaStorageError(input);
+  await notifyStorageError(error, options, runtimeOptions);
+  throw error;
+}
+function parseResponseBody3(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 appendQuery(path, query) {
+  if (!query) return path;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  const queryText = params.toString();
+  return queryText ? `${path}?${queryText}` : path;
+}
+function storagePath(path) {
+  return path;
+}
+function resolveStorageEndpointPath(endpoint, runtimeOptions) {
+  if (!runtimeOptions?.stripBasePath) {
+    return endpoint;
+  }
+  const [pathname, queryText] = String(endpoint).split("?", 2);
+  const trimmedPathname = pathname.startsWith("/storage/") ? pathname.slice("/storage".length) : pathname === "/storage" ? "/" : pathname;
+  const resolvedPath = trimmedPathname.startsWith("/") ? trimmedPathname : `/${trimmedPathname}`;
+  return storagePath(queryText ? `${resolvedPath}?${queryText}` : resolvedPath);
+}
+function withPathParam(path, name, value) {
+  return path.replace(`{${name}}`, encodeURIComponent(value));
+}
+function resolveErrorMessage3(payload, fallback) {
+  if (isRecord6(payload)) {
+    const message = payload.message ?? payload.error ?? payload.details;
+    if (typeof message === "string" && message.trim()) {
+      return message.trim();
+    }
+  }
+  if (typeof payload === "string" && payload.trim()) {
+    return payload.trim();
+  }
+  return fallback;
+}
+function resolveErrorHint2(payload) {
+  if (!isRecord6(payload)) return void 0;
+  const hint = payload.hint ?? payload.suggestion;
+  return typeof hint === "string" && hint.trim() ? hint.trim() : void 0;
+}
+function resolveErrorCause(payload) {
+  if (!isRecord6(payload)) return void 0;
+  const cause = payload.cause ?? payload.reason;
+  return typeof cause === "string" && cause.trim() ? cause.trim() : void 0;
+}
+function storageCodeFromUnknown(error) {
+  if (isAthenaGatewayError(error)) {
+    if (error.code === "INVALID_URL") return "INVALID_URL";
+    if (error.code === "NETWORK_ERROR") return "NETWORK_ERROR";
+    if (error.code === "INVALID_JSON") return "INVALID_JSON";
+    if (error.code === "HTTP_ERROR") return "HTTP_ERROR";
+  }
+  return "UNKNOWN_ERROR";
+}
+async function callStorageEndpoint(gateway, endpoint, method, envelope, payload, options, runtimeOptions) {
+  let url;
+  let headers;
+  try {
+    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : runtimeOptions?.baseUrl ? normalizeAthenaGatewayBaseUrl(runtimeOptions.baseUrl) : gateway.baseUrl;
+    url = buildAthenaGatewayUrl(baseUrl, resolveStorageEndpointPath(endpoint, runtimeOptions));
+    headers = gateway.buildHeaders(options);
+  } catch (error) {
+    return rejectStorageError(
+      {
+        code: storageCodeFromUnknown(error),
+        message: error instanceof Error ? error.message : `Athena storage ${method} ${endpoint} failed before sending the request`,
+        status: isAthenaGatewayError(error) ? error.status : 0,
+        endpoint,
+        method,
+        raw: error,
+        requestId: isAthenaGatewayError(error) ? error.requestId : void 0,
+        hint: isAthenaGatewayError(error) ? error.hint : void 0,
+        cause: error
+      },
+      options,
+      runtimeOptions
+    );
   }
   const requestInit = {
     method,
@@ -4200,8 +4719,8 @@ async function callStorageBinaryEndpoint(gateway, endpoint, method, options, run
   let url;
   let headers;
   try {
-    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : gateway.baseUrl;
-    url = buildAthenaGatewayUrl(baseUrl, endpoint);
+    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : runtimeOptions?.baseUrl ? normalizeAthenaGatewayBaseUrl(runtimeOptions.baseUrl) : gateway.baseUrl;
+    url = buildAthenaGatewayUrl(baseUrl, resolveStorageEndpointPath(endpoint, runtimeOptions));
     headers = gateway.buildHeaders(options);
   } catch (error) {
     return rejectStorageError(
@@ -4309,7 +4828,7 @@ async function putPresignedUploadBody(uploadUrl, uploadHeaders, body, options) {
   return fetch(uploadUrl, init);
 }
 function attachManagedUpload(upload) {
-  const headers = {};
+  const headers = { ...upload.headers ?? {} };
   return {
     ...upload,
     method: "PUT",
@@ -4355,15 +4874,20 @@ function normalizeUploadUrlRequest(input) {
     file_id: input.file_id ?? input.fileId,
     public: input.public,
     visibility: input.visibility,
-    metadata: input.metadata
+    metadata: input.metadata,
+    server_side_encryption: input.server_side_encryption,
+    sse: input.sse,
+    ssekms_key_id: input.ssekms_key_id,
+    kms_key_id: input.kms_key_id,
+    bucket_key_enabled: input.bucket_key_enabled
   };
 }
 async function callStorageUploadBinaryEndpoint(gateway, endpoint, body, options, runtimeOptions) {
   let url;
   let headers;
   try {
-    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : gateway.baseUrl;
-    url = buildAthenaGatewayUrl(baseUrl, endpoint);
+    const baseUrl = options?.baseUrl ? normalizeAthenaGatewayBaseUrl(options.baseUrl) : runtimeOptions?.baseUrl ? normalizeAthenaGatewayBaseUrl(runtimeOptions.baseUrl) : gateway.baseUrl;
+    url = buildAthenaGatewayUrl(baseUrl, resolveStorageEndpointPath(endpoint, runtimeOptions));
     headers = gateway.buildHeaders(options);
   } catch (error) {
     return rejectStorageError(
@@ -4487,6 +5011,7 @@ async function callStorageUploadBinaryEndpoint(gateway, endpoint, body, options,
   return parsedBody.parsed.data;
 }
 function createStorageModule(gateway, runtimeOptions) {
+  const resolvedRuntimeOptions = runtimeOptions;
   const callRaw = (path, method, payload, options) => callStorageEndpoint(
     gateway,
     storagePath(path),
@@ -4494,7 +5019,7 @@ function createStorageModule(gateway, runtimeOptions) {
     "raw",
     payload,
     options,
-    runtimeOptions
+    resolvedRuntimeOptions
   );
   const callAthena2 = (path, method, payload, options) => callStorageEndpoint(
     gateway,
@@ -4503,7 +5028,13 @@ function createStorageModule(gateway, runtimeOptions) {
     "athena",
     payload,
     options,
-    runtimeOptions
+    resolvedRuntimeOptions
+  );
+  const callStorageFileVisibility = (fileId, method, input, options) => callAthena2(
+    withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId),
+    method,
+    input,
+    options
   );
   const base = {
     listStorageCatalogs(options) {
@@ -4545,7 +5076,7 @@ function createStorageModule(gateway, runtimeOptions) {
         withPathParam("/storage/files/{file_id}/proxy", "file_id", fileId),
         query
       );
-      return callStorageBinaryEndpoint(gateway, storagePath(path), "GET", options, runtimeOptions);
+      return callStorageBinaryEndpoint(gateway, storagePath(path), "GET", options, resolvedRuntimeOptions);
     },
     updateStorageFile(fileId, input, options) {
       return callAthena2(withPathParam("/storage/files/{file_id}", "file_id", fileId), "PATCH", input, options);
@@ -4554,7 +5085,7 @@ function createStorageModule(gateway, runtimeOptions) {
       return callAthena2(withPathParam("/storage/files/{file_id}", "file_id", fileId), "DELETE", void 0, options);
     },
     setStorageFileVisibility(fileId, input, options) {
-      return callAthena2(withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId), "PATCH", input, options);
+      return callStorageFileVisibility(fileId, "PATCH", input, options);
     },
     deleteStorageFolder(input, options) {
       return callAthena2("/storage/folders/delete", "POST", input, options);
@@ -4592,7 +5123,7 @@ function createStorageModule(gateway, runtimeOptions) {
         storagePath(withPathParam("/storage/files/{file_id}/upload", "file_id", fileId)),
         body,
         options,
-        runtimeOptions
+        resolvedRuntimeOptions
       );
     },
     search(input, options) {
@@ -4626,13 +5157,62 @@ function createStorageModule(gateway, runtimeOptions) {
     publicUrl(fileId, options) {
       return callAthena2(withPathParam("/storage/files/{file_id}/public-url", "file_id", fileId), "GET", void 0, options);
     },
+    proxyUrl(fileId, query, options) {
+      const path = appendQuery(
+        withPathParam("/storage/files/{file_id}/proxy-url", "file_id", fileId),
+        query
+      );
+      return callAthena2(path, "GET", void 0, options);
+    },
     proxy(fileId, query, options) {
       return base.getStorageFileProxy(fileId, query, options);
     },
-    visibility: {
+    versions(fileId, options) {
+      return callAthena2(withPathParam("/storage/files/{file_id}/versions", "file_id", fileId), "GET", void 0, options);
+    },
+    restoreVersion(fileId, versionId, options) {
+      return callAthena2(
+        withPathParam(
+          withPathParam("/storage/files/{file_id}/versions/{version_id}/restore", "file_id", fileId),
+          "version_id",
+          versionId
+        ),
+        "POST",
+        {},
+        options
+      );
+    },
+    deleteVersion(fileId, versionId, options) {
+      return callAthena2(
+        withPathParam(
+          withPathParam("/storage/files/{file_id}/versions/{version_id}", "file_id", fileId),
+          "version_id",
+          versionId
+        ),
+        "DELETE",
+        void 0,
+        options
+      );
+    },
+    retention: {
+      get(fileId, query, options) {
+        const path = appendQuery(
+          withPathParam("/storage/files/{file_id}/retention", "file_id", fileId),
+          query
+        );
+        return callAthena2(path, "GET", void 0, options);
+      },
       set(fileId, input, options) {
+        return callAthena2(withPathParam("/storage/files/{file_id}/retention", "file_id", fileId), "POST", input, options);
+      }
+    },
+    visibility: {
+      update(fileId, input, options) {
         return base.setStorageFileVisibility(fileId, input, options);
       },
+      set(fileId, input, options) {
+        return callStorageFileVisibility(fileId, "POST", input, options);
+      },
       setMany(input, options) {
         return callAthena2("/storage/files/visibility-many", "POST", input, options);
       }
@@ -4727,6 +5307,18 @@ function createStorageModule(gateway, runtimeOptions) {
     uploadUrl(input, options) {
       return callAthena2("/storage/objects/upload-url", "POST", input, options);
     },
+    versions(input, options) {
+      return callAthena2("/storage/objects/versions", "POST", input, options);
+    },
+    restoreVersion(input, options) {
+      return callAthena2("/storage/objects/versions/restore", "POST", input, options);
+    },
+    deleteVersion(input, options) {
+      return callAthena2("/storage/objects/versions/delete", "POST", input, options);
+    },
+    postPolicy(input, options) {
+      return callAthena2("/storage/objects/post-policy", "POST", input, options);
+    },
     folder: objectFolder
   };
   const bucket = {
@@ -4739,6 +5331,39 @@ function createStorageModule(gateway, runtimeOptions) {
     delete(input, options) {
       return callAthena2("/storage/buckets/delete", "POST", input, options);
     },
+    lifecycle: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/lifecycle", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/lifecycle/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/lifecycle/delete", "POST", input, options);
+      }
+    },
+    policy: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/policy", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/policy/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/policy/delete", "POST", input, options);
+      }
+    },
+    publicAccess: {
+      get(input, options) {
+        return callAthena2("/storage/buckets/public-access", "POST", input, options);
+      },
+      set(input, options) {
+        return callAthena2("/storage/buckets/public-access/set", "POST", input, options);
+      },
+      delete(input, options) {
+        return callAthena2("/storage/buckets/public-access/delete", "POST", input, options);
+      }
+    },
     cors: {
       get(input, options) {
         return callAthena2("/storage/buckets/cors", "POST", input, options);
@@ -4750,42 +5375,212 @@ function createStorageModule(gateway, runtimeOptions) {
         return callAthena2("/storage/buckets/cors/delete", "POST", input, options);
       }
     }
-  };
-  const multipart = {
-    create(input, options) {
-      return callAthena2("/storage/multipart/create", "POST", input, options);
-    },
-    signPart(input, options) {
-      return callAthena2("/storage/multipart/sign-part", "POST", input, options);
-    },
-    complete(input, options) {
-      return callAthena2("/storage/multipart/complete", "POST", input, options);
-    },
-    abort(input, options) {
-      return callAthena2("/storage/multipart/abort", "POST", input, options);
-    },
-    listParts(input, options) {
-      return callAthena2("/storage/multipart/list-parts", "POST", input, options);
+  };
+  const multipart = {
+    create(input, options) {
+      return callAthena2("/storage/multipart/create", "POST", input, options);
+    },
+    signPart(input, options) {
+      return callAthena2("/storage/multipart/sign-part", "POST", input, options);
+    },
+    complete(input, options) {
+      return callAthena2("/storage/multipart/complete", "POST", input, options);
+    },
+    abort(input, options) {
+      return callAthena2("/storage/multipart/abort", "POST", input, options);
+    },
+    listParts(input, options) {
+      return callAthena2("/storage/multipart/list-parts", "POST", input, options);
+    }
+  };
+  const audit = {
+    list(input, options) {
+      return callAthena2("/storage/audit/list", "POST", input, options);
+    }
+  };
+  return {
+    ...base,
+    credentials,
+    catalog,
+    file,
+    folder,
+    permission,
+    object,
+    bucket,
+    multipart,
+    audit,
+    delete: file.delete
+  };
+}
+
+// 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;
+  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.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);
     }
-  };
-  const audit = {
-    list(input, options) {
-      return callAthena2("/storage/audit/list", "POST", input, options);
+    if (options.db?.url !== void 0 && options.db.url !== null) {
+      this.dbUrlOverride = options.db.url;
     }
-  };
-  return {
-    ...base,
-    credentials,
-    catalog,
-    file,
-    folder,
-    permission,
-    object,
-    bucket,
-    multipart,
-    audit,
-    delete: file.delete
-  };
+    if (options.gateway?.url !== void 0 && options.gateway.url !== null) {
+      this.gatewayUrlOverride = options.gateway.url;
+    }
+    if (options.dbUrl !== void 0 && options.dbUrl !== null) {
+      this.dbUrlOverride = options.dbUrl;
+    }
+    if (options.gatewayUrl !== void 0 && options.gatewayUrl !== null) {
+      this.gatewayUrlOverride = options.gatewayUrl;
+    }
+    if (options.authUrl !== void 0 && options.authUrl !== null) {
+      this.authUrlOverride = options.authUrl;
+    }
+    if (options.storage?.url !== void 0 && options.storage.url !== null) {
+      this.storageUrlOverride = options.storage.url;
+    }
+    if (options.storageUrl !== void 0 && options.storageUrl !== null) {
+      this.storageUrlOverride = options.storageUrl;
+    }
+    if (options.experimental !== void 0) {
+      this.experimentalOptions = mergeExperimentalOptions(this.experimentalOptions, options.experimental);
+    }
+    if (options.experimental?.athenaStorageBackend && options.experimental.typecheckColumns) {
+      return resolveBuilderReturn(this);
+    }
+    if (options.experimental?.athenaStorageBackend) {
+      return resolveBuilderReturn(this);
+    }
+    if (options.experimental?.typecheckColumns) {
+      return resolveBuilderReturn(this);
+    }
+    return this;
+  }
+  build() {
+    if (!this.rootUrl && !this.dbUrlOverride && !this.gatewayUrlOverride || !this.apiKey) {
+      throw new Error(
+        "AthenaClient requires key plus either .url() or a db/gateway override before .build()"
+      );
+    }
+    return this.buildClient({
+      url: this.rootUrl,
+      key: this.apiKey,
+      client: this.clientName,
+      backend: this.backendConfig,
+      headers: this.defaultHeaders,
+      db: this.dbUrlOverride ? { url: this.dbUrlOverride } : void 0,
+      gateway: this.gatewayUrlOverride ? { url: this.gatewayUrlOverride } : void 0,
+      auth: this.authConfig,
+      authUrl: this.authUrlOverride,
+      storage: this.storageUrlOverride ? { url: this.storageUrlOverride } : void 0,
+      storageUrl: this.storageUrlOverride,
+      experimental: this.experimentalOptions
+    });
+  }
+};
+function createAthenaClientBuilder(buildClient) {
+  return new AthenaClientBuilderImpl(buildClient);
 }
 
 // src/query-ast.ts
@@ -5398,32 +6193,455 @@ function createSelectTransportPlan(input) {
       count: input.options?.count,
       head: input.options?.head
     },
-    debug: {
-      columns: input.columns,
-      conditions,
-      limit: input.state.limit,
-      offset: input.state.offset,
-      currentPage: input.state.currentPage,
-      pageSize: input.state.pageSize,
-      order: input.state.order
+    debug: {
+      columns: input.columns,
+      conditions,
+      limit: input.state.limit,
+      offset: input.state.offset,
+      currentPage: input.state.currentPage,
+      pageSize: input.state.pageSize,
+      order: input.state.order
+    }
+  };
+}
+
+// src/query-debug-ast.ts
+var ATHENA_DEBUG_AST_KEY = "__athenaDebugAst";
+function cloneConditions(conditions) {
+  return conditions.map((condition) => ({ ...condition }));
+}
+function cloneTableBuilderStateAst(state) {
+  return {
+    conditions: cloneConditions(state.conditions),
+    limit: state.limit,
+    offset: state.offset,
+    order: state.order ? { ...state.order } : void 0,
+    currentPage: state.currentPage,
+    pageSize: state.pageSize,
+    totalPages: state.totalPages
+  };
+}
+function cloneRpcBuilderStateAst(state) {
+  return {
+    filters: state.filters.map((filter) => ({ ...filter })),
+    limit: state.limit,
+    offset: state.offset,
+    order: state.order ? { ...state.order } : void 0
+  };
+}
+function toSelectTransportAst(plan) {
+  if (plan.kind === "query") {
+    return {
+      mode: "typed-query",
+      endpoint: "/gateway/query",
+      payload: plan.payload
+    };
+  }
+  return {
+    mode: plan.payload.select !== void 0 ? "structured-fetch" : "compiled-fetch",
+    endpoint: "/gateway/fetch",
+    payload: plan.payload
+  };
+}
+function resolveDebugTableName(tableName) {
+  return tableName ?? "__unknown_table__";
+}
+function buildSelectDebugAst(input) {
+  return {
+    version: 1,
+    kind: "select",
+    tableName: input.tableName,
+    input: {
+      columns: input.columns,
+      state: cloneTableBuilderStateAst(input.state)
+    },
+    transport: toSelectTransportAst(input.plan)
+  };
+}
+function buildFindManyCompiledDebugAst(input) {
+  return {
+    version: 1,
+    kind: "findMany",
+    tableName: input.tableName,
+    input: {
+      select: input.options.select,
+      where: input.options.where,
+      orderBy: input.options.orderBy,
+      limit: input.options.limit
+    },
+    compiled: {
+      columns: input.compiledColumns,
+      baseState: cloneTableBuilderStateAst(input.baseState),
+      executionState: cloneTableBuilderStateAst(input.executionState)
+    },
+    transport: planToFindManyTransport(input.plan)
+  };
+}
+function buildFindManyDirectDebugAst(input) {
+  return {
+    version: 1,
+    kind: "findMany",
+    tableName: input.tableName,
+    input: {
+      select: input.options.select,
+      where: input.options.where,
+      orderBy: input.options.orderBy,
+      limit: input.options.limit
+    },
+    compiled: {
+      columns: input.compiledColumns,
+      baseState: cloneTableBuilderStateAst(input.baseState),
+      executionState: cloneTableBuilderStateAst(input.executionState)
+    },
+    transport: {
+      mode: "direct-ast-fetch",
+      endpoint: "/gateway/fetch",
+      payload: input.payload
+    }
+  };
+}
+function planToFindManyTransport(plan) {
+  if (plan.kind === "query") {
+    return {
+      mode: "compiled-query",
+      endpoint: "/gateway/query",
+      payload: plan.payload
+    };
+  }
+  return {
+    mode: plan.payload.select !== void 0 ? "structured-fetch" : "compiled-fetch",
+    endpoint: "/gateway/fetch",
+    payload: plan.payload
+  };
+}
+function buildInsertDebugAst(payload) {
+  return {
+    version: 1,
+    kind: "insert",
+    tableName: payload.table_name,
+    input: {
+      values: payload.insert_body,
+      returning: payload.columns,
+      count: payload.count,
+      head: payload.head,
+      defaultToNull: payload.default_to_null
+    },
+    transport: {
+      mode: "insert",
+      endpoint: "/gateway/insert",
+      payload
+    }
+  };
+}
+function buildUpsertDebugAst(payload) {
+  return {
+    version: 1,
+    kind: "upsert",
+    tableName: payload.table_name,
+    input: {
+      values: payload.insert_body,
+      updateBody: payload.update_body,
+      onConflict: payload.on_conflict,
+      returning: payload.columns,
+      count: payload.count,
+      head: payload.head,
+      defaultToNull: payload.default_to_null
+    },
+    transport: {
+      mode: "upsert",
+      endpoint: "/gateway/insert",
+      payload
+    }
+  };
+}
+function buildUpdateDebugAst(input) {
+  return {
+    version: 1,
+    kind: "update",
+    tableName: resolveDebugTableName(input.payload.table_name),
+    input: {
+      values: input.payload.set,
+      state: cloneTableBuilderStateAst(input.state),
+      returning: input.payload.columns
+    },
+    transport: {
+      mode: "update",
+      endpoint: "/gateway/update",
+      payload: input.payload
+    }
+  };
+}
+function buildDeleteDebugAst(input) {
+  return {
+    version: 1,
+    kind: "delete",
+    tableName: input.payload.table_name,
+    input: {
+      resourceId: input.payload.resource_id,
+      state: cloneTableBuilderStateAst(input.state),
+      returning: input.payload.columns
+    },
+    transport: {
+      mode: "delete",
+      endpoint: "/gateway/delete",
+      payload: input.payload
+    }
+  };
+}
+function buildRpcDebugAst(input) {
+  return {
+    version: 1,
+    kind: "rpc",
+    functionName: input.functionName,
+    input: {
+      args: input.args,
+      select: input.selectedColumns,
+      state: cloneRpcBuilderStateAst(input.state)
+    },
+    transport: {
+      mode: input.endpoint === "/gateway/rpc" ? "rpc-post" : "rpc-get",
+      endpoint: input.endpoint,
+      payload: input.payload
+    }
+  };
+}
+function buildRawQueryDebugAst(query) {
+  return {
+    version: 1,
+    kind: "query",
+    input: {
+      query
+    },
+    transport: {
+      mode: "raw-query",
+      endpoint: "/gateway/query",
+      payload: {
+        query
+      }
+    }
+  };
+}
+function attachAthenaDebugAst(target, ast) {
+  if (!ast) {
+    return;
+  }
+  if (!target || typeof target !== "object" && typeof target !== "function") {
+    return;
+  }
+  Object.defineProperty(target, ATHENA_DEBUG_AST_KEY, {
+    value: ast,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+}
+function getAthenaDebugAst(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") {
+    return null;
+  }
+  return value[ATHENA_DEBUG_AST_KEY] ?? null;
+}
+
+// src/query-tracing.ts
+var QUERY_TRACE_STACK_SKIP_PATTERNS = [
+  "src\\client.ts",
+  "src/client.ts",
+  "src\\query-tracing.ts",
+  "src/query-tracing.ts",
+  "dist\\client.",
+  "dist/client.",
+  "dist\\query-tracing.",
+  "dist/query-tracing.",
+  "node_modules\\@xylex-group\\athena",
+  "node_modules/@xylex-group/athena",
+  "node:internal",
+  "internal/process"
+];
+function parseQueryTraceCallsiteFrame(frame) {
+  const trimmed = frame.trim();
+  if (!trimmed) {
+    return null;
+  }
+  let body = trimmed.replace(/^at\s+/, "");
+  if (body.startsWith("async ")) {
+    body = body.slice(6);
+  }
+  let functionName;
+  let location = body;
+  const wrappedMatch = body.match(/^(.*?)\s+\((.*)\)$/);
+  if (wrappedMatch) {
+    functionName = wrappedMatch[1].trim() || void 0;
+    location = wrappedMatch[2].trim();
+  }
+  const locationMatch = location.match(/^(.*):(\d+):(\d+)$/);
+  if (!locationMatch) {
+    return null;
+  }
+  const filePath = locationMatch[1].replace(/^file:\/\//, "");
+  const line = Number(locationMatch[2]);
+  const column = Number(locationMatch[3]);
+  if (!Number.isFinite(line) || !Number.isFinite(column)) {
+    return null;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const fileName = normalizedPath.split("/").at(-1) ?? filePath;
+  return {
+    filePath,
+    fileName,
+    line,
+    column,
+    frame: trimmed,
+    functionName
+  };
+}
+function captureQueryTraceCallsite() {
+  const stack = new Error().stack;
+  if (!stack) return null;
+  const frames = stack.split("\n").slice(2).map((frame) => frame.trim()).filter(Boolean);
+  for (const frame of frames) {
+    if (QUERY_TRACE_STACK_SKIP_PATTERNS.some((pattern) => frame.includes(pattern))) {
+      continue;
+    }
+    const callsite = parseQueryTraceCallsiteFrame(frame);
+    if (callsite) return callsite;
+  }
+  const fallback = frames.find((frame) => !frame.includes("captureQueryTraceCallsite"));
+  return fallback ? parseQueryTraceCallsiteFrame(fallback) : null;
+}
+function defaultQueryTraceLogger(event) {
+  const target = event.table ?? event.functionName ?? "gateway";
+  const outcomeState = event.outcome?.error ? "error" : "ok";
+  const banner = `[athena-js][trace] ${event.operation.toUpperCase()} ${event.endpoint} ${target} ${event.durationMs}ms ${outcomeState}`;
+  console.info(banner, event);
+}
+function captureTraceCallsite(tracer) {
+  return tracer?.captureCallsite() ?? null;
+}
+function createTraceCallsiteStore(tracer, initialCallsite) {
+  let storedCallsite = initialCallsite ?? void 0;
+  return {
+    resolve(callsite) {
+      if (callsite) {
+        storedCallsite = callsite;
+        return callsite;
+      }
+      if (storedCallsite !== void 0) {
+        return storedCallsite;
+      }
+      const capturedCallsite = captureTraceCallsite(tracer);
+      if (capturedCallsite) {
+        storedCallsite = capturedCallsite;
+      }
+      return capturedCallsite;
+    }
+  };
+}
+function createQueryTracer(experimental) {
+  const traceOption = experimental?.traceQueries;
+  if (!traceOption) {
+    return void 0;
+  }
+  const logger = typeof traceOption === "object" && traceOption.logger ? traceOption.logger : defaultQueryTraceLogger;
+  const emit = (event) => {
+    try {
+      logger(event);
+    } catch (error) {
+      console.warn("[athena-js][trace] logger failed", error);
+    }
+  };
+  return {
+    captureCallsite: captureQueryTraceCallsite,
+    publishSuccess(context, result, durationMs, callsite) {
+      emit({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        operation: context.operation,
+        endpoint: context.endpoint,
+        table: context.table,
+        functionName: context.functionName,
+        sql: context.sql,
+        payload: context.payload,
+        ast: context.ast,
+        options: context.options,
+        callsite,
+        outcome: {
+          status: result.status,
+          error: result.error,
+          errorDetails: result.errorDetails ?? null,
+          count: result.count ?? null,
+          data: result.data,
+          raw: result.raw
+        }
+      });
+    },
+    publishFailure(context, error, durationMs, callsite) {
+      emit({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        operation: context.operation,
+        endpoint: context.endpoint,
+        table: context.table,
+        functionName: context.functionName,
+        sql: context.sql,
+        payload: context.payload,
+        ast: context.ast,
+        options: context.options,
+        callsite,
+        thrownError: error
+      });
     }
   };
 }
+async function executeWithQueryTrace(tracer, context, runner, callsiteOverride) {
+  const callsite = tracer ? callsiteOverride ?? tracer.captureCallsite() : null;
+  const startedAt = tracer ? Date.now() : 0;
+  try {
+    const result = await runner();
+    attachAthenaDebugAst(result, context.ast);
+    if (tracer) {
+      tracer.publishSuccess(context, result, Date.now() - startedAt, callsite);
+    }
+    return result;
+  } catch (error) {
+    attachAthenaDebugAst(error, context.ast);
+    if (tracer) {
+      tracer.publishFailure(context, error, Date.now() - startedAt, callsite);
+    }
+    throw error;
+  }
+}
+
+// src/schema/model-target.ts
+function normalizeOptionalName(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function isAthenaModelTarget(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return Boolean(candidate.meta && Array.isArray(candidate.meta.primaryKey));
+}
+function resolveAthenaModelTargetTableName(target, options = {}) {
+  const explicitTableName = normalizeOptionalName(target.meta.tableName);
+  if (explicitTableName) {
+    return explicitTableName;
+  }
+  const schemaName = normalizeOptionalName(target.meta.schema ?? options.fallbackSchema);
+  const modelName = normalizeOptionalName(target.meta.model ?? options.fallbackModel);
+  if (!modelName) {
+    throw new Error(
+      "Athena model target is missing meta.model or meta.tableName. Provide one of those before calling from(model)."
+    );
+  }
+  return schemaName ? `${schemaName}.${modelName}` : modelName;
+}
 
 // src/client.ts
 var DEFAULT_COLUMNS = "*";
 var SAFE_CAST_PATTERN = /^[a-z_][a-z0-9_]*(?:\[\])?$/i;
 var ATHENA_NORMALIZED_ERROR_KEY = "__athenaNormalizedError";
-var QUERY_TRACE_STACK_SKIP_PATTERNS = [
-  "src\\client.ts",
-  "src/client.ts",
-  "dist\\client.",
-  "dist/client.",
-  "node_modules\\@xylex-group\\athena",
-  "node_modules/@xylex-group/athena",
-  "node:internal",
-  "internal/process"
-];
 function formatResult(response) {
   const result = {
     data: response.data ?? null,
@@ -5565,154 +6783,6 @@ function createResultError(response, result, normalized) {
     raw: result.raw
   };
 }
-function parseQueryTraceCallsiteFrame(frame) {
-  const trimmed = frame.trim();
-  if (!trimmed) {
-    return null;
-  }
-  let body = trimmed.replace(/^at\s+/, "");
-  if (body.startsWith("async ")) {
-    body = body.slice(6);
-  }
-  let functionName;
-  let location = body;
-  const wrappedMatch = body.match(/^(.*?)\s+\((.*)\)$/);
-  if (wrappedMatch) {
-    functionName = wrappedMatch[1].trim() || void 0;
-    location = wrappedMatch[2].trim();
-  }
-  const locationMatch = location.match(/^(.*):(\d+):(\d+)$/);
-  if (!locationMatch) {
-    return null;
-  }
-  const filePath = locationMatch[1].replace(/^file:\/\//, "");
-  const line = Number(locationMatch[2]);
-  const column = Number(locationMatch[3]);
-  if (!Number.isFinite(line) || !Number.isFinite(column)) {
-    return null;
-  }
-  const normalizedPath = filePath.replace(/\\/g, "/");
-  const fileName = normalizedPath.split("/").at(-1) ?? filePath;
-  return {
-    filePath,
-    fileName,
-    line,
-    column,
-    frame: trimmed,
-    functionName
-  };
-}
-function captureQueryTraceCallsite() {
-  const stack = new Error().stack;
-  if (!stack) return null;
-  const frames = stack.split("\n").slice(2).map((frame) => frame.trim()).filter(Boolean);
-  for (const frame of frames) {
-    if (QUERY_TRACE_STACK_SKIP_PATTERNS.some((pattern) => frame.includes(pattern))) {
-      continue;
-    }
-    const callsite = parseQueryTraceCallsiteFrame(frame);
-    if (callsite) return callsite;
-  }
-  const fallback = frames.find((frame) => !frame.includes("captureQueryTraceCallsite"));
-  return fallback ? parseQueryTraceCallsiteFrame(fallback) : null;
-}
-function defaultQueryTraceLogger(event) {
-  const target = event.table ?? event.functionName ?? "gateway";
-  const outcomeState = event.outcome?.error ? "error" : "ok";
-  const banner = `[athena-js][trace] ${event.operation.toUpperCase()} ${event.endpoint} ${target} ${event.durationMs}ms ${outcomeState}`;
-  console.info(banner, event);
-}
-function captureTraceCallsite(tracer) {
-  return tracer?.captureCallsite() ?? null;
-}
-function createTraceCallsiteStore(tracer, initialCallsite) {
-  let storedCallsite = initialCallsite ?? void 0;
-  return {
-    resolve(callsite) {
-      if (callsite) {
-        storedCallsite = callsite;
-        return callsite;
-      }
-      if (storedCallsite !== void 0) {
-        return storedCallsite;
-      }
-      const capturedCallsite = captureTraceCallsite(tracer);
-      if (capturedCallsite) {
-        storedCallsite = capturedCallsite;
-      }
-      return capturedCallsite;
-    }
-  };
-}
-function createQueryTracer(experimental) {
-  const traceOption = experimental?.traceQueries;
-  if (!traceOption) {
-    return void 0;
-  }
-  const logger = typeof traceOption === "object" && traceOption.logger ? traceOption.logger : defaultQueryTraceLogger;
-  const emit = (event) => {
-    try {
-      logger(event);
-    } catch (error) {
-      console.warn("[athena-js][trace] logger failed", error);
-    }
-  };
-  return {
-    captureCallsite: captureQueryTraceCallsite,
-    publishSuccess(context, result, durationMs, callsite) {
-      emit({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs,
-        operation: context.operation,
-        endpoint: context.endpoint,
-        table: context.table,
-        functionName: context.functionName,
-        sql: context.sql,
-        payload: context.payload,
-        options: context.options,
-        callsite,
-        outcome: {
-          status: result.status,
-          error: result.error,
-          errorDetails: result.errorDetails ?? null,
-          count: result.count ?? null,
-          data: result.data,
-          raw: result.raw
-        }
-      });
-    },
-    publishFailure(context, error, durationMs, callsite) {
-      emit({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs,
-        operation: context.operation,
-        endpoint: context.endpoint,
-        table: context.table,
-        functionName: context.functionName,
-        sql: context.sql,
-        payload: context.payload,
-        options: context.options,
-        callsite,
-        thrownError: error
-      });
-    }
-  };
-}
-async function executeWithQueryTrace(tracer, context, runner, callsiteOverride) {
-  if (!tracer) {
-    return runner();
-  }
-  const callsite = callsiteOverride ?? tracer.captureCallsite();
-  const startedAt = Date.now();
-  try {
-    const result = await runner();
-    tracer.publishSuccess(context, result, Date.now() - startedAt, callsite);
-    return result;
-  } catch (error) {
-    tracer.publishFailure(context, error, Date.now() - startedAt, callsite);
-    throw error;
-  }
-}
 function toSingleResult(response) {
   const payload = response.data;
   const singleData = Array.isArray(payload) ? payload.length ? payload[0] : null : payload ?? null;
@@ -5740,6 +6810,15 @@ function asAthenaJsonObject(value) {
 function asAthenaJsonObjectArray(values) {
   return values;
 }
+function normalizeSelectColumnsInput(columns) {
+  if (columns === void 0) {
+    return void 0;
+  }
+  if (typeof columns === "string") {
+    return columns;
+  }
+  return [...columns];
+}
 function createMutationQuery(executor, defaultColumns = DEFAULT_COLUMNS, tracer, initialCallsite) {
   let selectedColumns = defaultColumns === null ? void 0 : defaultColumns;
   let selectedOptions;
@@ -5749,25 +6828,29 @@ function createMutationQuery(executor, defaultColumns = DEFAULT_COLUMNS, tracer,
     const payloadColumns = columns ?? selectedColumns;
     const payloadOptions = options ?? selectedOptions;
     if (!promise) {
-      promise = executor(payloadColumns, payloadOptions, callsiteStore.resolve(callsite));
+      promise = executor(
+        normalizeSelectColumnsInput(payloadColumns),
+        payloadOptions,
+        callsiteStore.resolve(callsite)
+      );
     }
     return promise;
   };
   const mutationQuery = {
-    select(columns = selectedColumns, options) {
+    select(columns, options) {
       selectedColumns = columns;
       selectedOptions = options ?? selectedOptions;
       return run(columns, options, captureTraceCallsite(tracer));
     },
-    returning(columns = selectedColumns, options) {
+    returning(columns, options) {
       return mutationQuery.select(columns, options);
     },
-    single(columns = selectedColumns, options) {
+    single(columns, options) {
       selectedColumns = columns;
       selectedOptions = options ?? selectedOptions;
       return run(columns, options, captureTraceCallsite(tracer)).then(toSingleResult);
     },
-    maybeSingle(columns = selectedColumns, options) {
+    maybeSingle(columns, options) {
       return mutationQuery.single(columns, options);
     },
     then(onfulfilled, onrejected) {
@@ -6324,7 +7407,10 @@ function createFilterMethods(state, addCondition, self) {
 }
 function toRpcSelect(columns) {
   if (!columns) return void 0;
-  return Array.isArray(columns) ? columns.join(",") : columns;
+  if (typeof columns === "string") {
+    return columns;
+  }
+  return columns.join(",");
 }
 function createRpcFilterMethods(filters, self) {
   const addFilter = (operator, column, value) => {
@@ -6373,7 +7459,7 @@ function createRpcFilterMethods(filters, self) {
     }
   };
 }
-function createRpcBuilder(functionName, args, baseOptions, client, formatGatewayResult, tracer, initialCallsite) {
+function createRpcBuilder(functionName, args, baseOptions, client, formatGatewayResult, tracer, initialCallsite, debugAstEnabled = false) {
   const state = {
     filters: []
   };
@@ -6383,6 +7469,7 @@ function createRpcBuilder(functionName, args, baseOptions, client, formatGateway
   const callsiteStore = createTraceCallsiteStore(tracer, initialCallsite);
   const executeRpc = async (columns, options, callsite) => {
     const mergedOptions = mergeOptions(baseOptions, options);
+    const normalizedSelectedColumns = normalizeSelectColumnsInput(columns);
     const payload = {
       function: functionName,
       args,
@@ -6397,6 +7484,14 @@ function createRpcBuilder(functionName, args, baseOptions, client, formatGateway
     };
     const endpoint = mergedOptions?.get ? `/rpc/${functionName}` : "/gateway/rpc";
     const sql = buildRpcDebugSql(payload);
+    const debugAst = debugAstEnabled ? buildRpcDebugAst({
+      functionName,
+      args,
+      selectedColumns: normalizedSelectedColumns,
+      state,
+      payload,
+      endpoint
+    }) : void 0;
     return executeWithQueryTrace(
       tracer,
       {
@@ -6405,6 +7500,7 @@ function createRpcBuilder(functionName, args, baseOptions, client, formatGateway
         functionName,
         sql,
         payload,
+        ast: debugAst,
         options: mergedOptions
       },
       async () => {
@@ -6425,7 +7521,7 @@ function createRpcBuilder(functionName, args, baseOptions, client, formatGateway
   const builder = {};
   const filterMethods = createRpcFilterMethods(state.filters, builder);
   Object.assign(builder, filterMethods, {
-    select(columns = selectedColumns, options) {
+    select(columns, options) {
       selectedColumns = columns;
       selectedOptions = options ?? selectedOptions;
       return run(columns, options, captureTraceCallsite(tracer));
@@ -6470,6 +7566,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
   const state = {
     conditions: []
   };
+  const debugAstEnabled = Boolean(experimental?.debugAst);
   const addCondition = (operator, column, value, hints) => {
     const condition = { operator };
     if (column) {
@@ -6513,15 +7610,27 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
     addCondition,
     builder
   );
-  const runSelect = async (columns = DEFAULT_COLUMNS, options, executionState = snapshotState(), callsite) => {
+  const runSelect = async (columns = DEFAULT_COLUMNS, options, executionState = snapshotState(), callsite, debugAstFactory) => {
+    const runtimeColumns = normalizeSelectColumnsInput(columns) ?? DEFAULT_COLUMNS;
     const resolvedTableName = resolveTableNameForCall(tableName, options?.schema);
     const plan = createSelectTransportPlan({
       tableName: resolvedTableName,
-      columns,
+      columns: runtimeColumns,
       state: executionState,
       options,
       buildTypedSelectQuery
     });
+    const debugAst = debugAstEnabled ? debugAstFactory?.({
+      tableName: resolvedTableName,
+      columns: runtimeColumns,
+      executionState,
+      plan
+    }) ?? buildSelectDebugAst({
+      tableName: resolvedTableName,
+      columns: runtimeColumns,
+      state: executionState,
+      plan
+    }) : void 0;
     if (plan.kind === "query") {
       return executeExperimentalRead(
         experimental,
@@ -6533,6 +7642,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             table: resolvedTableName,
             sql: plan.query,
             payload: plan.payload,
+            ast: debugAst,
             options
           },
           async () => {
@@ -6557,6 +7667,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           table: resolvedTableName,
           sql,
           payload: plan.payload,
+          ast: debugAst,
           options
         },
         async () => {
@@ -6570,7 +7681,11 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
   const createSelectChain = (columns, options, initialCallsite) => {
     const chain = {};
     const callsiteStore = createTraceCallsiteStore(tracer, initialCallsite);
-    const filterMethods2 = createFilterMethods(state, addCondition, chain);
+    const filterMethods2 = createFilterMethods(
+      state,
+      addCondition,
+      chain
+    );
     Object.assign(chain, filterMethods2, {
       async single(cols, opts) {
         const r = await runSelect(
@@ -6657,6 +7772,14 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           limit: executionState.limit,
           order: executionState.order
         });
+        const debugAst = debugAstEnabled ? buildFindManyDirectDebugAst({
+          tableName: resolvedTableName,
+          options,
+          compiledColumns: columns,
+          baseState,
+          executionState,
+          payload
+        }) : void 0;
         return executeExperimentalRead(
           experimental,
           () => executeWithQueryTrace(
@@ -6666,7 +7789,8 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
               endpoint: "/gateway/fetch",
               table: resolvedTableName,
               sql,
-              payload
+              payload,
+              ast: debugAst
             },
             async () => {
               const response = await client.fetchGateway(
@@ -6682,7 +7806,15 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
         columns,
         void 0,
         executionState,
-        callsite
+        callsite,
+        debugAstEnabled ? ({ tableName: resolvedTableName, executionState: tracedState, plan }) => buildFindManyCompiledDebugAst({
+          tableName: resolvedTableName,
+          options,
+          compiledColumns: columns,
+          baseState,
+          executionState: tracedState,
+          plan
+        }) : void 0
       );
     },
     insert(values, options) {
@@ -6702,6 +7834,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             payload.default_to_null = mergedOptions.defaultToNull;
           }
           const sql = buildInsertDebugSql(payload);
+          const debugAst = debugAstEnabled ? buildInsertDebugAst(payload) : void 0;
           return executeWithQueryTrace(
             tracer,
             {
@@ -6710,6 +7843,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
               table: resolvedTableName,
               sql,
               payload,
+              ast: debugAst,
               options: mergedOptions
             },
             async () => {
@@ -6735,6 +7869,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           payload.default_to_null = mergedOptions.defaultToNull;
         }
         const sql = buildInsertDebugSql(payload);
+        const debugAst = debugAstEnabled ? buildInsertDebugAst(payload) : void 0;
         return executeWithQueryTrace(
           tracer,
           {
@@ -6743,6 +7878,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             table: resolvedTableName,
             sql,
             payload,
+            ast: debugAst,
             options: mergedOptions
           },
           async () => {
@@ -6773,6 +7909,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             payload.default_to_null = mergedOptions.defaultToNull;
           }
           const sql = buildInsertDebugSql(payload);
+          const debugAst = debugAstEnabled ? buildUpsertDebugAst(payload) : void 0;
           return executeWithQueryTrace(
             tracer,
             {
@@ -6781,6 +7918,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
               table: resolvedTableName,
               sql,
               payload,
+              ast: debugAst,
               options: mergedOptions
             },
             async () => {
@@ -6808,6 +7946,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           payload.default_to_null = mergedOptions.defaultToNull;
         }
         const sql = buildInsertDebugSql(payload);
+        const debugAst = debugAstEnabled ? buildUpsertDebugAst(payload) : void 0;
         return executeWithQueryTrace(
           tracer,
           {
@@ -6816,6 +7955,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             table: resolvedTableName,
             sql,
             payload,
+            ast: debugAst,
             options: mergedOptions
           },
           async () => {
@@ -6830,7 +7970,8 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
     update(values, options) {
       const mutationCallsite = captureTraceCallsite(tracer);
       const executeUpdate = async (columns, selectOptions, callsite) => {
-        const filters = state.conditions.length ? [...state.conditions] : void 0;
+        const executionState = snapshotState();
+        const filters = executionState.conditions.length ? [...executionState.conditions] : void 0;
         const mergedOptions = mergeOptions(options, selectOptions);
         const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
         const payload = {
@@ -6839,12 +7980,16 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           conditions: filters,
           strip_nulls: mergedOptions?.stripNulls ?? true
         };
-        if (state.order) payload.sort_by = state.order;
-        if (state.currentPage !== void 0) payload.current_page = state.currentPage;
-        if (state.pageSize !== void 0) payload.page_size = state.pageSize;
-        if (state.totalPages !== void 0) payload.total_pages = state.totalPages;
+        if (executionState.order) payload.sort_by = executionState.order;
+        if (executionState.currentPage !== void 0) payload.current_page = executionState.currentPage;
+        if (executionState.pageSize !== void 0) payload.page_size = executionState.pageSize;
+        if (executionState.totalPages !== void 0) payload.total_pages = executionState.totalPages;
         if (columns) payload.columns = columns;
         const sql = buildUpdateDebugSql(payload);
+        const debugAst = debugAstEnabled ? buildUpdateDebugAst({
+          state: executionState,
+          payload
+        }) : void 0;
         return executeWithQueryTrace(
           tracer,
           {
@@ -6853,6 +7998,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             table: resolvedTableName,
             sql,
             payload,
+            ast: debugAst,
             options: mergedOptions
           },
           async () => {
@@ -6876,6 +8022,11 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
       }
       const mutationCallsite = captureTraceCallsite(tracer);
       const executeDelete = async (columns, selectOptions, callsite) => {
+        const executionState = snapshotState();
+        const debugState = {
+          ...executionState,
+          conditions: filters ? filters.map((condition) => ({ ...condition })) : []
+        };
         const mergedOptions = mergeOptions(options, selectOptions);
         const resolvedTableName = resolveTableNameForCall(tableName, mergedOptions?.schema);
         const payload = {
@@ -6883,12 +8034,16 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
           resource_id: resourceId,
           conditions: filters
         };
-        if (state.order) payload.sort_by = state.order;
-        if (state.currentPage !== void 0) payload.current_page = state.currentPage;
-        if (state.pageSize !== void 0) payload.page_size = state.pageSize;
-        if (state.totalPages !== void 0) payload.total_pages = state.totalPages;
+        if (executionState.order) payload.sort_by = executionState.order;
+        if (executionState.currentPage !== void 0) payload.current_page = executionState.currentPage;
+        if (executionState.pageSize !== void 0) payload.page_size = executionState.pageSize;
+        if (executionState.totalPages !== void 0) payload.total_pages = executionState.totalPages;
         if (columns) payload.columns = columns;
         const sql = buildDeleteDebugSql(payload);
+        const debugAst = debugAstEnabled ? buildDeleteDebugAst({
+          state: debugState,
+          payload
+        }) : void 0;
         return executeWithQueryTrace(
           tracer,
           {
@@ -6897,6 +8052,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
             table: resolvedTableName,
             sql,
             payload,
+            ast: debugAst,
             options: mergedOptions
           },
           async () => {
@@ -6924,6 +8080,7 @@ function createTableBuilder(tableName, client, formatGatewayResult, tracer, expe
   return builder;
 }
 function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
+  const debugAstEnabled = Boolean(experimental?.debugAst);
   return async function query(query, options) {
     const normalizedQuery = query.trim();
     if (!normalizedQuery) {
@@ -6940,6 +8097,7 @@ function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
           endpoint: "/gateway/query",
           sql: normalizedQuery,
           payload,
+          ast: debugAstEnabled ? buildRawQueryDebugAst(normalizedQuery) : void 0,
           options
         },
         async () => {
@@ -6951,6 +8109,96 @@ function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
     );
   };
 }
+function resolveClientServiceBaseUrl(value, label) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return normalizeAthenaGatewayBaseUrl(value, { label });
+}
+function appendServicePath(baseUrl, segment) {
+  const normalizedBaseUrl = normalizeAthenaGatewayBaseUrl(baseUrl, { label: "Athena public base URL" });
+  return `${normalizedBaseUrl}/${segment.replace(/^\/+/, "")}`;
+}
+function resolveServiceUrlOverride(value, label) {
+  return resolveClientServiceBaseUrl(value, label);
+}
+function resolveServiceUrls(config) {
+  const baseUrl = resolveClientServiceBaseUrl(config.url, "Athena public base URL");
+  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),
+    storageUrl: resolveServiceUrlOverride(config.storage?.url, "Athena storage base URL") ?? resolveServiceUrlOverride(config.storageUrl, "Athena storage base URL") ?? (baseUrl ? appendServicePath(baseUrl, "storage") : void 0)
+  };
+}
+function resolveOptionalClientName(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : void 0;
+}
+function resolveRequiredClientApiKey(value) {
+  if (value === void 0 || value === null) {
+    throw new Error(
+      "Athena API key is required. Pass createClient(url, key) with a real API key, or set key in the config object."
+    );
+  }
+  const normalizedValue = value.trim();
+  if (!normalizedValue) {
+    throw new Error(
+      "Athena API key is required. Pass createClient(url, key) with a real API key, or set key in the config object."
+    );
+  }
+  return normalizedValue;
+}
+function normalizeAuthClientConfig(auth, defaultBaseUrl) {
+  if (!auth && defaultBaseUrl === void 0) {
+    return void 0;
+  }
+  const {
+    url,
+    baseUrl,
+    apiKey,
+    bearerToken,
+    ...rest
+  } = auth ?? {};
+  const normalized = {
+    ...rest
+  };
+  const resolvedBaseUrl = resolveClientServiceBaseUrl(
+    url ?? baseUrl ?? defaultBaseUrl,
+    "Athena auth base URL"
+  );
+  if (resolvedBaseUrl !== void 0) {
+    normalized.baseUrl = resolvedBaseUrl;
+  }
+  if (typeof apiKey === "string") {
+    normalized.apiKey = apiKey;
+  }
+  if (typeof bearerToken === "string") {
+    normalized.bearerToken = bearerToken;
+  }
+  return normalized;
+}
+function resolveCreateClientConfig(config) {
+  const resolvedUrls = resolveServiceUrls(config);
+  if (!resolvedUrls.dbUrl) {
+    throw new Error(
+      "Athena DB base URL is required. Pass createClient(url, key) for a unified root, or set db.url / gateway.url / gatewayUrl explicitly."
+    );
+  }
+  return {
+    baseUrl: resolvedUrls.dbUrl,
+    apiKey: resolveRequiredClientApiKey(config.key),
+    client: resolveOptionalClientName(config.client),
+    backend: toBackendConfig(config.backend),
+    headers: config.headers,
+    auth: config.auth,
+    authUrl: resolvedUrls.authUrl,
+    storageUrl: resolvedUrls.storageUrl,
+    experimental: config.experimental
+  };
+}
 function createClientFromConfig(config) {
   const gatewayHeaders = {
     ...config.headers ?? {}
@@ -6967,14 +8215,31 @@ function createClientFromConfig(config) {
   });
   const formatGatewayResult = createResultFormatter(config.experimental);
   const queryTracer = createQueryTracer(config.experimental);
-  const auth = createAuthClient(config.auth);
-  const from = (table, options) => createTableBuilder(
-    resolveTableNameForCall(table, options?.schema),
-    gateway,
-    formatGatewayResult,
-    queryTracer,
-    config.experimental
-  );
+  const auth = createAuthClient(normalizeAuthClientConfig(config.auth, config.authUrl));
+  function from(tableOrModel, options) {
+    if (isAthenaModelTarget(tableOrModel)) {
+      if (options?.schema !== void 0) {
+        throw new Error(
+          "from(model) does not accept a schema override because the model already defines its target."
+        );
+      }
+      return createTableBuilder(
+        resolveAthenaModelTargetTableName(tableOrModel),
+        gateway,
+        formatGatewayResult,
+        queryTracer,
+        config.experimental
+      );
+    }
+    const resolvedTableName = resolveTableNameForCall(tableOrModel, options?.schema);
+    return createTableBuilder(
+      resolvedTableName,
+      gateway,
+      formatGatewayResult,
+      queryTracer,
+      config.experimental
+    );
+  }
   const rpc = (fn, args, options) => {
     const normalizedFn = fn.trim();
     if (!normalizedFn) {
@@ -6987,10 +8252,16 @@ function createClientFromConfig(config) {
       gateway,
       formatGatewayResult,
       queryTracer,
-      captureTraceCallsite(queryTracer)
+      captureTraceCallsite(queryTracer),
+      Boolean(config.experimental?.debugAst)
     );
   };
-  const query = createQueryBuilder(gateway, formatGatewayResult, config.experimental, queryTracer);
+  const query = createQueryBuilder(
+    gateway,
+    formatGatewayResult,
+    config.experimental,
+    queryTracer
+  );
   const db = createDbModule({ from, rpc, query });
   const sdkClient = {
     from,
@@ -7003,170 +8274,448 @@ function createClientFromConfig(config) {
   if (config.experimental?.athenaStorageBackend) {
     const storageClient = {
       ...sdkClient,
-      storage: createStorageModule(gateway, config.experimental.storage)
+      storage: createStorageModule(gateway, {
+        ...config.experimental.storage,
+        ...config.storageUrl ? {
+          baseUrl: config.storageUrl,
+          stripBasePath: true
+        } : {}
+      })
     };
     return storageClient;
   }
   return sdkClient;
 }
-var DEFAULT_BACKEND = { type: "athena" };
-function toBackendConfig(b) {
-  if (!b) return DEFAULT_BACKEND;
-  return typeof b === "string" ? { type: b } : b;
-}
-function mergeAuthClientConfig(current, next) {
-  const merged = {
-    ...current ?? {},
-    ...next
-  };
-  if (current?.headers || next.headers) {
-    merged.headers = {
-      ...current?.headers ?? {},
-      ...next.headers ?? {}
-    };
+var AthenaClient = class {
+  /** Create a fluent builder for a strongly-typed Athena SDK client. */
+  static builder() {
+    return createAthenaClientBuilder((config) => createClientFromConfig(resolveCreateClientConfig(config)));
   }
-  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
-    };
+  /** 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;
+    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"
+      );
+    }
+    return createClient({
+      url,
+      gatewayUrl,
+      authUrl,
+      storageUrl,
+      key
+    });
   }
-  if (current?.storage || next.storage) {
-    merged.storage = {
-      ...current?.storage ?? {},
-      ...next.storage ?? {}
-    };
+};
+function createClient(configOrUrl, apiKey, options) {
+  if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
+    return createClientFromConfig(resolveCreateClientConfig({
+      url: configOrUrl,
+      key: apiKey ?? "",
+      ...options
+    }));
   }
-  return merged;
+  return createClientFromConfig(resolveCreateClientConfig(configOrUrl));
 }
-var AthenaClientBuilderImpl = class {
-  baseUrl;
-  apiKey;
-  backendConfig = DEFAULT_BACKEND;
-  clientName;
-  defaultHeaders;
-  authConfig;
-  experimentalOptions;
-  url(url) {
-    this.baseUrl = 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;
+
+// src/gateway/types.ts
+var Backend = {
+  Athena: { type: "athena" },
+  Postgrest: { type: "postgrest" },
+  PostgreSQL: { type: "postgresql" },
+  ScyllaDB: { type: "scylladb" }
+};
+
+// src/schema/definitions.ts
+function defineModel(input) {
+  return input;
+}
+function defineSchema(models) {
+  return { models };
+}
+function defineDatabase(schemas) {
+  return { schemas };
+}
+function defineRegistry(databases) {
+  return databases;
+}
+
+// src/schema/model-form.ts
+function resolveNullishValue(mode) {
+  if (mode === "undefined") return void 0;
+  if (mode === "null") return null;
+  return "";
+}
+function isRecord10(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNullableColumn(model, key) {
+  const nullable = model.meta.nullable;
+  return nullable?.[key] === true;
+}
+function toModelFormDefaults(model, values, options) {
+  const source = values;
+  if (!isRecord10(source)) {
+    return {};
   }
-  experimental(options) {
-    this.experimentalOptions = mergeExperimentalOptions(this.experimentalOptions, options);
-    return options.athenaStorageBackend ? this : this;
+  const mode = options?.nullishMode ?? "empty-string";
+  const nullishValue = resolveNullishValue(mode);
+  const result = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === null && isNullableColumn(model, key)) {
+      result[key] = nullishValue;
+      continue;
+    }
+    result[key] = value;
   }
-  options(options) {
-    if (options.client !== void 0) {
-      this.clientName = options.client;
+  return result;
+}
+function toModelPayload(model, formValues, options) {
+  const emptyStringAsNull = options?.emptyStringAsNull ?? true;
+  const stripUndefined = options?.stripUndefined ?? true;
+  const result = {};
+  for (const [key, rawValue] of Object.entries(formValues)) {
+    if (rawValue === void 0 && stripUndefined) {
+      continue;
     }
-    if (options.backend !== void 0) {
-      this.backendConfig = toBackendConfig(options.backend);
+    if (emptyStringAsNull && rawValue === "" && isNullableColumn(model, key)) {
+      result[key] = null;
+      continue;
     }
-    if (options.headers !== void 0) {
-      this.defaultHeaders = {
-        ...this.defaultHeaders ?? {},
-        ...options.headers
-      };
+    result[key] = rawValue;
+  }
+  return result;
+}
+function createModelFormAdapter(model) {
+  return {
+    model,
+    toDefaults(values, options) {
+      return toModelFormDefaults(model, values, options);
+    },
+    toInsert(values, options) {
+      return toModelPayload(model, values, options);
+    },
+    toUpdate(values, options) {
+      return toModelPayload(model, values, options);
     }
-    if (options.auth !== void 0) {
-      this.authConfig = mergeAuthClientConfig(this.authConfig, options.auth);
+  };
+}
+
+// src/schema/table-columns.ts
+var COLUMN_CONFIG = /* @__PURE__ */ Symbol("athena.column.config");
+function createColumnBuilder(config) {
+  return {
+    [COLUMN_CONFIG]: config,
+    optional() {
+      return createColumnBuilder({
+        ...config,
+        nullable: true
+      });
+    },
+    from(columnName) {
+      return createColumnBuilder({
+        ...config,
+        columnName
+      });
+    },
+    defaulted() {
+      return createColumnBuilder({
+        ...config,
+        hasDefault: true
+      });
+    },
+    generated() {
+      return createColumnBuilder({
+        ...config,
+        isGenerated: true
+      });
     }
-    if (options.experimental !== void 0) {
-      this.experimentalOptions = mergeExperimentalOptions(this.experimentalOptions, options.experimental);
+  };
+}
+function isColumnBuilder(value) {
+  return value !== null && typeof value === "object" && COLUMN_CONFIG in value;
+}
+function getColumnConfig(column) {
+  return column[COLUMN_CONFIG];
+}
+function string() {
+  return createColumnBuilder({
+    kind: "string",
+    nullable: false,
+    hasDefault: false,
+    isGenerated: false
+  });
+}
+function number() {
+  return createColumnBuilder({
+    kind: "number",
+    nullable: false,
+    hasDefault: false,
+    isGenerated: false
+  });
+}
+function boolean() {
+  return createColumnBuilder({
+    kind: "boolean",
+    nullable: false,
+    hasDefault: false,
+    isGenerated: false
+  });
+}
+function json(schema) {
+  return createColumnBuilder({
+    kind: "json",
+    nullable: false,
+    hasDefault: false,
+    isGenerated: false,
+    jsonSchema: schema
+  });
+}
+function enumeration(values) {
+  if (values.length === 0) {
+    throw new Error("enumeration() requires at least one value");
+  }
+  return createColumnBuilder({
+    kind: "enumeration",
+    nullable: false,
+    hasDefault: false,
+    isGenerated: false,
+    enumValues: values
+  });
+}
+
+// src/schema/table-schemas.ts
+function isScalarFormKind(kind) {
+  return kind === "string" || kind === "number" || kind === "boolean" || kind === "enumeration";
+}
+function createBaseSchema(column) {
+  const config = getColumnConfig(column);
+  switch (config.kind) {
+    case "boolean":
+      return zod.z.boolean();
+    case "number":
+      return zod.z.number();
+    case "json":
+      return config.jsonSchema ?? zod.z.unknown();
+    case "enumeration":
+      if (!config.enumValues || config.enumValues.length === 0) {
+        return zod.z.string();
+      }
+      return zod.z.enum(config.enumValues);
+    case "string":
+    default:
+      return zod.z.string();
+  }
+}
+function applyNullable(schema, column) {
+  const config = getColumnConfig(column);
+  return config.nullable ? schema.nullable() : schema;
+}
+function applyInsertOptional(schema, column) {
+  const config = getColumnConfig(column);
+  return config.nullable || config.hasDefault ? schema.optional() : schema;
+}
+function createFormFieldSchema(column) {
+  const config = getColumnConfig(column);
+  const base = createBaseSchema(column);
+  let schema;
+  if (config.nullable && isScalarFormKind(config.kind)) {
+    schema = zod.z.union([base, zod.z.literal("")]).transform((value) => value === "" ? null : value);
+  } else {
+    schema = applyNullable(base, column);
+  }
+  if (config.nullable || config.hasDefault) {
+    schema = schema.optional();
+  }
+  return schema;
+}
+function buildTableSchemaBundle(model, columns) {
+  const rowShape = {};
+  const insertShape = {};
+  const updateShape = {};
+  const formShape = {};
+  for (const [columnName, column] of Object.entries(columns)) {
+    const config = getColumnConfig(column);
+    const base = createBaseSchema(column);
+    rowShape[columnName] = applyNullable(base, column);
+    if (config.isGenerated) {
+      continue;
     }
-    return options.experimental?.athenaStorageBackend ? this : this;
+    insertShape[columnName] = applyInsertOptional(applyNullable(base, column), column);
+    updateShape[columnName] = applyNullable(base, column).optional();
+    formShape[columnName] = createFormFieldSchema(column);
   }
-  build() {
-    if (!this.baseUrl || !this.apiKey) {
-      throw new Error("AthenaClient requires url and key; call .url() and .key() before .build()");
+  const rowSchema = zod.z.object(rowShape);
+  const insertSchema = zod.z.object(insertShape);
+  const updateSchema = zod.z.object(updateShape);
+  const formSchema = zod.z.object(formShape).transform((value) => toModelPayload(model, value));
+  return {
+    row: rowSchema,
+    insert: insertSchema,
+    update: updateSchema,
+    form: formSchema
+  };
+}
+
+// src/schema/table-builder.ts
+function assertColumnRecord(columns) {
+  for (const [columnName, column] of Object.entries(columns)) {
+    if (!isColumnBuilder(column)) {
+      throw new Error(`Invalid column definition for "${columnName}"`);
     }
-    return createClientFromConfig({
-      baseUrl: this.baseUrl,
-      apiKey: this.apiKey,
-      client: this.clientName,
-      backend: this.backendConfig,
-      headers: this.defaultHeaders,
-      auth: this.authConfig,
-      experimental: this.experimentalOptions
-    });
   }
-};
-var AthenaClient = class _AthenaClient {
-  /** Create a fluent builder for a strongly-typed Athena SDK client. */
-  static builder() {
-    return new AthenaClientBuilderImpl();
+}
+function normalizeMappedNameInput(mappedName) {
+  const normalized = mappedName.trim();
+  if (!normalized) {
+    throw new Error("table.from() requires a non-empty table name");
+  }
+  return normalized;
+}
+function normalizeSchemaNameInput(schemaName) {
+  const normalized = schemaName.trim();
+  if (!normalized) {
+    throw new Error("table.schema() requires a non-empty schema name");
+  }
+  if (normalized.includes(".")) {
+    throw new Error(
+      'table.schema() expects a schema name without dots. Use .schema("schema").from("table") or .from("schema.table").'
+    );
+  }
+  return normalized;
+}
+function resolveTableTarget(logicalName, mappedName, explicitSchemaName) {
+  const physicalName = (mappedName ?? logicalName).trim();
+  if (!physicalName) {
+    throw new Error("table() requires a non-empty name");
   }
-  /** Build a client from process environment variables. */
-  static fromEnvironment() {
-    const url = process.env.ATHENA_URL ?? process.env.ATHENA_GATEWAY_URL;
-    const key = process.env.ATHENA_API_KEY ?? process.env.ATHENA_GATEWAY_API_KEY;
-    if (!url || !key) {
+  const firstDot = physicalName.indexOf(".");
+  const lastDot = physicalName.lastIndexOf(".");
+  if (firstDot > 0 && firstDot === lastDot) {
+    const inlineSchema = physicalName.slice(0, firstDot).trim();
+    const inlineModel = physicalName.slice(firstDot + 1).trim();
+    if (!inlineSchema || !inlineModel) {
+      throw new Error('table.from() schema-qualified names must look like "schema.table"');
+    }
+    if (explicitSchemaName && explicitSchemaName !== inlineSchema) {
       throw new Error(
-        "ATHENA_URL and ATHENA_API_KEY (or ATHENA_GATEWAY_URL and ATHENA_GATEWAY_API_KEY) are required"
+        `table schema "${explicitSchemaName}" conflicts with mapped table "${physicalName}"`
       );
     }
-    return _AthenaClient.builder().url(url).key(key).build();
+    return {
+      schema: explicitSchemaName ?? inlineSchema,
+      model: inlineModel,
+      qualifiedName: `${explicitSchemaName ?? inlineSchema}.${inlineModel}`
+    };
   }
-};
-function createClient(url, apiKey, options) {
-  return createClientFromConfig({
-    baseUrl: url,
-    apiKey,
-    client: options?.client,
-    backend: toBackendConfig(options?.backend),
-    headers: options?.headers,
-    auth: options?.auth,
-    experimental: options?.experimental
-  });
+  if (explicitSchemaName) {
+    return {
+      schema: explicitSchemaName,
+      model: physicalName,
+      qualifiedName: `${explicitSchemaName}.${physicalName}`
+    };
+  }
+  return {
+    model: physicalName,
+    qualifiedName: physicalName
+  };
 }
-
-// src/gateway/types.ts
-var Backend = {
-  Athena: { type: "athena" },
-  Postgrest: { type: "postgrest" },
-  PostgreSQL: { type: "postgresql" },
-  ScyllaDB: { type: "scylladb" }
-};
-
-// src/schema/definitions.ts
-function defineModel(input) {
-  return input;
+function toColumnMetadata(column) {
+  const config = getColumnConfig(column);
+  return {
+    kind: config.kind,
+    columnName: config.columnName,
+    nullable: config.nullable,
+    hasDefault: config.hasDefault,
+    isGenerated: config.isGenerated,
+    enumValues: config.enumValues
+  };
 }
-function defineSchema(models) {
-  return { models };
+function buildNullableMap(columns) {
+  return Object.fromEntries(
+    Object.entries(columns).map(([columnName, column]) => [columnName, getColumnConfig(column).nullable])
+  );
 }
-function defineDatabase(schemas) {
-  return { schemas };
+function buildColumnMetadataMap(columns) {
+  return Object.fromEntries(
+    Object.entries(columns).map(([columnName, column]) => [columnName, toColumnMetadata(column)])
+  );
 }
-function defineRegistry(databases) {
-  return databases;
+function finalizeTable(name, mappedName, schemaName, columns, primaryKey) {
+  const target = resolveTableTarget(name, mappedName, schemaName);
+  const model = defineModel({
+    meta: {
+      schema: target.schema,
+      model: target.model,
+      primaryKey: [...primaryKey],
+      nullable: buildNullableMap(columns),
+      columns: buildColumnMetadataMap(columns)
+    }
+  });
+  const schemas = buildTableSchemaBundle(model, columns);
+  return Object.assign(model, {
+    kind: "table",
+    name,
+    mappedName,
+    schemaName: target.schema,
+    tableName: target.model,
+    qualifiedName: target.qualifiedName,
+    columns,
+    schemas
+  });
+}
+function createColumnsBuilder(name, mappedName, schemaName, columns) {
+  assertColumnRecord(columns);
+  return {
+    name,
+    mappedName,
+    schemaName,
+    columns,
+    from(tableName) {
+      const normalizedTableName = normalizeMappedNameInput(tableName);
+      resolveTableTarget(name, normalizedTableName, schemaName);
+      return createColumnsBuilder(name, normalizedTableName, schemaName, columns);
+    },
+    schema(nextSchemaName) {
+      const normalizedSchemaName = normalizeSchemaNameInput(nextSchemaName);
+      resolveTableTarget(name, mappedName, normalizedSchemaName);
+      return createColumnsBuilder(name, mappedName, normalizedSchemaName, columns);
+    },
+    primaryKey(...keys) {
+      return finalizeTable(name, mappedName, schemaName, columns, keys);
+    }
+  };
+}
+function createTableBuilder2(name, mappedName, schemaName) {
+  return {
+    name,
+    mappedName,
+    schemaName,
+    from(tableName) {
+      const normalizedTableName = normalizeMappedNameInput(tableName);
+      resolveTableTarget(name, normalizedTableName, schemaName);
+      return createTableBuilder2(name, normalizedTableName, schemaName);
+    },
+    schema(nextSchemaName) {
+      const normalizedSchemaName = normalizeSchemaNameInput(nextSchemaName);
+      resolveTableTarget(name, mappedName, normalizedSchemaName);
+      return createTableBuilder2(name, mappedName, normalizedSchemaName);
+    },
+    columns(columns) {
+      return createColumnsBuilder(name, mappedName, schemaName, columns);
+    }
+  };
+}
+function table(name) {
+  if (!name.trim()) {
+    throw new Error("table() requires a non-empty name");
+  }
+  return createTableBuilder2(name, void 0, void 0);
 }
 
 // src/schema/typed-client.ts
@@ -7208,12 +8757,10 @@ var RegistryNavigator = class {
     return modelDef;
   }
   resolveTableName(schema, model, modelDef) {
-    if (modelDef.meta.tableName) {
-      return modelDef.meta.tableName;
-    }
-    const schemaName = modelDef.meta.schema ?? schema;
-    const modelName = modelDef.meta.model ?? model;
-    return `${schemaName}.${modelName}`;
+    return resolveAthenaModelTargetTableName(modelDef, {
+      fallbackSchema: schema,
+      fallbackModel: model
+    });
   }
 };
 var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
@@ -7240,17 +8787,20 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
     this.clientOptions = {
       backend: input.options?.backend,
       client: input.options?.client,
-      headers: input.options?.headers
+      headers: input.options?.headers,
+      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)
+      headers: this.tenantHeaderMapper.apply(this.clientOptions.headers, tenantContext),
+      experimental: this.clientOptions.experimental
     });
     this.db = this.baseClient.db;
   }
-  from(table, options) {
-    return this.baseClient.from(table, options);
+  from(tableOrModel, options) {
+    const from = this.baseClient.from;
+    return from(tableOrModel, options);
   }
   rpc(fn, args, options) {
     return this.baseClient.rpc(fn, args, options);
@@ -7272,7 +8822,8 @@ var TypedAthenaClientImpl = class _TypedAthenaClientImpl {
         tenantContext: {
           ...this.tenantContext,
           ...context ?? {}
-        }
+        },
+        experimental: this.clientOptions.experimental
       }
     });
   }
@@ -7378,8 +8929,8 @@ var POSTGRES_CATALOG_SQL = {
     ORDER BY sn.nspname, sc.relname, con.conname;
   `
 };
-function tableKey(schema, table) {
-  return `${schema}.${table}`;
+function tableKey(schema, table2) {
+  return `${schema}.${table2}`;
 }
 function relationKey(...parts) {
   const base = parts.join("_").replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
@@ -7490,8 +9041,8 @@ var PostgresCatalogSnapshotAssembler = class {
   schemas = {};
   addColumnRows(columnRows, enumMap) {
     for (const row of columnRows) {
-      const table = this.ensureTable(row.schema_name, row.table_name);
-      table.columns[row.column_name] = {
+      const table2 = this.ensureTable(row.schema_name, row.table_name);
+      table2.columns[row.column_name] = {
         name: row.column_name,
         dataType: row.data_type,
         udtName: row.udt_name,
@@ -7507,12 +9058,12 @@ var PostgresCatalogSnapshotAssembler = class {
   }
   addPrimaryKeyRows(primaryKeyRows) {
     for (const row of primaryKeyRows) {
-      const table = this.ensureTable(row.schema_name, row.table_name);
+      const table2 = this.ensureTable(row.schema_name, row.table_name);
       const primaryKeyColumns = coerceStringArray(row.columns);
       row.columns = primaryKeyColumns;
-      table.primaryKey = primaryKeyColumns;
+      table2.primaryKey = primaryKeyColumns;
       for (const columnName of primaryKeyColumns) {
-        const column = table.columns[columnName];
+        const column = table2.columns[columnName];
         if (column) {
           column.isPrimaryKey = true;
         }
@@ -7628,14 +9179,14 @@ var PostgresCatalogSnapshotAssembler = class {
     }
     return schema.tables[tableName];
   }
-  upsertRelation(table, baseKey, relation) {
+  upsertRelation(table2, baseKey, relation) {
     let key = baseKey;
     let suffix = 2;
-    while (table.relations[key]) {
+    while (table2.relations[key]) {
       key = `${baseKey}_${suffix}`;
       suffix += 1;
     }
-    table.relations[key] = relation;
+    table2.relations[key] = relation;
   }
 };
 
@@ -7726,67 +9277,6 @@ function createPostgresIntrospectionProvider(options) {
   return new PostgresIntrospectionProvider(options);
 }
 
-// src/schema/model-form.ts
-function resolveNullishValue(mode) {
-  if (mode === "undefined") return void 0;
-  if (mode === "null") return null;
-  return "";
-}
-function isRecord10(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isNullableColumn(model, key) {
-  const nullable = model.meta.nullable;
-  return nullable?.[key] === true;
-}
-function toModelFormDefaults(model, values, options) {
-  const source = values;
-  if (!isRecord10(source)) {
-    return {};
-  }
-  const mode = options?.nullishMode ?? "empty-string";
-  const nullishValue = resolveNullishValue(mode);
-  const result = {};
-  for (const [key, value] of Object.entries(source)) {
-    if (value === null && isNullableColumn(model, key)) {
-      result[key] = nullishValue;
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
-}
-function toModelPayload(model, formValues, options) {
-  const emptyStringAsNull = options?.emptyStringAsNull ?? true;
-  const stripUndefined = options?.stripUndefined ?? true;
-  const result = {};
-  for (const [key, rawValue] of Object.entries(formValues)) {
-    if (rawValue === void 0 && stripUndefined) {
-      continue;
-    }
-    if (emptyStringAsNull && rawValue === "" && isNullableColumn(model, key)) {
-      result[key] = null;
-      continue;
-    }
-    result[key] = rawValue;
-  }
-  return result;
-}
-function createModelFormAdapter(model) {
-  return {
-    model,
-    toDefaults(values, options) {
-      return toModelFormDefaults(model, values, options);
-    },
-    toInsert(values, options) {
-      return toModelPayload(model, values, options);
-    },
-    toUpdate(values, options) {
-      return toModelPayload(model, values, options);
-    }
-  };
-}
-
 // src/generator/schema-selection.ts
 var DEFAULT_POSTGRES_SCHEMAS = ["public"];
 function collectSchemaNames(input) {
@@ -7832,6 +9322,7 @@ var DEFAULT_TARGETS = {
   database: "athena/relations.ts",
   registry: "athena/config.ts"
 };
+var DEFAULT_OUTPUT_FORMAT = "define-model";
 var DEFAULT_NAMING = {
   modelType: "pascal",
   modelConst: "camel",
@@ -7847,6 +9338,9 @@ var DEFAULT_EXPERIMENTAL_FLAGS = {
   postgresGatewayIntrospection: false,
   scyllaProviderContracts: true
 };
+var DEFAULT_INTERNAL_CONFIG = {
+  schemaVersion: 1
+};
 var PROJECT_ENV_FILENAMES = [".env", ".env.local"];
 var DIRECT_CONNECTION_STRING_ENV_KEYS = [
   "ATHENA_GENERATOR_PG_URL",
@@ -7863,6 +9357,27 @@ var GATEWAY_API_KEY_ENV_KEYS = [
   "ATHENA_GATEWAY_API_KEY",
   "ATHENA_GENERATOR_API_KEY"
 ];
+var GENERATOR_SCHEMA_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMAS"];
+var OUTPUT_FORMAT_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_FORMAT"];
+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 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"];
+var SCHEMA_CONST_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMA_CONST"];
+var DATABASE_CONST_ENV_KEYS = ["ATHENA_GENERATOR_DATABASE_CONST"];
+var REGISTRY_CONST_ENV_KEYS = ["ATHENA_GENERATOR_REGISTRY_CONST"];
+var EMIT_RELATIONS_ENV_KEYS = ["ATHENA_GENERATOR_EMIT_RELATIONS"];
+var EMIT_REGISTRY_ENV_KEYS = ["ATHENA_GENERATOR_EMIT_REGISTRY"];
+var GATEWAY_BACKEND_ENV_KEYS = ["ATHENA_GENERATOR_BACKEND"];
+var GATEWAY_EXPERIMENTAL_ENV_KEYS = ["ATHENA_GENERATOR_GATEWAY_EXPERIMENTAL"];
+var SCYLLA_PROVIDER_CONTRACTS_ENV_KEYS = ["ATHENA_GENERATOR_SCYLLA_PROVIDER_CONTRACTS"];
+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 BACKEND_TYPE_VALUES = ["athena", "postgrest", "postgresql", "scylladb"];
 function normalizeRawEnvValue(rawValue) {
   if (rawValue.startsWith('"') && rawValue.endsWith('"') && rawValue.length >= 2) {
     const inner = rawValue.slice(1, -1);
@@ -7954,6 +9469,50 @@ function resolveFallbackValue(fallbackKeys) {
   }
   return void 0;
 }
+function normalizeOneOfValue(rawValue, allowedValues, envKeys) {
+  if (!rawValue) {
+    return void 0;
+  }
+  if (allowedValues.includes(rawValue)) {
+    return rawValue;
+  }
+  throw new Error(
+    `Generator config env vars ${envKeys.join(", ")} must resolve to one of: ${allowedValues.join(", ")}. Received: ${rawValue}.`
+  );
+}
+function resolveOptionalOneOf(envKeys, allowedValues) {
+  return normalizeOneOfValue(resolveFallbackValue(envKeys), allowedValues, envKeys);
+}
+function resolveOptionalBoolean(envKeys) {
+  const rawValue = resolveFallbackValue(envKeys);
+  return rawValue === void 0 ? void 0 : parseBooleanFlag2(rawValue, false);
+}
+function resolveOptionalJson(envKeys) {
+  const rawValue = resolveFallbackValue(envKeys);
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(rawValue);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Generator config env vars ${envKeys.join(", ")} must contain valid JSON. ${message}`
+    );
+  }
+}
+function deriveDatabaseNameFromConnectionString(connectionString) {
+  try {
+    const parsedUrl = new URL(connectionString);
+    if (!POSTGRES_PROTOCOLS.has(parsedUrl.protocol)) {
+      return void 0;
+    }
+    const pathname = parsedUrl.pathname.replace(/^\/+/, "").trim();
+    return pathname.length > 0 ? decodeURIComponent(pathname) : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function normalizeOptionalString(value, fallbackKeys) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -8027,12 +9586,13 @@ function normalizeExperimentalFlags(input) {
 }
 function normalizeOutputConfig(output) {
   return {
+    format: output?.format ?? DEFAULT_OUTPUT_FORMAT,
     targets: {
       ...DEFAULT_TARGETS,
-      ...output.targets ?? {}
+      ...output?.targets ?? {}
     },
     placeholderMap: {
-      ...output.placeholderMap ?? {}
+      ...output?.placeholderMap ?? {}
     }
   };
 }
@@ -8043,7 +9603,7 @@ function normalizeProviderConfig(provider) {
       "provider.connectionString",
       DIRECT_CONNECTION_STRING_ENV_KEYS
     );
-    const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS);
+    const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? deriveDatabaseNameFromConnectionString(connectionString);
     return {
       ...provider,
       connectionString: applyPostgresPasswordFallback(connectionString),
@@ -8062,11 +9622,7 @@ function normalizeProviderConfig(provider) {
       "provider.apiKey",
       GATEWAY_API_KEY_ENV_KEYS
     );
-    const database = normalizeRequiredString(
-      provider.database,
-      "provider.database",
-      POSTGRES_DATABASE_ENV_KEYS
-    );
+    const database = normalizeOptionalString(provider.database, POSTGRES_DATABASE_ENV_KEYS) ?? "postgres";
     return {
       ...provider,
       gatewayUrl,
@@ -8075,6 +9631,26 @@ function normalizeProviderConfig(provider) {
       schemas: normalizeSchemaSelection(provider.schemas)
     };
   }
+  if (provider.kind === "scylla" && provider.mode === "direct") {
+    if (!provider.contactPoints?.length) {
+      throw new Error(
+        "Generator config is missing provider.contactPoints for scylla direct mode."
+      );
+    }
+    const keyspace = normalizeOptionalString(provider.keyspace, []);
+    if (!keyspace) {
+      throw new Error(
+        "Generator config is missing provider.keyspace for scylla direct mode."
+      );
+    }
+    return {
+      kind: "scylla",
+      mode: "direct",
+      contactPoints: provider.contactPoints.slice(),
+      keyspace,
+      datacenter: normalizeOptionalString(provider.datacenter, [])
+    };
+  }
   return provider;
 }
 function isAthenaGeneratorConfig(value) {
@@ -8082,7 +9658,7 @@ function isAthenaGeneratorConfig(value) {
     return false;
   }
   const record = value;
-  return Boolean(record.provider && typeof record.provider === "object") && Boolean(record.output && typeof record.output === "object");
+  return Boolean(record.provider && typeof record.provider === "object") && (record.output === void 0 || typeof record.output === "object");
 }
 function normalizeGeneratorConfig(input) {
   return {
@@ -8093,7 +9669,10 @@ function normalizeGeneratorConfig(input) {
       ...input.naming ?? {}
     },
     features: normalizeFeatureFlags(input.features),
-    experimental: normalizeExperimentalFlags(input.experimental)
+    experimental: normalizeExperimentalFlags(input.experimental),
+    internal: {
+      ...DEFAULT_INTERNAL_CONFIG
+    }
   };
 }
 function defineGeneratorConfig(config) {
@@ -8150,16 +9729,123 @@ function importConfigModule(moduleSpecifier) {
   );
   return runtimeImport(moduleSpecifier);
 }
+function buildEnvironmentOutputConfig() {
+  const format = resolveOptionalOneOf(OUTPUT_FORMAT_ENV_KEYS, OUTPUT_FORMAT_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) {
+    return void 0;
+  }
+  return {
+    format,
+    targets: {
+      ...modelTarget ? { model: modelTarget } : {},
+      ...schemaTarget ? { schema: schemaTarget } : {},
+      ...databaseTarget ? { database: databaseTarget } : {},
+      ...registryTarget ? { registry: registryTarget } : {}
+    },
+    placeholderMap
+  };
+}
+function buildEnvironmentNamingConfig() {
+  const modelType = resolveOptionalOneOf(MODEL_TYPE_ENV_KEYS, NAMING_STYLE_VALUES);
+  const modelConst = resolveOptionalOneOf(MODEL_CONST_ENV_KEYS, NAMING_STYLE_VALUES);
+  const schemaConst = resolveOptionalOneOf(SCHEMA_CONST_ENV_KEYS, NAMING_STYLE_VALUES);
+  const databaseConst = resolveOptionalOneOf(DATABASE_CONST_ENV_KEYS, NAMING_STYLE_VALUES);
+  const registryConst = resolveOptionalOneOf(REGISTRY_CONST_ENV_KEYS, NAMING_STYLE_VALUES);
+  if (modelType === void 0 && modelConst === void 0 && schemaConst === void 0 && databaseConst === void 0 && registryConst === void 0) {
+    return void 0;
+  }
+  return {
+    ...modelType ? { modelType } : {},
+    ...modelConst ? { modelConst } : {},
+    ...schemaConst ? { schemaConst } : {},
+    ...databaseConst ? { databaseConst } : {},
+    ...registryConst ? { registryConst } : {}
+  };
+}
+function buildEnvironmentFeatureFlags() {
+  const emitRelations = resolveOptionalBoolean(EMIT_RELATIONS_ENV_KEYS);
+  const emitRegistry = resolveOptionalBoolean(EMIT_REGISTRY_ENV_KEYS);
+  if (emitRelations === void 0 && emitRegistry === void 0) {
+    return void 0;
+  }
+  return {
+    ...emitRelations !== void 0 ? { emitRelations } : {},
+    ...emitRegistry !== void 0 ? { emitRegistry } : {}
+  };
+}
+function buildEnvironmentExperimentalFlags() {
+  const postgresGatewayIntrospection = resolveOptionalBoolean(GATEWAY_EXPERIMENTAL_ENV_KEYS);
+  const scyllaProviderContracts = resolveOptionalBoolean(SCYLLA_PROVIDER_CONTRACTS_ENV_KEYS);
+  if (postgresGatewayIntrospection === void 0 && scyllaProviderContracts === void 0) {
+    return void 0;
+  }
+  return {
+    ...postgresGatewayIntrospection !== void 0 ? { postgresGatewayIntrospection } : {},
+    ...scyllaProviderContracts !== void 0 ? { scyllaProviderContracts } : {}
+  };
+}
+function buildEnvironmentProviderConfig() {
+  const directConnectionString = resolveFallbackValue(DIRECT_CONNECTION_STRING_ENV_KEYS);
+  if (directConnectionString) {
+    return {
+      kind: "postgres",
+      mode: "direct",
+      connectionString: directConnectionString,
+      database: normalizeOptionalString(void 0, POSTGRES_DATABASE_ENV_KEYS),
+      schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS))
+    };
+  }
+  const gatewayUrl = resolveFallbackValue(GATEWAY_URL_ENV_KEYS);
+  const apiKey = resolveFallbackValue(GATEWAY_API_KEY_ENV_KEYS);
+  if (gatewayUrl && apiKey) {
+    const backend = resolveOptionalOneOf(GATEWAY_BACKEND_ENV_KEYS, BACKEND_TYPE_VALUES);
+    return {
+      kind: "postgres",
+      mode: "gateway",
+      gatewayUrl,
+      apiKey,
+      database: normalizeOptionalString(void 0, POSTGRES_DATABASE_ENV_KEYS),
+      schemas: normalizeSchemaSelection(resolveFallbackValue(GENERATOR_SCHEMA_ENV_KEYS)),
+      backend
+    };
+  }
+  return void 0;
+}
+function createEnvironmentGeneratorConfig() {
+  const provider = buildEnvironmentProviderConfig();
+  if (!provider) {
+    return void 0;
+  }
+  return {
+    provider,
+    output: buildEnvironmentOutputConfig(),
+    naming: buildEnvironmentNamingConfig(),
+    features: buildEnvironmentFeatureFlags(),
+    experimental: buildEnvironmentExperimentalFlags()
+  };
+}
 async function loadGeneratorConfig(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const restoreProjectEnv = applyProjectEnv(cwd);
-  const resolvedPath = options.configPath ? path.resolve(cwd, options.configPath) : findGeneratorConfigPath(cwd);
-  if (!resolvedPath) {
-    throw new Error(
-      `No generator config found in ${cwd}. Expected one of: ${DEFAULT_CONFIG_CANDIDATES.join(", ")}`
-    );
-  }
   try {
+    const resolvedPath = options.configPath ? path.resolve(cwd, options.configPath) : findGeneratorConfigPath(cwd);
+    if (!resolvedPath) {
+      const environmentConfig = createEnvironmentGeneratorConfig();
+      if (environmentConfig) {
+        return {
+          configPath: ENV_ONLY_CONFIG_PATH,
+          config: normalizeGeneratorConfig(environmentConfig)
+        };
+      }
+      throw new Error(
+        `No generator config found in ${cwd}. Expected one of: ${DEFAULT_CONFIG_CANDIDATES.join(", ")}. To run without a config file, set DATABASE_URL (direct mode) or ATHENA_URL + ATHENA_API_KEY (gateway mode).`
+      );
+    }
     const moduleUrl = url.pathToFileURL(resolvedPath);
     const module = await importConfigModule(`${moduleUrl.href}?cacheBust=${Date.now()}`);
     const rawConfig = extractConfigExport(module);
@@ -8380,59 +10066,6 @@ function escapeStringLiteral(value) {
   return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
 
-// src/generator/placeholders.ts
-function createStyleTokens(prefix, value) {
-  return {
-    [prefix]: value,
-    [`${prefix}_camel`]: applyNamingStyle(value, "camel"),
-    [`${prefix}_pascal`]: applyNamingStyle(value, "pascal"),
-    [`${prefix}_snake`]: applyNamingStyle(value, "snake"),
-    [`${prefix}_kebab`]: applyNamingStyle(value, "kebab")
-  };
-}
-function renderTemplate(template, tokenMap) {
-  return template.replace(/\{([A-Za-z0-9_]+)\}/g, (_match, token) => {
-    if (!(token in tokenMap)) {
-      throw new Error(`Unknown placeholder token "${token}" in template "${template}"`);
-    }
-    return tokenMap[token];
-  });
-}
-function resolvePlaceholderMap(baseTokens, outputConfig) {
-  const resolved = {
-    ...baseTokens
-  };
-  const reservedTokenKeys = new Set(Object.keys(baseTokens));
-  const entries = Object.entries(outputConfig.placeholderMap ?? {});
-  for (let index = 0; index < entries.length; index += 1) {
-    const [key, value] = entries[index];
-    if (reservedTokenKeys.has(key)) {
-      continue;
-    }
-    let current = value;
-    for (let depth = 0; depth < 8; depth += 1) {
-      const next = renderTemplate(current, resolved);
-      if (next === current) {
-        break;
-      }
-      current = next;
-    }
-    resolved[key] = current;
-  }
-  return resolved;
-}
-function renderOutputPath(template, context, outputConfig) {
-  const baseTokens = {
-    provider: context.provider,
-    kind: context.kind,
-    ...createStyleTokens("database", context.database),
-    ...createStyleTokens("schema", context.schema),
-    ...createStyleTokens("model", context.model)
-  };
-  const tokens = resolvePlaceholderMap(baseTokens, outputConfig);
-  return renderTemplate(template, tokens);
-}
-
 // src/generator/postgres-type-mapping.ts
 var NUMBER_TYPES = /* @__PURE__ */ new Set([
   "int2",
@@ -8549,7 +10182,60 @@ function resolvePostgresColumnType(column) {
   return wrapArrayType(baseType, column.arrayDimensions);
 }
 
-// src/generator/renderer.ts
+// src/generator/placeholders.ts
+function createStyleTokens(prefix, value) {
+  return {
+    [prefix]: value,
+    [`${prefix}_camel`]: applyNamingStyle(value, "camel"),
+    [`${prefix}_pascal`]: applyNamingStyle(value, "pascal"),
+    [`${prefix}_snake`]: applyNamingStyle(value, "snake"),
+    [`${prefix}_kebab`]: applyNamingStyle(value, "kebab")
+  };
+}
+function renderTemplate(template, tokenMap) {
+  return template.replace(/\{([A-Za-z0-9_]+)\}/g, (_match, token) => {
+    if (!(token in tokenMap)) {
+      throw new Error(`Unknown placeholder token "${token}" in template "${template}"`);
+    }
+    return tokenMap[token];
+  });
+}
+function resolvePlaceholderMap(baseTokens, outputConfig) {
+  const resolved = {
+    ...baseTokens
+  };
+  const reservedTokenKeys = new Set(Object.keys(baseTokens));
+  const entries = Object.entries(outputConfig.placeholderMap ?? {});
+  for (let index = 0; index < entries.length; index += 1) {
+    const [key, value] = entries[index];
+    if (reservedTokenKeys.has(key)) {
+      continue;
+    }
+    let current = value;
+    for (let depth = 0; depth < 8; depth += 1) {
+      const next = renderTemplate(current, resolved);
+      if (next === current) {
+        break;
+      }
+      current = next;
+    }
+    resolved[key] = current;
+  }
+  return resolved;
+}
+function renderOutputPath(template, context, outputConfig) {
+  const baseTokens = {
+    provider: context.provider,
+    kind: context.kind,
+    ...createStyleTokens("database", context.database),
+    ...createStyleTokens("schema", context.schema),
+    ...createStyleTokens("model", context.model)
+  };
+  const tokens = resolvePlaceholderMap(baseTokens, outputConfig);
+  return renderTemplate(template, tokens);
+}
+
+// src/generator/render-shared.ts
 function normalizePath(pathValue) {
   return pathValue.replace(/\\/g, "/");
 }
@@ -8562,11 +10248,13 @@ function toModuleImportPath(fromFile, targetFile) {
   );
   return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 }
+function resolveOutputPath(target, tokens, config) {
+  return normalizePath(renderOutputPath(target, tokens, config.output));
+}
 function renderObjectKey(key) {
-  const escaped = escapeTypePropertyName(key);
-  return escaped.startsWith("'") ? escaped : escaped;
+  return escapeTypePropertyName(key);
 }
-function renderRelation(relation) {
+function renderRelationLiteral(relation) {
   const through = relation.through ? `,
       through: {
         schema: ${escapeStringLiteral(relation.through.schema)},
@@ -8582,54 +10270,12 @@ function renderRelation(relation) {
       targetColumns: [${relation.targetColumns.map((value) => escapeStringLiteral(value)).join(", ")}]${through}
     }`;
 }
-function renderModelArtifact(snapshot, descriptor, config) {
-  const columnLines = Object.values(descriptor.table.columns).map((column) => {
-    const propertyName = escapeTypePropertyName(column.name);
-    const baseType = resolvePostgresColumnType(column);
-    const isOptional = column.isNullable;
-    const typeWithNullability = column.isNullable ? `${baseType} | null` : baseType;
-    return `  ${propertyName}${isOptional ? "?" : ""}: ${typeWithNullability}`;
-  }).join("\n");
-  const nullableLines = Object.values(descriptor.table.columns).map((column) => `      ${renderObjectKey(column.name)}: ${column.isNullable ? "true" : "false"}`).join(",\n");
-  const relationEntries = Object.entries(descriptor.table.relations);
-  const relationBlock = config.features.emitRelations && relationEntries.length > 0 ? `,
-    relations: {
-${relationEntries.map(([relationKey2, relationValue]) => `      ${renderObjectKey(relationKey2)}: ${renderRelation(relationValue)}`).join(",\n")}
-    }` : "";
-  const content = `import { defineModel } from '@xylex-group/athena'
-
-export interface ${descriptor.rowTypeName} {
-${columnLines}
-}
-
-export type ${descriptor.insertTypeName} = Partial<${descriptor.rowTypeName}>
-export type ${descriptor.updateTypeName} = Partial<${descriptor.insertTypeName}>
-
-export const ${descriptor.modelConstName} = defineModel<${descriptor.rowTypeName}, ${descriptor.insertTypeName}, ${descriptor.updateTypeName}>({
-  meta: {
-    database: ${escapeStringLiteral(snapshot.database)},
-    schema: ${escapeStringLiteral(descriptor.schemaName)},
-    model: ${escapeStringLiteral(descriptor.tableName)},
-    tableName: ${escapeStringLiteral(`${descriptor.schemaName}.${descriptor.tableName}`)},
-    primaryKey: [${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")}],
-    nullable: {
-${nullableLines}
-    }${relationBlock}
-  }
-})
-`;
-  return {
-    kind: "model",
-    path: descriptor.filePath,
-    content
-  };
-}
 function renderSchemaArtifact(descriptor) {
   const importLines = descriptor.models.map((modelDescriptor) => {
     const importPath = toModuleImportPath(descriptor.filePath, modelDescriptor.filePath);
-    return `import { ${modelDescriptor.modelConstName} } from '${importPath}'`;
+    return `import { ${modelDescriptor.exportConstName} } from '${importPath}'`;
   }).join("\n");
-  const modelEntries = descriptor.models.map((modelDescriptor) => `  ${renderObjectKey(modelDescriptor.tableName)}: ${modelDescriptor.modelConstName}`).join(",\n");
+  const modelEntries = descriptor.models.map((modelDescriptor) => `  ${renderObjectKey(modelDescriptor.tableName)}: ${modelDescriptor.exportConstName}`).join(",\n");
   const content = `import { defineSchema } from '@xylex-group/athena'
 ${importLines ? `
 ${importLines}
@@ -8664,11 +10310,18 @@ ${schemaEntries}
     content
   };
 }
-function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName) {
+function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName, generatedAt, outputFormat, schemaVersion) {
   const databaseImportPath = toModuleImportPath(registryPath, databasePath);
   const content = `import { defineRegistry } from '@xylex-group/athena'
 import { ${databaseConstName} } from '${databaseImportPath}'
 
+export const __athena_schema_meta = {
+  schemaVersion: ${schemaVersion},
+  generatedAt: ${escapeStringLiteral(generatedAt)},
+  database: ${escapeStringLiteral(databaseName)},
+  outputFormat: ${escapeStringLiteral(outputFormat)},
+} as const
+
 export const ${registryConstName} = defineRegistry({
   ${renderObjectKey(databaseName)}: ${databaseConstName}
 })
@@ -8747,123 +10400,332 @@ function scopeDuplicateDescriptorPathsBySchema(descriptors) {
   }
   return nextDescriptors;
 }
-var ArtifactComposer = class {
-  constructor(snapshot, config) {
-    this.snapshot = snapshot;
-    this.config = config;
-  }
-  compose() {
-    const providerName = this.snapshot.backend;
-    const databaseName = this.snapshot.database;
-    const modelDescriptors = [];
-    for (const schemaName of Object.keys(this.snapshot.schemas).sort()) {
-      const schema = this.snapshot.schemas[schemaName];
-      for (const tableName of Object.keys(schema.tables).sort()) {
-        const table = schema.tables[tableName];
-        const rowTypeName = `${toSafeIdentifier(`${schemaName} ${tableName}`, this.config.naming.modelType, "Model")}Row`;
-        const insertTypeName = `${toSafeIdentifier(`${schemaName} ${tableName}`, this.config.naming.modelType, "Model")}Insert`;
-        const updateTypeName = `${toSafeIdentifier(`${schemaName} ${tableName}`, this.config.naming.modelType, "Model")}Update`;
-        const modelConstName = `${toSafeIdentifier(`${schemaName} ${tableName} model`, this.config.naming.modelConst, "model")}`;
-        const modelPath = normalizePath(
-          renderOutputPath(this.config.output.targets.model, {
-            provider: providerName,
-            kind: "model",
-            database: databaseName,
-            schema: schemaName,
-            model: tableName
-          }, this.config.output)
-        );
-        modelDescriptors.push({
+function composeGeneratorArtifacts(input) {
+  const { snapshot, config, createModelDescriptor, renderModelArtifact: renderModelArtifact3 } = input;
+  const providerName = snapshot.backend;
+  const databaseName = snapshot.database;
+  const modelDescriptors = [];
+  for (const schemaName of Object.keys(snapshot.schemas).sort()) {
+    const schema = snapshot.schemas[schemaName];
+    for (const tableName of Object.keys(schema.tables).sort()) {
+      modelDescriptors.push(
+        createModelDescriptor({
+          providerName,
+          databaseName,
           schemaName,
           tableName,
-          filePath: modelPath,
-          rowTypeName,
-          insertTypeName,
-          updateTypeName,
-          modelConstName,
-          table
-        });
-      }
-    }
-    const scopedModelDescriptors = scopeDuplicateDescriptorPathsBySchema(modelDescriptors);
-    let schemaDescriptors = Object.keys(this.snapshot.schemas).sort().map((schemaName) => {
-      const schemaPath = normalizePath(
-        renderOutputPath(this.config.output.targets.schema, {
-          provider: providerName,
-          kind: "schema",
-          database: databaseName,
-          schema: schemaName,
-          model: "index"
-        }, this.config.output)
+          table: schema.tables[tableName]
+        })
       );
-      return {
-        schemaName,
-        filePath: schemaPath,
-        schemaConstName: toSafeIdentifier(
-          `${schemaName} schema`,
-          this.config.naming.schemaConst,
-          "schema"
-        ),
-        models: scopedModelDescriptors.filter((model) => model.schemaName === schemaName)
-      };
-    });
-    schemaDescriptors = scopeDuplicateDescriptorPathsBySchema(schemaDescriptors);
-    const databasePath = normalizePath(
-      renderOutputPath(this.config.output.targets.database, {
+    }
+  }
+  const scopedModelDescriptors = scopeDuplicateDescriptorPathsBySchema(modelDescriptors);
+  let schemaDescriptors = Object.keys(snapshot.schemas).sort().map((schemaName) => ({
+    schemaName,
+    filePath: resolveOutputPath(
+      config.output.targets.schema,
+      {
+        provider: providerName,
+        kind: "schema",
+        database: databaseName,
+        schema: schemaName,
+        model: "index"
+      },
+      config
+    ),
+    schemaConstName: toSafeIdentifier(
+      `${schemaName} schema`,
+      config.naming.schemaConst,
+      "schema"
+    ),
+    models: scopedModelDescriptors.filter((model) => model.schemaName === schemaName)
+  }));
+  schemaDescriptors = scopeDuplicateDescriptorPathsBySchema(schemaDescriptors);
+  const databaseDescriptor = {
+    filePath: resolveOutputPath(
+      config.output.targets.database,
+      {
         provider: providerName,
         kind: "database",
         database: databaseName,
         schema: "index",
         model: "index"
-      }, this.config.output)
+      },
+      config
+    ),
+    databaseConstName: toSafeIdentifier(
+      `${databaseName} database`,
+      config.naming.databaseConst,
+      "database"
+    ),
+    schemas: schemaDescriptors
+  };
+  const files = [];
+  for (const modelDescriptor of scopedModelDescriptors) {
+    files.push(renderModelArtifact3(modelDescriptor));
+  }
+  for (const schemaDescriptor of schemaDescriptors) {
+    files.push(renderSchemaArtifact(schemaDescriptor));
+  }
+  files.push(renderDatabaseArtifact(databaseDescriptor));
+  if (config.features.emitRegistry) {
+    const registryPath = resolveOutputPath(
+      config.output.targets.registry,
+      {
+        provider: providerName,
+        kind: "registry",
+        database: databaseName,
+        schema: "index",
+        model: "index"
+      },
+      config
+    );
+    files.push(
+      renderRegistryArtifact(
+        registryPath,
+        databaseDescriptor.filePath,
+        databaseDescriptor.databaseConstName,
+        toSafeIdentifier("registry", config.naming.registryConst, "registry"),
+        databaseName,
+        snapshot.generatedAt,
+        config.output.format,
+        config.internal.schemaVersion
+      )
     );
-    const databaseDescriptor = {
-      filePath: databasePath,
-      databaseConstName: toSafeIdentifier(
-        `${databaseName} database`,
-        this.config.naming.databaseConst,
-        "database"
-      ),
-      schemas: schemaDescriptors
-    };
-    const files = [];
-    for (const modelDescriptor of scopedModelDescriptors) {
-      files.push(renderModelArtifact(this.snapshot, modelDescriptor, this.config));
-    }
-    for (const schemaDescriptor of schemaDescriptors) {
-      files.push(renderSchemaArtifact(schemaDescriptor));
-    }
-    files.push(renderDatabaseArtifact(databaseDescriptor));
-    if (this.config.features.emitRegistry) {
-      const registryPath = normalizePath(
-        renderOutputPath(this.config.output.targets.registry, {
-          provider: providerName,
-          kind: "registry",
-          database: databaseName,
-          schema: "index",
-          model: "index"
-        }, this.config.output)
-      );
-      files.push(
-        renderRegistryArtifact(
-          registryPath,
-          databaseDescriptor.filePath,
-          databaseDescriptor.databaseConstName,
-          toSafeIdentifier("registry", this.config.naming.registryConst, "registry"),
-          databaseName
-        )
-      );
-    }
-    assertNoDuplicatePaths(files);
-    return {
-      snapshot: this.snapshot,
-      files
-    };
   }
-};
+  assertNoDuplicatePaths(files);
+  return {
+    snapshot,
+    files
+  };
+}
+
+// src/generator/table-builder-renderer.ts
+var SAFE_NUMBER_TYPES = /* @__PURE__ */ new Set([
+  "int2",
+  "int4",
+  "float4",
+  "float8",
+  "smallint",
+  "integer",
+  "real",
+  "double precision"
+]);
+var JSON_TYPES = /* @__PURE__ */ new Set(["json", "jsonb"]);
+var BOOLEAN_TYPES = /* @__PURE__ */ new Set(["bool", "boolean"]);
+var STRING_TYPES = /* @__PURE__ */ new Set([
+  "int8",
+  "bigint",
+  "serial8",
+  "bigserial",
+  "numeric",
+  "decimal",
+  "money",
+  "bytea"
+]);
+function normalizeTypeLabel2(column) {
+  const preferred = (column.udtName || column.dataType).toLowerCase().trim();
+  if (column.arrayDimensions > 0 && preferred.startsWith("_")) {
+    return preferred.slice(1);
+  }
+  return preferred;
+}
+function renderColumnBuilder(column) {
+  const label = normalizeTypeLabel2(column);
+  let helper;
+  let expression;
+  if (column.typeKind === "enum" && column.enumValues && column.enumValues.length > 0) {
+    helper = "enumeration";
+    expression = `enumeration([${column.enumValues.map((value) => escapeStringLiteral(value)).join(", ")}] as const)`;
+  } else if (column.arrayDimensions > 0 || JSON_TYPES.has(label) || column.typeKind === "composite") {
+    helper = "json";
+    expression = `json<${resolvePostgresColumnType(column)}>()`;
+  } else if (BOOLEAN_TYPES.has(label)) {
+    helper = "boolean";
+    expression = "boolean()";
+  } else if (SAFE_NUMBER_TYPES.has(label)) {
+    helper = "number";
+    expression = "number()";
+  } else if (STRING_TYPES.has(label)) {
+    helper = "string";
+    expression = "string()";
+  } else {
+    helper = "string";
+    expression = "string()";
+  }
+  if (column.isNullable) {
+    expression = `${expression}.optional()`;
+  }
+  if (column.hasDefault) {
+    expression = `${expression}.defaulted()`;
+  }
+  if (column.isGenerated) {
+    expression = `${expression}.generated()`;
+  }
+  return { helper, expression };
+}
+function renderModelArtifact(descriptor, config) {
+  const helperImports = /* @__PURE__ */ new Set(["table"]);
+  const columnLines = Object.entries(descriptor.table.columns).map(([columnName, column]) => {
+    const propertyName = escapeTypePropertyName(columnName);
+    const rendered = renderColumnBuilder(column);
+    helperImports.add(rendered.helper);
+    return `    ${propertyName}: ${rendered.expression}`;
+  }).join(",\n");
+  const helperImportLine = Array.from(helperImports).sort().join(", ");
+  const rowSchemaConstName = `${descriptor.tableConstName}_row_schema`;
+  const insertSchemaConstName = `${descriptor.tableConstName}_insert_schema`;
+  const updateSchemaConstName = `${descriptor.tableConstName}_update_schema`;
+  const formSchemaConstName = `${descriptor.tableConstName}_form_schema`;
+  const relationEntries = Object.entries(descriptor.table.relations);
+  const relationsAssignment = config.features.emitRelations && relationEntries.length > 0 ? `
+Object.assign(${descriptor.tableConstName}.meta, {
+  relations: {
+${relationEntries.map(([relationKey2, relationValue]) => `    ${renderObjectKey(relationKey2)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
+  }
+})
+` : "";
+  const content = `import { ${helperImportLine} } from '@xylex-group/athena'
+import type { FormValuesOf, InsertOf, RowOf, UpdateOf } from '@xylex-group/athena'
+
+export const ${descriptor.tableConstName} = table(${escapeStringLiteral(descriptor.tableName)})
+  .schema(${escapeStringLiteral(descriptor.schemaName)})
+  .columns({
+${columnLines}
+  })
+  .primaryKey(${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")})
+${relationsAssignment ? `${relationsAssignment}` : ""}
+export type ${descriptor.rowTypeName} = RowOf<typeof ${descriptor.tableConstName}>
+export type ${descriptor.insertTypeName} = InsertOf<typeof ${descriptor.tableConstName}>
+export type ${descriptor.updateTypeName} = UpdateOf<typeof ${descriptor.tableConstName}>
+export type ${descriptor.formValuesTypeName} = FormValuesOf<typeof ${descriptor.tableConstName}>
+
+export const ${rowSchemaConstName} = ${descriptor.tableConstName}.schemas.row
+export const ${insertSchemaConstName} = ${descriptor.tableConstName}.schemas.insert
+export const ${updateSchemaConstName} = ${descriptor.tableConstName}.schemas.update
+export const ${formSchemaConstName} = ${descriptor.tableConstName}.schemas.form
+`;
+  return {
+    kind: "model",
+    path: descriptor.filePath,
+    content
+  };
+}
+function generateTableBuilderArtifactsFromSnapshot(snapshot, config) {
+  const normalizedConfig = "internal" in config ? config : normalizeGeneratorConfig(config);
+  return composeGeneratorArtifacts({
+    snapshot,
+    config: normalizedConfig,
+    createModelDescriptor({ providerName, databaseName, schemaName, tableName, table: table2 }) {
+      const tableConstName = toSafeIdentifier(tableName, "preserve", "table");
+      return {
+        schemaName,
+        tableName,
+        filePath: resolveOutputPath(
+          normalizedConfig.output.targets.model,
+          {
+            provider: providerName,
+            kind: "model",
+            database: databaseName,
+            schema: schemaName,
+            model: tableName
+          },
+          normalizedConfig
+        ),
+        rowTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}Row`,
+        insertTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}Insert`,
+        updateTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}Update`,
+        formValuesTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}FormValues`,
+        tableConstName,
+        exportConstName: tableConstName,
+        table: table2
+      };
+    },
+    renderModelArtifact: (descriptor) => renderModelArtifact(descriptor, normalizedConfig)
+  });
+}
+
+// src/generator/renderer.ts
+function renderModelArtifact2(databaseName, descriptor, config) {
+  const columnLines = Object.values(descriptor.table.columns).map((column) => {
+    const propertyName = escapeTypePropertyName(column.name);
+    const baseType = resolvePostgresColumnType(column);
+    const isOptional = column.isNullable;
+    const typeWithNullability = column.isNullable ? `${baseType} | null` : baseType;
+    return `  ${propertyName}${isOptional ? "?" : ""}: ${typeWithNullability}`;
+  }).join("\n");
+  const nullableLines = Object.values(descriptor.table.columns).map((column) => `      ${renderObjectKey(column.name)}: ${column.isNullable ? "true" : "false"}`).join(",\n");
+  const relationEntries = Object.entries(descriptor.table.relations);
+  const relationBlock = config.features.emitRelations && relationEntries.length > 0 ? `,
+    relations: {
+${relationEntries.map(([relationKey2, relationValue]) => `      ${renderObjectKey(relationKey2)}: ${renderRelationLiteral(relationValue)}`).join(",\n")}
+    }` : "";
+  const content = `import { defineModel } from '@xylex-group/athena'
+
+export interface ${descriptor.rowTypeName} {
+${columnLines}
+}
+
+export type ${descriptor.insertTypeName} = Partial<${descriptor.rowTypeName}>
+export type ${descriptor.updateTypeName} = Partial<${descriptor.insertTypeName}>
+
+export const ${descriptor.modelConstName} = defineModel<${descriptor.rowTypeName}, ${descriptor.insertTypeName}, ${descriptor.updateTypeName}>({
+  meta: {
+    database: ${escapeStringLiteral(databaseName)},
+    schema: ${escapeStringLiteral(descriptor.schemaName)},
+    model: ${escapeStringLiteral(descriptor.tableName)},
+    tableName: ${escapeStringLiteral(`${descriptor.schemaName}.${descriptor.tableName}`)},
+    primaryKey: [${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")}],
+    nullable: {
+${nullableLines}
+    }${relationBlock}
+  }
+})
+`;
+  return {
+    kind: "model",
+    path: descriptor.filePath,
+    content
+  };
+}
 function generateArtifactsFromSnapshot(snapshot, config) {
-  const normalizedConfig = "naming" in config && "features" in config && "experimental" in config ? config : normalizeGeneratorConfig(config);
-  return new ArtifactComposer(snapshot, normalizedConfig).compose();
+  const normalizedConfig = "internal" in config ? config : normalizeGeneratorConfig(config);
+  if (normalizedConfig.output.format === "table-builder") {
+    return generateTableBuilderArtifactsFromSnapshot(snapshot, normalizedConfig);
+  }
+  return composeGeneratorArtifacts({
+    snapshot,
+    config: normalizedConfig,
+    createModelDescriptor({ providerName, databaseName, schemaName, tableName, table: table2 }) {
+      const modelConstName = toSafeIdentifier(
+        `${schemaName} ${tableName} model`,
+        normalizedConfig.naming.modelConst,
+        "model"
+      );
+      return {
+        schemaName,
+        tableName,
+        filePath: resolveOutputPath(
+          normalizedConfig.output.targets.model,
+          {
+            provider: providerName,
+            kind: "model",
+            database: databaseName,
+            schema: schemaName,
+            model: tableName
+          },
+          normalizedConfig
+        ),
+        rowTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}Row`,
+        insertTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}Insert`,
+        updateTypeName: `${toSafeIdentifier(`${schemaName} ${tableName}`, normalizedConfig.naming.modelType, "Model")}Update`,
+        modelConstName,
+        exportConstName: modelConstName,
+        table: table2
+      };
+    },
+    renderModelArtifact: (descriptor) => renderModelArtifact2(snapshot.database, descriptor, normalizedConfig)
+  });
 }
 
 // src/generator/providers.ts
@@ -9009,6 +10871,7 @@ async function runSchemaGenerator(options = {}) {
   return {
     ...generated,
     configPath,
+    config,
     writtenFiles
   };
 }
@@ -9453,6 +11316,7 @@ exports.Backend = Backend;
 exports.DEFAULT_POSTGRES_SCHEMAS = DEFAULT_POSTGRES_SCHEMAS;
 exports.assertInt = assertInt;
 exports.athenaAuth = athenaAuth;
+exports.boolean = boolean;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
 exports.createAuthClient = createAuthClient;
@@ -9468,17 +11332,21 @@ exports.defineGeneratorConfig = defineGeneratorConfig;
 exports.defineModel = defineModel;
 exports.defineRegistry = defineRegistry;
 exports.defineSchema = defineSchema;
+exports.enumeration = enumeration;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
+exports.getAthenaDebugAst = getAthenaDebugAst;
 exports.identifier = identifier;
 exports.isAthenaGatewayError = isAthenaGatewayError;
 exports.isOk = isOk;
+exports.json = json;
 exports.loadGeneratorConfig = loadGeneratorConfig;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeAthenaGatewayBaseUrl = normalizeAthenaGatewayBaseUrl;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
+exports.number = number;
 exports.parseBooleanFlag = parseBooleanFlag2;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
 exports.requireAffected = requireAffected;
@@ -9488,6 +11356,8 @@ exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;
 exports.runSchemaGenerator = runSchemaGenerator;
 exports.storageSdkManifest = storageSdkManifest;
+exports.string = string;
+exports.table = table;
 exports.toModelFormDefaults = toModelFormDefaults;
 exports.toModelPayload = toModelPayload;
 exports.unwrap = unwrap;