alinea 1.7.0 → 2.0.0-preview.0

package/dist/chunks/chunk-X47OVDF3.js

@@ -0,0 +1,1974 @@
+import {
+  BatchQuery,
+  Builder,
+  Column,
+  Functions,
+  JsonColumn,
+  and,
+  asc,
+  boolean,
+  column,
+  columnConfig,
+  eq,
+  formatColumn,
+  gt,
+  integer,
+  isNotNull,
+  isNull,
+  like,
+  not,
+  oid,
+  or,
+  primaryKeyColumns,
+  table,
+  text,
+  when
+} from "./chunk-G6E35DMJ.js";
+import {
+  Sql,
+  getCreate,
+  getData,
+  getDrop,
+  getQuery,
+  getResolver,
+  getSelection,
+  getSql,
+  getTable,
+  hasQuery,
+  hasSelection,
+  input,
+  internalResolver,
+  sql
+} from "./chunk-NWQXN4SB.js";
+import {
+  __export
+} from "./chunk-CQ52GEHY.js";
+
+// node_modules/rado/dist/driver.js
+var driver_exports = {};
+__export(driver_exports, {
+  "@electric-sql/pglite": () => connect8,
+  "@libsql/client": () => connect4,
+  "@neondatabase/serverless": () => connect7,
+  "@vercel/postgres": () => connect7,
+  "better-sqlite3": () => connect,
+  "bun:sqlite": () => connect2,
+  d1: () => connect3,
+  mysql2: () => connect5,
+  "node:sqlite": () => connect6,
+  pg: () => connect7,
+  "sql.js": () => connect9
+});
+
+// node_modules/rado/dist/universal/functions.js
+var insertId = sql.universal({
+  sqlite: Functions.last_insert_rowid(),
+  postgres: Functions.lastval(),
+  mysql: Functions.last_insert_id()
+}).mapWith(Number);
+function concat(...slices) {
+  return sql.universal({
+    mysql: Functions.concat(...slices),
+    default: sql.join(
+      slices.map((slice) => input(slice)),
+      sql` || `
+    )
+  });
+}
+
+// node_modules/rado/dist/universal/transactions.js
+function txGenerator(create) {
+  function run(tx) {
+    const iter = create(tx);
+    const next = (inner) => {
+      if (inner instanceof Promise)
+        return inner.then(iter.next.bind(iter)).catch(iter.throw.bind(iter)).then(handle);
+      try {
+        return handle(iter.next(inner));
+      } catch (err) {
+        return handle(iter.throw(err));
+      }
+    };
+    const handle = ({ done, value }) => {
+      if (done) return value;
+      return next(typeof value === "function" ? tx.transaction(value) : value);
+    };
+    return next();
+  }
+  return Object.assign(run, {
+    *[Symbol.iterator]() {
+      return yield run;
+    }
+  });
+}
+
+// node_modules/rado/dist/core/expr/Aggregate.js
+function count(input2) {
+  return Functions.count(input2 ?? sql`*`).mapWith(Number);
+}
+
+// node_modules/rado/dist/core/Resolver.js
+var Resolver = class {
+  #driver;
+  #dialect;
+  constructor(driver, dialect) {
+    this.#driver = driver;
+    this.#dialect = dialect;
+  }
+  toSQL(query) {
+    const emitter = this.#dialect.emit(query);
+    return { sql: emitter.sql, params: emitter.bind() };
+  }
+  prepare(query, name) {
+    const isSelection = hasSelection(query);
+    const mapRow = isSelection ? getSelection(query).mapRow : void 0;
+    const emitter = this.#dialect.emit(query);
+    const stmt = this.#driver.prepare(emitter.sql, {
+      isSelection,
+      name
+    });
+    return new PreparedStatement(emitter, stmt, mapRow, this.#driver);
+  }
+  batch(queries) {
+    return new Batch(
+      this.#driver,
+      queries.map((query) => {
+        const isSelection = hasSelection(query);
+        const mapRow = isSelection ? getSelection(query).mapRow : void 0;
+        const emitter = this.#dialect.emit(query);
+        return { sql: emitter.sql, params: emitter.bind(), isSelection, mapRow };
+      })
+    );
+  }
+};
+var Batch = class {
+  #driver;
+  #queries;
+  constructor(driver, queries) {
+    this.#driver = driver;
+    this.#queries = queries;
+  }
+  #transform = (results) => {
+    const ctx = {
+      values: void 0,
+      index: 0,
+      specs: this.#driver
+    };
+    for (let i = 0; i < this.#queries.length; i++) {
+      const { mapRow } = this.#queries[i];
+      if (!mapRow) continue;
+      const rows = results[i];
+      for (let j = 0; j < results[i].length; j++) {
+        ctx.values = rows[j];
+        ctx.index = 0;
+        rows[j] = mapRow(ctx);
+      }
+    }
+    return results;
+  };
+  execute() {
+    const results = this.#driver.batch(this.#queries);
+    if (results instanceof Promise) return results.then(this.#transform);
+    return this.#transform(results);
+  }
+};
+var PreparedStatement = class {
+  #emitter;
+  #stmt;
+  #mapRow;
+  #specs;
+  constructor(emitter, stmt, mapRow, specs) {
+    this.#emitter = emitter;
+    this.#stmt = stmt;
+    this.#mapRow = mapRow;
+    this.#specs = specs;
+  }
+  #transform = (rows) => {
+    if (!this.#mapRow) return rows;
+    const ctx = {
+      values: void 0,
+      index: 0,
+      specs: this.#specs
+    };
+    for (let i = 0; i < rows.length; i++) {
+      ctx.values = rows[i];
+      ctx.index = 0;
+      rows[i] = this.#mapRow(ctx);
+    }
+    return rows;
+  };
+  all(inputs) {
+    const rows = this.#stmt.values(this.#emitter.bind(inputs));
+    if (rows instanceof Promise) return rows.then(this.#transform);
+    return this.#transform(rows);
+  }
+  get(inputs) {
+    const rows = this.all(inputs);
+    if (rows instanceof Promise) return rows.then((rows2) => rows2[0]);
+    return rows[0];
+  }
+  run(inputs) {
+    return this.#stmt.run(this.#emitter.bind(inputs));
+  }
+  async execute(inputs) {
+    return this.all(inputs);
+  }
+  free() {
+    this.#stmt.free();
+  }
+};
+
+// node_modules/rado/dist/core/Database.js
+var Database = class extends Builder {
+  driver;
+  dialect;
+  diff;
+  [internalResolver];
+  constructor(driver, dialect, diff) {
+    const resolver = new Resolver(driver, dialect);
+    super({ resolver });
+    this[internalResolver] = resolver;
+    this.driver = driver;
+    this.dialect = dialect;
+    this.diff = diff;
+  }
+  close() {
+    return this.driver.close();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  async [Symbol.asyncDispose]() {
+    return this.close();
+  }
+  create(...createables) {
+    return new BatchQuery(getResolver(this), createables.flatMap(getCreate));
+  }
+  drop(...droppables) {
+    return new BatchQuery(getResolver(this), droppables.flatMap(getDrop));
+  }
+  run(input2) {
+    const sql2 = this.dialect.inline(input2);
+    return this.driver.exec(sql2);
+  }
+  get(input2) {
+    const emitter = this.dialect.emit(input2);
+    return this.driver.prepare(emitter.sql).get(emitter.bind());
+  }
+  all(input2) {
+    const emitter = this.dialect.emit(input2);
+    return this.driver.prepare(emitter.sql).all(emitter.bind());
+  }
+  migrate(...tables) {
+    if (this.dialect.runtime === "mysql" && tables.length > 1) {
+      const run = async () => {
+        for (const table2 of tables) await this.migrate(table2);
+      };
+      return run();
+    }
+    const computeDiff = this.diff;
+    return this.transaction(
+      txGenerator(function* (tx) {
+        for (const table2 of tables) {
+          const diff = yield* computeDiff(table2);
+          if (diff.length > 0) yield* tx.batch(diff.map(sql.unsafe));
+        }
+      })
+    );
+  }
+  batch(queries) {
+    return new BatchQuery(getResolver(this), queries);
+  }
+  execute(input2) {
+    const inner = getSql(input2);
+    const emitter = this.dialect.emit(inner.inlineValues());
+    if (emitter.hasParams) throw new Error("Query has parameters");
+    return this.driver.exec(emitter.sql);
+  }
+  refreshMaterializedView(view) {
+    return this.execute(sql`refresh materialized view ${view}`);
+  }
+  transaction(run, options = {}) {
+    return this.driver.transaction(
+      (inner) => {
+        const tx = new Transaction(inner, this.dialect, this.diff);
+        return run(tx);
+      },
+      { async: run.constructor.name === "AsyncFunction", ...options }
+    );
+  }
+  $count(source, condition) {
+    return this.select(count()).from(source).where(condition).$first();
+  }
+};
+var Rollback = class extends Error {
+  constructor(data) {
+    super("Rollback");
+    this.data = data;
+  }
+  data;
+};
+var Transaction = class extends Database {
+  rollback(data) {
+    throw new Rollback(data);
+  }
+};
+var SyncDatabase = class extends Database {
+};
+var AsyncDatabase = class extends Database {
+};
+
+// node_modules/rado/dist/sqlite/columns.js
+function boolean2(name) {
+  return new Column({
+    name,
+    type: column.integer(),
+    mapFromDriverValue(value) {
+      return value === 1;
+    },
+    mapToDriverValue(value) {
+      return value ? 1 : 0;
+    }
+  });
+}
+function integer2(...args) {
+  const { name, options } = columnConfig(args);
+  if (options?.mode === "timestamp" || options?.mode === "timestamp_ms") {
+    const scale = options.mode === "timestamp" ? 1e3 : 1;
+    return new Column({
+      name,
+      type: column.integer(),
+      mapFromDriverValue(value) {
+        if (value === null) return null;
+        return new Date(value * scale);
+      },
+      mapToDriverValue(value) {
+        return Math.floor(value.getTime() / scale);
+      }
+    });
+  }
+  if (options?.mode === "boolean") return boolean2();
+  return new Column({ name, type: column.integer() });
+}
+function text2(...args) {
+  const { name, options } = columnConfig(args);
+  if (options?.mode === "json")
+    return new JsonColumn({
+      name,
+      type: column.text(options?.length),
+      mapToDriverValue(value) {
+        return JSON.stringify(value);
+      },
+      mapFromDriverValue(value) {
+        return JSON.parse(value);
+      }
+    });
+  return new Column({ name, type: column.text(options?.length) });
+}
+
+// node_modules/rado/dist/core/Dialect.js
+var Dialect = class {
+  runtime;
+  #createEmitter;
+  constructor(runtime, createEmitter) {
+    this.runtime = runtime;
+    this.#createEmitter = createEmitter;
+  }
+  emit = (input2) => {
+    const sql2 = hasQuery(input2) ? getQuery(input2) : getSql(input2);
+    const emitter = new this.#createEmitter(this.runtime);
+    sql2.emit(emitter);
+    return emitter;
+  };
+  inline = (input2) => {
+    const sql2 = hasQuery(input2) ? getQuery(input2) : getSql(input2);
+    const emitter = new this.#createEmitter(this.runtime);
+    sql2.inlineValues().emit(emitter);
+    return emitter.sql;
+  };
+};
+
+// node_modules/rado/dist/core/Param.js
+var NamedParam = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var ValueParam = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+
+// node_modules/rado/dist/core/Emitter.js
+var Emitter = class {
+  #runtime;
+  sql = "";
+  params = [];
+  constructor(runtime) {
+    this.#runtime = runtime;
+  }
+  get hasParams() {
+    return this.params.length > 0;
+  }
+  bind(inputs) {
+    return this.params.map((param) => {
+      if (param instanceof ValueParam) return this.processValue(param.value);
+      if (inputs && param.name in inputs)
+        return this.processValue(inputs[param.name]);
+      throw new Error(`Missing input for named parameter: ${param.name}`);
+    });
+  }
+  processValue(value) {
+    return value;
+  }
+  emitIdentifierOrSelf(value) {
+    if (value === Sql.SELF_TARGET) {
+      if (!this.#selfName) throw new Error("Self target not defined");
+      this.emitIdentifier(this.#selfName);
+    } else {
+      this.emitIdentifier(value);
+    }
+  }
+  emitUnsafe(value) {
+    this.sql += value;
+  }
+  #selfName;
+  emitSelf(inner, name) {
+    this.#selfName = name;
+    inner.emit(this);
+    this.#selfName = void 0;
+  }
+  #inlineFields = false;
+  inlineFields(inner, withTableName) {
+    const previous = this.#inlineFields;
+    this.#inlineFields = !withTableName;
+    inner.emit(this);
+    this.#inlineFields = previous;
+  }
+  #inlineValues = false;
+  inlineValues(inner) {
+    const previous = this.#inlineValues;
+    this.#inlineValues = true;
+    inner.emit(this);
+    this.#inlineValues = previous;
+  }
+  emitField({ targetName, fieldName }) {
+    if (this.#inlineFields) return this.emitIdentifier(fieldName);
+    this.emitIdentifierOrSelf(targetName);
+    this.emitUnsafe(".");
+    this.emitIdentifier(fieldName);
+  }
+  emitValueOrInline(value) {
+    if (this.#inlineValues) this.emitInline(value);
+    else this.emitValue(value);
+  }
+  emitUniversal(runtimes) {
+    const sql2 = runtimes[this.#runtime] ?? runtimes.default;
+    if (!sql2) throw new Error("Unsupported runtime");
+    getSql(sql2).emit(this);
+  }
+};
+
+// node_modules/rado/dist/sqlite/dialect.js
+var DOUBLE_QUOTE = '"';
+var ESCAPE_DOUBLE_QUOTE = '""';
+var MATCH_DOUBLE_QUOTE = /"/g;
+var SINGLE_QUOTE = "'";
+var ESCAPE_SINGLE_QUOTE = "''";
+var MATCH_SINGLE_QUOTE = /'/g;
+var sqliteDialect = new Dialect(
+  "sqlite",
+  class extends Emitter {
+    processValue(value) {
+      return typeof value === "boolean" ? value ? 1 : 0 : value;
+    }
+    emitValue(value) {
+      this.params.push(new ValueParam(value));
+      this.sql += "?";
+    }
+    emitPlaceholder(name) {
+      this.params.push(new NamedParam(name));
+      this.sql += "?";
+    }
+    emitJsonPath({ target, asSql, segments }) {
+      target.emit(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map(
+          (p) => typeof p === "number" ? `[${p}]` : `.${JSON.stringify(p)}`
+        ).join("")}`
+      );
+    }
+    emitInline(value) {
+      if (value === null || value === void 0) return this.sql += "null";
+      if (typeof value === "number") return this.sql += value;
+      if (typeof value === "string")
+        return this.sql += this.quoteString(value);
+      if (typeof value === "boolean") return this.sql += value ? "1" : "0";
+      this.sql += `json(${this.quoteString(JSON.stringify(value))})`;
+    }
+    emitIdentifier(identifier) {
+      this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
+    }
+    quoteString(input2) {
+      return SINGLE_QUOTE + input2.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
+    }
+  }
+);
+
+// node_modules/rado/dist/sqlite/diff.js
+var TableInfo = table("TableInfo", {
+  cid: integer2().notNull(),
+  name: text2().notNull(),
+  type: text2().notNull(),
+  notnull: boolean2().notNull(),
+  dflt_value: text2(),
+  pk: integer2().notNull()
+});
+var SqliteMaster = table("SqliteMaster", {
+  type: text2().notNull(),
+  name: text2().notNull(),
+  tbl_name: text2().notNull(),
+  rootpage: integer2().notNull(),
+  sql: text2().notNull()
+});
+var inline = (sql2) => sqliteDialect.inline(sql2);
+var sqliteDiff = (targetTable) => {
+  return txGenerator(function* (tx) {
+    const tableApi = getTable(targetTable);
+    const columnInfo = yield* tx.select(TableInfo).from(sql`pragma_table_info(${sql.inline(tableApi.name)}) as "TableInfo"`);
+    if (columnInfo.length === 0) return tableApi.create().map(inline);
+    const indexInfo = yield* tx.select(SqliteMaster).from(sql`sqlite_master as "SqliteMaster"`).where(
+      eq(SqliteMaster.tbl_name, tableApi.name),
+      eq(SqliteMaster.type, "index")
+    );
+    const hasSinglePrimaryKey = columnInfo.reduce((acc, column2) => acc + column2.pk, 0) === 1;
+    const localColumns = new Map(
+      columnInfo.map((column2) => {
+        return [
+          column2.name,
+          inline(
+            formatColumn({
+              type: sql.unsafe(column2.type.toLowerCase()),
+              notNull: column2.notnull,
+              primary: hasSinglePrimaryKey && column2.pk === 1,
+              defaultValue: column2.dflt_value !== null ? sql.unsafe(column2.dflt_value) : void 0
+            })
+          )
+        ];
+      })
+    );
+    const schemaColumns = new Map(
+      Object.entries(tableApi.columns).map(([name, column2]) => {
+        const columnApi = getData(column2);
+        return [columnApi.name ?? name, inline(formatColumn(columnApi))];
+      })
+    );
+    const localIndexes = new Map(
+      indexInfo.filter((index) => !index.name.startsWith("sqlite_autoindex_")).map((index) => [index.name, index.sql])
+    );
+    const schemaIndexes = new Map(
+      Object.entries(tableApi.indexes()).map(([name, index]) => {
+        const indexApi = getData(index);
+        return [name, inline(indexApi.toSql(tableApi.name, name, false))];
+      })
+    );
+    const stmts = [];
+    const columnNames = /* @__PURE__ */ new Set([
+      ...localColumns.keys(),
+      ...schemaColumns.keys()
+    ]);
+    for (const columnName of columnNames) {
+      const localInstruction = localColumns.get(columnName);
+      const schemaInstruction = schemaColumns.get(columnName);
+      if (!schemaInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable: sql.identifier(tableApi.name),
+            dropColumn: sql.identifier(columnName)
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable: sql.identifier(tableApi.name),
+            addColumn: [
+              sql.identifier(columnName),
+              sql.unsafe(schemaInstruction)
+            ]
+          })
+        );
+      } else if (localInstruction !== schemaInstruction) {
+        return recreate();
+      }
+    }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...localIndexes.keys(),
+      ...schemaIndexes.keys()
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = localIndexes.get(indexName);
+      const schemaInstruction = schemaIndexes.get(indexName);
+      const dropLocal = sql.query({
+        dropIndex: sql.identifier(indexName)
+      });
+      if (!schemaInstruction) {
+        stmts.unshift(dropLocal);
+      } else if (schemaInstruction && !localInstruction) {
+        stmts.push(sql.unsafe(schemaInstruction));
+      } else if (schemaInstruction && localInstruction !== schemaInstruction) {
+        stmts.unshift(dropLocal);
+        stmts.push(sql.unsafe(schemaInstruction));
+      }
+    }
+    try {
+      yield* txGenerator(function* (sp) {
+        yield* sp.batch(stmts);
+        const [tableInfo] = yield* sp.select(SqliteMaster.sql).from(sql`sqlite_master as "SqliteMaster"`).where(
+          eq(SqliteMaster.tbl_name, tableApi.name),
+          eq(SqliteMaster.type, "table")
+        );
+        sp.rollback(tableInfo);
+      });
+    } catch (err) {
+      if (!(err instanceof Rollback)) throw err;
+      const localInstruction = err.data;
+      const schemaInstruction = inline(tableApi.createTable());
+      const stripStmt = (q) => q.slice("create table ".length);
+      if (stripStmt(localInstruction) !== stripStmt(schemaInstruction)) {
+        return recreate();
+      }
+    }
+    return stmts.map(inline);
+    function recreate() {
+      const tempName = `new_${tableApi.name}`;
+      const tempTable = table(tempName, tableApi.columns);
+      const missingColumns = new Set(
+        Array.from(columnNames).filter((name) => !localColumns.has(name))
+      );
+      const selection = Object.fromEntries(
+        Object.entries(tableApi.columns).map(([name, column2]) => {
+          const columnApi = getData(column2);
+          const key = columnApi.name ?? name;
+          if (missingColumns.has(key))
+            return [name, columnApi.defaultValue ?? sql`null`];
+          return [name, targetTable[name]];
+        })
+      );
+      return [
+        // Create a new temporary table with the new definition
+        tableApi.createTable(tempName),
+        // Copy the data from the old table to the new table
+        getQuery(
+          tx.insert(tempTable).select(tx.select(selection).from(targetTable))
+        ),
+        // Drop the old table
+        sql.query({ dropTable: sql.identifier(tableApi.name) }),
+        // Rename the temporary table to the old table name
+        sql.query({
+          alterTable: sql.identifier(tempName),
+          renameTo: sql.identifier(tableApi.name)
+        }),
+        // Create missing indexes
+        ...tableApi.createIndexes()
+      ].map(inline);
+    }
+  });
+};
+
+// node_modules/rado/dist/sqlite/transactions.js
+var locks = /* @__PURE__ */ new WeakMap();
+function execTransaction(driver, depth, wrap, run, options) {
+  const needsLock = options.async;
+  const behavior = options.behavior ?? "deferred";
+  if (!needsLock) return transact();
+  let trigger;
+  const lock = new Promise((resolve) => trigger = resolve);
+  const current = Promise.resolve(locks.get(driver));
+  locks.set(driver, lock);
+  return current.then(transact).finally(trigger);
+  function transact() {
+    try {
+      driver.exec(depth > 0 ? `savepoint d${depth}` : `begin ${behavior}`);
+      const result = run(wrap(depth + 1));
+      if (result instanceof Promise) return result.then(release, rollback);
+      return release(result);
+    } catch (error) {
+      return rollback(error);
+    }
+  }
+  function release(result) {
+    driver.exec(depth > 0 ? `release d${depth}` : "commit");
+    return result;
+  }
+  function rollback(error) {
+    driver.exec(depth > 0 ? `rollback to d${depth}` : "rollback");
+    throw error;
+  }
+}
+
+// node_modules/rado/dist/driver/better-sqlite3.js
+var PreparedStatement2 = class {
+  constructor(stmt, isSelection) {
+    this.stmt = stmt;
+    this.isSelection = isSelection;
+  }
+  stmt;
+  isSelection;
+  all(params) {
+    return this.stmt.all(...params);
+  }
+  run(params) {
+    return this.stmt.run(...params);
+  }
+  get(params) {
+    return this.stmt.get(...params);
+  }
+  values(params) {
+    if (this.isSelection)
+      return this.stmt.raw(true).all(...params);
+    this.stmt.run(...params);
+    return [];
+  }
+  free() {
+  }
+};
+var BetterSqlite3Driver = class _BetterSqlite3Driver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = false;
+  supportsTransactions = true;
+  exec(query) {
+    this.client.exec(query);
+  }
+  close() {
+    this.client.close();
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement2(
+      this.client.prepare(sql2),
+      options?.isSelection ?? false
+    );
+  }
+  batch(queries) {
+    return this.transaction(
+      (tx) => queries.map(
+        ({ sql: sql2, params, isSelection }) => tx.prepare(sql2, { isSelection }).values(params)
+      ),
+      {}
+    );
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _BetterSqlite3Driver(this.client, depth),
+      run,
+      options
+    );
+  }
+};
+function connect(db) {
+  return new SyncDatabase(
+    new BetterSqlite3Driver(db),
+    sqliteDialect,
+    sqliteDiff
+  );
+}
+
+// node_modules/rado/dist/driver/bun-sqlite.js
+var PreparedStatement3 = class {
+  constructor(stmt, isSelection) {
+    this.stmt = stmt;
+    this.isSelection = isSelection;
+  }
+  stmt;
+  isSelection;
+  all(params) {
+    return this.stmt.all(...params);
+  }
+  run(params) {
+    return this.stmt.run(...params);
+  }
+  get(params) {
+    return this.stmt.get(...params);
+  }
+  values(params) {
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
+    return this.stmt.values(...params);
+  }
+  free() {
+    this.stmt.finalize();
+  }
+};
+var BunSqliteDriver = class _BunSqliteDriver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = false;
+  supportsTransactions = true;
+  exec(query) {
+    this.client.exec(query);
+  }
+  close() {
+    this.client.close();
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement3(
+      this.client.prepare(sql2),
+      options?.isSelection ?? false
+    );
+  }
+  batch(queries) {
+    return this.transaction((tx) => {
+      return queries.map(
+        ({ sql: sql2, params, isSelection }) => tx.prepare(sql2, { isSelection }).values(params)
+      );
+    }, {});
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _BunSqliteDriver(this.client, depth),
+      run,
+      options
+    );
+  }
+};
+function connect2(db) {
+  return new SyncDatabase(new BunSqliteDriver(db), sqliteDialect, sqliteDiff);
+}
+
+// node_modules/rado/dist/driver/d1.js
+var PreparedStatement4 = class {
+  constructor(stmt, isSelection) {
+    this.stmt = stmt;
+    this.isSelection = isSelection;
+  }
+  stmt;
+  isSelection;
+  async all(params) {
+    return this.stmt.bind(...params).all().then(({ results }) => results);
+  }
+  async run(params) {
+    const results = await this.stmt.bind(...params).run();
+  }
+  async get(params) {
+    return this.stmt.bind(...params).first();
+  }
+  async values(params) {
+    if (this.isSelection) return this.stmt.bind(...params).raw();
+    await this.stmt.bind(...params).run();
+    return [];
+  }
+  free() {
+  }
+};
+var D1Driver = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  parsesJson = false;
+  supportsTransactions = false;
+  async exec(query) {
+    await this.client.exec(query);
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement4(
+      this.client.prepare(sql2),
+      options?.isSelection ?? false
+    );
+  }
+  async close() {
+  }
+  async batch(queries) {
+    const stmts = queries.map(
+      ({ sql: sql2, params }) => this.client.prepare(sql2).bind(...params)
+    );
+    const rows = await this.client.batch(stmts);
+    return rows.map((row, index) => {
+      const isSelection = queries[index]?.isSelection;
+      if (!isSelection) return [];
+      return row.results.map(Object.values);
+    });
+  }
+  async transaction() {
+    throw new Error("Transactions are not supported in D1");
+  }
+};
+function connect3(client) {
+  return new AsyncDatabase(new D1Driver(client), sqliteDialect, sqliteDiff);
+}
+
+// node_modules/rado/dist/driver/libsql.js
+var PreparedStatement5 = class {
+  constructor(client, sql2) {
+    this.client = client;
+    this.sql = sql2;
+  }
+  client;
+  sql;
+  async all(params) {
+    const result = await this.client.execute({ sql: this.sql, args: params });
+    return result.rows;
+  }
+  async run(params) {
+    const result = await this.client.execute({ sql: this.sql, args: params });
+  }
+  async get(params) {
+    return (await this.all(params))[0] ?? null;
+  }
+  async values(params) {
+    const result = await this.client.execute({ sql: this.sql, args: params });
+    return result.rows;
+  }
+  free() {
+  }
+};
+var LibSQLClient = class _LibSQLClient {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = false;
+  supportsTransactions = true;
+  async exec(query) {
+    await this.client.execute(query);
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement5(this.client, sql2);
+  }
+  async close() {
+    if ("close" in this.client) return this.client.close();
+  }
+  async batch(queries) {
+    const stmts = queries.map(({ sql: sql2, params }) => {
+      return { sql: sql2, args: params };
+    });
+    const rows = await this.client.batch(stmts);
+    return rows.map((row) => row.rows);
+  }
+  async transaction(run, options) {
+    const client = "transaction" in this.client ? await this.client.transaction() : this.client;
+    const driver = new _LibSQLClient(client, this.depth + 1);
+    if (this.depth > 0) await client.execute(`savepoint d${this.depth}`);
+    try {
+      const result = await run(driver);
+      if (this.depth > 0)
+        await client.execute(`release savepoint d${this.depth}`);
+      else await client.commit();
+      return result;
+    } catch (error) {
+      if (this.depth > 0)
+        await client.execute(`rollback to savepoint d${this.depth}`);
+      else await client.rollback();
+      throw error;
+    } finally {
+      if (this.depth === 0) client.close();
+    }
+  }
+};
+function connect4(client) {
+  return new AsyncDatabase(new LibSQLClient(client), sqliteDialect, sqliteDiff);
+}
+
+// node_modules/rado/dist/mysql/dialect.js
+var BACKTICK = "`";
+var ESCAPE_BACKTICK = "``";
+var MATCH_BACKTICK = /`/g;
+var ESCAPE_BACKSLASH = "\\\\";
+var MATCH_BACKSLASH = /\\/g;
+var SINGLE_QUOTE2 = "'";
+var ESCAPE_SINGLE_QUOTE2 = "''";
+var MATCH_SINGLE_QUOTE2 = /'/g;
+var mysqlDialect = new Dialect(
+  "mysql",
+  class extends Emitter {
+    runtime = "mysql";
+    emitValue(value) {
+      this.params.push(new ValueParam(value));
+      this.sql += "?";
+    }
+    emitPlaceholder(name) {
+      this.params.push(new NamedParam(name));
+      this.sql += "?";
+    }
+    emitJsonPath({ target, asSql, segments }) {
+      target.emit(this);
+      this.sql += asSql ? "->>" : "->";
+      this.sql += this.quoteString(
+        `$${segments.map(
+          (p) => typeof p === "number" ? `[${p}]` : `.${JSON.stringify(p)}`
+        ).join("")}`
+      );
+    }
+    emitInline(value) {
+      if (value === null || value === void 0) return this.sql += "null";
+      if (typeof value === "number" || typeof value === "boolean")
+        return this.sql += value;
+      if (typeof value === "string")
+        return this.sql += this.quoteString(value);
+      this.sql += this.quoteString(JSON.stringify(value));
+    }
+    quoteString(input2) {
+      return SINGLE_QUOTE2 + input2.replace(MATCH_BACKSLASH, ESCAPE_BACKSLASH).replace(MATCH_SINGLE_QUOTE2, ESCAPE_SINGLE_QUOTE2) + SINGLE_QUOTE2;
+    }
+    emitIdentifier(identifier) {
+      this.sql += BACKTICK + identifier.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
+    }
+  }
+);
+
+// node_modules/rado/dist/core/Schema.js
+function schema(schemaName) {
+  return {
+    table(tableName, columns, config) {
+      return table(tableName, columns, config, schemaName);
+    }
+  };
+}
+
+// node_modules/rado/dist/mysql/columns.js
+function integer3(name) {
+  return new Column({ name, type: column.integer() });
+}
+function text3(name) {
+  return new Column({ name, type: column.text() });
+}
+
+// node_modules/rado/dist/mysql/diff.js
+var ns = schema("information_schema");
+var Information = ns.table("columns", {
+  table_name: text3().notNull(),
+  column_name: text3().notNull(),
+  column_type: text3().notNull(),
+  is_nullable: text3().notNull(),
+  column_default: text3(),
+  extra: text3().notNull(),
+  table_schema: text3().notNull()
+});
+var Statistics = ns.table("statistics", {
+  table_name: text3().notNull(),
+  column_name: text3().notNull(),
+  index_name: text3().notNull(),
+  non_unique: integer3().notNull(),
+  seq_in_index: integer3().notNull(),
+  table_schema: text3().notNull()
+});
+var TableConstraints = ns.table("table_constraints", {
+  constraint_name: text3().notNull(),
+  table_name: text3().notNull(),
+  constraint_type: text3().notNull(),
+  table_schema: text3().notNull()
+});
+var inline2 = (sql2) => mysqlDialect.inline(sql2);
+var mysqlDiff = (hasTable) => {
+  return txGenerator(function* (tx) {
+    const tableApi = getTable(hasTable);
+    const stmts = [];
+    const columnInfo = yield* tx.select({
+      name: Information.column_name,
+      type: Information.column_type,
+      notNull: eq(Information.is_nullable, "NO"),
+      defaultValue: Information.column_default,
+      extra: Information.extra
+    }).from(Information).where(
+      eq(Information.table_name, tableApi.name),
+      eq(Information.table_schema, sql`database()`)
+    );
+    if (columnInfo.length === 0) return tableApi.create().map(inline2);
+    const indexInfo = yield* tx.select({
+      index_name: Statistics.index_name,
+      column_name: Statistics.column_name,
+      non_unique: Statistics.non_unique,
+      seq_in_index: Statistics.seq_in_index
+    }).from(Statistics).where(
+      eq(Statistics.table_name, tableApi.name),
+      eq(Statistics.table_schema, sql`database()`)
+    ).orderBy(Statistics.index_name, Statistics.seq_in_index);
+    const indexMap = /* @__PURE__ */ new Map();
+    for (const index of indexInfo) {
+      if (!indexMap.has(index.index_name)) {
+        indexMap.set(index.index_name, []);
+      }
+      indexMap.get(index.index_name).push(index.column_name);
+    }
+    const localColumns = new Map(
+      columnInfo.map((column2) => {
+        let type = column2.type.toLowerCase();
+        const isAutoIncrement = column2.extra.toLowerCase().includes("auto_increment");
+        if (isAutoIncrement) {
+          if (type.includes("bigint")) type = "bigserial";
+          else if (type.includes("smallint")) type = "smallserial";
+          else type = "serial";
+        }
+        return [
+          column2.name,
+          {
+            type: sql.unsafe(type),
+            notNull: column2.notNull && !isAutoIncrement,
+            nullable: !column2.notNull,
+            defaultValue: column2.defaultValue && !isAutoIncrement ? sql.unsafe(column2.defaultValue) : void 0
+          }
+        ];
+      })
+    );
+    const primaryKeys = primaryKeyColumns(tableApi);
+    const schemaColumns = new Map(
+      Object.entries(tableApi.columns).map(([name, column2]) => {
+        const columnApi = getData(column2);
+        const columnName = columnApi.name ?? name;
+        return [
+          columnName,
+          {
+            ...columnApi,
+            nullable: !columnApi.notNull && !primaryKeys.has(columnName)
+          }
+        ];
+      })
+    );
+    const columnNames = /* @__PURE__ */ new Set([
+      ...localColumns.keys(),
+      ...schemaColumns.keys()
+    ]);
+    for (const columnName of columnNames) {
+      const alterTable = sql.identifier(tableApi.name);
+      const column2 = sql.identifier(columnName);
+      const localInstruction = localColumns.get(columnName);
+      const schemaInstruction = schemaColumns.get(columnName);
+      if (!schemaInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable,
+            dropColumn: column2
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable,
+            addColumn: [column2, formatColumn(schemaInstruction)]
+          })
+        );
+      } else {
+        if (inline2(localInstruction.type) !== inline2(schemaInstruction.type)) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              modifyColumn: [column2, schemaInstruction.type]
+            })
+          );
+        }
+        if (Boolean(localInstruction.nullable) !== Boolean(schemaInstruction.nullable)) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              modifyColumn: [
+                column2,
+                schemaInstruction.nullable ? sql`${schemaInstruction.type} null` : sql`${schemaInstruction.type} not null`
+              ]
+            })
+          );
+        }
+        const localDefault = localInstruction.defaultValue;
+        const schemaDefault = schemaInstruction.defaultValue;
+        const localDefaultStr = localDefault && inline2(localDefault);
+        const schemaDefaultStr = schemaDefault && inline2(schemaDefault);
+        if (localDefaultStr !== schemaDefaultStr) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              alterColumn: [
+                column2,
+                schemaDefault ? sql`set default ${schemaDefault}` : sql`drop default`
+              ]
+            })
+          );
+        }
+      }
+    }
+    const localIndexes = new Map(
+      Array.from(indexMap.entries()).filter(([name]) => name !== "PRIMARY").map(([name, columns]) => {
+        return [
+          name,
+          sql`index ${sql.identifier(name)} (${sql.join(columns.map(sql.identifier), sql`, `)})`
+        ];
+      })
+    );
+    const schemaIndexes = new Map(
+      Object.entries(tableApi.indexes()).map(([name, index]) => {
+        const indexApi = getData(index);
+        return [name, indexApi.toSql(tableApi.name, name, false)];
+      })
+    );
+    const indexNames = /* @__PURE__ */ new Set([
+      ...localIndexes.keys(),
+      ...schemaIndexes.keys()
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = localIndexes.get(indexName);
+      const schemaInstruction = schemaIndexes.get(indexName);
+      if (!schemaInstruction) {
+        stmts.unshift(
+          sql.query({
+            alterTable: sql.identifier(tableApi.name),
+            dropIndex: sql.identifier(indexName)
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(schemaInstruction);
+      } else if (inline2(localInstruction) !== inline2(schemaInstruction)) {
+        if (indexName === "PRIMARY") {
+          stmts.unshift(
+            sql.query({
+              alterTable: sql.identifier(tableApi.name),
+              dropPrimaryKey: true
+            })
+          );
+          stmts.push(schemaInstruction);
+        } else {
+          stmts.unshift(
+            sql.query({
+              alterTable: sql.identifier(tableApi.name),
+              dropIndex: sql.identifier(indexName)
+            })
+          );
+          stmts.push(schemaInstruction);
+        }
+      }
+    }
+    return stmts.map(inline2);
+  });
+};
+
+// node_modules/rado/dist/mysql/transactions.js
+function startTransaction(options) {
+  return [
+    "start transaction",
+    options.withConsistentSnapshot && "with consistent snapshot",
+    options.accessMode
+  ].filter(Boolean).join(" ");
+}
+function setTransaction(options) {
+  if (!options.isolationLevel) return;
+  return [
+    "set transaction",
+    options.isolationLevel && `isolation level ${options.isolationLevel}`
+  ].filter(Boolean).join(" ");
+}
+
+// node_modules/rado/dist/driver/mysql2.js
+var PreparedStatement6 = class {
+  constructor(client, sql2, isSelection, name) {
+    this.client = client;
+    this.sql = sql2;
+    this.isSelection = isSelection;
+    this.name = name;
+  }
+  client;
+  sql;
+  isSelection;
+  name;
+  #transformParam = (param) => {
+    if (param instanceof Uint8Array) return Buffer.from(param);
+    return param;
+  };
+  all(params) {
+    return this.client.query(this.sql, params.map(this.#transformParam)).then((res) => res[0]);
+  }
+  async run(params) {
+    await this.client.query(this.sql, params.map(this.#transformParam));
+  }
+  get(params) {
+    return this.all(params).then((rows) => rows[0] ?? null);
+  }
+  values(params) {
+    if (!this.isSelection) return this.run(params).then(() => []);
+    return this.client.query({
+      sql: this.sql,
+      values: params.map(this.#transformParam),
+      rowsAsArray: true
+    }).then((res) => res[0]);
+  }
+  free() {
+  }
+};
+var Mysql2Driver = class _Mysql2Driver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = true;
+  supportsTransactions = true;
+  async exec(query) {
+    await this.client.query(query);
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement6(
+      this.client,
+      sql2,
+      options?.isSelection ?? false,
+      options?.name
+    );
+  }
+  async close() {
+    if ("end" in this.client) return this.client.end();
+  }
+  async batch(queries) {
+    const transact = async (tx) => {
+      const results = [];
+      for (const { sql: sql2, params, isSelection } of queries)
+        results.push(await tx.prepare(sql2, { isSelection }).values(params));
+      return results;
+    };
+    if (this.depth > 0) return transact(this);
+    return this.transaction(transact, {});
+  }
+  async transaction(run, options) {
+    const client = isPool(this.client) ? await this.client.getConnection() : this.client;
+    const driver = new _Mysql2Driver(client, this.depth + 1);
+    try {
+      await client.query(
+        this.depth > 0 ? `savepoint d${this.depth}` : startTransaction(options)
+      );
+      if (this.depth === 0) {
+        const setOptions = setTransaction(options);
+        if (setOptions) await client.query(setOptions);
+      }
+      const result = await run(driver);
+      await client.query(
+        this.depth > 0 ? `release savepoint d${this.depth}` : "commit"
+      );
+      return result;
+    } catch (error) {
+      await client.query(
+        this.depth > 0 ? `rollback to savepoint d${this.depth}` : "rollback"
+      );
+      throw error;
+    } finally {
+      if (isPool(this.client))
+        this.client.releaseConnection(client);
+    }
+  }
+};
+function isPool(client) {
+  return "getConnection" in client;
+}
+function connect5(client) {
+  return new AsyncDatabase(
+    new Mysql2Driver("promise" in client ? client.promise() : client),
+    mysqlDialect,
+    mysqlDiff
+  );
+}
+
+// node_modules/rado/dist/driver/node-sqlite.js
+var PreparedStatement7 = class {
+  constructor(stmt, isSelection) {
+    this.stmt = stmt;
+    this.isSelection = isSelection;
+  }
+  stmt;
+  isSelection;
+  all(params) {
+    return this.stmt.all(...params);
+  }
+  run(params) {
+    this.stmt.run(...params);
+  }
+  get(params) {
+    return this.stmt.get(...params);
+  }
+  values(params) {
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
+    this.stmt.setReturnArrays(true);
+    try {
+      return this.stmt.all(...params);
+    } finally {
+      this.stmt.setReturnArrays(false);
+    }
+  }
+  free() {
+  }
+};
+var NodeSqliteDriver = class _NodeSqliteDriver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = false;
+  supportsTransactions = true;
+  exec(query) {
+    this.client.exec(query);
+  }
+  close() {
+    this.client.close();
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement7(
+      this.client.prepare(sql2),
+      options?.isSelection ?? false
+    );
+  }
+  batch(queries) {
+    return this.transaction(
+      (tx) => queries.map(
+        ({ sql: sql2, params, isSelection }) => tx.prepare(sql2, { isSelection }).values(params)
+      ),
+      {}
+    );
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _NodeSqliteDriver(this.client, depth),
+      run,
+      options
+    );
+  }
+};
+function connect6(db) {
+  return new SyncDatabase(new NodeSqliteDriver(db), sqliteDialect, sqliteDiff);
+}
+
+// node_modules/rado/dist/postgres/dialect.js
+var DOUBLE_QUOTE2 = '"';
+var ESCAPE_DOUBLE_QUOTE2 = '""';
+var MATCH_DOUBLE_QUOTE2 = /"/g;
+var SINGLE_QUOTE3 = "'";
+var ESCAPE_SINGLE_QUOTE3 = "''";
+var MATCH_SINGLE_QUOTE3 = /'/g;
+var postgresDialect = new Dialect(
+  "postgres",
+  class extends Emitter {
+    runtime = "postgres";
+    emitValue(value) {
+      this.params.push(new ValueParam(value));
+      this.sql += `$${this.params.length}`;
+    }
+    emitPlaceholder(name) {
+      this.params.push(new NamedParam(name));
+      this.sql += `$${this.params.length}`;
+    }
+    emitJsonPath({ target, asSql, segments }) {
+      target.emit(this);
+      for (let i = 0; i < segments.length; i++) {
+        const access = segments[i];
+        if (i <= segments.length - 2) this.sql += "->";
+        else if (i === segments.length - 1) this.sql += asSql ? "->>" : "->";
+        if (typeof access === "number") this.sql += access;
+        else this.sql += this.quoteString(access);
+      }
+    }
+    emitInline(value) {
+      if (value === null || value === void 0) return this.sql += "null";
+      if (typeof value === "number" || typeof value === "boolean")
+        return this.sql += value;
+      if (typeof value === "string")
+        return this.sql += this.quoteString(value);
+      this.sql += this.quoteString(JSON.stringify(value));
+    }
+    quoteString(input2) {
+      return SINGLE_QUOTE3 + input2.replace(MATCH_SINGLE_QUOTE3, ESCAPE_SINGLE_QUOTE3) + SINGLE_QUOTE3;
+    }
+    emitIdentifier(identifier) {
+      this.sql += DOUBLE_QUOTE2 + identifier.replace(MATCH_DOUBLE_QUOTE2, ESCAPE_DOUBLE_QUOTE2) + DOUBLE_QUOTE2;
+    }
+  }
+);
+
+// node_modules/rado/dist/postgres/diff.js
+var Attr = table("pg_attribute", {
+  name: text("attname").notNull(),
+  typId: oid("atttypid").notNull(),
+  typMod: integer("atttypmod").notNull(),
+  notNull: boolean("attnotnull").notNull(),
+  relId: oid("attrelid").notNull(),
+  isDropped: boolean("attisdropped").notNull(),
+  num: integer("attnum").notNull(),
+  identity: text("attidentity"),
+  hasDef: boolean("atthasdef").notNull()
+});
+var Class = table("pg_class", {
+  oid: oid().notNull(),
+  relname: text().notNull(),
+  relnamespace: oid().notNull()
+});
+var Namespace = table("pg_namespace", {
+  oid: oid().notNull(),
+  name: text("nspname").notNull()
+});
+var Type = table("pg_type", {
+  oid: oid().notNull(),
+  name: text("typname").notNull()
+});
+var AttrDef = table("pg_attrdef", {
+  relId: oid("adrelid").notNull(),
+  num: integer("adnum").notNull(),
+  bin: text("adbin").notNull()
+});
+var inline3 = (sql2) => postgresDialect.inline(sql2);
+var columnType = sql`pg_catalog.format_type(${Attr.typId}, ${Attr.typMod})`;
+var columnDefaultValue = when(
+  [Attr.hasDef, sql`pg_catalog.pg_get_expr(${AttrDef.bin}, ${AttrDef.relId})`],
+  null
+);
+var identity = when(
+  [eq(Attr.identity, "a"), sql`'generated always as identity'`],
+  [eq(Attr.identity, "d"), sql`'generated by default as identity'`],
+  null
+);
+var postgresDiff = (hasTable) => {
+  return txGenerator(function* (tx) {
+    const tableApi = getTable(hasTable);
+    const def = tx.select({
+      table_name: Class.relname,
+      name: Attr.name,
+      type: columnType,
+      notNull: Attr.notNull,
+      defaultValue: columnDefaultValue,
+      identity,
+      schema_name: Namespace.name
+    }).from(Class).innerJoin(Namespace, eq(Namespace.oid, Class.relnamespace)).innerJoin(Attr, and(gt(Attr.num, 0), eq(Attr.relId, Class.oid))).innerJoin(Type, eq(Attr.typId, Type.oid)).leftJoin(
+      AttrDef,
+      and(eq(Attr.relId, AttrDef.relId), eq(Attr.num, AttrDef.num))
+    ).where(eq(Class.relname, tableApi.name)).orderBy(asc(Attr.num)).as("def");
+    const mapSequenceType = when(
+      def.type,
+      ["integer", "serial"],
+      ["smallint", "smallserial"],
+      ["bigint", "bigserial"],
+      def.type
+    );
+    const isSequence = like(def.defaultValue, "nextval(%_seq%");
+    const type = concat(
+      when([isSequence, mapSequenceType], def.type),
+      when(
+        [isNotNull(def.identity), concat(" ", def.identity).inlineValues()],
+        ""
+      )
+    ).inlineValues();
+    const isNumeric = or(
+      eq(def.type, "integer"),
+      eq(def.type, "smallint"),
+      eq(def.type, "bigint")
+    );
+    const isNumericSequence = and(isSequence, isNumeric);
+    const defaultValue = when(
+      [
+        and(isNotNull(def.defaultValue), not(isNumericSequence)),
+        def.defaultValue
+      ],
+      ""
+    );
+    const columnInfo = yield* tx.select({
+      name: def.name,
+      type,
+      notNull: and(def.notNull, isNull(def.identity)),
+      defaultValue
+    }).from(def);
+    if (columnInfo.length === 0) return tableApi.create().map(inline3);
+    const localColumns = new Map(
+      columnInfo.map((column2) => {
+        return [
+          column2.name,
+          {
+            type: sql.unsafe(column2.type.toLowerCase()),
+            notNull: column2.notNull,
+            nullable: !column2.notNull,
+            defaultValue: column2.defaultValue ? sql.unsafe(column2.defaultValue) : void 0
+          }
+        ];
+      })
+    );
+    const primaryKeys = primaryKeyColumns(tableApi);
+    const schemaColumns = new Map(
+      Object.entries(tableApi.columns).map(([name, column2]) => {
+        const columnApi = getData(column2);
+        const columnName = columnApi.name ?? name;
+        return [
+          columnName,
+          {
+            ...columnApi,
+            nullable: !columnApi.notNull && !primaryKeys.has(columnName)
+          }
+        ];
+      })
+    );
+    const stmts = [];
+    const columnNames = /* @__PURE__ */ new Set([
+      ...localColumns.keys(),
+      ...schemaColumns.keys()
+    ]);
+    for (const columnName of columnNames) {
+      const alterTable = sql.identifier(tableApi.name);
+      const column2 = sql.identifier(columnName);
+      const localInstruction = localColumns.get(columnName);
+      const schemaInstruction = schemaColumns.get(columnName);
+      if (!schemaInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable,
+            dropColumn: column2
+          })
+        );
+      } else if (!localInstruction) {
+        stmts.push(
+          sql.query({
+            alterTable,
+            addColumn: [column2, formatColumn(schemaInstruction)]
+          })
+        );
+      } else {
+        if (inline3(localInstruction.type) !== inline3(schemaInstruction.type)) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              alterColumn: [column2, sql`type ${schemaInstruction.type}`]
+            })
+          );
+        }
+        if (Boolean(localInstruction.nullable) !== Boolean(schemaInstruction.nullable)) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              alterColumn: [
+                column2,
+                schemaInstruction.nullable ? sql`drop not null` : sql`set not null`
+              ]
+            })
+          );
+        }
+        const localDefault = localInstruction.defaultValue;
+        const schemaDefault = schemaInstruction.defaultValue;
+        const localDefaultStr = localDefault && inline3(localDefault);
+        const schemaDefaultStr = schemaDefault && inline3(schemaDefault);
+        if (localDefaultStr !== schemaDefaultStr) {
+          stmts.push(
+            sql.query({
+              alterTable,
+              alterColumn: [
+                column2,
+                schemaDefault ? sql`set default ${schemaDefault}` : sql`drop default`
+              ]
+            })
+          );
+        }
+      }
+    }
+    return stmts.map(inline3);
+  });
+};
+
+// node_modules/rado/dist/postgres/transactions.js
+function setTransaction2(options) {
+  return [
+    "set transaction",
+    options.isolationLevel && `isolation level ${options.isolationLevel}`,
+    options.accessMode,
+    options.deferrable ? "deferrable" : "not deferrable"
+  ].filter(Boolean).join(" ");
+}
+
+// node_modules/rado/dist/driver/pg.js
+function isPool2(client) {
+  return "connect" in client && "totalCount" in client && "idleCount" in client && "waitingCount" in client;
+}
+async function acquireClient(client, depth) {
+  if (depth > 0 || !isPool2(client)) return { client };
+  const acquired = await client.connect();
+  return {
+    client: acquired,
+    release: () => acquired.release()
+  };
+}
+var PreparedStatement8 = class {
+  constructor(client, sql2, name) {
+    this.client = client;
+    this.sql = sql2;
+    this.name = name;
+  }
+  client;
+  sql;
+  name;
+  all(params) {
+    return this.client.query({
+      name: this.name,
+      text: this.sql,
+      values: params
+    }).then((res) => res.rows);
+  }
+  async run(params) {
+    await this.client.query(
+      {
+        name: this.name,
+        text: this.sql,
+        values: params
+      },
+      params
+    );
+  }
+  get(params) {
+    return this.all(params).then((rows) => rows[0] ?? null);
+  }
+  values(params) {
+    return this.client.query({
+      name: this.name,
+      text: this.sql,
+      values: params,
+      rowMode: "array"
+    }).then((res) => res.rows);
+  }
+  free() {
+  }
+};
+var PgDriver = class _PgDriver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = true;
+  supportsTransactions = true;
+  async exec(query) {
+    await this.client.query(query);
+  }
+  prepare(sql2, options) {
+    return new PreparedStatement8(this.client, sql2, options?.name);
+  }
+  async close() {
+    if (this.depth > 0) throw new Error("Cannot close a transaction");
+    if ("release" in this.client) return this.client.release();
+    if ("end" in this.client) return this.client.end();
+  }
+  async batch(queries) {
+    return this.transaction(async (tx) => {
+      const results = [];
+      for (const { sql: sql2, params } of queries)
+        results.push(await tx.prepare(sql2).values(params));
+      return results;
+    }, {});
+  }
+  async transaction(run, options) {
+    const { client, release } = await acquireClient(this.client, this.depth);
+    try {
+      await client.query(this.depth > 0 ? `savepoint d${this.depth}` : "begin");
+      if (this.depth === 0) await client.query(setTransaction2(options));
+      const result = await run(new _PgDriver(client, this.depth + 1));
+      await client.query(
+        this.depth > 0 ? `release savepoint d${this.depth}` : "commit"
+      );
+      return result;
+    } catch (error) {
+      await client.query(
+        this.depth > 0 ? `rollback to savepoint d${this.depth}` : "rollback"
+      );
+      throw error;
+    } finally {
+      release?.();
+    }
+  }
+};
+function connect7(client) {
+  return new AsyncDatabase(
+    new PgDriver(client),
+    postgresDialect,
+    postgresDiff
+  );
+}
+
+// node_modules/rado/dist/driver/pglite.js
+var RAW_DATE_TIME_PARSERS = {
+  20: (value) => value,
+  // int8 / bigint (e.g. count(*))
+  1082: (value) => value,
+  // date
+  1114: (value) => value,
+  // timestamp
+  1184: (value) => value
+  // timestamptz
+};
+var PreparedStatement9 = class {
+  constructor(client, sql2) {
+    this.client = client;
+    this.sql = sql2;
+  }
+  client;
+  sql;
+  all(params) {
+    return this.client.query(this.sql, params, {
+      rowMode: "object",
+      parsers: RAW_DATE_TIME_PARSERS
+    }).then((res) => res.rows);
+  }
+  async run(params) {
+    await this.client.query(this.sql, params, {
+      rowMode: "array",
+      parsers: RAW_DATE_TIME_PARSERS
+    });
+  }
+  get(params) {
+    return this.all(params).then((rows) => rows[0] ?? null);
+  }
+  values(params) {
+    return this.client.query(this.sql, params, {
+      rowMode: "array",
+      parsers: RAW_DATE_TIME_PARSERS
+    }).then((res) => res.rows);
+  }
+  free() {
+  }
+};
+var PGliteDriver = class _PGliteDriver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = true;
+  supportsTransactions = true;
+  async exec(query) {
+    await this.client.exec(query);
+  }
+  close() {
+    if ("close" in this.client) return this.client.close();
+    throw new Error("Cannot close a transaction");
+  }
+  prepare(sql2) {
+    return new PreparedStatement9(this.client, sql2);
+  }
+  async batch(queries) {
+    const transact = async (tx) => {
+      const results = [];
+      for (const { sql: sql2, params } of queries)
+        results.push(await tx.prepare(sql2).values(params));
+      return results;
+    };
+    if (this.depth > 0) return transact(this);
+    return this.transaction(transact, {});
+  }
+  async transaction(run, options) {
+    if (this.depth === 0 && "transaction" in this.client)
+      return this.client.transaction(async (tx) => {
+        await tx.query(setTransaction2(options));
+        return run(new _PGliteDriver(tx, this.depth + 1));
+      });
+    await this.exec(`savepoint d${this.depth}`);
+    try {
+      const result = await run(new _PGliteDriver(this.client, this.depth + 1));
+      await this.exec(`release d${this.depth}`);
+      return result;
+    } catch (error) {
+      await this.exec(`rollback to d${this.depth}`);
+      throw error;
+    }
+  }
+};
+function connect8(db) {
+  return new AsyncDatabase(new PGliteDriver(db), postgresDialect, postgresDiff);
+}
+
+// node_modules/rado/dist/driver/sql.js.js
+var PreparedStatement10 = class {
+  constructor(client, stmt) {
+    this.client = client;
+    this.stmt = stmt;
+  }
+  client;
+  stmt;
+  *iterate(params) {
+    this.stmt.bind(params);
+    while (this.stmt.step()) yield this.stmt.getAsObject();
+    this.stmt.reset();
+  }
+  *iterateValues(params) {
+    this.stmt.bind(params);
+    while (this.stmt.step()) yield this.stmt.get();
+    this.stmt.reset();
+  }
+  all(params) {
+    return Array.from(this.iterate(params));
+  }
+  run(params) {
+    this.stmt.run(params);
+    this.stmt.reset();
+    return { rowsAffected: this.client.getRowsModified() };
+  }
+  get(params) {
+    return this.all(params)[0] ?? null;
+  }
+  values(params) {
+    return Array.from(this.iterateValues(params));
+  }
+  free() {
+    this.stmt.free();
+  }
+};
+var SqlJsDriver = class _SqlJsDriver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = false;
+  supportsTransactions = true;
+  exec(query) {
+    this.client.exec(query);
+  }
+  close() {
+    this.client.close();
+  }
+  prepare(sql2) {
+    return new PreparedStatement10(this.client, this.client.prepare(sql2));
+  }
+  batch(queries) {
+    return this.transaction(
+      (tx) => queries.map(({ sql: sql2, params }) => tx.prepare(sql2).values(params)),
+      {}
+    );
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _SqlJsDriver(this.client, depth),
+      run,
+      options
+    );
+  }
+};
+function connect9(db) {
+  return new SyncDatabase(new SqlJsDriver(db), sqliteDialect, sqliteDiff);
+}
+
+export {
+  driver_exports
+};