@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-IOAUK4OI.cjs

@@ -1,2162 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-var _chunk4U5XZDLGcjs = require('./chunk-4U5XZDLG.cjs');
-
-
-
-var _chunkZQRCSUSBcjs = require('./chunk-ZQRCSUSB.cjs');
-
-
-var _chunk6D24SDKOcjs = require('./chunk-6D24SDKO.cjs');
-
-
-var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
-
-// 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, fitSqlIndexName, "fitSqlIndexName");
-
-// src/schema-sql.ts
-function describeSchemaReference(model, fieldKey) {
-  const field = model.model.fields[fieldKey];
-  const target = _optionalChain([model, 'access', _ => _.referenceTargets, 'optionalAccess', _2 => _2[fieldKey]]);
-  if (target) return `${target.table}.${target.column}`;
-  return `${_optionalChain([field, 'optionalAccess', _3 => _3.reference, 'optionalAccess', _4 => _4.model])}.${_optionalChain([field, 'optionalAccess', _5 => _5.reference, 'optionalAccess', _6 => _6.field])}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _chunk6D24SDKOcjs.resolveSchemaModels.call(void 0, 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: _nullishCoalesce(_optionalChain([target, 'access', _7 => _7.fields, 'access', _8 => _8[reference.field], 'optionalAccess', _9 => _9.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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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)) {
-    _chunkZQRCSUSBcjs.assertNoSchemaListField.call(void 0, 
-      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 = _optionalChain([model, 'access', _10 => _10.foreignKeys, 'optionalAccess', _11 => _11[fieldKey]]);
-    const reference = _nullishCoalesce(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");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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) => _optionalChain([model, 'access', _12 => _12.model, 'access', _13 => _13.fields, 'access', _14 => _14[fieldKey], 'optionalAccess', _15 => _15.name]) || fieldKey).join("_")}_${constraint.type}`
-      ),
-      columns: constraint.fields.map(
-        (fieldKey) => quoteSqlIdentifier(dialect, _optionalChain([model, 'access', _16 => _16.model, 'access', _17 => _17.fields, 'access', _18 => _18[fieldKey], 'optionalAccess', _19 => _19.name]) || fieldKey)
-      ),
-      unique: constraint.type === "unique"
-    });
-  }
-  return definitions;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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(", ")});`
-  }));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 || !_chunkZQRCSUSBcjs.isDatabaseEnforcedReference.call(void 0, 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, _optionalChain([referencedModel, 'access', _20 => _20.model, 'access', _21 => _21.fields, 'access', _22 => _22[referencedField], 'optionalAccess', _23 => _23.name]) || referencedField)})`
-      ];
-      if (field.reference.onDelete) {
-        pieces.push(`ON DELETE ${SQL_ON_DELETE_ACTIONS[field.reference.onDelete]}`);
-      }
-      lookup.set(fieldKey, pieces.join(" "));
-    }
-  }
-  return lookup;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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";
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getSqlDefaultExpression, "getSqlDefaultExpression");
-function isNullableField(field) {
-  return field.nullable === true || field.required === false;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isNullableField, "isNullableField");
-function quoteSqlIdentifier(dialect, value) {
-  if (dialect === "mysql") {
-    return `\`${value.replace(/`/g, "``")}\``;
-  }
-  return `"${value.replace(/"/g, '""')}"`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, quoteSqlIdentifier, "quoteSqlIdentifier");
-function createModelLookup(models) {
-  return new Map(models.map((model) => [`${model.ownerKey}.${model.modelKey}`, model]));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createModelLookup, "createModelLookup");
-function orderSchemaModelsByReferences(models, modelLookup) {
-  const ordered = [];
-  const states = /* @__PURE__ */ new Map();
-  const stack = [];
-  const visit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 && _chunkZQRCSUSBcjs.isDatabaseEnforcedReference.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, orderSchemaModelsByReferences, "orderSchemaModelsByReferences");
-function getCollectedModelKey(model) {
-  return `${model.ownerKey}.${model.modelKey}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getCollectedModelKey, "getCollectedModelKey");
-function toSnakeCase(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s.-]+/g, "_").replace(/__+/g, "_").toLowerCase();
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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("");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toPascalCase, "toPascalCase");
-function toCamelCase(value) {
-  const pascal = toPascalCase(value);
-  return pascal ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : pascal;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, toCamelCase, "toCamelCase");
-function escapeSqlString(value, dialect) {
-  const quoted = value.replace(/'/g, "''");
-  return dialect === "mysql" ? quoted.replace(/\\/g, "\\\\") : quoted;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
-    }
-    _optionalChain([currentTable, 'optionalAccess', _24 => _24.push, 'call', _25 => _25(statement)]);
-  }
-  for (const model of models) {
-    const existing = await describeTable(executor, dialect, model.modelName);
-    if (!existing) {
-      statements.push(..._nullishCoalesce(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(_nullishCoalesce(model.foreignKeys, () => ( {}))).map(([fieldKey, key]) => ({
-      ...key,
-      column: model.model.fields[fieldKey].name,
-      referencedColumn: key.column
-    }));
-    const isCrossOwnerOf = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (key) => (reference) => key.column.toLowerCase() === reference.column.toLowerCase() && key.table.toLowerCase() === reference.referencedTable.toLowerCase(), "isCrossOwnerOf");
-    const isCrossOwner = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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
-    }))
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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
-    }))
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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(
-        _nullishCoalesce(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)
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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(_nullishCoalesce(readRowValue(row, "pk"), () => ( 0))) > 0;
-    return {
-      name: String(readRowValue(row, "name")),
-      type: normalizeColumnType("sqlite", String(_nullishCoalesce(readRowValue(row, "type"), () => ( "")))),
-      nullable: !primaryKey && Number(_nullishCoalesce(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(_nullishCoalesce(readRowValue(left, "seqno"), () => ( 0))) - Number(_nullishCoalesce(readRowValue(right, "seqno"), () => ( 0)))
-      ).map((column) => String(readRowValue(column, "name"))),
-      unique: asBoolean(readRowValue(row, "unique")),
-      primary: String(_nullishCoalesce(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"))
-    }))
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _nullishCoalesce(grouped.get(name), () => ( {
-      name,
-      columns: [],
-      unique: dialect === "mysql" ? Number(_nullishCoalesce(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(
-          _nullishCoalesce(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)
-  }));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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"))
-  }));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, expectedColumnDefinition, "expectedColumnDefinition");
-function actualColumnDefinition(column, field, dialect) {
-  return {
-    type: column.type,
-    nullable: column.nullable,
-    default: normalizeDatabaseDefault(column.rawDefault, field, dialect),
-    primaryKey: column.primaryKey
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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();
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 _nullishCoalesce(model.model.constraints, () => ( []))) {
-    indexes.push({
-      name: _nullishCoalesce(constraint.name, () => ( `${model.modelName}_${constraint.fields.map((fieldKey) => _nullishCoalesce(_optionalChain([model, 'access', _26 => _26.model, 'access', _27 => _27.fields, 'access', _28 => _28[fieldKey], 'optionalAccess', _29 => _29.name]), () => ( fieldKey))).join("_")}_${constraint.type}`)),
-      columns: constraint.fields.map((fieldKey) => _nullishCoalesce(_optionalChain([model, 'access', _30 => _30.model, 'access', _31 => _31.fields, 'access', _32 => _32[fieldKey], 'optionalAccess', _33 => _33.name]), () => ( fieldKey))),
-      unique: constraint.type === "unique"
-    });
-  }
-  return indexes;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, collectExpectedIndexes, "collectExpectedIndexes");
-function collectExpectedReferences(model, modelLookup) {
-  const references = [];
-  for (const field of Object.values(model.model.fields)) {
-    if (!field.reference || !_chunkZQRCSUSBcjs.isDatabaseEnforcedReference.call(void 0, field.reference)) continue;
-    const target = modelLookup.get(`${model.ownerKey}.${field.reference.model}`);
-    if (!target) continue;
-    references.push({
-      column: field.name,
-      referencedTable: target.modelName,
-      referencedColumn: _nullishCoalesce(_optionalChain([target, 'access', _34 => _34.model, 'access', _35 => _35.fields, 'access', _36 => _36[field.reference.field], 'optionalAccess', _37 => _37.name]), () => ( field.reference.field)),
-      onDelete: _nullishCoalesce(field.reference.onDelete, () => ( "noAction"))
-    });
-  }
-  return references;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, compareDefinitions, "compareDefinitions");
-function indexSignature(index) {
-  return `${index.unique ? "unique" : "index"}:${index.columns.map((column) => column.toLowerCase()).join(",")}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, indexSignature, "indexSignature");
-function referenceSignature(reference) {
-  return [
-    reference.column,
-    reference.referencedTable,
-    reference.referencedColumn,
-    reference.onDelete
-  ].map((value) => value.toLowerCase()).join(":");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, hasSchemaDrift, "hasSchemaDrift");
-function readRowValue(row, name) {
-  return _nullishCoalesce(row[name], () => ( row[name.toUpperCase()]));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readRowValue, "readRowValue");
-function nullableString(value) {
-  return value === void 0 || value === null ? null : String(value);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, nullableString, "nullableString");
-function asBoolean(value) {
-  return value === true || value === 1 || value === "1" || String(value).toLowerCase() === "true";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, asBoolean, "asBoolean");
-function normalizeDeleteAction(value) {
-  switch (String(_nullishCoalesce(value, () => ( "NO ACTION"))).toUpperCase().replace(/[_\s]+/gu, "")) {
-    case "CASCADE":
-      return "cascade";
-    case "RESTRICT":
-      return "restrict";
-    case "SETNULL":
-      return "setNull";
-    default:
-      return "noAction";
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeDeleteAction, "normalizeDeleteAction");
-function stripWrappingParentheses(value) {
-  let result = value;
-  while (result.startsWith("(") && result.endsWith(")")) {
-    result = result.slice(1, -1).trim();
-  }
-  return result;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, stripWrappingParentheses, "stripWrappingParentheses");
-function stripSqlQuotes(value) {
-  if (value.length >= 2 && (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"'))) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, stripSqlQuotes, "stripSqlQuotes");
-function escapeSqlitePragmaValue(value) {
-  return value.replace(/'/gu, "''");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, escapeSqlitePragmaValue, "escapeSqlitePragmaValue");
-async function applySchemaMigration(plan, executor) {
-  const applied = [];
-  for (const statement of [...plan.statements, ..._nullishCoalesce(plan.upgrades, () => ( []))]) {
-    await executor.execute(statement.sql);
-    applied.push(statement.target);
-  }
-  return { applied, skipped: plan.drift };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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(" ")};`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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))}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, quoteTableName, "quoteTableName");
-function formatSchemaMigration(plan, owner, options = {}) {
-  const header = [
-    `-- Generated by \`farm ${owner} migrate\` from the ${owner} schema.`,
-    `-- Dialect: ${plan.dialect}`,
-    options.addsColumns || (_nullishCoalesce(_optionalChain([plan, 'access', _38 => _38.upgrades, 'optionalAccess', _39 => _39.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 = _nullishCoalesce(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")}
-`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 ${_nullishCoalesce(column.expected.default, () => ( "none"))}, found ${_nullishCoalesce(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");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, describeSchemaDrift, "describeSchemaDrift");
-function formatIndexDefinition(index) {
-  return `${index.name} (${index.unique ? "unique: " : ""}${index.columns.join(", ")})`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, formatIndexDefinition, "formatIndexDefinition");
-function formatReferenceDefinition(reference) {
-  return `${reference.column} -> ${reference.referencedTable}.${reference.referencedColumn} on delete ${reference.onDelete}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, formatReferenceDefinition, "formatReferenceDefinition");
-function createSchemaExecutor(client, owner) {
-  const candidate = client;
-  if (candidate && typeof candidate.getItem === "function" && typeof candidate.setItem === "function") {
-    return null;
-  }
-  if (typeof _optionalChain([candidate, 'optionalAccess', _40 => _40.prepare]) === "function" && typeof _optionalChain([candidate, 'optionalAccess', _41 => _41.exec]) === "function") {
-    return {
-      dialect: "sqlite",
-      executor: {
-        async execute(sql) {
-          candidate.exec(sql);
-        },
-        async query(sql) {
-          return candidate.prepare(sql).all();
-        }
-      }
-    };
-  }
-  if (typeof _optionalChain([candidate, 'optionalAccess', _42 => _42.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 _nullishCoalesce(result[0], () => ( []));
-          return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _43 => _43.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.`
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createSchemaExecutor, "createSchemaExecutor");
-
-// src/schema-state.ts
-var literal = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 _nullishCoalesce(model.model.constraints, () => ( []))) {
-      indexes.push(
-        _nullishCoalesce(constraint.name, () => ( `${model.modelName}_${constraint.fields.map((key) => _nullishCoalesce(_optionalChain([model, 'access', _44 => _44.model, 'access', _45 => _45.fields, 'access', _46 => _46[key], 'optionalAccess', _47 => _47.name]), () => ( key))).join("_")}_${constraint.type}`))
-      );
-    }
-    tables[model.modelName] = { columns, indexes: indexes.sort() };
-  }
-  return { tables };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, diffSchemaSnapshots, "diffSchemaSnapshots");
-function hasSchemaChanges(changes) {
-  return changes.addedTables.length + changes.addedColumns.length + changes.addedIndexes.length + changes.otherChanges.length > 0;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, hasSchemaChanges, "hasSchemaChanges");
-async function readSchemaState(executor, dialect, owner) {
-  const q = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 (e) {
-    return void 0;
-  }
-  const row = rows[0];
-  if (!row) return void 0;
-  const read = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (name) => _nullishCoalesce(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 (e2) {
-    return void 0;
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readSchemaState, "readSchemaState");
-async function writeSchemaState(executor, dialect, owner, state) {
-  const q = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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, _nullishCoalesce(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(", ")})`
-  );
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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)`)
-  ];
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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");
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, schemaStepChecksum, "schemaStepChecksum");
-var literal2 = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (name) => _nullishCoalesce(row[name], () => ( row[name.toUpperCase()])), "read");
-      applied.set(String(read("id")), String(read("checksum")));
-    }
-  } catch (e3) {
-  }
-  return applied;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, readAppliedSchemaSteps, "readAppliedSchemaSteps");
-function stepsTableStatement(dialect) {
-  const q = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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")}))`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, stepsTableStatement, "stepsTableStatement");
-function recordStatement(dialect, owner, step) {
-  const q = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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(", ")})`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, recordStatement, "recordStatement");
-async function planSchemaSteps(input) {
-  const { owner, dialect, executor, applied } = input;
-  const plan = { steps: [], edited: [], fresh: input.fresh };
-  const models = _chunk6D24SDKOcjs.resolveSchemaModels.call(void 0, owner, input.schema);
-  const q = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (name) => quoteSqlIdentifier(dialect, name), "q");
-  const columnsOf = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (table) => await _asyncOptionalChain([(await describeSchemaTable(executor, dialect, table)), 'optionalAccess', async _48 => _48.columns, 'access', async _49 => _49.map, 'call', async _50 => _50((column) => column.name)]), "columnsOf");
-  const has = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (columns, name) => Boolean(
-    _optionalChain([columns, 'optionalAccess', _51 => _51.some, 'call', _52 => _52(
-      (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(_optionalChain([input, 'access', _53 => _53.recorded, 'optionalAccess', _54 => _54.tables, 'access', _55 => _55[table], 'optionalAccess', _56 => _56.columns, 'access', _57 => _57[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(_optionalChain([input, 'access', _58 => _58.recorded, 'optionalAccess', _59 => _59.tables, 'access', _60 => _60[table]]));
-      const ownedElsewhere = [..._nullishCoalesce(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: _nullishCoalesce(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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 _nullishCoalesce(step.description, () => ( `custom SQL (${step.id})`));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, runSchemaStep, "runSchemaStep");
-function withoutRenameTargets(models, stepPlan) {
-  const pending = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _61 => _61.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 = _nullishCoalesce(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 } };
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 _asyncOptionalChain([(await readSchemaState(input.executor, input.dialect, input.owner)), 'optionalAccess', async _62 => _62.snapshot]);
-  return planSchemaSteps({ ...input, applied, fresh, recorded });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, planOwnerSchemaSteps, "planOwnerSchemaSteps");
-
-// src/schema-foreign-keys.ts
-async function planCrossOwnerReferences(owner, others, dialect, executor) {
-  const plan = { eligible: [], waiting: [], skipped: [] };
-  const own = _chunk6D24SDKOcjs.resolveSchemaModels.call(void 0, 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 (e4) {
-    }
-  }
-  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 || !_chunkZQRCSUSBcjs.isDatabaseEnforcedReference.call(void 0, reference)) continue;
-      const described = Object.prototype.hasOwnProperty.call(own, reference.model) ? own[reference.model].name : _optionalChain([byKey, 'access', _63 => _63.get, 'call', _64 => _64(reference.model), 'optionalAccess', _65 => _65.modelName]);
-      const creator = described ? creators.get(described.toLowerCase()) : void 0;
-      if (!creator) continue;
-      const target = _optionalChain([Object, 'access', _66 => _66.entries, 'call', _67 => _67(creator.model.model.fields), 'access', _68 => _68.find, 'call', _69 => _69(
-        ([key, candidate]) => key === reference.field || candidate.name === reference.field
-      ), 'optionalAccess', _70 => _70[1]]);
-      const entry = {
-        owner: owner.name,
-        modelKey: model.modelKey,
-        fieldKey,
-        table: model.modelName,
-        column: field.name,
-        referencedOwner: creator.owner,
-        referencedTable: creator.model.modelName,
-        referencedColumn: _nullishCoalesce(_optionalChain([target, 'optionalAccess', _71 => _71.name]), () => ( reference.field)),
-        onDelete: _nullishCoalesce(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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, planCrossOwnerReferences, "planCrossOwnerReferences");
-function isForeignKeyAllowed(allowForeignKeys, reference) {
-  if (!allowForeignKeys || !Object.prototype.hasOwnProperty.call(allowForeignKeys, reference.owner)) {
-    return false;
-  }
-  const allowed = _nullishCoalesce(allowForeignKeys[reference.owner], () => ( []));
-  return allowed.includes(reference.modelKey) || allowed.includes(reference.table);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isForeignKeyAllowed, "isForeignKeyAllowed");
-function describeForeignKeyApproval(reference) {
-  return `schema: { allowForeignKeys: { ${JSON.stringify(reference.owner)}: [${JSON.stringify(reference.modelKey)}] } }`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, describeForeignKeyApproval, "describeForeignKeyApproval");
-
-// src/schema-tables.ts
-function findSchemaTableOwners(config) {
-  const integrations = config.integrations;
-  const candidates = [
-    ..._nullishCoalesce(config.plugins, () => ( [])),
-    ...Array.isArray(integrations) ? integrations : Object.values(_nullishCoalesce(integrations, () => ( {})))
-  ];
-  const owners = [];
-  for (const candidate of candidates) {
-    const declaration = _chunk4U5XZDLGcjs.readSchemaTables.call(void 0, candidate);
-    if (declaration && !owners.some((owner) => owner.name === declaration.name)) {
-      owners.push(declaration);
-    }
-  }
-  return owners;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, findSchemaTableOwners, "findSchemaTableOwners");
-function collectOwnerModels(owner) {
-  return collectSchemaModels([[owner.name, owner.schema, owner.models]]);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, collectOwnerModels, "collectOwnerModels");
-var emptyExtensionPlan = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => ({
-  statements: [],
-  present: [],
-  missingTables: [],
-  conflicts: [],
-  unsupported: []
-}), "emptyExtensionPlan");
-async function migrateSchemaTables(owner, options = {}) {
-  const log = _nullishCoalesce(options.log, () => ( (() => {
-  })));
-  const client = await owner.resolveClient(_nullishCoalesce(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 = _nullishCoalesce(owner.dialect, () => ( adapter.dialect));
-  const schemaConfig = _optionalChain([options, 'access', _72 => _72.config, 'optionalAccess', _73 => _73.schema]);
-  const reportOnly = options.extensions === "report";
-  const applying = Boolean(options.apply) && !reportOnly;
-  const steps = _nullishCoalesce(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 (e5) {
-          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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (phase) => {
-    for (const planned of _nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _74 => _74.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;
-    (_nullishCoalesce(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 = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _75 => _75.steps]), () => ( []))).filter((planned) => planned.state !== "record");
-  if (upgrade || pendingSteps.length > 0) {
-    const versions = _optionalChain([upgrade, 'optionalAccess', _76 => _76.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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async () => {
-    if (options.extensions === "report") return;
-    const unfinished = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _77 => _77.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 = _nullishCoalesce(plan.addableForeignKeys, () => ( []));
-  const foreignKeysUnsupported = dialect === "sqlite" ? addable : [];
-  const foreignKeysAllowed = dialect === "sqlite" ? [] : addable.filter(
-    (key) => isForeignKeyAllowed(_optionalChain([schemaConfig, 'optionalAccess', _78 => _78.allowForeignKeys]), { owner: owner.name, ...key })
-  );
-  const foreignKeysUnapproved = dialect === "sqlite" ? [] : addable.filter((key) => !foreignKeysAllowed.includes(key));
-  const extensionsPlan = await planSchemaExtensions(
-    _chunk4U5XZDLGcjs.collectSchemaExtensions.call(void 0, owner.name, owner.schema, owner.models),
-    dialect,
-    executor
-  );
-  const allowExtend = _optionalChain([schemaConfig, 'optionalAccess', _79 => _79.allowExtend]);
-  const approved = reportOnly ? [] : extensionsPlan.statements.filter(
-    (statement) => _chunk4U5XZDLGcjs.isSchemaExtensionAllowed.call(void 0, 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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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: (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _80 => _80.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 + (_nullishCoalesce(_optionalChain([plan, 'access', _81 => _81.upgrades, 'optionalAccess', _82 => _82.length]), () => ( 0))) + approved.length + foreignKeysAllowed.length;
-  const blockedAt = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _83 => _83.steps]), () => ( []))).findIndex(
-    (planned) => planned.state === "blocked" || planned.state === "run" && planned.destructive && !options.allowDestructive
-  );
-  const runnableSteps = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _84 => _84.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) => _chunk4U5XZDLGcjs.describeSchemaExtensionApproval.call(void 0, statement.extension))
-  )) {
-    const columns = unapproved.filter((statement) => _chunk4U5XZDLGcjs.describeSchemaExtensionApproval.call(void 0, 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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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};`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (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 = _nullishCoalesce(rows[0], () => ( {}));
-  return Number(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(row.orphans, () => ( row.ORPHANS)), () => ( Object.values(row)[0])), () => ( 0)));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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")}
-` : "";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, formatForeignKeys, "formatForeignKeys");
-function describeStepChanges(stepPlan, allowDestructive) {
-  const pending = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _85 => _85.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}`;
-  });
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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 _nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _86 => _86.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: (_nullishCoalesce(changes.removedColumns, () => ( []))).filter(
-      ({ table, column }) => !renamedFrom.has(`${table}.${column}`)
-    )
-  };
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, withoutStepChanges, "withoutStepChanges");
-function renameHints(changes) {
-  const hints = [];
-  for (const removed of _nullishCoalesce(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;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, renameHints, "renameHints");
-function formatSteps(stepPlan, phase, reportOnly) {
-  const planned = (_nullishCoalesce(_optionalChain([stepPlan, 'optionalAccess', _87 => _87.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")}
-
-`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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) => _chunk4U5XZDLGcjs.describeSchemaExtensionApproval.call(void 0, 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")}
-` : "";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, 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.`
-    );
-  }
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, logExtensionProblems, "logExtensionProblems");
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.describeSchemaReference = describeSchemaReference; exports.collectSchemaModels = collectSchemaModels; exports.generateSqlStatements = generateSqlStatements; exports.renderSqlSchemaFile = renderSqlSchemaFile; exports.getSqlColumnType = getSqlColumnType; exports.getSqlDefaultExpression = getSqlDefaultExpression; exports.isNullableField = isNullableField; exports.quoteSqlIdentifier = quoteSqlIdentifier; exports.toSnakeCase = toSnakeCase; exports.toPascalCase = toPascalCase; exports.toCamelCase = toCamelCase; exports.escapeSqlString = escapeSqlString; exports.planSchemaMigration = planSchemaMigration; exports.describeSchemaTable = describeSchemaTable; exports.applySchemaMigration = applySchemaMigration; exports.columnTypeFamily = columnTypeFamily; exports.planSchemaExtensions = planSchemaExtensions; exports.formatSchemaMigration = formatSchemaMigration; exports.describeSchemaDrift = describeSchemaDrift; exports.createSchemaExecutor = createSchemaExecutor; exports.FARM_SCHEMA_STATE_TABLE = FARM_SCHEMA_STATE_TABLE; exports.createSchemaSnapshot = createSchemaSnapshot; exports.diffSchemaSnapshots = diffSchemaSnapshots; exports.hasSchemaChanges = hasSchemaChanges; exports.readSchemaState = readSchemaState; exports.FARM_SCHEMA_STEPS_TABLE = FARM_SCHEMA_STEPS_TABLE; exports.withoutRenameTargets = withoutRenameTargets; exports.planOwnerSchemaSteps = planOwnerSchemaSteps; exports.planCrossOwnerReferences = planCrossOwnerReferences; exports.describeForeignKeyApproval = describeForeignKeyApproval; exports.findSchemaTableOwners = findSchemaTableOwners; exports.collectOwnerModels = collectOwnerModels; exports.migrateSchemaTables = migrateSchemaTables;