@danielhritcu/zenstack-custom 1.1.0

package/dist/index.cjs

@@ -0,0 +1,3705 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  APP_SLUG_JS: () => APP_SLUG_JS,
+  APP_SLUG_SQL: () => APP_SLUG_SQL,
+  CustomObject: () => CustomObject,
+  ENUM_MAP: () => ENUM_MAP,
+  FALSE: () => FALSE,
+  GENERATED_FILE_BANNER: () => GENERATED_FILE_BANNER,
+  PgCronJob: () => PgCronJob,
+  PgExtension: () => PgExtension,
+  PgFunction: () => PgFunction,
+  PgTrigger: () => PgTrigger,
+  TriggerFunction: () => TriggerFunction,
+  adaptToLegacyConfig: () => adaptToLegacyConfig,
+  appSlugForeignKey: () => appSlugForeignKey,
+  assertNoTypedColumnOverrides: () => assertNoTypedColumnOverrides,
+  auditColumns: () => auditColumns,
+  buildRelations: () => buildRelations,
+  buildTypeDefs: () => buildTypeDefs,
+  capitalize: () => capitalize,
+  categorizeChanges: () => categorizeChanges,
+  cleanMeta: () => cleanMeta,
+  colAppSlug: () => colAppSlug,
+  colCreatedAt: () => colCreatedAt,
+  colDeletedAt: () => colDeletedAt,
+  colId: () => colId,
+  colNumeric: () => colNumeric,
+  colTimestamp: () => colTimestamp,
+  colUpdatedAt: () => colUpdatedAt,
+  collectCustomObjects: () => collectCustomObjects,
+  computeHash: () => computeHash,
+  currentAppSlug: () => currentAppSlug,
+  currentUser: () => currentUser,
+  custom: () => custom,
+  defaultPolicy: () => defaultPolicy,
+  defineConfig: () => defineConfig,
+  defineModels: () => defineModels,
+  derived: () => derived,
+  discoverEnums: () => discoverEnums,
+  discoverTables: () => discoverTables,
+  discoverViews: () => discoverViews,
+  drop: () => drop,
+  emitCompatTs: () => emitCompatTs,
+  emitEnumBlock: () => emitEnumBlock,
+  emitEnumsTs: () => emitEnumsTs,
+  emitFieldBlock: () => emitFieldBlock,
+  emitGeneratedFileBanner: () => emitGeneratedFileBanner,
+  emitIndexTs: () => emitIndexTs,
+  emitInputTs: () => emitInputTs,
+  emitJsonNamespaceBlock: () => emitJsonNamespaceBlock,
+  emitJsonRawNamespaceBlock: () => emitJsonRawNamespaceBlock,
+  emitJsonRawTs: () => emitJsonRawTs,
+  emitJsonTs: () => emitJsonTs,
+  emitModelsTs: () => emitModelsTs,
+  emitOrmTypesTs: () => emitOrmTypesTs,
+  emitRelationField: () => emitRelationField,
+  emitSchemaTs: () => emitSchemaTs,
+  emitTypeDefsBlock: () => emitTypeDefsBlock,
+  emitViewsTs: () => emitViewsTs,
+  esc: () => esc,
+  extend: () => extend,
+  extractFKs: () => extractFKs,
+  fixOrder: () => fixOrder,
+  formatChangeSummary: () => formatChangeSummary,
+  formatVerboseOutput: () => formatVerboseOutput,
+  generate: () => generate,
+  generateDropSQL: () => generateDropSQL,
+  getDrizzleTableName: () => getDrizzleTableName,
+  getLatestSnapshotPath: () => getLatestSnapshotPath,
+  hasAppSlug: () => hasAppSlug,
+  hasBypassEnabled: () => hasBypassEnabled,
+  loadSchemaModules: () => loadSchemaModules,
+  many: () => many,
+  mapColumn: () => mapColumn,
+  model: () => model,
+  one: () => one,
+  packToSgz: () => packToSgz,
+  parseFlags: () => parseFlags,
+  pgCron: () => pgCron,
+  pgExtension: () => pgExtension,
+  pgFunction: () => pgFunction,
+  pgOrmEnum: () => pgOrmEnum,
+  pgTrigger: () => pgTrigger,
+  pgTypes: () => pgTypes,
+  readJournal: () => readJournal,
+  readSnapshotCustomObjects: () => readSnapshotCustomObjects,
+  serializeCustomObject: () => serializeCustomObject,
+  simpleDiff: () => simpleDiff,
+  syncMeta: () => syncMeta,
+  through: () => through,
+  toPascalCase: () => toPascalCase,
+  toPgEnum: () => toPgEnum,
+  uncapitalize: () => uncapitalize,
+  unpackFromSgz: () => unpackFromSgz,
+  validateOrder: () => validateOrder,
+  validateTimestamps: () => validateTimestamps,
+  writeFileIfChanged: () => writeFileIfChanged,
+  writeSnapshotCustomObjects: () => writeSnapshotCustomObjects
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/codegen/config.ts
+function defineConfig(tables, config) {
+  const derived2 = config.derived ?? {};
+  const orm = {
+    ...tables
+  };
+  for (const [name, desc] of Object.entries(derived2)) {
+    if (name in tables) {
+      throw new Error(`Derived model "${name}" collides with existing table name.`);
+    }
+    orm[name] = desc;
+  }
+  const models = config.models(orm);
+  return {
+    tables,
+    schema: config.schema,
+    default: config.default,
+    derived: derived2,
+    models
+  };
+}
+__name(defineConfig, "defineConfig");
+
+// src/codegen/dsl/extend.ts
+var import_pg_core = require("drizzle-orm/pg-core");
+function inferNarrow(where) {
+  const narrow = {};
+  let hasNarrow = false;
+  for (const [field, condition] of Object.entries(where)) {
+    if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+      const cond = condition;
+      if ("in" in cond && Array.isArray(cond["in"])) {
+        narrow[field] = cond["in"];
+        hasNarrow = true;
+      }
+    }
+  }
+  return hasNarrow ? narrow : null;
+}
+__name(inferNarrow, "inferNarrow");
+function derived(base, opts) {
+  const cfg = (0, import_pg_core.getTableConfig)(base);
+  const descriptor = {
+    __brand: "derived",
+    base,
+    where: opts.where,
+    narrow: opts.narrow ?? inferNarrow(opts.where),
+    baseName: cfg.name
+  };
+  return new Proxy(descriptor, {
+    get(target, prop, receiver) {
+      if (prop in target) return Reflect.get(target, prop, receiver);
+      return Reflect.get(base, prop);
+    },
+    has(target, prop) {
+      return prop in target || prop in base;
+    }
+  });
+}
+__name(derived, "derived");
+function extend(tables, derivedModels) {
+  for (const key of Object.keys(derivedModels)) {
+    if (key in tables) {
+      throw new Error(`Derived model "${key}" collides with existing table name. Choose a different name.`);
+    }
+  }
+  const extended = {
+    tables: {
+      ...tables
+    },
+    derived: {
+      ...derivedModels
+    }
+  };
+  const schemaProps = Object.assign({}, tables, derivedModels, {
+    __extended: extended
+  });
+  const defineModelsFn = /* @__PURE__ */ __name((globalConfig, models) => ({
+    schema: extended,
+    global: globalConfig,
+    models
+  }), "defineModelsFn");
+  return Object.assign(defineModelsFn, schemaProps);
+}
+__name(extend, "extend");
+
+// src/codegen/dsl/relations.ts
+function one(target, opts) {
+  return {
+    kind: "one",
+    target,
+    fields: opts.fields,
+    references: opts.references,
+    ...opts.where ? {
+      where: opts.where
+    } : {},
+    ...opts.relationName ? {
+      relationName: opts.relationName
+    } : {}
+  };
+}
+__name(one, "one");
+function many(target, opts) {
+  return {
+    kind: "many",
+    target,
+    ...opts?.where ? {
+      where: opts.where
+    } : {},
+    ...opts?.single ? {
+      single: true
+    } : {}
+  };
+}
+__name(many, "many");
+function through(path) {
+  return {
+    kind: "through",
+    path
+  };
+}
+__name(through, "through");
+
+// src/codegen/dsl/model.ts
+function model(table, opts) {
+  const helpers = {
+    one,
+    many,
+    through
+  };
+  return {
+    table,
+    relations: opts.relations?.(helpers),
+    computed: opts.computed,
+    search: opts.search,
+    defaultWhere: opts.defaultWhere,
+    derived: opts.derived,
+    validate: opts.validate
+  };
+}
+__name(model, "model");
+function defineModels(extendedSchema, globalConfig, models) {
+  return {
+    schema: extendedSchema.__extended,
+    global: globalConfig,
+    models
+  };
+}
+__name(defineModels, "defineModels");
+
+// src/codegen/dsl/adapter.ts
+var import_pg_core2 = require("drizzle-orm/pg-core");
+var COMPUTED_TYPE_MAP = {
+  json: {
+    type: "Json",
+    tsType: "JsonValue"
+  },
+  string: {
+    type: "String",
+    tsType: "string"
+  },
+  text: {
+    type: "String",
+    tsType: "string"
+  },
+  int: {
+    type: "Int",
+    tsType: "number"
+  },
+  float: {
+    type: "Float",
+    tsType: "number"
+  },
+  bool: {
+    type: "Boolean",
+    tsType: "boolean"
+  },
+  boolean: {
+    type: "Boolean",
+    tsType: "boolean"
+  },
+  dateTime: {
+    type: "DateTime",
+    tsType: "Date"
+  }
+};
+function resolveColumn(tables, column) {
+  for (const table of Object.values(tables)) {
+    for (const key of Object.keys(table)) {
+      if (table[key] === column) return {
+        table,
+        jsKey: key
+      };
+    }
+  }
+  const sqlName = column.name;
+  for (const table of Object.values(tables)) {
+    for (const key of Object.keys(table)) {
+      const col = table[key];
+      if (col && typeof col === "object" && "name" in col && col.name === sqlName) {
+        return {
+          table,
+          jsKey: key
+        };
+      }
+    }
+  }
+  return void 0;
+}
+__name(resolveColumn, "resolveColumn");
+function findExportNameForTable(tables, target) {
+  for (const [exportName, table] of Object.entries(tables)) {
+    if (table === target) return exportName;
+  }
+  const targetSqlName = (0, import_pg_core2.getTableConfig)(target).name;
+  for (const [exportName, table] of Object.entries(tables)) {
+    if ((0, import_pg_core2.getTableConfig)(table).name === targetSqlName) return exportName;
+  }
+  throw new Error(`Could not find export name for table "${targetSqlName}"`);
+}
+__name(findExportNameForTable, "findExportNameForTable");
+function sqlNameToExportName(tables, sqlName) {
+  for (const [exportName, table] of Object.entries(tables)) {
+    if ((0, import_pg_core2.getTableConfig)(table).name === sqlName) return exportName;
+  }
+  throw new Error(`No table export found with SQL name "${sqlName}"`);
+}
+__name(sqlNameToExportName, "sqlNameToExportName");
+function findDerivedNameForDescriptor(derived2, descriptor) {
+  for (const [name, desc] of Object.entries(derived2)) {
+    if (desc === descriptor) return name;
+  }
+  throw new Error(`Could not find derived model name for descriptor with base "${descriptor.baseName}"`);
+}
+__name(findDerivedNameForDescriptor, "findDerivedNameForDescriptor");
+function convertSearchFields(tables, fields) {
+  const result = {};
+  for (const field of fields) {
+    if ("name" in field && typeof field.name === "string") {
+      const resolved = resolveColumn(tables, field);
+      if (!resolved) throw new Error(`Could not resolve column "${field.name}"`);
+      result[resolved.jsKey] = true;
+    } else {
+      for (const [relation, nested] of Object.entries(field)) {
+        result[relation] = convertSearchFields(tables, nested);
+      }
+    }
+  }
+  return result;
+}
+__name(convertSearchFields, "convertSearchFields");
+function convertSearchProfile(tables, _modelTable, profile) {
+  return {
+    fields: convertSearchFields(tables, profile.fields)
+  };
+}
+__name(convertSearchProfile, "convertSearchProfile");
+function adaptToLegacyConfig(output) {
+  const { schema, models } = output;
+  const computedFields = {};
+  const computedCallbacks = {};
+  const derivedModels = {};
+  const filteredRelations = {};
+  const searchDefaults = {};
+  const throughRelations = {};
+  const relationTargets = {};
+  const modelScopes = {};
+  const derivedFields = {};
+  const validationSchemas = {};
+  const fkRelations = {};
+  for (const [derivedName, desc] of Object.entries(schema.derived)) {
+    const baseExportName = sqlNameToExportName(schema.tables, desc.baseName);
+    if (!derivedModels[baseExportName]) {
+      derivedModels[baseExportName] = {};
+    }
+    derivedModels[baseExportName][derivedName] = {
+      where: desc.where,
+      ...desc.narrow ? {
+        narrow: desc.narrow
+      } : {}
+    };
+  }
+  for (const [modelName, config] of Object.entries(models)) {
+    if (config.computed && typeof config.computed !== "function") {
+      const resolvedComputed = {};
+      const callbacks = {};
+      for (const [fieldName, decl] of Object.entries(config.computed)) {
+        if (typeof decl === "function") {
+          resolvedComputed[fieldName] = COMPUTED_TYPE_MAP["json"];
+          callbacks[fieldName] = decl;
+        } else {
+          const declObj = decl;
+          const typeKey = declObj.type?.toLowerCase() ?? "json";
+          resolvedComputed[fieldName] = COMPUTED_TYPE_MAP[typeKey] ?? COMPUTED_TYPE_MAP["json"];
+        }
+      }
+      computedFields[modelName] = resolvedComputed;
+      if (Object.keys(callbacks).length > 0) {
+        computedCallbacks[modelName] = callbacks;
+      }
+    }
+    if (config.relations) {
+      for (const [relName, rel] of Object.entries(config.relations)) {
+        if (rel.kind === "one") {
+          const oneRel = rel;
+          const targetTable = "__brand" in oneRel.target ? oneRel.target.base : oneRel.target;
+          const targetExportName = findExportNameForTable(schema.tables, targetTable);
+          const resolvedFields = oneRel.fields.map((col) => {
+            const resolved = resolveColumn(schema.tables, col);
+            return resolved?.jsKey ?? col.name;
+          });
+          const resolvedRefs = oneRel.references.map((col) => {
+            const resolved = resolveColumn(schema.tables, col);
+            return resolved?.jsKey ?? col.name;
+          });
+          if (oneRel.where) {
+            if (!fkRelations[modelName]) {
+              fkRelations[modelName] = {};
+            }
+            fkRelations[modelName][relName] = {
+              targetExportName,
+              fields: resolvedFields,
+              references: resolvedRefs,
+              relationName: oneRel.relationName ?? null
+            };
+            if (!filteredRelations[modelName]) {
+              filteredRelations[modelName] = {};
+            }
+            filteredRelations[modelName][relName] = {
+              relation: {
+                [relName]: true
+              },
+              where: oneRel.where,
+              single: true
+            };
+          } else {
+            if (!fkRelations[modelName]) {
+              fkRelations[modelName] = {};
+            }
+            fkRelations[modelName][relName] = {
+              targetExportName,
+              fields: resolvedFields,
+              references: resolvedRefs,
+              relationName: oneRel.relationName ?? null
+            };
+          }
+          if ("__brand" in oneRel.target && oneRel.target.__brand === "derived") {
+            const descriptor = oneRel.target;
+            const derivedName = findDerivedNameForDescriptor(schema.derived, descriptor);
+            const baseExportName = sqlNameToExportName(schema.tables, descriptor.baseName);
+            if (!derivedModels[baseExportName]) {
+              derivedModels[baseExportName] = {};
+            }
+            const derivedEntry = derivedModels[baseExportName][derivedName];
+            if (derivedEntry) {
+              if (!derivedEntry.relations) {
+                derivedEntry.relations = {};
+              }
+              if (!derivedEntry.relations[modelName]) {
+                derivedEntry.relations[modelName] = {};
+              }
+              derivedEntry.relations[modelName][relName] = true;
+            }
+            if (!relationTargets[modelName]) {
+              relationTargets[modelName] = {};
+            }
+            relationTargets[modelName][relName] = derivedName;
+          }
+        } else if (rel.kind === "many") {
+          const manyRel = rel;
+          const targetExportName = findExportNameForTable(schema.tables, manyRel.target);
+          if (!filteredRelations[modelName]) {
+            filteredRelations[modelName] = {};
+          }
+          filteredRelations[modelName][relName] = {
+            relation: {
+              [targetExportName]: true
+            },
+            ...manyRel.where ? {
+              where: manyRel.where
+            } : {},
+            ...manyRel.single ? {
+              single: true
+            } : {}
+          };
+        } else if (rel.kind === "through") {
+          const throughRel = rel;
+          if (!throughRelations[modelName]) {
+            throughRelations[modelName] = {};
+          }
+          throughRelations[modelName][relName] = {
+            path: throughRel.path
+          };
+        }
+      }
+    }
+    if (config.defaultWhere) {
+      modelScopes[modelName] = config.defaultWhere;
+    } else if (output.global.defaultWhere) {
+      modelScopes[modelName] = output.global.defaultWhere;
+    }
+    if (config.derived) {
+      derivedFields[modelName] = config.derived;
+    }
+    if (config.validate) {
+      validationSchemas[modelName] = config.validate;
+    }
+    if (config.search) {
+      const modelSearchDefaults = {};
+      for (const [profileName, profile] of Object.entries(config.search)) {
+        modelSearchDefaults[profileName] = convertSearchProfile(schema.tables, config.table, profile);
+      }
+      searchDefaults[modelName] = modelSearchDefaults;
+    }
+  }
+  return {
+    computedFields,
+    computedCallbacks,
+    derivedModels,
+    filteredRelations,
+    searchDefaults,
+    throughRelations,
+    relationTargets,
+    modelScopes,
+    derivedFields,
+    validationSchemas,
+    fkRelations
+  };
+}
+__name(adaptToLegacyConfig, "adaptToLegacyConfig");
+
+// src/codegen/utils.ts
+var fs = __toESM(require("fs"), 1);
+var APP_SLUG_SQL = "app_slug";
+var APP_SLUG_JS = "appSlug";
+var GENERATED_FILE_BANNER = [
+  "//////////////////////////////////////////////////////////////////////////////////////////////",
+  "// DO NOT MODIFY THIS FILE                                                                  //",
+  "// Generated by scripts/zen from Drizzle schema.                                            //",
+  "//////////////////////////////////////////////////////////////////////////////////////////////",
+  "",
+  "/* eslint-disable */"
+];
+function emitGeneratedFileBanner() {
+  return [
+    ...GENERATED_FILE_BANNER
+  ];
+}
+__name(emitGeneratedFileBanner, "emitGeneratedFileBanner");
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+__name(capitalize, "capitalize");
+function toPascalCase(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[_\-\s]+/).filter(Boolean).map(capitalize).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function uncapitalize(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+__name(uncapitalize, "uncapitalize");
+function esc(s) {
+  return JSON.stringify(s);
+}
+__name(esc, "esc");
+function getDrizzleTableName(table) {
+  return table[Symbol.for("drizzle:Name")];
+}
+__name(getDrizzleTableName, "getDrizzleTableName");
+function writeFileIfChanged(filePath, content) {
+  if (fs.existsSync(filePath) && fs.readFileSync(filePath, "utf-8") === content) {
+    return false;
+  }
+  fs.writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+__name(writeFileIfChanged, "writeFileIfChanged");
+
+// src/codegen/columns.ts
+function mapColumn(jsKey, col, enumMap) {
+  const sqlName = col.name;
+  const colType = col.columnType;
+  const notNull = col.notNull;
+  const hasDefault = col.hasDefault;
+  const isPrimary = col.primary;
+  const isUnique = col.isUnique;
+  const generated = col.generated;
+  const isArray = colType === "PgArray";
+  let type = "String";
+  const dbAttrs = [];
+  let enumPgName = null;
+  let isJsonColumn = false;
+  let actualColType = colType;
+  let actualCol = col;
+  if (isArray && col.baseColumn) {
+    actualCol = col.baseColumn;
+    actualColType = actualCol.columnType;
+  }
+  switch (actualColType) {
+    case "PgUUID":
+      type = "String";
+      dbAttrs.push("@db.Uuid");
+      break;
+    case "PgText":
+      type = "String";
+      break;
+    case "PgVarchar": {
+      type = "String";
+      const len = actualCol.length;
+      if (len) dbAttrs.push(`@db.VarChar(${len})`);
+      else dbAttrs.push("@db.VarChar");
+      break;
+    }
+    case "PgBoolean":
+      type = "Boolean";
+      break;
+    case "PgInteger":
+      type = "Int";
+      break;
+    case "PgBigInt53":
+      type = "BigInt";
+      break;
+    case "PgSerial":
+      type = "Int";
+      break;
+    case "PgReal":
+      type = "Float";
+      dbAttrs.push("@db.Real");
+      break;
+    case "PgDoublePrecision":
+      type = "Float";
+      dbAttrs.push("@db.DoublePrecision");
+      break;
+    case "PgTimestamp": {
+      type = "DateTime";
+      const wtz = actualCol.withTimezone ?? actualCol.config?.withTimezone;
+      if (wtz) dbAttrs.push("@db.Timestamptz(6)");
+      else dbAttrs.push("@db.Timestamp(6)");
+      break;
+    }
+    case "PgDate":
+    case "PgDateString":
+      type = "DateTime";
+      dbAttrs.push("@db.Date");
+      break;
+    case "PgJsonb":
+      type = "Json";
+      isJsonColumn = true;
+      dbAttrs.push("@db.JsonB");
+      break;
+    case "PgJson":
+      type = "Json";
+      isJsonColumn = true;
+      dbAttrs.push("@db.Json");
+      break;
+    case "PgEnumColumn": {
+      if (isArray) {
+        type = "String";
+      } else {
+        const eName = actualCol.enum?.enumName;
+        if (eName && enumMap.has(eName)) {
+          type = enumMap.get(eName).zenstackName;
+          enumPgName = eName;
+        } else {
+          type = "String";
+        }
+      }
+      break;
+    }
+    case "PgCustomColumn": {
+      const sqlType = actualCol.sqlName || actualCol.config?.dataType;
+      if (sqlType === "json") {
+        type = "Json";
+        isJsonColumn = true;
+        dbAttrs.push("@db.Json");
+      } else if (sqlType === "jsonb") {
+        type = "Json";
+        isJsonColumn = true;
+        dbAttrs.push("@db.JsonB");
+      } else if (sqlType === "numeric") {
+        type = "Decimal";
+      } else type = "String";
+      break;
+    }
+    case "PgNumeric":
+      type = "Decimal";
+      break;
+    default:
+      console.warn(`Unknown Drizzle column type "${actualColType}" for column "${sqlName}" \u2014 falling back to String`);
+      type = "String";
+  }
+  let defaultExpr = null;
+  if (hasDefault) {
+    if (isPrimary && actualColType === "PgUUID") {
+      defaultExpr = 'ExpressionUtils.call("uuid")';
+    } else if (actualColType === "PgBigInt53" && col.generatedIdentity) {
+      defaultExpr = 'ExpressionUtils.call("autoincrement")';
+    } else if (actualColType === "PgSerial") {
+      defaultExpr = 'ExpressionUtils.call("autoincrement")';
+    } else if (col.defaultFn) {
+      if (type === "DateTime") {
+        defaultExpr = 'ExpressionUtils.call("now")';
+      } else if (type === "String" && isPrimary) {
+        defaultExpr = 'ExpressionUtils.call("uuid")';
+      } else {
+        defaultExpr = null;
+      }
+    } else if (col.default !== void 0) {
+      const d = col.default;
+      if (typeof d === "boolean" || typeof d === "number") {
+        defaultExpr = `ExpressionUtils.literal(${d})`;
+      } else if (typeof d === "string") {
+        defaultExpr = `ExpressionUtils.literal(${esc(d)})`;
+      } else if (d && typeof d === "object" && "queryChunks" in d) {
+        try {
+          const chunks = d.queryChunks || [];
+          const sqlStr = chunks.map((c) => typeof c === "string" ? c : c.value?.[0] || "").join("").trim();
+          if (sqlStr) {
+            defaultExpr = `ExpressionUtils.call("dbgenerated", [ExpressionUtils.literal(${esc(sqlStr)})])`;
+          }
+        } catch (e) {
+          console.warn(`Failed to parse SQL default for column "${sqlName}":`, e);
+        }
+      } else if (Array.isArray(d) && d.length === 0) {
+        defaultExpr = "[] as FieldDefault";
+      } else if (typeof d === "object" && d !== null && Object.keys(d).length === 0) {
+        defaultExpr = `ExpressionUtils.literal("{}")`;
+      }
+    }
+  }
+  return {
+    name: jsKey,
+    sqlName,
+    type,
+    isJsonColumn,
+    optional: !notNull && !hasDefault,
+    array: isArray,
+    id: isPrimary,
+    unique: isUnique,
+    hasDefault,
+    dbAttrs,
+    defaultExpr,
+    enumPgName,
+    isGenerated: !!generated
+  };
+}
+__name(mapColumn, "mapColumn");
+
+// src/codegen/discover.ts
+var import_pg_core4 = require("drizzle-orm/pg-core");
+var fs2 = __toESM(require("fs"), 1);
+var ts = __toESM(require("typescript"), 1);
+
+// src/drizzle/define.ts
+var import_drizzle_orm = require("drizzle-orm");
+var import_pg_core3 = require("drizzle-orm/pg-core");
+var ENUM_MAP = Symbol.for("drizzle:EnumMap");
+function toPgEnum(record) {
+  return Object.values(record);
+}
+__name(toPgEnum, "toPgEnum");
+function pgOrmEnum(name, values) {
+  const pgValues = Object.values(values);
+  const result = (0, import_pg_core3.pgEnum)(name, pgValues);
+  result[ENUM_MAP] = values;
+  return result;
+}
+__name(pgOrmEnum, "pgOrmEnum");
+var pgTypes = {
+  date: /* @__PURE__ */ __name(() => "date", "date"),
+  uuid: /* @__PURE__ */ __name(() => "uuid", "uuid"),
+  text: /* @__PURE__ */ __name(() => "text", "text"),
+  integer: /* @__PURE__ */ __name(() => "integer", "integer"),
+  bigint: /* @__PURE__ */ __name(() => "bigint", "bigint"),
+  boolean: /* @__PURE__ */ __name(() => "boolean", "boolean"),
+  numeric: /* @__PURE__ */ __name(() => "numeric", "numeric"),
+  timestamptz: /* @__PURE__ */ __name(() => "timestamptz", "timestamptz"),
+  timestamp: /* @__PURE__ */ __name(() => "timestamp", "timestamp"),
+  jsonb: /* @__PURE__ */ __name(() => "jsonb", "jsonb"),
+  json: /* @__PURE__ */ __name(() => "json", "json")
+};
+var CustomObject = class extends import_drizzle_orm.SQL {
+  static {
+    __name(this, "CustomObject");
+  }
+  name;
+  type;
+  schema;
+  qualifiedName;
+  constructor(name, type, schema) {
+    const qn = schema ? `${schema}.${name}` : name;
+    super(import_drizzle_orm.sql.raw(qn).queryChunks), this.name = name, this.type = type, this.schema = schema;
+    this.qualifiedName = qn;
+  }
+  getSQL() {
+    return import_drizzle_orm.sql.raw(this.qualifiedName);
+  }
+};
+var PgFunction = class extends CustomObject {
+  static {
+    __name(this, "PgFunction");
+  }
+  opts;
+  constructor(name, opts) {
+    super(name, "function", opts.schema), this.opts = opts;
+  }
+  toSQL(dialect) {
+    const args = this.opts.args ? Object.entries(this.opts.args(pgTypes)).map(([n, type]) => `${n} ${type}`).join(", ") : "";
+    const language = this.opts.language ?? "plpgsql";
+    const body = dialect.sqlToQuery(this.opts.body()).sql;
+    const lines = [
+      `CREATE OR REPLACE FUNCTION ${this.qualifiedName}(${args})`,
+      `RETURNS ${this.opts.returns}`,
+      `LANGUAGE ${language}`
+    ];
+    if (this.opts.security === "definer") lines.push("SECURITY DEFINER");
+    if (this.opts.searchPath) lines.push(`SET search_path = ${this.opts.searchPath}`);
+    lines.push(`AS $function$
+${body}
+$function$;`);
+    return lines.join("\n");
+  }
+};
+var TriggerFunction = class extends PgFunction {
+  static {
+    __name(this, "TriggerFunction");
+  }
+  triggerOpts;
+  constructor(name, triggerOpts) {
+    super(name, {
+      returns: "trigger",
+      schema: triggerOpts.schema,
+      language: triggerOpts.language,
+      security: triggerOpts.security,
+      searchPath: triggerOpts.searchPath,
+      body: triggerOpts.body
+    }), this.triggerOpts = triggerOpts;
+  }
+};
+var PgTrigger = class extends CustomObject {
+  static {
+    __name(this, "PgTrigger");
+  }
+  opts;
+  tableName;
+  constructor(name, opts) {
+    super(name, "trigger", opts.schema), this.opts = opts;
+    this.tableName = opts.on[Symbol.for("drizzle:Name")];
+  }
+  toSQL(dialect) {
+    const tableName = this.tableName;
+    const eventParts = this.opts.events.map((e) => {
+      if (typeof e === "string") return e.toUpperCase();
+      const cols = e.update.map((c) => c.name).join(", ");
+      return `UPDATE OF ${cols}`;
+    });
+    const lines = [
+      `CREATE OR REPLACE TRIGGER ${this.name}`,
+      `${this.opts.timing.toUpperCase()} ${eventParts.join(" OR ")}`,
+      `ON ${tableName}`,
+      `FOR EACH ${this.opts.forEach.toUpperCase()}`
+    ];
+    if (this.opts.condition) {
+      const cond = dialect.sqlToQuery(this.opts.condition).sql;
+      lines.push(`WHEN (${cond})`);
+    }
+    lines.push(`EXECUTE FUNCTION ${this.opts.execute.qualifiedName}();`);
+    return lines.join("\n");
+  }
+};
+var PgExtension = class extends CustomObject {
+  static {
+    __name(this, "PgExtension");
+  }
+  opts;
+  constructor(name, opts = {}) {
+    super(name, "extension"), this.opts = opts;
+  }
+  toSQL() {
+    const schema = this.opts.schema ? ` SCHEMA ${this.opts.schema}` : "";
+    return `CREATE EXTENSION IF NOT EXISTS "${this.name}"${schema};`;
+  }
+};
+function pgExtension(name, opts = {}) {
+  return new PgExtension(name, opts);
+}
+__name(pgExtension, "pgExtension");
+var PgCronJob = class extends CustomObject {
+  static {
+    __name(this, "PgCronJob");
+  }
+  opts;
+  constructor(name, opts) {
+    super(name, "cron"), this.opts = opts;
+  }
+  toSQL(dialect) {
+    const cmd = dialect.sqlToQuery(this.opts.command()).sql;
+    const escapedName = this.name.replace(/'/g, "''");
+    const escapedSchedule = this.opts.schedule.replace(/'/g, "''");
+    return `SELECT cron.schedule('${escapedName}', '${escapedSchedule}', $$${cmd}$$);`;
+  }
+};
+function pgCron(name, opts) {
+  return new PgCronJob(name, opts);
+}
+__name(pgCron, "pgCron");
+function pgFunction(name, opts) {
+  if (opts.returns === "trigger" && "triggersOn" in opts) {
+    return new TriggerFunction(name, opts);
+  }
+  return new PgFunction(name, opts);
+}
+__name(pgFunction, "pgFunction");
+function pgTrigger(name, opts) {
+  return new PgTrigger(name, opts);
+}
+__name(pgTrigger, "pgTrigger");
+
+// src/codegen/discover.ts
+function discoverEnums(allEnums) {
+  const enums = /* @__PURE__ */ new Map();
+  for (const [exportName, val] of Object.entries(allEnums)) {
+    if (typeof val !== "function" || !("enumName" in val)) continue;
+    const e = val;
+    const pgName = e.enumName;
+    const values = e.enumValues;
+    const zenstackName = capitalize(exportName.replace(/Enum$/, ""));
+    const mapping = e[ENUM_MAP] ?? null;
+    enums.set(pgName, {
+      pgName,
+      zenstackName,
+      values,
+      mapping,
+      mappedName: pgName
+    });
+  }
+  return enums;
+}
+__name(discoverEnums, "discoverEnums");
+function getColumnsObject(node) {
+  if (ts.isObjectLiteralExpression(node)) return node;
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    if (ts.isObjectLiteralExpression(node.body)) return node.body;
+    if (ts.isParenthesizedExpression(node.body) && ts.isObjectLiteralExpression(node.body.expression)) {
+      return node.body.expression;
+    }
+    if (ts.isBlock(node.body)) {
+      for (const statement of node.body.statements) {
+        if (!ts.isReturnStatement(statement) || !statement.expression) continue;
+        if (ts.isObjectLiteralExpression(statement.expression)) return statement.expression;
+        if (ts.isParenthesizedExpression(statement.expression) && ts.isObjectLiteralExpression(statement.expression.expression)) {
+          return statement.expression.expression;
+        }
+      }
+    }
+  }
+  return null;
+}
+__name(getColumnsObject, "getColumnsObject");
+function getColumnBuilderName(node) {
+  if (ts.isCallExpression(node)) return getColumnBuilderName(node.expression);
+  if (ts.isPropertyAccessExpression(node)) {
+    if (ts.isIdentifier(node.expression) && node.expression.text === "col") {
+      return node.name.text;
+    }
+    return getColumnBuilderName(node.expression);
+  }
+  return null;
+}
+__name(getColumnBuilderName, "getColumnBuilderName");
+function assertNoTypedColumnOverrides(tablesFilePath) {
+  const sourceFile = ts.createSourceFile(tablesFilePath, fs2.readFileSync(tablesFilePath, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      if (!ts.isCallExpression(declaration.initializer)) continue;
+      const columnsArg = declaration.initializer.arguments[1];
+      if (!columnsArg) continue;
+      const columnsObject = getColumnsObject(columnsArg);
+      if (!columnsObject) continue;
+      for (const property of columnsObject.properties) {
+        if (!ts.isPropertyAssignment(property)) continue;
+        const nameNode = property.name;
+        const jsKey = ts.isIdentifier(nameNode) || ts.isStringLiteral(nameNode) ? nameNode.text : null;
+        if (!jsKey) continue;
+        let typedCall = null;
+        const visit = /* @__PURE__ */ __name((node) => {
+          if (typedCall) return;
+          if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "$type") {
+            typedCall = node;
+            return;
+          }
+          ts.forEachChild(node, visit);
+        }, "visit");
+        visit(property.initializer);
+        if (!typedCall) continue;
+        const resolvedCall = typedCall;
+        const builderName = getColumnBuilderName(resolvedCall.expression.expression);
+        if (builderName === "json" || builderName === "jsonb" || builderName === "array") continue;
+        const fullText = property.initializer.getText();
+        if (fullText.includes(".array()")) continue;
+        console.warn(`Warning: Column "${declaration.name.text}.${jsKey}" uses $type<...>() on a ${builderName ?? "scalar"} column. Consider using a real enum.`);
+      }
+    }
+  }
+}
+__name(assertNoTypedColumnOverrides, "assertNoTypedColumnOverrides");
+function discoverTables(allTables, computedFieldsConfig = {}, derivedModelsConfig = {}) {
+  const tables = [];
+  const tablesByModel = /* @__PURE__ */ new Map();
+  for (const [exportName, _val] of Object.entries(allTables)) {
+    const val = _val;
+    if (!val || typeof val !== "object") continue;
+    const syms = Object.getOwnPropertySymbols(val);
+    if (!syms.some((s) => s.toString().includes("IsDrizzleTable"))) continue;
+    const sqlName = getDrizzleTableName(val);
+    const modelName = exportName;
+    const typeName = capitalize(exportName);
+    const sqlToJsKey = /* @__PURE__ */ new Map();
+    const jsKeySet = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(val)) {
+      const col = val[key];
+      if (col.name && col.columnType) {
+        sqlToJsKey.set(col.name, key);
+        jsKeySet.add(key);
+      }
+    }
+    const cfg = (0, import_pg_core4.getTableConfig)(val);
+    const computedFields = Object.entries(computedFieldsConfig[exportName] ?? {}).map(([name, field]) => {
+      if (jsKeySet.has(name)) {
+        throw new Error(`Computed field "${exportName}.${name}" collides with an existing column.`);
+      }
+      return {
+        name,
+        type: field.type,
+        tsType: field.tsType
+      };
+    });
+    tables.push({
+      exportName,
+      sqlName,
+      modelName,
+      typeName,
+      table: val,
+      cfg,
+      sqlToJsKey,
+      jsKeySet,
+      computedFields,
+      derivedFrom: null,
+      defaultWhere: null,
+      narrow: null
+    });
+    tablesByModel.set(modelName, tables[tables.length - 1]);
+  }
+  for (const modelName of Object.keys(computedFieldsConfig)) {
+    if (!tablesByModel.has(modelName)) {
+      throw new Error(`Computed fields declared for unknown table export "${modelName}".`);
+    }
+  }
+  for (const [baseModelName, derivedModels] of Object.entries(derivedModelsConfig)) {
+    const baseTable = tablesByModel.get(baseModelName);
+    if (!baseTable) {
+      throw new Error(`Derived models declared for unknown table export "${baseModelName}".`);
+    }
+    for (const [derivedModelName, declaration] of Object.entries(derivedModels)) {
+      if (tablesByModel.has(derivedModelName)) {
+        throw new Error(`Derived model "${derivedModelName}" collides with an existing table or derived model.`);
+      }
+      const derivedTable = {
+        ...baseTable,
+        exportName: derivedModelName,
+        modelName: derivedModelName,
+        typeName: capitalize(derivedModelName),
+        computedFields: [
+          ...baseTable.computedFields
+        ],
+        derivedFrom: baseModelName,
+        defaultWhere: declaration.where,
+        narrow: declaration.narrow ?? null
+      };
+      tables.push(derivedTable);
+      tablesByModel.set(derivedModelName, derivedTable);
+    }
+  }
+  return tables;
+}
+__name(discoverTables, "discoverTables");
+function discoverViews(allViews) {
+  const views = [];
+  for (const [exportName, val] of Object.entries(allViews)) {
+    if (!val || typeof val !== "object") continue;
+    const syms = Object.getOwnPropertySymbols(val);
+    if (!syms.some((s) => s.toString().includes("IsDrizzleView"))) continue;
+    const cfg = (0, import_pg_core4.getViewConfig)(val);
+    const sqlName = cfg.name;
+    const modelName = exportName;
+    const typeName = capitalize(exportName);
+    const sqlToJsKey = /* @__PURE__ */ new Map();
+    const columns = /* @__PURE__ */ new Map();
+    for (const [jsKey, col] of Object.entries(cfg.selectedFields)) {
+      const colObj = col;
+      if (colObj.name && colObj.columnType) {
+        sqlToJsKey.set(colObj.name, jsKey);
+        columns.set(jsKey, colObj);
+      }
+    }
+    views.push({
+      exportName,
+      sqlName,
+      modelName,
+      typeName,
+      columns,
+      sqlToJsKey
+    });
+  }
+  return views;
+}
+__name(discoverViews, "discoverViews");
+function extractFKs(table) {
+  const cfg = (0, import_pg_core4.getTableConfig)(table);
+  return cfg.foreignKeys.map((fk) => {
+    const ref = fk.reference();
+    return {
+      name: fk.getName(),
+      localColumns: ref.columns.map((c) => c.name),
+      foreignTable: getDrizzleTableName(ref.foreignTable),
+      foreignColumns: ref.foreignColumns.map((c) => c.name)
+    };
+  });
+}
+__name(extractFKs, "extractFKs");
+
+// src/codegen/relations.ts
+function makePhysicalRelationSignature(fields, references, array) {
+  return [
+    array ? "many" : "one",
+    fields?.join(",") || "",
+    references?.join(",") || ""
+  ].join("|");
+}
+__name(makePhysicalRelationSignature, "makePhysicalRelationSignature");
+function makePhysicalFKSignature(sourceTable, targetTable, fk) {
+  return makePhysicalRelationSignature(fk.localColumns.map((column) => sourceTable.sqlToJsKey.get(column) || column), fk.foreignColumns.map((column) => targetTable.sqlToJsKey.get(column) || column), false);
+}
+__name(makePhysicalFKSignature, "makePhysicalFKSignature");
+function assertNoRelationFieldCollision(table, sourceRelations, fieldName) {
+  if (table.jsKeySet.has(fieldName)) {
+    throw new Error(`Relation "${table.exportName}.${fieldName}" collides with an existing field. Rename the FK key in tables.ts or choose a different relation key in relations.ts.`);
+  }
+  if (sourceRelations.some((relation) => relation.fieldName === fieldName)) {
+    throw new Error(`Relation "${table.exportName}.${fieldName}" collides with another relation field. Use a unique key in relations.ts.`);
+  }
+}
+__name(assertNoRelationFieldCollision, "assertNoRelationFieldCollision");
+function unfoldThroughPath(path, relationNames = []) {
+  const entries = Object.entries(path);
+  if (entries.length !== 1) {
+    throw new Error("Through relation path must contain exactly one relation per level.");
+  }
+  const entry = entries[0];
+  const [relationName, next] = entry;
+  relationNames.push(relationName);
+  if (next === true) {
+    return relationNames;
+  }
+  return unfoldThroughPath(next, relationNames);
+}
+__name(unfoldThroughPath, "unfoldThroughPath");
+function unfoldRelationSelector(relation) {
+  const entries = Object.entries(relation);
+  if (entries.length !== 1) {
+    throw new Error("Filtered relation selector must contain exactly one relation.");
+  }
+  const entry = entries[0];
+  const [relationName, enabled] = entry;
+  if (enabled !== true) {
+    throw new Error("Filtered relation selector values must be true.");
+  }
+  return relationName;
+}
+__name(unfoldRelationSelector, "unfoldRelationSelector");
+function buildRelations(tables, relationTargets = {}, filteredRelations = {}, throughRelations = {}, fkRelations = {}) {
+  const baseTables = tables.filter((table) => !table.derivedFrom);
+  const sqlToBaseTable = /* @__PURE__ */ new Map();
+  const modelToTable = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    modelToTable.set(table.modelName, table);
+    if (!table.derivedFrom) {
+      sqlToBaseTable.set(table.sqlName, table);
+    }
+  }
+  const fksByTable = /* @__PURE__ */ new Map();
+  for (const table of baseTables) {
+    fksByTable.set(table.modelName, extractFKs(table.table));
+  }
+  const modelRelations = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    modelRelations.set(table.modelName, []);
+  }
+  for (const [modelName, relations] of Object.entries(fkRelations)) {
+    const sourceTable = modelToTable.get(modelName);
+    if (!sourceTable) continue;
+    const sourceRelations = modelRelations.get(modelName) || [];
+    const colByName = new Map(sourceTable.cfg.columns.map((column) => [
+      column.name,
+      column
+    ]));
+    for (const [relName, fkInfo] of Object.entries(relations)) {
+      const targetTable = modelToTable.get(fkInfo.targetExportName) ?? sqlToBaseTable.get(fkInfo.targetExportName);
+      if (!targetTable) continue;
+      const targetModelOverride = relationTargets[modelName]?.[relName];
+      const fieldName = relName;
+      assertNoRelationFieldCollision(sourceTable, sourceRelations, fieldName);
+      let hasDefaultFK = false;
+      let isOptional = false;
+      const jsToSql = new Map([
+        ...sourceTable.sqlToJsKey.entries()
+      ].map(([sql4, js]) => [
+        js,
+        sql4
+      ]));
+      for (const jsKey of fkInfo.fields) {
+        const sqlName = jsToSql.get(jsKey) ?? jsKey;
+        const localColumn = colByName.get(sqlName);
+        if (localColumn?.hasDefault) hasDefaultFK = true;
+        if (!localColumn?.notNull) isOptional = true;
+      }
+      sourceRelations.push({
+        fieldName,
+        targetModel: targetModelOverride ?? fkInfo.targetExportName,
+        optional: isOptional,
+        array: false,
+        relationName: fkInfo.relationName,
+        fields: fkInfo.fields,
+        references: fkInfo.references,
+        hasDefault: hasDefaultFK
+      });
+    }
+    modelRelations.set(modelName, sourceRelations);
+  }
+  for (const table of tables) {
+    if (!table.derivedFrom) continue;
+    const baseRelations = modelRelations.get(table.derivedFrom) || [];
+    modelRelations.set(table.modelName, baseRelations.map((relation) => ({
+      ...relation,
+      _opposite: void 0
+    })));
+  }
+  for (const table of baseTables) {
+    const sourceRelations = modelRelations.get(table.modelName) || [];
+    const relationsByTarget = /* @__PURE__ */ new Map();
+    for (const relation of sourceRelations) {
+      if (relation.kind && relation.kind !== "normal") continue;
+      const group = relationsByTarget.get(relation.targetModel) || [];
+      group.push(relation);
+      relationsByTarget.set(relation.targetModel, group);
+    }
+    for (const [targetModel, relations] of relationsByTarget) {
+      if (relations.length <= 1) continue;
+      for (const relation of relations) {
+        if (relation.relationName) continue;
+        throw new Error(`Ambiguous relations for "${table.exportName}" -> "${targetModel}". Add explicit relationName values in supabase/schema/relations.ts.`);
+      }
+    }
+    const declaredFKRelations = new Set(sourceRelations.filter((relation) => !relation.array && relation.fields && relation.references).map((relation) => makePhysicalRelationSignature(relation.fields, relation.references, relation.array)));
+    for (const fk of fksByTable.get(table.modelName) || []) {
+      const targetTable = sqlToBaseTable.get(fk.foreignTable);
+      if (!targetTable) continue;
+      const signature = makePhysicalFKSignature(table, targetTable, fk);
+      if (declaredFKRelations.has(signature)) continue;
+      throw new Error(`Missing explicit relation in supabase/schema/relations.ts for "${table.exportName}": [${fk.localColumns.join(", ")}] -> ${targetTable.exportName}([${fk.foreignColumns.join(", ")}]).`);
+    }
+  }
+  const forwardByTarget = /* @__PURE__ */ new Map();
+  for (const sourceTable of tables) {
+    for (const relation of modelRelations.get(sourceTable.modelName) || []) {
+      if (relation.kind && relation.kind !== "normal") continue;
+      const group = forwardByTarget.get(relation.targetModel) || [];
+      group.push({
+        source: sourceTable,
+        relation
+      });
+      forwardByTarget.set(relation.targetModel, group);
+    }
+  }
+  const inverseRelations = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const inverses = [];
+    const existingNames = new Set((modelRelations.get(table.modelName) || []).map((relation) => relation.fieldName));
+    for (const { source: sourceTable, relation } of forwardByTarget.get(table.modelName) || []) {
+      const sourceExport = sourceTable.exportName || sourceTable.sqlName;
+      let fieldName = sourceExport.endsWith("s") ? sourceExport : sourceExport + "s";
+      if (existingNames.has(fieldName)) {
+        const explicitRelation = (modelRelations.get(table.modelName) || []).find((item) => item.fieldName === fieldName);
+        if (explicitRelation) {
+          relation._opposite = fieldName;
+          continue;
+        }
+        const mainField = relation.fields?.find((field) => field !== APP_SLUG_JS) || relation.fields?.[0] || relation.fieldName;
+        fieldName = sourceExport + "By" + capitalize(mainField);
+      }
+      inverses.push({
+        fieldName,
+        targetModel: sourceTable.modelName,
+        optional: false,
+        array: true,
+        relationName: relation.relationName,
+        fields: null,
+        references: null,
+        hasDefault: false,
+        _opposite: relation.fieldName
+      });
+      relation._opposite = fieldName;
+      existingNames.add(fieldName);
+    }
+    inverseRelations.set(table.modelName, inverses);
+  }
+  const getAvailableRelations = /* @__PURE__ */ __name((modelName) => [
+    ...modelRelations.get(modelName) || [],
+    ...inverseRelations.get(modelName) || []
+  ], "getAvailableRelations");
+  for (const [modelName, declarations] of Object.entries(filteredRelations)) {
+    const sourceTable = modelToTable.get(modelName);
+    if (!sourceTable) {
+      throw new Error(`Filtered relations declared for unknown model "${modelName}".`);
+    }
+    const sourceRelations = modelRelations.get(modelName) || [];
+    const availableRelations = getAvailableRelations(modelName);
+    for (const [fieldName, declaration] of Object.entries(declarations)) {
+      const sourceRelation = unfoldRelationSelector(declaration.relation);
+      const existingFk = sourceRelations.find((r) => r.fieldName === fieldName);
+      if (existingFk && sourceRelation === fieldName) {
+        existingFk.kind = "filtered";
+        existingFk.sourceRelation = sourceRelation;
+        existingFk.where = declaration.where;
+        existingFk.single = declaration.single;
+        continue;
+      }
+      assertNoRelationFieldCollision(sourceTable, [
+        ...sourceRelations,
+        ...inverseRelations.get(modelName) || []
+      ], fieldName);
+      const baseRelation = availableRelations.find((relation) => relation.fieldName === sourceRelation);
+      if (!baseRelation) {
+        throw new Error(`Filtered relation "${modelName}.${fieldName}" references unknown relation "${sourceRelation}".`);
+      }
+      sourceRelations.push({
+        fieldName,
+        targetModel: baseRelation.targetModel,
+        optional: declaration.single ? true : baseRelation.optional,
+        array: declaration.single ? false : baseRelation.array,
+        relationName: null,
+        fields: baseRelation.fields,
+        references: baseRelation.references,
+        hasDefault: false,
+        kind: "filtered",
+        sourceRelation,
+        where: declaration.where,
+        single: declaration.single
+      });
+    }
+    modelRelations.set(modelName, sourceRelations);
+  }
+  for (const [modelName, declarations] of Object.entries(throughRelations)) {
+    const sourceTable = modelToTable.get(modelName);
+    if (!sourceTable) {
+      throw new Error(`Through relations declared for unknown model "${modelName}".`);
+    }
+    const sourceRelations = modelRelations.get(modelName) || [];
+    for (const [fieldName, declaration] of Object.entries(declarations)) {
+      assertNoRelationFieldCollision(sourceTable, [
+        ...sourceRelations,
+        ...inverseRelations.get(modelName) || []
+      ], fieldName);
+      const throughPath = unfoldThroughPath(declaration.path);
+      let currentModel = modelName;
+      let targetRelation;
+      let isMany = false;
+      for (const relationName of throughPath) {
+        const relation = getAvailableRelations(currentModel).find((item) => item.fieldName === relationName);
+        if (!relation) {
+          throw new Error(`Through relation "${modelName}.${fieldName}" references unknown relation "${currentModel}.${relationName}".`);
+        }
+        targetRelation = relation;
+        currentModel = relation.targetModel;
+        if (relation.array) {
+          isMany = true;
+        }
+      }
+      if (!targetRelation) {
+        throw new Error(`Through relation "${modelName}.${fieldName}" is missing a target path.`);
+      }
+      sourceRelations.push({
+        fieldName,
+        targetModel: targetRelation.targetModel,
+        optional: !isMany,
+        array: isMany,
+        relationName: null,
+        fields: null,
+        references: null,
+        hasDefault: false,
+        kind: "through",
+        throughPath
+      });
+    }
+    modelRelations.set(modelName, sourceRelations);
+  }
+  return {
+    modelRelations,
+    inverseRelations
+  };
+}
+__name(buildRelations, "buildRelations");
+
+// src/codegen/typed-json.ts
+var import_casing = require("drizzle-orm/casing");
+var import_ts_morph = require("ts-morph");
+function unwrapNullableType(type) {
+  if (!type.isUnion()) return type;
+  const nonNull = type.getUnionTypes().filter((member) => !member.isNull() && !member.isUndefined());
+  if (nonNull.length !== 1) return type;
+  return unwrapNullableType(nonNull[0]);
+}
+__name(unwrapNullableType, "unwrapNullableType");
+function getResolvedArrayInfo(type) {
+  const resolvedType = unwrapNullableType(type);
+  if (!resolvedType.isArray()) {
+    return {
+      resolvedType,
+      isArray: false
+    };
+  }
+  return {
+    resolvedType: resolvedType.getArrayElementTypeOrThrow(),
+    isArray: true
+  };
+}
+__name(getResolvedArrayInfo, "getResolvedArrayInfo");
+function normalizeTypeText(typeText) {
+  let normalized = typeText.replace(/\s+/g, " ").trim();
+  normalized = normalized.replace(/\s*\|\s*(?:null|undefined)\s*$/g, "").trim();
+  let isArray = false;
+  if (normalized.endsWith("[]")) {
+    normalized = normalized.slice(0, -2).trim();
+    isArray = true;
+  }
+  if (normalized.startsWith("(") && normalized.endsWith(")")) {
+    normalized = normalized.slice(1, -1).trim();
+  }
+  return {
+    baseText: normalized,
+    isArray
+  };
+}
+__name(normalizeTypeText, "normalizeTypeText");
+function buildTypeDefs(typesPath, tables, views, enumMap) {
+  const project = createTypedJsonProject(typesPath, !!views?.length);
+  const sf = project.getSourceFileOrThrow(typesPath);
+  const typeDefs = /* @__PURE__ */ new Map();
+  const fieldToTypeDef = /* @__PURE__ */ new Map();
+  const typedJsonFieldMap = /* @__PURE__ */ new Map();
+  const exportedTypes = createExportedTypeRegistry(sf);
+  const entityBySqlName = /* @__PURE__ */ new Map();
+  for (const table of tables) entityBySqlName.set(table.sqlName, table);
+  for (const view of views || []) entityBySqlName.set(view.sqlName, view);
+  const tableByExportName = new Map(tables.map((table) => [
+    table.exportName,
+    table
+  ]));
+  const sourceFiles = [
+    "supabase/schema/tables.ts"
+  ];
+  if (views?.length) sourceFiles.push("supabase/schema/views.ts");
+  for (const filePath of sourceFiles) {
+    scanFileForTypedColumns({
+      sourceFile: project.getSourceFileOrThrow(filePath),
+      exportedTypes,
+      typeDefs,
+      fieldToTypeDef,
+      typedJsonFieldMap,
+      entityBySqlName,
+      tableByExportName,
+      enumMap: enumMap || /* @__PURE__ */ new Map()
+    });
+  }
+  return {
+    typeDefs,
+    fieldToTypeDef,
+    typedJsonFields: sortTypedJsonFields([
+      ...typedJsonFieldMap.values()
+    ])
+  };
+}
+__name(buildTypeDefs, "buildTypeDefs");
+function createExportedTypeRegistry(sourceFile) {
+  const declarations = /* @__PURE__ */ new Map();
+  const resolvedTypes = /* @__PURE__ */ new Map();
+  for (const stmt of sourceFile.getStatements()) {
+    if (stmt.getKind() === import_ts_morph.SyntaxKind.TypeAliasDeclaration) {
+      const typeAlias = stmt.asKindOrThrow(import_ts_morph.SyntaxKind.TypeAliasDeclaration);
+      if (typeAlias.isExported()) {
+        declarations.set(typeAlias.getName(), typeAlias);
+      }
+    }
+    if (stmt.getKind() === import_ts_morph.SyntaxKind.InterfaceDeclaration) {
+      const iface = stmt.asKindOrThrow(import_ts_morph.SyntaxKind.InterfaceDeclaration);
+      if (iface.isExported()) {
+        declarations.set(iface.getName(), iface);
+      }
+    }
+  }
+  return {
+    has(name) {
+      return declarations.has(name);
+    },
+    get(name) {
+      if (!declarations.has(name)) return void 0;
+      const cachedType = resolvedTypes.get(name);
+      if (cachedType) return cachedType;
+      const declaration = declarations.get(name);
+      if (!declaration) return void 0;
+      const resolvedType = declaration.getType();
+      resolvedTypes.set(name, resolvedType);
+      return resolvedType;
+    }
+  };
+}
+__name(createExportedTypeRegistry, "createExportedTypeRegistry");
+function createTypedJsonProject(typesPath, includeViews) {
+  const project = new import_ts_morph.Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      module: import_ts_morph.ModuleKind.ESNext,
+      moduleResolution: import_ts_morph.ModuleResolutionKind.Bundler,
+      target: import_ts_morph.ScriptTarget.ES2022,
+      allowJs: false,
+      baseUrl: ".",
+      paths: {
+        "@/*": [
+          "src/*"
+        ],
+        "~/*": [
+          "app/*"
+        ]
+      }
+    }
+  });
+  project.addSourceFileAtPath(typesPath);
+  project.addSourceFileAtPath("supabase/schema/tables.ts");
+  if (includeViews) {
+    project.addSourceFileAtPath("supabase/schema/views.ts");
+  }
+  return project;
+}
+__name(createTypedJsonProject, "createTypedJsonProject");
+function scanFileForTypedColumns({ sourceFile, exportedTypes, typeDefs, fieldToTypeDef, typedJsonFieldMap, entityBySqlName, tableByExportName, enumMap }) {
+  const registerTypedJsonField = /* @__PURE__ */ __name((entitySqlName, columnSqlName, typeDefName, isArray, sourceTypeName) => {
+    const entity = entityBySqlName.get(entitySqlName);
+    if (!entity) return;
+    const fieldName = entity.sqlToJsKey.get(columnSqlName) || columnSqlName;
+    const fieldKey = `${entitySqlName}.${fieldName}`;
+    fieldToTypeDef.set(fieldKey, {
+      typeDefName,
+      isArray
+    });
+    typedJsonFieldMap.set(fieldKey, {
+      entitySqlName,
+      entityTypeName: entity.typeName,
+      fieldName,
+      typeDefName,
+      isArray,
+      sourceTypeName
+    });
+  }, "registerTypedJsonField");
+  for (const access of sourceFile.getDescendantsOfKind(import_ts_morph.SyntaxKind.PropertyAccessExpression)) {
+    if (access.getName() !== "$type") continue;
+    const call = access.getParentIfKind(import_ts_morph.SyntaxKind.CallExpression);
+    if (!call || call.getExpression() !== access) continue;
+    const typeArg = call.getTypeArguments()[0];
+    if (!typeArg) continue;
+    const propertyAssignment = call.getFirstAncestorByKind(import_ts_morph.SyntaxKind.PropertyAssignment);
+    if (!propertyAssignment) continue;
+    const columnSqlName = propertyAssignment.getName();
+    const entitySqlName = getEntitySqlName(call);
+    if (!entitySqlName) continue;
+    const rawTypeText = typeArg.getText().trim();
+    const { baseText, isArray: isArrayFromText } = normalizeTypeText(rawTypeText);
+    const rowTypeDefName = resolveWholeRowTypeDefName(baseText, tableByExportName, typeDefs, enumMap);
+    if (rowTypeDefName) {
+      const isArray2 = isArrayFromText || getResolvedArrayInfo(typeArg.getType()).isArray;
+      registerTypedJsonField(entitySqlName, columnSqlName, rowTypeDefName, isArray2);
+      continue;
+    }
+    if (exportedTypes.has(baseText)) {
+      const type = exportedTypes.get(baseText);
+      if (type && tryBuildTypeDef(baseText, type, typeDefs, exportedTypes)) {
+        const isArray2 = isArrayFromText || getResolvedArrayInfo(type).isArray;
+        registerTypedJsonField(entitySqlName, columnSqlName, baseText, isArray2, baseText);
+      }
+      continue;
+    }
+    const { resolvedType, isArray: isArrayFromType } = getResolvedArrayInfo(typeArg.getType());
+    const isArray = isArrayFromType || isArrayFromText;
+    const generatedName = `${toPascalCase(entitySqlName)}${toPascalCase(columnSqlName)}`;
+    if (tryBuildTypeDef(generatedName, resolvedType, typeDefs, exportedTypes)) {
+      registerTypedJsonField(entitySqlName, columnSqlName, generatedName, isArray);
+    }
+  }
+}
+__name(scanFileForTypedColumns, "scanFileForTypedColumns");
+function getEntitySqlName(call) {
+  let node = call.getParent();
+  while (node) {
+    if (node.getKind() === import_ts_morph.SyntaxKind.CallExpression) {
+      const candidate = node.asKindOrThrow(import_ts_morph.SyntaxKind.CallExpression);
+      const callee = candidate.getExpression().getText();
+      if (callee === "pgTable" || callee === "pgView") {
+        const firstArg = candidate.getArguments()[0];
+        return firstArg ? firstArg.getText().replace(/['"]/g, "") : null;
+      }
+    }
+    node = node.getParent();
+  }
+  return null;
+}
+__name(getEntitySqlName, "getEntitySqlName");
+function resolveWholeRowTypeDefName(typeText, tableByExportName, typeDefs, enumMap) {
+  const wholeRowMatch = typeText.match(/^typeof\s+(?:t\.)?(\w+)\.\$infer(?:Select|Insert)$/);
+  if (!wholeRowMatch) return null;
+  const refTable = tableByExportName.get(wholeRowMatch[1]);
+  if (!refTable) return null;
+  const rowTypeDefName = `${refTable.typeName}Row`;
+  if (!typeDefs.has(rowTypeDefName)) {
+    buildRowTypeDef(rowTypeDefName, refTable, typeDefs, enumMap);
+  }
+  return typeDefs.has(rowTypeDefName) ? rowTypeDefName : null;
+}
+__name(resolveWholeRowTypeDefName, "resolveWholeRowTypeDefName");
+function buildRowTypeDef(name, table, typeDefs, enumMap) {
+  const fields = {};
+  for (const jsKey of [
+    ...table.sqlToJsKey.values()
+  ]) {
+    const col = table.table[jsKey];
+    if (!col?.columnType) continue;
+    const mapped = mapColumn(jsKey, col, enumMap);
+    if (mapped.isGenerated) continue;
+    if (mapped.sqlName === "$hash") continue;
+    let type;
+    switch (mapped.type) {
+      case "String":
+      case "Int":
+      case "Float":
+      case "Boolean":
+      case "DateTime":
+      case "Json":
+        type = mapped.type;
+        break;
+      case "BigInt":
+        type = "Int";
+        break;
+      case "Decimal":
+        type = "Float";
+        break;
+      default:
+        type = "String";
+        break;
+    }
+    const fieldName = (0, import_casing.toCamelCase)(mapped.name);
+    fields[fieldName] = {
+      name: fieldName,
+      ...fieldName !== mapped.name && {
+        rawName: mapped.name
+      },
+      type,
+      ...mapped.optional && {
+        optional: true
+      },
+      ...mapped.array && {
+        array: true
+      }
+    };
+  }
+  if (Object.keys(fields).length > 0) {
+    typeDefs.set(name, {
+      name,
+      fields
+    });
+  }
+}
+__name(buildRowTypeDef, "buildRowTypeDef");
+function tryBuildTypeDef(name, type, typeDefs, exportedTypes) {
+  if (typeDefs.has(name)) return true;
+  if (type.isArray()) {
+    return tryBuildTypeDef(name, type.getArrayElementTypeOrThrow(), typeDefs, exportedTypes);
+  }
+  if (type.isUnion()) {
+    const nonNull = type.getUnionTypes().filter((member) => !member.isNull() && !member.isUndefined());
+    if (nonNull.length === 1) {
+      return tryBuildTypeDef(name, nonNull[0], typeDefs, exportedTypes);
+    }
+    return false;
+  }
+  if (!type.isObject() || type.getProperties().length === 0) return false;
+  if (type.getStringIndexType()) return false;
+  if (type.getCallSignatures().length > 0) return false;
+  const fields = {};
+  for (const prop of type.getProperties()) {
+    const propName = prop.getName();
+    const declaration = prop.getValueDeclaration();
+    if (!declaration) continue;
+    const propType = prop.getTypeAtLocation(declaration);
+    const fieldName = (0, import_casing.toCamelCase)(propName);
+    const mappedField = mapTypeToTypeDef(propName, propType, name, typeDefs, exportedTypes);
+    fields[fieldName] = {
+      name: fieldName,
+      ...fieldName !== propName && {
+        rawName: propName
+      },
+      type: mappedField?.type || "Json",
+      ...prop.isOptional() && {
+        optional: true
+      },
+      ...mappedField?.isArray && {
+        array: true
+      }
+    };
+  }
+  if (Object.keys(fields).length === 0) return false;
+  typeDefs.set(name, {
+    name,
+    fields
+  });
+  return true;
+}
+__name(tryBuildTypeDef, "tryBuildTypeDef");
+function mapTypeToTypeDef(fieldName, type, parentName, typeDefs, exportedTypes) {
+  if (type.isUnion()) {
+    const unwrapped = unwrapNullableType(type);
+    if (unwrapped !== type) {
+      return mapTypeToTypeDef(fieldName, unwrapped, parentName, typeDefs, exportedTypes);
+    }
+    const nonNull = type.getUnionTypes().filter((member) => !member.isNull() && !member.isUndefined());
+    if (nonNull.every((member) => member.isStringLiteral() || member.isString())) {
+      return {
+        type: "String",
+        isArray: false
+      };
+    }
+    if (nonNull.every((member) => member.isNumberLiteral() || member.isNumber())) {
+      return {
+        type: "Float",
+        isArray: false
+      };
+    }
+    if (nonNull.every((member) => member.isBooleanLiteral() || member.isBoolean())) {
+      return {
+        type: "Boolean",
+        isArray: false
+      };
+    }
+    return null;
+  }
+  if (type.isString() || type.isStringLiteral()) return {
+    type: "String",
+    isArray: false
+  };
+  if (type.isNumber() || type.isNumberLiteral()) return {
+    type: "Float",
+    isArray: false
+  };
+  if (type.isBoolean() || type.isBooleanLiteral()) return {
+    type: "Boolean",
+    isArray: false
+  };
+  if (type.getSymbol()?.getName() === "Date") return {
+    type: "DateTime",
+    isArray: false
+  };
+  if (type.isArray()) {
+    const inner = mapTypeToTypeDef(fieldName, type.getArrayElementTypeOrThrow(), parentName, typeDefs, exportedTypes);
+    return inner ? {
+      type: inner.type,
+      isArray: true
+    } : null;
+  }
+  if (type.isObject() && type.getProperties().length > 0) {
+    if (type.getStringIndexType()) return {
+      type: "Json",
+      isArray: false
+    };
+    if (type.getCallSignatures().length > 0) return null;
+    const symbol = type.getAliasSymbol() || type.getSymbol();
+    const knownName = symbol?.getName();
+    if (knownName && exportedTypes.has(knownName)) {
+      if (tryBuildTypeDef(knownName, type, typeDefs, exportedTypes)) {
+        return {
+          type: knownName,
+          isArray: false
+        };
+      }
+    }
+    const subTypeDefName = `${parentName}${toPascalCase(fieldName)}`;
+    if (tryBuildTypeDef(subTypeDefName, type, typeDefs, exportedTypes)) {
+      return {
+        type: subTypeDefName,
+        isArray: false
+      };
+    }
+  }
+  return null;
+}
+__name(mapTypeToTypeDef, "mapTypeToTypeDef");
+function emitTypeDefsBlock(typeDefs) {
+  if (typeDefs.size === 0) return "";
+  const lines = [];
+  lines.push("    typeDefs = {");
+  for (const [name, typeDef] of sortTypeDefs(typeDefs)) {
+    lines.push(`        ${name}: {`);
+    lines.push(`            name: ${esc(typeDef.name)},`);
+    lines.push(`            fields: {`);
+    for (const field of Object.values(typeDef.fields)) {
+      const parts = [
+        `name: ${esc(field.name)}`,
+        `type: ${esc(field.type)}`
+      ];
+      if (field.optional) parts.push("optional: true");
+      if (field.array) parts.push("array: true");
+      if (field.rawName && field.rawName !== field.name) {
+        parts.push(`attributes: [{ name: "@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(field.rawName)}) }] }]`);
+      }
+      lines.push(`                ${field.name}: { ${parts.join(", ")} },`);
+    }
+    lines.push("            }");
+    lines.push("        },");
+  }
+  lines.push("    } as const;");
+  return lines.join("\n");
+}
+__name(emitTypeDefsBlock, "emitTypeDefsBlock");
+function mapTypeDefFieldToTs(field, typeDefs) {
+  let tsType;
+  switch (field.type) {
+    case "String":
+      tsType = "string";
+      break;
+    case "Int":
+    case "Float":
+      tsType = "number";
+      break;
+    case "Boolean":
+      tsType = "boolean";
+      break;
+    case "DateTime":
+      tsType = "Date";
+      break;
+    case "Json":
+      tsType = "unknown";
+      break;
+    default:
+      tsType = typeDefs.has(field.type) ? `${field.type}JsonShape` : "unknown";
+      break;
+  }
+  return field.array ? `${tsType}[]` : tsType;
+}
+__name(mapTypeDefFieldToTs, "mapTypeDefFieldToTs");
+function getJsonFieldAlias(info) {
+  return `${info.entityTypeName}${toPascalCase(info.fieldName)}Json`;
+}
+__name(getJsonFieldAlias, "getJsonFieldAlias");
+function getJsonRawFieldAlias(info) {
+  return `${getJsonFieldAlias(info)}Raw`;
+}
+__name(getJsonRawFieldAlias, "getJsonRawFieldAlias");
+function emitJsonNamespaceBlock(typeDefs, typedJsonFields, indent2 = "") {
+  const out = [];
+  for (const [name, typeDef] of sortTypeDefs(typeDefs)) {
+    out.push(`${indent2}export type ${name}JsonShape = {`);
+    for (const field of Object.values(typeDef.fields)) {
+      const optional = field.optional ? "?" : "";
+      out.push(`${indent2}  ${field.name}${optional}: ${mapTypeDefFieldToTs(field, typeDefs)};`);
+    }
+    out.push(`${indent2}};`);
+    out.push("");
+  }
+  for (const info of typedJsonFields) {
+    out.push(`${indent2}export type ${getJsonFieldAlias(info)} = ${info.typeDefName}JsonShape;`);
+    out.push("");
+  }
+  if (out.at(-1) === "") {
+    out.pop();
+  }
+  return out;
+}
+__name(emitJsonNamespaceBlock, "emitJsonNamespaceBlock");
+function emitJsonRawNamespaceBlock(typedJsonFields, indent2 = "") {
+  const out = [];
+  for (const info of typedJsonFields.filter((field) => field.sourceTypeName)) {
+    out.push(`${indent2}export type ${getJsonRawFieldAlias(info)} = RawJson.${info.sourceTypeName};`);
+    out.push("");
+  }
+  if (out.at(-1) === "") {
+    out.pop();
+  }
+  return out;
+}
+__name(emitJsonRawNamespaceBlock, "emitJsonRawNamespaceBlock");
+function emitJsonTs(typeDefs, typedJsonFields) {
+  const out = [
+    ...emitGeneratedFileBanner(),
+    ""
+  ];
+  out.push(...emitJsonNamespaceBlock(typeDefs, typedJsonFields));
+  out.push("");
+  return out.join("\n");
+}
+__name(emitJsonTs, "emitJsonTs");
+function emitJsonRawTs(typedJsonFields) {
+  const out = [
+    ...emitGeneratedFileBanner(),
+    "",
+    'import type * as RawJson from "../../supabase/schema/types";',
+    ""
+  ];
+  out.push(...emitJsonRawNamespaceBlock(typedJsonFields));
+  out.push("");
+  return out.join("\n");
+}
+__name(emitJsonRawTs, "emitJsonRawTs");
+function sortTypeDefs(typeDefs) {
+  return [
+    ...typeDefs.entries()
+  ].sort(([left], [right]) => left.localeCompare(right));
+}
+__name(sortTypeDefs, "sortTypeDefs");
+function sortTypedJsonFields(typedJsonFields) {
+  return [
+    ...typedJsonFields
+  ].sort((left, right) => {
+    const leftKey = `${getJsonFieldAlias(left)}:${left.sourceTypeName || ""}`;
+    const rightKey = `${getJsonFieldAlias(right)}:${right.sourceTypeName || ""}`;
+    return leftKey.localeCompare(rightKey);
+  });
+}
+__name(sortTypedJsonFields, "sortTypedJsonFields");
+
+// src/codegen/emit.ts
+var DB_ATTR_RE = /@db\.(\w+)(?:\((\d+)\))?/;
+function buildDerivedEnumName(modelName, fieldName) {
+  return `${toPascalCase(modelName)}${toPascalCase(fieldName)}`;
+}
+__name(buildDerivedEnumName, "buildDerivedEnumName");
+function inferFieldIsNonNull(defaultWhere, fieldName) {
+  if (!defaultWhere) return false;
+  const condition = defaultWhere[fieldName];
+  if (condition === void 0 || condition === null) return false;
+  if (Array.isArray(condition)) return condition.length > 0;
+  if (typeof condition !== "object") return true;
+  if (Object.prototype.hasOwnProperty.call(condition, "not") && Reflect.get(condition, "not") === null) {
+    return true;
+  }
+  if (Object.prototype.hasOwnProperty.call(condition, "in")) {
+    const values = Reflect.get(condition, "in");
+    return Array.isArray(values) && values.length > 0;
+  }
+  return false;
+}
+__name(inferFieldIsNonNull, "inferFieldIsNonNull");
+function applyDerivedFieldOverrides(field, table) {
+  if (!table.derivedFrom) return field;
+  const narrowedValues = table.narrow?.[field.name];
+  return {
+    ...field,
+    // Keep base enum type — narrowing is handled at runtime by derived-models plugin
+    optional: narrowedValues && narrowedValues.length > 0 ? false : field.optional && !inferFieldIsNonNull(table.defaultWhere, field.name)
+  };
+}
+__name(applyDerivedFieldOverrides, "applyDerivedFieldOverrides");
+function collectDerivedEnums(tables, enumMap) {
+  const derivedEnums = /* @__PURE__ */ new Map();
+  const tablesByModel = new Map(tables.map((table) => [
+    table.modelName,
+    table
+  ]));
+  for (const table of tables) {
+    if (!table.derivedFrom || !table.narrow) continue;
+    const baseTable = tablesByModel.get(table.derivedFrom);
+    if (!baseTable) continue;
+    const baseFields = /* @__PURE__ */ new Map();
+    for (const jsKey of baseTable.sqlToJsKey.values()) {
+      const column = baseTable.table[jsKey];
+      const field = mapColumn(jsKey, column, enumMap);
+      baseFields.set(field.name === "$hash" ? "hash" : field.name, field);
+    }
+    for (const [fieldName, narrowedValues] of Object.entries(table.narrow)) {
+      if (!narrowedValues.length) continue;
+      const baseField = baseFields.get(fieldName);
+      if (!baseField) {
+        throw new Error(`Unknown narrowed field "${table.modelName}.${fieldName}".`);
+      }
+      const baseEnum = [
+        ...enumMap.values()
+      ].find((info) => info.zenstackName === baseField.type);
+      if (!baseEnum) {
+        continue;
+      }
+      const values = narrowedValues.map((value) => String(value));
+      for (const value of values) {
+        if (!baseEnum.values.includes(value)) {
+          throw new Error(`Invalid narrowed enum value "${value}" for "${table.modelName}.${fieldName}".`);
+        }
+      }
+      const enumName = buildDerivedEnumName(table.modelName, fieldName);
+      if (derivedEnums.has(enumName)) continue;
+      const mapping = baseEnum.mapping ? Object.fromEntries(Object.entries(baseEnum.mapping).filter(([, value]) => values.includes(value))) : Object.fromEntries(values.map((value) => [
+        toPascalCase(value).toUpperCase(),
+        value
+      ]));
+      derivedEnums.set(enumName, {
+        pgName: `$derived:${enumName}`,
+        zenstackName: enumName,
+        values,
+        mapping,
+        mappedName: null
+      });
+    }
+  }
+  return derivedEnums;
+}
+__name(collectDerivedEnums, "collectDerivedEnums");
+function emitEnumBlock(info) {
+  const lines = [];
+  lines.push(`        ${info.zenstackName}: {`);
+  lines.push(`            name: ${esc(info.zenstackName)},`);
+  const tuples = info.mapping ? (() => {
+    const invertedMap = Object.fromEntries(Object.entries(info.mapping).map(([k, v]) => [
+      v,
+      k
+    ]));
+    return info.values.map((v) => {
+      const key = invertedMap[v];
+      if (!key) throw new Error(`Enum "${info.pgName}" value "${v}" not found in mapping.`);
+      return [
+        v,
+        key
+      ];
+    });
+  })() : info.values.map((v) => [
+    v,
+    v
+  ]);
+  const valuesEntries = tuples.map(([value]) => `${esc(value)}: ${esc(value)}`);
+  lines.push(`            values: { ${valuesEntries.join(", ")} },`);
+  lines.push(`            fields: {`);
+  for (const [v] of tuples) {
+    lines.push(`                ${esc(v)}: { name: ${esc(v)} },`);
+  }
+  lines.push(`            },`);
+  const mappedName = info.mappedName === void 0 ? info.pgName : info.mappedName;
+  if (mappedName) {
+    lines.push(`            attributes: [{ name: "@@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(mappedName)}) }] }]`);
+  }
+  lines.push(`        }`);
+  return lines.join("\n");
+}
+__name(emitEnumBlock, "emitEnumBlock");
+function emitFieldBlock(field) {
+  const parts = [];
+  parts.push(`name: ${esc(field.name)}`);
+  parts.push(`type: ${esc(field.type)}`);
+  if (field.optional) parts.push("optional: true");
+  if (field.array) parts.push("array: true");
+  if (field.id) parts.push("id: true");
+  if (field.unique) parts.push("unique: true");
+  const attrs = [];
+  if (field.id) attrs.push('{ name: "@id" }');
+  if (field.unique) attrs.push('{ name: "@unique" }');
+  if (field.name !== field.sqlName) {
+    attrs.push(`{ name: "@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(field.sqlName)}) }] }`);
+  }
+  for (const da of field.dbAttrs) {
+    const match = da.match(DB_ATTR_RE);
+    if (match) {
+      const [, attrName, arg] = match;
+      if (arg) {
+        attrs.push(`{ name: "@db.${attrName}", args: [{ name: "x", value: ExpressionUtils.literal(${arg}) }] }`);
+      } else {
+        attrs.push(`{ name: "@db.${attrName}" }`);
+      }
+    }
+  }
+  if (field.defaultExpr) {
+    const attrValue = field.defaultExpr === "[] as FieldDefault" ? 'ExpressionUtils.literal("[]")' : field.defaultExpr;
+    attrs.push(`{ name: "@default", args: [{ name: "value", value: ${attrValue} }] }`);
+  }
+  if (field.isGenerated) {
+    attrs.push('{ name: "@ignore" }');
+  }
+  if (field.isJsonColumn && field.type !== "Json") {
+    attrs.push('{ name: "@json" }');
+  }
+  if (attrs.length > 0) {
+    parts.push(`attributes: [${attrs.join(", ")}]`);
+  }
+  if (field.defaultExpr) {
+    if (field.defaultExpr.startsWith("ExpressionUtils.literal(")) {
+      const inner = field.defaultExpr.slice("ExpressionUtils.literal(".length, -1);
+      parts.push(`default: ${inner}`);
+    } else {
+      parts.push(`default: ${field.defaultExpr}`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+__name(emitFieldBlock, "emitFieldBlock");
+function emitRelationField(rel, opposite) {
+  const parts = [];
+  parts.push(`name: ${esc(rel.fieldName)}`);
+  parts.push(`type: ${esc(rel.targetModel)}`);
+  if (rel.optional) parts.push("optional: true");
+  if (rel.array) parts.push("array: true");
+  const relParts = [];
+  if (opposite) relParts.push(`opposite: ${esc(opposite)}`);
+  if (rel.relationName) relParts.push(`name: ${esc(rel.relationName)}`);
+  if (rel.fields) relParts.push(`fields: [${rel.fields.map((f) => esc(f)).join(", ")}]`);
+  if (rel.references) relParts.push(`references: [${rel.references.map((r) => esc(r)).join(", ")}]`);
+  if (rel.hasDefault) relParts.push("hasDefault: true");
+  parts.push(`relation: { ${relParts.join(", ")} }`);
+  const attrArgs = [];
+  if (rel.relationName) {
+    attrArgs.push(`{ name: "name", value: ExpressionUtils.literal(${esc(rel.relationName)}) }`);
+  }
+  if (rel.fields) {
+    attrArgs.push(`{ name: "fields", value: ExpressionUtils.array("String", [${rel.fields.map((f) => `ExpressionUtils.field(${esc(f)})`).join(", ")}]) }`);
+  }
+  if (rel.references) {
+    attrArgs.push(`{ name: "references", value: ExpressionUtils.array("String", [${rel.references.map((r) => `ExpressionUtils.field(${esc(r)})`).join(", ")}]) }`);
+  }
+  if (attrArgs.length > 0) {
+    parts.push(`attributes: [{ name: "@relation", args: [${attrArgs.join(", ")}] }]`);
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+__name(emitRelationField, "emitRelationField");
+function emitUnknownLiteral(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return esc(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => emitUnknownLiteral(item)).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    return `{ ${Object.entries(value).map(([key, item]) => `${JSON.stringify(key)}: ${emitUnknownLiteral(item)}`).join(", ")} }`;
+  }
+  throw new Error(`Unsupported config literal: ${String(value)}`);
+}
+__name(emitUnknownLiteral, "emitUnknownLiteral");
+function emitPluginsBlock(modelRelations, searchDefaults, modelScopes) {
+  const lines = [];
+  lines.push("    plugins = {");
+  lines.push("        virtualRelations: {");
+  for (const [model2, relations] of modelRelations) {
+    const virtualRelations = relations.filter((relation) => relation.kind && relation.kind !== "normal");
+    if (virtualRelations.length === 0) continue;
+    lines.push(`            ${model2}: {`);
+    for (const relation of virtualRelations) {
+      const parts = [
+        `kind: ${esc(relation.kind)}`,
+        `targetModel: ${esc(relation.targetModel)}`
+      ];
+      if (relation.sourceRelation) {
+        parts.push(`relation: ${esc(relation.sourceRelation)}`);
+      }
+      if (relation.throughPath) {
+        parts.push(`path: [${relation.throughPath.map((segment) => esc(segment)).join(", ")}]`);
+      }
+      if (relation.where) {
+        parts.push(`where: ${emitUnknownLiteral(relation.where)}`);
+      }
+      if (relation.single) {
+        parts.push("single: true");
+      }
+      lines.push(`                ${relation.fieldName}: { ${parts.join(", ")} },`);
+    }
+    lines.push("            },");
+  }
+  lines.push("        },");
+  lines.push("        searchDefaults: {");
+  for (const [model2, profiles] of Object.entries(searchDefaults)) {
+    if (!profiles) continue;
+    lines.push(`            ${model2}: {`);
+    for (const [profile, declaration] of Object.entries(profiles)) {
+      const parts = [
+        `fields: ${emitUnknownLiteral(declaration.fields)}`
+      ];
+      if (declaration.mode) {
+        parts.push(`mode: ${esc(declaration.mode)}`);
+      }
+      if (declaration.strategy) {
+        parts.push(`strategy: ${esc(declaration.strategy)}`);
+      }
+      lines.push(`                ${profile}: { ${parts.join(", ")} },`);
+    }
+    lines.push("            },");
+  }
+  lines.push("        },");
+  if (Object.keys(modelScopes).length > 0) {
+    lines.push("        modelScopes: {");
+    for (const [scopeModel, where] of Object.entries(modelScopes)) {
+      lines.push(`            ${scopeModel}: ${emitUnknownLiteral(where)},`);
+    }
+    lines.push("        },");
+  }
+  lines.push("    } as const;");
+  return lines.join("\n");
+}
+__name(emitPluginsBlock, "emitPluginsBlock");
+function applyTypeDefOverride(field, fieldMapping) {
+  if (!fieldMapping) return field;
+  return {
+    ...field,
+    type: fieldMapping.typeDefName,
+    array: fieldMapping.isArray || field.array,
+    dbAttrs: field.dbAttrs.filter((attr) => !attr.startsWith("@db.Json"))
+  };
+}
+__name(applyTypeDefOverride, "applyTypeDefOverride");
+function emitModelBlock(t, enumMap, modelRelations, inverseRelations, fieldToTypeDef) {
+  const out = [];
+  const { cfg } = t;
+  const fields = [];
+  const fieldByName = /* @__PURE__ */ new Map();
+  for (const jsKey of [
+    ...t.sqlToJsKey.values()
+  ]) {
+    const col = t.table[jsKey];
+    const field = mapColumn(jsKey, col, enumMap);
+    if (field.sqlName === "$hash") {
+      field.isGenerated = true;
+      field.name = "hash";
+    }
+    const typedField = applyDerivedFieldOverrides(applyTypeDefOverride(field, fieldToTypeDef?.get(`${t.sqlName}.${jsKey}`)), t);
+    fields.push(typedField);
+    fieldByName.set(typedField.name, typedField);
+  }
+  const fkRels = modelRelations.get(t.modelName) || [];
+  const fkFieldMap = /* @__PURE__ */ new Map();
+  for (const rel of fkRels) {
+    if (rel.fields) {
+      for (const f of rel.fields) {
+        if (!fkFieldMap.has(f)) fkFieldMap.set(f, []);
+        fkFieldMap.get(f).push(rel.fieldName);
+      }
+    }
+  }
+  out.push(`        ${t.modelName}: {`);
+  out.push(`            name: ${esc(t.modelName)},`);
+  out.push(`            fields: {`);
+  for (const field of fields) {
+    const fkFor = fkFieldMap.get(field.name);
+    let block = emitFieldBlock(field);
+    if (fkFor) {
+      block = block.slice(0, -2) + `, foreignKeyFor: [${fkFor.map((f) => esc(f)).join(", ")}] }`;
+    }
+    out.push(`                ${field.name}: ${block},`);
+  }
+  for (const rel of fkRels) {
+    const isVirtualOnly = rel.kind === "through" || rel.kind === "filtered" && !rel.fields;
+    const opposite = isVirtualOnly ? "" : rel._opposite || rel.fieldName;
+    const block = emitRelationField(rel, opposite);
+    out.push(`                ${rel.fieldName}: ${block},`);
+  }
+  const invRels = inverseRelations.get(t.modelName) || [];
+  for (const rel of invRels) {
+    const opposite = rel._opposite || rel.fieldName;
+    const block = emitRelationField(rel, opposite);
+    out.push(`                ${rel.fieldName}: ${block},`);
+  }
+  for (const computedField of t.computedFields) {
+    out.push(`                ${computedField.name}: { name: ${esc(computedField.name)}, type: ${esc(computedField.type)}, computed: true, attributes: [{ name: "@computed" }] },`);
+  }
+  out.push(`            },`);
+  if (t.computedFields.length > 0) {
+    out.push(`            computedFields: {`);
+    for (const computedField of t.computedFields) {
+      out.push(`                ${computedField.name}(_context: { modelAlias: ${esc(t.modelName)} }): ${computedField.tsType} { throw new Error("computed stub"); },`);
+    }
+    out.push(`            },`);
+  }
+  const modelAttrs = [];
+  modelAttrs.push(`{ name: "@@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(t.sqlName)}) }] }`);
+  for (const uc of cfg.uniqueConstraints) {
+    const ucCols = uc.columns.map((c) => c.name);
+    if (ucCols.length > 1) {
+      modelAttrs.push(`{ name: "@@unique", args: [{ name: "fields", value: ExpressionUtils.array("String", [${ucCols.map((c) => `ExpressionUtils.field(${esc(t.sqlToJsKey.get(c) || c)})`).join(", ")}]) }] }`);
+    }
+  }
+  if (cfg.primaryKeys.length > 0) {
+    for (const pk of cfg.primaryKeys) {
+      const pkCols = pk.columns.map((c) => c.name);
+      modelAttrs.push(`{ name: "@@id", args: [{ name: "fields", value: ExpressionUtils.array("String", [${pkCols.map((c) => `ExpressionUtils.field(${esc(t.sqlToJsKey.get(c) || c)})`).join(", ")}]) }] }`);
+    }
+  }
+  out.push(`            attributes: [${modelAttrs.join(", ")}],`);
+  const idCols = cfg.columns.filter((c) => c.primary).map((c) => t.sqlToJsKey.get(c.name) || c.name);
+  if (idCols.length === 0 && cfg.primaryKeys.length > 0) {
+    const pkCols = cfg.primaryKeys[0].columns.map((c) => t.sqlToJsKey.get(c.name) || c.name);
+    out.push(`            idFields: [${pkCols.map((c) => esc(c)).join(", ")}],`);
+  } else {
+    out.push(`            idFields: [${idCols.map((c) => esc(c)).join(", ")}],`);
+  }
+  const ufEntries = [];
+  const ufKeys = /* @__PURE__ */ new Set();
+  const addUnique = /* @__PURE__ */ __name((cols) => {
+    const key = cols.join("_");
+    if (ufKeys.has(key)) return;
+    ufKeys.add(key);
+    if (cols.length === 1) {
+      ufEntries.push(`${key}: { type: ${esc(fieldByName.get(key)?.type || "String")} }`);
+    } else {
+      const inner = cols.map((c) => `${c}: { type: ${esc(fieldByName.get(c)?.type || "String")} }`).join(", ");
+      ufEntries.push(`${key}: { ${inner} }`);
+    }
+  }, "addUnique");
+  if (idCols.length > 0) {
+    addUnique(idCols);
+  } else if (cfg.primaryKeys.length > 0) {
+    const pkCols = cfg.primaryKeys[0].columns.map((c) => t.sqlToJsKey.get(c.name) || c.name);
+    addUnique(pkCols);
+  }
+  for (const uc of cfg.uniqueConstraints) {
+    addUnique(uc.columns.map((c) => t.sqlToJsKey.get(c.name) || c.name));
+  }
+  for (const f of fields) {
+    if (f.unique) addUnique([
+      f.name
+    ]);
+  }
+  out.push(`            uniqueFields: { ${ufEntries.join(", ")} }`);
+  out.push(`        },`);
+  return out;
+}
+__name(emitModelBlock, "emitModelBlock");
+function emitViewModelBlock(v, enumMap, fieldToTypeDef) {
+  const out = [];
+  const fields = [];
+  const fieldByName = /* @__PURE__ */ new Map();
+  for (const [jsKey, col] of v.columns) {
+    const field = mapColumn(jsKey, col, enumMap);
+    if (field.sqlName === "$hash") {
+      field.isGenerated = true;
+      field.name = "hash";
+    }
+    const typedField = applyTypeDefOverride(field, fieldToTypeDef?.get(`${v.sqlName}.${jsKey}`));
+    fields.push(typedField);
+    fieldByName.set(typedField.name, typedField);
+  }
+  out.push(`        ${v.modelName}: {`);
+  out.push(`            name: ${esc(v.modelName)},`);
+  out.push(`            isView: true,`);
+  out.push(`            fields: {`);
+  for (const field of fields) {
+    const block = emitFieldBlock(field);
+    out.push(`                ${field.name}: ${block},`);
+  }
+  out.push(`            },`);
+  const modelAttrs = [];
+  modelAttrs.push(`{ name: "@@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(v.sqlName)}) }] }`);
+  out.push(`            attributes: [${modelAttrs.join(", ")}],`);
+  const idCols = [];
+  for (const [jsKey, col] of v.columns) {
+    if (col.primary) {
+      const name = jsKey === "$hash" ? "hash" : jsKey;
+      idCols.push(name);
+    }
+  }
+  if (idCols.length === 0 && fields.length > 0) {
+    idCols.push(fields[0].name);
+  }
+  out.push(`            idFields: [${idCols.map((c) => esc(c)).join(", ")}],`);
+  const ufEntries = [];
+  if (idCols.length > 0) {
+    const key = idCols.join("_");
+    if (idCols.length === 1) {
+      ufEntries.push(`${key}: { type: ${esc(fieldByName.get(key)?.type || "String")} }`);
+    } else {
+      const inner = idCols.map((c) => `${c}: { type: ${esc(fieldByName.get(c)?.type || "String")} }`).join(", ");
+      ufEntries.push(`${key}: { ${inner} }`);
+    }
+  }
+  for (const f of fields) {
+    if (f.unique && !idCols.includes(f.name)) {
+      const key = f.name;
+      ufEntries.push(`${key}: { type: ${esc(f.type)} }`);
+    }
+  }
+  out.push(`            uniqueFields: { ${ufEntries.join(", ")} }`);
+  out.push(`        },`);
+  return out;
+}
+__name(emitViewModelBlock, "emitViewModelBlock");
+function emitSchemaTs({ tables, enumMap, modelRelations, inverseRelations, searchDefaults, modelScopes, typeDefs, fieldToTypeDef, views }) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  const allEnums = new Map([
+    ...enumMap,
+    ...collectDerivedEnums(tables, enumMap)
+  ]);
+  const hasJsonComputedField = tables.some((table) => table.computedFields.some((field) => field.tsType === "JsonValue"));
+  out.push("");
+  out.push('import { ExpressionUtils, type FieldDefault, type SchemaDef } from "@zenstackhq/schema";');
+  if (hasJsonComputedField) {
+    out.push('import type { JsonValue } from "@zenstackhq/orm";');
+  }
+  out.push("export class SchemaType implements SchemaDef {");
+  out.push('    provider = { type: "postgresql" } as const;');
+  out.push("    models = {");
+  for (const t of tables) {
+    out.push(...emitModelBlock(t, enumMap, modelRelations, inverseRelations, fieldToTypeDef));
+  }
+  if (views) {
+    for (const v of views) {
+      out.push(...emitViewModelBlock(v, enumMap, fieldToTypeDef));
+    }
+  }
+  out.push("    } as const;");
+  if (typeDefs && typeDefs.size > 0) {
+    out.push(emitTypeDefsBlock(typeDefs));
+  }
+  out.push("    enums = {");
+  for (const [, info] of allEnums) {
+    out.push(emitEnumBlock(info) + ",");
+  }
+  out.push("    } as const;");
+  out.push(emitPluginsBlock(modelRelations, searchDefaults, modelScopes ?? {}));
+  out.push("}");
+  out.push("");
+  out.push("export const schema = new SchemaType();");
+  out.push("");
+  return out.join("\n");
+}
+__name(emitSchemaTs, "emitSchemaTs");
+function emitModelsTs(tables, typedJsonFields = []) {
+  const jsonFieldAliases = createJsonFieldAliasMap(typedJsonFields);
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type * as Json from "./json";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  for (const t of tables) {
+    out.push(`export interface ${t.typeName} extends $.ModelResult<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`export namespace ${t.typeName} {`);
+    for (const fieldName of getEntityFieldNames(t)) {
+      const exportName = toPascalCase(fieldName);
+      const jsonAlias = jsonFieldAliases.get(`${t.typeName}.${fieldName}`);
+      if (jsonAlias) {
+        out.push(`  export interface ${exportName} extends Json.${jsonAlias} {}`);
+      } else {
+        out.push(`  export type ${exportName} = ${t.typeName}[${esc(fieldName)}];`);
+      }
+    }
+    out.push("}");
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitModelsTs, "emitModelsTs");
+function emitViewsTs(views, typedJsonFields = []) {
+  const jsonFieldAliases = createJsonFieldAliasMap(typedJsonFields);
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type * as Json from "./json";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  for (const v of views) {
+    out.push(`export interface ${v.typeName} extends $.ModelResult<Schema, ${esc(v.modelName)}> {}`);
+    out.push(`export namespace ${v.typeName} {`);
+    for (const fieldName of getEntityFieldNames(v)) {
+      const exportName = toPascalCase(fieldName);
+      const jsonAlias = jsonFieldAliases.get(`${v.typeName}.${fieldName}`);
+      if (jsonAlias) {
+        out.push(`  export interface ${exportName} extends Json.${jsonAlias} {}`);
+      } else {
+        out.push(`  export type ${exportName} = ${v.typeName}[${esc(fieldName)}];`);
+      }
+    }
+    out.push("}");
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitViewsTs, "emitViewsTs");
+function emitInputTs(tables) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  for (const t of tables) {
+    out.push(`export namespace ${t.typeName} {`);
+    out.push(`  export interface FindManyArgs extends $.FindManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface FindUniqueArgs extends $.FindUniqueArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface FindFirstArgs extends $.FindFirstArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface ExistsArgs extends $.ExistsArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CreateArgs extends $.CreateArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CreateManyArgs extends $.CreateManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CreateManyAndReturnArgs extends $.CreateManyAndReturnArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpdateArgs extends $.UpdateArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpdateManyArgs extends $.UpdateManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpdateManyAndReturnArgs extends $.UpdateManyAndReturnArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpsertArgs extends $.UpsertArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface DeleteArgs extends $.DeleteArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface DeleteManyArgs extends $.DeleteManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CountArgs extends $.CountArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface AggregateArgs extends $.AggregateArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface GroupByArgs extends $.GroupByArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface WhereInput extends $.WhereInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface Select extends $.SelectInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface Include extends $.IncludeInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface Omit extends $.OmitInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export type GetPayload<Args extends $.SelectIncludeOmit<Schema, ${esc(t.modelName)}, true>, Options extends $.QueryOptions<Schema> = $.QueryOptions<Schema>> = $.SimplifiedPlainResult<Schema, ${esc(t.modelName)}, Args, Options>;`);
+    out.push("}");
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitInputTs, "emitInputTs");
+function emitIndexTs({ tables, views, enumMap, typeDefs, typedJsonFields }) {
+  const allEnums = new Map([
+    ...enumMap,
+    ...collectDerivedEnums(tables, enumMap)
+  ]);
+  const jsonFieldAliases = createJsonFieldAliasMap(typedJsonFields);
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type * as RawJson from "../../supabase/schema/types";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  out.push("export namespace Json {");
+  out.push(...emitJsonNamespaceBlock(typeDefs, typedJsonFields, "  "));
+  out.push("}");
+  out.push("");
+  out.push("export namespace JsonRaw {");
+  const jsonRawLines = emitJsonRawNamespaceBlock(typedJsonFields, "  ");
+  if (jsonRawLines.length > 0) {
+    out.push(...jsonRawLines);
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Table {");
+  for (const table of tables) {
+    out.push(...emitEntityNamespaceBlock(table, table.modelName, jsonFieldAliases, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace View {");
+  for (const view of views) {
+    out.push(...emitEntityNamespaceBlock(view, view.modelName, jsonFieldAliases, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Input {");
+  for (const table of tables) {
+    out.push(...emitInputNamespaceBlock(table, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace ComputedFields {");
+  out.push("  export type All = $.ComputedFieldsOptions<Schema>;");
+  for (const table of tables) {
+    if (table.computedFields.length === 0) continue;
+    out.push(`  export type ${table.typeName} = $.ComputedFieldsOptions<Schema>[${esc(table.modelName)}];`);
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Enum {");
+  for (const [, info] of allEnums) {
+    out.push(...emitEnumNamespaceBlock(info, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  return out.join("\n");
+}
+__name(emitIndexTs, "emitIndexTs");
+function emitCompatTs({ tables, views, enumMap, typedJsonFields }) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  const jsonAliases = typedJsonFields.map((field) => `${field.entityTypeName}${toPascalCase(field.fieldName)}Json`);
+  const jsonRawAliases = typedJsonFields.filter((field) => field.sourceTypeName).map((field) => `${field.entityTypeName}${toPascalCase(field.fieldName)}JsonRaw`);
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import * as Db from "./index";');
+  out.push('import type { SchemaType as Schema } from "./schema";');
+  out.push("");
+  out.push("export namespace Models {");
+  for (const table of tables) {
+    out.push(...emitCompatEntityAlias(table, "Table", "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Views {");
+  for (const view of views) {
+    out.push(...emitCompatEntityAlias(view, "View", "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Input {");
+  for (const table of tables) {
+    out.push(...emitCompatInputAliases(table, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Json {");
+  for (const alias of jsonAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `Db.Json.${alias}`, "  "));
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace JsonRaw {");
+  for (const alias of jsonRawAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `Db.JsonRaw.${alias}`, "  "));
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Enums {");
+  for (const [, info] of enumMap) {
+    if (!info.mapping) continue;
+    out.push(...emitDeprecatedEnumAliases(info.zenstackName, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  for (const table of tables) {
+    out.push(...emitDeprecatedTypeAlias(table.typeName, `Models.${table.typeName}`));
+  }
+  for (const view of views) {
+    out.push(...emitDeprecatedTypeAlias(view.typeName, `Views.${view.typeName}`));
+  }
+  for (const table of tables) {
+    out.push(...emitCompatInputAliases(table));
+  }
+  for (const alias of jsonAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `Json.${alias}`));
+  }
+  for (const alias of jsonRawAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `JsonRaw.${alias}`));
+  }
+  for (const [, info] of enumMap) {
+    if (!info.mapping) continue;
+    out.push(...emitDeprecatedEnumAliases(info.zenstackName));
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitCompatTs, "emitCompatTs");
+function emitOrmTypesTs(tables) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type { SchemaType as Schema } from "./schema";');
+  out.push("");
+  out.push("export type Client = $.ClientContract<Schema>;");
+  out.push("");
+  out.push("export namespace ComputedFields {");
+  out.push("  export type All = $.ComputedFieldsOptions<Schema>;");
+  for (const table of tables) {
+    if (table.computedFields.length === 0) continue;
+    out.push(`  export type ${table.typeName} = $.ComputedFieldsOptions<Schema>[${esc(table.modelName)}];`);
+  }
+  out.push("}");
+  out.push("");
+  return out.join("\n");
+}
+__name(emitOrmTypesTs, "emitOrmTypesTs");
+function getEntityFieldNames(entity) {
+  const fieldNames = /* @__PURE__ */ new Set();
+  if ("table" in entity) {
+    for (const jsKey of entity.sqlToJsKey.values()) {
+      fieldNames.add(jsKey === "$hash" ? "hash" : jsKey);
+    }
+    for (const computedField of entity.computedFields) {
+      fieldNames.add(computedField.name);
+    }
+  } else {
+    for (const jsKey of entity.columns.keys()) {
+      fieldNames.add(jsKey === "$hash" ? "hash" : jsKey);
+    }
+  }
+  return [
+    ...fieldNames
+  ];
+}
+__name(getEntityFieldNames, "getEntityFieldNames");
+function createJsonFieldAliasMap(typedJsonFields) {
+  return new Map(typedJsonFields.map((field) => [
+    `${field.entityTypeName}.${field.fieldName}`,
+    `${field.entityTypeName}${toPascalCase(field.fieldName)}Json`
+  ]));
+}
+__name(createJsonFieldAliasMap, "createJsonFieldAliasMap");
+function emitEntityNamespaceBlock(entity, modelName, jsonFieldAliases, indent2 = "") {
+  const out = [];
+  out.push(`${indent2}export interface ${entity.typeName} extends $.ModelResult<Schema, ${esc(modelName)}> {}`);
+  out.push(`${indent2}export namespace ${entity.typeName} {`);
+  for (const fieldName of getEntityFieldNames(entity)) {
+    const exportName = toPascalCase(fieldName);
+    const jsonAlias = jsonFieldAliases.get(`${entity.typeName}.${fieldName}`);
+    if (jsonAlias) {
+      out.push(`${indent2}  export interface ${exportName} extends Json.${jsonAlias} {}`);
+    } else {
+      out.push(`${indent2}  export type ${exportName} = ${entity.typeName}[${esc(fieldName)}];`);
+    }
+  }
+  out.push(`${indent2}}`);
+  return out;
+}
+__name(emitEntityNamespaceBlock, "emitEntityNamespaceBlock");
+function emitInputNamespaceBlock(table, indent2 = "") {
+  const out = [];
+  out.push(`${indent2}export namespace ${table.typeName} {`);
+  out.push(`${indent2}  export interface FindManyArgs extends $.FindManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface FindUniqueArgs extends $.FindUniqueArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface FindFirstArgs extends $.FindFirstArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface ExistsArgs extends $.ExistsArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface CreateArgs extends $.CreateArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface CreateManyArgs extends $.CreateManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface CreateManyAndReturnArgs extends $.CreateManyAndReturnArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface UpdateArgs extends $.UpdateArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface UpdateManyArgs extends $.UpdateManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface UpdateManyAndReturnArgs extends $.UpdateManyAndReturnArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface UpsertArgs extends $.UpsertArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface DeleteArgs extends $.DeleteArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface DeleteManyArgs extends $.DeleteManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface CountArgs extends $.CountArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface AggregateArgs extends $.AggregateArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface GroupByArgs extends $.GroupByArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface WhereInput extends $.WhereInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface Select extends $.SelectInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface Include extends $.IncludeInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export interface Omit extends $.OmitInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent2}  export type GetPayload<Args extends $.SelectIncludeOmit<Schema, ${esc(table.modelName)}, true>, Options extends $.QueryOptions<Schema> = $.QueryOptions<Schema>> = $.SimplifiedPlainResult<Schema, ${esc(table.modelName)}, Args, Options>;`);
+  out.push(`${indent2}}`);
+  return out;
+}
+__name(emitInputNamespaceBlock, "emitInputNamespaceBlock");
+function emitEnumNamespaceBlock(info, indent2 = "") {
+  if (!info.mapping) return [];
+  const out = [];
+  const entries = Object.entries(info.mapping).map(([key, value]) => `${indent2}  ${key}: ${esc(value)}`).join(",\n");
+  out.push(`${indent2}export const ${info.zenstackName} = {`);
+  out.push(entries);
+  out.push(`${indent2}} as const;`);
+  out.push(`${indent2}export type ${info.zenstackName} = (typeof ${info.zenstackName})[keyof typeof ${info.zenstackName}];`);
+  out.push(`${indent2}export type ${info.zenstackName}Key = ${Object.keys(info.mapping).map((key) => esc(key)).join(" | ")};`);
+  out.push(`${indent2}export const ${info.zenstackName}Values = Object.values(${info.zenstackName});`);
+  out.push(`${indent2}export const ${info.zenstackName}Keys = Object.keys(${info.zenstackName}) as ${info.zenstackName}Key[];`);
+  return out;
+}
+__name(emitEnumNamespaceBlock, "emitEnumNamespaceBlock");
+function emitDeprecatedTypeAlias(name, target, indent2 = "") {
+  return [
+    `${indent2}/** @deprecated Use ${target} instead. */`,
+    `${indent2}export type ${name} = ${target};`
+  ];
+}
+__name(emitDeprecatedTypeAlias, "emitDeprecatedTypeAlias");
+function emitDeprecatedValueAlias(name, target, indent2 = "") {
+  return [
+    `${indent2}/** @deprecated Use ${target} instead. */`,
+    `${indent2}export const ${name} = ${target};`
+  ];
+}
+__name(emitDeprecatedValueAlias, "emitDeprecatedValueAlias");
+function emitDeprecatedEnumAliases(enumName, indent2 = "") {
+  return [
+    ...emitDeprecatedValueAlias(enumName, `Db.Enum.${enumName}`, indent2),
+    ...emitDeprecatedTypeAlias(enumName, `Db.Enum.${enumName}`, indent2),
+    ...emitDeprecatedTypeAlias(`${enumName}Key`, `Db.Enum.${enumName}Key`, indent2),
+    ...emitDeprecatedValueAlias(`${enumName}Values`, `Db.Enum.${enumName}Values`, indent2),
+    ...emitDeprecatedValueAlias(`${enumName}Keys`, `Db.Enum.${enumName}Keys`, indent2)
+  ];
+}
+__name(emitDeprecatedEnumAliases, "emitDeprecatedEnumAliases");
+function emitCompatEntityAlias(entity, namespace, indent2 = "") {
+  const target = `Db.${namespace}.${entity.typeName}`;
+  const out = [
+    `${indent2}/** @deprecated Use ${target} instead. */`
+  ];
+  const legacyFields = [
+    ...entity.sqlToJsKey.entries()
+  ].map(([sqlName, jsName]) => ({
+    sqlName,
+    fieldName: jsName === "$hash" ? "hash" : jsName
+  })).filter(({ sqlName, fieldName }) => sqlName !== "$hash" && sqlName !== fieldName);
+  if (legacyFields.length === 0) {
+    out.push(`${indent2}export type ${entity.typeName} = ${target};`);
+    return out;
+  }
+  out.push(`${indent2}export type ${entity.typeName} = ${target} & {`);
+  for (const { sqlName, fieldName } of legacyFields) {
+    out.push(`${indent2}  /** @deprecated Use ${fieldName} instead. */`);
+    out.push(`${indent2}  ${esc(sqlName)}: ${target}[${esc(fieldName)}];`);
+  }
+  out.push(`${indent2}};`);
+  return out;
+}
+__name(emitCompatEntityAlias, "emitCompatEntityAlias");
+function emitCompatInputAliases(table, indent2 = "") {
+  const target = `Db.Input.${table.typeName}`;
+  return [
+    ...emitDeprecatedTypeAlias(`${table.typeName}FindManyArgs`, `${target}.FindManyArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}FindUniqueArgs`, `${target}.FindUniqueArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}FindFirstArgs`, `${target}.FindFirstArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}ExistsArgs`, `${target}.ExistsArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CreateArgs`, `${target}.CreateArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CreateManyArgs`, `${target}.CreateManyArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CreateManyAndReturnArgs`, `${target}.CreateManyAndReturnArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpdateArgs`, `${target}.UpdateArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpdateManyArgs`, `${target}.UpdateManyArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpdateManyAndReturnArgs`, `${target}.UpdateManyAndReturnArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpsertArgs`, `${target}.UpsertArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}DeleteArgs`, `${target}.DeleteArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}DeleteManyArgs`, `${target}.DeleteManyArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CountArgs`, `${target}.CountArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}AggregateArgs`, `${target}.AggregateArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}GroupByArgs`, `${target}.GroupByArgs`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}WhereInput`, `${target}.WhereInput`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}Select`, `${target}.Select`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}Include`, `${target}.Include`, indent2),
+    ...emitDeprecatedTypeAlias(`${table.typeName}Omit`, `${target}.Omit`, indent2),
+    `${indent2}/** @deprecated Use ${target}.GetPayload instead. */`,
+    `${indent2}export type ${table.typeName}GetPayload<Args extends $.SelectIncludeOmit<Schema, ${esc(table.modelName)}, true>, Options extends $.QueryOptions<Schema> = $.QueryOptions<Schema>> = ${target}.GetPayload<Args, Options>;`
+  ];
+}
+__name(emitCompatInputAliases, "emitCompatInputAliases");
+function emitEnumsTs(enumMap) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  for (const [, info] of enumMap) {
+    if (!info.mapping) continue;
+    const n = info.zenstackName;
+    const entries = Object.entries(info.mapping).map(([k, v]) => `  ${k}: ${esc(v)}`).join(",\n");
+    out.push(`export const ${n} = {
+${entries},
+} as const;`);
+    out.push(`export type ${n} = (typeof ${n})[keyof typeof ${n}];`);
+    out.push(`export type ${n}Key = ${Object.keys(info.mapping).map((k) => esc(k)).join(" | ")};`);
+    out.push(`export const ${n}Values = Object.values(${n});`);
+    out.push(`export const ${n}Keys = Object.keys(${n}) as ${n}Key[];`);
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitEnumsTs, "emitEnumsTs");
+
+// src/drizzle/cols.ts
+var import_drizzle_orm3 = require("drizzle-orm");
+var import_pg_core6 = require("drizzle-orm/pg-core");
+
+// src/drizzle/rls.ts
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_pg_core5 = require("drizzle-orm/pg-core");
+var currentAppSlug = import_drizzle_orm2.sql`current_setting('rls.app')`;
+var hasAppSlug = import_drizzle_orm2.sql`(select ${currentAppSlug} is not null)`;
+var currentUser = import_drizzle_orm2.sql`current_setting('rls.user')`;
+var hasUser = import_drizzle_orm2.sql`(select ${currentUser} is not null)`;
+var hasBypassEnabled = import_drizzle_orm2.sql`(select current_setting('rls.bypass') = 'enabled')`;
+var TRUE = import_drizzle_orm2.sql`true`;
+var FALSE = import_drizzle_orm2.sql`false`;
+var defaultPolicy = /* @__PURE__ */ __name((name, { table, policies }) => {
+  const isSameAppSlug = import_drizzle_orm2.sql`${currentAppSlug} = ${table.appSlug}`;
+  const selectPolicy = (0, import_pg_core5.pgPolicy)(`rls.${name}.select`, {
+    as: "permissive",
+    for: "select",
+    using: import_drizzle_orm2.sql`${isSameAppSlug} or ${hasBypassEnabled}`
+  });
+  const insertPolicy = (0, import_pg_core5.pgPolicy)(`rls.${name}.insert`, {
+    as: "permissive",
+    for: "insert",
+    withCheck: import_drizzle_orm2.sql`${hasAppSlug} or ${hasBypassEnabled}`
+  });
+  const updatePolicy = (0, import_pg_core5.pgPolicy)(`rls.${name}.update`, {
+    as: "permissive",
+    for: "update",
+    using: import_drizzle_orm2.sql`${isSameAppSlug} or ${hasBypassEnabled}`
+  });
+  const deletePolicy = (0, import_pg_core5.pgPolicy)(`rls.${name}.delete`, {
+    as: "permissive",
+    for: "delete",
+    using: import_drizzle_orm2.sql`${hasBypassEnabled} or ${isSameAppSlug}`
+  });
+  const ctx = {
+    currentAppSlug,
+    currentUser,
+    hasAppSlug,
+    hasUser,
+    isSameAppSlug,
+    hasBypass: hasBypassEnabled,
+    TRUE,
+    FALSE
+  };
+  return [
+    typeof policies?.select === "function" ? (0, import_pg_core5.pgPolicy)(`rls.${name}.select`, {
+      as: "permissive",
+      for: "select",
+      using: policies.select(ctx)
+    }) : selectPolicy,
+    typeof policies?.insert === "function" ? (0, import_pg_core5.pgPolicy)(`rls.${name}.insert`, {
+      as: "permissive",
+      for: "insert",
+      withCheck: policies.insert(ctx)
+    }) : insertPolicy,
+    typeof policies?.update === "function" ? (0, import_pg_core5.pgPolicy)(`rls.${name}.update`, {
+      as: "permissive",
+      for: "update",
+      withCheck: policies.update(ctx)
+    }) : updatePolicy,
+    typeof policies?.delete === "function" ? (0, import_pg_core5.pgPolicy)(`rls.${name}.delete`, {
+      as: "permissive",
+      for: "delete",
+      using: policies.delete(ctx)
+    }) : deletePolicy
+  ].filter(Boolean);
+}, "defaultPolicy");
+
+// src/drizzle/cols.ts
+var colNumeric = /* @__PURE__ */ __name((name) => {
+  return (0, import_pg_core6.customType)({
+    dataType: /* @__PURE__ */ __name(() => "numeric", "dataType"),
+    fromDriver: Number,
+    toDriver: /* @__PURE__ */ __name((value) => import_drizzle_orm3.sql`${value.toString()}::numeric`, "toDriver")
+  })(name);
+}, "colNumeric");
+var colAppSlug = /* @__PURE__ */ __name((name) => (0, import_pg_core6.text)(name).default(currentAppSlug), "colAppSlug");
+var colTimestamp = /* @__PURE__ */ __name((name) => (0, import_pg_core6.timestamp)(name, {
+  withTimezone: true,
+  mode: "date"
+}), "colTimestamp");
+var colCreatedAt = /* @__PURE__ */ __name((name) => colTimestamp(name).defaultNow().notNull(), "colCreatedAt");
+var colUpdatedAt = /* @__PURE__ */ __name((name) => colTimestamp(name).defaultNow().notNull(), "colUpdatedAt");
+var colDeletedAt = /* @__PURE__ */ __name((name) => colTimestamp(name), "colDeletedAt");
+var colId = /* @__PURE__ */ __name((name) => (0, import_pg_core6.uuid)(name).defaultRandom().primaryKey().notNull(), "colId");
+var auditColumns = /* @__PURE__ */ __name(() => ({
+  createdBy: (0, import_pg_core6.text)("created_by").default(currentUser).notNull(),
+  updatedBy: (0, import_pg_core6.text)("updated_by").default(currentUser).notNull(),
+  createdAt: colCreatedAt("created_at"),
+  updatedAt: colUpdatedAt("updated_at"),
+  deletedAt: colDeletedAt("deleted_at")
+}), "auditColumns");
+var appSlugForeignKey = /* @__PURE__ */ __name((table, tableName, appsTable) => (0, import_pg_core6.foreignKey)({
+  columns: [
+    table.appSlug
+  ],
+  foreignColumns: [
+    appsTable.slug
+  ],
+  name: `${tableName}_app_slug_fkey`
+}).onUpdate("cascade").onDelete("cascade"), "appSlugForeignKey");
+
+// src/drizzle/generate.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_zlib = require("zlib");
+var import_pg_core7 = require("drizzle-orm/pg-core");
+function parseFlags(argv = process.argv, env = process.env) {
+  const dryRun = argv.includes("--dry-run") || env["DRY_RUN"] === "1";
+  const verbose = argv.includes("--verbose") || env["VERBOSE"] === "1" || dryRun;
+  const fix = argv.includes("--fix");
+  return {
+    dryRun,
+    verbose,
+    fix
+  };
+}
+__name(parseFlags, "parseFlags");
+function computeHash(sql4) {
+  const hash = (0, import_node_crypto.createHash)("sha256").update(sql4).digest("hex");
+  return `sha256:${hash}`;
+}
+__name(computeHash, "computeHash");
+function categorizeChanges(prev, curr) {
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(prev),
+    ...Object.keys(curr)
+  ]);
+  const changes = [];
+  for (const key of [
+    ...allKeys
+  ].sort()) {
+    if (!(key in prev)) {
+      changes.push({
+        key,
+        category: "added"
+      });
+    } else if (!(key in curr)) {
+      changes.push({
+        key,
+        category: "removed"
+      });
+    } else if (prev[key] !== curr[key]) {
+      changes.push({
+        key,
+        category: "modified"
+      });
+    }
+  }
+  return changes;
+}
+__name(categorizeChanges, "categorizeChanges");
+function formatChangeSummary(changes) {
+  if (changes.length === 0) return "";
+  const prefixes = {
+    added: "+",
+    modified: "~",
+    removed: "-"
+  };
+  const labels = {
+    added: "new",
+    modified: "modified",
+    removed: "removed"
+  };
+  const lines = changes.map(({ key, category }) => `  ${prefixes[category]} ${key} (${labels[category]})`);
+  return `Custom SQL changes:
+${lines.join("\n")}`;
+}
+__name(formatChangeSummary, "formatChangeSummary");
+function simpleDiff(prev, curr) {
+  const prevLines = prev.split("\n");
+  const currLines = curr.split("\n");
+  const result = [];
+  let pi = 0;
+  let ci = 0;
+  while (pi < prevLines.length || ci < currLines.length) {
+    if (pi >= prevLines.length) {
+      result.push(`+${currLines[ci]}`);
+      ci++;
+    } else if (ci >= currLines.length) {
+      result.push(`-${prevLines[pi]}`);
+      pi++;
+    } else if (prevLines[pi] === currLines[ci]) {
+      result.push(` ${prevLines[pi]}`);
+      pi++;
+      ci++;
+    } else {
+      result.push(`-${prevLines[pi]}`);
+      result.push(`+${currLines[ci]}`);
+      pi++;
+      ci++;
+    }
+  }
+  return result.join("\n");
+}
+__name(simpleDiff, "simpleDiff");
+function indent(text2) {
+  return text2.split("\n").map((line) => `  ${line}`).join("\n");
+}
+__name(indent, "indent");
+function formatVerboseOutput(changes, currentObjects, prevObjects) {
+  const sections = [];
+  for (const { key, category } of changes) {
+    if (category === "added") {
+      const sql4 = currentObjects[key]?.sql ?? "";
+      sections.push(`+ ${key} (new)
+${indent(sql4)}`);
+    } else if (category === "modified") {
+      const currSql = currentObjects[key]?.sql ?? "";
+      const prevSql = prevObjects[key]?.sql ?? "";
+      if (prevSql) {
+        const diff = simpleDiff(prevSql, currSql);
+        sections.push(`~ ${key} (modified)
+  --- previous
+  +++ current
+${indent(diff)}`);
+      } else {
+        sections.push(`~ ${key} (modified \u2014 previous SQL not stored, showing current)
+${indent(currSql)}`);
+      }
+    } else {
+      sections.push(`- ${key} (removed)`);
+    }
+  }
+  return sections.join("\n");
+}
+__name(formatVerboseOutput, "formatVerboseOutput");
+function readJournal(migrationsDir) {
+  const journalPath = (0, import_node_path.join)(migrationsDir, "meta", "_journal.json");
+  return JSON.parse((0, import_node_fs.readFileSync)(journalPath, "utf-8"));
+}
+__name(readJournal, "readJournal");
+function timestampFromTag(tag) {
+  return tag.match(/^(\d+)/)?.[1] ?? tag;
+}
+__name(timestampFromTag, "timestampFromTag");
+function nowTimestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "p");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+__name(nowTimestamp, "nowTimestamp");
+function getLatestSnapshotPath(migrationsDir, journal) {
+  if (journal.entries.length === 0) return null;
+  const latest = journal.entries[journal.entries.length - 1];
+  return (0, import_node_path.join)(migrationsDir, "meta", `${timestampFromTag(latest.tag)}_snapshot.json`);
+}
+__name(getLatestSnapshotPath, "getLatestSnapshotPath");
+function readSnapshotCustomObjects(snapshotPath) {
+  const snapshot = JSON.parse((0, import_node_fs.readFileSync)(snapshotPath, "utf-8"));
+  const raw = snapshot.customObjects ?? {};
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") {
+      result[key] = {
+        hash: value,
+        sql: ""
+      };
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(readSnapshotCustomObjects, "readSnapshotCustomObjects");
+function writeSnapshotCustomObjects(snapshotPath, objects) {
+  const snapshot = JSON.parse((0, import_node_fs.readFileSync)(snapshotPath, "utf-8"));
+  snapshot.customObjects = objects;
+  (0, import_node_fs.writeFileSync)(snapshotPath, JSON.stringify(snapshot, null, 2) + "\n");
+}
+__name(writeSnapshotCustomObjects, "writeSnapshotCustomObjects");
+function stableStringify(obj) {
+  if (obj === null || typeof obj !== "object") return JSON.stringify(obj);
+  if (Array.isArray(obj)) return `[${obj.map(stableStringify).join(",")}]`;
+  const sorted = Object.keys(obj).sort();
+  const entries = sorted.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${entries.join(",")}}`;
+}
+__name(stableStringify, "stableStringify");
+function packToSgz(migrationsDir) {
+  const metaDir = (0, import_node_path.join)(migrationsDir, "meta");
+  if (!(0, import_node_fs.existsSync)(metaDir)) return;
+  const snapshotFiles = (0, import_node_fs.readdirSync)(metaDir).filter((f) => f.endsWith("_snapshot.json"));
+  const sqlFiles = (0, import_node_fs.readdirSync)(migrationsDir).filter((f) => f.endsWith(".sql"));
+  for (const file of snapshotFiles) {
+    const timestamp2 = timestampFromTag(file);
+    const sqlFile = sqlFiles.find((f) => f.startsWith(timestamp2));
+    if (!sqlFile) continue;
+    const sqlStem = sqlFile.replace(/\.sql$/, "");
+    const normalized = stableStringify(JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(metaDir, file), "utf-8")));
+    const compressed = (0, import_node_zlib.gzipSync)(normalized, {
+      level: 9
+    });
+    (0, import_node_fs.writeFileSync)((0, import_node_path.join)(migrationsDir, `${sqlStem}.sgz`), compressed);
+  }
+}
+__name(packToSgz, "packToSgz");
+function unpackFromSgz(migrationsDir) {
+  const metaDir = (0, import_node_path.join)(migrationsDir, "meta");
+  (0, import_node_fs.mkdirSync)(metaDir, {
+    recursive: true
+  });
+  const sgzFiles = (0, import_node_fs.readdirSync)(migrationsDir).filter((f) => f.endsWith(".sgz")).sort();
+  const sqlFiles = (0, import_node_fs.readdirSync)(migrationsDir).filter((f) => f.endsWith(".sql"));
+  const entries = [];
+  for (let i = 0; i < sgzFiles.length; i++) {
+    const stem = sgzFiles[i].replace(/\.sgz$/, "");
+    const timestamp2 = timestampFromTag(stem);
+    const decompressed = (0, import_node_zlib.gunzipSync)((0, import_node_fs.readFileSync)((0, import_node_path.join)(migrationsDir, sgzFiles[i])));
+    (0, import_node_fs.writeFileSync)((0, import_node_path.join)(metaDir, `${timestamp2}_snapshot.json`), decompressed);
+    const sqlFile = sqlFiles.find((f) => f.startsWith(timestamp2));
+    const tag = sqlFile ? sqlFile.replace(/\.sql$/, "") : stem;
+    entries.push({
+      idx: i,
+      version: "7",
+      when: parseInt(timestamp2, 10),
+      tag,
+      breakpoints: true
+    });
+  }
+  const journal = {
+    version: "7",
+    dialect: "postgresql",
+    entries
+  };
+  (0, import_node_fs.writeFileSync)((0, import_node_path.join)(metaDir, "_journal.json"), JSON.stringify(journal, null, 2) + "\n");
+}
+__name(unpackFromSgz, "unpackFromSgz");
+function cleanMeta(migrationsDir) {
+  const metaDir = (0, import_node_path.join)(migrationsDir, "meta");
+  if ((0, import_node_fs.existsSync)(metaDir)) (0, import_node_fs.rmSync)(metaDir, {
+    recursive: true
+  });
+}
+__name(cleanMeta, "cleanMeta");
+function listSgzFiles(migrationsDir) {
+  return (0, import_node_fs.readdirSync)(migrationsDir).filter((f) => f.endsWith(".sgz")).sort();
+}
+__name(listSgzFiles, "listSgzFiles");
+function validateTimestamps(migrationsDir) {
+  const duplicates = [];
+  let prevTimestamp = "";
+  for (const file of listSgzFiles(migrationsDir)) {
+    const ts2 = timestampFromTag(file);
+    if (ts2 === prevTimestamp) duplicates.push(file);
+    prevTimestamp = ts2;
+  }
+  return duplicates;
+}
+__name(validateTimestamps, "validateTimestamps");
+function validateOrder(migrationsDir) {
+  const sgzFiles = listSgzFiles(migrationsDir);
+  const issues = [];
+  let prevContentId = "";
+  for (const file of sgzFiles) {
+    const content = JSON.parse((0, import_node_zlib.gunzipSync)((0, import_node_fs.readFileSync)((0, import_node_path.join)(migrationsDir, file))).toString());
+    if (prevContentId !== "" && content.prevId !== prevContentId) {
+      issues.push({
+        file,
+        expected: prevContentId,
+        actual: content.prevId
+      });
+    }
+    prevContentId = content.id;
+  }
+  return issues;
+}
+__name(validateOrder, "validateOrder");
+function fixOrder(migrationsDir, issues) {
+  let lastUsedTs = "";
+  for (const issue of issues) {
+    const sgzPath = (0, import_node_path.join)(migrationsDir, issue.file);
+    const sqlFile = issue.file.replace(/\.sgz$/, ".sql");
+    const sqlPath = (0, import_node_path.join)(migrationsDir, sqlFile);
+    let sqlContent = "";
+    try {
+      sqlContent = (0, import_node_fs.readFileSync)(sqlPath, "utf-8");
+    } catch {
+    }
+    const snapshot = JSON.parse((0, import_node_zlib.gunzipSync)((0, import_node_fs.readFileSync)(sgzPath)).toString());
+    snapshot.prevId = issue.expected;
+    const suffix = sqlFile.replace(/^\d+/, "");
+    try {
+      (0, import_node_fs.unlinkSync)(sqlPath);
+    } catch {
+    }
+    (0, import_node_fs.unlinkSync)(sgzPath);
+    let ts2 = findTimestampAfterDependency(migrationsDir, issue.expected);
+    if (ts2 <= lastUsedTs) ts2 = String(Number(lastUsedTs) + 1);
+    lastUsedTs = ts2;
+    const newStem = `${ts2}${suffix.replace(/\.sql$/, "")}`;
+    (0, import_node_fs.writeFileSync)((0, import_node_path.join)(migrationsDir, `${newStem}.sql`), sqlContent);
+    (0, import_node_fs.writeFileSync)((0, import_node_path.join)(migrationsDir, `${newStem}.sgz`), (0, import_node_zlib.gzipSync)(stableStringify(snapshot), {
+      level: 9
+    }));
+  }
+}
+__name(fixOrder, "fixOrder");
+function findTimestampAfterDependency(migrationsDir, expectedId) {
+  for (const file of listSgzFiles(migrationsDir)) {
+    const content = JSON.parse((0, import_node_zlib.gunzipSync)((0, import_node_fs.readFileSync)((0, import_node_path.join)(migrationsDir, file))).toString());
+    if (content.id === expectedId) {
+      const depTs = timestampFromTag(file);
+      return String(Number(depTs) + 1);
+    }
+  }
+  return nowTimestamp();
+}
+__name(findTimestampAfterDependency, "findTimestampAfterDependency");
+function collectCustomObjects(moduleExports) {
+  return Object.values(moduleExports).filter((v) => v instanceof CustomObject);
+}
+__name(collectCustomObjects, "collectCustomObjects");
+function serializeCustomObject(obj, dialect) {
+  return obj.toSQL(dialect);
+}
+__name(serializeCustomObject, "serializeCustomObject");
+function generateDropSQL(key, createSQL) {
+  const [type] = key.split(":");
+  switch (type) {
+    case "function": {
+      const m = createSQL.match(/CREATE OR REPLACE FUNCTION\s+(\S+)\s*\(/);
+      return m ? `DROP FUNCTION IF EXISTS ${m[1]};` : null;
+    }
+    case "trigger": {
+      const m = createSQL.match(/CREATE OR REPLACE TRIGGER\s+(\S+)[\s\S]*?ON\s+(\S+)/);
+      return m ? `DROP TRIGGER IF EXISTS ${m[1]} ON ${m[2]};` : null;
+    }
+    case "extension": {
+      const m = createSQL.match(/CREATE EXTENSION IF NOT EXISTS\s+"([^"]+)"/);
+      return m ? `DROP EXTENSION IF EXISTS "${m[1]}";` : null;
+    }
+    case "cron": {
+      const m = createSQL.match(/cron\.schedule\('([^']+)'/);
+      return m ? `SELECT cron.unschedule('${m[1]}');` : null;
+    }
+    default:
+      return null;
+  }
+}
+__name(generateDropSQL, "generateDropSQL");
+function findNewMigrationFile(migrationsDir, beforeFiles) {
+  const afterFiles = (0, import_node_fs.readdirSync)(migrationsDir).filter((f) => f.endsWith(".sql"));
+  const newFile = afterFiles.find((f) => !beforeFiles.has(f));
+  return newFile ? (0, import_node_path.join)(migrationsDir, newFile) : null;
+}
+__name(findNewMigrationFile, "findNewMigrationFile");
+async function generate(migrationsDir, schemaModules, flags = {
+  dryRun: false,
+  verbose: false,
+  fix: false
+}) {
+  const duplicates = validateTimestamps(migrationsDir);
+  if (duplicates.length > 0) {
+    console.error("Duplicate migration timestamps detected:");
+    for (const file of duplicates) console.error(`  ${file}`);
+    console.error("Resolve manually \u2014 each migration must have a unique timestamp.");
+    process.exit(1);
+  }
+  const orderIssues = validateOrder(migrationsDir);
+  if (orderIssues.length > 0) {
+    if (!flags.fix) {
+      console.error("Migration order issues detected:");
+      for (const issue of orderIssues) {
+        console.error(`  ${issue.file}: expected prevId="${issue.expected}", actual="${issue.actual}"`);
+      }
+      console.error("Run with --fix to repair.");
+      process.exit(1);
+    }
+    if (flags.dryRun) {
+      console.log("Would fix migration order:");
+      for (const issue of orderIssues) {
+        console.log(`  ${issue.file}: re-timestamp, set prevId="${issue.expected}"`);
+      }
+    } else {
+      fixOrder(migrationsDir, orderIssues);
+      console.log(`Fixed ${orderIssues.length} migration order issue(s).`);
+    }
+  }
+  const dialect = new import_pg_core7.PgDialect();
+  unpackFromSgz(migrationsDir);
+  try {
+    const journal = readJournal(migrationsDir);
+    const snapshotPath = getLatestSnapshotPath(migrationsDir, journal);
+    const prevObjects = snapshotPath ? readSnapshotCustomObjects(snapshotPath) : {};
+    let beforeFiles = /* @__PURE__ */ new Set();
+    if (!flags.dryRun) {
+      beforeFiles = new Set((0, import_node_fs.readdirSync)(migrationsDir).filter((f) => f.endsWith(".sql")));
+      console.log("Running drizzle-kit generate...");
+      try {
+        (0, import_node_child_process.execSync)("pnpm drizzle generate", {
+          stdio: "inherit"
+        });
+      } catch {
+        throw new Error("drizzle-kit generate failed. Aborting.");
+      }
+    }
+    const allObjects = schemaModules.flatMap(collectCustomObjects);
+    const typeOrder = [
+      "function",
+      "trigger",
+      "extension",
+      "cron"
+    ];
+    const ordered = allObjects.filter((o) => typeOrder.includes(o.type)).sort((a, b) => typeOrder.indexOf(a.type) - typeOrder.indexOf(b.type) || a.name.localeCompare(b.name));
+    const currentObjects = {};
+    for (const obj of ordered) {
+      const sqlStr = serializeCustomObject(obj, dialect);
+      const triggerTable = obj instanceof PgTrigger ? `.${obj.tableName}` : "";
+      const key = `${obj.type}:${obj.name}${triggerTable}`;
+      currentObjects[key] = {
+        hash: computeHash(sqlStr),
+        sql: sqlStr
+      };
+    }
+    const prevHashes = Object.fromEntries(Object.entries(prevObjects).map(([key, entry]) => [
+      key,
+      entry.hash
+    ]));
+    const currentHashes = Object.fromEntries(Object.entries(currentObjects).map(([key, entry]) => [
+      key,
+      entry.hash
+    ]));
+    const changes = categorizeChanges(prevHashes, currentHashes);
+    if (changes.length === 0) {
+      console.log("No custom SQL changes detected.");
+      if (!flags.dryRun) {
+        const latestJournal = readJournal(migrationsDir);
+        const latestSnapshotPath = getLatestSnapshotPath(migrationsDir, latestJournal);
+        if (latestSnapshotPath) writeSnapshotCustomObjects(latestSnapshotPath, currentObjects);
+        packToSgz(migrationsDir);
+      }
+      return;
+    }
+    console.log(formatChangeSummary(changes));
+    if (flags.verbose) {
+      console.log("");
+      console.log(formatVerboseOutput(changes, currentObjects, prevObjects));
+    }
+    if (flags.dryRun) {
+      console.log("\n=== DRY RUN: No files were written ===");
+      return;
+    }
+    let migrationFile = findNewMigrationFile(migrationsDir, beforeFiles);
+    if (!migrationFile) {
+      console.log("No drizzle migration was created. Creating custom migration...");
+      (0, import_node_child_process.execSync)("pnpm drizzle generate --custom", {
+        stdio: "inherit"
+      });
+      migrationFile = findNewMigrationFile(migrationsDir, beforeFiles);
+      if (!migrationFile) throw new Error("Failed to create custom migration file");
+    }
+    const createKeys = changes.filter((c) => c.category !== "removed").map((c) => c.key);
+    const createStatements = createKeys.map((key) => `-- @drizzle-custom ${key}
+${currentObjects[key].sql}`);
+    const removedKeys = changes.filter((c) => c.category === "removed").map((c) => c.key);
+    const dropStatements = removedKeys.map((key) => {
+      const dropSql = generateDropSQL(key, prevObjects[key]?.sql ?? "");
+      return dropSql ? `-- @drizzle-custom ${key} (removed)
+${dropSql}` : null;
+    }).filter(Boolean);
+    const allStatements = [
+      ...dropStatements,
+      ...createStatements
+    ].join("\n\n");
+    (0, import_node_fs.appendFileSync)(migrationFile, `
+-- Custom SQL objects
+${allStatements}
+`);
+    if (dropStatements.length > 0) {
+      const dropNames = removedKeys.join(", ");
+      (0, import_node_fs.appendFileSync)(migrationFile, `
+-- TODO: Review dropped objects (${dropNames})
+-- If they have dependants (triggers, cron jobs, etc.), add DROP/UPDATE statements below.
+-- Run 'pnpm dev:init' to verify this migration applies cleanly.
+
+`);
+      console.log(`\u26A0 ${dropStatements.length} object(s) dropped \u2014 check migration for dependency TODOs`);
+    }
+    const total = createKeys.length + dropStatements.length;
+    console.log(`Appended ${total} custom SQL statement(s) to ${migrationFile}`);
+    const updatedJournal = readJournal(migrationsDir);
+    const updatedSnapshotPath = getLatestSnapshotPath(migrationsDir, updatedJournal);
+    if (updatedSnapshotPath) {
+      writeSnapshotCustomObjects(updatedSnapshotPath, currentObjects);
+      console.log(`Updated custom hashes in ${updatedSnapshotPath}`);
+    }
+    packToSgz(migrationsDir);
+  } finally {
+    cleanMeta(migrationsDir);
+  }
+}
+__name(generate, "generate");
+function drop(migrationsDir) {
+  unpackFromSgz(migrationsDir);
+  try {
+    (0, import_node_child_process.execSync)("pnpm drizzle drop", {
+      stdio: "inherit"
+    });
+    packToSgz(migrationsDir);
+    for (const f of (0, import_node_fs.readdirSync)(migrationsDir)) {
+      if (!f.endsWith(".sgz")) continue;
+      if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(migrationsDir, f.replace(".sgz", ".sql")))) {
+        (0, import_node_fs.unlinkSync)((0, import_node_path.join)(migrationsDir, f));
+      }
+    }
+  } finally {
+    cleanMeta(migrationsDir);
+  }
+}
+__name(drop, "drop");
+function custom(migrationsDir) {
+  unpackFromSgz(migrationsDir);
+  try {
+    (0, import_node_child_process.execSync)("pnpm drizzle generate --custom", {
+      stdio: "inherit"
+    });
+    packToSgz(migrationsDir);
+  } finally {
+    cleanMeta(migrationsDir);
+  }
+}
+__name(custom, "custom");
+async function loadSchemaModules(schemaDir) {
+  const sourceNames = [
+    "functions",
+    "triggers",
+    "extensions",
+    "cron"
+  ];
+  const importTasks = [];
+  for (const name of sourceNames) {
+    const dirPath = (0, import_node_path.join)(schemaDir, name);
+    const filePath = (0, import_node_path.join)(schemaDir, `${name}.ts`);
+    if ((0, import_node_fs.existsSync)(dirPath) && (0, import_node_fs.statSync)(dirPath).isDirectory()) {
+      const scanDir = /* @__PURE__ */ __name((dir, prefix) => {
+        for (const entry of (0, import_node_fs.readdirSync)(dir)) {
+          const fullPath = (0, import_node_path.join)(dir, entry);
+          if ((0, import_node_fs.statSync)(fullPath).isDirectory()) {
+            scanDir(fullPath, `${prefix}${entry}/`);
+          } else if (entry.endsWith(".ts") && !entry.includes(".test.") && !entry.includes(".spec.")) {
+            importTasks.push(import(fullPath).catch((err) => {
+              const msg = err instanceof Error ? err.message : String(err);
+              console.error(`Failed to load ${prefix}${entry}: ${msg}`);
+              process.exit(1);
+            }));
+          }
+        }
+      }, "scanDir");
+      scanDir(dirPath, `${name}/`);
+    } else if ((0, import_node_fs.existsSync)(filePath)) {
+      importTasks.push(import(filePath).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to load ${name}.ts: ${msg}`);
+        process.exit(1);
+      }));
+    }
+  }
+  return Promise.all(importTasks);
+}
+__name(loadSchemaModules, "loadSchemaModules");
+async function syncMeta(migrationsDir, schemaModules) {
+  const dialect = new import_pg_core7.PgDialect();
+  const allObjects = schemaModules.flatMap(collectCustomObjects);
+  const ordered = allObjects.sort((a, b) => a.type.localeCompare(b.type) || a.name.localeCompare(b.name));
+  const currentObjects = {};
+  for (const obj of ordered) {
+    const sqlStr = serializeCustomObject(obj, dialect);
+    const triggerTable = obj instanceof PgTrigger ? `.${obj.tableName}` : "";
+    currentObjects[`${obj.type}:${obj.name}${triggerTable}`] = {
+      hash: computeHash(sqlStr),
+      sql: sqlStr
+    };
+  }
+  const sgzFiles = listSgzFiles(migrationsDir);
+  if (sgzFiles.length === 0) {
+    console.error("No .sgz files found. Nothing to sync.");
+    process.exit(1);
+  }
+  const latestSgz = sgzFiles[sgzFiles.length - 1];
+  const sgzPath = (0, import_node_path.join)(migrationsDir, latestSgz);
+  const snap = JSON.parse((0, import_node_zlib.gunzipSync)((0, import_node_fs.readFileSync)(sgzPath)).toString());
+  snap.customObjects = currentObjects;
+  (0, import_node_fs.writeFileSync)(sgzPath, (0, import_node_zlib.gzipSync)(stableStringify(snap), {
+    level: 9
+  }));
+  console.log(`Synced ${Object.keys(currentObjects).length} custom objects into ${latestSgz}`);
+}
+__name(syncMeta, "syncMeta");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APP_SLUG_JS,
+  APP_SLUG_SQL,
+  CustomObject,
+  ENUM_MAP,
+  FALSE,
+  GENERATED_FILE_BANNER,
+  PgCronJob,
+  PgExtension,
+  PgFunction,
+  PgTrigger,
+  TriggerFunction,
+  adaptToLegacyConfig,
+  appSlugForeignKey,
+  assertNoTypedColumnOverrides,
+  auditColumns,
+  buildRelations,
+  buildTypeDefs,
+  capitalize,
+  categorizeChanges,
+  cleanMeta,
+  colAppSlug,
+  colCreatedAt,
+  colDeletedAt,
+  colId,
+  colNumeric,
+  colTimestamp,
+  colUpdatedAt,
+  collectCustomObjects,
+  computeHash,
+  currentAppSlug,
+  currentUser,
+  custom,
+  defaultPolicy,
+  defineConfig,
+  defineModels,
+  derived,
+  discoverEnums,
+  discoverTables,
+  discoverViews,
+  drop,
+  emitCompatTs,
+  emitEnumBlock,
+  emitEnumsTs,
+  emitFieldBlock,
+  emitGeneratedFileBanner,
+  emitIndexTs,
+  emitInputTs,
+  emitJsonNamespaceBlock,
+  emitJsonRawNamespaceBlock,
+  emitJsonRawTs,
+  emitJsonTs,
+  emitModelsTs,
+  emitOrmTypesTs,
+  emitRelationField,
+  emitSchemaTs,
+  emitTypeDefsBlock,
+  emitViewsTs,
+  esc,
+  extend,
+  extractFKs,
+  fixOrder,
+  formatChangeSummary,
+  formatVerboseOutput,
+  generate,
+  generateDropSQL,
+  getDrizzleTableName,
+  getLatestSnapshotPath,
+  hasAppSlug,
+  hasBypassEnabled,
+  loadSchemaModules,
+  many,
+  mapColumn,
+  model,
+  one,
+  packToSgz,
+  parseFlags,
+  pgCron,
+  pgExtension,
+  pgFunction,
+  pgOrmEnum,
+  pgTrigger,
+  pgTypes,
+  readJournal,
+  readSnapshotCustomObjects,
+  serializeCustomObject,
+  simpleDiff,
+  syncMeta,
+  through,
+  toPascalCase,
+  toPgEnum,
+  uncapitalize,
+  unpackFromSgz,
+  validateOrder,
+  validateTimestamps,
+  writeFileIfChanged,
+  writeSnapshotCustomObjects
+});
+//# sourceMappingURL=index.cjs.map