nextly 0.0.1 → 0.0.2-alpha.1

package/dist/chunk-AK6Z23OX.mjs

@@ -0,0 +1,1464 @@
+import {
+  buildDesiredTableFromComponentFields,
+  buildDesiredTableFromFields,
+  countNulls,
+  countRows,
+  diffSnapshots,
+  introspectLiveSnapshot
+} from "./chunk-SBACDPNX.mjs";
+import {
+  ComponentSchemaService
+} from "./chunk-V4EQTOA4.mjs";
+import {
+  generateRuntimeSchema
+} from "./chunk-IZWPRDC3.mjs";
+import {
+  getDialectTables
+} from "./chunk-TS7GHTG2.mjs";
+
+// src/domains/schema/pipeline/errors.ts
+import { UnsupportedDialectVersionError } from "@nextlyhq/adapter-drizzle/version-check";
+function classifyError(err) {
+  if (err instanceof UnsupportedDialectVersionError) {
+    return {
+      code: "UNSUPPORTED_DIALECT_VERSION",
+      message: err.message,
+      details: err
+    };
+  }
+  if (err instanceof Error) {
+    const stack = err.stack ?? "";
+    if (stack.includes("drizzle-kit")) {
+      return {
+        code: "PUSHSCHEMA_FAILED",
+        message: err.message,
+        details: err
+      };
+    }
+    return {
+      code: "INTERNAL_ERROR",
+      message: err.message,
+      details: err
+    };
+  }
+  const message = typeof err === "string" ? err : JSON.stringify(err);
+  return {
+    code: "INTERNAL_ERROR",
+    message,
+    details: err
+  };
+}
+
+// src/domains/schema/pipeline/apply.ts
+function createApplyDesiredSchema(deps) {
+  return async function applyDesiredSchema(desired, source, ctx) {
+    const start = Date.now();
+    const resolvedChannel = ctx.promptChannel === "auto" ? "terminal" : ctx.promptChannel;
+    if (source === "ui" && ctx.schemaVersions) {
+      for (const slug of Object.keys(desired.collections)) {
+        const expected = ctx.schemaVersions[slug];
+        if (expected === void 0) continue;
+        const actual = await deps.readSchemaVersionForSlug(slug);
+        if (actual !== null && actual !== expected) {
+          return {
+            success: false,
+            error: {
+              code: "SCHEMA_VERSION_CONFLICT",
+              message: `Schema version conflict on '${slug}': expected ${expected}, found ${actual}. Reload and try again.`
+            },
+            durationMs: Date.now() - start
+          };
+        }
+      }
+    }
+    let pipelineResult;
+    try {
+      pipelineResult = await deps.applyPipeline(
+        desired,
+        source,
+        resolvedChannel
+      );
+    } catch (err) {
+      const classified = classifyError(err);
+      return {
+        success: false,
+        error: classified,
+        durationMs: Date.now() - start
+      };
+    }
+    if (!pipelineResult.success) {
+      return {
+        success: false,
+        error: {
+          code: pipelineResult.error?.code ?? "INTERNAL_ERROR",
+          message: pipelineResult.error?.message ?? "Pipeline returned failure with no error details",
+          details: pipelineResult.error?.details
+        },
+        partiallyApplied: pipelineResult.partiallyApplied,
+        durationMs: Date.now() - start
+      };
+    }
+    const allSlugs = Object.keys(desired.collections);
+    const newSchemaVersions = await deps.readNewSchemaVersionsForSlugs(allSlugs);
+    return {
+      success: true,
+      newSchemaVersions,
+      statementsExecuted: pipelineResult.statementsExecuted,
+      renamesApplied: pipelineResult.renamesApplied,
+      durationMs: Date.now() - start,
+      // F10 PR 6: forward the diff-derived counts so the dispatcher
+      // can build a contextual toast. Undefined when the underlying
+      // pipeline doesn't compute one.
+      summary: pipelineResult.summary
+    };
+  };
+}
+
+// src/domains/schema/pipeline/pre-cleanup/executor.ts
+import { sql } from "drizzle-orm";
+
+// src/domains/schema/pipeline/_internal/run-statement.ts
+async function runStatement(txOrDb, dialect, stmt) {
+  if (dialect === "sqlite") {
+    txOrDb.run(stmt);
+    return;
+  }
+  await txOrDb.execute(stmt);
+}
+
+// src/domains/schema/pipeline/prompt-dispatcher/errors.ts
+var TTYRequiredError = class extends Error {
+  constructor(detail) {
+    super(
+      `TTY required for schema confirmation. ${detail} Run from an interactive terminal, or use code-first migration files via \`nextly migrate:create\`.`
+    );
+    this.name = "TTYRequiredError";
+  }
+};
+var PromptCancelledError = class extends Error {
+  constructor() {
+    super("Schema apply cancelled by user");
+    this.name = "PromptCancelledError";
+  }
+};
+
+// src/domains/schema/pipeline/pre-cleanup/snapshot-patch.ts
+function applyMakeOptionalToSnapshot(snapshot, resolutions, events) {
+  const makeOptionalEventIds = new Set(
+    resolutions.filter((r) => r.kind === "make_optional").map((r) => r.eventId)
+  );
+  if (makeOptionalEventIds.size === 0) return snapshot;
+  const targets = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (makeOptionalEventIds.has(event.id) && (event.kind === "add_not_null_with_nulls" || event.kind === "add_required_field_no_default")) {
+      targets.set(event.id, {
+        table: event.tableName,
+        column: event.columnName
+      });
+    }
+  }
+  if (targets.size === 0) return snapshot;
+  return {
+    tables: snapshot.tables.map((table) => {
+      const matchingTargets = [...targets.values()].filter(
+        (t) => t.table === table.name
+      );
+      if (matchingTargets.length === 0) return table;
+      return {
+        ...table,
+        columns: table.columns.map((col) => {
+          const matched = matchingTargets.some((t) => t.column === col.name);
+          return matched ? { ...col, nullable: true } : col;
+        })
+      };
+    })
+  };
+}
+
+// src/domains/schema/pipeline/pre-cleanup/validate-default.ts
+import { z } from "zod";
+var TEXT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "email",
+  "textarea",
+  "richText",
+  "code",
+  "url",
+  "slug"
+]);
+var NUMBER_TYPES = /* @__PURE__ */ new Set(["number", "int", "integer"]);
+var BOOL_TYPES = /* @__PURE__ */ new Set(["checkbox", "boolean"]);
+var DATE_TYPES = /* @__PURE__ */ new Set(["date", "datetime", "timestamp"]);
+function schemaForType(type) {
+  if (TEXT_TYPES.has(type)) return z.string();
+  if (NUMBER_TYPES.has(type)) return z.number();
+  if (BOOL_TYPES.has(type)) return z.boolean();
+  if (DATE_TYPES.has(type)) {
+    return z.union([z.string().datetime(), z.date()]);
+  }
+  return z.unknown();
+}
+function validateDefaultValue(field, value) {
+  const schema = schemaForType(field.type);
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    return { success: false, error: issue?.message ?? "validation failed" };
+  }
+  return { success: true };
+}
+
+// src/domains/schema/pipeline/pre-cleanup/executor.ts
+var SAFE_IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function readDeleteThreshold() {
+  const env = process.env.NEXTLY_DELETE_THRESHOLD;
+  if (!env) return 1e4;
+  const n = parseInt(env, 10);
+  return Number.isFinite(n) && n > 0 ? n : 1e4;
+}
+function assertSafeIdent(name) {
+  if (!SAFE_IDENT.test(name)) {
+    throw new Error(
+      `unsafe identifier: ${name} (only [A-Za-z_][A-Za-z0-9_]* allowed)`
+    );
+  }
+}
+var RealPreCleanupExecutor = class {
+  async execute(args) {
+    for (const r of args.resolutions) {
+      if (r.kind === "abort") {
+        throw new PromptCancelledError();
+      }
+    }
+    const seenEventIds = /* @__PURE__ */ new Set();
+    for (const r of args.resolutions) {
+      if (seenEventIds.has(r.eventId)) {
+        throw new Error(
+          `DUPLICATE_RESOLUTION_FOR_EVENT: ${r.eventId} has multiple resolutions attached`
+        );
+      }
+      seenEventIds.add(r.eventId);
+    }
+    const eventById = new Map(
+      args.events.map((e) => [e.id, e])
+    );
+    const threshold = readDeleteThreshold();
+    for (const r of args.resolutions) {
+      const event = eventById.get(r.eventId);
+      if (!event) continue;
+      if (event.kind !== "add_not_null_with_nulls" && event.kind !== "add_required_field_no_default") {
+        continue;
+      }
+      if (r.kind === "provide_default") {
+        const field = args.fields.find((f) => f.name === event.columnName);
+        const fieldType = field?.type ?? "text";
+        const validation = validateDefaultValue(
+          { name: event.columnName, type: fieldType },
+          r.value
+        );
+        if (!validation.success) {
+          throw new Error(
+            `INVALID_DEFAULT_FOR_TYPE: ${event.columnName} (${fieldType}) - ${validation.error}`
+          );
+        }
+        assertSafeIdent(event.tableName);
+        assertSafeIdent(event.columnName);
+        const stmt = sql`UPDATE ${sql.identifier(event.tableName)} SET ${sql.identifier(event.columnName)} = ${r.value} WHERE ${sql.identifier(event.columnName)} IS NULL`;
+        await runStatement(args.tx, args.dialect, stmt);
+      } else if (r.kind === "delete_nonconforming") {
+        if (event.kind === "add_not_null_with_nulls" && event.nullCount >= threshold) {
+          throw new Error(
+            `DELETE_THRESHOLD_EXCEEDED: ${event.nullCount} rows >= ${threshold}; explicit confirmation required`
+          );
+        }
+        assertSafeIdent(event.tableName);
+        assertSafeIdent(event.columnName);
+        const stmt = sql`DELETE FROM ${sql.identifier(event.tableName)} WHERE ${sql.identifier(event.columnName)} IS NULL`;
+        await runStatement(args.tx, args.dialect, stmt);
+      }
+    }
+    return applyMakeOptionalToSnapshot(
+      args.desiredSnapshot,
+      args.resolutions,
+      args.events
+    );
+  }
+};
+
+// src/domains/schema/pipeline/pushschema-pipeline.ts
+import { dequal } from "dequal";
+
+// src/init/schema-snapshot-cache.ts
+var g = globalThis;
+function getCachedSnapshot() {
+  return g.__nextly_prevSchemaSnapshot;
+}
+function setCachedSnapshot(snapshot) {
+  g.__nextly_prevSchemaSnapshot = snapshot;
+}
+
+// src/runtime/notifications/build-event.ts
+function buildNotificationEvent(args) {
+  const ts = (args.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  if (args.success) {
+    return {
+      ts,
+      source: args.source,
+      status: "success",
+      scope: args.scope,
+      summary: args.summary,
+      durationMs: args.durationMs,
+      journalId: args.journalId
+    };
+  }
+  return {
+    ts,
+    source: args.source,
+    status: "failed",
+    scope: args.scope,
+    summary: args.summary,
+    durationMs: args.durationMs,
+    journalId: args.journalId,
+    error: args.error
+  };
+}
+
+// src/domains/schema/pipeline/managed-tables.ts
+var MANAGED_TABLE_PREFIXES_REGEX = /^(dc_|single_|comp_)/;
+function isManagedTable(name) {
+  return MANAGED_TABLE_PREFIXES_REGEX.test(name);
+}
+
+// src/domains/schema/pipeline/pre-resolution/apply-resolutions.ts
+function applyResolutionsToOperations(ops, resolutions) {
+  const renamesToApply = resolutions.filter((r) => r.choice === "rename");
+  if (renamesToApply.length === 0) return ops;
+  const dropIndexByKey = /* @__PURE__ */ new Map();
+  const addIndexByKey = /* @__PURE__ */ new Map();
+  ops.forEach((op, i) => {
+    if (op.type === "drop_column") {
+      dropIndexByKey.set(keyDrop(op), i);
+    } else if (op.type === "add_column") {
+      addIndexByKey.set(keyAdd(op), i);
+    }
+  });
+  const consumed = /* @__PURE__ */ new Set();
+  const renameOps = [];
+  for (const r of renamesToApply) {
+    const dropKey = `${r.tableName}::${r.fromColumn}`;
+    const addKey = `${r.tableName}::${r.toColumn}`;
+    const dropIdx = dropIndexByKey.get(dropKey);
+    const addIdx = addIndexByKey.get(addKey);
+    if (dropIdx === void 0 || addIdx === void 0) continue;
+    if (consumed.has(dropIdx) || consumed.has(addIdx)) continue;
+    const dropOp = ops[dropIdx];
+    const addOp = ops[addIdx];
+    consumed.add(dropIdx);
+    consumed.add(addIdx);
+    renameOps.push({
+      type: "rename_column",
+      tableName: r.tableName,
+      fromColumn: r.fromColumn,
+      toColumn: r.toColumn,
+      fromType: dropOp.columnType,
+      toType: addOp.column.type
+    });
+  }
+  const out = [];
+  for (let i = 0; i < ops.length; i++) {
+    if (!consumed.has(i)) out.push(ops[i]);
+  }
+  out.push(...renameOps);
+  return out;
+}
+function keyDrop(op) {
+  return `${op.tableName}::${op.columnName}`;
+}
+function keyAdd(op) {
+  return `${op.tableName}::${op.column.name}`;
+}
+
+// src/domains/schema/pipeline/pre-resolution/executor.ts
+import { sql as sql2 } from "drizzle-orm";
+
+// src/domains/schema/pipeline/diff/types.ts
+var PRE_RESOLUTION_OP_TYPES = [
+  "rename_column",
+  "rename_table",
+  "drop_column",
+  "drop_table"
+];
+function isPreResolutionOp(op) {
+  return PRE_RESOLUTION_OP_TYPES.includes(op.type);
+}
+
+// src/domains/schema/pipeline/sql-templates/identifier-quoting.ts
+function quoteIdent(name, dialect) {
+  const q4 = dialect === "mysql" ? "`" : '"';
+  if (name.includes(q4)) {
+    throw new Error(
+      `Invalid identifier ${JSON.stringify(name)}: contains the dialect quote character (${q4}). Managed tables and FieldConfig column names must not contain quote characters.`
+    );
+  }
+  return `${q4}${name}${q4}`;
+}
+
+// src/domains/schema/pipeline/sql-templates/mysql.ts
+var q = (n) => quoteIdent(n, "mysql");
+function columnDef(c) {
+  const nullable = c.nullable ? "" : " NOT NULL";
+  const def = c.default !== void 0 ? ` DEFAULT ${c.default}` : "";
+  return `${q(c.name)} ${c.type}${nullable}${def}`;
+}
+function generateMysqlSQL(op) {
+  switch (op.type) {
+    case "add_table":
+      return generateAddTable(op);
+    case "drop_table":
+      return generateDropTable(op);
+    case "rename_table":
+      return generateRenameTable(op);
+    case "add_column":
+      return generateAddColumn(op);
+    case "drop_column":
+      return generateDropColumn(op);
+    case "rename_column":
+      return generateRenameColumn(op);
+    case "change_column_type":
+      return generateChangeColumnType(op);
+    case "change_column_nullable":
+      return generateChangeColumnNullable(op);
+    case "change_column_default":
+      return generateChangeColumnDefault(op);
+    default: {
+      const exhaustive = op;
+      void exhaustive;
+      throw new Error(
+        `generateMysqlSQL: unsupported op ${op.type}`
+      );
+    }
+  }
+}
+function generateAddTable(op) {
+  const cols = op.table.columns.map((c) => `  ${columnDef(c)}`).join(",\n");
+  return `CREATE TABLE ${q(op.table.name)} (
+${cols}
+)`;
+}
+function generateDropTable(op) {
+  return `DROP TABLE ${q(op.tableName)}`;
+}
+function generateRenameTable(op) {
+  return `ALTER TABLE ${q(op.fromName)} RENAME TO ${q(op.toName)}`;
+}
+function generateAddColumn(op) {
+  return `ALTER TABLE ${q(op.tableName)} ADD COLUMN ${columnDef(op.column)}`;
+}
+function generateDropColumn(op) {
+  return `ALTER TABLE ${q(op.tableName)} DROP COLUMN ${q(op.columnName)}`;
+}
+function generateRenameColumn(op) {
+  return `ALTER TABLE ${q(op.tableName)} RENAME COLUMN ${q(op.fromColumn)} TO ${q(op.toColumn)}`;
+}
+function generateChangeColumnType(op) {
+  return `ALTER TABLE ${q(op.tableName)} MODIFY COLUMN ${q(op.columnName)} ${op.toType}`;
+}
+function generateChangeColumnNullable(op) {
+  throw new MysqlUnsupportedOperationError(
+    "change_column_nullable",
+    `Cannot generate valid MODIFY COLUMN SQL for ${op.tableName}.${op.columnName} because the column type is not tracked on this operation. F12 will extend ChangeColumnNullableOp with the type. For now, use 'nextly migrate:create --blank' and hand-write 'ALTER TABLE \`${op.tableName}\` MODIFY COLUMN \`${op.columnName}\` <TYPE> ${op.toNullable ? "NULL" : "NOT NULL"};'.`
+  );
+}
+function generateChangeColumnDefault(op) {
+  return op.toDefault === void 0 ? `ALTER TABLE ${q(op.tableName)} ALTER COLUMN ${q(op.columnName)} DROP DEFAULT` : `ALTER TABLE ${q(op.tableName)} ALTER COLUMN ${q(op.columnName)} SET DEFAULT ${op.toDefault}`;
+}
+var MysqlUnsupportedOperationError = class extends Error {
+  constructor(opType, hint) {
+    super(`MySQL F11 PR 3 limitation: ${opType}. ${hint}`);
+    this.name = "MysqlUnsupportedOperationError";
+  }
+};
+
+// src/domains/schema/pipeline/sql-templates/postgres.ts
+var q2 = (n) => quoteIdent(n, "postgresql");
+function columnDef2(c) {
+  const nullable = c.nullable ? "" : " NOT NULL";
+  const def = c.default !== void 0 ? ` DEFAULT ${c.default}` : "";
+  return `${q2(c.name)} ${c.type}${nullable}${def}`;
+}
+function generatePgSQL(op) {
+  switch (op.type) {
+    case "add_table":
+      return generateAddTable2(op);
+    case "drop_table":
+      return generateDropTable2(op);
+    case "rename_table":
+      return generateRenameTable2(op);
+    case "add_column":
+      return generateAddColumn2(op);
+    case "drop_column":
+      return generateDropColumn2(op);
+    case "rename_column":
+      return generateRenameColumn2(op);
+    case "change_column_type":
+      return generateChangeColumnType2(op);
+    case "change_column_nullable":
+      return generateChangeColumnNullable2(op);
+    case "change_column_default":
+      return generateChangeColumnDefault2(op);
+    default: {
+      const exhaustive = op;
+      void exhaustive;
+      throw new Error(
+        `generatePgSQL: unsupported op ${op.type}`
+      );
+    }
+  }
+}
+function generateAddTable2(op) {
+  const cols = op.table.columns.map((c) => `  ${columnDef2(c)}`).join(",\n");
+  return `CREATE TABLE ${q2(op.table.name)} (
+${cols}
+)`;
+}
+function generateDropTable2(op) {
+  return `DROP TABLE ${q2(op.tableName)} CASCADE`;
+}
+function generateRenameTable2(op) {
+  return `ALTER TABLE ${q2(op.fromName)} RENAME TO ${q2(op.toName)}`;
+}
+function generateAddColumn2(op) {
+  return `ALTER TABLE ${q2(op.tableName)} ADD COLUMN ${columnDef2(op.column)}`;
+}
+function generateDropColumn2(op) {
+  return `ALTER TABLE ${q2(op.tableName)} DROP COLUMN ${q2(op.columnName)}`;
+}
+function generateRenameColumn2(op) {
+  return `ALTER TABLE ${q2(op.tableName)} RENAME COLUMN ${q2(op.fromColumn)} TO ${q2(op.toColumn)}`;
+}
+function generateChangeColumnType2(op) {
+  return `ALTER TABLE ${q2(op.tableName)} ALTER COLUMN ${q2(op.columnName)} TYPE ${op.toType}`;
+}
+function generateChangeColumnNullable2(op) {
+  return op.toNullable ? `ALTER TABLE ${q2(op.tableName)} ALTER COLUMN ${q2(op.columnName)} DROP NOT NULL` : `ALTER TABLE ${q2(op.tableName)} ALTER COLUMN ${q2(op.columnName)} SET NOT NULL`;
+}
+function generateChangeColumnDefault2(op) {
+  return op.toDefault === void 0 ? `ALTER TABLE ${q2(op.tableName)} ALTER COLUMN ${q2(op.columnName)} DROP DEFAULT` : `ALTER TABLE ${q2(op.tableName)} ALTER COLUMN ${q2(op.columnName)} SET DEFAULT ${op.toDefault}`;
+}
+
+// src/domains/schema/pipeline/sql-templates/sqlite.ts
+var q3 = (n) => quoteIdent(n, "sqlite");
+function columnDef3(c) {
+  const nullable = c.nullable ? "" : " NOT NULL";
+  const def = c.default !== void 0 ? ` DEFAULT ${c.default}` : "";
+  return `${q3(c.name)} ${c.type}${nullable}${def}`;
+}
+var SqliteUnsupportedOperationError = class extends Error {
+  constructor(opType, hint) {
+    super(
+      `SQLite does not support ${opType} in place. ${hint} For migrate:create, you may need to write a manual recreate-table migration via --blank.`
+    );
+    this.name = "SqliteUnsupportedOperationError";
+  }
+};
+function generateSqliteSQL(op) {
+  switch (op.type) {
+    case "add_table":
+      return generateAddTable3(op);
+    case "drop_table":
+      return generateDropTable3(op);
+    case "rename_table":
+      return generateRenameTable3(op);
+    case "add_column":
+      return generateAddColumn3(op);
+    case "drop_column":
+      return generateDropColumn3(op);
+    case "rename_column":
+      return generateRenameColumn3(op);
+    case "change_column_type":
+      throw new SqliteUnsupportedOperationError(
+        "change_column_type",
+        "Use ALTER TABLE ... RENAME TO ... + CREATE TABLE ... + INSERT INTO ... SELECT + DROP TABLE ..."
+      );
+    case "change_column_nullable":
+      throw new SqliteUnsupportedOperationError(
+        "change_column_nullable",
+        "Same recreate-table workaround as change_column_type."
+      );
+    case "change_column_default":
+      throw new SqliteUnsupportedOperationError(
+        "change_column_default",
+        "Same recreate-table workaround as change_column_type."
+      );
+    default: {
+      const exhaustive = op;
+      void exhaustive;
+      throw new Error(
+        `generateSqliteSQL: unsupported op ${op.type}`
+      );
+    }
+  }
+}
+function generateAddTable3(op) {
+  const cols = op.table.columns.map((c) => `  ${columnDef3(c)}`).join(",\n");
+  return `CREATE TABLE ${q3(op.table.name)} (
+${cols}
+)`;
+}
+function generateDropTable3(op) {
+  return `DROP TABLE ${q3(op.tableName)}`;
+}
+function generateRenameTable3(op) {
+  return `ALTER TABLE ${q3(op.fromName)} RENAME TO ${q3(op.toName)}`;
+}
+function generateAddColumn3(op) {
+  return `ALTER TABLE ${q3(op.tableName)} ADD COLUMN ${columnDef3(op.column)}`;
+}
+function generateDropColumn3(op) {
+  return `ALTER TABLE ${q3(op.tableName)} DROP COLUMN ${q3(op.columnName)}`;
+}
+function generateRenameColumn3(op) {
+  return `ALTER TABLE ${q3(op.tableName)} RENAME COLUMN ${q3(op.fromColumn)} TO ${q3(op.toColumn)}`;
+}
+
+// src/domains/schema/pipeline/sql-templates/index.ts
+function generateSQL(op, dialect) {
+  switch (dialect) {
+    case "postgresql":
+      return generatePgSQL(op);
+    case "mysql":
+      return generateMysqlSQL(op);
+    case "sqlite":
+      return generateSqliteSQL(op);
+    default: {
+      const exhaustive = dialect;
+      void exhaustive;
+      throw new Error(`generateSQL: unsupported dialect ${dialect}`);
+    }
+  }
+}
+
+// src/domains/schema/pipeline/pre-resolution/executor.ts
+async function executePreResolutionOps(txOrDb, ops, dialect) {
+  const preOps = ops.filter(isPreResolutionOp);
+  if (preOps.length === 0) return 0;
+  const ordered = orderForExecution(preOps);
+  for (const op of ordered) {
+    const sqlString = sqlForOp(op, dialect);
+    await runRaw(txOrDb, sqlString, dialect);
+  }
+  return ordered.length;
+}
+function orderForExecution(ops) {
+  const renameTables = [];
+  const renameColumns = [];
+  const dropColumns = [];
+  const dropTables = [];
+  for (const op of ops) {
+    if (op.type === "rename_table") renameTables.push(op);
+    else if (op.type === "rename_column") renameColumns.push(op);
+    else if (op.type === "drop_column") dropColumns.push(op);
+    else if (op.type === "drop_table") dropTables.push(op);
+  }
+  return [...renameTables, ...renameColumns, ...dropColumns, ...dropTables];
+}
+function sqlForOp(op, dialect) {
+  return generateSQL(op, dialect);
+}
+async function runRaw(txOrDb, sqlString, dialect) {
+  if (dialect === "sqlite") {
+    const handle2 = txOrDb;
+    handle2.run(sql2.raw(sqlString));
+    return;
+  }
+  const handle = txOrDb;
+  await handle.execute(sql2.raw(sqlString));
+}
+
+// src/domains/schema/pipeline/stdout-capture.ts
+async function withCapturedStdout(work, logger) {
+  if (process.stdin.isTTY) {
+    return work();
+  }
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  process.stdout.write = ((chunk) => {
+    stdoutBuffer += String(chunk);
+    return true;
+  });
+  process.stderr.write = ((chunk) => {
+    stderrBuffer += String(chunk);
+    return true;
+  });
+  try {
+    const result = await work();
+    flushBufferedToDebug("[drizzle-kit stdout]", stdoutBuffer, logger);
+    flushBufferedToDebug("[drizzle-kit stderr]", stderrBuffer, logger);
+    return result;
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+}
+function flushBufferedToDebug(prefix, buffer, logger) {
+  if (!buffer) return;
+  const trimmed = buffer.replace(/\n+$/, "");
+  if (!trimmed) return;
+  if (logger?.debug) {
+    logger.debug(`${prefix} ${trimmed}`);
+  }
+}
+
+// src/domains/schema/pipeline/pushschema-pipeline.ts
+function applyMakeOptionalToDesired(desired, resolutions, events) {
+  const makeOptionalEventIds = new Set(
+    resolutions.filter((r) => r.kind === "make_optional").map((r) => r.eventId)
+  );
+  if (makeOptionalEventIds.size === 0) return desired;
+  const targets = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (makeOptionalEventIds.has(event.id) && (event.kind === "add_not_null_with_nulls" || event.kind === "add_required_field_no_default")) {
+      targets.set(event.id, {
+        table: event.tableName,
+        column: event.columnName
+      });
+    }
+  }
+  if (targets.size === 0) return desired;
+  const patchCollection = (coll) => {
+    const matchingTargets = [...targets.values()].filter(
+      (t) => t.table === coll.tableName
+    );
+    if (matchingTargets.length === 0) return coll;
+    return {
+      ...coll,
+      fields: coll.fields.map((field) => {
+        const matched = matchingTargets.some((t) => t.column === field.name);
+        if (!matched) return field;
+        return { ...field, required: false };
+      })
+    };
+  };
+  return {
+    ...desired,
+    collections: Object.fromEntries(
+      Object.entries(desired.collections).map(([slug, c]) => [
+        slug,
+        patchCollection(c)
+      ])
+    ),
+    singles: Object.fromEntries(
+      Object.entries(desired.singles).map(([slug, s]) => [
+        slug,
+        patchCollection(s)
+      ])
+    ),
+    components: Object.fromEntries(
+      Object.entries(desired.components).map(([slug, c]) => [
+        slug,
+        patchCollection(c)
+      ])
+    )
+  };
+}
+var PushSchemaError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "PushSchemaError";
+  }
+};
+var DdlExecutionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "DdlExecutionError";
+  }
+};
+function computeJournalSummaryFromOperations(operations) {
+  let added = 0;
+  let removed = 0;
+  let renamed = 0;
+  let changed = 0;
+  for (const op of operations) {
+    switch (op.type) {
+      case "add_table":
+      case "add_column":
+        added++;
+        break;
+      case "drop_table":
+      case "drop_column":
+        removed++;
+        break;
+      case "rename_table":
+      case "rename_column":
+        renamed++;
+        break;
+      case "change_column_type":
+      case "change_column_nullable":
+      case "change_column_default":
+        changed++;
+        break;
+      default: {
+        const exhaustive = op;
+        void exhaustive;
+        break;
+      }
+    }
+  }
+  return { added, removed, renamed, changed };
+}
+function computeJournalScope(source, uiTargetSlug) {
+  if (source === "ui" && uiTargetSlug) {
+    return { kind: "collection", slug: uiTargetSlug };
+  }
+  return { kind: "global" };
+}
+function toNotificationScope(scope) {
+  if (scope.kind === "fresh-push") return { kind: "fresh-push" };
+  if (scope.kind === "global") {
+    return scope.slug ? { kind: "global", slug: scope.slug } : { kind: "global" };
+  }
+  return scope.slug ? { kind: scope.kind, slug: scope.slug } : { kind: "global" };
+}
+var PushSchemaPipeline = class {
+  constructor(deps, testHooks = {}) {
+    this.deps = deps;
+    this.testHooks = testHooks;
+  }
+  async apply(args) {
+    const { desired, db, dialect, source, promptChannel, databaseName } = args;
+    const scope = computeJournalScope(source, args.uiTargetSlug);
+    const startMs = Date.now();
+    const cachedSnapshot = getCachedSnapshot();
+    if (cachedSnapshot !== void 0 && dequal(desired, cachedSnapshot)) {
+      console.log(
+        "[Nextly schema] No changes detected since last apply; skipping push (dequal cache hit)."
+      );
+      return {
+        success: true,
+        statementsExecuted: 0,
+        renamesApplied: 0,
+        // Zero-count summary — same shape as the full-success branch,
+        // so the dispatcher's notification rendering doesn't have to
+        // distinguish "no-op" from "real-success-with-no-ops".
+        summary: {
+          added: 0,
+          removed: 0,
+          renamed: 0,
+          changed: 0
+        }
+      };
+    }
+    const journalId = await this.deps.migrationJournal.recordStart({
+      source,
+      statementsPlanned: 0,
+      scope,
+      batch: source === "code" ? -1 : void 0
+    });
+    try {
+      const managedTableNames = [
+        ...Object.values(desired.collections).map((c) => c.tableName),
+        ...Object.values(desired.singles).map((s) => s.tableName),
+        ...Object.values(desired.components).map((c) => c.tableName)
+      ];
+      const liveSnapshot = this.testHooks._introspectSnapshotOverride ? await this.testHooks._introspectSnapshotOverride(
+        db,
+        dialect,
+        managedTableNames
+      ) : await introspectLiveSnapshot(db, dialect, managedTableNames);
+      const desiredSnapshot = {
+        tables: [
+          ...Object.values(desired.collections).map(
+            (c) => buildDesiredTableFromFields(
+              c.tableName,
+              // FieldConfig has the shape buildDesiredTableFromFields expects;
+              // cast through unknown for the structural-vs-nominal type gap.
+              c.fields,
+              dialect,
+              // Thread the status flag so the diff includes the status system
+              // column when Draft/Published is enabled.
+              { hasStatus: c.status === true }
+            )
+          ),
+          ...Object.values(desired.singles).map(
+            (s) => buildDesiredTableFromFields(
+              s.tableName,
+              s.fields,
+              dialect,
+              { hasStatus: s.status === true }
+            )
+          ),
+          ...Object.values(desired.components).map(
+            (c) => buildDesiredTableFromComponentFields(
+              c.tableName,
+              c.fields,
+              dialect
+            )
+          )
+        ]
+      };
+      const operations = diffSnapshots(liveSnapshot, desiredSnapshot);
+      const candidates = this.deps.renameDetector.detect(operations, dialect);
+      const classificationResult = await this.deps.classifier.classify({
+        operations,
+        drizzleWarnings: [],
+        hasDataLoss: false,
+        countNulls: (table, column) => countNulls(db, dialect, table, column),
+        countRows: (table) => countRows(db, dialect, table),
+        dialect
+      });
+      const dispatchResult = candidates.length > 0 || classificationResult.level !== "safe" ? await this.deps.promptDispatcher.dispatch({
+        candidates,
+        events: classificationResult.events,
+        classification: classificationResult.level,
+        channel: promptChannel
+      }) : {
+        confirmedRenames: [],
+        resolutions: [],
+        proceed: true
+      };
+      if (!dispatchResult.proceed) {
+        throw new PromptCancelledError();
+      }
+      const patchedDesired = applyMakeOptionalToDesired(
+        desired,
+        dispatchResult.resolutions,
+        classificationResult.events
+      );
+      const resolvedOps = applyResolutionsToOperations(
+        operations,
+        toRenameResolutions(dispatchResult.confirmedRenames, candidates)
+      );
+      const drizzleSchema = this.testHooks._buildDrizzleSchemaOverride ? this.testHooks._buildDrizzleSchemaOverride(patchedDesired, dialect) : this.buildDrizzleSchema(patchedDesired, dialect);
+      const kit = this.testHooks._kitOverride ? this.testHooks._kitOverride : await this.importDrizzleKit(dialect, databaseName);
+      const isSqlite = dialect === "sqlite";
+      const runApply = async (tx) => {
+        const preResExecutor = this.testHooks._executePreResolutionOverride ?? executePreResolutionOps;
+        try {
+          await preResExecutor(tx, resolvedOps, dialect);
+        } catch (err) {
+          throw new DdlExecutionError(
+            err instanceof Error ? err.message : String(err),
+            err
+          );
+        }
+        const aggregatedFields = [
+          ...Object.values(desired.collections),
+          ...Object.values(desired.singles),
+          ...Object.values(desired.components)
+        ].flatMap(
+          (c) => c.fields.filter(
+            (f) => typeof f.name === "string"
+          ).map((f) => ({ name: f.name, type: f.type }))
+        );
+        try {
+          await this.deps.preCleanupExecutor.execute({
+            tx,
+            desiredSnapshot,
+            resolutions: dispatchResult.resolutions,
+            events: classificationResult.events,
+            fields: aggregatedFields,
+            dialect
+          });
+        } catch (err) {
+          if (err instanceof PromptCancelledError) throw err;
+          throw new DdlExecutionError(
+            err instanceof Error ? err.message : String(err),
+            err
+          );
+        }
+        const desiredTableNames = Object.keys(drizzleSchema);
+        let pushResult;
+        try {
+          pushResult = await withCapturedStdout(
+            () => kit.pushSchema(drizzleSchema, tx, desiredTableNames),
+            // eslint-disable-next-line turbo/no-undeclared-env-vars
+            process.env.DEBUG_SCHEMA === "1" ? { debug: (msg) => console.debug(msg) } : void 0
+          );
+        } catch (err) {
+          throw new PushSchemaError(
+            err instanceof Error ? err.message : String(err),
+            err
+          );
+        }
+        const safe = this.filterUnsafeStatements(
+          pushResult.statementsToExecute,
+          desiredTableNames
+        );
+        try {
+          await this.deps.executor.executeStatements(tx, safe);
+        } catch (err) {
+          throw new DdlExecutionError(
+            err instanceof Error ? err.message : String(err),
+            err
+          );
+        }
+        return safe.length;
+      };
+      let statementsExecuted;
+      if (isSqlite) {
+        await this.runSqlitePragma(db, "PRAGMA foreign_keys = OFF");
+        try {
+          statementsExecuted = await runApply(db);
+        } finally {
+          await this.runSqlitePragma(db, "PRAGMA foreign_keys = ON");
+        }
+      } else {
+        const txFn = this.testHooks._txOverride ? this.testHooks._txOverride : this.makeTransactionRunner(db);
+        statementsExecuted = await txFn(runApply);
+      }
+      const summary = computeJournalSummaryFromOperations(resolvedOps);
+      setCachedSnapshot(desired);
+      await this.deps.migrationJournal.recordEnd(journalId, {
+        success: true,
+        statementsExecuted,
+        summary
+      });
+      await this.deps.notifier.notify(
+        buildNotificationEvent({
+          success: true,
+          source,
+          scope: toNotificationScope(scope),
+          summary,
+          durationMs: Date.now() - startMs,
+          journalId
+        })
+      );
+      return {
+        success: true,
+        statementsExecuted,
+        renamesApplied: dispatchResult.confirmedRenames.length,
+        // F10 PR 6: surface the diff counts so the dispatcher can
+        // render an admin toast like "1 field added, 1 renamed".
+        summary
+      };
+    } catch (err) {
+      const code = this.classifyErrorCode(err);
+      const message = err instanceof Error ? err.message : String(err);
+      await this.deps.migrationJournal.recordEnd(journalId, {
+        success: false,
+        statementsExecuted: 0,
+        error: err
+      });
+      await this.deps.notifier.notify(
+        buildNotificationEvent({
+          success: false,
+          source,
+          scope: toNotificationScope(scope),
+          durationMs: Date.now() - startMs,
+          journalId,
+          error: { code, message }
+        })
+      );
+      return {
+        success: false,
+        statementsExecuted: 0,
+        renamesApplied: 0,
+        error: {
+          code,
+          message: err instanceof Error ? err.message : String(err),
+          details: err
+        }
+      };
+    }
+  }
+  filterUnsafeStatements(statements, desiredTableNames) {
+    const desiredSet = new Set(
+      desiredTableNames.map((t) => t.toLowerCase())
+    );
+    return statements.filter((stmt) => {
+      const dropMatch = stmt.match(
+        /^DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:["`]?\w+["`]?\.)?["`]?(\w+)["`]?/i
+      );
+      if (!dropMatch) return true;
+      const tableName = dropMatch[1] ?? "<unknown>";
+      const isInDesired = desiredSet.has(tableName.toLowerCase());
+      if (isInDesired) {
+        return true;
+      }
+      console.warn(
+        `[Nextly schema] Blocked DROP TABLE "${tableName}" emitted by drizzle-kit pushSchema (table not in current desired schema). If this drop was intentional, route it through the pre-resolution executor with explicit user confirmation. (managed=${isManagedTable(tableName)})`
+      );
+      return false;
+    });
+  }
+  async runSqlitePragma(db, pragma) {
+    const { sql: sqlTag } = await import("drizzle-orm");
+    const dbTyped = db;
+    dbTyped.run(sqlTag.raw(pragma));
+  }
+  buildDrizzleSchema(desired, dialect) {
+    const out = {};
+    for (const [exportKey, value] of Object.entries(
+      getDialectTables(dialect)
+    )) {
+      if (this.isDrizzleTable(value)) {
+        const sqlName = this.getDrizzleTableName(value, exportKey);
+        out[sqlName] = value;
+      }
+    }
+    for (const c of Object.values(desired.collections)) {
+      const { table } = generateRuntimeSchema(
+        c.tableName,
+        c.fields,
+        dialect,
+        { status: c.status === true }
+      );
+      out[c.tableName] = table;
+    }
+    for (const s of Object.values(desired.singles)) {
+      const { table } = generateRuntimeSchema(
+        s.tableName,
+        s.fields,
+        dialect,
+        { status: s.status === true }
+      );
+      out[s.tableName] = table;
+    }
+    const componentSchemaService = new ComponentSchemaService(dialect);
+    for (const c of Object.values(desired.components)) {
+      const componentTable = componentSchemaService.generateRuntimeSchema(
+        c.tableName,
+        c.fields
+      );
+      out[c.tableName] = componentTable;
+    }
+    return out;
+  }
+  // Phase 6 follow-up: cheap structural check for Drizzle tables.
+  // Mirrors SchemaRegistry.isDrizzleTable but inlined to avoid
+  // pulling SchemaRegistry's DI graph into the pipeline module.
+  isDrizzleTable(value) {
+    if (!value || typeof value !== "object") return false;
+    return Symbol.for("drizzle:Name") in value;
+  }
+  // Phase 6 follow-up: extract a Drizzle table's SQL name.
+  getDrizzleTableName(value, fallback) {
+    const named = value[Symbol.for("drizzle:Name")];
+    return typeof named === "string" ? named : fallback;
+  }
+  async importDrizzleKit(dialect, databaseName) {
+    const { getPgDrizzleKit, getMySQLDrizzleKit, getSQLiteDrizzleKit } = await import("./drizzle-kit-lazy-D2M2PXR2.mjs");
+    switch (dialect) {
+      case "postgresql": {
+        const kit = await getPgDrizzleKit();
+        return {
+          // PG drizzle-kit accepts tablesFilter (4th arg) — pass through
+          // so introspection is scoped to just the current pipeline's
+          // desired tables. Eliminates spurious DROP TABLE / RENAME
+          // emissions for managed tables outside the pipeline's scope.
+          pushSchema: (schema, db, tablesFilter) => kit.pushSchema(schema, db, ["public"], tablesFilter)
+        };
+      }
+      case "mysql": {
+        if (!databaseName) {
+          throw new Error(
+            "PushSchemaPipeline: MySQL requires databaseName in apply() args. Caller (e.g. dev-server.ts, dispatcher) must extract the database name from the connection URL and pass it through."
+          );
+        }
+        const kit = await getMySQLDrizzleKit();
+        return {
+          // MySQL drizzle-kit upstream takes (schema, db, databaseName) —
+          // no tablesFilter slot. Discard the arg here; the post-emission
+          // filterUnsafeStatements is the data-loss safeguard.
+          pushSchema: (schema, db) => kit.pushSchema(schema, db, databaseName)
+        };
+      }
+      case "sqlite": {
+        const kit = await getSQLiteDrizzleKit();
+        return {
+          // SQLite drizzle-kit upstream takes only (schema, db) — no
+          // tablesFilter. Same caveat as MySQL.
+          pushSchema: (schema, db) => kit.pushSchema(schema, db)
+        };
+      }
+      default: {
+        const exhaustive = dialect;
+        throw new Error(`Unsupported dialect: ${String(exhaustive)}`);
+      }
+    }
+  }
+  makeTransactionRunner(db) {
+    const dbTyped = db;
+    return (fn) => dbTyped.transaction(fn);
+  }
+  classifyErrorCode(err) {
+    if (err instanceof PushSchemaError) return "PUSHSCHEMA_FAILED";
+    if (err instanceof DdlExecutionError) return "DDL_EXECUTION_FAILED";
+    if (err instanceof TTYRequiredError) return "CONFIRMATION_REQUIRED_NO_TTY";
+    if (err instanceof PromptCancelledError) return "CONFIRMATION_DECLINED";
+    return "INTERNAL_ERROR";
+  }
+};
+function toRenameResolutions(confirmedRenames, allCandidates) {
+  const confirmedSet = new Set(
+    confirmedRenames.map((c) => `${c.tableName}::${c.fromColumn}::${c.toColumn}`)
+  );
+  return allCandidates.map((c) => ({
+    tableName: c.tableName,
+    fromColumn: c.fromColumn,
+    toColumn: c.toColumn,
+    choice: confirmedSet.has(`${c.tableName}::${c.fromColumn}::${c.toColumn}`) ? "rename" : "drop_and_add"
+  }));
+}
+
+// src/domains/schema/pipeline/pushschema-pipeline-stubs.ts
+var noopPreRenameExecutor = {
+  execute: () => Promise.resolve()
+};
+var noopMigrationJournal = {
+  recordStart: () => Promise.resolve("noop-journal-id"),
+  recordEnd: () => Promise.resolve()
+};
+
+// src/domains/schema/services/drizzle-statement-executor.ts
+var DrizzleStatementExecutor = class {
+  constructor(dialect, db) {
+    this.dialect = dialect;
+    this.db = db;
+  }
+  // tx is load-bearing for PG and MySQL (we execute via tx.execute so
+  // the statements run inside the pipeline's transaction). For SQLite,
+  // tx is intentionally ignored — better-sqlite3's driver is sync and
+  // automatically associates this.db.run() calls with the active
+  // transaction context (started by drizzle's db.transaction()).
+  async executeStatements(tx, statements) {
+    if (statements.length === 0) return;
+    switch (this.dialect) {
+      case "postgresql":
+        return this.executePg(tx, statements);
+      case "mysql":
+        return this.executeMysql(tx, statements);
+      case "sqlite":
+        return this.executeSqlite(statements);
+      default: {
+        const exhaustive = this.dialect;
+        throw new Error(`Unsupported dialect: ${String(exhaustive)}`);
+      }
+    }
+  }
+  async executePg(tx, statements) {
+    const { sql: sqlTag } = await import("drizzle-orm");
+    const txTyped = tx;
+    for (const stmt of statements) {
+      await txTyped.execute(sqlTag.raw(stmt));
+    }
+  }
+  async executeMysql(tx, statements) {
+    const { sql: sqlTag } = await import("drizzle-orm");
+    const txTyped = tx;
+    for (const stmt of statements) {
+      await txTyped.execute(sqlTag.raw(stmt));
+    }
+  }
+  async executeSqlite(statements) {
+    const { sql: sqlTag } = await import("drizzle-orm");
+    const dbTyped = this.db;
+    for (const rawStmt of statements) {
+      const pieces = rawStmt.split("\n").map((line) => line.replace(/--> statement-breakpoint/g, "")).join("\n").split(";").map((s) => s.trim()).filter(
+        (s) => s.length > 0 && !s.startsWith("--") && /\b(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE)\b/i.test(s)
+      );
+      for (const raw of pieces) {
+        const stmt = await this.rewriteRecreateInsertForMissingCols(raw);
+        try {
+          dbTyped.run(sqlTag.raw(stmt));
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const causeMsg = err instanceof Error && err.cause instanceof Error ? err.cause.message : "";
+          if (msg.includes("already exists") || msg.includes("duplicate column name") || causeMsg.includes("already exists") || causeMsg.includes("duplicate column name")) {
+            continue;
+          }
+          throw err;
+        }
+      }
+    }
+    const violations = dbTyped.all(
+      sqlTag.raw("PRAGMA foreign_key_check")
+    );
+    if (violations.length > 0) {
+      const byTable = /* @__PURE__ */ new Map();
+      for (const v of violations) {
+        byTable.set(v.table, (byTable.get(v.table) ?? 0) + 1);
+      }
+      const summary = [...byTable.entries()].map(([t, n]) => `${t}: ${n} orphan(s)`).join(", ");
+      const sample = JSON.stringify(violations.slice(0, 5));
+      throw new Error(
+        `SQLite foreign_key_check found ${violations.length} FK violation(s) after schema apply (${summary}). First few rows: ${sample}`
+      );
+    }
+  }
+  // Preserved verbatim (with structural typing) from the old
+  // DrizzlePushService — see that class for the original rationale.
+  // Drizzle-kit 0.31.10's SQLite recreate-table strategy emits
+  //   INSERT INTO `__new_<t>`(cols) SELECT cols FROM `<t>`
+  // where `cols` includes columns that do not yet exist in `<t>`.
+  // That fails with "no such column". This rewrites the SELECT list
+  // so missing columns are substituted with NULL.
+  async rewriteRecreateInsertForMissingCols(stmt) {
+    const m = stmt.match(
+      /^INSERT\s+INTO\s+`(__new_[^`]+)`\s*\(([^)]+)\)\s+SELECT\s+([^]+?)\s+FROM\s+`([^`]+)`\s*$/i
+    );
+    if (!m) return stmt;
+    const [, , insertColsRaw, , sourceTable] = m;
+    if (/["\0]/.test(sourceTable)) return stmt;
+    const insertCols = insertColsRaw.split(",").map((c) => c.trim().replace(/^`|`$/g, "").replace(/^"|"$/g, ""));
+    let sourceColNames;
+    try {
+      const { sql: sqlTag } = await import("drizzle-orm");
+      const dbTyped = this.db;
+      const rows = dbTyped.all(
+        sqlTag.raw(`PRAGMA table_info("${sourceTable}")`)
+      );
+      sourceColNames = rows.map((r) => r.name);
+    } catch {
+      return stmt;
+    }
+    const selectList = insertCols.map((col) => sourceColNames.includes(col) ? `"${col}"` : "NULL").join(", ");
+    const colList = insertCols.map((col) => `"${col}"`).join(", ");
+    return `INSERT INTO \`__new_${sourceTable}\`(${colList}) SELECT ${selectList} FROM \`${sourceTable}\``;
+  }
+};
+
+// src/runtime/notifications/production.ts
+import { join } from "path";
+
+// src/runtime/notifications/channels/ndjson.ts
+import { mkdir, appendFile } from "fs/promises";
+import { dirname } from "path";
+var NDJSONChannel = class {
+  name = "ndjson";
+  filePath;
+  logger;
+  dirEnsured = false;
+  disabled = false;
+  constructor(opts) {
+    this.filePath = opts.filePath;
+    this.logger = opts.logger ?? {};
+  }
+  async write(event) {
+    if (this.disabled) return;
+    try {
+      if (!this.dirEnsured) {
+        await mkdir(dirname(this.filePath), { recursive: true });
+        this.dirEnsured = true;
+      }
+      const line = `${JSON.stringify(event)}
+`;
+      await appendFile(this.filePath, line, { encoding: "utf8" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.warn?.(
+        `[notifications] ndjson channel disabled (${msg}). Restart the dev server after fixing the underlying cause.`
+      );
+      this.disabled = true;
+    }
+  }
+};
+
+// src/runtime/notifications/channels/terminal.ts
+var TerminalChannel = class {
+  name = "terminal";
+  writer;
+  constructor(opts = {}) {
+    this.writer = opts.writer ?? ((chunk) => process.stdout.write(chunk));
+  }
+  write(event) {
+    if (event.status === "failed" && event.error.code === "CONFIRMATION_REQUIRED_NO_TTY") {
+      return Promise.resolve();
+    }
+    const title = event.status === "success" ? `Schema applied \u2014 ${describeScope(event.scope)}` : `Schema apply FAILED \u2014 ${describeScope(event.scope)}`;
+    const detail = event.status === "success" ? describeSummary(event.summary) : event.error.message;
+    const meta = `${event.source === "ui" ? "ui" : "hmr"} \xB7 ${event.durationMs}ms`;
+    const box = boxify([title, detail, meta]);
+    this.writer(box + "\n");
+    return Promise.resolve();
+  }
+};
+function describeScope(scope) {
+  if (scope.kind === "fresh-push") return "fresh-push";
+  if (scope.kind === "global") {
+    return scope.slug ? `global:${scope.slug}` : "global";
+  }
+  return `${scope.kind}:${scope.slug}`;
+}
+function describeSummary(s) {
+  const parts = [];
+  if (s.added) parts.push(`${s.added} added`);
+  if (s.removed) parts.push(`${s.removed} removed`);
+  if (s.renamed) parts.push(`${s.renamed} renamed`);
+  if (s.changed) parts.push(`${s.changed} changed`);
+  return parts.length > 0 ? parts.join(", ") : "no changes";
+}
+function boxify(lines) {
+  const minWidth = 20;
+  const width = Math.max(...lines.map((l) => l.length), minWidth);
+  const border = `+${"-".repeat(width + 2)}+`;
+  const padded = lines.map((l) => `| ${l.padEnd(width)} |`);
+  return [border, ...padded, border].join("\n");
+}
+
+// src/runtime/notifications/dispatcher.ts
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (err === void 0) return "undefined";
+  if (err === null) return "null";
+  if (typeof err === "number" || typeof err === "boolean") {
+    return String(err);
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return "[unstringifiable error]";
+  }
+}
+function createNotifier(opts) {
+  const { channels, logger } = opts;
+  return {
+    async notify(event) {
+      for (const channel of channels) {
+        try {
+          await channel.write(event);
+        } catch (err) {
+          logger?.warn?.(
+            `[notifications] ${channel.name} channel failed: ${describeError(err)}`
+          );
+        }
+      }
+    }
+  };
+}
+
+// src/runtime/notifications/production.ts
+var cached = null;
+function getProductionNotifier() {
+  if (cached) return cached;
+  cached = createNotifier({
+    channels: [
+      new TerminalChannel(),
+      new NDJSONChannel({
+        filePath: join(process.cwd(), ".nextly", "logs", "migrations.log")
+      })
+    ],
+    logger: {
+      warn: (msg) => console.warn(msg)
+    }
+  });
+  return cached;
+}
+
+export {
+  createApplyDesiredSchema,
+  TTYRequiredError,
+  PromptCancelledError,
+  RealPreCleanupExecutor,
+  generateSQL,
+  PushSchemaPipeline,
+  noopPreRenameExecutor,
+  noopMigrationJournal,
+  DrizzleStatementExecutor,
+  getProductionNotifier
+};