@xylex-group/athena 2.8.0 → 2.9.0

package/dist/cli/index.js

@@ -686,6 +686,77 @@ function resolveProviderSchemas(providerConfig) {
   return [...DEFAULT_POSTGRES_SCHEMAS];
 }
 
+// src/generator/table-selection.ts
+function normalizeTableSelector(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeTableSelection(value) {
+  if (typeof value === "string") {
+    return Array.from(
+      new Set(
+        value.split(",").map(normalizeTableSelector).filter((entry) => Boolean(entry))
+      )
+    );
+  }
+  if (Array.isArray(value)) {
+    return Array.from(
+      new Set(
+        value.map((entry) => typeof entry === "string" ? normalizeTableSelector(entry) : void 0).filter((entry) => Boolean(entry))
+      )
+    );
+  }
+  return [];
+}
+function matchesTableSelector(schemaName, tableName, selector) {
+  const separatorIndex = selector.indexOf(".");
+  if (separatorIndex < 0) {
+    return tableName === selector;
+  }
+  const selectorSchema = selector.slice(0, separatorIndex).trim();
+  const selectorTable = selector.slice(separatorIndex + 1).trim();
+  return selectorSchema === schemaName && selectorTable === tableName;
+}
+function shouldKeepTable(schemaName, tableName, filter) {
+  const included = filter.includeTables.length === 0 || filter.includeTables.some((selector) => matchesTableSelector(schemaName, tableName, selector));
+  if (!included) {
+    return false;
+  }
+  return !filter.excludeTables.some((selector) => matchesTableSelector(schemaName, tableName, selector));
+}
+function hasTableFilters(filter) {
+  return filter.includeTables.length > 0 || filter.excludeTables.length > 0;
+}
+function filterIntrospectionSnapshot(snapshot, filter) {
+  if (!hasTableFilters(filter)) {
+    return snapshot;
+  }
+  const schemas = {};
+  for (const [schemaName, schema] of Object.entries(snapshot.schemas)) {
+    const tables = Object.fromEntries(
+      Object.entries(schema.tables).filter(([tableName]) => shouldKeepTable(schemaName, tableName, filter))
+    );
+    if (Object.keys(tables).length === 0) {
+      continue;
+    }
+    schemas[schemaName] = {
+      ...schema,
+      tables
+    };
+  }
+  if (Object.keys(schemas).length === 0) {
+    const includeLabel = filter.includeTables.length > 0 ? ` includeTables=${filter.includeTables.join(", ")}` : "";
+    const excludeLabel = filter.excludeTables.length > 0 ? ` excludeTables=${filter.excludeTables.join(", ")}` : "";
+    throw new Error(
+      `Generator table filters matched no tables after schema selection.${includeLabel}${excludeLabel}`
+    );
+  }
+  return {
+    ...snapshot,
+    schemas
+  };
+}
+
 // src/generator/config.ts
 var POSTGRES_PROTOCOLS = /* @__PURE__ */ new Set(["postgres:", "postgresql:"]);
 var DEFAULT_CONFIG_CANDIDATES = [
@@ -696,13 +767,20 @@ var DEFAULT_CONFIG_CANDIDATES = [
   ".athena.config.ts",
   ".athena.config.js"
 ];
-var DEFAULT_TARGETS = {
+var LEGACY_DEFAULT_TARGETS = {
   model: "athena/models/{schema_kebab}/{model_kebab}.ts",
   schema: "athena/schemas/{schema_kebab}.ts",
   database: "athena/relations.ts",
   registry: "athena/config.ts"
 };
-var DEFAULT_OUTPUT_FORMAT = "define-model";
+var ATHENA_DIRECT_TARGETS = {
+  model: "athena/models/{schema_kebab}/{model_kebab}.ts",
+  schema: "athena/schemas/{schema_kebab}.ts",
+  database: "athena/relations.ts",
+  registry: "athena/registry.generated.ts"
+};
+var DEFAULT_OUTPUT_FORMAT = "table-builder";
+var DEFAULT_OUTPUT_PRESET = "athena-direct";
 var DEFAULT_NAMING = {
   modelType: "pascal",
   modelConst: "camel",
@@ -721,6 +799,10 @@ var DEFAULT_EXPERIMENTAL_FLAGS = {
 var DEFAULT_INTERNAL_CONFIG = {
   schemaVersion: 1
 };
+var DEFAULT_FILTER_CONFIG = {
+  includeTables: [],
+  excludeTables: []
+};
 var PROJECT_ENV_FILENAMES = [".env", ".env.local"];
 var DIRECT_CONNECTION_STRING_ENV_KEYS = [
   "ATHENA_GENERATOR_PG_URL",
@@ -739,10 +821,13 @@ var GATEWAY_API_KEY_ENV_KEYS = [
 ];
 var GENERATOR_SCHEMA_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMAS"];
 var OUTPUT_FORMAT_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_FORMAT"];
+var OUTPUT_PRESET_ENV_KEYS = ["ATHENA_GENERATOR_OUTPUT_PRESET"];
 var MODEL_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_MODEL_TARGET"];
 var SCHEMA_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_SCHEMA_TARGET"];
 var DATABASE_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_DATABASE_TARGET"];
 var REGISTRY_TARGET_ENV_KEYS = ["ATHENA_GENERATOR_REGISTRY_TARGET"];
+var TABLES_ENV_KEYS = ["ATHENA_GENERATOR_TABLES"];
+var EXCLUDE_TABLES_ENV_KEYS = ["ATHENA_GENERATOR_EXCLUDE_TABLES"];
 var PLACEHOLDER_MAP_ENV_KEYS = ["ATHENA_GENERATOR_PLACEHOLDER_MAP"];
 var MODEL_TYPE_ENV_KEYS = ["ATHENA_GENERATOR_MODEL_TYPE", "ATHENA_GENERATOR_MODEL_STYLE"];
 var MODEL_CONST_ENV_KEYS = ["ATHENA_GENERATOR_MODEL_CONST"];
@@ -757,7 +842,12 @@ var SCYLLA_PROVIDER_CONTRACTS_ENV_KEYS = ["ATHENA_GENERATOR_SCYLLA_PROVIDER_CONT
 var ENV_ONLY_CONFIG_PATH = "[environment defaults]";
 var NAMING_STYLE_VALUES = ["preserve", "camel", "pascal", "snake", "kebab"];
 var OUTPUT_FORMAT_VALUES = ["define-model", "table-builder"];
+var OUTPUT_PRESET_VALUES = ["legacy", "athena-direct"];
 var BACKEND_TYPE_VALUES = ["athena", "postgrest", "postgresql", "scylladb"];
+var OUTPUT_PRESET_TARGETS = {
+  legacy: LEGACY_DEFAULT_TARGETS,
+  "athena-direct": ATHENA_DIRECT_TARGETS
+};
 function normalizeRawEnvValue(rawValue) {
   if (rawValue.startsWith('"') && rawValue.endsWith('"') && rawValue.length >= 2) {
     const inner = rawValue.slice(1, -1);
@@ -964,11 +1054,19 @@ function normalizeExperimentalFlags(input) {
     )
   };
 }
+function normalizeFilterConfig(input) {
+  return {
+    includeTables: normalizeTableSelection(input?.includeTables),
+    excludeTables: normalizeTableSelection(input?.excludeTables)
+  };
+}
 function normalizeOutputConfig(output) {
+  const preset = output?.preset ?? DEFAULT_OUTPUT_PRESET;
   return {
     format: output?.format ?? DEFAULT_OUTPUT_FORMAT,
+    preset,
     targets: {
-      ...DEFAULT_TARGETS,
+      ...OUTPUT_PRESET_TARGETS[preset],
       ...output?.targets ?? {}
     },
     placeholderMap: {
@@ -1048,6 +1146,10 @@ function normalizeGeneratorConfig(input) {
       ...DEFAULT_NAMING,
       ...input.naming ?? {}
     },
+    filter: {
+      ...DEFAULT_FILTER_CONFIG,
+      ...normalizeFilterConfig(input.filter)
+    },
     features: normalizeFeatureFlags(input.features),
     experimental: normalizeExperimentalFlags(input.experimental),
     internal: {
@@ -1108,16 +1210,18 @@ function importConfigModule(moduleSpecifier) {
 }
 function buildEnvironmentOutputConfig() {
   const format = resolveOptionalOneOf(OUTPUT_FORMAT_ENV_KEYS, OUTPUT_FORMAT_VALUES);
+  const preset = resolveOptionalOneOf(OUTPUT_PRESET_ENV_KEYS, OUTPUT_PRESET_VALUES);
   const modelTarget = resolveFallbackValue(MODEL_TARGET_ENV_KEYS);
   const schemaTarget = resolveFallbackValue(SCHEMA_TARGET_ENV_KEYS);
   const databaseTarget = resolveFallbackValue(DATABASE_TARGET_ENV_KEYS);
   const registryTarget = resolveFallbackValue(REGISTRY_TARGET_ENV_KEYS);
   const placeholderMap = resolveOptionalJson(PLACEHOLDER_MAP_ENV_KEYS);
-  if (format === void 0 && modelTarget === void 0 && schemaTarget === void 0 && databaseTarget === void 0 && registryTarget === void 0 && placeholderMap === void 0) {
+  if (format === void 0 && preset === void 0 && modelTarget === void 0 && schemaTarget === void 0 && databaseTarget === void 0 && registryTarget === void 0 && placeholderMap === void 0) {
     return void 0;
   }
   return {
     format,
+    preset,
     targets: {
       ...modelTarget ? { model: modelTarget } : {},
       ...schemaTarget ? { schema: schemaTarget } : {},
@@ -1127,6 +1231,17 @@ function buildEnvironmentOutputConfig() {
     placeholderMap
   };
 }
+function buildEnvironmentFilterConfig() {
+  const includeTables = resolveFallbackValue(TABLES_ENV_KEYS);
+  const excludeTables = resolveFallbackValue(EXCLUDE_TABLES_ENV_KEYS);
+  if (includeTables === void 0 && excludeTables === void 0) {
+    return void 0;
+  }
+  return {
+    ...includeTables !== void 0 ? { includeTables } : {},
+    ...excludeTables !== void 0 ? { excludeTables } : {}
+  };
+}
 function buildEnvironmentNamingConfig() {
   const modelType = resolveOptionalOneOf(MODEL_TYPE_ENV_KEYS, NAMING_STYLE_VALUES);
   const modelConst = resolveOptionalOneOf(MODEL_CONST_ENV_KEYS, NAMING_STYLE_VALUES);
@@ -1202,6 +1317,7 @@ function createEnvironmentGeneratorConfig() {
     provider,
     output: buildEnvironmentOutputConfig(),
     naming: buildEnvironmentNamingConfig(),
+    filter: buildEnvironmentFilterConfig(),
     features: buildEnvironmentFeatureFlags(),
     experimental: buildEnvironmentExperimentalFlags()
   };
@@ -1363,7 +1479,7 @@ ${schemaEntries}
     content
   };
 }
-function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName, generatedAt, outputFormat, schemaVersion) {
+function renderRegistryArtifact(registryPath, databasePath, databaseConstName, registryConstName, databaseName, generatedAt, outputPreset, outputFormat, schemaVersion) {
   const databaseImportPath = toModuleImportPath(registryPath, databasePath);
   const content = `import { defineRegistry } from '@xylex-group/athena'
 import { ${databaseConstName} } from '${databaseImportPath}'
@@ -1372,6 +1488,7 @@ export const __athena_schema_meta = {
   schemaVersion: ${schemaVersion},
   generatedAt: ${escapeStringLiteral(generatedAt)},
   database: ${escapeStringLiteral(databaseName)},
+  outputPreset: ${escapeStringLiteral(outputPreset)},
   outputFormat: ${escapeStringLiteral(outputFormat)},
 } as const
 
@@ -1541,6 +1658,7 @@ function composeGeneratorArtifacts(input) {
         toSafeIdentifier("registry", config.naming.registryConst, "registry"),
         databaseName,
         snapshot.generatedAt,
+        config.output.preset,
         config.output.format,
         config.internal.schemaVersion
       )
@@ -1646,7 +1764,7 @@ export const ${descriptor.tableConstName} = table(${escapeStringLiteral(descript
   .columns({
 ${columnLines}
   })
-  .primaryKey(${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")})
+  ${descriptor.table.primaryKey.length > 0 ? `.primaryKey(${descriptor.table.primaryKey.map((value) => escapeStringLiteral(value)).join(", ")})` : ".withoutPrimaryKey()"}
 ${relationsAssignment ? `${relationsAssignment}` : ""}
 export type ${descriptor.rowTypeName} = RowOf<typeof ${descriptor.tableConstName}>
 export type ${descriptor.insertTypeName} = InsertOf<typeof ${descriptor.tableConstName}>
@@ -1743,11 +1861,12 @@ ${nullableLines}
 }
 function generateArtifactsFromSnapshot(snapshot, config) {
   const normalizedConfig = "internal" in config ? config : normalizeGeneratorConfig(config);
+  const filteredSnapshot = filterIntrospectionSnapshot(snapshot, normalizedConfig.filter);
   if (normalizedConfig.output.format === "table-builder") {
-    return generateTableBuilderArtifactsFromSnapshot(snapshot, normalizedConfig);
+    return generateTableBuilderArtifactsFromSnapshot(filteredSnapshot, normalizedConfig);
   }
   return composeGeneratorArtifacts({
-    snapshot,
+    snapshot: filteredSnapshot,
     config: normalizedConfig,
     createModelDescriptor({ providerName, databaseName, schemaName, tableName, table }) {
       const modelConstName = toSafeIdentifier(
@@ -1777,7 +1896,7 @@ function generateArtifactsFromSnapshot(snapshot, config) {
         table
       };
     },
-    renderModelArtifact: (descriptor) => renderModelArtifact2(snapshot.database, descriptor, normalizedConfig)
+    renderModelArtifact: (descriptor) => renderModelArtifact2(filteredSnapshot.database, descriptor, normalizedConfig)
   });
 }
 
@@ -1883,7 +2002,7 @@ var getSessionCookie = (request, config) => {
 
 // package.json
 var package_default = {
-  version: "2.8.0"
+  version: "2.9.0"
 };
 
 // src/sdk-version.ts
@@ -1896,6 +2015,7 @@ function buildSdkHeaderValue(sdkName) {
 var DEFAULT_CLIENT = "railway_direct";
 var SDK_NAME = "xylex-group/athena";
 var SDK_HEADER_VALUE = buildSdkHeaderValue(SDK_NAME);
+var NO_CACHE_HEADER_VALUE = "no-cache";
 function parseResponseBody(rawText, contentType) {
   if (!rawText) {
     return { parsed: null, parseFailed: false };
@@ -1914,6 +2034,9 @@ function parseResponseBody(rawText, contentType) {
 function normalizeHeaderValue(value) {
   return value ? value : void 0;
 }
+function isCacheControlHeaderName(name) {
+  return name.toLowerCase() === "cache-control";
+}
 function resolveHeaderValue(headers, candidates) {
   for (const candidate of candidates) {
     const direct = normalizeHeaderValue(headers[candidate]);
@@ -2072,6 +2195,7 @@ function buildRpcGetEndpoint(payload) {
 }
 function buildHeaders(config, options) {
   const mergedStripNulls = options?.stripNulls ?? true;
+  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
   const extraHeaders = {
     ...config.headers ?? {},
     ...options?.headers ?? {}
@@ -2125,11 +2249,15 @@ function buildHeaders(config, options) {
   const athenaClientKeys = ["x-athena-client", "X-Athena-Client"];
   Object.entries(extraHeaders).forEach(([key, value]) => {
     if (athenaClientKeys.includes(key)) return;
+    if (forceNoCache && isCacheControlHeaderName(key)) return;
     const normalized = normalizeHeaderValue(value);
     if (normalized) {
       headers[key] = normalized;
     }
   });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE;
+  }
   return headers;
 }
 function toInvalidUrlResponse(error, endpoint, method) {
@@ -2569,6 +2697,35 @@ function quoteSelectColumnsExpression(columns) {
   }
   return tokens.map(quoteSelectToken).join(", ");
 }
+var ATHENA_AUTH_MAX_TEMPLATE_VARIABLES = 64;
+var ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH = 128;
+function describeTemplateVariableTarget(target) {
+  const normalized = target?.trim();
+  return normalized && normalized.length > 0 ? normalized : "Athena auth admin email template variables";
+}
+function assertAthenaAuthTemplateVariables(variables, target) {
+  const label = describeTemplateVariableTarget(target);
+  if (!Array.isArray(variables)) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  if (variables.length > ATHENA_AUTH_MAX_TEMPLATE_VARIABLES) {
+    throw new Error(
+      `${label} cannot contain more than ${ATHENA_AUTH_MAX_TEMPLATE_VARIABLES} entries.`
+    );
+  }
+  variables.forEach((variable, index) => {
+    if (typeof variable !== "string") {
+      throw new Error(
+        `${label} must contain only strings. Received ${typeof variable} at index ${index}.`
+      );
+    }
+    if (variable.length > ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH) {
+      throw new Error(
+        `${label} cannot contain entries longer than ${ATHENA_AUTH_MAX_TEMPLATE_VARIABLE_LENGTH} characters. Received ${variable.length} characters at index ${index}.`
+      );
+    }
+  });
+}
 
 // src/auth/react-email.ts
 var reactEmailRenderModulePromise;
@@ -2758,6 +2915,7 @@ async function resolveReactEmailPayloadFields(input, fields, options) {
 var DEFAULT_AUTH_BASE_URL = "http://localhost:3001/api/auth";
 var SDK_NAME2 = "xylex-group/athena-auth";
 var SDK_HEADER_VALUE2 = buildSdkHeaderValue(SDK_NAME2);
+var NO_CACHE_HEADER_VALUE2 = "no-cache";
 function normalizeBaseUrl(baseUrl) {
   return (baseUrl ?? DEFAULT_AUTH_BASE_URL).replace(/\/$/, "");
 }
@@ -2767,6 +2925,9 @@ function isRecord4(value) {
 function normalizeHeaderValue2(value) {
   return value ? value : void 0;
 }
+function isCacheControlHeaderName2(name) {
+  return name.toLowerCase() === "cache-control";
+}
 function parseResponseBody2(rawText, contentType) {
   if (!rawText) {
     return { parsed: null, parseFailed: false };
@@ -2822,6 +2983,54 @@ function mergeCallOptions(base, override) {
     }
   };
 }
+function toSessionGuardFailure(sessionResult) {
+  if (sessionResult.status === 401 || sessionResult.data == null) {
+    return {
+      ok: false,
+      reason: "unauthorized",
+      status: 401,
+      error: sessionResult.error ?? "Unauthorized",
+      sessionResult
+    };
+  }
+  return {
+    ok: false,
+    reason: "upstream_error",
+    status: sessionResult.status,
+    error: sessionResult.error ?? "Failed to resolve current session",
+    sessionResult
+  };
+}
+function toPermissionGuardFailure(permissionResult, sessionResult) {
+  if (permissionResult.status === 401) {
+    return {
+      ok: false,
+      reason: "unauthorized",
+      status: 401,
+      error: permissionResult.error ?? "Unauthorized",
+      sessionResult,
+      permissionResult
+    };
+  }
+  if (permissionResult.status === 403) {
+    return {
+      ok: false,
+      reason: "forbidden",
+      status: 403,
+      error: permissionResult.error ?? "Forbidden",
+      sessionResult,
+      permissionResult
+    };
+  }
+  return {
+    ok: false,
+    reason: "upstream_error",
+    status: permissionResult.status,
+    error: permissionResult.error ?? "Failed to resolve permission check",
+    sessionResult,
+    permissionResult
+  };
+}
 function extractFetchOptions(input) {
   if (!input) {
     return {
@@ -2837,6 +3046,7 @@ function extractFetchOptions(input) {
   };
 }
 function buildHeaders2(config, options) {
+  const forceNoCache = Boolean(config.forceNoCache || options?.forceNoCache);
   const headers = {
     "Content-Type": "application/json",
     "X-Athena-Sdk": SDK_HEADER_VALUE2
@@ -2850,16 +3060,30 @@ function buildHeaders2(config, options) {
   if (bearerToken) {
     headers.Authorization = `Bearer ${bearerToken}`;
   }
+  const cookie = options?.cookie ?? config.cookie;
+  if (cookie) {
+    headers.Cookie = cookie;
+  }
+  const sessionToken = options?.sessionToken ?? config.sessionToken;
+  if (sessionToken) {
+    headers["X-Athena-Auth-Session-Token"] = sessionToken;
+  }
   const mergedExtraHeaders = {
     ...config.headers ?? {},
     ...options?.headers ?? {}
   };
   Object.entries(mergedExtraHeaders).forEach(([key, value]) => {
+    if (forceNoCache && isCacheControlHeaderName2(key)) {
+      return;
+    }
     const normalized = normalizeHeaderValue2(value);
     if (normalized) {
       headers[key] = normalized;
     }
   });
+  if (forceNoCache) {
+    headers["Cache-Control"] = NO_CACHE_HEADER_VALUE2;
+  }
   return headers;
 }
 function appendQueryParam(searchParams, key, value) {
@@ -3124,7 +3348,91 @@ function createAuthClient(config = {}) {
     htmlField: "htmlTemplate",
     textField: "textTemplate",
     variablesField: "variables"
-  }, withReactEmailRoute(route));
+  }, withReactEmailRoute(route)).then((payload) => {
+    if ("variables" in payload && payload.variables !== void 0 && payload.variables !== null) {
+      assertAthenaAuthTemplateVariables(
+        payload.variables,
+        `${route} variables`
+      );
+    }
+    return payload;
+  });
+  const requireSession = async (input, options) => {
+    const sessionInput = input?.fetchOptions ? { fetchOptions: input.fetchOptions } : void 0;
+    const sessionResult = await getGeneric(
+      "/get-session",
+      sessionInput,
+      options
+    );
+    if (!sessionResult.ok || sessionResult.data == null) {
+      return toSessionGuardFailure(sessionResult);
+    }
+    return {
+      ok: true,
+      session: sessionResult.data
+    };
+  };
+  const getUser = async (input, options) => {
+    const sessionResult = await getGeneric(
+      "/get-session",
+      input,
+      options
+    );
+    if (!sessionResult.ok) {
+      return {
+        ...sessionResult,
+        data: null
+      };
+    }
+    return {
+      ...sessionResult,
+      data: {
+        user: sessionResult.data?.user ?? null
+      }
+    };
+  };
+  const requirePermission = async (endpoint, input, options) => {
+    const sessionGuard = await requireSession(
+      input?.fetchOptions ? { fetchOptions: input.fetchOptions } : void 0,
+      options
+    );
+    if (!sessionGuard.ok) {
+      return sessionGuard;
+    }
+    const permissionResult = await postGeneric(
+      endpoint,
+      input,
+      options
+    );
+    if (!permissionResult.ok) {
+      return toPermissionGuardFailure(permissionResult, {
+        ok: true,
+        status: 200,
+        data: sessionGuard.session,
+        error: null,
+        errorDetails: null,
+        raw: sessionGuard.session
+      });
+    }
+    if (!permissionResult.data?.success) {
+      return {
+        ok: false,
+        reason: "forbidden",
+        status: 403,
+        error: permissionResult.data?.error ?? "Forbidden",
+        sessionResult: {
+          ok: true,
+          status: 200,
+          data: sessionGuard.session,
+          error: null,
+          errorDetails: null,
+          raw: sessionGuard.session
+        },
+        permissionResult
+      };
+    }
+    return sessionGuard;
+  };
   const listUserEmailsWithFallback = async (input, options) => {
     const primary = await getWithQuery(
       "/email/list",
@@ -3286,6 +3594,7 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    requirePermission: (input, options) => requirePermission("/organization/has-permission", input, options),
     invitation: {
       cancel: (input, options) => executePostWithCompatibleInput(
         resolvedConfig,
@@ -3481,6 +3790,8 @@ function createAuthClient(config = {}) {
   };
   const auth = {
     getSession: (input, options) => getGeneric("/get-session", input, options),
+    getUser,
+    requireSession,
     signOut,
     forgetPassword: (input, options) => postGeneric("/forget-password", input, options),
     resetPassword: authResetPassword,
@@ -3575,6 +3886,7 @@ function createAuthClient(config = {}) {
         }
       },
       hasPermission: (input, options) => postGeneric("/admin/has-permission", input, options),
+      requirePermission: (input, options) => requirePermission("/admin/has-permission", input, options),
       apiKey: {
         create: (input, options) => postGeneric("/admin/api-key/create", input, options)
       },
@@ -3726,6 +4038,8 @@ function createAuthClient(config = {}) {
       input,
       options
     ),
+    getUser,
+    requireSession,
     listSessions: (input, options) => executeGetWithCompatibleInput(
       resolvedConfig,
       { endpoint: "/list-sessions", method: "GET" },
@@ -3879,7 +4193,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
         }
       };
     });
@@ -3890,10 +4209,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,
@@ -3996,8 +4322,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);
   }
@@ -4208,129 +4535,624 @@ var storageSdkManifest = {
       responseType: "{ data: S3CatalogItem[] }"
     },
     {
-      name: "createStorageCatalog",
+      name: "createStorageCatalog",
+      method: "POST",
+      path: "/storage/catalogs",
+      requestType: "CreateStorageCatalogRequest",
+      responseEnvelope: "raw",
+      responseType: "S3CatalogItem"
+    },
+    {
+      name: "updateStorageCatalog",
+      method: "PATCH",
+      path: "/storage/catalogs/{id}",
+      pathParams: ["id"],
+      requestType: "UpdateStorageCatalogRequest",
+      responseEnvelope: "raw",
+      responseType: "S3CatalogItem"
+    },
+    {
+      name: "deleteStorageCatalog",
+      method: "DELETE",
+      path: "/storage/catalogs/{id}",
+      pathParams: ["id"],
+      responseEnvelope: "raw",
+      responseType: "{ id: string; deleted: boolean }"
+    },
+    {
+      name: "listStorageCredentials",
+      method: "GET",
+      path: "/storage/credentials",
+      responseEnvelope: "raw",
+      responseType: "{ data: S3CredentialListItem[] }"
+    },
+    {
+      name: "createStorageUploadUrl",
+      method: "POST",
+      path: "/storage/files/upload-url",
+      requestType: "CreateStorageUploadUrlRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageUploadUrlResponse"
+    },
+    {
+      name: "createStorageUploadUrls",
+      method: "POST",
+      path: "/storage/files/upload-urls",
+      requestType: "CreateStorageUploadUrlsRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageBatchUploadUrlResponse"
+    },
+    {
+      name: "listStorageFiles",
+      method: "POST",
+      path: "/storage/files/list",
+      requestType: "ListStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageListFilesResponse"
+    },
+    {
+      name: "getStorageFile",
+      method: "GET",
+      path: "/storage/files/{file_id}",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "getStorageFileUrl",
+      method: "GET",
+      path: "/storage/files/{file_id}/url",
+      pathParams: ["file_id"],
+      queryParams: ["purpose"],
+      responseEnvelope: "athena",
+      responseType: "PresignedFileUrlResponse"
+    },
+    {
+      name: "getStorageFileProxy",
+      method: "GET",
+      path: "/storage/files/{file_id}/proxy",
+      pathParams: ["file_id"],
+      queryParams: ["purpose"],
+      responseEnvelope: "raw",
+      responseType: "Response",
+      binary: true
+    },
+    {
+      name: "updateStorageFile",
+      method: "PATCH",
+      path: "/storage/files/{file_id}",
+      pathParams: ["file_id"],
+      requestType: "UpdateStorageFileRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "deleteStorageFile",
+      method: "DELETE",
+      path: "/storage/files/{file_id}",
+      pathParams: ["file_id"],
+      responseEnvelope: "athena",
+      responseType: "StorageFileMutationResponse"
+    },
+    {
+      name: "setStorageFileVisibility",
+      method: "PATCH",
+      path: "/storage/files/{file_id}/visibility",
+      pathParams: ["file_id"],
+      requestType: "SetStorageFileVisibilityRequest",
+      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",
+      path: "/storage/folders/delete",
+      requestType: "DeleteStorageFolderRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFolderMutationResponse"
+    },
+    {
+      name: "moveStorageFolder",
+      method: "POST",
+      path: "/storage/folders/move",
+      requestType: "MoveStorageFolderRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageFolderMutationResponse"
+    },
+    {
+      name: "searchStorageFiles",
+      method: "POST",
+      path: "/storage/files/search",
+      requestType: "SearchStorageFilesRequest",
+      responseEnvelope: "athena",
+      responseType: "StorageListFilesResponse"
+    },
+    {
+      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/catalogs",
-      requestType: "CreateStorageCatalogRequest",
-      responseEnvelope: "raw",
-      responseType: "S3CatalogItem"
+      path: "/storage/buckets/policy",
+      requestType: "StorageBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "updateStorageCatalog",
-      method: "PATCH",
-      path: "/storage/catalogs/{id}",
-      pathParams: ["id"],
-      requestType: "UpdateStorageCatalogRequest",
-      responseEnvelope: "raw",
-      responseType: "S3CatalogItem"
+      name: "setStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy/set",
+      requestType: "StorageSetBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "deleteStorageCatalog",
-      method: "DELETE",
-      path: "/storage/catalogs/{id}",
-      pathParams: ["id"],
-      responseEnvelope: "raw",
-      responseType: "{ id: string; deleted: boolean }"
+      name: "deleteStorageBucketPolicy",
+      method: "POST",
+      path: "/storage/buckets/policy/delete",
+      requestType: "StorageBucketPolicyRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "listStorageCredentials",
-      method: "GET",
-      path: "/storage/credentials",
-      responseEnvelope: "raw",
-      responseType: "{ data: S3CredentialListItem[] }"
+      name: "getStorageBucketPublicAccess",
+      method: "POST",
+      path: "/storage/buckets/public-access",
+      requestType: "StoragePublicAccessBlockRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "createStorageUploadUrl",
+      name: "setStorageBucketPublicAccess",
       method: "POST",
-      path: "/storage/files/upload-url",
-      requestType: "CreateStorageUploadUrlRequest",
+      path: "/storage/buckets/public-access/set",
+      requestType: "StorageSetPublicAccessBlockRequest",
       responseEnvelope: "athena",
-      responseType: "StorageUploadUrlResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "createStorageUploadUrls",
+      name: "deleteStorageBucketPublicAccess",
       method: "POST",
-      path: "/storage/files/upload-urls",
-      requestType: "CreateStorageUploadUrlsRequest",
+      path: "/storage/buckets/public-access/delete",
+      requestType: "StoragePublicAccessBlockRequest",
       responseEnvelope: "athena",
-      responseType: "StorageBatchUploadUrlResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "listStorageFiles",
+      name: "getStorageBucketCors",
       method: "POST",
-      path: "/storage/files/list",
-      requestType: "ListStorageFilesRequest",
+      path: "/storage/buckets/cors",
+      requestType: "StorageBucketCorsRequest",
       responseEnvelope: "athena",
-      responseType: "StorageListFilesResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "getStorageFile",
-      method: "GET",
-      path: "/storage/files/{file_id}",
-      pathParams: ["file_id"],
+      name: "setStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors/set",
+      requestType: "StorageSetBucketCorsRequest",
       responseEnvelope: "athena",
-      responseType: "StorageFileMutationResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "getStorageFileUrl",
-      method: "GET",
-      path: "/storage/files/{file_id}/url",
-      pathParams: ["file_id"],
-      queryParams: ["purpose"],
+      name: "deleteStorageBucketCors",
+      method: "POST",
+      path: "/storage/buckets/cors/delete",
+      requestType: "StorageBucketCorsRequest",
       responseEnvelope: "athena",
-      responseType: "PresignedFileUrlResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "getStorageFileProxy",
-      method: "GET",
-      path: "/storage/files/{file_id}/proxy",
-      pathParams: ["file_id"],
-      queryParams: ["purpose"],
-      responseEnvelope: "raw",
-      responseType: "Response",
-      binary: true
+      name: "createStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/create",
+      requestType: "StorageMultipartCreateRequest",
+      responseEnvelope: "athena",
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "updateStorageFile",
-      method: "PATCH",
-      path: "/storage/files/{file_id}",
-      pathParams: ["file_id"],
-      requestType: "UpdateStorageFileRequest",
+      name: "signStorageMultipartPart",
+      method: "POST",
+      path: "/storage/multipart/sign-part",
+      requestType: "StorageMultipartSignPartRequest",
       responseEnvelope: "athena",
-      responseType: "StorageFileMutationResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "deleteStorageFile",
-      method: "DELETE",
-      path: "/storage/files/{file_id}",
-      pathParams: ["file_id"],
+      name: "completeStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/complete",
+      requestType: "StorageMultipartCompleteRequest",
       responseEnvelope: "athena",
       responseType: "StorageFileMutationResponse"
     },
     {
-      name: "setStorageFileVisibility",
-      method: "PATCH",
-      path: "/storage/files/{file_id}/visibility",
-      pathParams: ["file_id"],
-      requestType: "SetStorageFileVisibilityRequest",
+      name: "abortStorageMultipartUpload",
+      method: "POST",
+      path: "/storage/multipart/abort",
+      requestType: "StorageMultipartAbortRequest",
       responseEnvelope: "athena",
-      responseType: "StorageFileMutationResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "deleteStorageFolder",
+      name: "listStorageMultipartParts",
       method: "POST",
-      path: "/storage/folders/delete",
-      requestType: "DeleteStorageFolderRequest",
+      path: "/storage/multipart/list-parts",
+      requestType: "StorageMultipartListPartsRequest",
       responseEnvelope: "athena",
-      responseType: "StorageFolderMutationResponse"
+      responseType: "Record<string, unknown>"
     },
     {
-      name: "moveStorageFolder",
+      name: "listStorageAuditEvents",
       method: "POST",
-      path: "/storage/folders/move",
-      requestType: "MoveStorageFolderRequest",
+      path: "/storage/audit/list",
+      requestType: "StorageAuditQueryRequest",
       responseEnvelope: "athena",
-      responseType: "StorageFolderMutationResponse"
+      responseType: "StorageAuditListResponse"
     }
   ]
 };
@@ -4783,7 +5605,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",
@@ -4829,7 +5651,12 @@ 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) {
@@ -4980,6 +5807,12 @@ function createStorageModule(gateway, runtimeOptions) {
     options,
     resolvedRuntimeOptions
   );
+  const callStorageFileVisibility = (fileId, method, input, options) => callAthena2(
+    withPathParam("/storage/files/{file_id}/visibility", "file_id", fileId),
+    method,
+    input,
+    options
+  );
   const base = {
     listStorageCatalogs(options) {
       return callRaw("/storage/catalogs", "GET", void 0, options);
@@ -5029,7 +5862,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);
@@ -5101,13 +5934,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);
       }
@@ -5202,6 +6084,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 = {
@@ -5214,6 +6108,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);
@@ -7790,6 +8717,59 @@ function createQueryBuilder(client, formatGatewayResult, experimental, tracer) {
     );
   };
 }
+function normalizeOptionalString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue ? normalizedValue : void 0;
+}
+function readHeaderBagValue(headers, targetKey) {
+  if (!headers) {
+    return void 0;
+  }
+  if (typeof headers.get === "function") {
+    return normalizeOptionalString2(headers.get(targetKey));
+  }
+  const normalizedTargetKey = targetKey.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== normalizedTargetKey) {
+      continue;
+    }
+    if (typeof value === "string") {
+      return normalizeOptionalString2(value);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function resolveSessionContextOptions(session, options) {
+  const sessionToken = normalizeOptionalString2(session?.session?.token);
+  const requestCookie = readHeaderBagValue(options?.requestHeaders, "cookie") ?? readHeaderBagValue(options?.headers, "cookie");
+  const authInput = options?.auth;
+  const resolvedUserId = options?.userId !== void 0 ? options.userId : session?.user?.id;
+  const resolvedOrganizationId = options?.organizationId !== void 0 ? options.organizationId : session?.session?.activeOrganizationId;
+  const resolvedBearerToken = authInput?.bearerToken !== void 0 ? authInput.bearerToken : sessionToken;
+  const resolvedSessionToken = authInput?.sessionToken !== void 0 ? authInput.sessionToken : sessionToken;
+  const resolvedCookie = authInput?.cookie !== void 0 ? authInput.cookie : requestCookie;
+  const auth = authInput !== void 0 || resolvedBearerToken !== void 0 || resolvedSessionToken !== void 0 || resolvedCookie !== void 0 ? {
+    ...authInput ?? {},
+    ...resolvedBearerToken !== void 0 ? { bearerToken: resolvedBearerToken } : {},
+    ...resolvedSessionToken !== void 0 ? { sessionToken: resolvedSessionToken } : {},
+    ...resolvedCookie !== void 0 ? { cookie: resolvedCookie } : {},
+    headers: authInput?.headers ? { ...authInput.headers } : void 0
+  } : void 0;
+  if (resolvedUserId === void 0 && resolvedOrganizationId === void 0 && options?.forceNoCache === void 0 && !options?.headers && !auth) {
+    return void 0;
+  }
+  return {
+    userId: resolvedUserId,
+    organizationId: resolvedOrganizationId,
+    forceNoCache: options?.forceNoCache,
+    headers: options?.headers ? { ...options.headers } : void 0,
+    auth
+  };
+}
 function resolveClientServiceBaseUrl(value, label) {
   if (value === void 0 || value === null) {
     return void 0;
@@ -7811,21 +8791,143 @@ function resolveServiceUrls(config) {
     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 hasHeaderIgnoreCase(headers, targetKey) {
+  const normalizedTargetKey = targetKey.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalizedTargetKey);
+}
+function mergeClientHeaders(current, next) {
+  if (!current && !next) {
+    return void 0;
+  }
+  return {
+    ...current ?? {},
+    ...next ?? {}
+  };
+}
+function mergeDefinedObject(current, next) {
+  if (!current && !next) {
+    return void 0;
+  }
+  const merged = {
+    ...current ?? {}
+  };
+  const mutableMerged = merged;
+  for (const [key, value] of Object.entries(next ?? {})) {
+    if (value !== void 0) {
+      mutableMerged[key] = value;
+    }
+  }
+  return merged;
+}
+function mergeAuthClientOptions(current, next) {
+  const merged = mergeDefinedObject(current, next);
+  if (!merged) {
+    return void 0;
+  }
+  const mergedHeaders = mergeClientHeaders(current?.headers, next?.headers);
+  if (mergedHeaders) {
+    merged.headers = mergedHeaders;
+  }
+  return merged;
+}
+function mergeServiceUrlOverrides(current, next) {
+  return mergeDefinedObject(current, next);
+}
+function toClientContextOverrides(context) {
+  if (!context) {
+    return void 0;
+  }
+  return {
+    userId: context.userId,
+    organizationId: context.organizationId,
+    forceNoCache: context.forceNoCache,
+    headers: context.headers,
+    auth: context.auth ? {
+      ...context.auth,
+      headers: context.auth.headers ? { ...context.auth.headers } : void 0
+    } : void 0
+  };
+}
+function mergeClientOverrideOptions(base, overrides) {
+  if (!overrides) {
+    return {
+      ...base,
+      headers: base.headers ? { ...base.headers } : void 0,
+      auth: base.auth ? {
+        ...base.auth,
+        headers: base.auth.headers ? { ...base.auth.headers } : void 0
+      } : void 0,
+      db: base.db ? { ...base.db } : void 0,
+      gateway: base.gateway ? { ...base.gateway } : void 0,
+      storage: base.storage ? { ...base.storage } : void 0
+    };
+  }
+  const merged = mergeDefinedObject(base, overrides) ?? { ...base };
+  return {
+    ...merged,
+    headers: mergeClientHeaders(base.headers, overrides.headers),
+    auth: mergeAuthClientOptions(base.auth, overrides.auth),
+    db: mergeServiceUrlOverrides(base.db, overrides.db),
+    gateway: mergeServiceUrlOverrides(base.gateway, overrides.gateway),
+    storage: mergeServiceUrlOverrides(base.storage, overrides.storage)
+  };
+}
 function normalizeAuthClientConfig(auth, defaultBaseUrl) {
   if (!auth && defaultBaseUrl === void 0) {
     return void 0;
   }
-  const { url, ...rest } = auth ?? {};
+  const {
+    url,
+    baseUrl,
+    apiKey,
+    bearerToken,
+    cookie,
+    sessionToken,
+    ...rest
+  } = auth ?? {};
   const normalized = {
     ...rest
   };
   const resolvedBaseUrl = resolveClientServiceBaseUrl(
-    url ?? rest.baseUrl ?? defaultBaseUrl,
+    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;
+  }
+  if (typeof cookie === "string") {
+    normalized.cookie = cookie;
+  }
+  if (typeof sessionToken === "string") {
+    normalized.sessionToken = sessionToken;
+  }
   return normalized;
 }
 function resolveCreateClientConfig(config) {
@@ -7837,8 +8939,11 @@ function resolveCreateClientConfig(config) {
   }
   return {
     baseUrl: resolvedUrls.dbUrl,
-    apiKey: config.key,
-    client: config.client,
+    apiKey: resolveRequiredClientApiKey(config.key),
+    client: resolveOptionalClientName(config.client),
+    userId: config.userId,
+    organizationId: config.organizationId,
+    forceNoCache: config.forceNoCache,
     backend: toBackendConfig(config.backend),
     headers: config.headers,
     auth: config.auth,
@@ -7847,23 +8952,39 @@ function resolveCreateClientConfig(config) {
     experimental: config.experimental
   };
 }
-function createClientFromConfig(config) {
+function createClientFromInput(sourceConfig) {
+  return createClientFromConfig(resolveCreateClientConfig(sourceConfig), sourceConfig);
+}
+function createClientFromConfig(config, sourceConfig) {
+  const normalizedAuthConfig = normalizeAuthClientConfig(config.auth, config.authUrl);
   const gatewayHeaders = {
     ...config.headers ?? {}
   };
-  if (config.auth?.bearerToken && gatewayHeaders["X-Athena-Auth-Bearer-Token"] === void 0 && gatewayHeaders["x-athena-auth-bearer-token"] === void 0) {
-    gatewayHeaders["X-Athena-Auth-Bearer-Token"] = config.auth.bearerToken;
+  if (normalizedAuthConfig?.bearerToken && !hasHeaderIgnoreCase(gatewayHeaders, "X-Athena-Auth-Bearer-Token")) {
+    gatewayHeaders["X-Athena-Auth-Bearer-Token"] = normalizedAuthConfig.bearerToken;
+  }
+  if (normalizedAuthConfig?.cookie && !hasHeaderIgnoreCase(gatewayHeaders, "Cookie")) {
+    gatewayHeaders.Cookie = normalizedAuthConfig.cookie;
+  }
+  if (normalizedAuthConfig?.sessionToken && !hasHeaderIgnoreCase(gatewayHeaders, "X-Athena-Auth-Session-Token")) {
+    gatewayHeaders["X-Athena-Auth-Session-Token"] = normalizedAuthConfig.sessionToken;
   }
   const gateway = createAthenaGatewayClient({
     baseUrl: config.baseUrl,
     apiKey: config.apiKey,
     client: config.client,
+    userId: config.userId,
+    organizationId: config.organizationId,
+    forceNoCache: config.forceNoCache,
     backend: config.backend,
     headers: gatewayHeaders
   });
   const formatGatewayResult = createResultFormatter(config.experimental);
   const queryTracer = createQueryTracer(config.experimental);
-  const auth = createAuthClient(normalizeAuthClientConfig(config.auth, config.authUrl));
+  const auth = createAuthClient({
+    ...normalizedAuthConfig ?? {},
+    ...config.forceNoCache ? { forceNoCache: true } : {}
+  });
   function from(tableOrModel, options) {
     if (isAthenaModelTarget(tableOrModel)) {
       if (options?.schema !== void 0) {
@@ -7911,17 +9032,45 @@ function createClientFromConfig(config) {
     queryTracer
   );
   const db = createDbModule({ from, rpc, query });
+  const withContext = (context) => createClientFromInput(
+    mergeClientOverrideOptions(sourceConfig, toClientContextOverrides(context))
+  );
+  const withSession = (session, options) => createClientFromInput(
+    mergeClientOverrideOptions(
+      sourceConfig,
+      toClientContextOverrides(resolveSessionContextOptions(session, options))
+    )
+  );
+  const authWithOptions = (options) => createClientFromInput(mergeClientOverrideOptions(sourceConfig, options));
   const sdkClient = {
     from,
     db,
     rpc,
     query,
     verifyConnection: gateway.verifyConnection,
-    auth: auth.auth
+    auth: auth.auth,
+    withContext,
+    withSession,
+    withOptions: authWithOptions
   };
   if (config.experimental?.athenaStorageBackend) {
+    const storageWithContext = (context) => createClientFromInput(
+      mergeClientOverrideOptions(sourceConfig, toClientContextOverrides(context))
+    );
+    const storageWithSession = (session, options) => createClientFromInput(
+      mergeClientOverrideOptions(
+        sourceConfig,
+        toClientContextOverrides(resolveSessionContextOptions(session, options))
+      )
+    );
+    const storageWithOptions = (options) => createClientFromInput(
+      mergeClientOverrideOptions(sourceConfig, options)
+    );
     const storageClient = {
       ...sdkClient,
+      withContext: storageWithContext,
+      withSession: storageWithSession,
+      withOptions: storageWithOptions,
       storage: createStorageModule(gateway, {
         ...config.experimental.storage,
         ...config.storageUrl ? {
@@ -7935,14 +9084,14 @@ function createClientFromConfig(config) {
   return sdkClient;
 }
 function createClient(configOrUrl, apiKey, options) {
-  if (typeof configOrUrl === "string") {
-    return createClientFromConfig(resolveCreateClientConfig({
+  if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
+    return createClientFromInput({
       url: configOrUrl,
       key: apiKey ?? "",
       ...options
-    }));
+    });
   }
-  return createClientFromConfig(resolveCreateClientConfig(configOrUrl));
+  return createClientFromInput(configOrUrl);
 }
 
 // src/schema/postgres-introspection-core.ts
@@ -8498,16 +9647,25 @@ async function fileExists(path) {
 }
 async function writeArtifacts(files, cwd) {
   const writtenFiles = [];
+  const skippedFiles = [];
   for (const file of files) {
     const absolutePath = resolve(cwd, file.path);
     if (!canOverwriteArtifact(file) && await fileExists(absolutePath)) {
+      skippedFiles.push({
+        kind: file.kind,
+        path: file.path,
+        reason: "protected-existing-file"
+      });
       continue;
     }
     await mkdir(dirname(absolutePath), { recursive: true });
     await writeFile(absolutePath, file.content, "utf8");
     writtenFiles.push(file.path);
   }
-  return writtenFiles;
+  return {
+    writtenFiles,
+    skippedFiles
+  };
 }
 async function runSchemaGenerator(options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -8521,11 +9679,13 @@ async function runSchemaGenerator(options = {}) {
     schemas: resolveProviderSchemas(config.provider)
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
-  const writtenFiles = options.dryRun ? [] : await writeArtifacts(generated.files, cwd);
+  const writeResult = options.dryRun ? { writtenFiles: [], skippedFiles: [] } : await writeArtifacts(generated.files, cwd);
   return {
     ...generated,
     configPath,
-    writtenFiles
+    config,
+    writtenFiles: writeResult.writtenFiles,
+    skippedFiles: writeResult.skippedFiles
   };
 }
 
@@ -8553,7 +9713,7 @@ function generateUsage() {
     "",
     "Options:",
     "  --config <path>  Explicit path to athena.config.ts or athena-js.config.ts",
-    "  --dry-run        Build generated files in memory without writing them to disk",
+    "  --dry-run        Build generated files in memory without writing them to disk and print mode/target hints",
     "  -h, --help       Show help for generate",
     "",
     "Config resolution:",
@@ -8567,6 +9727,68 @@ function generateUsage() {
     "  athena-js generate --config ./athena.config.ts --dry-run"
   ].join("\n");
 }
+function normalizePath2(pathValue) {
+  return pathValue.replace(/\\/g, "/");
+}
+function isLegacyConfigRegistryTarget(target) {
+  return normalizePath2(target) === "athena/config.ts";
+}
+function isFlatSchemaTarget(target) {
+  return normalizePath2(target) === "athena/schema.ts";
+}
+function formatProviderLine(result) {
+  const { provider } = result.config;
+  if (provider.kind === "postgres") {
+    const schemaList = Array.isArray(provider.schemas) ? provider.schemas.join(",") : typeof provider.schemas === "string" ? provider.schemas : "public";
+    const database = provider.database ? ` database=${provider.database}` : "";
+    const backend = provider.mode === "gateway" && provider.backend ? ` backend=${provider.backend}` : "";
+    return `[provider] kind=${provider.kind} mode=${provider.mode}${database}${backend} schemas=${schemaList}`;
+  }
+  const datacenter = provider.datacenter ? ` datacenter=${provider.datacenter}` : "";
+  return `[provider] kind=${provider.kind} mode=${provider.mode} keyspace=${provider.keyspace} contactPoints=${provider.contactPoints.join(",")}${datacenter}`;
+}
+function formatFilterLine(result) {
+  const { includeTables, excludeTables } = result.config.filter;
+  if (includeTables.length === 0 && excludeTables.length === 0) {
+    return void 0;
+  }
+  return `[filter] include=${includeTables.length > 0 ? includeTables.join(",") : "-"} exclude=${excludeTables.length > 0 ? excludeTables.join(",") : "-"}`;
+}
+function formatGeneratorModeLines(result) {
+  const lines = [
+    `[mode] preset=${result.config.output.preset} format=${result.config.output.format} modelTarget=${result.config.output.targets.model}`,
+    formatProviderLine(result),
+    `[targets] schema=${result.config.output.targets.schema} database=${result.config.output.targets.database} registry=${result.config.output.targets.registry}`
+  ];
+  const filterLine = formatFilterLine(result);
+  if (filterLine) {
+    lines.push(filterLine);
+  }
+  if (result.config.output.format === "define-model") {
+    lines.push(
+      '[note] Legacy define-model compatibility output is active. Set output.format="table-builder" or ATHENA_GENERATOR_OUTPUT_FORMAT=table-builder to emit table(...).schema(...).columns(...).primaryKey(...).'
+    );
+  }
+  if (result.config.output.preset === "legacy") {
+    lines.push(
+      '[note] Legacy preset is active. It keeps registry output on athena/config.ts for compatibility; prefer output.preset="athena-direct" for the default safe direct layout.'
+    );
+  }
+  lines.push(
+    "[note] Default generator mode is preset=athena-direct + format=table-builder. experimental.findManyAst only affects runtime findMany(...) transport and does not enable generator table output."
+  );
+  if (isLegacyConfigRegistryTarget(result.config.output.targets.registry)) {
+    lines.push(
+      '[warn] Registry target points at athena/config.ts. That file is often a handwritten runtime seam; prefer output.preset="athena-direct" or output.targets.registry="athena/registry.generated.ts" unless you intentionally need legacy compatibility.'
+    );
+  }
+  if (isFlatSchemaTarget(result.config.output.targets.schema)) {
+    lines.push(
+      "[warn] Schema target points at athena/schema.ts. Prefer schema-scoped output such as athena/schemas/{schema_kebab}.ts."
+    );
+  }
+  return lines;
+}
 function usage(topic = "root") {
   return topic === "generate" ? generateUsage() : rootUsage();
 }
@@ -8649,6 +9871,12 @@ function formatGeneratorError(error, configPath) {
   }
   return new Error(normalizeErrorMessage(error));
 }
+function formatSkippedArtifactLine(artifact) {
+  if (artifact.reason === "protected-existing-file") {
+    return ` [skip] ${artifact.path} (existing ${artifact.kind} artifacts are protected from overwrite; delete or retarget the file to regenerate it)`;
+  }
+  return ` [skip] ${artifact.path}`;
+}
 async function runCLI(argv, runtime = {}) {
   const log = runtime.log ?? console.log;
   const runGenerator = runtime.runGenerator ?? runSchemaGenerator;
@@ -8668,15 +9896,24 @@ async function runCLI(argv, runtime = {}) {
   }
   if (parsed.dryRun) {
     log(`[dry-run] Generated ${result.files.length} files from ${result.configPath}`);
+    for (const line of formatGeneratorModeLines(result)) {
+      log(line);
+    }
     for (const file of result.files) {
       log(` - ${file.path}`);
     }
     return;
   }
   log(`Generated ${result.writtenFiles.length} files from ${result.configPath}`);
+  for (const line of formatGeneratorModeLines(result)) {
+    log(line);
+  }
   for (const filePath of result.writtenFiles) {
     log(` - ${filePath}`);
   }
+  for (const artifact of result.skippedFiles) {
+    log(formatSkippedArtifactLine(artifact));
+  }
 }
 
 export { parseCommand, runCLI, usage };