@xylex-group/athena 3.0.2 → 3.1.0

package/dist/index.cjs

@@ -573,8 +573,8 @@ function computeDelayMs(attempt, error, config) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve3) => {
-    setTimeout(resolve3, ms);
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
   });
 }
 async function withRetry(config, fn) {
@@ -2009,7 +2009,7 @@ function buildAthenaGatewayUrl(baseUrl, path) {
 
 // package.json
 var package_default = {
-  version: "3.0.2"
+  version: "3.1.0"
 };
 
 // src/sdk-version.ts
@@ -5228,7 +5228,7 @@ async function putWithXhr(url, signed, body, signal, onProgress) {
   if (Xhr === void 0) {
     return Promise.reject(new Error("athena.storage.file.upload direct mode requires XMLHttpRequest in this runtime"));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const xhr = new Xhr();
     const abort = () => xhr.abort();
     xhr.open("PUT", url);
@@ -5241,7 +5241,7 @@ async function putWithXhr(url, signed, body, signal, onProgress) {
         return;
       }
       onProgress({ loaded: bodySize(body) });
-      resolve3(new Response(xhr.response, {
+      resolve4(new Response(xhr.response, {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: parseXhrHeaders(xhr.getAllResponseHeaders())
@@ -5694,7 +5694,7 @@ function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
   if (Xhr === void 0) {
     return Promise.reject(new Error("athena.storage.file.upload requires XMLHttpRequest in this runtime"));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const xhr = new Xhr();
     const abort = () => xhr.abort();
     xhr.open("PUT", url);
@@ -5711,7 +5711,7 @@ function putUploadBodyWithXhr(url, source, headers, options, onProgress) {
         return;
       }
       onProgress({ loaded: source.sizeBytes });
-      resolve3(new Response(xhr.response, {
+      resolve4(new Response(xhr.response, {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: parseXhrHeaders2(xhr.getAllResponseHeaders())
@@ -10770,6 +10770,305 @@ var Backend = {
   ScyllaDB: { type: "scylladb" }
 };
 
+// src/query/read-query.ts
+function normalizeAthenaReadQueryOrderBy(orderBy) {
+  if (!orderBy) {
+    return [];
+  }
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return list.filter(
+    (entry) => entry && typeof entry.column === "string" && entry.column.trim().length > 0
+  );
+}
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function flattenAthenaRowValue(row, column) {
+  if (!column.relation) {
+    return row[column.column];
+  }
+  const relationValue = row[column.relation.name];
+  if (Array.isArray(relationValue)) {
+    return relationValue.map((entry) => isRecord12(entry) ? entry[column.column] : void 0).filter((entry) => entry !== void 0);
+  }
+  if (isRecord12(relationValue)) {
+    return relationValue[column.column];
+  }
+  return void 0;
+}
+function resolveFlatRowKey(row, index, preferredKey) {
+  const preferredValue = preferredKey && preferredKey in row ? row[preferredKey] : void 0;
+  if (preferredValue !== void 0 && preferredValue !== null && `${preferredValue}`.trim().length > 0) {
+    return String(preferredValue);
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "__rowKey") {
+      continue;
+    }
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        return `${key}-${value.join("-")}`;
+      }
+      continue;
+    }
+    const nextValue = String(value).trim();
+    if (nextValue.length > 0) {
+      return nextValue;
+    }
+  }
+  return `row-${index + 1}`;
+}
+function flattenAthenaReadQueryRows(rows, columns, preferredKey) {
+  return rows.map((entry, index) => {
+    const sourceRow = isRecord12(entry) ? entry : {};
+    const flatRow = columns.reduce(
+      (currentRow, column) => {
+        currentRow[column.key] = flattenAthenaRowValue(sourceRow, column);
+        return currentRow;
+      },
+      { __rowKey: "" }
+    );
+    flatRow.__rowKey = resolveFlatRowKey(flatRow, index, preferredKey);
+    return flatRow;
+  });
+}
+var flattenAthenaRows = flattenAthenaReadQueryRows;
+function buildAthenaReadQuerySelectString(columns) {
+  const baseColumns = columns.filter((column) => !column.relation).map((column) => column.column);
+  const relationGroups = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!column.relation) {
+      continue;
+    }
+    const groupKey = [
+      column.relation.name,
+      column.relation.schema ?? "",
+      column.relation.table
+    ].join(":");
+    const existingGroup = relationGroups.get(groupKey);
+    if (existingGroup) {
+      if (!existingGroup.columns.includes(column.column)) {
+        existingGroup.columns.push(column.column);
+      }
+      continue;
+    }
+    relationGroups.set(groupKey, {
+      columns: [column.column],
+      relation: column.relation
+    });
+  }
+  const relationColumns = [...relationGroups.values()].map(
+    ({ columns: relationColumns2, relation }) => {
+      const relationTarget = relation.schema ? `${relation.schema}.${relation.table}` : relation.table;
+      return `${relation.name}:${relationTarget}(${relationColumns2.join(",")})`;
+    }
+  );
+  return [...baseColumns, ...relationColumns].join(",");
+}
+var buildAthenaTableSelectString = buildAthenaReadQuerySelectString;
+function buildAthenaReadQueryFindManySelect(columns) {
+  const select = {};
+  for (const column of columns) {
+    if (!column.relation) {
+      select[column.column] = true;
+      continue;
+    }
+    const existingRelation = select[column.relation.name];
+    if (existingRelation && existingRelation !== true && isRecord12(existingRelation.select)) {
+      existingRelation.select[column.column] = true;
+      continue;
+    }
+    select[column.relation.name] = {
+      ...column.relation.schema ? { schema: column.relation.schema } : {},
+      select: {
+        [column.column]: true
+      }
+    };
+  }
+  return select;
+}
+var buildAthenaTableFindManySelect = buildAthenaReadQueryFindManySelect;
+function buildAthenaReadQueryFindManyWhere(filters) {
+  if (!filters?.length) {
+    return;
+  }
+  return filters.reduce(
+    (where, filter) => {
+      const operator = filter.operator ?? "eq";
+      where[filter.column] = operator === "eq" ? filter.value : { [operator]: filter.value };
+      return where;
+    },
+    {}
+  );
+}
+var buildAthenaTableFindManyWhere = buildAthenaReadQueryFindManyWhere;
+function buildAthenaReadQueryFindManyOrderBy(orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return;
+  }
+  if (normalized.length === 1) {
+    const primary = normalized[0];
+    if (!primary) {
+      return;
+    }
+    return {
+      ascending: primary.direction !== "desc",
+      column: primary.column
+    };
+  }
+  return Object.fromEntries(
+    normalized.map((entry) => [
+      entry.column,
+      entry.direction === "desc" ? "desc" : "asc"
+    ])
+  );
+}
+var buildAthenaTableFindManyOrderBy = buildAthenaReadQueryFindManyOrderBy;
+var normalizeAthenaTableOrderBy = normalizeAthenaReadQueryOrderBy;
+function applyAthenaReadQueryFilters(queryBuilder, filters) {
+  if (!filters?.length) {
+    return queryBuilder;
+  }
+  return filters.reduce((currentBuilder, filter) => {
+    const operator = filter.operator ?? "eq";
+    const builderMethod = currentBuilder[operator];
+    if (typeof builderMethod !== "function") {
+      return currentBuilder;
+    }
+    return builderMethod.call(currentBuilder, filter.column, filter.value);
+  }, queryBuilder);
+}
+var applyAthenaTableFilters = applyAthenaReadQueryFilters;
+function applyAthenaReadQuerySelectOrder(queryBuilder, orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return queryBuilder;
+  }
+  return normalized.reduce(
+    (builder, entry) => builder.order(entry.column, {
+      ascending: entry.direction !== "desc"
+    }),
+    queryBuilder
+  );
+}
+var applyAthenaTableSelectOrder = applyAthenaReadQuerySelectOrder;
+function applyAthenaReadQuerySelectLimit(queryBuilder, limit) {
+  if (!limit || limit < 1) {
+    return queryBuilder;
+  }
+  return queryBuilder.limit(limit);
+}
+var applyAthenaTableSelectLimit = applyAthenaReadQuerySelectLimit;
+function clampAthenaReadQueryTotalItems(totalItems, limit) {
+  if (!limit || limit < 1) {
+    return totalItems;
+  }
+  return Math.min(totalItems, limit);
+}
+var clampAthenaTableTotalItems = clampAthenaReadQueryTotalItems;
+function resolveCountValue(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return Math.max(0, Math.trunc(candidate));
+    }
+  }
+  return 0;
+}
+function resolveTotalItemsFromPage({
+  countCandidates,
+  limit,
+  page,
+  pageSize,
+  rowCount
+}) {
+  const exactCount = resolveCountValue(...countCandidates);
+  if (exactCount > 0) {
+    return clampAthenaReadQueryTotalItems(exactCount, limit);
+  }
+  if (rowCount > 0) {
+    const base = (page - 1) * pageSize + rowCount;
+    const synthetic = rowCount >= pageSize ? base + 1 : base;
+    return clampAthenaReadQueryTotalItems(synthetic, limit);
+  }
+  return clampAthenaReadQueryTotalItems(exactCount, limit);
+}
+async function executeAthenaReadQuery({
+  client,
+  page,
+  pageSize,
+  query
+}) {
+  const db = client.db;
+  const baseBuilder = db.from(query.table, {
+    schema: query.schema
+  });
+  const countBuilder = applyAthenaReadQueryFilters(
+    db.from(query.table, { schema: query.schema }),
+    query.filters
+  );
+  const countResult = await countBuilder.select(query.countColumn, {
+    count: "exact",
+    head: true
+  });
+  if ((query.mode ?? "findMany") === "select") {
+    const selectBuilder = applyAthenaReadQuerySelectLimit(
+      applyAthenaReadQuerySelectOrder(
+        applyAthenaReadQueryFilters(baseBuilder, query.filters),
+        query.orderBy
+      ),
+      query.limit
+    );
+    const result2 = await selectBuilder.currentPage(page).pageSize(pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
+      count: "exact"
+    });
+    const rows2 = flattenAthenaReadQueryRows(
+      Array.isArray(result2.data) ? result2.data : [],
+      query.columns,
+      query.rowKey
+    );
+    return {
+      debugAst: getAthenaDebugAst(result2) ?? void 0,
+      rows: rows2,
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count, result2.count],
+        limit: query.limit,
+        page,
+        pageSize,
+        rowCount: rows2.length
+      })
+    };
+  }
+  const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
+  const findManyOptions = {
+    ...query.limit ? { limit: query.limit } : {},
+    ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
+    select: buildAthenaReadQueryFindManySelect(query.columns),
+    ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
+  };
+  const result = await baseBuilder.currentPage(page).pageSize(pageSize).findMany(findManyOptions);
+  const rows = flattenAthenaReadQueryRows(
+    Array.isArray(result.data) ? result.data : [],
+    query.columns,
+    query.rowKey
+  );
+  return {
+    debugAst: getAthenaDebugAst(result) ?? void 0,
+    rows,
+    totalItems: resolveTotalItemsFromPage({
+      countCandidates: [countResult.count, result.count],
+      limit: query.limit,
+      page,
+      pageSize,
+      rowCount: rows.length
+    })
+  };
+}
+var executeAthenaTableQuery = executeAthenaReadQuery;
+
 // src/schema/definitions.ts
 function defineModel(input) {
   return input;
@@ -10790,7 +11089,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -10799,7 +11098,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord12(source)) {
+  if (!isRecord13(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -11719,6 +12018,12 @@ var ATHENA_DIRECT_TARGETS = {
 };
 var DEFAULT_OUTPUT_FORMAT = "table-builder";
 var DEFAULT_OUTPUT_PRESET = "athena-direct";
+var DEFAULT_ARTIFACT_WRITE_POLICY = "merge";
+var ARTIFACT_WRITE_POLICIES = /* @__PURE__ */ new Set([
+  "merge",
+  "skip",
+  "overwrite"
+]);
 var DEFAULT_NAMING = {
   modelType: "pascal",
   modelConst: "camel",
@@ -11998,6 +12303,23 @@ function normalizeFilterConfig(input) {
     excludeTables: normalizeTableSelection(input?.excludeTables)
   };
 }
+function normalizeArtifactWritePolicy(value, fieldName) {
+  if (value === void 0 || value === null || value === "") {
+    return DEFAULT_ARTIFACT_WRITE_POLICY;
+  }
+  if (typeof value === "string" && ARTIFACT_WRITE_POLICIES.has(value)) {
+    return value;
+  }
+  throw new Error(
+    `Invalid output.artifactWrite.${fieldName}: expected one of merge | skip | overwrite, received ${JSON.stringify(value)}.`
+  );
+}
+function normalizeArtifactWriteConfig(input) {
+  return {
+    database: normalizeArtifactWritePolicy(input?.database, "database"),
+    registry: normalizeArtifactWritePolicy(input?.registry, "registry")
+  };
+}
 function normalizeOutputConfig(output) {
   const preset = output?.preset ?? DEFAULT_OUTPUT_PRESET;
   return {
@@ -12009,7 +12331,8 @@ function normalizeOutputConfig(output) {
     },
     placeholderMap: {
       ...output?.placeholderMap ?? {}
-    }
+    },
+    artifactWrite: normalizeArtifactWriteConfig(output?.artifactWrite)
   };
 }
 function normalizeProviderConfig(provider) {
@@ -12292,6 +12615,486 @@ async function loadGeneratorConfig(options = {}) {
   }
 }
 
+// src/generator/schema-discovery.ts
+var DISCOVER_POSTGRES_SCHEMAS_SQL = `
+  SELECT DISTINCT n.nspname AS schema_name
+  FROM pg_namespace n
+  JOIN pg_class c ON c.relnamespace = n.oid
+  WHERE c.relkind IN ('r', 'p')
+    AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+    AND n.nspname NOT LIKE 'pg_toast%'
+    AND n.nspname NOT LIKE 'pg_temp_%'
+    AND n.nspname NOT LIKE 'pg_toast_temp_%'
+  ORDER BY n.nspname;
+`.trim();
+var SYSTEM_SCHEMA_PREFIXES = ["pg_"];
+var SYSTEM_SCHEMAS = /* @__PURE__ */ new Set(["pg_catalog", "information_schema"]);
+function normalizeDiscoveredSchemas(input) {
+  const schemas = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of input) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    if (SYSTEM_SCHEMAS.has(schema)) {
+      continue;
+    }
+    if (SYSTEM_SCHEMA_PREFIXES.some((prefix) => schema.startsWith(prefix))) {
+      continue;
+    }
+    seen.add(schema);
+    schemas.push(schema);
+  }
+  return schemas;
+}
+function mergeSchemaSelections(configured, discovered) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of configured ?? []) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    result.push(schema);
+  }
+  for (const value of discovered) {
+    const schema = value.trim();
+    if (!schema || seen.has(schema)) {
+      continue;
+    }
+    seen.add(schema);
+    result.push(schema);
+  }
+  return result.length > 0 ? result : ["public"];
+}
+function schemasEqual(left, right) {
+  const a = normalizeDiscoveredSchemas(left ?? []);
+  const b = normalizeDiscoveredSchemas(right ?? []);
+  if (a.length !== b.length) {
+    return false;
+  }
+  const set = new Set(a);
+  return b.every((schema) => set.has(schema));
+}
+function coerceSchemaName(row) {
+  const raw = row.schema_name ?? row.schemaName ?? row.nspname;
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+async function loadPgPoolConstructor2() {
+  const module = await import('pg');
+  const poolConstructor = module.Pool ?? module.default?.Pool;
+  if (!poolConstructor) {
+    throw new Error(
+      '@xylex-group/athena: Unable to load the PostgreSQL driver for schema discovery. Ensure "pg" is installed and this API runs in a Node.js server runtime.'
+    );
+  }
+  return poolConstructor;
+}
+async function discoverDirectSchemas(config) {
+  const PoolConstructor = await loadPgPoolConstructor2();
+  const pool = new PoolConstructor({ connectionString: config.connectionString });
+  try {
+    const result = await pool.query(DISCOVER_POSTGRES_SCHEMAS_SQL);
+    const names = result.rows.map(coerceSchemaName).filter((value) => Boolean(value));
+    return normalizeDiscoveredSchemas(names);
+  } finally {
+    await pool.end();
+  }
+}
+async function discoverGatewaySchemas(config) {
+  const client = createClient({
+    db: { url: config.gatewayUrl },
+    key: config.apiKey,
+    backend: {
+      type: config.backend ?? "postgresql"
+    }
+  });
+  const result = await client.query(DISCOVER_POSTGRES_SCHEMAS_SQL);
+  if (result.error || result.status < 200 || result.status >= 300) {
+    throw new Error(
+      result.error?.message ?? `Gateway schema discovery failed with status ${result.status}`
+    );
+  }
+  const names = (result.data ?? []).map(coerceSchemaName).filter((value) => Boolean(value));
+  return normalizeDiscoveredSchemas(names);
+}
+async function discoverPostgresSchemas(provider) {
+  if (provider.kind === "postgres" && provider.mode === "direct") {
+    return discoverDirectSchemas(provider);
+  }
+  if (provider.kind === "postgres" && provider.mode === "gateway") {
+    return discoverGatewaySchemas(provider);
+  }
+  throw new Error(
+    `Schema discovery is only implemented for postgres direct/gateway providers (received ${provider.kind}/${"mode" in provider ? provider.mode : "unknown"}).`
+  );
+}
+
+// src/generator/config-file.ts
+function hasEnv(keys) {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+var DIRECT_CONNECTION_KEYS = [
+  "ATHENA_GENERATOR_PG_URL",
+  "DATABASE_URL",
+  "PG_URL",
+  "POSTGRES_URL",
+  "POSTGRESQL_URL"
+];
+var GATEWAY_URL_KEYS = ["ATHENA_URL", "ATHENA_GATEWAY_URL", "ATHENA_GENERATOR_URL"];
+var GATEWAY_KEY_KEYS = [
+  "ATHENA_API_KEY",
+  "ATHENA_GATEWAY_API_KEY",
+  "ATHENA_GENERATOR_API_KEY"
+];
+function detectGeneratorProviderMode(preferred = "auto") {
+  if (preferred === "direct" || preferred === "gateway") {
+    return preferred;
+  }
+  const hasDirect = hasEnv(DIRECT_CONNECTION_KEYS);
+  const hasGateway = hasEnv(GATEWAY_URL_KEYS) && hasEnv(GATEWAY_KEY_KEYS);
+  if (hasDirect) {
+    return "direct";
+  }
+  if (hasGateway) {
+    return "gateway";
+  }
+  return "direct";
+}
+function formatStringArray(values, indent) {
+  if (values.length === 0) {
+    return "[]";
+  }
+  const inner = values.map((value) => `${indent}  ${JSON.stringify(value)}`).join(",\n");
+  return `[
+${inner},
+${indent}]`;
+}
+function buildDirectProviderBlock(schemas) {
+  return `  provider: {
+    kind: "postgres",
+    mode: "direct",
+    connectionString: generatorEnv("DATABASE_URL"),
+    database: generatorEnv("ATHENA_GENERATOR_DB", { optional: true }),
+    schemas: ${formatStringArray(schemas, "    ")},
+  }`;
+}
+function buildGatewayProviderBlock(schemas) {
+  return `  provider: {
+    kind: "postgres",
+    mode: "gateway",
+    gatewayUrl: generatorEnv("ATHENA_URL"),
+    apiKey: generatorEnv("ATHENA_API_KEY"),
+    database: generatorEnv("ATHENA_GENERATOR_DB", { default: "postgres" }),
+    schemas: ${formatStringArray(schemas, "    ")},
+  }`;
+}
+function renderGeneratorConfigFile(options) {
+  const schemas = options.schemas && options.schemas.length > 0 ? [...options.schemas] : [...DEFAULT_POSTGRES_SCHEMAS];
+  const providerBlock = options.mode === "gateway" ? buildGatewayProviderBlock(schemas) : buildDirectProviderBlock(schemas);
+  return `import { defineGeneratorConfig, generatorEnv } from "@xylex-group/athena";
+
+export default defineGeneratorConfig({
+${providerBlock},
+  output: {
+    format: "table-builder",
+    preset: "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",
+    },
+    placeholderMap: {
+      namespace: "athena",
+    },
+  },
+  naming: {
+    modelType: "pascal",
+    modelConst: "camel",
+    schemaConst: "camel",
+    databaseConst: "camel",
+    registryConst: "camel",
+  },
+  features: {
+    emitRelations: true,
+    emitRegistry: true,
+  },
+  experimental: {
+    postgresGatewayIntrospection: false,
+    scyllaProviderContracts: true,
+  },
+});
+`;
+}
+function resolveConfigPath(cwd, configPath) {
+  if (configPath) {
+    const absolutePath2 = path.resolve(cwd, configPath);
+    return {
+      absolutePath: absolutePath2,
+      relativePath: configPath.replace(/\\/g, "/"),
+      exists: fs.existsSync(absolutePath2)
+    };
+  }
+  const discovered = findGeneratorConfigPath(cwd);
+  if (discovered) {
+    const relativePath = discovered.startsWith(cwd) ? discovered.slice(cwd.length).replace(/^[/\\]/, "").replace(/\\/g, "/") : "athena.config.ts";
+    return {
+      absolutePath: discovered,
+      relativePath,
+      exists: true
+    };
+  }
+  const absolutePath = path.resolve(cwd, "athena.config.ts");
+  return {
+    absolutePath,
+    relativePath: "athena.config.ts",
+    exists: false
+  };
+}
+function providerModeFromConfig(provider, preferred) {
+  if (provider && provider.kind === "postgres") {
+    if (provider.mode === "gateway") {
+      return "gateway";
+    }
+    if (provider.mode === "direct") {
+      return "direct";
+    }
+  }
+  return detectGeneratorProviderMode(preferred);
+}
+function schemasFromNormalized(config) {
+  if (config.provider.kind !== "postgres") {
+    return [...DEFAULT_POSTGRES_SCHEMAS];
+  }
+  return normalizeSchemaSelection(config.provider.schemas);
+}
+function patchSchemasInConfigSource(source, schemas) {
+  const formattedInline = `[${schemas.map((value) => JSON.stringify(value)).join(", ")}]`;
+  const formattedMultiline = formatStringArray(schemas, "    ");
+  const listDefaultPattern = /(schemas\s*:\s*generatorEnv\.list\s*\(\s*['"][^'"]+['"]\s*,\s*\{[\s\S]*?default\s*:\s*)(\[[^\]]*\])/m;
+  if (listDefaultPattern.test(source)) {
+    return source.replace(listDefaultPattern, `$1${formattedInline}`);
+  }
+  const literalPattern = /(schemas\s*:\s*)(\[[^\]]*\])/m;
+  if (literalPattern.test(source)) {
+    const usesMultiline = /schemas\s*:\s*\[\s*\n/.test(source);
+    return source.replace(
+      literalPattern,
+      `$1${usesMultiline ? formattedMultiline : formattedInline}`
+    );
+  }
+  const modeLine = /(mode\s*:\s*["'](?:direct|gateway)["']\s*,)/m;
+  if (modeLine.test(source)) {
+    return source.replace(
+      modeLine,
+      `$1
+    schemas: ${formattedInline},`
+    );
+  }
+  return void 0;
+}
+function extractLiteralSchemas(source) {
+  const listDefaultMatch = source.match(
+    /schemas\s*:\s*generatorEnv\.list\s*\(\s*['"][^'"]+['"]\s*,\s*\{[\s\S]*?default\s*:\s*(\[[^\]]*\])/m
+  );
+  const literalMatch = listDefaultMatch ?? source.match(/schemas\s*:\s*(\[[^\]]*\])/m);
+  if (!literalMatch) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(literalMatch[1].replace(/'/g, '"'));
+    if (!Array.isArray(parsed)) {
+      return void 0;
+    }
+    return parsed.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
+  } catch {
+    return void 0;
+  }
+}
+async function resolveDiscoveredSchemas(options) {
+  if (options.explicit && options.explicit.length > 0) {
+    return {
+      schemas: normalizeSchemaSelection(options.explicit),
+      discovered: false
+    };
+  }
+  if (!options.discoverSchemas) {
+    if (options.loaded) {
+      return {
+        schemas: schemasFromNormalized(options.loaded.config),
+        discovered: false
+      };
+    }
+    return {
+      schemas: [...DEFAULT_POSTGRES_SCHEMAS],
+      discovered: false
+    };
+  }
+  try {
+    let provider = options.provider;
+    if (!provider && options.loaded) {
+      provider = options.loaded.config.provider;
+    }
+    if (!provider) {
+      const probeConfig = {
+        provider: options.mode === "gateway" ? { kind: "postgres", mode: "gateway" } : { kind: "postgres", mode: "direct" }
+      };
+      const normalized = normalizeGeneratorConfig(probeConfig);
+      provider = normalized.provider;
+    }
+    const discovered = await discoverPostgresSchemas(provider);
+    if (discovered.length === 0) {
+      const fallback = options.loaded ? schemasFromNormalized(options.loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS];
+      return { schemas: fallback, discovered: true };
+    }
+    if (options.loaded) {
+      return {
+        schemas: mergeSchemaSelections(schemasFromNormalized(options.loaded.config), discovered),
+        discovered: true
+      };
+    }
+    return { schemas: discovered, discovered: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const fallback = options.loaded ? schemasFromNormalized(options.loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS];
+    return {
+      schemas: fallback,
+      discovered: false,
+      discoveryError: message
+    };
+  }
+}
+async function ensureGeneratorConfigFile(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun === true;
+  const discoverSchemas = options.discoverSchemas !== false;
+  const force = options.force === true;
+  const preferredMode = options.mode ?? "auto";
+  const pathInfo = resolveConfigPath(cwd, options.configPath);
+  const changes = [];
+  let loaded = options.loaded;
+  if (!loaded && pathInfo.exists && !force) {
+    try {
+      loaded = await loadGeneratorConfig({
+        cwd,
+        configPath: pathInfo.absolutePath
+      });
+    } catch {
+    }
+  }
+  const mode = providerModeFromConfig(loaded?.config.provider ?? options.provider, preferredMode);
+  const schemaResolution = await resolveDiscoveredSchemas({
+    discoverSchemas,
+    provider: options.provider ?? loaded?.config.provider,
+    loaded,
+    explicit: options.schemas,
+    mode
+  });
+  if (schemaResolution.discoveryError) {
+    changes.push(`schema-discovery-failed: ${schemaResolution.discoveryError}`);
+  } else if (schemaResolution.discovered) {
+    changes.push(`schemas-discovered: ${schemaResolution.schemas.join(",")}`);
+  }
+  if (!pathInfo.exists || force) {
+    const content = renderGeneratorConfigFile({
+      mode,
+      schemas: schemaResolution.schemas
+    });
+    if (!pathInfo.exists) {
+      changes.push("created-modern-config");
+    } else {
+      changes.push("force-rewrote-config");
+    }
+    if (!dryRun) {
+      await promises.mkdir(path.dirname(pathInfo.absolutePath), { recursive: true });
+      await promises.writeFile(pathInfo.absolutePath, content, "utf8");
+    }
+    return {
+      action: pathInfo.exists ? "updated" : "created",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content,
+      schemas: schemaResolution.schemas,
+      changes,
+      mode,
+      reason: pathInfo.exists ? "force rewrite" : "config file missing"
+    };
+  }
+  const existingSource = await promises.readFile(pathInfo.absolutePath, "utf8");
+  const existingLiteralSchemas = extractLiteralSchemas(existingSource);
+  const existingSchemas = existingLiteralSchemas ?? (loaded ? schemasFromNormalized(loaded.config) : [...DEFAULT_POSTGRES_SCHEMAS]);
+  if (schemasEqual(existingSchemas, schemaResolution.schemas)) {
+    return {
+      action: "unchanged",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: changes.length > 0 ? changes : ["schemas-already-current"],
+      mode,
+      reason: "schemas already match discovered/configured set"
+    };
+  }
+  const patched = patchSchemasInConfigSource(existingSource, schemaResolution.schemas);
+  if (!patched) {
+    return {
+      action: "skipped",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: [
+        ...changes,
+        "could-not-patch-schemas-surgically",
+        "re-run with force=true to rewrite full template"
+      ],
+      mode,
+      reason: "existing config schemas could not be updated surgically without risking a destructive rewrite"
+    };
+  }
+  if (patched === existingSource) {
+    return {
+      action: "unchanged",
+      path: pathInfo.relativePath,
+      absolutePath: pathInfo.absolutePath,
+      content: existingSource,
+      schemas: existingSchemas,
+      changes: [...changes, "patch-noop"],
+      mode,
+      reason: "patch produced identical content"
+    };
+  }
+  changes.push(
+    `schemas-updated: ${existingSchemas.join(",")} -> ${schemaResolution.schemas.join(",")}`
+  );
+  if (!dryRun) {
+    await promises.writeFile(pathInfo.absolutePath, patched, "utf8");
+  }
+  return {
+    action: "updated",
+    path: pathInfo.relativePath,
+    absolutePath: pathInfo.absolutePath,
+    content: patched,
+    schemas: schemaResolution.schemas,
+    changes,
+    mode,
+    reason: "auto-filled provider.schemas"
+  };
+}
+
 // src/generator/env.ts
 function readEnvStringValue2(key) {
   if (typeof process === "undefined" || !process.env) {
@@ -13270,9 +14073,764 @@ function resolveGeneratorProvider(providerConfig, experimentalFlags) {
   }
   throw new Error(`Unsupported generator provider kind: ${providerConfig.kind ?? "unknown"}`);
 }
-function canOverwriteArtifact(file) {
-  return file.kind === "model" || file.kind === "schema";
+
+// src/generator/artifact-merge.ts
+var IMPORT_RE = /^import\s+(?:type\s+)?(?:\{([^}]*)\}|([A-Za-z_$][\w$]*))\s+from\s+(['"])([^'"]+)\3\s*;?\s*$/gm;
+var DEFINE_EXPORT_RE = /export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(define(?:Database|Registry))\s*\(\s*\{/g;
+var META_EXPORT_RE = /export\s+const\s+__athena_schema_meta\s*=\s*\{/g;
+var KNOWN_META_KEYS = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "generatedAt",
+  "database",
+  "outputPreset",
+  "outputFormat"
+]);
+function detectNewline(source) {
+  return source.includes("\r\n") ? "\r\n" : "\n";
+}
+function detectStyle(source) {
+  const newline = detectNewline(source);
+  const single = (source.match(/'/g) ?? []).length;
+  const double = (source.match(/"/g) ?? []).length;
+  const quote = double > single ? '"' : "'";
+  const importLines = source.split(/\r?\n/).filter((line) => line.trimStart().startsWith("import "));
+  const semicolons = importLines.length > 0 ? importLines.filter((line) => line.trimEnd().endsWith(";")).length >= importLines.length / 2 : false;
+  const objectLines = source.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[A-Za-z0-9_'"]+\s*:\s*.+/.test(line));
+  const trailingComma = objectLines.length > 0 ? objectLines.filter((line) => line.endsWith(",")).length >= Math.ceil(objectLines.length / 2) : true;
+  const indentMatch = source.match(/\n([ \t]+)\S/);
+  const indent = indentMatch?.[1] ?? "  ";
+  return { quote, semicolons, trailingComma, indent, newline };
+}
+function quoteString(value, quote) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(new RegExp(quote, "g"), `\\${quote}`);
+  return `${quote}${escaped}${quote}`;
+}
+function parseNamedImports(source) {
+  const imports = [];
+  IMPORT_RE.lastIndex = 0;
+  let match;
+  while ((match = IMPORT_RE.exec(source)) !== null) {
+    const named = match[1];
+    const defaultName = match[2];
+    const module = match[4];
+    const names = named ? named.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
+      const alias = part.split(/\s+as\s+/);
+      return (alias[1] ?? alias[0]).trim();
+    }) : defaultName ? [defaultName] : [];
+    imports.push({
+      names,
+      module,
+      raw: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return imports;
+}
+function findMatchingBrace(source, openIndex) {
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplate = false;
+  let escaped = false;
+  for (let i = openIndex; i < source.length; i += 1) {
+    const ch = source[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && (inSingle || inDouble || inTemplate)) {
+      escaped = true;
+      continue;
+    }
+    if (!inDouble && !inTemplate && ch === "'") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && !inTemplate && ch === '"') {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "`") {
+      inTemplate = !inTemplate;
+      continue;
+    }
+    if (inSingle || inDouble || inTemplate) {
+      continue;
+    }
+    if (ch === "{") {
+      depth += 1;
+    } else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function parseObjectEntries(body) {
+  const entries = [];
+  const lines = body.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*")) {
+      continue;
+    }
+    const withoutComma = trimmed.endsWith(",") ? trimmed.slice(0, -1).trimEnd() : trimmed;
+    const match = withoutComma.match(/^([A-Za-z_$][\w$]*|['"][^'"]+['"])\s*:\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const keyRaw = match[1];
+    const key = keyRaw.startsWith("'") || keyRaw.startsWith('"') ? keyRaw.slice(1, -1) : keyRaw;
+    entries.push({
+      key,
+      value: match[2].trim(),
+      raw: trimmed
+    });
+  }
+  return entries;
 }
+function parseDefineBlocks(source) {
+  const blocks = [];
+  DEFINE_EXPORT_RE.lastIndex = 0;
+  let match;
+  while ((match = DEFINE_EXPORT_RE.exec(source)) !== null) {
+    const exportName = match[1];
+    const callName = match[2];
+    const openBrace = match.index + match[0].lastIndexOf("{");
+    const closeBrace = findMatchingBrace(source, openBrace);
+    if (closeBrace < 0) {
+      continue;
+    }
+    const body = source.slice(openBrace + 1, closeBrace);
+    const fullEnd = (() => {
+      let i = closeBrace + 1;
+      while (i < source.length && /\s/.test(source[i])) i += 1;
+      if (source[i] === ")") i += 1;
+      while (i < source.length && /\s/.test(source[i])) i += 1;
+      if (source[i] === ";") i += 1;
+      return i;
+    })();
+    blocks.push({
+      kind: callName === "defineDatabase" ? "database" : "registry",
+      exportName,
+      callName,
+      entries: parseObjectEntries(body),
+      bodyStart: openBrace + 1,
+      bodyEnd: closeBrace,
+      fullStart: match.index,
+      fullEnd,
+      raw: source.slice(match.index, fullEnd)
+    });
+  }
+  return blocks;
+}
+function parseMetaBlock(source) {
+  META_EXPORT_RE.lastIndex = 0;
+  const match = META_EXPORT_RE.exec(source);
+  if (!match) {
+    return void 0;
+  }
+  const openBrace = match.index + match[0].lastIndexOf("{");
+  const closeBrace = findMatchingBrace(source, openBrace);
+  if (closeBrace < 0) {
+    return void 0;
+  }
+  let fullEnd = closeBrace + 1;
+  const after = source.slice(fullEnd);
+  const asConst = after.match(/^\s*as\s+const\s*;?/);
+  if (asConst) {
+    fullEnd += asConst[0].length;
+  } else if (source[fullEnd] === ";") {
+    fullEnd += 1;
+  }
+  return {
+    entries: parseObjectEntries(source.slice(openBrace + 1, closeBrace)),
+    bodyStart: openBrace + 1,
+    bodyEnd: closeBrace,
+    fullStart: match.index,
+    fullEnd,
+    raw: source.slice(match.index, fullEnd)
+  };
+}
+function hasImportBinding(imports, name, module) {
+  return imports.some(
+    (item) => item.names.includes(name) && (module === void 0)
+  );
+}
+function findImportForName(imports, name) {
+  return imports.find((item) => item.names.includes(name));
+}
+function normalizeModulePath(modulePath) {
+  return modulePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\.ts$/, "");
+}
+function formatImport(names, modulePath, style) {
+  const body = `import { ${names.join(", ")} } from ${quoteString(modulePath, style.quote)}`;
+  return style.semicolons ? `${body};` : body;
+}
+function formatObjectEntry(key, value, style, isLast) {
+  const needsQuote = !/^[A-Za-z_$][\w$]*$/.test(key);
+  const renderedKey = needsQuote ? quoteString(key, style.quote) : key;
+  const comma = !isLast || style.trailingComma ? "," : "";
+  return `${style.indent}${renderedKey}: ${value}${comma}`;
+}
+function replaceRange(source, start, end, insertion) {
+  return source.slice(0, start) + insertion + source.slice(end);
+}
+function collectDuplicateKeys(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const dupes = [];
+  for (const entry of entries) {
+    if (seen.has(entry.key)) {
+      dupes.push(entry.key);
+    }
+    seen.add(entry.key);
+  }
+  return dupes;
+}
+function collectDuplicateImportBindings(imports) {
+  const seen = /* @__PURE__ */ new Set();
+  const dupes = [];
+  for (const item of imports) {
+    for (const name of item.names) {
+      if (seen.has(name)) {
+        dupes.push(name);
+      }
+      seen.add(name);
+    }
+  }
+  return dupes;
+}
+function lintArtifactSource(source, kind) {
+  const errors = [];
+  const imports = parseNamedImports(source);
+  const dupImports = collectDuplicateImportBindings(imports);
+  if (dupImports.length > 0) {
+    errors.push(`duplicate import bindings: ${dupImports.join(", ")}`);
+  }
+  const blocks = parseDefineBlocks(source).filter((block2) => block2.kind === kind);
+  if (blocks.length === 0) {
+    errors.push(`missing export const \u2026 = define${kind === "database" ? "Database" : "Registry"}({\u2026})`);
+    return errors;
+  }
+  if (blocks.length > 1) {
+    errors.push(`multiple define${kind === "database" ? "Database" : "Registry"} exports found`);
+  }
+  const block = blocks[0];
+  const dupKeys = collectDuplicateKeys(block.entries);
+  if (dupKeys.length > 0) {
+    errors.push(`duplicate object keys: ${dupKeys.join(", ")}`);
+  }
+  for (const entry of block.entries) {
+    const valueId = entry.value.match(/^[A-Za-z_$][\w$]*$/)?.[0];
+    if (valueId && !hasImportBinding(imports, valueId) && valueId !== block.exportName) {
+      if (!source.includes(`const ${valueId}`) && !source.includes(`function ${valueId}`)) {
+        errors.push(`value "${valueId}" for key "${entry.key}" is not imported`);
+      }
+    }
+  }
+  if (kind === "database" && !hasImportBinding(imports, "defineDatabase")) {
+    errors.push("missing defineDatabase import");
+  }
+  if (kind === "registry" && !hasImportBinding(imports, "defineRegistry")) {
+    errors.push("missing defineRegistry import");
+  }
+  return errors;
+}
+function preservedCustomUnits(existing, generated, kind) {
+  const custom = [];
+  const existingImports = parseNamedImports(existing);
+  const generatedImports = parseNamedImports(generated);
+  const generatedModules = new Set(generatedImports.map((item) => normalizeModulePath(item.module)));
+  const generatedNames = new Set(generatedImports.flatMap((item) => item.names));
+  for (const item of existingImports) {
+    const moduleNorm = normalizeModulePath(item.module);
+    if (moduleNorm.includes("@xylex-group/athena")) {
+      continue;
+    }
+    const unexpectedNames = item.names.filter((name) => !generatedNames.has(name));
+    if (unexpectedNames.length > 0 && !generatedModules.has(moduleNorm)) {
+      custom.push(`import { ${unexpectedNames.join(", ")} } from '${item.module}'`);
+    } else if (unexpectedNames.length > 0) {
+      custom.push(`import binding(s): ${unexpectedNames.join(", ")}`);
+    }
+  }
+  const existingBlocks = parseDefineBlocks(existing).filter((block) => block.kind === kind);
+  const generatedBlocks = parseDefineBlocks(generated).filter((block) => block.kind === kind);
+  const generatedKeys = new Set(generatedBlocks[0]?.entries.map((entry) => entry.key) ?? []);
+  for (const entry of existingBlocks[0]?.entries ?? []) {
+    if (!generatedKeys.has(entry.key)) {
+      custom.push(`${kind} entry: ${entry.key}: ${entry.value}`);
+    }
+  }
+  if (kind === "registry") {
+    const existingMeta = parseMetaBlock(existing);
+    const generatedMeta = parseMetaBlock(generated);
+    const generatedMetaKeys = new Set(generatedMeta?.entries.map((entry) => entry.key) ?? []);
+    for (const entry of existingMeta?.entries ?? []) {
+      if (!generatedMetaKeys.has(entry.key) && !KNOWN_META_KEYS.has(entry.key)) {
+        custom.push(`meta entry: ${entry.key}: ${entry.value}`);
+      }
+    }
+  }
+  const exportConstRe = /^export\s+const\s+([A-Za-z_$][\w$]*)\b/gm;
+  const generatedExports = /* @__PURE__ */ new Set();
+  let match;
+  exportConstRe.lastIndex = 0;
+  while ((match = exportConstRe.exec(generated)) !== null) {
+    generatedExports.add(match[1]);
+  }
+  exportConstRe.lastIndex = 0;
+  while ((match = exportConstRe.exec(existing)) !== null) {
+    if (!generatedExports.has(match[1]) && match[1] !== "__athena_schema_meta") {
+      custom.push(`export const ${match[1]}`);
+    }
+  }
+  return custom;
+}
+function insertImportAfterPackageImports(source, importLine, style) {
+  const imports = parseNamedImports(source);
+  if (imports.length === 0) {
+    return `${importLine}${style.newline}${source}`;
+  }
+  let anchor = imports[imports.length - 1];
+  for (let i = imports.length - 1; i >= 0; i -= 1) {
+    if (imports[i].module.startsWith(".")) {
+      anchor = imports[i];
+      break;
+    }
+  }
+  const insertAt = anchor.end;
+  const before = source.slice(0, insertAt);
+  const after = source.slice(insertAt);
+  const needsLeadingNl = !before.endsWith("\n");
+  const prefix = needsLeadingNl ? style.newline : "";
+  return `${before}${prefix}${importLine}${after.startsWith("\n") || after.startsWith("\r\n") ? "" : style.newline}${after}`;
+}
+function rewriteObjectBody(entries, style) {
+  if (entries.length === 0) {
+    return style.newline;
+  }
+  const lines = entries.map(
+    (entry, index) => formatObjectEntry(entry.key, entry.value, style, index === entries.length - 1)
+  );
+  return `${style.newline}${lines.join(style.newline)}${style.newline}`;
+}
+function mergeDatabaseArtifact(existing, generated) {
+  const style = detectStyle(existing);
+  const generatedStyle = detectStyle(generated);
+  const effectiveStyle = {
+    ...style,
+    // Prefer existing fingerprint; fall back to generated if existing is empty-ish
+    quote: existing.includes('"') || existing.includes("'") ? style.quote : generatedStyle.quote
+  };
+  const generatedImports = parseNamedImports(generated);
+  const existingBlocks = parseDefineBlocks(existing).filter((block) => block.kind === "database");
+  const generatedBlocks = parseDefineBlocks(generated).filter((block) => block.kind === "database");
+  if (existingBlocks.length === 0 || generatedBlocks.length === 0) {
+    return {
+      action: "skip",
+      skipReason: "merge-unparseable",
+      added: [],
+      preservedCustom: [],
+      conflicts: [],
+      lintErrors: [],
+      detail: "could not locate defineDatabase({\u2026}) export for merge"
+    };
+  }
+  const generatedBlock = generatedBlocks[0];
+  const conflicts = [];
+  const added = [];
+  let next = existing;
+  if (!hasImportBinding(parseNamedImports(next), "defineDatabase")) {
+    const pkgImport = generatedImports.find((item) => item.names.includes("defineDatabase"));
+    if (pkgImport) {
+      const line = formatImport(["defineDatabase"], pkgImport.module, effectiveStyle);
+      next = insertImportAfterPackageImports(next, line, effectiveStyle);
+      added.push("import defineDatabase");
+    }
+  }
+  let workingImports = parseNamedImports(next);
+  let workingBlocks = parseDefineBlocks(next).filter((block) => block.kind === "database");
+  let workingBlock = workingBlocks[0];
+  const entryMap = new Map(workingBlock.entries.map((entry) => [entry.key, entry]));
+  for (const desired of generatedBlock.entries) {
+    const existingEntry = entryMap.get(desired.key);
+    if (existingEntry) {
+      if (existingEntry.value !== desired.value) {
+        conflicts.push(
+          `key "${desired.key}" maps to ${existingEntry.value} (existing) vs ${desired.value} (generated)`
+        );
+      }
+      continue;
+    }
+    const desiredImport = generatedImports.find((item) => item.names.includes(desired.value));
+    if (desiredImport) {
+      const existingForName = findImportForName(workingImports, desired.value);
+      if (existingForName) {
+        if (normalizeModulePath(existingForName.module) !== normalizeModulePath(desiredImport.module)) {
+          conflicts.push(
+            `binding "${desired.value}" imported from '${existingForName.module}' vs '${desiredImport.module}'`
+          );
+          continue;
+        }
+      } else {
+        const line = formatImport([desired.value], desiredImport.module, effectiveStyle);
+        next = insertImportAfterPackageImports(next, line, effectiveStyle);
+        added.push(`import ${desired.value}`);
+        workingImports = parseNamedImports(next);
+      }
+    }
+    workingBlocks = parseDefineBlocks(next).filter((block) => block.kind === "database");
+    workingBlock = workingBlocks[0];
+    const nextEntries = [...workingBlock.entries, { key: desired.key, value: desired.value, raw: "" }];
+    const body = rewriteObjectBody(nextEntries, effectiveStyle);
+    next = replaceRange(next, workingBlock.bodyStart, workingBlock.bodyEnd, body);
+    entryMap.set(desired.key, { key: desired.key, value: desired.value, raw: "" });
+    added.push(`database entry: ${desired.key}`);
+  }
+  if (conflicts.length > 0 && added.length === 0) {
+    return {
+      action: "skip",
+      skipReason: "merge-conflict",
+      added: [],
+      preservedCustom: preservedCustomUnits(existing, generated, "database"),
+      conflicts,
+      lintErrors: [],
+      detail: conflicts.join("; ")
+    };
+  }
+  const lintErrors = lintArtifactSource(next, "database");
+  if (lintErrors.length > 0) {
+    return {
+      action: "skip",
+      skipReason: "merge-lint-failed",
+      added,
+      preservedCustom: preservedCustomUnits(existing, generated, "database"),
+      conflicts,
+      lintErrors,
+      detail: lintErrors.join("; ")
+    };
+  }
+  const preservedCustom = preservedCustomUnits(next, generated, "database");
+  if (next === existing || next.replace(/\r\n/g, "\n") === existing.replace(/\r\n/g, "\n")) {
+    return {
+      action: "unchanged",
+      content: existing,
+      skipReason: "already-current",
+      added: [],
+      preservedCustom,
+      conflicts,
+      lintErrors: [],
+      detail: conflicts.length > 0 ? conflicts.join("; ") : void 0
+    };
+  }
+  return {
+    action: "write",
+    content: next.endsWith("\n") ? next : `${next}${effectiveStyle.newline}`,
+    writeReason: "merged",
+    added,
+    preservedCustom,
+    conflicts,
+    lintErrors: []
+  };
+}
+function mergeMetaFields(existingMeta, generatedMeta) {
+  const added = [];
+  if (!generatedMeta) {
+    return { entries: existingMeta?.entries ?? [], changed: false, added };
+  }
+  if (!existingMeta) {
+    return {
+      entries: generatedMeta.entries,
+      changed: true,
+      added: generatedMeta.entries.map((entry) => `meta entry: ${entry.key}`)
+    };
+  }
+  const map = new Map(existingMeta.entries.map((entry) => [entry.key, entry]));
+  let changed = false;
+  for (const desired of generatedMeta.entries) {
+    const current = map.get(desired.key);
+    if (!current) {
+      map.set(desired.key, desired);
+      added.push(`meta entry: ${desired.key}`);
+      changed = true;
+      continue;
+    }
+    if (KNOWN_META_KEYS.has(desired.key) && current.value !== desired.value) {
+      map.set(desired.key, desired);
+      added.push(`meta refresh: ${desired.key}`);
+      changed = true;
+    }
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of existingMeta.entries) {
+    const next = map.get(entry.key);
+    if (next) {
+      ordered.push(next);
+      seen.add(entry.key);
+    }
+  }
+  for (const entry of generatedMeta.entries) {
+    if (!seen.has(entry.key)) {
+      const next = map.get(entry.key);
+      if (next) {
+        ordered.push(next);
+        seen.add(entry.key);
+      }
+    }
+  }
+  for (const [key, entry] of map) {
+    if (!seen.has(key)) {
+      ordered.push(entry);
+    }
+  }
+  return { entries: ordered, changed, added };
+}
+function mergeRegistryArtifact(existing, generated) {
+  const style = detectStyle(existing);
+  const effectiveStyle = style;
+  const generatedImports = parseNamedImports(generated);
+  const existingBlocks = parseDefineBlocks(existing).filter((block) => block.kind === "registry");
+  const generatedBlocks = parseDefineBlocks(generated).filter((block) => block.kind === "registry");
+  if (existingBlocks.length === 0 || generatedBlocks.length === 0) {
+    return {
+      action: "skip",
+      skipReason: "merge-unparseable",
+      added: [],
+      preservedCustom: [],
+      conflicts: [],
+      lintErrors: [],
+      detail: "could not locate defineRegistry({\u2026}) export for merge"
+    };
+  }
+  const existingBlock = existingBlocks[0];
+  const generatedBlock = generatedBlocks[0];
+  const conflicts = [];
+  const added = [];
+  let next = existing;
+  if (!hasImportBinding(parseNamedImports(next), "defineRegistry")) {
+    const pkgImport = generatedImports.find((item) => item.names.includes("defineRegistry"));
+    if (pkgImport) {
+      next = insertImportAfterPackageImports(
+        next,
+        formatImport(["defineRegistry"], pkgImport.module, effectiveStyle),
+        effectiveStyle
+      );
+      added.push("import defineRegistry");
+    }
+  }
+  const preferredDbValue = existingBlock.entries[0]?.value ?? generatedBlock.entries[0]?.value;
+  const generatedDbImport = generatedImports.find((item) => item.names.includes(generatedBlock.entries[0]?.value ?? "")) ?? generatedImports.find((item) => item.module.startsWith("."));
+  if (preferredDbValue && generatedDbImport) {
+    const existingForName = findImportForName(parseNamedImports(next), preferredDbValue);
+    if (!existingForName) {
+      const modulePath = generatedDbImport.module;
+      const importName = findImportForName(generatedImports, preferredDbValue)?.names[0] ?? generatedBlock.entries[0]?.value ?? preferredDbValue;
+      if (!hasImportBinding(parseNamedImports(next), importName)) {
+        next = insertImportAfterPackageImports(
+          next,
+          formatImport([importName], modulePath, effectiveStyle),
+          effectiveStyle
+        );
+        added.push(`import ${importName}`);
+      }
+    } else if (normalizeModulePath(existingForName.module) !== normalizeModulePath(generatedDbImport.module)) {
+      conflicts.push(
+        `binding "${preferredDbValue}" imported from '${existingForName.module}' vs '${generatedDbImport.module}'`
+      );
+    }
+  }
+  let workingBlocks = parseDefineBlocks(next).filter((block) => block.kind === "registry");
+  let workingBlock = workingBlocks[0];
+  const entryMap = new Map(workingBlock.entries.map((entry) => [entry.key, entry]));
+  for (const desired of generatedBlock.entries) {
+    const existingEntry = entryMap.get(desired.key);
+    if (existingEntry) {
+      continue;
+    }
+    const dbImport = parseNamedImports(next).find(
+      (item) => item.module.startsWith(".") && item.names.some((name) => name !== "defineRegistry")
+    );
+    const value = dbImport?.names[0] ?? desired.value;
+    const nextEntries = [...workingBlock.entries, { key: desired.key, value, raw: "" }];
+    const body = rewriteObjectBody(nextEntries, effectiveStyle);
+    next = replaceRange(next, workingBlock.bodyStart, workingBlock.bodyEnd, body);
+    entryMap.set(desired.key, { key: desired.key, value, raw: "" });
+    added.push(`registry entry: ${desired.key}`);
+    workingBlocks = parseDefineBlocks(next).filter((block) => block.kind === "registry");
+    workingBlock = workingBlocks[0];
+  }
+  const existingMeta = parseMetaBlock(next);
+  const generatedMeta = parseMetaBlock(generated);
+  const structuralAdded = added.length > 0;
+  if (generatedMeta) {
+    if (!existingMeta) {
+      const blocks = parseDefineBlocks(next).filter((block) => block.kind === "registry");
+      const insertAt = blocks[0]?.fullStart ?? next.length;
+      const metaBody = rewriteObjectBody(generatedMeta.entries, effectiveStyle);
+      const metaBlock = `export const __athena_schema_meta = {${metaBody}} as const${effectiveStyle.semicolons ? ";" : ""}${effectiveStyle.newline}${effectiveStyle.newline}`;
+      next = replaceRange(next, insertAt, insertAt, metaBlock);
+      added.push("__athena_schema_meta");
+    } else {
+      const desiredEntries = structuralAdded ? generatedMeta.entries : generatedMeta.entries.filter((entry) => {
+        return !existingMeta.entries.some((current) => current.key === entry.key);
+      });
+      if (structuralAdded) {
+        const merged = mergeMetaFields(existingMeta, generatedMeta);
+        if (merged.changed) {
+          const metaNow = parseMetaBlock(next);
+          if (metaNow) {
+            const body = rewriteObjectBody(merged.entries, effectiveStyle);
+            next = replaceRange(next, metaNow.bodyStart, metaNow.bodyEnd, body);
+            added.push(...merged.added);
+          }
+        }
+      } else if (desiredEntries.length > 0) {
+        const map = new Map(existingMeta.entries.map((entry) => [entry.key, entry]));
+        for (const entry of desiredEntries) {
+          map.set(entry.key, entry);
+          added.push(`meta entry: ${entry.key}`);
+        }
+        const ordered = [
+          ...existingMeta.entries.map((entry) => map.get(entry.key)),
+          ...desiredEntries.filter((entry) => !existingMeta.entries.some((e) => e.key === entry.key))
+        ];
+        const metaNow = parseMetaBlock(next);
+        if (metaNow) {
+          const body = rewriteObjectBody(ordered, effectiveStyle);
+          next = replaceRange(next, metaNow.bodyStart, metaNow.bodyEnd, body);
+        }
+      }
+    }
+  }
+  if (conflicts.length > 0 && added.length === 0) {
+    return {
+      action: "skip",
+      skipReason: "merge-conflict",
+      added: [],
+      preservedCustom: preservedCustomUnits(existing, generated, "registry"),
+      conflicts,
+      lintErrors: [],
+      detail: conflicts.join("; ")
+    };
+  }
+  const lintErrors = lintArtifactSource(next, "registry");
+  if (lintErrors.length > 0) {
+    return {
+      action: "skip",
+      skipReason: "merge-lint-failed",
+      added,
+      preservedCustom: preservedCustomUnits(existing, generated, "registry"),
+      conflicts,
+      lintErrors,
+      detail: lintErrors.join("; ")
+    };
+  }
+  const preservedCustom = preservedCustomUnits(next, generated, "registry");
+  if (next.replace(/\r\n/g, "\n") === existing.replace(/\r\n/g, "\n")) {
+    return {
+      action: "unchanged",
+      content: existing,
+      skipReason: "already-current",
+      added: [],
+      preservedCustom,
+      conflicts,
+      lintErrors: []
+    };
+  }
+  return {
+    action: "write",
+    content: next.endsWith("\n") ? next : `${next}${effectiveStyle.newline}`,
+    writeReason: "merged",
+    added,
+    preservedCustom,
+    conflicts,
+    lintErrors: []
+  };
+}
+function mergeProtectedArtifact(kind, existing, generated, policy) {
+  if (policy === "overwrite") {
+    if (existing.replace(/\r\n/g, "\n") === generated.replace(/\r\n/g, "\n")) {
+      return {
+        action: "unchanged",
+        content: existing,
+        skipReason: "already-current",
+        added: [],
+        preservedCustom: [],
+        conflicts: [],
+        lintErrors: []
+      };
+    }
+    return {
+      action: "write",
+      content: generated,
+      writeReason: "overwritten",
+      added: ["full overwrite"],
+      preservedCustom: [],
+      conflicts: [],
+      lintErrors: []
+    };
+  }
+  if (policy === "skip") {
+    return {
+      action: "skip",
+      skipReason: "protected-existing-file",
+      added: [],
+      preservedCustom: preservedCustomUnits(existing, generated, kind),
+      conflicts: [],
+      lintErrors: [],
+      detail: "artifactWrite policy is skip"
+    };
+  }
+  return kind === "database" ? mergeDatabaseArtifact(existing, generated) : mergeRegistryArtifact(existing, generated);
+}
+function resolveArtifactWritePlan(file, existingContent, policy) {
+  if (existingContent === null) {
+    return {
+      action: "write",
+      content: file.content,
+      writeReason: "created",
+      added: ["created"],
+      preservedCustom: [],
+      conflicts: [],
+      lintErrors: []
+    };
+  }
+  if (file.kind === "model" || file.kind === "schema" || policy === "always") {
+    if (existingContent.replace(/\r\n/g, "\n") === file.content.replace(/\r\n/g, "\n")) {
+      return {
+        action: "unchanged",
+        content: existingContent,
+        skipReason: "already-current",
+        added: [],
+        preservedCustom: [],
+        conflicts: [],
+        lintErrors: []
+      };
+    }
+    return {
+      action: "write",
+      content: file.content,
+      writeReason: existingContent ? "overwritten" : "created",
+      added: ["overwritten"],
+      preservedCustom: [],
+      conflicts: [],
+      lintErrors: []
+    };
+  }
+  return mergeProtectedArtifact(
+    file.kind,
+    existingContent,
+    file.content,
+    policy
+  );
+}
+
+// src/generator/pipeline.ts
 async function fileExists(path) {
   try {
     await promises.stat(path);
@@ -13281,47 +14839,156 @@ async function fileExists(path) {
     return false;
   }
 }
-async function writeArtifacts(files, cwd) {
+async function readExisting(path) {
+  try {
+    return await promises.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function policyForArtifact(file, config) {
+  if (file.kind === "model" || file.kind === "schema") {
+    return "always";
+  }
+  if (file.kind === "database") {
+    return config.output.artifactWrite.database;
+  }
+  return config.output.artifactWrite.registry;
+}
+async function writeArtifacts(files, cwd, config, dryRun) {
   const writtenFiles = [];
+  const writtenDetails = [];
   const skippedFiles = [];
   for (const file of files) {
     const absolutePath = path.resolve(cwd, file.path);
-    if (!canOverwriteArtifact(file) && await fileExists(absolutePath)) {
+    const exists = await fileExists(absolutePath);
+    const existingContent = exists ? await readExisting(absolutePath) : null;
+    const policy = policyForArtifact(file, config);
+    const plan = resolveArtifactWritePlan(file, existingContent, policy);
+    if (plan.action === "skip" || plan.action === "unchanged") {
+      skippedFiles.push({
+        kind: file.kind,
+        path: file.path,
+        reason: plan.skipReason ?? "already-current",
+        detail: plan.detail,
+        preservedCustom: plan.preservedCustom.length > 0 ? plan.preservedCustom : void 0,
+        conflicts: plan.conflicts.length > 0 ? plan.conflicts : void 0,
+        lintErrors: plan.lintErrors.length > 0 ? plan.lintErrors : void 0
+      });
+      continue;
+    }
+    if (!plan.content || !plan.writeReason) {
       skippedFiles.push({
         kind: file.kind,
         path: file.path,
-        reason: "protected-existing-file"
+        reason: "merge-lint-failed",
+        detail: "merge produced no content",
+        lintErrors: plan.lintErrors
       });
       continue;
     }
-    await promises.mkdir(path.dirname(absolutePath), { recursive: true });
-    await promises.writeFile(absolutePath, file.content, "utf8");
+    if (!dryRun) {
+      await promises.mkdir(path.dirname(absolutePath), { recursive: true });
+      await promises.writeFile(absolutePath, plan.content, "utf8");
+    }
     writtenFiles.push(file.path);
+    writtenDetails.push({
+      kind: file.kind,
+      path: file.path,
+      reason: plan.writeReason,
+      added: plan.added.length > 0 ? plan.added : void 0,
+      preservedCustom: plan.preservedCustom.length > 0 ? plan.preservedCustom : void 0
+    });
   }
   return {
     writtenFiles,
+    writtenDetails,
     skippedFiles
   };
 }
+function withPostgresSchemas(config, schemas) {
+  if (config.provider.kind !== "postgres") {
+    return config;
+  }
+  return {
+    ...config,
+    provider: {
+      ...config.provider,
+      schemas
+    }
+  };
+}
 async function runSchemaGenerator(options = {}) {
   const cwd = options.cwd ?? process.cwd();
+  const dryRun = options.dryRun === true;
+  const writeConfig = options.writeConfig !== false;
+  const discoverSchemas = options.discoverSchemas !== false;
   const configOptions = {
     cwd,
     configPath: options.configPath
   };
-  const { configPath, config } = await loadGeneratorConfig(configOptions);
+  const loaded = await loadGeneratorConfig(configOptions);
+  let { configPath, config } = loaded;
+  let configEnsure;
+  let effectiveSchemas = resolveProviderSchemas(config.provider);
+  const canDiscoverLive = discoverSchemas && config.provider.kind === "postgres" && !options.provider;
+  if (canDiscoverLive) {
+    try {
+      const discovered = await discoverPostgresSchemas(config.provider);
+      if (discovered.length > 0) {
+        effectiveSchemas = mergeSchemaSelections(effectiveSchemas, discovered);
+      }
+    } catch {
+    }
+  }
+  config = withPostgresSchemas(config, effectiveSchemas);
+  const shouldEnsureConfig = writeConfig && config.provider.kind === "postgres" && !options.provider;
+  if (shouldEnsureConfig) {
+    const ensureResult = await ensureGeneratorConfigFile({
+      cwd,
+      configPath: options.configPath,
+      dryRun,
+      // Schemas already resolved above — avoid a second discovery round-trip.
+      discoverSchemas: false,
+      provider: config.provider,
+      loaded: { configPath, config },
+      schemas: effectiveSchemas,
+      mode: config.provider.mode
+    });
+    configEnsure = {
+      action: ensureResult.action,
+      path: ensureResult.path,
+      schemas: ensureResult.schemas,
+      changes: ensureResult.changes,
+      reason: ensureResult.reason
+    };
+    if (ensureResult.action === "created" || ensureResult.action === "updated" || ensureResult.action === "unchanged" && configPath === "[environment defaults]") {
+      configPath = ensureResult.absolutePath;
+      if (ensureResult.schemas.length > 0) {
+        effectiveSchemas = ensureResult.schemas;
+        config = withPostgresSchemas(config, effectiveSchemas);
+      }
+    }
+  }
   const provider = options.provider ?? resolveGeneratorProvider(config.provider, config.experimental);
   const snapshot = await provider.inspect({
-    schemas: resolveProviderSchemas(config.provider)
+    schemas: effectiveSchemas
   });
   const generated = generateArtifactsFromSnapshot(snapshot, config);
-  const writeResult = options.dryRun ? { writtenFiles: [], skippedFiles: [] } : await writeArtifacts(generated.files, cwd);
+  const writeResult = await writeArtifacts(
+    generated.files,
+    cwd,
+    config,
+    dryRun
+  );
   return {
     ...generated,
     configPath,
     config,
     writtenFiles: writeResult.writtenFiles,
-    skippedFiles: writeResult.skippedFiles
+    writtenDetails: writeResult.writtenDetails,
+    skippedFiles: writeResult.skippedFiles,
+    configEnsure
   };
 }
 
@@ -13390,15 +15057,15 @@ function readCookieFromHeaders(headers, name) {
   }
   return parseCookies(cookieHeader).get(name);
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function resolveSessionCandidate(value) {
-  if (!isRecord13(value)) {
+  if (!isRecord14(value)) {
     return null;
   }
-  const session = isRecord13(value.session) ? value.session : void 0;
-  const user = isRecord13(value.user) ? value.user : void 0;
+  const session = isRecord14(value.session) ? value.session : void 0;
+  const user = isRecord14(value.user) ? value.user : void 0;
   if (session && typeof session.token === "string" && session.token.length > 0 && user) {
     return {
       session,
@@ -13408,7 +15075,7 @@ function resolveSessionCandidate(value) {
   return null;
 }
 function inferSessionPair(returned) {
-  return resolveSessionCandidate(returned) ?? (isRecord13(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord13(returned) ? resolveSessionCandidate(returned.session) : null);
+  return resolveSessionCandidate(returned) ?? (isRecord14(returned) ? resolveSessionCandidate(returned.data) : null) ?? (isRecord14(returned) ? resolveSessionCandidate(returned.session) : null);
 }
 function resolveResponseHeaders(ctx) {
   if (ctx.context.responseHeaders instanceof Headers) {
@@ -13839,11 +15506,27 @@ exports.Backend = Backend;
 exports.DEFAULT_MULTIPART_PART_SIZE_BYTES = DEFAULT_MULTIPART_PART_SIZE_BYTES;
 exports.DEFAULT_MULTIPART_THRESHOLD_BYTES = DEFAULT_MULTIPART_THRESHOLD_BYTES;
 exports.DEFAULT_POSTGRES_SCHEMAS = DEFAULT_POSTGRES_SCHEMAS;
+exports.applyAthenaReadQueryFilters = applyAthenaReadQueryFilters;
+exports.applyAthenaReadQuerySelectLimit = applyAthenaReadQuerySelectLimit;
+exports.applyAthenaReadQuerySelectOrder = applyAthenaReadQuerySelectOrder;
+exports.applyAthenaTableFilters = applyAthenaTableFilters;
+exports.applyAthenaTableSelectLimit = applyAthenaTableSelectLimit;
+exports.applyAthenaTableSelectOrder = applyAthenaTableSelectOrder;
 exports.assertInt = assertInt;
 exports.athenaAuth = athenaAuth;
 exports.billingSdkManifest = billingSdkManifest;
 exports.boolean = boolean;
+exports.buildAthenaReadQueryFindManyOrderBy = buildAthenaReadQueryFindManyOrderBy;
+exports.buildAthenaReadQueryFindManySelect = buildAthenaReadQueryFindManySelect;
+exports.buildAthenaReadQueryFindManyWhere = buildAthenaReadQueryFindManyWhere;
+exports.buildAthenaReadQuerySelectString = buildAthenaReadQuerySelectString;
+exports.buildAthenaTableFindManyOrderBy = buildAthenaTableFindManyOrderBy;
+exports.buildAthenaTableFindManySelect = buildAthenaTableFindManySelect;
+exports.buildAthenaTableFindManyWhere = buildAthenaTableFindManyWhere;
+exports.buildAthenaTableSelectString = buildAthenaTableSelectString;
 exports.chatSdkManifest = chatSdkManifest;
+exports.clampAthenaReadQueryTotalItems = clampAthenaReadQueryTotalItems;
+exports.clampAthenaTableTotalItems = clampAthenaTableTotalItems;
 exports.coerceInt = coerceInt;
 exports.createAthenaStorageError = createAthenaStorageError;
 exports.createAuthReactEmailInput = createAuthReactEmailInput;
@@ -13859,10 +15542,17 @@ exports.defineGeneratorConfig = defineGeneratorConfig;
 exports.defineModel = defineModel;
 exports.defineRegistry = defineRegistry;
 exports.defineSchema = defineSchema;
+exports.detectGeneratorProviderMode = detectGeneratorProviderMode;
+exports.discoverPostgresSchemas = discoverPostgresSchemas;
 exports.ensureActiveOrganization = ensureActiveOrganization;
+exports.ensureGeneratorConfigFile = ensureGeneratorConfigFile;
 exports.enumeration = enumeration;
+exports.executeAthenaReadQuery = executeAthenaReadQuery;
+exports.executeAthenaTableQuery = executeAthenaTableQuery;
 exports.filterIntrospectionSnapshot = filterIntrospectionSnapshot;
 exports.findGeneratorConfigPath = findGeneratorConfigPath;
+exports.flattenAthenaReadQueryRows = flattenAthenaReadQueryRows;
+exports.flattenAthenaRows = flattenAthenaRows;
 exports.generateArtifactsFromSnapshot = generateArtifactsFromSnapshot;
 exports.generatorEnv = generatorEnv;
 exports.getAthenaDebugAst = getAthenaDebugAst;
@@ -13871,14 +15561,20 @@ exports.isAthenaGatewayError = isAthenaGatewayError;
 exports.isOk = isOk;
 exports.json = json;
 exports.loadGeneratorConfig = loadGeneratorConfig;
+exports.mergeSchemaSelections = mergeSchemaSelections;
 exports.normalizeAthenaError = normalizeAthenaError;
 exports.normalizeAthenaGatewayBaseUrl = normalizeAthenaGatewayBaseUrl;
+exports.normalizeAthenaReadQueryOrderBy = normalizeAthenaReadQueryOrderBy;
+exports.normalizeAthenaTableOrderBy = normalizeAthenaTableOrderBy;
+exports.normalizeDiscoveredSchemas = normalizeDiscoveredSchemas;
 exports.normalizeGeneratorConfig = normalizeGeneratorConfig;
 exports.normalizeSchemaSelection = normalizeSchemaSelection;
 exports.normalizeTableSelection = normalizeTableSelection;
 exports.number = number;
 exports.parseBooleanFlag = parseBooleanFlag2;
+exports.patchSchemasInConfigSource = patchSchemasInConfigSource;
 exports.renderAthenaReactEmail = renderAthenaReactEmail;
+exports.renderGeneratorConfigFile = renderGeneratorConfigFile;
 exports.requireAffected = requireAffected;
 exports.requireSuccess = requireSuccess;
 exports.resolveGeneratorProvider = resolveGeneratorProvider;
@@ -13886,6 +15582,7 @@ exports.resolvePostgresColumnType = resolvePostgresColumnType;
 exports.resolveProviderSchemas = resolveProviderSchemas;
 exports.resolveStoragePath = resolveStoragePath;
 exports.runSchemaGenerator = runSchemaGenerator;
+exports.schemasEqual = schemasEqual;
 exports.storageSdkManifest = storageSdkManifest;
 exports.string = string;
 exports.table = table;