@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-HALDNTIV.mjs

@@ -0,0 +1,2225 @@
+import {
+  assertNoSchemaListField,
+  isDatabaseEnforcedReference,
+  resolveSchemaModels
+} from "./chunk-ZMSZZXOR.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/schema-sql-identifiers.ts
+var POSTGRES_IDENTIFIER_BYTES = 63;
+function fitSqlIndexName(dialect, name) {
+  if (dialect !== "postgres") return name;
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(name);
+  if (bytes.length <= POSTGRES_IDENTIFIER_BYTES) return name;
+  let hash = 2166136261;
+  for (const byte of bytes) hash = Math.imul(hash ^ byte, 16777619);
+  const suffix = `_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+  let prefix = "";
+  let length = 0;
+  for (const character of name) {
+    const size = encoder.encode(character).length;
+    if (length + size > POSTGRES_IDENTIFIER_BYTES - suffix.length) break;
+    prefix += character;
+    length += size;
+  }
+  return prefix + suffix;
+}
+__name(fitSqlIndexName, "fitSqlIndexName");
+
+// src/schema-sql.ts
+function describeSchemaReference(model, fieldKey) {
+  const field = model.model.fields[fieldKey];
+  const target = model.referenceTargets?.[fieldKey];
+  if (target) return `${target.table}.${target.column}`;
+  return `${field?.reference?.model}.${field?.reference?.field}`;
+}
+__name(describeSchemaReference, "describeSchemaReference");
+var SQL_ON_DELETE_ACTIONS = {
+  cascade: "CASCADE",
+  restrict: "RESTRICT",
+  setNull: "SET NULL",
+  noAction: "NO ACTION"
+};
+function collectSchemaModels(entries) {
+  const collectedModels = [];
+  const seenModelNames = /* @__PURE__ */ new Map();
+  for (const [ownerKey, schema, only] of entries) {
+    const resolvedModels = resolveSchemaModels(ownerKey, schema);
+    for (const [modelKey, model] of Object.entries(resolvedModels)) {
+      if (only && !only.includes(modelKey)) continue;
+      if (model.external) continue;
+      const collisionKey = model.name.toLowerCase();
+      const previousOwner = seenModelNames.get(collisionKey);
+      if (previousOwner && previousOwner !== `${ownerKey}.${modelKey}`) {
+        throw new Error(
+          `Schema model "${ownerKey}.${modelKey}" resolves to "${model.name}", which conflicts with "${previousOwner}". Rename one of the models with schema.models.<model>.name.`
+        );
+      }
+      seenModelNames.set(collisionKey, `${ownerKey}.${modelKey}`);
+      const referenceTargets = {};
+      for (const [fieldKey, field] of Object.entries(model.fields)) {
+        const reference = field.reference;
+        if (!reference || !Object.prototype.hasOwnProperty.call(resolvedModels, reference.model)) {
+          continue;
+        }
+        const target = resolvedModels[reference.model];
+        if (!target.external && (!only || only.includes(reference.model))) continue;
+        referenceTargets[fieldKey] = {
+          table: target.name,
+          column: target.fields[reference.field]?.name ?? reference.field
+        };
+      }
+      collectedModels.push({
+        ownerKey,
+        modelKey,
+        modelName: model.name,
+        exportName: toCamelCase(`${ownerKey}_${modelKey}`),
+        prismaModelName: toPascalCase(`${ownerKey}_${modelKey}`),
+        model,
+        ...Object.keys(referenceTargets).length > 0 ? { referenceTargets } : {}
+      });
+    }
+  }
+  return collectedModels;
+}
+__name(collectSchemaModels, "collectSchemaModels");
+function generateSqlStatements(models, dialect) {
+  const modelLookup = createModelLookup(models);
+  const orderedModels = orderSchemaModelsByReferences(models, modelLookup);
+  const statements = [];
+  for (const model of orderedModels) {
+    statements.push({
+      kind: "table",
+      target: model.modelName,
+      sql: renderSqlTable(model, dialect, modelLookup)
+    });
+    for (const index of renderSqlIndexes(model, dialect)) {
+      statements.push(index);
+    }
+  }
+  return statements;
+}
+__name(generateSqlStatements, "generateSqlStatements");
+function renderSqlSchemaFile(models, dialect) {
+  const lines = ["-- Generated by Farm.js CLI. Review before applying.", ""];
+  const modelLookup = createModelLookup(models);
+  const orderedModels = orderSchemaModelsByReferences(models, modelLookup);
+  for (const model of orderedModels) {
+    lines.push(
+      `-- Owner "${model.ownerKey}" model "${model.modelKey}"`,
+      renderSqlTable(model, dialect, modelLookup),
+      ""
+    );
+    for (const statement of renderSqlIndexes(model, dialect)) {
+      lines.push(statement.sql, "");
+    }
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+__name(renderSqlSchemaFile, "renderSqlSchemaFile");
+function renderSqlTable(model, dialect, modelLookup) {
+  const tableName = quoteSqlIdentifier(dialect, model.modelName);
+  const lines = [`CREATE TABLE IF NOT EXISTS ${tableName} (`];
+  const columns = [];
+  const internalReferences = createInternalReferenceLookup(model, dialect, modelLookup);
+  for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+    assertNoSchemaListField(
+      field,
+      `${model.ownerKey}.${model.modelKey}.${fieldKey}`,
+      `${dialect} SQL generation`
+    );
+    const parts = [
+      `  ${quoteSqlIdentifier(dialect, field.name)}`,
+      getSqlColumnType(field, dialect)
+    ];
+    if (field.primaryKey) {
+      parts.push("PRIMARY KEY");
+    } else if (!isNullableField(field)) {
+      parts.push("NOT NULL");
+    }
+    if (!field.primaryKey && field.unique) {
+      parts.push("UNIQUE");
+    }
+    const defaultValue = getSqlDefaultExpression(field, dialect);
+    if (defaultValue) {
+      parts.push(`DEFAULT ${defaultValue}`);
+    }
+    const crossOwner = model.foreignKeys?.[fieldKey];
+    const reference = internalReferences.get(fieldKey) ?? (crossOwner ? `REFERENCES ${quoteSqlIdentifier(dialect, crossOwner.table)} (${quoteSqlIdentifier(dialect, crossOwner.column)})${crossOwner.onDelete !== "noAction" ? ` ON DELETE ${SQL_ON_DELETE_ACTIONS[crossOwner.onDelete]}` : ""}` : void 0);
+    if (reference) {
+      parts.push(reference);
+    } else if (field.reference) {
+      parts.push(
+        `/* references ${describeSchemaReference(model, fieldKey)}${field.reference.onDelete ? ` on delete ${field.reference.onDelete}` : ""} */`
+      );
+    }
+    columns.push(parts.join(" "));
+  }
+  if (dialect === "mysql") {
+    for (const definition of collectSchemaIndexes(model, dialect)) {
+      columns.push(
+        `  ${definition.unique ? "UNIQUE KEY" : "KEY"} ${quoteSqlIdentifier(dialect, definition.name)} (${definition.columns.join(", ")})`
+      );
+    }
+  }
+  lines.push(columns.join(",\n"));
+  lines.push(");");
+  return lines.join("\n");
+}
+__name(renderSqlTable, "renderSqlTable");
+function collectSchemaIndexes(model, dialect) {
+  const definitions = [];
+  for (const field of Object.values(model.model.fields)) {
+    if (!field.index) {
+      continue;
+    }
+    definitions.push({
+      name: fitSqlIndexName(dialect, `${model.modelName}_${field.name}_idx`),
+      columns: [quoteSqlIdentifier(dialect, field.name)],
+      unique: false
+    });
+  }
+  for (const constraint of model.model.constraints || []) {
+    definitions.push({
+      name: fitSqlIndexName(
+        dialect,
+        constraint.name || `${model.modelName}_${constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name || fieldKey).join("_")}_${constraint.type}`
+      ),
+      columns: constraint.fields.map(
+        (fieldKey) => quoteSqlIdentifier(dialect, model.model.fields[fieldKey]?.name || fieldKey)
+      ),
+      unique: constraint.type === "unique"
+    });
+  }
+  return definitions;
+}
+__name(collectSchemaIndexes, "collectSchemaIndexes");
+function renderSqlIndexes(model, dialect) {
+  if (dialect === "mysql") {
+    return [];
+  }
+  const tableName = quoteSqlIdentifier(dialect, model.modelName);
+  return collectSchemaIndexes(model, dialect).map((definition) => ({
+    kind: "index",
+    target: definition.name,
+    sql: `CREATE ${definition.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${quoteSqlIdentifier(dialect, definition.name)} ON ${tableName} (${definition.columns.join(", ")});`
+  }));
+}
+__name(renderSqlIndexes, "renderSqlIndexes");
+function createInternalReferenceLookup(model, dialect, modelLookup) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+    if (!field.reference || !isDatabaseEnforcedReference(field.reference)) {
+      continue;
+    }
+    const referencedModel = modelLookup.get(`${model.ownerKey}.${field.reference.model}`);
+    if (referencedModel) {
+      const referencedField = field.reference.field;
+      const pieces = [
+        `REFERENCES ${quoteSqlIdentifier(dialect, referencedModel.modelName)} (${quoteSqlIdentifier(dialect, referencedModel.model.fields[referencedField]?.name || referencedField)})`
+      ];
+      if (field.reference.onDelete) {
+        pieces.push(`ON DELETE ${SQL_ON_DELETE_ACTIONS[field.reference.onDelete]}`);
+      }
+      lookup.set(fieldKey, pieces.join(" "));
+    }
+  }
+  return lookup;
+}
+__name(createInternalReferenceLookup, "createInternalReferenceLookup");
+function getSqlColumnType(field, dialect) {
+  if (dialect === "postgres") {
+    switch (field.type) {
+      case "boolean":
+        return "BOOLEAN";
+      case "integer":
+        return "INTEGER";
+      case "number":
+        return "DOUBLE PRECISION";
+      case "datetime":
+        return "TIMESTAMPTZ";
+      case "json":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  }
+  if (dialect === "mysql") {
+    switch (field.type) {
+      case "boolean":
+        return "BOOLEAN";
+      case "integer":
+        return "INT";
+      case "number":
+        return "DOUBLE";
+      case "datetime":
+        return "DATETIME";
+      case "json":
+        return "JSON";
+      case "text":
+        return "TEXT";
+      default:
+        return "VARCHAR(255)";
+    }
+  }
+  switch (field.type) {
+    case "boolean":
+    case "integer":
+      return "INTEGER";
+    case "number":
+      return "REAL";
+    default:
+      return "TEXT";
+  }
+}
+__name(getSqlColumnType, "getSqlColumnType");
+function getSqlDefaultExpression(field, dialect) {
+  if (field.default === void 0) {
+    return null;
+  }
+  if (field.type === "datetime" && field.default === "now") {
+    return "CURRENT_TIMESTAMP";
+  }
+  if (typeof field.default === "string") {
+    return `'${escapeSqlString(field.default, dialect)}'`;
+  }
+  if (typeof field.default === "number") {
+    return String(field.default);
+  }
+  if (typeof field.default === "boolean") {
+    if (dialect === "sqlite") {
+      return field.default ? "1" : "0";
+    }
+    return field.default ? "TRUE" : "FALSE";
+  }
+  return null;
+}
+__name(getSqlDefaultExpression, "getSqlDefaultExpression");
+function isNullableField(field) {
+  return field.nullable === true || field.required === false;
+}
+__name(isNullableField, "isNullableField");
+function quoteSqlIdentifier(dialect, value) {
+  if (dialect === "mysql") {
+    return `\`${value.replace(/`/g, "``")}\``;
+  }
+  return `"${value.replace(/"/g, '""')}"`;
+}
+__name(quoteSqlIdentifier, "quoteSqlIdentifier");
+function createModelLookup(models) {
+  return new Map(models.map((model) => [`${model.ownerKey}.${model.modelKey}`, model]));
+}
+__name(createModelLookup, "createModelLookup");
+function orderSchemaModelsByReferences(models, modelLookup) {
+  const ordered = [];
+  const states = /* @__PURE__ */ new Map();
+  const stack = [];
+  const visit = /* @__PURE__ */ __name((model) => {
+    const modelKey = getCollectedModelKey(model);
+    if (states.get(modelKey) === "visited") {
+      return;
+    }
+    states.set(modelKey, "visiting");
+    stack.push(model);
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const field of Object.values(model.model.fields)) {
+      if (field.reference && isDatabaseEnforcedReference(field.reference)) {
+        dependencies.add(`${model.ownerKey}.${field.reference.model}`);
+      }
+    }
+    for (const dependencyKey of dependencies) {
+      const dependency = modelLookup.get(dependencyKey);
+      if (!dependency || dependency === model) {
+        continue;
+      }
+      if (states.get(dependencyKey) === "visiting") {
+        const cycleStart = stack.findIndex(
+          (candidate) => getCollectedModelKey(candidate) === dependencyKey
+        );
+        const cycle = [...stack.slice(cycleStart), dependency].map((candidate) => `"${getCollectedModelKey(candidate)}"`).join(" -> ");
+        throw new Error(
+          `Schema table references contain a cycle: ${cycle}. Database-enforced cross-table cycles cannot be created inline; remove one edge or manage that constraint separately.`
+        );
+      }
+      visit(dependency);
+    }
+    stack.pop();
+    states.set(modelKey, "visited");
+    ordered.push(model);
+  }, "visit");
+  for (const model of models) {
+    visit(model);
+  }
+  return ordered;
+}
+__name(orderSchemaModelsByReferences, "orderSchemaModelsByReferences");
+function getCollectedModelKey(model) {
+  return `${model.ownerKey}.${model.modelKey}`;
+}
+__name(getCollectedModelKey, "getCollectedModelKey");
+function toSnakeCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s.-]+/g, "_").replace(/__+/g, "_").toLowerCase();
+}
+__name(toSnakeCase, "toSnakeCase");
+function toPascalCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[\s._-]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function toCamelCase(value) {
+  const pascal = toPascalCase(value);
+  return pascal ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : pascal;
+}
+__name(toCamelCase, "toCamelCase");
+function escapeSqlString(value, dialect) {
+  const quoted = value.replace(/'/g, "''");
+  return dialect === "mysql" ? quoted.replace(/\\/g, "\\\\") : quoted;
+}
+__name(escapeSqlString, "escapeSqlString");
+
+// src/schema-migrate.ts
+async function planSchemaMigration(models, dialect, executor) {
+  const statements = [];
+  const upToDate = [];
+  const drift = [];
+  const addableForeignKeys = [];
+  const upgrades = [];
+  const modelLookup = new Map(
+    models.map((model) => [`${model.ownerKey}.${model.modelKey}`, model])
+  );
+  const byTable = /* @__PURE__ */ new Map();
+  let currentTable;
+  for (const statement of generateSqlStatements(models, dialect)) {
+    if (statement.kind === "table") {
+      currentTable = [];
+      byTable.set(statement.target, currentTable);
+    }
+    currentTable?.push(statement);
+  }
+  for (const model of models) {
+    const existing = await describeTable(executor, dialect, model.modelName);
+    if (!existing) {
+      statements.push(...byTable.get(model.modelName) ?? []);
+      continue;
+    }
+    const expectedColumns = new Map(
+      Object.values(model.model.fields).map((field) => [field.name.toLowerCase(), field])
+    );
+    const actualColumns = new Map(
+      existing.columns.map((column) => [column.name.toLowerCase(), column])
+    );
+    const missingColumns = [...expectedColumns.values()].filter((field) => !actualColumns.has(field.name.toLowerCase())).map((field) => field.name);
+    const extraColumns = existing.columns.filter((column) => !expectedColumns.has(column.name.toLowerCase())).map((column) => column.name);
+    const changedColumns = [];
+    for (const [columnKey, field] of expectedColumns) {
+      const actualColumn = actualColumns.get(columnKey);
+      if (!actualColumn) continue;
+      const expectedDefinition = expectedColumnDefinition(field, dialect);
+      const actualDefinition = actualColumnDefinition(actualColumn, field, dialect);
+      const differences = [];
+      if (expectedDefinition.type !== actualDefinition.type) differences.push("type");
+      if (expectedDefinition.nullable !== actualDefinition.nullable) {
+        differences.push("nullability");
+      }
+      if (expectedDefinition.default !== actualDefinition.default) differences.push("default");
+      if (expectedDefinition.primaryKey !== actualDefinition.primaryKey) {
+        differences.push("primaryKey");
+      }
+      if (differences.length > 0) {
+        changedColumns.push({
+          column: field.name,
+          differences,
+          expected: expectedDefinition,
+          actual: actualDefinition
+        });
+      }
+    }
+    const expectedIndexes = collectExpectedIndexes(model);
+    const actualIndexes = existing.indexes.filter((index) => !index.primary);
+    const { missing: missingIndexes, extra: unmatchedIndexes } = compareDefinitions(
+      expectedIndexes,
+      actualIndexes,
+      indexSignature
+    );
+    const expectedReferences = collectExpectedReferences(model, modelLookup);
+    const crossOwner = Object.entries(model.foreignKeys ?? {}).map(([fieldKey, key]) => ({
+      ...key,
+      column: model.model.fields[fieldKey].name,
+      referencedColumn: key.column
+    }));
+    const isCrossOwnerOf = /* @__PURE__ */ __name((key) => (reference) => key.column.toLowerCase() === reference.column.toLowerCase() && key.table.toLowerCase() === reference.referencedTable.toLowerCase(), "isCrossOwnerOf");
+    const isCrossOwner = /* @__PURE__ */ __name((reference) => crossOwner.some((key) => isCrossOwnerOf(key)(reference)), "isCrossOwner");
+    const { missing: missingReferences, extra: unmatchedReferences } = compareDefinitions(
+      expectedReferences,
+      existing.references,
+      referenceSignature
+    );
+    const extraReferences = unmatchedReferences.filter((reference) => !isCrossOwner(reference));
+    for (const key of crossOwner) {
+      if (existing.references.some(isCrossOwnerOf(key))) continue;
+      addableForeignKeys.push({
+        modelKey: model.modelKey,
+        table: model.modelName,
+        column: key.column,
+        referencedTable: key.table,
+        referencedColumn: key.referencedColumn,
+        onDelete: key.onDelete
+      });
+    }
+    const referenceColumns = new Set(
+      existing.references.map((reference) => reference.column.toLowerCase())
+    );
+    const extraIndexes = unmatchedIndexes.filter(
+      (index) => !(dialect === "mysql" && !index.unique && index.columns.length === 1 && referenceColumns.has(index.columns[0].toLowerCase()))
+    );
+    const remainingColumns = [];
+    for (const column of missingColumns) {
+      const field = expectedColumns.get(column.toLowerCase());
+      if (field.primaryKey || field.unique || unsupportedColumnReason(field, dialect)) {
+        remainingColumns.push(column);
+        continue;
+      }
+      upgrades.push({
+        kind: "column",
+        table: model.modelName,
+        target: `${model.modelName}.${column}`,
+        sql: addColumnStatement(dialect, model.modelName, field)
+      });
+    }
+    const remainingIndexes = [];
+    for (const index of missingIndexes) {
+      const columnsExist = index.columns.every(
+        (column) => actualColumns.has(column.toLowerCase()) || !remainingColumns.includes(column)
+      );
+      if (index.unique || !columnsExist) {
+        remainingIndexes.push(index);
+        continue;
+      }
+      const columns = index.columns.map((column) => quoteSqlIdentifier(dialect, column)).join(", ");
+      const name = fitSqlIndexName(dialect, index.name);
+      upgrades.push({
+        kind: "index",
+        table: model.modelName,
+        target: name,
+        sql: `CREATE INDEX${dialect === "mysql" ? "" : " IF NOT EXISTS"} ${quoteSqlIdentifier(dialect, name)} ON ${quoteTableName(dialect, model.modelName)} (${columns});`
+      });
+    }
+    const entry = {
+      table: model.modelName,
+      missingColumns: remainingColumns,
+      extraColumns,
+      changedColumns,
+      missingIndexes: remainingIndexes,
+      extraIndexes: extraIndexes.map(({ name, columns, unique }) => ({ name, columns, unique })),
+      missingReferences,
+      extraReferences
+    };
+    if (hasSchemaDrift(entry)) drift.push(entry);
+    else if (!upgrades.some((upgrade) => upgrade.table === model.modelName)) {
+      upToDate.push(model.modelName);
+    }
+  }
+  return { dialect, statements, upgrades, upToDate, drift, addableForeignKeys };
+}
+__name(planSchemaMigration, "planSchemaMigration");
+async function describeSchemaTable(executor, dialect, table) {
+  const described = await describeTable(executor, dialect, table);
+  if (!described) {
+    if (dialect === "sqlite") return void 0;
+    const dot = table.indexOf(".");
+    if (dot > 0) {
+      return describeQualifiedTable(executor, dialect, table.slice(0, dot), table.slice(dot + 1));
+    }
+    if (dialect === "postgres") {
+      const schema = await findOnSearchPath(executor, table);
+      return schema ? describeQualifiedTable(executor, dialect, schema, table) : void 0;
+    }
+    return void 0;
+  }
+  return {
+    columns: described.columns.map(({ name, type, nullable, primaryKey }) => ({
+      name,
+      type,
+      nullable,
+      primaryKey
+    }))
+  };
+}
+__name(describeSchemaTable, "describeSchemaTable");
+async function describeQualifiedTable(executor, dialect, schema, table) {
+  const rows = await executor.query(
+    dialect === "mysql" ? "select column_name, column_type as type, is_nullable from information_schema.columns where table_schema = ? and table_name = ? order by ordinal_position" : "select column_name, data_type as type, is_nullable from information_schema.columns where table_schema = $1 and table_name = $2 order by ordinal_position",
+    [schema, table]
+  );
+  if (rows.length === 0) return void 0;
+  return {
+    columns: rows.map((row) => ({
+      name: String(readRowValue(row, "column_name")),
+      type: normalizeColumnType(dialect, String(readRowValue(row, "type"))),
+      nullable: String(readRowValue(row, "is_nullable")).toUpperCase() === "YES",
+      primaryKey: false
+    }))
+  };
+}
+__name(describeQualifiedTable, "describeQualifiedTable");
+async function findOnSearchPath(executor, table) {
+  const rows = await executor.query(
+    `select namespace.nspname as schema_name
+       from unnest(current_schemas(false)) with ordinality as path(name, position)
+       join pg_namespace namespace on namespace.nspname = path.name
+       join pg_class relation on relation.relnamespace = namespace.oid
+      where relation.relname = $1 and relation.relkind in ('r', 'p', 'v', 'f')
+      order by path.position
+      limit 1`,
+    [table]
+  );
+  const schema = rows[0] && readRowValue(rows[0], "schema_name");
+  return schema ? String(schema) : void 0;
+}
+__name(findOnSearchPath, "findOnSearchPath");
+async function describeTable(executor, dialect, table) {
+  if (dialect === "sqlite") {
+    return describeSqliteTable(executor, table);
+  }
+  const [sql, params] = dialect === "mysql" ? [
+    "select column_name, data_type, column_type, is_nullable, column_default from information_schema.columns where table_name = ? and table_schema = database() order by ordinal_position",
+    [table]
+  ] : [
+    "select column_name, data_type, udt_name, is_nullable, column_default from information_schema.columns where table_name = $1 and table_schema = current_schema() order by ordinal_position",
+    [table]
+  ];
+  const rows = await executor.query(sql, params);
+  if (rows.length === 0) return void 0;
+  const columns = rows.map((row) => ({
+    name: String(readRowValue(row, "column_name")),
+    type: normalizeColumnType(
+      dialect,
+      String(
+        readRowValue(row, dialect === "mysql" ? "column_type" : "data_type") ?? readRowValue(row, "data_type")
+      )
+    ),
+    nullable: String(readRowValue(row, "is_nullable")).toUpperCase() === "YES",
+    rawDefault: nullableString(readRowValue(row, "column_default")),
+    primaryKey: false
+  }));
+  const indexes = await describeServerIndexes(executor, dialect, table);
+  const primaryColumns = new Set(
+    indexes.filter((index) => index.primary).flatMap((index) => index.columns.map((column) => column.toLowerCase()))
+  );
+  for (const column of columns) {
+    if (primaryColumns.has(column.name.toLowerCase())) {
+      column.primaryKey = true;
+      column.nullable = false;
+    }
+  }
+  return {
+    columns,
+    indexes,
+    references: await describeServerReferences(executor, dialect, table)
+  };
+}
+__name(describeTable, "describeTable");
+async function describeSqliteTable(executor, table) {
+  const escapedTable = escapeSqlitePragmaValue(table);
+  const rows = await executor.query(`pragma table_info('${escapedTable}')`);
+  if (rows.length === 0) return void 0;
+  const columns = rows.map((row) => {
+    const primaryKey = Number(readRowValue(row, "pk") ?? 0) > 0;
+    return {
+      name: String(readRowValue(row, "name")),
+      type: normalizeColumnType("sqlite", String(readRowValue(row, "type") ?? "")),
+      nullable: !primaryKey && Number(readRowValue(row, "notnull") ?? 0) === 0,
+      rawDefault: nullableString(readRowValue(row, "dflt_value")),
+      primaryKey
+    };
+  });
+  const indexRows = await executor.query(`pragma index_list('${escapedTable}')`);
+  const indexes = [];
+  for (const row of indexRows) {
+    const name = String(readRowValue(row, "name"));
+    const columnRows = await executor.query(
+      `pragma index_info('${escapeSqlitePragmaValue(name)}')`
+    );
+    indexes.push({
+      name,
+      columns: columnRows.sort(
+        (left, right) => Number(readRowValue(left, "seqno") ?? 0) - Number(readRowValue(right, "seqno") ?? 0)
+      ).map((column) => String(readRowValue(column, "name"))),
+      unique: asBoolean(readRowValue(row, "unique")),
+      primary: String(readRowValue(row, "origin") ?? "").toLowerCase() === "pk"
+    });
+  }
+  const referenceRows = await executor.query(`pragma foreign_key_list('${escapedTable}')`);
+  return {
+    columns,
+    indexes,
+    references: referenceRows.map((row) => ({
+      column: String(readRowValue(row, "from")),
+      referencedTable: String(readRowValue(row, "table")),
+      referencedColumn: String(readRowValue(row, "to")),
+      onDelete: normalizeDeleteAction(readRowValue(row, "on_delete"))
+    }))
+  };
+}
+__name(describeSqliteTable, "describeSqliteTable");
+async function describeServerIndexes(executor, dialect, table) {
+  const [sql, params] = dialect === "mysql" ? [
+    "select index_name, non_unique, column_name, seq_in_index from information_schema.statistics where table_name = ? and table_schema = database() order by index_name, seq_in_index",
+    [table]
+  ] : [
+    `select index_class.relname as index_name,
+                  index_info.indisunique as is_unique,
+                  index_info.indisprimary as is_primary,
+                  attribute.attname as column_name,
+                  index_key.column_position
+             from pg_catalog.pg_class table_class
+             join pg_catalog.pg_namespace namespace on namespace.oid = table_class.relnamespace
+             join pg_catalog.pg_index index_info on index_info.indrelid = table_class.oid
+             join pg_catalog.pg_class index_class on index_class.oid = index_info.indexrelid
+             join lateral unnest(index_info.indkey) with ordinality as index_key(attnum, column_position) on true
+             left join pg_catalog.pg_attribute attribute
+               on attribute.attrelid = table_class.oid and attribute.attnum = index_key.attnum
+            where table_class.relname = $1
+              and namespace.nspname = current_schema()
+              and index_key.column_position <= index_info.indnkeyatts
+            order by index_class.relname, index_key.column_position`,
+    [table]
+  ];
+  const rows = await executor.query(sql, params);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const name = String(readRowValue(row, "index_name"));
+    const index = grouped.get(name) ?? {
+      name,
+      columns: [],
+      unique: dialect === "mysql" ? Number(readRowValue(row, "non_unique") ?? 1) === 0 : asBoolean(readRowValue(row, "is_unique")),
+      primary: dialect === "mysql" ? name.toUpperCase() === "PRIMARY" : asBoolean(readRowValue(row, "is_primary")),
+      orderedColumns: []
+    };
+    const column = readRowValue(row, "column_name");
+    if (column !== void 0 && column !== null) {
+      index.orderedColumns.push({
+        position: Number(
+          readRowValue(row, dialect === "mysql" ? "seq_in_index" : "column_position") ?? 0
+        ),
+        name: String(column)
+      });
+    }
+    grouped.set(name, index);
+  }
+  return [...grouped.values()].map(({ orderedColumns, ...index }) => ({
+    ...index,
+    columns: orderedColumns.sort((left, right) => left.position - right.position).map((column) => column.name)
+  }));
+}
+__name(describeServerIndexes, "describeServerIndexes");
+async function describeServerReferences(executor, dialect, table) {
+  const [sql, params] = dialect === "mysql" ? [
+    `select key_columns.column_name,
+                  key_columns.referenced_table_name as referenced_table,
+                  key_columns.referenced_column_name as referenced_column,
+                  referential.delete_rule
+             from information_schema.key_column_usage key_columns
+             join information_schema.referential_constraints referential
+               on referential.constraint_schema = key_columns.constraint_schema
+              and referential.constraint_name = key_columns.constraint_name
+              and referential.table_name = key_columns.table_name
+            where key_columns.table_schema = database()
+              and key_columns.table_name = ?
+              and key_columns.referenced_table_name is not null
+            order by key_columns.constraint_name, key_columns.ordinal_position`,
+    [table]
+  ] : [
+    `select key_columns.column_name,
+                  referenced_columns.table_name as referenced_table,
+                  referenced_columns.column_name as referenced_column,
+                  referential.delete_rule
+             from information_schema.table_constraints constraints
+             join information_schema.key_column_usage key_columns
+               on key_columns.constraint_catalog = constraints.constraint_catalog
+              and key_columns.constraint_schema = constraints.constraint_schema
+              and key_columns.constraint_name = constraints.constraint_name
+             join information_schema.referential_constraints referential
+               on referential.constraint_catalog = constraints.constraint_catalog
+              and referential.constraint_schema = constraints.constraint_schema
+              and referential.constraint_name = constraints.constraint_name
+             join information_schema.constraint_column_usage referenced_columns
+               on referenced_columns.constraint_catalog = referential.unique_constraint_catalog
+              and referenced_columns.constraint_schema = referential.unique_constraint_schema
+              and referenced_columns.constraint_name = referential.unique_constraint_name
+            where constraints.constraint_type = 'FOREIGN KEY'
+              and constraints.table_schema = current_schema()
+              and constraints.table_name = $1
+            order by constraints.constraint_name, key_columns.ordinal_position`,
+    [table]
+  ];
+  const rows = await executor.query(sql, params);
+  return rows.map((row) => ({
+    column: String(readRowValue(row, "column_name")),
+    referencedTable: String(readRowValue(row, "referenced_table")),
+    referencedColumn: String(readRowValue(row, "referenced_column")),
+    onDelete: normalizeDeleteAction(readRowValue(row, "delete_rule"))
+  }));
+}
+__name(describeServerReferences, "describeServerReferences");
+function expectedColumnDefinition(field, dialect) {
+  return {
+    type: normalizeColumnType(dialect, getSqlColumnType(field, dialect)),
+    nullable: !field.primaryKey && isNullableField(field),
+    default: expectedDefault(field),
+    primaryKey: field.primaryKey === true
+  };
+}
+__name(expectedColumnDefinition, "expectedColumnDefinition");
+function actualColumnDefinition(column, field, dialect) {
+  return {
+    type: column.type,
+    nullable: column.nullable,
+    default: normalizeDatabaseDefault(column.rawDefault, field, dialect),
+    primaryKey: column.primaryKey
+  };
+}
+__name(actualColumnDefinition, "actualColumnDefinition");
+function expectedDefault(field) {
+  if (field.default === void 0) return null;
+  if (field.type === "datetime" && field.default === "now") return "CURRENT_TIMESTAMP";
+  if (typeof field.default === "string") return JSON.stringify(field.default);
+  if (typeof field.default === "number" || typeof field.default === "boolean") {
+    return String(field.default);
+  }
+  return null;
+}
+__name(expectedDefault, "expectedDefault");
+function normalizeDatabaseDefault(value, field, dialect) {
+  if (value === null) return null;
+  let normalized = stripWrappingParentheses(value.trim());
+  if (dialect === "postgres") {
+    normalized = normalized.replace(/::[\w\s"]+$/u, "");
+  }
+  if (field.type === "datetime" && /^(?:current_timestamp(?:\(\d+\))?|now\(\))$/iu.test(normalized)) {
+    return "CURRENT_TIMESTAMP";
+  }
+  if (field.type === "boolean") {
+    const booleanValue = stripSqlQuotes(normalized).toLowerCase();
+    if (["1", "true", "t", "b'1'"].includes(booleanValue)) return "true";
+    if (["0", "false", "f", "b'0'"].includes(booleanValue)) return "false";
+  }
+  if (field.type === "integer" || field.type === "number") {
+    return stripSqlQuotes(normalized);
+  }
+  if (["id", "uuid", "string", "text", "enum", "datetime"].includes(field.type)) {
+    return JSON.stringify(stripSqlQuotes(normalized).replace(/''/gu, "'"));
+  }
+  return normalized.toUpperCase();
+}
+__name(normalizeDatabaseDefault, "normalizeDatabaseDefault");
+function normalizeColumnType(dialect, value) {
+  const type = value.trim().toLowerCase().replace(/\s+/gu, " ");
+  if (dialect === "sqlite") {
+    if (/int/u.test(type)) return "integer";
+    if (/(?:char|clob|text)/u.test(type)) return "text";
+    if (/(?:real|floa|doub)/u.test(type)) return "real";
+    if (/blob/u.test(type) || type === "") return "blob";
+    return "numeric";
+  }
+  if (dialect === "mysql") {
+    if (/^(?:bool|boolean|tinyint\(1\))/u.test(type)) return "boolean";
+    if (/^(?:int|integer)(?:\(\d+\))?/u.test(type)) return "integer";
+    if (/^(?:double|double precision)/u.test(type)) return "double";
+    return type;
+  }
+  if (["int4", "integer"].includes(type)) return "integer";
+  if (["float8", "double precision"].includes(type)) return "double precision";
+  if (["timestamptz", "timestamp with time zone"].includes(type)) return "timestamptz";
+  return type;
+}
+__name(normalizeColumnType, "normalizeColumnType");
+function collectExpectedIndexes(model) {
+  const indexes = [];
+  for (const field of Object.values(model.model.fields)) {
+    if (field.index) {
+      indexes.push({
+        name: `${model.modelName}_${field.name}_idx`,
+        columns: [field.name],
+        unique: false
+      });
+    }
+    if (!field.primaryKey && field.unique) {
+      indexes.push({
+        name: `${model.modelName}_${field.name}_unique`,
+        columns: [field.name],
+        unique: true
+      });
+    }
+  }
+  for (const constraint of model.model.constraints ?? []) {
+    indexes.push({
+      name: constraint.name ?? `${model.modelName}_${constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name ?? fieldKey).join("_")}_${constraint.type}`,
+      columns: constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name ?? fieldKey),
+      unique: constraint.type === "unique"
+    });
+  }
+  return indexes;
+}
+__name(collectExpectedIndexes, "collectExpectedIndexes");
+function collectExpectedReferences(model, modelLookup) {
+  const references = [];
+  for (const field of Object.values(model.model.fields)) {
+    if (!field.reference || !isDatabaseEnforcedReference(field.reference)) continue;
+    const target = modelLookup.get(`${model.ownerKey}.${field.reference.model}`);
+    if (!target) continue;
+    references.push({
+      column: field.name,
+      referencedTable: target.modelName,
+      referencedColumn: target.model.fields[field.reference.field]?.name ?? field.reference.field,
+      onDelete: field.reference.onDelete ?? "noAction"
+    });
+  }
+  return references;
+}
+__name(collectExpectedReferences, "collectExpectedReferences");
+function compareDefinitions(expected, actual, signature) {
+  const remaining = [...actual];
+  const missing = [];
+  for (const expectedValue of expected) {
+    const expectedSignature = signature(expectedValue);
+    const actualIndex = remaining.findIndex(
+      (actualValue) => signature(actualValue) === expectedSignature
+    );
+    if (actualIndex === -1) missing.push(expectedValue);
+    else remaining.splice(actualIndex, 1);
+  }
+  return { missing, extra: remaining };
+}
+__name(compareDefinitions, "compareDefinitions");
+function indexSignature(index) {
+  return `${index.unique ? "unique" : "index"}:${index.columns.map((column) => column.toLowerCase()).join(",")}`;
+}
+__name(indexSignature, "indexSignature");
+function referenceSignature(reference) {
+  return [
+    reference.column,
+    reference.referencedTable,
+    reference.referencedColumn,
+    reference.onDelete
+  ].map((value) => value.toLowerCase()).join(":");
+}
+__name(referenceSignature, "referenceSignature");
+function hasSchemaDrift(drift) {
+  return drift.missingColumns.length > 0 || drift.extraColumns.length > 0 || drift.changedColumns.length > 0 || drift.missingIndexes.length > 0 || drift.extraIndexes.length > 0 || drift.missingReferences.length > 0 || drift.extraReferences.length > 0;
+}
+__name(hasSchemaDrift, "hasSchemaDrift");
+function readRowValue(row, name) {
+  return row[name] ?? row[name.toUpperCase()];
+}
+__name(readRowValue, "readRowValue");
+function nullableString(value) {
+  return value === void 0 || value === null ? null : String(value);
+}
+__name(nullableString, "nullableString");
+function asBoolean(value) {
+  return value === true || value === 1 || value === "1" || String(value).toLowerCase() === "true";
+}
+__name(asBoolean, "asBoolean");
+function normalizeDeleteAction(value) {
+  switch (String(value ?? "NO ACTION").toUpperCase().replace(/[_\s]+/gu, "")) {
+    case "CASCADE":
+      return "cascade";
+    case "RESTRICT":
+      return "restrict";
+    case "SETNULL":
+      return "setNull";
+    default:
+      return "noAction";
+  }
+}
+__name(normalizeDeleteAction, "normalizeDeleteAction");
+function stripWrappingParentheses(value) {
+  let result = value;
+  while (result.startsWith("(") && result.endsWith(")")) {
+    result = result.slice(1, -1).trim();
+  }
+  return result;
+}
+__name(stripWrappingParentheses, "stripWrappingParentheses");
+function stripSqlQuotes(value) {
+  if (value.length >= 2 && (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"'))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+__name(stripSqlQuotes, "stripSqlQuotes");
+function escapeSqlitePragmaValue(value) {
+  return value.replace(/'/gu, "''");
+}
+__name(escapeSqlitePragmaValue, "escapeSqlitePragmaValue");
+async function applySchemaMigration(plan, executor) {
+  const applied = [];
+  for (const statement of [...plan.statements, ...plan.upgrades ?? []]) {
+    await executor.execute(statement.sql);
+    applied.push(statement.target);
+  }
+  return { applied, skipped: plan.drift };
+}
+__name(applySchemaMigration, "applySchemaMigration");
+function columnTypeFamily(type) {
+  const value = type.trim().toLowerCase();
+  if (/^(bool|boolean|tinyint\(1\))/u.test(value)) return "boolean";
+  if (value.startsWith("uuid")) return "uuid";
+  if (/(char|text|clob|citext|string)/u.test(value)) return "text";
+  if (/^(int|integer|smallint|bigint|mediumint|tinyint|int[248]|serial|bigserial)/u.test(value)) {
+    return "integer";
+  }
+  if (/^(double|real|float|numeric|decimal|number)/u.test(value)) return "number";
+  if (/^(timestamp|datetime|date)/u.test(value)) return "datetime";
+  if (value.startsWith("json")) return "json";
+  return void 0;
+}
+__name(columnTypeFamily, "columnTypeFamily");
+async function planSchemaExtensions(extensions, dialect, executor) {
+  const plan = {
+    statements: [],
+    present: [],
+    missingTables: [],
+    conflicts: [],
+    unsupported: []
+  };
+  for (const extension of extensions) {
+    const table = await describeSchemaTable(executor, dialect, extension.table);
+    if (!table) {
+      plan.missingTables.push(extension);
+      continue;
+    }
+    for (const { fieldKey, field } of extension.fields) {
+      const existing = table.columns.find(
+        (column) => dialect === "postgres" ? column.name === field.name : column.name.toLowerCase() === field.name.toLowerCase()
+      );
+      const expected = getSqlColumnType(field, dialect);
+      if (existing) {
+        const mine = columnTypeFamily(expected);
+        const theirs = columnTypeFamily(existing.type);
+        if (dialect !== "sqlite" && mine && theirs && mine !== theirs) {
+          plan.conflicts.push({ extension, column: field.name, expected, actual: existing.type });
+        } else {
+          plan.present.push(`${extension.table}.${field.name}`);
+        }
+        continue;
+      }
+      const reason = unsupportedColumnReason(field, dialect);
+      if (reason) {
+        plan.unsupported.push({ extension, column: field.name, reason });
+        continue;
+      }
+      plan.statements.push({
+        kind: "column",
+        target: `${extension.table}.${field.name}`,
+        sql: addColumnStatement(dialect, extension.table, field),
+        extension,
+        fieldKey,
+        column: field.name
+      });
+    }
+  }
+  return plan;
+}
+__name(planSchemaExtensions, "planSchemaExtensions");
+function addColumnStatement(dialect, table, field) {
+  const defaultValue = getSqlDefaultExpression(field, dialect);
+  const parts = [
+    `ALTER TABLE ${quoteTableName(dialect, table)} ADD COLUMN`,
+    quoteSqlIdentifier(dialect, field.name),
+    getSqlColumnType(field, dialect),
+    ...isNullableField(field) ? [] : ["NOT NULL"],
+    ...defaultValue ? [`DEFAULT ${defaultValue}`] : []
+  ];
+  return `${parts.join(" ")};`;
+}
+__name(addColumnStatement, "addColumnStatement");
+function unsupportedColumnReason(field, dialect) {
+  const type = getSqlColumnType(field, dialect);
+  const defaultValue = getSqlDefaultExpression(field, dialect);
+  if (dialect === "mysql" && defaultValue && (type === "TEXT" || type === "JSON")) {
+    return `MySQL cannot give a ${type} column a default. Make it nullable without a default.`;
+  }
+  if (dialect === "sqlite" && defaultValue === "CURRENT_TIMESTAMP") {
+    return "SQLite cannot add a column whose default is the current time. Make it nullable.";
+  }
+  if (!isNullableField(field) && !defaultValue) {
+    return "It is required but its default cannot be written in SQL. Make it nullable.";
+  }
+  return void 0;
+}
+__name(unsupportedColumnReason, "unsupportedColumnReason");
+function quoteTableName(dialect, table) {
+  const dot = table.indexOf(".");
+  if (dialect === "sqlite" || dot <= 0) return quoteSqlIdentifier(dialect, table);
+  return `${quoteSqlIdentifier(dialect, table.slice(0, dot))}.${quoteSqlIdentifier(dialect, table.slice(dot + 1))}`;
+}
+__name(quoteTableName, "quoteTableName");
+function formatSchemaMigration(plan, owner, options = {}) {
+  const header = [
+    `-- Generated by \`farm ${owner} migrate\` from the ${owner} schema.`,
+    `-- Dialect: ${plan.dialect}`,
+    options.addsColumns || (plan.upgrades?.length ?? 0) > 0 ? "-- Review before applying. Existing tables only get what is added below; nothing is changed or dropped." : "-- Review before applying. Farm never alters existing tables."
+  ];
+  const upgrades = plan.upgrades ?? [];
+  if (plan.statements.length === 0 && upgrades.length === 0) {
+    header.push("--", "-- Nothing to create: every declared model already has a table.");
+    return `${header.join("\n")}
+`;
+  }
+  const sections = [
+    ...plan.statements.map((statement) => statement.sql),
+    ...upgrades.length > 0 ? [
+      [
+        "-- Added to tables that already exist:",
+        ...upgrades.map((statement) => statement.sql)
+      ].join("\n")
+    ] : []
+  ];
+  return `${header.join("\n")}
+
+${sections.join("\n\n")}
+`;
+}
+__name(formatSchemaMigration, "formatSchemaMigration");
+function describeSchemaDrift(drift) {
+  return drift.map((entry) => {
+    const lines = [`  ${entry.table}`];
+    if (entry.missingColumns.length > 0) {
+      lines.push(`    missing in the database: ${entry.missingColumns.join(", ")}`);
+    }
+    if (entry.extraColumns.length > 0) {
+      lines.push(`    not in the schema: ${entry.extraColumns.join(", ")}`);
+    }
+    for (const column of entry.changedColumns) {
+      const differences = column.differences.map((difference) => {
+        if (difference === "type") {
+          return `type expected ${column.expected.type}, found ${column.actual.type}`;
+        }
+        if (difference === "nullability") {
+          return `nullability expected ${column.expected.nullable ? "nullable" : "required"}, found ${column.actual.nullable ? "nullable" : "required"}`;
+        }
+        if (difference === "default") {
+          return `default expected ${column.expected.default ?? "none"}, found ${column.actual.default ?? "none"}`;
+        }
+        return `primary key expected ${column.expected.primaryKey ? "yes" : "no"}, found ${column.actual.primaryKey ? "yes" : "no"}`;
+      });
+      lines.push(`    changed column ${column.column}: ${differences.join("; ")}`);
+    }
+    if (entry.missingIndexes.length > 0) {
+      lines.push(
+        `    missing indexes: ${entry.missingIndexes.map(formatIndexDefinition).join(", ")}`
+      );
+    }
+    if (entry.extraIndexes.length > 0) {
+      lines.push(
+        `    not in the schema indexes: ${entry.extraIndexes.map(formatIndexDefinition).join(", ")}`
+      );
+    }
+    if (entry.missingReferences.length > 0) {
+      lines.push(
+        `    missing references: ${entry.missingReferences.map(formatReferenceDefinition).join(", ")}`
+      );
+    }
+    if (entry.extraReferences.length > 0) {
+      lines.push(
+        `    not in the schema references: ${entry.extraReferences.map(formatReferenceDefinition).join(", ")}`
+      );
+    }
+    return lines.join("\n");
+  }).join("\n");
+}
+__name(describeSchemaDrift, "describeSchemaDrift");
+function formatIndexDefinition(index) {
+  return `${index.name} (${index.unique ? "unique: " : ""}${index.columns.join(", ")})`;
+}
+__name(formatIndexDefinition, "formatIndexDefinition");
+function formatReferenceDefinition(reference) {
+  return `${reference.column} -> ${reference.referencedTable}.${reference.referencedColumn} on delete ${reference.onDelete}`;
+}
+__name(formatReferenceDefinition, "formatReferenceDefinition");
+function createSchemaExecutor(client, owner) {
+  const candidate = client;
+  if (candidate && typeof candidate.getItem === "function" && typeof candidate.setItem === "function") {
+    return null;
+  }
+  if (typeof candidate?.prepare === "function" && typeof candidate?.exec === "function") {
+    return {
+      dialect: "sqlite",
+      executor: {
+        async execute(sql) {
+          candidate.exec(sql);
+        },
+        async query(sql) {
+          return candidate.prepare(sql).all();
+        }
+      }
+    };
+  }
+  if (typeof candidate?.query === "function") {
+    const isMysqlClient = typeof candidate.escapeId === "function" || typeof candidate.format === "function";
+    return {
+      dialect: isMysqlClient ? "mysql" : "postgres",
+      executor: {
+        async execute(sql) {
+          await candidate.query(sql);
+        },
+        async query(sql, params) {
+          const result = await candidate.query(sql, params);
+          if (Array.isArray(result)) return result[0] ?? [];
+          return result?.rows ?? [];
+        }
+      }
+    };
+  }
+  throw new Error(
+    `${owner}: the configured client cannot run migrations. Pass a pg, mysql, or sqlite connection, or create the tables with your own migration tooling.`
+  );
+}
+__name(createSchemaExecutor, "createSchemaExecutor");
+
+// src/schema-extend.ts
+function collectSchemaExtensions(owner, schema, models) {
+  if (!schema.extend) return [];
+  const resolved = resolveSchemaModels(owner, schema);
+  const extensions = [];
+  for (const [modelKey, extension] of Object.entries(schema.extend)) {
+    const model = resolved[modelKey];
+    if (!model || !model.external && (!models || models.includes(modelKey))) continue;
+    const fields = Object.keys(extension.fields ?? {}).map((fieldKey) => {
+      const field = model.fields[fieldKey];
+      assertAddableColumn(owner, modelKey, fieldKey, field);
+      return { fieldKey, field };
+    });
+    if (fields.length > 0) {
+      extensions.push({ owner, modelKey, table: model.name, fields });
+    }
+  }
+  return extensions;
+}
+__name(collectSchemaExtensions, "collectSchemaExtensions");
+function assertAddableColumn(owner, modelKey, fieldKey, field) {
+  const where = `${owner} adds "${modelKey}.${fieldKey}" to a table it does not own`;
+  if (field.primaryKey || field.unique || field.index || field.list) {
+    const what = field.primaryKey ? "a primary key" : field.unique ? "unique" : field.index ? "indexed" : "a list";
+    throw new Error(`${where}, which cannot be ${what}. Remove it from the extension.`);
+  }
+  if (field.nullable !== true && field.required !== false && field.default === void 0) {
+    throw new Error(
+      `${where}. The table may already have rows, so the column needs a \`default\` or \`nullable: true\`.`
+    );
+  }
+}
+__name(assertAddableColumn, "assertAddableColumn");
+function isSchemaExtensionAllowed(allowExtend, extension) {
+  if (!allowExtend || !Object.prototype.hasOwnProperty.call(allowExtend, extension.owner)) {
+    return false;
+  }
+  const allowed = allowExtend[extension.owner] ?? [];
+  return allowed.includes(extension.modelKey) || allowed.includes(extension.table);
+}
+__name(isSchemaExtensionAllowed, "isSchemaExtensionAllowed");
+function describeSchemaExtensionApproval(extension) {
+  return `schema: { allowExtend: { ${JSON.stringify(extension.owner)}: [${JSON.stringify(extension.modelKey)}] } }`;
+}
+__name(describeSchemaExtensionApproval, "describeSchemaExtensionApproval");
+
+// src/schema-state.ts
+var literal = /* @__PURE__ */ __name((dialect, value) => value === null ? "NULL" : `'${escapeSqlString(value, dialect)}'`, "literal");
+var FARM_SCHEMA_STATE_TABLE = "farm_schema_state";
+function createSchemaSnapshot(models) {
+  const tables = {};
+  for (const model of models) {
+    const columns = {};
+    const indexes = [];
+    for (const field of Object.values(model.model.fields)) {
+      columns[field.name] = {
+        type: field.type,
+        nullable: field.nullable === true || field.required === false,
+        primaryKey: field.primaryKey === true,
+        unique: field.unique === true,
+        ...field.default !== void 0 ? { default: field.default } : {}
+      };
+      if (field.index) indexes.push(`${model.modelName}_${field.name}_idx`);
+    }
+    for (const constraint of model.model.constraints ?? []) {
+      indexes.push(
+        constraint.name ?? `${model.modelName}_${constraint.fields.map((key) => model.model.fields[key]?.name ?? key).join("_")}_${constraint.type}`
+      );
+    }
+    tables[model.modelName] = { columns, indexes: indexes.sort() };
+  }
+  return { tables };
+}
+__name(createSchemaSnapshot, "createSchemaSnapshot");
+function diffSchemaSnapshots(previous, next) {
+  const changes = {
+    addedTables: [],
+    addedColumns: [],
+    addedIndexes: [],
+    otherChanges: [],
+    removedColumns: []
+  };
+  for (const [table, definition] of Object.entries(next.tables)) {
+    const before = previous.tables[table];
+    if (!before) {
+      changes.addedTables.push(table);
+      continue;
+    }
+    for (const [column, columnDefinition] of Object.entries(definition.columns)) {
+      const old = before.columns[column];
+      if (!old) {
+        changes.addedColumns.push({ table, column, type: columnDefinition.type });
+      } else if (JSON.stringify(old) !== JSON.stringify(columnDefinition)) {
+        changes.otherChanges.push(`${table}.${column} is redefined`);
+      }
+    }
+    for (const [column, old] of Object.entries(before.columns)) {
+      if (definition.columns[column]) continue;
+      changes.otherChanges.push(`${table}.${column} is removed`);
+      changes.removedColumns.push({ table, column, type: old.type });
+    }
+    for (const index of definition.indexes) {
+      if (!before.indexes.includes(index)) changes.addedIndexes.push(index);
+    }
+  }
+  for (const table of Object.keys(previous.tables)) {
+    if (!next.tables[table]) changes.otherChanges.push(`${table} is removed`);
+  }
+  return changes;
+}
+__name(diffSchemaSnapshots, "diffSchemaSnapshots");
+function hasSchemaChanges(changes) {
+  return changes.addedTables.length + changes.addedColumns.length + changes.addedIndexes.length + changes.otherChanges.length > 0;
+}
+__name(hasSchemaChanges, "hasSchemaChanges");
+async function readSchemaState(executor, dialect, owner) {
+  const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+  let rows;
+  try {
+    if (!await describeSchemaTable(executor, dialect, FARM_SCHEMA_STATE_TABLE)) return void 0;
+    rows = await executor.query(
+      `SELECT ${q("version")}, ${q("snapshot")}, ${q("applied_at")} FROM ${q(FARM_SCHEMA_STATE_TABLE)} WHERE ${q("owner")} = ${literal(dialect, owner)}`
+    );
+  } catch {
+    return void 0;
+  }
+  const row = rows[0];
+  if (!row) return void 0;
+  const read = /* @__PURE__ */ __name((name) => row[name] ?? row[name.toUpperCase()], "read");
+  try {
+    const snapshot = read("snapshot");
+    return {
+      version: read("version") == null ? void 0 : String(read("version")),
+      snapshot: typeof snapshot === "string" ? JSON.parse(snapshot) : snapshot,
+      appliedAt: String(read("applied_at"))
+    };
+  } catch {
+    return void 0;
+  }
+}
+__name(readSchemaState, "readSchemaState");
+async function writeSchemaState(executor, dialect, owner, state) {
+  const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+  const key = dialect === "mysql" ? "VARCHAR(191)" : "TEXT";
+  await executor.execute(
+    `CREATE TABLE IF NOT EXISTS ${q(FARM_SCHEMA_STATE_TABLE)} (${q("owner")} ${key} PRIMARY KEY, ${q("version")} ${dialect === "mysql" ? "VARCHAR(255)" : "TEXT"}, ${q("snapshot")} ${dialect === "mysql" ? "LONGTEXT" : "TEXT"} NOT NULL, ${q("applied_at")} ${dialect === "mysql" ? "VARCHAR(64)" : "TEXT"} NOT NULL)`
+  );
+  const values = [
+    literal(dialect, owner),
+    literal(dialect, state.version ?? null),
+    literal(dialect, JSON.stringify(state.snapshot)),
+    literal(dialect, (/* @__PURE__ */ new Date()).toISOString())
+  ];
+  await executor.execute(
+    `DELETE FROM ${q(FARM_SCHEMA_STATE_TABLE)} WHERE ${q("owner")} = ${values[0]}`
+  );
+  await executor.execute(
+    `INSERT INTO ${q(FARM_SCHEMA_STATE_TABLE)} (${q("owner")}, ${q("version")}, ${q("snapshot")}, ${q("applied_at")}) VALUES (${values.join(", ")})`
+  );
+}
+__name(writeSchemaState, "writeSchemaState");
+function describeSchemaChanges(changes) {
+  return [
+    ...changes.addedTables.map((table) => `  + ${table}  new table`),
+    ...changes.addedColumns.map(({ table, column, type }) => `  + ${table}.${column}  ${type}`),
+    ...changes.addedIndexes.map((index) => `  + ${index}  index`),
+    ...changes.otherChanges.map((change) => `  ~ ${change}  (Farm will not do this on its own)`)
+  ];
+}
+__name(describeSchemaChanges, "describeSchemaChanges");
+
+// src/schema-steps.ts
+var FARM_SCHEMA_STEPS_TABLE = "farm_schema_steps";
+function schemaStepChecksum(step) {
+  const { description: _description, ...definition } = step;
+  let hash = 2166136261;
+  for (const character of JSON.stringify(definition)) {
+    hash ^= character.codePointAt(0);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+__name(schemaStepChecksum, "schemaStepChecksum");
+var literal2 = /* @__PURE__ */ __name((dialect, value) => `'${escapeSqlString(value, dialect)}'`, "literal");
+async function readAppliedSchemaSteps(executor, dialect, owner) {
+  const applied = /* @__PURE__ */ new Map();
+  try {
+    if (!await describeSchemaTable(executor, dialect, FARM_SCHEMA_STEPS_TABLE)) return applied;
+    const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+    const rows = await executor.query(
+      `SELECT ${q("id")}, ${q("checksum")} FROM ${q(FARM_SCHEMA_STEPS_TABLE)} WHERE ${q("owner")} = ${literal2(dialect, owner)}`
+    );
+    for (const row of rows) {
+      const read = /* @__PURE__ */ __name((name) => row[name] ?? row[name.toUpperCase()], "read");
+      applied.set(String(read("id")), String(read("checksum")));
+    }
+  } catch {
+  }
+  return applied;
+}
+__name(readAppliedSchemaSteps, "readAppliedSchemaSteps");
+function stepsTableStatement(dialect) {
+  const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+  const key = dialect === "mysql" ? "VARCHAR(191)" : "TEXT";
+  return `CREATE TABLE IF NOT EXISTS ${q(FARM_SCHEMA_STEPS_TABLE)} (${q("owner")} ${key} NOT NULL, ${q("id")} ${key} NOT NULL, ${q("checksum")} ${dialect === "mysql" ? "VARCHAR(64)" : "TEXT"} NOT NULL, ${q("applied_at")} ${dialect === "mysql" ? "VARCHAR(64)" : "TEXT"} NOT NULL, PRIMARY KEY (${q("owner")}, ${q("id")}))`;
+}
+__name(stepsTableStatement, "stepsTableStatement");
+function recordStatement(dialect, owner, step) {
+  const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+  return `INSERT INTO ${q(FARM_SCHEMA_STEPS_TABLE)} (${q("owner")}, ${q("id")}, ${q("checksum")}, ${q("applied_at")}) VALUES (${[owner, step.id, schemaStepChecksum(step), (/* @__PURE__ */ new Date()).toISOString()].map((value) => literal2(dialect, value)).join(", ")})`;
+}
+__name(recordStatement, "recordStatement");
+async function planSchemaSteps(input) {
+  const { owner, dialect, executor, applied } = input;
+  const plan = { steps: [], edited: [], fresh: input.fresh };
+  const models = resolveSchemaModels(owner, input.schema);
+  const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+  const columnsOf = /* @__PURE__ */ __name(async (table) => (await describeSchemaTable(executor, dialect, table))?.columns.map((column) => column.name), "columnsOf");
+  const has = /* @__PURE__ */ __name((columns, name) => Boolean(
+    columns?.some(
+      (column) => dialect === "postgres" ? column === name : column.toLowerCase() === name.toLowerCase()
+    )
+  ), "has");
+  for (const step of input.steps) {
+    const recorded = applied.get(step.id);
+    if (recorded !== void 0) {
+      if (recorded !== schemaStepChecksum(step)) plan.edited.push(step.id);
+      continue;
+    }
+    if (input.fresh) {
+      plan.steps.push({
+        step,
+        summary: summarize(step, models),
+        phase: "before",
+        statements: [],
+        state: "record"
+      });
+      continue;
+    }
+    if ("renameColumn" in step) {
+      const table = models[step.renameColumn.model].name;
+      const to = models[step.renameColumn.model].fields[step.renameColumn.to].name;
+      const from = step.renameColumn.from;
+      const columns = await columnsOf(table);
+      const summary = `rename ${table}.${from} \u2192 ${table}.${to}`;
+      const planned = {
+        step,
+        summary,
+        phase: "before",
+        statements: [`ALTER TABLE ${q(table)} RENAME COLUMN ${q(from)} TO ${q(to)}`],
+        state: "run"
+      };
+      if (!columns) {
+        Object.assign(planned, { state: "blocked", reason: `"${table}" does not exist.` });
+      } else if (has(columns, from) && has(columns, to)) {
+        Object.assign(planned, {
+          state: "blocked",
+          reason: `both "${from}" and "${to}" exist, so renaming would lose one. Move the data and drop one column yourself.`
+        });
+      } else if (!has(columns, from)) {
+        Object.assign(planned, {
+          state: has(columns, to) ? "record" : "blocked",
+          statements: [],
+          ...has(columns, to) ? {} : { reason: `"${table}" has neither "${from}" nor "${to}".` }
+        });
+      }
+      plan.steps.push(planned);
+    } else if ("renameTable" in step) {
+      const to = models[step.renameTable.to].name;
+      const from = step.renameTable.from;
+      const summary = `rename table ${from} \u2192 ${to}`;
+      const [hasFrom, hasTo] = [Boolean(await columnsOf(from)), Boolean(await columnsOf(to))];
+      plan.steps.push({
+        step,
+        summary,
+        phase: "before",
+        statements: hasFrom && !hasTo ? [
+          dialect === "mysql" ? `RENAME TABLE ${q(from)} TO ${q(to)}` : `ALTER TABLE ${q(from)} RENAME TO ${q(to)}`
+        ] : [],
+        state: hasFrom && !hasTo ? "run" : hasTo && !hasFrom ? "record" : "blocked",
+        ...hasFrom && hasTo ? { reason: `both "${from}" and "${to}" exist, so renaming would lose one.` } : !hasFrom && !hasTo ? { reason: `neither "${from}" nor "${to}" exists.` } : {}
+      });
+    } else if ("dropColumn" in step) {
+      const table = models[step.dropColumn.model].name;
+      const column = step.dropColumn.column;
+      const columns = await columnsOf(table);
+      const summary = `drop ${table}.${column}`;
+      const created = Boolean(input.recorded?.tables[table]?.columns[column]);
+      const planned = {
+        step,
+        summary,
+        phase: "before",
+        statements: [`ALTER TABLE ${q(table)} DROP COLUMN ${q(column)}`],
+        state: "run",
+        destructive: true
+      };
+      if (!columns) {
+        Object.assign(planned, { state: "blocked", reason: `"${table}" does not exist.` });
+      } else if (!has(columns, column)) {
+        Object.assign(planned, { state: "record", statements: [] });
+      } else if (!created) {
+        Object.assign(planned, {
+          state: "blocked",
+          reason: `Farm has no record of ${owner} creating "${table}.${column}", so it will not drop it. Drop it yourself if it is no longer needed.`
+        });
+      }
+      plan.steps.push(planned);
+    } else if ("dropTable" in step) {
+      const table = step.dropTable.table;
+      const exists = Boolean(await columnsOf(table));
+      const created = Boolean(input.recorded?.tables[table]);
+      const ownedElsewhere = [...input.othersTables ?? []].some(
+        (other) => other.toLowerCase() === table.toLowerCase()
+      );
+      plan.steps.push({
+        step,
+        summary: `drop table ${table}`,
+        phase: "before",
+        statements: exists ? [`DROP TABLE ${q(table)}`] : [],
+        destructive: true,
+        ...!exists ? { state: "record" } : ownedElsewhere ? {
+          state: "blocked",
+          reason: `another plugin creates "${table}", so ${owner} will not drop it.`
+        } : !created ? {
+          state: "blocked",
+          reason: `Farm has no record of ${owner} creating "${table}", so it will not drop it. Drop it yourself if it is no longer needed.`
+        } : { state: "run" }
+      });
+    } else {
+      const sql = step.sql[dialect];
+      const statements = sql === void 0 ? [] : typeof sql === "string" ? [sql] : [...sql];
+      plan.steps.push({
+        step,
+        summary: step.description ?? `custom SQL (${step.id})`,
+        phase: step.before ? "before" : "after",
+        statements,
+        state: sql === void 0 ? "blocked" : "run",
+        ...sql === void 0 ? { reason: `it has no SQL for ${dialect}.` } : {}
+      });
+    }
+  }
+  return plan;
+}
+__name(planSchemaSteps, "planSchemaSteps");
+function summarize(step, models) {
+  if ("renameColumn" in step) {
+    const model = models[step.renameColumn.model];
+    return `rename ${model.name}.${step.renameColumn.from} \u2192 ${model.name}.${model.fields[step.renameColumn.to].name}`;
+  }
+  if ("renameTable" in step) {
+    return `rename table ${step.renameTable.from} \u2192 ${models[step.renameTable.to].name}`;
+  }
+  if ("dropColumn" in step) {
+    return `drop ${models[step.dropColumn.model].name}.${step.dropColumn.column}`;
+  }
+  if ("dropTable" in step) return `drop table ${step.dropTable.table}`;
+  return step.description ?? `custom SQL (${step.id})`;
+}
+__name(summarize, "summarize");
+async function runSchemaStep(executor, dialect, owner, planned) {
+  await executor.execute(stepsTableStatement(dialect));
+  const statements = [
+    ...planned.state === "run" ? planned.statements : [],
+    recordStatement(dialect, owner, planned.step)
+  ];
+  if (dialect === "postgres") {
+    await executor.execute(
+      statements.map((statement) => statement.replace(/;\s*$/u, "")).join(";\n")
+    );
+    return;
+  }
+  if (dialect === "sqlite") {
+    await executor.execute("BEGIN");
+    try {
+      for (const statement of statements) await executor.execute(statement);
+      await executor.execute("COMMIT");
+    } catch (error) {
+      await executor.execute("ROLLBACK").catch(() => {
+      });
+      throw error;
+    }
+    return;
+  }
+  for (const statement of statements) await executor.execute(statement);
+}
+__name(runSchemaStep, "runSchemaStep");
+function withoutRenameTargets(models, stepPlan) {
+  const pending = (stepPlan?.steps ?? []).filter((planned) => planned.state === "run");
+  if (pending.length === 0) return models;
+  const tables = /* @__PURE__ */ new Set();
+  const columns = /* @__PURE__ */ new Map();
+  for (const { step } of pending) {
+    if ("renameTable" in step) tables.add(step.renameTable.to);
+    if ("renameColumn" in step) {
+      const set = columns.get(step.renameColumn.model) ?? /* @__PURE__ */ new Set();
+      set.add(step.renameColumn.to);
+      columns.set(step.renameColumn.model, set);
+    }
+  }
+  return models.filter((model) => !tables.has(model.modelKey)).map((model) => {
+    const skip = columns.get(model.modelKey);
+    if (!skip) return model;
+    const fields = Object.fromEntries(
+      Object.entries(model.model.fields).filter(([key]) => !skip.has(key))
+    );
+    return { ...model, model: { ...model.model, fields } };
+  });
+}
+__name(withoutRenameTargets, "withoutRenameTargets");
+async function planOwnerSchemaSteps(input) {
+  const applied = input.readApplied === false ? /* @__PURE__ */ new Map() : await readAppliedSchemaSteps(input.executor, input.dialect, input.owner);
+  const candidates = [
+    ...input.tables,
+    ...input.steps.flatMap((step) => "renameTable" in step ? [step.renameTable.from] : [])
+  ];
+  let fresh = applied.size === 0;
+  for (const table of candidates) {
+    if (!fresh) break;
+    if (await describeSchemaTable(input.executor, input.dialect, table)) fresh = false;
+  }
+  const recorded = input.readApplied === false ? void 0 : (await readSchemaState(input.executor, input.dialect, input.owner))?.snapshot;
+  return planSchemaSteps({ ...input, applied, fresh, recorded });
+}
+__name(planOwnerSchemaSteps, "planOwnerSchemaSteps");
+
+// src/schema-owner.ts
+var FARM_SCHEMA_TABLES = /* @__PURE__ */ Symbol.for("farm.schema-tables");
+function declareSchemaTables(target, declaration) {
+  Object.defineProperty(target, FARM_SCHEMA_TABLES, {
+    value: declaration,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+}
+__name(declareSchemaTables, "declareSchemaTables");
+function readSchemaTables(candidate) {
+  if (!candidate || typeof candidate !== "object" && typeof candidate !== "function") {
+    return void 0;
+  }
+  return candidate[FARM_SCHEMA_TABLES];
+}
+__name(readSchemaTables, "readSchemaTables");
+
+// src/schema-foreign-keys.ts
+async function planCrossOwnerReferences(owner, others, dialect, executor) {
+  const plan = { eligible: [], waiting: [], skipped: [] };
+  const own = resolveSchemaModels(owner.name, owner.schema);
+  const creators = /* @__PURE__ */ new Map();
+  const byKey = /* @__PURE__ */ new Map();
+  for (const other of others) {
+    if (other.name === owner.name) continue;
+    try {
+      for (const model of collectSchemaModels([[other.name, other.schema, other.models]])) {
+        creators.set(model.modelName.toLowerCase(), { owner: other.name, model });
+        byKey.set(model.modelKey, model);
+      }
+    } catch {
+    }
+  }
+  for (const model of collectSchemaModels([[owner.name, owner.schema, owner.models]])) {
+    for (const [fieldKey, field] of Object.entries(model.model.fields)) {
+      const reference = field.reference;
+      if (!reference || !isDatabaseEnforcedReference(reference)) continue;
+      const described = Object.prototype.hasOwnProperty.call(own, reference.model) ? own[reference.model].name : byKey.get(reference.model)?.modelName;
+      const creator = described ? creators.get(described.toLowerCase()) : void 0;
+      if (!creator) continue;
+      const target = Object.entries(creator.model.model.fields).find(
+        ([key, candidate]) => key === reference.field || candidate.name === reference.field
+      )?.[1];
+      const entry = {
+        owner: owner.name,
+        modelKey: model.modelKey,
+        fieldKey,
+        table: model.modelName,
+        column: field.name,
+        referencedOwner: creator.owner,
+        referencedTable: creator.model.modelName,
+        referencedColumn: target?.name ?? reference.field,
+        onDelete: reference.onDelete ?? "noAction"
+      };
+      if (!target || !(target.primaryKey || target.unique)) {
+        plan.skipped.push({
+          reference: entry,
+          reason: `"${entry.referencedTable}.${entry.referencedColumn}" is not its primary key or unique.`
+        });
+        continue;
+      }
+      const mine = columnTypeFamily(getSqlColumnType(field, dialect));
+      const theirs = columnTypeFamily(getSqlColumnType(target, dialect));
+      if (dialect !== "sqlite" && mine !== theirs) {
+        plan.skipped.push({ reference: entry, reason: "the column types differ." });
+        continue;
+      }
+      const table = await describeSchemaTable(executor, dialect, entry.referencedTable);
+      if (!table) {
+        plan.waiting.push(entry);
+        continue;
+      }
+      const column = table.columns.find(
+        (candidate) => dialect === "postgres" ? candidate.name === entry.referencedColumn : candidate.name.toLowerCase() === entry.referencedColumn.toLowerCase()
+      );
+      if (!column) {
+        plan.skipped.push({
+          reference: entry,
+          reason: `"${entry.referencedTable}" has no column "${entry.referencedColumn}".`
+        });
+        continue;
+      }
+      plan.eligible.push(entry);
+    }
+  }
+  return plan;
+}
+__name(planCrossOwnerReferences, "planCrossOwnerReferences");
+function isForeignKeyAllowed(allowForeignKeys, reference) {
+  if (!allowForeignKeys || !Object.prototype.hasOwnProperty.call(allowForeignKeys, reference.owner)) {
+    return false;
+  }
+  const allowed = allowForeignKeys[reference.owner] ?? [];
+  return allowed.includes(reference.modelKey) || allowed.includes(reference.table);
+}
+__name(isForeignKeyAllowed, "isForeignKeyAllowed");
+function describeForeignKeyApproval(reference) {
+  return `schema: { allowForeignKeys: { ${JSON.stringify(reference.owner)}: [${JSON.stringify(reference.modelKey)}] } }`;
+}
+__name(describeForeignKeyApproval, "describeForeignKeyApproval");
+
+// src/schema-tables.ts
+function findSchemaTableOwners(config) {
+  const integrations = config.integrations;
+  const candidates = [
+    ...config.plugins ?? [],
+    ...Array.isArray(integrations) ? integrations : Object.values(integrations ?? {})
+  ];
+  const owners = [];
+  for (const candidate of candidates) {
+    const declaration = readSchemaTables(candidate);
+    if (declaration && !owners.some((owner) => owner.name === declaration.name)) {
+      owners.push(declaration);
+    }
+  }
+  return owners;
+}
+__name(findSchemaTableOwners, "findSchemaTableOwners");
+function collectOwnerModels(owner) {
+  return collectSchemaModels([[owner.name, owner.schema, owner.models]]);
+}
+__name(collectOwnerModels, "collectOwnerModels");
+var emptyExtensionPlan = /* @__PURE__ */ __name(() => ({
+  statements: [],
+  present: [],
+  missingTables: [],
+  conflicts: [],
+  unsupported: []
+}), "emptyExtensionPlan");
+async function migrateSchemaTables(owner, options = {}) {
+  const log = options.log ?? (() => {
+  });
+  const client = await owner.resolveClient(options.config ?? {});
+  const adapter = createSchemaExecutor(client, owner.name);
+  if (!adapter) {
+    log(
+      `Nothing to create: ${owner.name} stores data through a storage mount, which has no tables.`
+    );
+    return {
+      plan: { dialect: "sqlite", statements: [], upToDate: [], drift: [] },
+      sql: "",
+      applied: [],
+      extensions: { ...emptyExtensionPlan(), unapproved: [], pending: [] },
+      foreignKeys: { waiting: [], unapproved: [], unsupported: [], blocked: [] },
+      steps: { ran: [], pending: [] },
+      planned: 0
+    };
+  }
+  const { executor } = adapter;
+  const dialect = owner.dialect ?? adapter.dialect;
+  const schemaConfig = options.config?.schema;
+  const reportOnly = options.extensions === "report";
+  const applying = Boolean(options.apply) && !reportOnly;
+  const steps = owner.migrations ?? [];
+  let stepPlan;
+  const stepsRan = [];
+  let stepsStopped;
+  if (steps.length > 0) {
+    const othersTables = new Set(
+      (options.config ? findSchemaTableOwners(options.config) : []).filter((other) => other.name !== owner.name).flatMap((other) => {
+        try {
+          return collectOwnerModels(other).map((model) => model.modelName);
+        } catch {
+          return [];
+        }
+      })
+    );
+    stepPlan = await planOwnerSchemaSteps({
+      owner: owner.name,
+      schema: owner.schema,
+      steps,
+      tables: collectOwnerModels(owner).map((model) => model.modelName),
+      dialect,
+      executor,
+      readApplied: !reportOnly,
+      othersTables
+    });
+    for (const id of stepPlan.edited) {
+      log(
+        `Migration step "${id}" changed after it ran here. Farm never runs a step twice; review the change yourself.`
+      );
+    }
+  }
+  const runSteps = /* @__PURE__ */ __name(async (phase) => {
+    for (const planned of stepPlan?.steps ?? []) {
+      if (stepsStopped) return;
+      if (planned.phase !== phase) continue;
+      if (planned.state === "run" && planned.destructive && !options.allowDestructive) {
+        stepsStopped = planned;
+        log(
+          `Stopped at migration step "${planned.step.id}" (${planned.summary}): it deletes data. Run again with --allow-destructive to let it. Later steps wait.`
+        );
+        return;
+      }
+      if (planned.state === "blocked") {
+        stepsStopped = planned;
+        log(
+          `Stopped at migration step "${planned.step.id}" (${planned.summary}): ${planned.reason} Later steps wait for it.`
+        );
+        return;
+      }
+      await runSchemaStep(executor, dialect, owner.name, planned);
+      stepsRan.push(planned.step.id);
+    }
+  }, "runSteps");
+  if (applying) await runSteps("before");
+  const models = collectOwnerModels(owner);
+  const planningModels = applying ? models : withoutRenameTargets(models, stepPlan);
+  const others = options.config ? findSchemaTableOwners(options.config) : [];
+  const crossOwner = await planCrossOwnerReferences(owner, others, dialect, executor);
+  for (const reference of crossOwner.eligible) {
+    const model = planningModels.find((candidate) => candidate.modelKey === reference.modelKey);
+    if (!model) continue;
+    (model.foreignKeys ?? (model.foreignKeys = {}))[reference.fieldKey] = {
+      table: reference.referencedTable,
+      column: reference.referencedColumn,
+      onDelete: reference.onDelete
+    };
+  }
+  const plan = await planSchemaMigration(planningModels, dialect, executor);
+  const snapshot = createSchemaSnapshot(models);
+  const state = await readSchemaState(executor, dialect, owner.name);
+  const changes = state ? diffSchemaSnapshots(state.snapshot, snapshot) : void 0;
+  const upgrade = state && changes && hasSchemaChanges(changes) ? { from: state.version, to: owner.version, changes } : void 0;
+  const pendingSteps = (stepPlan?.steps ?? []).filter((planned) => planned.state !== "record");
+  if (upgrade || pendingSteps.length > 0) {
+    const versions = upgrade?.from && upgrade.to && upgrade.from !== upgrade.to ? `${owner.name} ${upgrade.from} \u2192 ${upgrade.to} changes its tables:` : `${owner.name}'s tables changed since they were last migrated:`;
+    log(
+      [
+        versions,
+        ...describeStepChanges(stepPlan, Boolean(options.allowDestructive)),
+        ...describeSchemaChanges(withoutStepChanges(changes, stepPlan)),
+        ...renameHints(withoutStepChanges(changes, stepPlan))
+      ].join("\n")
+    );
+  }
+  const recordState = /* @__PURE__ */ __name(async () => {
+    if (options.extensions === "report") return;
+    const unfinished = (stepPlan?.steps ?? []).some(
+      (planned) => !stepsRan.includes(planned.step.id)
+    );
+    if (stepsStopped || unfinished) return;
+    try {
+      await writeSchemaState(executor, dialect, owner.name, { version: owner.version, snapshot });
+    } catch (error) {
+      log(
+        `Applied, but could not record it in "${FARM_SCHEMA_STATE_TABLE}" (${error instanceof Error ? error.message : String(error)}). The next upgrade of ${owner.name} will be compared with the database instead of this version.`
+      );
+    }
+  }, "recordState");
+  const addable = plan.addableForeignKeys ?? [];
+  const foreignKeysUnsupported = dialect === "sqlite" ? addable : [];
+  const foreignKeysAllowed = dialect === "sqlite" ? [] : addable.filter(
+    (key) => isForeignKeyAllowed(schemaConfig?.allowForeignKeys, { owner: owner.name, ...key })
+  );
+  const foreignKeysUnapproved = dialect === "sqlite" ? [] : addable.filter((key) => !foreignKeysAllowed.includes(key));
+  const extensionsPlan = await planSchemaExtensions(
+    collectSchemaExtensions(owner.name, owner.schema, owner.models),
+    dialect,
+    executor
+  );
+  const allowExtend = schemaConfig?.allowExtend;
+  const approved = reportOnly ? [] : extensionsPlan.statements.filter(
+    (statement) => isSchemaExtensionAllowed(allowExtend, statement.extension)
+  );
+  const unapproved = reportOnly ? [] : extensionsPlan.statements.filter((statement) => !approved.includes(statement));
+  const sql = formatSteps(stepPlan, "before", reportOnly) + formatSchemaMigration(plan, owner.name, {
+    addsColumns: approved.length + foreignKeysAllowed.length > 0
+  }) + formatSteps(stepPlan, "after", reportOnly) + formatForeignKeys(owner.name, dialect, foreignKeysAllowed, foreignKeysUnapproved) + formatExtensions(owner.name, {
+    approved,
+    unapproved,
+    reported: reportOnly ? extensionsPlan.statements : []
+  });
+  const pendingAfter = /* @__PURE__ */ __name((added) => [
+    ...extensionsPlan.statements.map((statement) => statement.target).filter((target) => !added.has(target)),
+    ...extensionsPlan.unsupported.map((entry) => `${entry.extension.table}.${entry.column}`),
+    ...extensionsPlan.missingTables.flatMap(
+      (extension) => extension.fields.map(({ field }) => `${extension.table}.${field.name}`)
+    )
+  ], "pendingAfter");
+  const blocked = [];
+  const result = /* @__PURE__ */ __name((applied2) => ({
+    plan,
+    sql,
+    applied: applied2,
+    extensions: { ...extensionsPlan, unapproved, pending: pendingAfter(new Set(applied2)) },
+    foreignKeys: {
+      waiting: crossOwner.waiting,
+      unapproved: foreignKeysUnapproved,
+      unsupported: foreignKeysUnsupported,
+      blocked
+    },
+    upgrade,
+    steps: {
+      plan: stepPlan,
+      ran: stepsRan,
+      pending: (stepPlan?.steps ?? []).filter((planned) => !stepsRan.includes(planned.step.id)).map((planned) => planned.step.id)
+    },
+    planned: pendingStatements + runnableSteps
+  }), "result");
+  const creating = new Set(plan.statements.map((statement) => statement.target));
+  for (const reference of crossOwner.waiting) {
+    if (!creating.has(reference.table)) continue;
+    log(
+      `"${reference.table}.${reference.column}" is created without a foreign key: ${reference.referencedOwner} has not created "${reference.referencedTable}" yet. Run \`farm schema migrate\` to create both in order.`
+    );
+  }
+  for (const key of foreignKeysUnsupported) {
+    log(
+      `"${key.table}.${key.column}" has no foreign key to "${key.referencedTable}". SQLite can only add one when it creates the table.`
+    );
+  }
+  if (plan.upToDate.length > 0) {
+    log(`Already up to date: ${plan.upToDate.join(", ")}`);
+  }
+  if (plan.drift.length > 0) {
+    log(
+      `These tables exist but no longer match the schema. Farm will not change them:
+${describeSchemaDrift(plan.drift)}`
+    );
+  }
+  logExtensionProblems(owner.name, extensionsPlan, log);
+  const pendingStatements = plan.statements.length + (plan.upgrades?.length ?? 0) + approved.length + foreignKeysAllowed.length;
+  const blockedAt = (stepPlan?.steps ?? []).findIndex(
+    (planned) => planned.state === "blocked" || planned.state === "run" && planned.destructive && !options.allowDestructive
+  );
+  const runnableSteps = (stepPlan?.steps ?? []).slice(0, blockedAt === -1 ? void 0 : blockedAt).filter((planned) => !stepsRan.includes(planned.step.id)).length;
+  if (pendingStatements === 0 && runnableSteps === 0 && blockedAt === -1 && unapproved.length === 0 && foreignKeysUnapproved.length === 0 && (!reportOnly || extensionsPlan.statements.length === 0)) {
+    log("Nothing to create.");
+    if (options.apply) await recordState();
+    return result([]);
+  }
+  if (options.write) {
+    const { writeFile, mkdir } = await import("fs/promises");
+    const { dirname } = await import("path");
+    await mkdir(dirname(options.write), { recursive: true });
+    await writeFile(options.write, sql, "utf8");
+    log(`Wrote ${pendingStatements} statement(s) to ${options.write}`);
+    return result([]);
+  }
+  if (!options.apply) {
+    log(sql);
+    return result([]);
+  }
+  for (const approval of new Set(
+    unapproved.map((statement) => describeSchemaExtensionApproval(statement.extension))
+  )) {
+    const columns = unapproved.filter((statement) => describeSchemaExtensionApproval(statement.extension) === approval).map((statement) => statement.target);
+    log(
+      `Not allowed yet, so not added: ${columns.join(", ")}. To allow it, add to farm.config: ${approval}`
+    );
+  }
+  const created = await applySchemaMigration(plan, executor);
+  const applied = [...created.applied];
+  for (const statement of approved) {
+    await executor.execute(statement.sql);
+    applied.push(statement.target);
+  }
+  for (const key of foreignKeysAllowed) {
+    const orphans = await countOrphans(executor, dialect, key);
+    if (orphans > 0) {
+      blocked.push({ key, orphans });
+      log(
+        `Cannot add the foreign key "${key.table}.${key.column}" \u2192 "${key.referencedTable}": ${orphans} row(s) point at no "${key.referencedTable}". Fix or remove them, then run again.`
+      );
+      continue;
+    }
+    await executor.execute(foreignKeyStatement(dialect, key));
+    applied.push(`${key.table}.${key.column} \u2192 ${key.referencedTable}`);
+  }
+  for (const key of foreignKeysUnapproved) {
+    log(
+      `Not allowed yet, so not added: the foreign key "${key.table}.${key.column}" \u2192 "${key.referencedTable}". To allow it, add to farm.config: ${describeForeignKeyApproval({ owner: owner.name, modelKey: key.modelKey })}`
+    );
+  }
+  if (applied.length > 0) log(`Created: ${applied.join(", ")}`);
+  await runSteps("after");
+  if (stepsRan.length > 0) log(`Ran migration steps: ${stepsRan.join(", ")}`);
+  await recordState();
+  return result(applied);
+}
+__name(migrateSchemaTables, "migrateSchemaTables");
+function foreignKeyStatement(dialect, key) {
+  const name = `${key.table}_${key.column}_fkey`.slice(0, 63);
+  const onDelete = key.onDelete !== "noAction" ? ` ON DELETE ${SQL_ON_DELETE[key.onDelete]}` : "";
+  const q = /* @__PURE__ */ __name((value) => quoteSqlIdentifier(dialect, value), "q");
+  return `ALTER TABLE ${q(key.table)} ADD CONSTRAINT ${q(name)} FOREIGN KEY (${q(key.column)}) REFERENCES ${q(key.referencedTable)} (${q(key.referencedColumn)})${onDelete};`;
+}
+__name(foreignKeyStatement, "foreignKeyStatement");
+var SQL_ON_DELETE = {
+  cascade: "CASCADE",
+  restrict: "RESTRICT",
+  setNull: "SET NULL",
+  noAction: "NO ACTION"
+};
+async function countOrphans(executor, dialect, key) {
+  const q = /* @__PURE__ */ __name((name) => quoteSqlIdentifier(dialect, name), "q");
+  const rows = await executor.query(
+    `SELECT COUNT(*) AS orphans FROM ${q(key.table)} child WHERE child.${q(key.column)} IS NOT NULL AND NOT EXISTS (SELECT 1 FROM ${q(key.referencedTable)} parent WHERE parent.${q(key.referencedColumn)} = child.${q(key.column)})`
+  );
+  const row = rows[0] ?? {};
+  return Number(row.orphans ?? row.ORPHANS ?? Object.values(row)[0] ?? 0);
+}
+__name(countOrphans, "countOrphans");
+function formatForeignKeys(owner, dialect, allowed, unapproved) {
+  const sections = [];
+  if (allowed.length > 0) {
+    sections.push(
+      [
+        `-- Foreign keys from ${owner}'s existing tables to other plugins' tables, allowed in farm.config.`,
+        "-- Added only when no row points at nothing.",
+        ...allowed.map((key) => foreignKeyStatement(dialect, key))
+      ].join("\n")
+    );
+  }
+  if (unapproved.length > 0) {
+    const approvals = [
+      ...new Set(
+        unapproved.map((key) => describeForeignKeyApproval({ owner, modelKey: key.modelKey }))
+      )
+    ];
+    sections.push(
+      [
+        `-- Foreign keys from ${owner}'s existing tables to other plugins' tables. Not allowed yet, so not run.`,
+        "-- To allow them, add to farm.config:",
+        ...approvals.map((approval) => `--   ${approval}`),
+        ...unapproved.map((key) => `-- ${foreignKeyStatement(dialect, key)}`)
+      ].join("\n")
+    );
+  }
+  return sections.length > 0 ? `
+${sections.join("\n\n")}
+` : "";
+}
+__name(formatForeignKeys, "formatForeignKeys");
+function describeStepChanges(stepPlan, allowDestructive) {
+  const pending = (stepPlan?.steps ?? []).filter((planned) => planned.state !== "record");
+  return pending.map((planned, index) => {
+    const when = planned.phase === "after" ? " (after the changes below)" : "";
+    const deletes = planned.destructive && planned.state === "run" ? allowDestructive ? "  \u26A0 deletes data" : "  \u26A0 deletes data, needs --allow-destructive" : "";
+    const blocked = planned.state === "blocked" ? `  \u2717 blocked: ${planned.reason}` : "";
+    return `  ${index + 1}. ${planned.summary}${when}${deletes}${blocked}`;
+  });
+}
+__name(describeStepChanges, "describeStepChanges");
+function withoutStepChanges(changes, stepPlan) {
+  const empty = {
+    addedTables: [],
+    addedColumns: [],
+    addedIndexes: [],
+    otherChanges: [],
+    removedColumns: []
+  };
+  if (!changes) return empty;
+  const renamedTo = /* @__PURE__ */ new Set();
+  const renamedFrom = /* @__PURE__ */ new Set();
+  for (const { summary, step } of stepPlan?.steps ?? []) {
+    const match = /^rename (?:table )?(\S+) → (\S+)$/u.exec(summary);
+    if (!match || !("renameColumn" in step || "renameTable" in step)) continue;
+    renamedFrom.add(match[1]);
+    renamedTo.add(match[2]);
+  }
+  return {
+    addedTables: changes.addedTables.filter((table) => !renamedTo.has(table)),
+    addedColumns: changes.addedColumns.filter(
+      ({ table, column }) => !renamedTo.has(`${table}.${column}`)
+    ),
+    addedIndexes: changes.addedIndexes,
+    otherChanges: changes.otherChanges.filter(
+      (change) => ![...renamedFrom].some((from) => change === `${from} is removed`)
+    ),
+    removedColumns: (changes.removedColumns ?? []).filter(
+      ({ table, column }) => !renamedFrom.has(`${table}.${column}`)
+    )
+  };
+}
+__name(withoutStepChanges, "withoutStepChanges");
+function renameHints(changes) {
+  const hints = [];
+  for (const removed of changes.removedColumns ?? []) {
+    const added = changes.addedColumns.find(
+      ({ table, type }) => table === removed.table && type === removed.type
+    );
+    if (!added) continue;
+    hints.push(
+      `  ? if ${removed.table}.${removed.column} was renamed to ${added.table}.${added.column}, the plugin needs a migration step, or the data stays in ${removed.column}`
+    );
+  }
+  return hints;
+}
+__name(renameHints, "renameHints");
+function formatSteps(stepPlan, phase, reportOnly) {
+  const planned = (stepPlan?.steps ?? []).filter(
+    (entry) => entry.phase === phase && entry.state !== "record"
+  );
+  if (planned.length === 0) return "";
+  const heading = phase === "before" ? "-- Migration steps, run before the changes below:" : "-- Migration steps, run after the changes above:";
+  const lines = [heading];
+  for (const entry of planned) {
+    lines.push(
+      `-- ${entry.step.id}: ${entry.summary}${entry.destructive ? "  (deletes data)" : ""}`
+    );
+    if (entry.state === "blocked") {
+      lines.push(`--   blocked: ${entry.reason}`);
+      continue;
+    }
+    for (const statement of entry.statements) {
+      lines.push(reportOnly ? `-- ${statement};` : `${statement.replace(/;\s*$/u, "")};`);
+    }
+  }
+  if (reportOnly) {
+    lines.push("-- Your ORM owns these tables: add the steps to its migrations instead.");
+  }
+  return `${lines.join("\n")}
+
+`;
+}
+__name(formatSteps, "formatSteps");
+function formatExtensions(owner, groups) {
+  const sections = [];
+  if (groups.approved.length > 0) {
+    sections.push(
+      [
+        `-- Columns ${owner} adds to tables it does not own, allowed in farm.config.`,
+        ...groups.approved.map((statement) => statement.sql)
+      ].join("\n")
+    );
+  }
+  if (groups.unapproved.length > 0) {
+    const approvals = [
+      ...new Set(
+        groups.unapproved.map((statement) => describeSchemaExtensionApproval(statement.extension))
+      )
+    ];
+    sections.push(
+      [
+        `-- Columns ${owner} adds to tables it does not own. Not allowed yet, so not run.`,
+        "-- To allow them, add to farm.config:",
+        ...approvals.map((approval) => `--   ${approval}`),
+        ...groups.unapproved.map((statement) => `-- ${statement.sql}`)
+      ].join("\n")
+    );
+  }
+  if (groups.reported.length > 0) {
+    sections.push(
+      [
+        `-- Columns ${owner} adds to tables your ORM owns. Farm will not alter them:`,
+        "-- add them to your ORM's schema and run its migration.",
+        ...groups.reported.map((statement) => `-- ${statement.sql}`)
+      ].join("\n")
+    );
+  }
+  return sections.length > 0 ? `
+${sections.join("\n\n")}
+` : "";
+}
+__name(formatExtensions, "formatExtensions");
+function logExtensionProblems(owner, plan, log) {
+  for (const extension of plan.missingTables) {
+    log(
+      `Cannot add ${extension.fields.map(({ field }) => field.name).join(", ")} to "${extension.table}": the table does not exist. Run the migration that creates it (your ORM's, or a library's such as Better Auth) first.`
+    );
+  }
+  for (const entry of plan.unsupported) {
+    log(`Cannot add "${entry.extension.table}.${entry.column}" for ${owner}: ${entry.reason}`);
+  }
+  for (const entry of plan.conflicts) {
+    log(
+      `"${entry.extension.table}.${entry.column}" already exists as ${entry.actual}; ${owner} expects ${entry.expected.toLowerCase()}. Farm will not change it.`
+    );
+  }
+}
+__name(logExtensionProblems, "logExtensionProblems");
+
+export {
+  describeSchemaReference,
+  collectSchemaModels,
+  generateSqlStatements,
+  renderSqlSchemaFile,
+  getSqlColumnType,
+  getSqlDefaultExpression,
+  isNullableField,
+  quoteSqlIdentifier,
+  toSnakeCase,
+  toPascalCase,
+  toCamelCase,
+  escapeSqlString,
+  planSchemaMigration,
+  describeSchemaTable,
+  applySchemaMigration,
+  columnTypeFamily,
+  planSchemaExtensions,
+  formatSchemaMigration,
+  describeSchemaDrift,
+  createSchemaExecutor,
+  collectSchemaExtensions,
+  isSchemaExtensionAllowed,
+  describeSchemaExtensionApproval,
+  FARM_SCHEMA_STATE_TABLE,
+  createSchemaSnapshot,
+  diffSchemaSnapshots,
+  hasSchemaChanges,
+  readSchemaState,
+  FARM_SCHEMA_STEPS_TABLE,
+  withoutRenameTargets,
+  planOwnerSchemaSteps,
+  planCrossOwnerReferences,
+  describeForeignKeyApproval,
+  FARM_SCHEMA_TABLES,
+  declareSchemaTables,
+  readSchemaTables,
+  findSchemaTableOwners,
+  collectOwnerModels,
+  migrateSchemaTables
+};