@absolutejs/absolute 0.20.0-beta.120 → 0.20.0-beta.122

package/dist/cli/db-8wweexdp.js

@@ -0,0 +1,1100 @@
+// @bun
+import {
+  colors
+} from "./index-8nym68py.js";
+import {
+  UNFOUND_INDEX
+} from "./index-czwrxgdj.js";
+import {
+  __require
+} from "./index-mywsk201.js";
+
+// src/cli/scripts/db.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var {env, spawn } = globalThis.Bun;
+
+// src/cli/scripts/dbEngines/detect.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var DRIZZLE_CONFIGS = [
+  "drizzle.config.ts",
+  "drizzle.config.mts",
+  "drizzle.config.js",
+  "drizzle.config.mjs",
+  "drizzle.config.cjs"
+];
+var PRISMA_SCHEMAS = ["prisma/schema.prisma", "schema.prisma"];
+var SQLITE_FILE_PATTERN = /\.(db|db3|sqlite|sqlite3)$/i;
+var SUPPORTED_SCHEMES = "postgres://, postgresql://, cockroachdb://, mysql://, mariadb://, singlestore://, file:, sqlite:, libsql://, http(s)://, ws(s)://, sqlserver://, mssql://";
+var SCHEME_FAMILIES = {
+  "cockroachdb:": "postgres",
+  "file:": "sqlite",
+  "http:": "libsql",
+  "https:": "libsql",
+  "libsql:": "libsql",
+  "mariadb:": "mysql",
+  "mssql:": "mssql",
+  "mysql:": "mysql",
+  "postgres:": "postgres",
+  "postgresql:": "postgres",
+  "singlestore:": "mysql",
+  "sqlite:": "sqlite",
+  "sqlite3:": "sqlite",
+  "sqlserver:": "mssql",
+  "ws:": "libsql",
+  "wss:": "libsql"
+};
+var REFUSED_SCHEMES = {
+  "edgedb:": "Gel (EdgeDB)",
+  "gel:": "Gel (EdgeDB)",
+  "mongodb:": "MongoDB",
+  "mongodb+srv:": "MongoDB"
+};
+var DIALECT_FAMILIES = {
+  cockroach: "postgres",
+  cockroachdb: "postgres",
+  mssql: "mssql",
+  mysql: "mysql",
+  postgresql: "postgres",
+  singlestore: "mysql",
+  sqlite: "sqlite",
+  sqlserver: "mssql",
+  turso: "sqlite"
+};
+var REFUSED_DIALECTS = {
+  gel: "Gel (EdgeDB)",
+  mongodb: "MongoDB"
+};
+var readText = (path) => existsSync(path) ? readFileSync(path, "utf-8") : undefined;
+var drizzleHint = (cwd) => DRIZZLE_CONFIGS.map((name) => {
+  const text = readText(join(cwd, name));
+  const dialect = text?.match(/dialect\s*:\s*['"`](\w+)['"`]/)?.[1];
+  return dialect === undefined ? undefined : { dialect, source: name };
+}).find((hint) => hint !== undefined);
+var prismaHint = (cwd) => PRISMA_SCHEMAS.map((name) => {
+  const text = readText(join(cwd, name));
+  const block = text?.match(/datasource\s+\w+\s*\{[^}]*\}/)?.[0];
+  const provider = block?.match(/provider\s*=\s*"(\w+)"/)?.[1];
+  return provider === undefined ? undefined : { dialect: provider, source: name };
+}).find((hint) => hint !== undefined);
+var readOrmDialect = (cwd) => drizzleHint(cwd) ?? prismaHint(cwd);
+var refuse = (engine, origin) => new Error(`absolute db does not support ${engine} (${origin}): backup/restore works on SQL databases only \u2014 PostgreSQL, CockroachDB, MySQL, MariaDB, SingleStore, SQLite, libSQL/Turso and SQL Server.`);
+var schemeOf = (url) => {
+  const match = url.match(/^([a-z][a-z0-9+.-]*:)/i);
+  return match?.[1]?.toLowerCase();
+};
+var familyForSchemeless = (url, hint) => {
+  const hinted = hint === undefined ? undefined : DIALECT_FAMILIES[hint.dialect];
+  if (hinted === "sqlite" || SQLITE_FILE_PATTERN.test(url))
+    return "sqlite";
+  return;
+};
+var detectTarget = (url, hint) => {
+  const scheme = schemeOf(url);
+  const refusedScheme = scheme === undefined ? undefined : REFUSED_SCHEMES[scheme];
+  if (refusedScheme !== undefined)
+    throw refuse(refusedScheme, `${scheme}// URL`);
+  const family = scheme === undefined || scheme.length === 2 ? familyForSchemeless(url, hint) : SCHEME_FAMILIES[scheme];
+  const refusedDialect = hint === undefined ? undefined : REFUSED_DIALECTS[hint.dialect];
+  if (family === undefined && refusedDialect !== undefined && hint)
+    throw refuse(refusedDialect, `${hint.source} declares "${hint.dialect}"`);
+  if (family === undefined)
+    throw new Error(`Unrecognised database URL${scheme === undefined ? "" : ` scheme "${scheme}"`}. absolute db understands ${SUPPORTED_SCHEMES}, or a path to a .db/.sqlite file.`);
+  return { family, url };
+};
+var sqlitePath = (url, cwd) => {
+  const withoutScheme = url.replace(/^(sqlite3?|file):(\/\/)?/i, "").replace(/\?.*$/, "");
+  const decoded = decodeURIComponent(withoutScheme);
+  if (decoded === ":memory:")
+    throw new Error("An in-memory SQLite database (:memory:) has nothing to back up or restore; point --url at a database file.");
+  const candidates = decoded.startsWith("/") ? [decoded] : [join(cwd, decoded), join(cwd, "prisma", decoded)];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (found === undefined)
+    throw new Error(`SQLite database file not found: ${candidates[0]}. Create it (run your migrations) first \u2014 absolute db never creates an empty database.`);
+  return found;
+};
+
+// src/cli/scripts/dbEngines/sqlText.ts
+var MAX_CHUNK_ROWS = 500;
+var chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size));
+var insertableColumns = (meta) => meta.columns.filter((col) => col.generated !== true);
+var quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`;
+var quoteMssqlIdent = (name) => `[${name.replace(/]/g, "]]")}]`;
+var quoteMysqlIdent = (name) => `\`${name.replace(/`/g, "``")}\``;
+var rowsPerChunk = (columnCount, paramLimit) => Math.max(1, Math.min(MAX_CHUNK_ROWS, Math.floor(paramLimit / Math.max(1, columnCount))));
+var updatableColumns = (meta) => insertableColumns(meta).map((col) => col.name).filter((name) => !meta.primaryKey.includes(name));
+var conflictClause = (meta) => {
+  if (meta.primaryKey.length === 0)
+    return "on conflict do nothing";
+  const target = meta.primaryKey.map(quoteIdent).join(", ");
+  const updatable = updatableColumns(meta);
+  if (updatable.length === 0)
+    return `on conflict (${target}) do nothing`;
+  const sets = updatable.map((name) => `${quoteIdent(name)} = excluded.${quoteIdent(name)}`).join(", ");
+  return `on conflict (${target}) do update set ${sets}`;
+};
+var valueGroups = (rowCount, columnCount, slot) => Array.from({ length: rowCount }, (_, rowIdx) => {
+  const slots = Array.from({ length: columnCount }, (_cell, colIdx) => slot(rowIdx * columnCount + colIdx));
+  return `(${slots.join(", ")})`;
+}).join(", ");
+var mysqlInsert = (meta, rowCount, rowAlias) => {
+  const cols = insertableColumns(meta);
+  const columnList = cols.map((col) => quoteMysqlIdent(col.name)).join(", ");
+  const groups = valueGroups(rowCount, cols.length, () => "?");
+  const updatable = updatableColumns(meta);
+  const table = quoteMysqlIdent(meta.name);
+  const [first] = cols;
+  if ((meta.primaryKey.length === 0 || updatable.length === 0) && first !== undefined)
+    return `insert into ${table} (${columnList}) values ${groups} on duplicate key update ${quoteMysqlIdent(first.name)} = ${quoteMysqlIdent(first.name)}`;
+  const incoming = (name) => rowAlias ? `new_row.${quoteMysqlIdent(name)}` : `values(${quoteMysqlIdent(name)})`;
+  const sets = updatable.map((name) => `${quoteMysqlIdent(name)} = ${incoming(name)}`).join(", ");
+  const alias = rowAlias ? " as new_row" : "";
+  return `insert into ${table} (${columnList}) values ${groups}${alias} on duplicate key update ${sets}`;
+};
+var postgresInsert = (meta, rowCount, overridingSystemValue) => {
+  const cols = insertableColumns(meta);
+  const columnList = cols.map((col) => quoteIdent(col.name)).join(", ");
+  const overriding = overridingSystemValue ? " overriding system value" : "";
+  const groups = valueGroups(rowCount, cols.length, (index) => `$${index + 1}`);
+  return `insert into ${quoteIdent(meta.name)} (${columnList})${overriding} values ${groups} ${conflictClause(meta)}`;
+};
+var sqliteInsert = (meta, rowCount) => {
+  const cols = insertableColumns(meta);
+  const columnList = cols.map((col) => quoteIdent(col.name)).join(", ");
+  const groups = valueGroups(rowCount, cols.length, () => "?");
+  return `insert into ${quoteIdent(meta.name)} (${columnList}) values ${groups} ${conflictClause(meta)}`;
+};
+var mssqlCast = (col, index) => `cast(@p${index} as ${col.sqlType ?? "nvarchar(max)"})`;
+var dependencyOrder = (names, links) => {
+  const present = new Set(names);
+  const edges = links.filter((link) => present.has(link.from) && present.has(link.to) && link.from !== link.to);
+  const indegree = new Map(names.map((name) => [name, 0]));
+  edges.forEach((link) => indegree.set(link.from, (indegree.get(link.from) ?? 0) + 1));
+  const ready = names.filter((name) => (indegree.get(name) ?? 0) === 0);
+  const ordered = [];
+  const release = (parent) => edges.filter((link) => link.to === parent).forEach((link) => {
+    const next = (indegree.get(link.from) ?? 0) - 1;
+    indegree.set(link.from, next);
+    if (next === 0)
+      ready.push(link.from);
+  });
+  const drain = () => {
+    const head = ready.shift();
+    if (head === undefined)
+      return;
+    ordered.push(head);
+    release(head);
+    drain();
+  };
+  drain();
+  names.forEach((name) => {
+    if (!ordered.includes(name))
+      ordered.push(name);
+  });
+  return ordered;
+};
+var mssqlUpsert = (meta, rowCount, qualifiedTable) => {
+  const cols = insertableColumns(meta);
+  const names = cols.map((col) => quoteMssqlIdent(col.name));
+  const rows = Array.from({ length: rowCount }, (_, rowIdx) => {
+    const slots = cols.map((col, colIdx) => mssqlCast(col, rowIdx * cols.length + colIdx));
+    return `(${slots.join(", ")})`;
+  }).join(", ");
+  const identity = cols.some((col) => col.identity === true);
+  const identityOn = identity ? `set identity_insert ${qualifiedTable} on; ` : "";
+  const identityOff = identity ? ` set identity_insert ${qualifiedTable} off;` : "";
+  if (meta.primaryKey.length === 0)
+    return `${identityOn}insert into ${qualifiedTable} (${names.join(", ")}) values ${rows};${identityOff}`;
+  const match = meta.primaryKey.map((name) => `tgt.${quoteMssqlIdent(name)} = src.${quoteMssqlIdent(name)}`).join(" and ");
+  const updatable = updatableColumns(meta);
+  const whenMatched = updatable.length === 0 ? "" : ` when matched then update set ${updatable.map((name) => `tgt.${quoteMssqlIdent(name)} = src.${quoteMssqlIdent(name)}`).join(", ")}`;
+  const sourceCols = names.map((name) => `src.${name}`).join(", ");
+  return `${identityOn}merge into ${qualifiedTable} with (holdlock) as tgt using (values ${rows}) as src (${names.join(", ")}) on ${match}${whenMatched} when not matched then insert (${names.join(", ")}) values (${sourceCols});${identityOff}`;
+};
+
+// src/cli/scripts/dbEngines/values.ts
+var INT32_MAX = 2147483647;
+var INT32_MIN = -2147483648;
+var ISO_UTC_PATTERN = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(?:Z|[+-]00:?00)$/;
+var isRecord = (value) => typeof value === "object" && value !== null;
+var isSerializedBuffer = (value) => isRecord(value) && value.type === "Buffer" && Array.isArray(value.data) && value.data.every((byte) => typeof byte === "number");
+var decodeBinary = (value) => isSerializedBuffer(value) ? Buffer.from(value.data) : undefined;
+var isStructured = (value) => Array.isArray(value) || isRecord(value) && !(value instanceof Date) && !Buffer.isBuffer(value);
+var parseJsonText = (value) => {
+  if (typeof value !== "string")
+    return value;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed;
+  } catch {
+    return value;
+  }
+};
+var quotePgArrayElement = (value) => {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (Array.isArray(value))
+    return pgArrayLiteral(value);
+  const text = isRecord(value) ? JSON.stringify(value) : String(value);
+  return `"${text.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+};
+var encodeMssqlValue = (col, value) => {
+  if (value === null || value === undefined)
+    return null;
+  const bytes = decodeBinary(value);
+  if (bytes !== undefined && !col.isJson)
+    return bytes;
+  if (isStructured(value))
+    return JSON.stringify(value);
+  if (typeof value === "number" && Number.isInteger(value) && (value > INT32_MAX || value < INT32_MIN))
+    return String(value);
+  if (col.kind === "temporal" && typeof value === "string")
+    return value.replace(/Z$/, "");
+  return value;
+};
+var encodeMysqlValue = (col, value) => {
+  if (value === null || value === undefined)
+    return null;
+  const bytes = decodeBinary(value);
+  if (bytes !== undefined && !col.isJson)
+    return bytes;
+  if (col.isJson)
+    return JSON.stringify(value);
+  if (isStructured(value))
+    return JSON.stringify(value);
+  if (col.kind === "temporal" && typeof value === "string")
+    return isoToSqlDateTime(value);
+  return value;
+};
+var encodeSqliteValue = (col, value) => {
+  if (value === null || value === undefined)
+    return null;
+  const bytes = decodeBinary(value);
+  if (bytes !== undefined && !col.isJson)
+    return new Uint8Array(bytes);
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  if (isStructured(value))
+    return JSON.stringify(value);
+  return value;
+};
+var encodeValue = (col, value) => {
+  if (value === null || value === undefined)
+    return null;
+  if (col.isJson)
+    return value;
+  const bytes = decodeBinary(value);
+  if (bytes !== undefined)
+    return bytes;
+  if (Array.isArray(value))
+    return pgArrayLiteral(value);
+  if (isStructured(value))
+    return JSON.stringify(value);
+  return value;
+};
+var isoToSqlDateTime = (value) => value.replace(ISO_UTC_PATTERN, "$1 $2");
+var pgArrayLiteral = (values) => `{${values.map(quotePgArrayElement).join(",")}}`;
+var normalizeValue = (value) => {
+  if (typeof value === "bigint")
+    return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value.toString();
+  if (value instanceof ArrayBuffer)
+    return Buffer.from(value);
+  if (value instanceof Uint8Array && !Buffer.isBuffer(value))
+    return Buffer.from(value);
+  return value;
+};
+var normalizeRow = (row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeValue(value)]));
+
+// src/cli/scripts/dbEngines/mssql.ts
+var MSSQL_PARAM_LIMIT = 2000;
+var DEFAULT_PORT = 1433;
+var UNICODE_BYTES = 2;
+var MAX_LENGTH_UNBOUNDED = -1;
+var LENGTH_TYPES = ["binary", "char", "varbinary", "varchar"];
+var UNICODE_LENGTH_TYPES = ["nchar", "nvarchar"];
+var SCALE_TYPES = ["datetime2", "datetimeoffset", "time"];
+var DECIMAL_TYPES = ["decimal", "numeric"];
+var TEMPORAL_TYPES = [
+  "date",
+  "datetime",
+  "datetime2",
+  "datetimeoffset",
+  "smalldatetime",
+  "time"
+];
+var MONEY_TYPES = ["money", "smallmoney"];
+var CLR_TYPES = ["geography", "geometry", "hierarchyid"];
+var BINARY_TYPES = ["binary", "image", "varbinary", ...CLR_TYPES];
+var SERVER_GENERATED_TYPES = ["timestamp"];
+var truthy = (value) => value !== undefined && ["1", "true", "yes"].includes(value.toLowerCase());
+var optionalValue = (value) => value === undefined || value === "" ? undefined : value;
+var mssqlColumnType = (row) => {
+  const type = row.type.toLowerCase();
+  const maxOr = (length) => row.max_length === MAX_LENGTH_UNBOUNDED ? "max" : String(length);
+  if (LENGTH_TYPES.includes(type))
+    return `${type}(${maxOr(row.max_length)})`;
+  if (UNICODE_LENGTH_TYPES.includes(type))
+    return `${type}(${maxOr(row.max_length / UNICODE_BYTES)})`;
+  if (DECIMAL_TYPES.includes(type))
+    return `${type}(${row.precision}, ${row.scale})`;
+  if (SCALE_TYPES.includes(type))
+    return `${type}(${row.scale})`;
+  return type;
+};
+var parseMssqlUrl = (url) => {
+  if (/^sqlserver:/i.test(url)) {
+    const [hostPart = "", ...pairs] = url.replace(/^sqlserver:\/\//i, "").split(";");
+    const settings = new Map(pairs.filter((pair) => pair.includes("=")).map((pair) => {
+      const [key = "", ...rest] = pair.split("=");
+      return [key.trim().toLowerCase(), rest.join("=").trim()];
+    }));
+    const [hostWithInstance = "", port] = hostPart.split(":");
+    const [server = "", instanceName] = hostWithInstance.split("\\");
+    const target2 = {
+      database: optionalValue(settings.get("database") ?? settings.get("initial catalog")),
+      encrypt: settings.has("encrypt") ? truthy(settings.get("encrypt")) : true,
+      instanceName: optionalValue(instanceName),
+      password: settings.get("password") ?? settings.get("pwd"),
+      port: port === undefined ? undefined : Number(port),
+      server,
+      trustServerCertificate: truthy(settings.get("trustservercertificate")),
+      user: settings.get("user") ?? settings.get("username") ?? settings.get("user id") ?? settings.get("uid")
+    };
+    return target2;
+  }
+  const parsed = new URL(url);
+  const params = parsed.searchParams;
+  const target = {
+    database: optionalValue(decodeURIComponent(parsed.pathname.slice(1))),
+    encrypt: params.has("encrypt") ? truthy(params.get("encrypt") ?? undefined) : true,
+    instanceName: optionalValue(params.get("instanceName") ?? undefined),
+    password: optionalValue(decodeURIComponent(parsed.password)),
+    port: parsed.port === "" ? undefined : Number(parsed.port),
+    server: parsed.hostname,
+    trustServerCertificate: truthy(params.get("trustServerCertificate") ?? undefined),
+    user: optionalValue(decodeURIComponent(parsed.username))
+  };
+  return target;
+};
+var toColumn = (row) => {
+  const type = row.type.toLowerCase();
+  const column = {
+    generated: row.is_computed || SERVER_GENERATED_TYPES.includes(type),
+    identity: row.is_identity,
+    isJson: false,
+    kind: "other",
+    name: row.name,
+    sqlType: mssqlColumnType(row)
+  };
+  if (BINARY_TYPES.includes(type))
+    column.kind = "binary";
+  if (TEMPORAL_TYPES.includes(type))
+    column.kind = "temporal";
+  return column;
+};
+var selectExpression = (col) => {
+  const name = quoteMssqlIdent(col.name);
+  const type = (col.sqlType ?? "").replace(/\(.*$/, "");
+  if (TEMPORAL_TYPES.includes(type))
+    return `convert(nvarchar(max), ${name}, 126) as ${name}`;
+  if (MONEY_TYPES.includes(type))
+    return `convert(nvarchar(max), ${name}, 2) as ${name}`;
+  if (DECIMAL_TYPES.includes(type))
+    return `cast(${name} as nvarchar(max)) as ${name}`;
+  if (CLR_TYPES.includes(type))
+    return `cast(${name} as varbinary(max)) as ${name}`;
+  return name;
+};
+var loadMssql = async () => {
+  try {
+    return await import("mssql");
+  } catch {
+    throw new Error("SQL Server support needs the optional mssql driver in this project: bun add mssql");
+  }
+};
+var openMssql = async (url) => {
+  const { ConnectionPool } = await loadMssql();
+  const target = parseMssqlUrl(url);
+  const pool = new ConnectionPool({
+    database: target.database,
+    options: {
+      encrypt: target.encrypt,
+      instanceName: target.instanceName,
+      trustServerCertificate: target.trustServerCertificate
+    },
+    password: target.password,
+    port: target.instanceName === undefined ? target.port ?? DEFAULT_PORT : target.port,
+    server: target.server,
+    user: target.user
+  });
+  await pool.connect();
+  const query = async (text, params = []) => {
+    const request = pool.request();
+    params.forEach((value, idx) => request.input(`p${idx}`, value));
+    const result = await request.query(text);
+    return result.recordset ?? [];
+  };
+  const [schemaRow] = await query("select schema_name() as name");
+  const schema = String(schemaRow?.name ?? "dbo");
+  const qualified = (name) => `${quoteMssqlIdent(schema)}.${quoteMssqlIdent(name)}`;
+  const listTables = async () => {
+    const rows = await query("select name from sys.tables where schema_id = schema_id(@p0) and is_ms_shipped = 0 order by name", [schema]);
+    return rows.map((row) => String(row.name));
+  };
+  const tableMeta = async (name) => {
+    const [columnRows, keyRows] = await Promise.all([
+      query("select c.name, type_name(c.system_type_id) as type, c.max_length, c.precision, c.scale, c.is_computed, c.is_identity from sys.columns c where c.object_id = object_id(@p0) order by c.column_id", [qualified(name)]),
+      query("select c.name from sys.indexes i join sys.index_columns ic on ic.object_id = i.object_id and ic.index_id = i.index_id join sys.columns c on c.object_id = ic.object_id and c.column_id = ic.column_id where i.is_primary_key = 1 and i.object_id = object_id(@p0) order by ic.key_ordinal", [qualified(name)])
+    ]);
+    const columns = columnRows.map((row) => {
+      const column = {
+        is_computed: row.is_computed === true,
+        is_identity: row.is_identity === true,
+        max_length: Number(row.max_length),
+        name: String(row.name),
+        precision: Number(row.precision),
+        scale: Number(row.scale),
+        type: String(row.type)
+      };
+      return toColumn(column);
+    });
+    const primaryKey = keyRows.map((row) => String(row.name));
+    const meta = { columns, name, primaryKey };
+    return meta;
+  };
+  const foreignLinks = async () => {
+    const rows = await query("select object_name(fk.parent_object_id) as child, object_name(fk.referenced_object_id) as parent from sys.foreign_keys fk where fk.schema_id = schema_id(@p0)", [schema]);
+    return rows.map((row) => ({
+      from: String(row.child),
+      to: String(row.parent)
+    }));
+  };
+  const readRows = async (meta) => {
+    const list = meta.columns.map(selectExpression).join(", ");
+    const rows = await query(`select ${list} from ${qualified(meta.name)}`);
+    return rows.map(normalizeRow);
+  };
+  const insertChunk = async (meta, rows) => {
+    const cols = insertableColumns(meta);
+    const params = rows.flatMap((row) => cols.map((col) => encodeMssqlValue(col, row[col.name])));
+    await query(mssqlUpsert(meta, rows.length, qualified(meta.name)), params);
+  };
+  const insertRows = async (meta, rows) => {
+    const size = rowsPerChunk(insertableColumns(meta).length, MSSQL_PARAM_LIMIT);
+    await chunkRows(rows, size).reduce(async (prev, part) => {
+      await prev;
+      return insertChunk(meta, part);
+    }, Promise.resolve());
+  };
+  const truncate = async (names) => {
+    if (names.length === 0)
+      return;
+    const tables = names.map(qualified);
+    const statements = [
+      ...tables.map((table) => `alter table ${table} nocheck constraint all;`),
+      ...tables.map((table) => `delete from ${table};`),
+      ...tables.map((table) => `alter table ${table} with check check constraint all;`)
+    ];
+    await query(statements.join(" "));
+  };
+  const connection = {
+    engine: "mssql",
+    foreignLinks,
+    insertRows,
+    listTables,
+    readRows,
+    tableMeta,
+    truncate,
+    afterRestore: () => Promise.resolve(),
+    close: () => pool.close()
+  };
+  return connection;
+};
+
+// src/cli/scripts/dbEngines/mysql.ts
+var {SQL } = globalThis.Bun;
+var MYSQL_PARAM_LIMIT = 65535;
+var ROW_ALIAS_MIN_VERSION = "8.0.19".split(".").map(Number);
+var NOT_FOUND = -1;
+var KINDS = {
+  binary: "binary",
+  bit: "binary",
+  blob: "binary",
+  date: "temporal",
+  datetime: "temporal",
+  json: "json",
+  longblob: "binary",
+  mediumblob: "binary",
+  time: "temporal",
+  timestamp: "temporal",
+  tinyblob: "binary",
+  varbinary: "binary"
+};
+var GENERATED_EXTRA = /\b(VIRTUAL|STORED|PERSISTENT)\b/i;
+var PUBLIC_KEY_RETRIEVAL_PARAM = "allowPublicKeyRetrieval";
+var kindOf = (dataType) => KINDS[dataType] ?? "other";
+var atLeast = (version, minimum) => {
+  const parts = (version.match(/^(\d+)\.(\d+)\.(\d+)/) ?? []).slice(1).map(Number);
+  const firstDiff = minimum.findIndex((part, idx) => (parts[idx] ?? 0) !== part);
+  return firstDiff === NOT_FOUND || (parts[firstDiff] ?? 0) > (minimum[firstDiff] ?? 0);
+};
+var connectionOptions = (url) => {
+  const parsed = new URL(url.replace(/^singlestore:/i, "mysql:"));
+  const allowPublicKeyRetrieval = parsed.searchParams.get(PUBLIC_KEY_RETRIEVAL_PARAM) === "true";
+  parsed.searchParams.delete(PUBLIC_KEY_RETRIEVAL_PARAM);
+  const options = {
+    allowPublicKeyRetrieval,
+    url: parsed.toString()
+  };
+  return options;
+};
+var openMysql = async (url) => {
+  const sql = new SQL(connectionOptions(url));
+  const [version] = await sql.unsafe("select version() as v");
+  const versionText = version?.v ?? "";
+  const singlestoreRows = await sql.unsafe(`show variables like 'memsql_version'`);
+  const mariadb = /mariadb/i.test(versionText);
+  const singlestore = singlestoreRows.length > 0;
+  const rowAlias = !mariadb && !singlestore && atLeast(versionText, ROW_ALIAS_MIN_VERSION);
+  const engineName = mariadb ? "mariadb" : "mysql";
+  const listTables = async () => {
+    const rows = await sql.unsafe(`select table_name as name from information_schema.tables where table_schema = database() and table_type = 'BASE TABLE' order by table_name`);
+    return rows.map((row) => row.name);
+  };
+  const mariadbJsonColumns = async (name) => {
+    if (!mariadb)
+      return new Set;
+    const rows = await sql.unsafe(`select check_clause as clause from information_schema.check_constraints where constraint_schema = database() and table_name = ?`, [name]);
+    return new Set(rows.flatMap((row) => [...row.clause.matchAll(/json_valid\(`([^`]+)`\)/gi)].map((match) => match[1] ?? "")));
+  };
+  const columnsFor = async (name) => {
+    const jsonText = await mariadbJsonColumns(name);
+    const rows = await sql.unsafe(`select column_name as name, data_type as data_type, extra as extra from information_schema.columns where table_schema = database() and table_name = ? order by ordinal_position`, [name]);
+    return rows.map((row) => ({
+      generated: GENERATED_EXTRA.test(row.extra ?? ""),
+      isJson: row.data_type.toLowerCase() === "json" || jsonText.has(row.name),
+      kind: kindOf(row.data_type.toLowerCase()),
+      name: row.name
+    }));
+  };
+  const primaryKeyFor = async (name) => {
+    const rows = await sql.unsafe(`select column_name as name from information_schema.key_column_usage where table_schema = database() and table_name = ? and constraint_name = 'PRIMARY' order by ordinal_position`, [name]);
+    return rows.map((row) => row.name);
+  };
+  const tableMeta = async (name) => {
+    const [columns, primaryKey] = await Promise.all([
+      columnsFor(name),
+      primaryKeyFor(name)
+    ]);
+    return { columns, name, primaryKey };
+  };
+  const foreignLinks = async () => {
+    const rows = await sql.unsafe(`select table_name as child, referenced_table_name as parent from information_schema.key_column_usage where table_schema = database() and referenced_table_name is not null`);
+    return rows.map((row) => ({ from: row.child, to: row.parent }));
+  };
+  const readRows = async (meta) => {
+    const list = meta.columns.map((col) => col.kind === "temporal" ? `cast(${quoteMysqlIdent(col.name)} as char) as ${quoteMysqlIdent(col.name)}` : quoteMysqlIdent(col.name)).join(", ");
+    const rows = await sql.unsafe(`select ${list} from ${quoteMysqlIdent(meta.name)}`);
+    return rows.map(normalizeRow);
+  };
+  const insertChunk = async (meta, rows) => {
+    const cols = insertableColumns(meta);
+    const params = rows.flatMap((row) => cols.map((col) => encodeMysqlValue(col, row[col.name])));
+    await sql.unsafe(mysqlInsert(meta, rows.length, rowAlias), params);
+  };
+  const insertRows = async (meta, rows) => {
+    const size = rowsPerChunk(insertableColumns(meta).length, MYSQL_PARAM_LIMIT);
+    await chunkRows(rows, size).reduce(async (prev, part) => {
+      await prev;
+      return insertChunk(meta, part);
+    }, Promise.resolve());
+  };
+  const truncate = async (names) => {
+    if (names.length === 0)
+      return;
+    const conn = await sql.reserve();
+    const statements = [
+      ...singlestore ? [] : ["set foreign_key_checks = 0"],
+      ...names.map((name) => `truncate table ${quoteMysqlIdent(name)}`)
+    ];
+    try {
+      await statements.reduce(async (prev, statement) => {
+        await prev;
+        await conn.unsafe(statement);
+      }, Promise.resolve());
+    } finally {
+      if (!singlestore)
+        await conn.unsafe("set foreign_key_checks = 1");
+      conn.release();
+    }
+  };
+  const connection = {
+    engine: singlestore ? "singlestore" : engineName,
+    foreignLinks,
+    insertRows,
+    listTables,
+    readRows,
+    tableMeta,
+    truncate,
+    afterRestore: () => Promise.resolve(),
+    close: () => sql.end()
+  };
+  return connection;
+};
+
+// src/cli/scripts/dbEngines/postgres.ts
+var {SQL: SQL2 } = globalThis.Bun;
+var PG_PARAM_LIMIT = 65535;
+var SCHEMA = "public";
+var JSON_DATA_TYPES = ["json", "jsonb"];
+var KINDS2 = {
+  ARRAY: "array",
+  bytea: "binary",
+  json: "json",
+  jsonb: "json"
+};
+var kindOf2 = (dataType) => KINDS2[dataType] ?? "other";
+var toColumn2 = (row) => ({
+  generated: row.is_generated === "ALWAYS",
+  identity: row.identity_generation === "ALWAYS",
+  isJson: JSON_DATA_TYPES.includes(row.data_type),
+  kind: kindOf2(row.data_type),
+  name: row.column_name,
+  sequenced: row.is_identity === "YES" || (row.column_default ?? "").startsWith("nextval(")
+});
+var connectionUrl = (url) => url.replace(/^cockroachdb:/i, "postgresql:");
+var openPostgres = async (url) => {
+  const sql = new SQL2(connectionUrl(url));
+  const [version] = await sql.unsafe("select version() as v");
+  const cockroach = /cockroachdb/i.test(version?.v ?? "");
+  const sequencedByTable = new Map;
+  const listTables = async () => {
+    const rows = await sql`select table_name from information_schema.tables where table_schema = ${SCHEMA} and table_type = ${"BASE TABLE"} order by table_name`;
+    return rows.map((row) => row.table_name);
+  };
+  const columnsFor = async (name) => {
+    const hidden = cockroach ? ` and is_hidden = 'NO'` : "";
+    const rows = await sql.unsafe(`select column_name, data_type, column_default, is_generated, is_identity, identity_generation from information_schema.columns where table_schema = $1 and table_name = $2${hidden} order by ordinal_position`, [SCHEMA, name]);
+    return rows.map(toColumn2);
+  };
+  const primaryKeyFor = async (name) => {
+    const rows = await sql.unsafe(`select a.attname as col from pg_index i join pg_attribute a on a.attrelid = i.indrelid and a.attnum = any(i.indkey) where i.indrelid = $1::regclass and i.indisprimary order by a.attnum`, [`${SCHEMA}.${quoteIdent(name)}`]);
+    return rows.map((row) => row.col);
+  };
+  const tableMeta = async (name) => {
+    const [columns, primaryKey] = await Promise.all([
+      columnsFor(name),
+      primaryKeyFor(name)
+    ]);
+    sequencedByTable.set(name, columns.filter((col) => col.sequenced).map((col) => col.name));
+    return {
+      columns: columns.map(({ generated, identity, isJson, kind, name: colName }) => ({
+        generated,
+        identity,
+        isJson,
+        kind,
+        name: colName
+      })),
+      name,
+      primaryKey
+    };
+  };
+  const foreignLinks = async () => {
+    const rows = await sql.unsafe(`select tc.table_name as child, ccu.table_name as parent from information_schema.table_constraints tc join information_schema.constraint_column_usage ccu on ccu.constraint_name = tc.constraint_name and ccu.table_schema = tc.table_schema where tc.constraint_type = 'FOREIGN KEY' and tc.table_schema = $1`, [SCHEMA]);
+    return rows.map((row) => ({ from: row.child, to: row.parent }));
+  };
+  const readRows = async (meta) => {
+    const rows = await sql.unsafe(`select * from ${quoteIdent(meta.name)}`);
+    return rows;
+  };
+  const insertChunk = async (meta, rows) => {
+    const cols = insertableColumns(meta);
+    const overriding = cols.some((col) => col.identity === true);
+    const params = rows.flatMap((row) => cols.map((col) => encodeValue(col, row[col.name])));
+    await sql.unsafe(postgresInsert(meta, rows.length, overriding), params);
+  };
+  const insertRows = async (meta, rows) => {
+    const size = rowsPerChunk(insertableColumns(meta).length, PG_PARAM_LIMIT);
+    await chunkRows(rows, size).reduce(async (prev, part) => {
+      await prev;
+      return insertChunk(meta, part);
+    }, Promise.resolve());
+  };
+  const truncate = async (names) => {
+    if (names.length === 0)
+      return;
+    const list = names.map(quoteIdent).join(", ");
+    const restart = cockroach ? "" : " restart identity";
+    await sql.unsafe(`truncate ${list}${restart} cascade`);
+  };
+  const resyncSequences = async (meta) => {
+    const sequenced = sequencedByTable.get(meta.name) ?? [];
+    await Promise.all(sequenced.map((col) => sql.unsafe(`select setval(pg_get_serial_sequence($1, $2), coalesce((select max(${quoteIdent(col)}) from ${quoteIdent(meta.name)}), 0) + 1, false)`, [`${SCHEMA}.${quoteIdent(meta.name)}`, col])));
+  };
+  const afterRestore = async (restored) => {
+    await Promise.all(restored.map(resyncSequences));
+  };
+  const connection = {
+    afterRestore,
+    engine: cockroach ? "cockroach" : "postgres",
+    foreignLinks,
+    insertRows,
+    listTables,
+    readRows,
+    tableMeta,
+    truncate,
+    close: () => sql.end()
+  };
+  return connection;
+};
+
+// src/cli/scripts/dbEngines/sqlite.ts
+import { Database } from "bun:sqlite";
+var SQLITE_PARAM_LIMIT = 32766;
+var GENERATED_HIDDEN = 2;
+var AUTH_TOKEN_ENV_KEYS = [
+  "TURSO_AUTH_TOKEN",
+  "LIBSQL_AUTH_TOKEN",
+  "DATABASE_AUTH_TOKEN"
+];
+var toBinding = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || value instanceof Uint8Array)
+    return value;
+  return String(value);
+};
+var bunSqliteExecutor = (path) => {
+  const db = new Database(path, {
+    create: false,
+    readwrite: true,
+    safeIntegers: true
+  });
+  const executor = {
+    all: (query, params) => {
+      const rows = db.query(query).all(...params.map(toBinding));
+      return Promise.resolve(rows);
+    },
+    batch: (statements) => {
+      db.transaction(() => {
+        statements.forEach((statement) => db.run(statement));
+      })();
+      return Promise.resolve();
+    },
+    close: () => {
+      db.close();
+      return Promise.resolve();
+    },
+    run: (query, params) => {
+      db.query(query).run(...params.map(toBinding));
+      return Promise.resolve();
+    }
+  };
+  return executor;
+};
+var loadLibsql = async () => {
+  try {
+    return await import("@libsql/client");
+  } catch {
+    throw new Error("Remote libSQL / Turso support needs the optional @libsql/client driver in this project: bun add @libsql/client");
+  }
+};
+var libsqlAuthToken = (url) => url.searchParams.get("authToken") ?? AUTH_TOKEN_ENV_KEYS.map((key) => process.env[key]).find((value) => typeof value === "string" && value !== "");
+var libsqlExecutor = async (url) => {
+  const { createClient } = await loadLibsql();
+  const parsed = new URL(url);
+  const authToken = libsqlAuthToken(parsed);
+  parsed.searchParams.delete("authToken");
+  const client = createClient({
+    authToken,
+    intMode: "bigint",
+    url: parsed.toString()
+  });
+  const toArgs = (params) => params.map((value) => {
+    const binding = toBinding(value);
+    return typeof binding === "boolean" ? Number(binding) : binding;
+  });
+  const executor = {
+    all: async (query, params) => {
+      const result = await client.execute({
+        args: toArgs(params),
+        sql: query
+      });
+      return result.rows.map((row) => Object.fromEntries(result.columns.map((column, idx) => [column, row[idx]])));
+    },
+    batch: async (statements) => {
+      await client.batch(statements, "write");
+    },
+    close: () => {
+      client.close();
+      return Promise.resolve();
+    },
+    run: async (query, params) => {
+      await client.execute({ args: toArgs(params), sql: query });
+    }
+  };
+  return executor;
+};
+var isInternalTable = (name) => name.startsWith("sqlite_") || name.startsWith("libsql_");
+var openSqlite = (exec, engine) => {
+  const listTables = async () => {
+    const rows = await exec.all(`select name from sqlite_master where type = 'table' order by name`, []);
+    return rows.map((row) => String(row.name)).filter((name) => !isInternalTable(name));
+  };
+  const tableMeta = async (name) => {
+    const rows = await exec.all("select name, type, pk, hidden from pragma_table_xinfo(?) order by cid", [name]);
+    const columnRows = rows.map((row) => {
+      const column = {
+        hidden: row.hidden,
+        name: String(row.name),
+        pk: row.pk,
+        type: typeof row.type === "string" ? row.type : null
+      };
+      return column;
+    });
+    const primaryKey = columnRows.filter((row) => Number(row.pk) > 0).sort((left, right) => Number(left.pk) - Number(right.pk)).map((row) => row.name);
+    const columns = columnRows.map((row) => {
+      const column = {
+        generated: Number(row.hidden) >= GENERATED_HIDDEN,
+        isJson: false,
+        kind: /blob/i.test(row.type ?? "") ? "binary" : "other",
+        name: row.name
+      };
+      return column;
+    });
+    const meta = { columns, name, primaryKey };
+    return meta;
+  };
+  const foreignLinks = async () => {
+    const rows = await exec.all(`select m.name as child, f."table" as parent from sqlite_master m join pragma_foreign_key_list(m.name) f where m.type = 'table'`, []);
+    return rows.map((row) => ({
+      from: String(row.child),
+      to: String(row.parent)
+    }));
+  };
+  const readRows = async (meta) => {
+    const rows = await exec.all(`select * from ${quoteIdent(meta.name)}`, []);
+    return rows.map(normalizeRow);
+  };
+  const insertChunk = async (meta, rows) => {
+    const cols = insertableColumns(meta);
+    const params = rows.flatMap((row) => cols.map((col) => encodeSqliteValue(col, row[col.name])));
+    await exec.run(sqliteInsert(meta, rows.length), params);
+  };
+  const insertRows = async (meta, rows) => {
+    const size = rowsPerChunk(insertableColumns(meta).length, SQLITE_PARAM_LIMIT);
+    await chunkRows(rows, size).reduce(async (prev, part) => {
+      await prev;
+      return insertChunk(meta, part);
+    }, Promise.resolve());
+  };
+  const truncate = async (names) => {
+    if (names.length === 0)
+      return;
+    const sequence = await exec.all(`select name from sqlite_master where type = 'table' and name = 'sqlite_sequence'`, []);
+    const quotedNames = names.map((name) => `'${name.replace(/'/g, "''")}'`).join(", ");
+    await exec.batch([
+      "pragma defer_foreign_keys = on",
+      ...names.map((name) => `delete from ${quoteIdent(name)}`),
+      ...sequence.length > 0 ? [`delete from sqlite_sequence where name in (${quotedNames})`] : []
+    ]);
+  };
+  const connection = {
+    close: exec.close,
+    engine,
+    foreignLinks,
+    insertRows,
+    listTables,
+    readRows,
+    tableMeta,
+    truncate,
+    afterRestore: () => Promise.resolve()
+  };
+  return connection;
+};
+
+// src/cli/scripts/dbEngines/open.ts
+var openConnection = async (target, cwd) => {
+  if (target.family === "postgres")
+    return openPostgres(target.url);
+  if (target.family === "mysql")
+    return openMysql(target.url);
+  if (target.family === "mssql")
+    return openMssql(target.url);
+  if (target.family === "libsql")
+    return openSqlite(await libsqlExecutor(target.url), "libsql");
+  return openSqlite(bunSqliteExecutor(sqlitePath(target.url, cwd)), "sqlite");
+};
+
+// src/cli/scripts/db.ts
+var BACKUP_FORMAT_VERSION = 1;
+var URL_ENV_KEYS = [
+  "DATABASE_URL",
+  "POSTGRES_URL",
+  "DATABASE_URL_UNPOOLED",
+  "MYSQL_URL",
+  "TURSO_DATABASE_URL",
+  "LIBSQL_URL",
+  "MSSQL_URL"
+];
+var TEXT_JSON_ENGINES = ["libsql", "mssql", "sqlite"];
+var SEED_CANDIDATES = ["db/seed.ts", "src/db/seed.ts", "seed.ts"];
+var VALUE_FLAGS = ["--out", "--url", "--only", "--exclude"];
+var paint = (text, color) => `${color}${text}${colors.reset}`;
+var findUrl = (explicit) => explicit ?? URL_ENV_KEYS.map((key) => env[key]).find((value) => typeof value === "string" && value !== "");
+var resolveUrl = (explicit) => {
+  const found = findUrl(explicit);
+  if (found === undefined || found === "")
+    throw new Error(`No database URL found. Set ${URL_ENV_KEYS.join(" or ")}, or pass --url <url>.`);
+  return found;
+};
+var resolveTarget = (url) => detectTarget(url, readOrmDialect(process.cwd()));
+var keepTable = (name, options) => (options.only.length === 0 || options.only.includes(name)) && !options.exclude.includes(name);
+var withConnection = async (target, work) => {
+  const conn = await openConnection(target, process.cwd());
+  try {
+    return await work(conn);
+  } finally {
+    await conn.close();
+  }
+};
+var dumpTables = async (conn, options) => {
+  const chosen = (await conn.listTables()).filter((name) => keepTable(name, options));
+  const dumps = await Promise.all(chosen.map(async (name) => {
+    const rows = await conn.readRows(await conn.tableMeta(name));
+    return [name, rows];
+  }));
+  const tables = Object.fromEntries(dumps);
+  return { chosen, engine: conn.engine, tables };
+};
+var runBackup = async (options) => {
+  const { chosen, engine, tables } = await withConnection(resolveTarget(options.url), (conn) => dumpTables(conn, options));
+  const stamp = new Date().toISOString();
+  const payload = engine === "postgres" ? { at: stamp, tables, v: BACKUP_FORMAT_VERSION } : { at: stamp, engine, tables, v: BACKUP_FORMAT_VERSION };
+  const dir = options.out ?? join2(process.cwd(), "backups");
+  mkdirSync(dir, { recursive: true });
+  const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
+  const file = join2(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
+  writeFileSync(file, json);
+  writeFileSync(join2(dir, "latest.json"), json);
+  const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
+  console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
+  console.log(paint(`  ${engine}: ${chosen.length} tables, ${total} rows`, colors.dim));
+};
+var parseJsonColumns = (meta, row) => {
+  const parsed = { ...row };
+  meta.columns.filter((col) => col.isJson).forEach((col) => {
+    parsed[col.name] = parseJsonText(row[col.name]);
+  });
+  return parsed;
+};
+var confirmTruncate = (count, options) => !options.truncate || options.yes || prompt(paint(`\u26A0 TRUNCATE ${count} tables before restore? type "yes": `, colors.yellow)) === "yes";
+var restoreInto = async (conn, payload, options) => {
+  const names = Object.keys(payload.tables).filter((name) => keepTable(name, options));
+  const existing = new Set(await conn.listTables());
+  const missing = names.filter((name) => !existing.has(name));
+  if (missing.length > 0)
+    throw new Error(`The target ${conn.engine} database has no table ${missing.join(", ")}. Create the schema first (e.g. drizzle-kit push / prisma migrate deploy) or pass --exclude ${missing.join(",")}.`);
+  const source = payload.engine ?? "postgres";
+  if (source !== conn.engine)
+    console.log(paint(`  restoring a ${source} backup into ${conn.engine}; values are re-encoded per column`, colors.dim));
+  const order = dependencyOrder(names, await conn.foreignLinks());
+  const metas = await Promise.all(order.map((name) => conn.tableMeta(name)));
+  if (!confirmTruncate(order.length, options)) {
+    console.log(paint("aborted", colors.yellow));
+    return;
+  }
+  if (options.truncate)
+    await conn.truncate([...order].reverse());
+  const jsonAsText = TEXT_JSON_ENGINES.includes(source);
+  await metas.reduce(async (prev, meta) => {
+    await prev;
+    const rows = payload.tables[meta.name] ?? [];
+    return conn.insertRows(meta, jsonAsText ? rows.map((row) => parseJsonColumns(meta, row)) : rows);
+  }, Promise.resolve());
+  await conn.afterRestore(metas.filter((meta) => (payload.tables[meta.name]?.length ?? 0) > 0));
+  return order;
+};
+var runRestore = async (file, options) => {
+  if (!existsSync2(file))
+    throw new Error(`Backup not found: ${file}`);
+  const payload = JSON.parse(readFileSync2(file, "utf-8"));
+  const order = await withConnection(resolveTarget(options.url), (conn) => restoreInto(conn, payload, options));
+  if (order === undefined)
+    return;
+  const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
+  console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
+};
+var seedEnv = (explicitUrl) => {
+  const url = findUrl(explicitUrl);
+  if (url === undefined || url === "")
+    return { ...process.env };
+  return {
+    ...process.env,
+    ABSOLUTE_DB_ENGINE: resolveTarget(url).family,
+    DATABASE_URL: url
+  };
+};
+var runSeed = async (entry, url) => {
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync2(join2(process.cwd(), candidate)));
+  if (target === undefined)
+    throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
+  console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
+  const proc = spawn(["bun", "run", target], {
+    env: seedEnv(url),
+    stderr: "inherit",
+    stdin: "inherit",
+    stdout: "inherit"
+  });
+  const code = await proc.exited;
+  if (code !== 0)
+    throw new Error(`Seed failed (exit ${code}).`);
+};
+var flagValue = (rest, flag) => {
+  const idx = rest.indexOf(flag);
+  return idx === UNFOUND_INDEX ? undefined : rest[idx + 1];
+};
+var listValue = (rest, flag) => (flagValue(rest, flag) ?? "").split(",").map((part) => part.trim()).filter((part) => part !== "");
+var parseOptions = (rest) => ({
+  exclude: listValue(rest, "--exclude"),
+  only: listValue(rest, "--only"),
+  out: flagValue(rest, "--out"),
+  truncate: rest.includes("--truncate"),
+  url: resolveUrl(flagValue(rest, "--url")),
+  yes: rest.includes("--yes") || rest.includes("-y")
+});
+var positionalArgs = (rest) => rest.filter((arg, idx) => !arg.startsWith("-") && !VALUE_FLAGS.includes(rest[idx - 1] ?? ""));
+var usage = () => {
+  console.error("Usage: absolute db <backup|restore|seed> [options]");
+  console.error("  backup  [--out <dir>] [--only a,b] [--exclude a,b] [--url <url>]   Dump tables \u2192 JSON (+ latest.json)");
+  console.error("  restore [file] [--truncate] [--only a,b] [--exclude a,b] [-y]      Idempotent upsert by primary key");
+  console.error("  seed    [file] [--url <url>]                                       Run the project\u2019s seed script");
+  console.error("Engines (picked from the URL scheme): PostgreSQL + CockroachDB (postgres://), MySQL, MariaDB + SingleStore (mysql://, mariadb://, singlestore://),");
+  console.error("  SQLite + local libSQL files (file:, sqlite:, *.db), remote libSQL/Turso (libsql://, https://; needs @libsql/client),");
+  console.error("  SQL Server (sqlserver://, mssql://; needs mssql). MongoDB and Gel are refused.");
+  process.exit(1);
+};
+var runDb = async (args) => {
+  const [sub, ...rest] = args;
+  if (sub === "backup") {
+    await runBackup(parseOptions(rest));
+    return;
+  }
+  if (sub === "restore") {
+    const file = positionalArgs(rest)[0] ?? join2(process.cwd(), "backups", "latest.json");
+    await runRestore(file, parseOptions(rest));
+    return;
+  }
+  if (sub === "seed") {
+    await runSeed(positionalArgs(rest)[0], flagValue(rest, "--url"));
+    return;
+  }
+  usage();
+};
+export {
+  chunkRows,
+  conflictClause,
+  dependencyOrder,
+  encodeValue,
+  quoteIdent,
+  runDb
+};