alinea 1.7.0 → 2.0.0-preview.0

package/dist/backend/api/CreateBackend.js

@@ -1,2516 +1,52 @@
 import {
-  Field,
-  Functions,
-  and,
-  asc,
-  callFunction,
-  column,
-  eq,
-  gt,
-  isNotNull,
-  isNull,
-  jsonAggregateArray,
-  jsonArray,
-  like,
-  not,
-  or,
-  table,
-  when
-} from "../../chunks/chunk-SKF4L7JN.js";
-import {
-  Sql,
-  getData,
-  getField,
-  getQuery,
-  getResolver,
-  getSelection,
-  getSql,
-  getTable,
-  getTarget,
-  hasField,
-  hasQuery,
-  hasSelection,
-  hasSql,
-  hasTable,
-  hasTarget,
-  input,
-  internalData,
-  internalQuery,
-  internalResolver,
-  internalSelection,
-  internalSql,
-  internalTarget,
-  sql
-} from "../../chunks/chunk-PNILF4WM.js";
-import {
-  __export
-} from "../../chunks/chunk-NZLE2WMY.js";
+  driver_exports
+} from "../../chunks/chunk-X47OVDF3.js";
+import "../../chunks/chunk-G6E35DMJ.js";
+import "../../chunks/chunk-NWQXN4SB.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/api/CreateBackend.ts
 import { assert } from "alinea/core/util/Assert";
-
-// node_modules/rado/dist/driver.js
-var driver_exports = {};
-__export(driver_exports, {
-  "@electric-sql/pglite": () => connect7,
-  "@libsql/client": () => connect4,
-  "@neondatabase/serverless": () => connect6,
-  "@vercel/postgres": () => connect6,
-  "better-sqlite3": () => connect,
-  "bun:sqlite": () => connect2,
-  d1: () => connect3,
-  mysql2: () => connect5,
-  pg: () => connect6,
-  "sql.js": () => connect8
-});
-
-// 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(input), 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/Virtual.js
-function virtual(alias, source) {
-  const target = { [internalTarget]: sql.identifier(alias) };
-  if (source && hasSql(source)) {
-    const expr = getSql(source);
-    const name = expr.alias;
-    if (!name) throw new Error("Cannot alias a virtual field without a name");
-    return Object.assign(new Field(alias, name, expr), target);
-  }
-  return new Proxy(target, {
-    get(target2, field) {
-      if (field in target2) return target2[field];
-      const from = source?.[field];
-      if (typeof field !== "string") return from;
-      return target2[field] = new Field(
-        alias,
-        field,
-        from ? getSql(from) : void 0
-      );
-    }
-  });
-}
-
-// node_modules/rado/dist/core/Selection.js
-var SqlColumn = class {
-  constructor(sql2, targetName) {
-    this.sql = sql2;
-    this.targetName = targetName;
-  }
-  result(ctx) {
-    const value = ctx.values[ctx.index++];
-    if (!this.sql.mapFromDriverValue) return value;
-    return this.sql.mapFromDriverValue(value, ctx.specs);
-  }
-};
-var ObjectColumn = class {
-  constructor(nullable, entries) {
-    this.nullable = nullable;
-    this.entries = entries;
-  }
-  result(ctx) {
-    const result = {};
-    let isNullable = this.nullable.size > 0;
-    for (const entry of this.entries) {
-      const name = entry[0];
-      const col = entry[1];
-      const value = col.result(ctx);
-      result[name] = value;
-      if (isNullable) {
-        if (value === null) {
-          if (col.targetName && !this.nullable.has(col.targetName))
-            isNullable = false;
-        } else {
-          isNullable = false;
-        }
-      }
-    }
-    if (isNullable) return null;
-    return result;
-  }
-};
-var Selection = class {
-  constructor(input2, nullable) {
-    this.input = input2;
-    this.nullable = nullable;
-    const root = this.#defineColumn(nullable, input2);
-    this.mapRow = root.result.bind(root);
-  }
-  mapRow;
-  makeVirtual(name) {
-    return virtual(name, this.input);
-  }
-  #defineColumn(nullable, input2) {
-    const expr = getSql(input2);
-    if (expr) return new SqlColumn(expr, getField(input2)?.targetName);
-    return new ObjectColumn(
-      nullable,
-      Object.entries(input2).map(([name, value]) => [
-        name,
-        this.#defineColumn(nullable, value)
-      ])
-    );
-  }
-  fieldNames() {
-    return this.#fieldNames(this.input, /* @__PURE__ */ new Set());
-  }
-  #fieldNames(input2, names, name) {
-    const expr = getSql(input2);
-    if (expr) {
-      let exprName = name ?? expr.alias;
-      if (!exprName) throw new Error("Missing field name");
-      while (names.has(exprName)) exprName = `${exprName}_`;
-      return [exprName];
-    }
-    return Object.entries(input2).flatMap(
-      ([name2, value]) => this.#fieldNames(value, names, name2)
-    );
-  }
-  #selectionToSql(input2, names, name) {
-    const expr = getSql(input2);
-    if (expr) {
-      let exprName = name ?? expr.alias;
-      if (exprName) {
-        while (names.has(exprName)) exprName = `${exprName}_`;
-        names.add(exprName);
-        if (hasField(input2)) {
-          const field = getField(input2);
-          if (field.fieldName === exprName) return [expr];
-        }
-        return [sql`${expr.forSelection()} as ${sql.identifier(exprName)}`];
-      }
-      return [expr];
-    }
-    return Object.entries(input2).flatMap(
-      ([name2, value]) => this.#selectionToSql(value, names, name2)
-    );
-  }
-  get [internalSql]() {
-    return sql.join(this.#selectionToSql(this.input, /* @__PURE__ */ new Set()), sql`, `);
-  }
-  join(right, operator) {
-    return this;
-  }
-};
-var TableSelection = class extends Selection {
-  constructor(table2) {
-    super(table2, /* @__PURE__ */ new Set());
-    this.table = table2;
-  }
-  join(right, operator) {
-    const leftTable = getTable(this.table);
-    const rightTable = getTable(right);
-    const nullable = new Set(this.nullable);
-    if (operator === "right" || operator === "full")
-      nullable.add(leftTable.aliased);
-    if (operator === "left" || operator === "full")
-      nullable.add(rightTable.aliased);
-    return new JoinSelection([this.table, right], nullable);
-  }
-};
-var JoinSelection = class _JoinSelection extends Selection {
-  constructor(tables, nullable) {
-    super(
-      Object.fromEntries(tables.map((table2) => [getTable(table2).aliased, table2])),
-      nullable
-    );
-    this.tables = tables;
-  }
-  join(right, operator) {
-    const rightTable = getTable(right);
-    const nullable = new Set(this.nullable);
-    if (operator === "right" || operator === "full")
-      this.tables.map((table2) => getTable(table2).aliased).forEach(nullable.add, nullable);
-    if (operator === "left" || operator === "full")
-      nullable.add(rightTable.aliased);
-    return new _JoinSelection([...this.tables, right], nullable);
-  }
-};
-function selection(input2, nullable = []) {
-  return new Selection(input2, new Set(nullable));
-}
-((selection2) => {
-  function table2(table22) {
-    return new TableSelection(table22);
-  }
-  selection2.table = table2;
-})(selection || (selection = {}));
-
-// node_modules/rado/dist/core/Query.js
-var Executable = class {
-  #execute;
-  constructor(exec) {
-    this.#execute = exec;
-  }
-  *[Symbol.iterator]() {
-    const interim = this.#execute();
-    const isAsync = interim instanceof Promise;
-    if (!isAsync) return interim;
-    let result;
-    yield interim.then((v) => result = v);
-    return result;
-  }
-  run() {
-    return this.#execute();
-  }
-  // biome-ignore lint/suspicious/noThenProperty:
-  async then(onfulfilled, onrejected) {
-    try {
-      const result = await this.#execute();
-      return onfulfilled ? onfulfilled(result) : result;
-    } catch (error) {
-      return onrejected ? onrejected(error) : Promise.reject(error);
-    }
-  }
-  catch(onrejected) {
-    return this.then().catch(onrejected);
-  }
-  finally(onfinally) {
-    return this.then().finally(onfinally);
-  }
-};
-var QueryBatch = class extends Executable {
-  constructor(queryResolver, queries) {
-    super(() => {
-      return queryResolver.batch(queries).execute();
-    });
-  }
-};
-var Query = class extends Executable {
-  [internalData];
-  constructor(data) {
-    super(() => this.#exec(void 0));
-    this[internalData] = data;
-  }
-  #exec(method, db) {
-    const data = getData(this);
-    const resolver = db ? getResolver(db) : data.resolver;
-    const isSelection = hasSelection(this);
-    const prepared = resolver.prepare(this, "");
-    const resultType = method ?? (isSelection ? "all" : "run");
-    try {
-      const result = prepared[resultType]();
-      if (result instanceof Promise)
-        return result.then((res) => res ?? null).finally(prepared.free.bind(prepared));
-      prepared.free();
-      return result ?? null;
-    } catch (error) {
-      prepared.free();
-      throw error;
-    }
-  }
-  all(db) {
-    return this.#exec("all", db);
-  }
-  get(db) {
-    return this.#exec("get", db);
-  }
-  run(db) {
-    return this.#exec("run", db);
-  }
-  prepare(name) {
-    return getData(this).resolver.prepare(this, name);
-  }
-  toSQL(db) {
-    const resolver = db ? getResolver(db) : getData(this).resolver;
-    if (!resolver) throw new Error("Query has no resolver");
-    return resolver.toSQL(this);
-  }
-};
-
-// node_modules/rado/dist/core/query/Delete.js
-var Delete = class extends Query {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    if (data.returning) this[internalSelection] = data.returning;
-  }
-  get [internalQuery]() {
-    return sql.chunk("emitDelete", this);
-  }
-};
-var DeleteFrom = class _DeleteFrom extends Delete {
-  where(...where) {
-    return new _DeleteFrom({ ...getData(this), where: and(...where) });
-  }
-  returning(returning) {
-    const data = getData(this);
-    return new Delete({
-      ...data,
-      returning: returning ? selection(returning) : selection.table(data.from)
-    });
-  }
-};
-
-// node_modules/rado/dist/core/query/Insert.js
-var Insert = class extends Query {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    if (data.returning) this[internalSelection] = data.returning;
-  }
-  get [internalQuery]() {
-    return sql.chunk("emitInsert", this);
-  }
-};
-var InsertCanReturn = class extends Insert {
-  returning(returning) {
-    const data = getData(this);
-    return new Insert({
-      ...data,
-      returning: returning ? selection(returning) : selection.table(data.into)
-    });
-  }
-};
-var InsertCanConflict = class extends InsertCanReturn {
-  onConflictDoNothing(onConflict) {
-    return this.#onConflict(onConflict ?? {});
-  }
-  onConflictDoUpdate(onConflict) {
-    return this.#onConflict(onConflict);
-  }
-  onDuplicateKeyUpdate(update) {
-    return new InsertCanReturn({
-      ...getData(this),
-      onDuplicateKeyUpdate: this.#updateFields(update.set)
-    });
-  }
-  #updateFields(update) {
-    return sql.join(
-      Object.entries(update).map(
-        ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
-      ),
-      sql`, `
-    );
-  }
-  #onConflict({
-    target,
-    targetWhere,
-    set,
-    setWhere
-  }) {
-    const update = set && this.#updateFields(set);
-    return new InsertCanReturn({
-      ...getData(this),
-      onConflict: sql.join([
-        target && sql`(${Array.isArray(target) ? sql.join(target, sql`, `) : target})`,
-        targetWhere && sql`where ${targetWhere}`,
-        update ? sql.join([
-          sql`do update set ${update}`,
-          setWhere && sql`where ${setWhere}`
-        ]) : sql`do nothing`
-      ])
-    });
-  }
-};
-var defaultKeyword = sql.universal({
-  sqlite: sql`null`,
-  default: sql`default`
-});
-var InsertInto = class {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  values(insert) {
-    const { into } = getData(this);
-    const rows = Array.isArray(insert) ? insert : [insert];
-    const table2 = getTable(into);
-    const values = sql.join(
-      rows.map((row) => {
-        return sql`(${sql.join(
-          Object.entries(table2.columns).map(([key, column2]) => {
-            const value = row[key];
-            const { $default, mapToDriverValue } = getData(column2);
-            if (value !== void 0) {
-              if (value && typeof value === "object" && hasSql(value))
-                return value;
-              return input(mapToDriverValue?.(value) ?? value);
-            }
-            if ($default) return $default();
-            return defaultKeyword;
-          }),
-          sql`, `
-        )})`;
-      }),
-      sql`, `
-    );
-    return new InsertCanConflict({ ...getData(this), values });
-  }
-  select(query) {
-    return new InsertCanConflict({
-      ...getData(this),
-      select: getQuery(query)
-    });
-  }
-};
-
-// node_modules/rado/dist/core/query/Union.js
-var UnionBase = class extends Query {
-  [internalData];
-  #makeSelf() {
-    const { select } = getData(this);
-    return select.makeVirtual(Sql.SELF_TARGET);
-  }
-  union(right) {
-    return new Union({
-      ...getData(this),
-      left: this,
-      operator: sql`union`,
-      right: typeof right === "function" ? right(this.#makeSelf()) : right
-    });
-  }
-  unionAll(right) {
-    return new Union({
-      ...getData(this),
-      left: this,
-      operator: sql`union all`,
-      right: typeof right === "function" ? right(this.#makeSelf()) : right
-    });
-  }
-  intersect(right) {
-    return new Union({
-      ...getData(this),
-      left: this,
-      operator: sql`intersect`,
-      right: typeof right === "function" ? right(this.#makeSelf()) : right
-    });
-  }
-  intersectAll(right) {
-    return new Union({
-      ...getData(this),
-      left: this,
-      operator: sql`intersect all`,
-      right: typeof right === "function" ? right(this.#makeSelf()) : right
-    });
-  }
-  except(right) {
-    return new Union({
-      ...getData(this),
-      left: this,
-      operator: sql`except`,
-      right: typeof right === "function" ? right(this.#makeSelf()) : right
-    });
-  }
-  exceptAll(right) {
-    return new Union({
-      ...getData(this),
-      left: this,
-      operator: sql`except all`,
-      right: typeof right === "function" ? right(this.#makeSelf()) : right
-    });
-  }
-};
-var Union = class extends UnionBase {
-  [internalData];
-  [internalSelection];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    this[internalSelection] = data.select;
-  }
-  get [internalQuery]() {
-    return sql.chunk("emitUnion", getData(this));
-  }
-};
-
-// node_modules/rado/dist/core/query/Select.js
-var Select = class _Select extends UnionBase {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-  }
-  as(alias) {
-    const fields = getSelection(this).makeVirtual(alias);
-    return Object.assign(fields, {
-      [internalTarget]: sql`(${getQuery(this)}) as ${sql.identifier(
-        alias
-      )}`.inlineFields(true)
-    });
-  }
-  from(target) {
-    const { select: current } = getData(this);
-    const from = hasTarget(target) ? getTarget(target) : getSql(target);
-    const isTable = hasTable(target);
-    const selected = current ?? (isTable ? selection.table(target) : selection(sql`*`));
-    return new _Select({
-      ...getData(this),
-      select: selected,
-      from
-    });
-  }
-  #join(operator, right, on) {
-    const { from, select: current } = getData(this);
-    return new _Select({
-      ...getData(this),
-      select: hasTable(right) ? current?.join(right, operator) : current,
-      from: sql.join([
-        from,
-        sql.unsafe(`${operator} join`),
-        getTarget(right),
-        sql`on ${on}`
-      ])
-    });
-  }
-  leftJoin(right, on) {
-    return this.#join("left", right, on);
-  }
-  rightJoin(right, on) {
-    return this.#join("right", right, on);
-  }
-  innerJoin(right, on) {
-    return this.#join("inner", right, on);
-  }
-  fullJoin(right, on) {
-    return this.#join("full", right, on);
-  }
-  where(...where) {
-    return new _Select({ ...getData(this), where: and(...where) });
-  }
-  groupBy(...exprs) {
-    return new _Select({
-      ...getData(this),
-      groupBy: sql.join(exprs, sql.unsafe(", "))
-    });
-  }
-  having(having) {
-    return new _Select({
-      ...getData(this),
-      having: typeof having === "function" ? having(getSelection(this).input) : having
-    });
-  }
-  orderBy(...exprs) {
-    return new _Select({
-      ...getData(this),
-      orderBy: sql.join(exprs, sql.unsafe(", "))
-    });
-  }
-  limit(limit) {
-    return new _Select({ ...getData(this), limit: input(limit) });
-  }
-  offset(offset) {
-    return new _Select({
-      ...getData(this),
-      offset: input(offset)
-    });
-  }
-  get [internalSelection]() {
-    const { select } = getData(this);
-    if (!select) throw new Error("No selection defined");
-    return select;
-  }
-  get [internalQuery]() {
-    return sql.chunk("emitSelect", getData(this));
-  }
-  get [internalSql]() {
-    return sql`(${getQuery(this)})`;
-  }
-};
-
-// node_modules/rado/dist/core/query/Update.js
-var Update = class extends Query {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    if (data.returning) this[internalSelection] = data.returning;
-  }
-  get [internalQuery]() {
-    return sql.chunk("emitUpdate", this);
-  }
-};
-var UpdateTable = class _UpdateTable extends Update {
-  set(values) {
-    const { table: table2 } = getData(this);
-    const set = sql.join(
-      Object.entries(values).map(([key, value]) => {
-        const column2 = getTable(table2).columns[key];
-        const { mapToDriverValue } = getData(column2);
-        const expr = value && typeof value === "object" && hasSql(value) ? value : input(mapToDriverValue?.(value) ?? value);
-        return sql`${sql.identifier(key)} = ${expr}`;
-      }),
-      sql`, `
-    );
-    return new _UpdateTable({ ...getData(this), set });
-  }
-  where(...where) {
-    return new _UpdateTable({
-      ...getData(this),
-      where: and(...where)
-    });
-  }
-  returning(returning) {
-    const data = getData(this);
-    return new Update({
-      ...data,
-      returning: returning ? selection(returning) : selection.table(data.table)
-    });
-  }
-};
-
-// node_modules/rado/dist/core/Builder.js
-var BuilderBase = class {
-  [internalData];
-  constructor(data = {}) {
-    this[internalData] = data;
-  }
-  select(input2) {
-    return new Select({
-      ...getData(this),
-      select: input2 && selection(input2)
-    });
-  }
-  selectDistinct(input2) {
-    return new Select({
-      ...getData(this),
-      select: input2 && selection(input2),
-      distinct: true
-    });
-  }
-  selectDistinctOn(columns, input2) {
-    return new Select({
-      ...getData(this),
-      select: input2 && selection(input2),
-      distinctOn: columns
-    });
-  }
-  update(table2) {
-    return new UpdateTable({ ...getData(this), table: table2 });
-  }
-  insert(into) {
-    return new InsertInto({ ...getData(this), into });
-  }
-  delete(from) {
-    return new DeleteFrom({ ...getData(this), from });
-  }
-};
-var Builder = class extends BuilderBase {
-  $with(cteName) {
-    return {
-      as(query) {
-        const fields = getSelection(query).makeVirtual(cteName);
-        return Object.assign(fields, {
-          [internalQuery]: getQuery(query).nameSelf(cteName)
-        });
-      }
-    };
-  }
-  with(...definitions) {
-    return new BuilderBase({
-      ...getData(this),
-      cte: { recursive: false, definitions }
-    });
-  }
-  withRecursive(...definitions) {
-    return new BuilderBase({
-      ...getData(this),
-      cte: { recursive: true, definitions }
-    });
-  }
-};
-
-// 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[i];
-        ctx.index = 0;
-        rows[i] = 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(...tables) {
-    return new QueryBatch(
-      getResolver(this),
-      tables.flatMap((table2) => getTable(table2).create())
-    );
-  }
-  drop(...tables) {
-    return new QueryBatch(
-      getResolver(this),
-      tables.map((table2) => getTable(table2).drop())
-    );
-  }
-  migrate(...tables) {
-    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 QueryBatch(getResolver(this), queries);
-  }
-  execute(input2) {
-    const emitter = this.dialect.emit(input2);
-    if (emitter.hasParams) throw new Error("Query has parameters");
-    return this.driver.exec(emitter.sql);
-  }
-  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 }
-    );
-  }
-};
-var Rollback = class extends Error {
-  constructor(data) {
-    super("Rollback");
-    this.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 boolean(name) {
-  return column({
-    name,
-    type: column.integer(),
-    mapFromDriverValue(value) {
-      return value === 1;
-    },
-    mapToDriverValue(value) {
-      return value ? 1 : 0;
-    }
-  });
-}
-function integer(name) {
-  return column({ name, type: column.integer() });
-}
-function text(name) {
-  return column({ name, type: column.text() });
-}
-
-// 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.emitTo(emitter);
-    return emitter;
-  };
-  inline = (input2) => {
-    const sql2 = hasQuery(input2) ? getQuery(input2) : getSql(input2);
-    const emitter = new this.#createEmitter(this.runtime);
-    sql2.inlineValues().emitTo(emitter);
-    return emitter.sql;
-  };
-};
-
-// node_modules/rado/dist/core/Param.js
-var NamedParam = class {
-  constructor(name) {
-    this.name = name;
-  }
-};
-var ValueParam = class {
-  constructor(value) {
-    this.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);
-    }
-  }
-  selfName;
-  emitSelf({ name, inner }) {
-    this.selfName = name;
-    inner.emitTo(this);
-    this.selfName = void 0;
-  }
-  emitUnsafe(value) {
-    this.sql += value;
-  }
-  emitField({ targetName, fieldName }) {
-    this.emitIdentifierOrSelf(targetName);
-    this.emitUnsafe(".");
-    this.emitIdentifier(fieldName);
-  }
-  emitCreateTable(tableApi) {
-    sql.join([
-      sql`create table`,
-      //ifNotExists ? sql`if not exists` : undefined,
-      tableApi.target(),
-      sql`(${tableApi.createDefinition()})`
-    ]).emitTo(this);
-  }
-  emitColumn(column2) {
-    sql.join([
-      column2.type,
-      column2.primary && sql`primary key`,
-      column2.notNull && sql`not null`,
-      column2.isUnique && sql`unique`,
-      column2.autoIncrement && sql`autoincrement`,
-      column2.defaultValue && sql`default ${column2.defaultValue}`,
-      column2.references && sql`references ${sql.chunk("emitReferences", [column2.references()])}`,
-      column2.onUpdate && sql`on update ${column2.onUpdate}`
-    ]).emitTo(this);
-  }
-  emitReferences(fields) {
-    callFunction(
-      sql.identifier(fields[0].targetName),
-      fields.map((field) => sql.identifier(field.fieldName))
-    ).emitTo(this);
-  }
-  emitDelete(deleteOp) {
-    const { cte, from, where, returning } = getData(deleteOp);
-    if (cte) this.emitWith(cte);
-    const table2 = getTable(from);
-    sql.query({
-      deleteFrom: sql.identifier(table2.name),
-      where,
-      returning
-    }).emitTo(this);
-  }
-  emitInsert(insert) {
-    const {
-      cte,
-      into,
-      values,
-      select,
-      onConflict,
-      onDuplicateKeyUpdate,
-      returning
-    } = getData(insert);
-    if (cte) this.emitWith(cte);
-    const table2 = getTable(into);
-    const tableName = sql.identifier(table2.name);
-    sql.query({
-      insertInto: sql`${tableName}(${table2.listColumns()})`,
-      ...values ? { values } : { "": select },
-      onConflict,
-      onDuplicateKeyUpdate,
-      returning
-    }).inlineFields(false).emitTo(this);
-  }
-  emitSelect({
-    select,
-    cte,
-    from,
-    distinct,
-    distinctOn,
-    where,
-    groupBy,
-    orderBy,
-    having,
-    limit,
-    offset
-  }) {
-    if (cte) this.emitWith(cte);
-    const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
-    sql.query({
-      select: sql.join([prefix, select]),
-      from,
-      where,
-      groupBy,
-      orderBy,
-      having,
-      limit,
-      offset
-    }).emitTo(this);
-  }
-  emitUnion({ left, operator, right }) {
-    sql.join([getQuery(left), operator, getQuery(right)]).emitTo(this);
-  }
-  emitUpdate(update) {
-    const { cte, table: table2, set, where, returning } = getData(update);
-    const tableApi = getTable(table2);
-    if (cte) this.emitWith(cte);
-    sql.query({
-      update: sql.identifier(tableApi.name),
-      set,
-      where,
-      returning
-    }).inlineFields(false).emitTo(this);
-  }
-  emitWith(cte) {
-    sql.query({
-      [cte.recursive ? "withRecursive" : "with"]: sql.join(
-        cte.definitions.map((cte2) => {
-          const query = getQuery(cte2);
-          const target = getTarget(cte2);
-          return sql`${target} as (${query})`;
-        }),
-        sql`, `
-      )
-    }).add(sql` `).emitTo(this);
-  }
-  emitInclude(data) {
-    const wrapQuery = Boolean(data.limit || data.offset || data.orderBy);
-    const innerQuery = sql.chunk("emitSelect", data);
-    const inner = wrapQuery ? sql`select * from (${innerQuery})` : innerQuery;
-    if (!data.select) throw new Error("No selection defined");
-    const fields = data.select.fieldNames();
-    const subject = jsonArray(
-      ...fields.map((name) => sql`_.${sql.identifier(name)}`)
-    );
-    sql`(select ${data.first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`.emitTo(this);
-  }
-  emitUniversal(runtimes) {
-    const sql2 = runtimes[this.#runtime] ?? runtimes.default;
-    if (!sql2) throw new Error("Unsupported runtime");
-    sql2.emitTo(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.sql += "?";
-      this.params.push(new ValueParam(value));
-    }
-    emitJsonPath({ target, asSql, segments }) {
-      target.emitTo(this);
-      this.sql += asSql ? "->>" : "->";
-      this.sql += this.quoteString(
-        `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${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))})`;
-    }
-    emitPlaceholder(name) {
-      this.sql += "?";
-      this.params.push(new NamedParam(name));
-    }
-    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: integer().notNull(),
-  name: text().notNull(),
-  type: text().notNull(),
-  notnull: boolean().notNull(),
-  dflt_value: text(),
-  pk: integer().notNull()
-});
-var SqliteMaster = table("SqliteMaster", {
-  type: text().notNull(),
-  name: text().notNull(),
-  tbl_name: text().notNull(),
-  rootpage: integer().notNull(),
-  sql: text().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"`);
-    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(
-            sql.chunk("emitColumn", {
-              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(sql.chunk("emitColumn", 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 selection2 = 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(selection2).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;
-  }
-  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;
-  }
-  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);
-  }
-  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) {
-    this.stmt = stmt;
-  }
-  all(params) {
-    return this.stmt.all(...params);
-  }
-  run(params) {
-    return this.stmt.run(...params);
-  }
-  get(params) {
-    return this.stmt.get(...params);
-  }
-  values(params) {
-    return this.stmt.values(...params);
-  }
-  free() {
-    this.stmt.finalize();
-  }
-};
-var BunSqliteDriver = class _BunSqliteDriver {
-  constructor(client, depth = 0) {
-    this.client = client;
-    this.depth = depth;
-  }
-  parsesJson = false;
-  supportsTransactions = true;
-  exec(query) {
-    this.client.exec(query);
-  }
-  close() {
-    this.client.close();
-  }
-  prepare(sql2) {
-    return new PreparedStatement3(this.client.prepare(sql2));
-  }
-  batch(queries) {
-    return this.transaction((tx) => {
-      return queries.map(({ sql: sql2, params }) => tx.prepare(sql2).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;
-  }
-  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;
-  }
-  parsesJson = false;
-  supportsTransactions = false;
-  async exec(query) {
-    await this.client.exec(query);
-  }
-  prepare(sql2, options) {
-    return new PreparedStatement4(this.client.prepare(sql2), options.isSelection);
-  }
-  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) => row.results);
-  }
-  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;
-  }
-  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;
-  }
-  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 SINGLE_QUOTE2 = "'";
-var ESCAPE_SINGLE_QUOTE2 = "''";
-var MATCH_SINGLE_QUOTE2 = /'/g;
-var mysqlDialect = new Dialect(
-  "mysql",
-  class extends Emitter {
-    runtime = "mysql";
-    paramIndex = 0;
-    emitValue(value) {
-      this.sql += "?";
-      this.params.push(new ValueParam(value));
-    }
-    emitJsonPath({ target, asSql, segments }) {
-      target.emitTo(this);
-      this.sql += asSql ? "->>" : "->";
-      this.sql += this.quoteString(
-        `$${segments.map((p) => typeof p === "number" ? `[${p}]` : `.${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));
-    }
-    emitPlaceholder(name) {
-      this.sql += "?";
-      this.params.push(new NamedParam(name));
-    }
-    quoteString(input2) {
-      return SINGLE_QUOTE2 + input2.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 integer2(name) {
-  return column({ name, type: column.integer() });
-}
-function text2(name) {
-  return column({ name, type: column.text() });
-}
-
-// node_modules/rado/dist/mysql/diff.js
-var ns = schema("information_schema");
-var Information = ns.table("columns", {
-  table_name: text2().notNull(),
-  column_name: text2().notNull(),
-  column_type: text2().notNull(),
-  is_nullable: text2().notNull(),
-  column_default: text2(),
-  extra: text2().notNull(),
-  table_schema: text2().notNull()
-});
-var Statistics = ns.table("statistics", {
-  table_name: text2().notNull(),
-  column_name: text2().notNull(),
-  index_name: text2().notNull(),
-  non_unique: integer2().notNull(),
-  seq_in_index: integer2().notNull(),
-  table_schema: text2().notNull()
-});
-var TableConstraints = ns.table("table_constraints", {
-  constraint_name: text2().notNull(),
-  table_name: text2().notNull(),
-  constraint_type: text2().notNull(),
-  table_schema: text2().notNull()
-});
-var inline2 = (sql2) => mysqlDialect.inline(sql2);
-var mysqlDiff = (hasTable2) => {
-  return txGenerator(function* (tx) {
-    const tableApi = getTable(hasTable2);
-    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()`)
-    );
-    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,
-            defaultValue: column2.defaultValue && !isAutoIncrement ? sql.unsafe(column2.defaultValue) : void 0
-          }
-        ];
-      })
-    );
-    const schemaColumns = new Map(
-      Object.entries(tableApi.columns).map(([name, column2]) => {
-        const columnApi = getData(column2);
-        return [columnApi.name ?? name, columnApi];
-      })
-    );
-    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, sql.chunk("emitColumn", schemaInstruction)]
-          })
-        );
-      } else {
-        if (inline2(localInstruction.type) !== inline2(schemaInstruction.type)) {
-          stmts.push(
-            sql.query({
-              alterTable,
-              modifyColumn: [column2, schemaInstruction.type]
-            })
-          );
-        }
-        if (Boolean(localInstruction.notNull) !== Boolean(schemaInstruction.notNull)) {
-          stmts.push(
-            sql.query({
-              alterTable,
-              modifyColumn: [
-                column2,
-                schemaInstruction.notNull ? sql`${schemaInstruction.type} not null` : sql`${schemaInstruction.type} 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, name) {
-    this.client = client;
-    this.sql = sql2;
-    this.name = 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) {
-    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;
-  }
-  parsesJson = true;
-  supportsTransactions = true;
-  async exec(query) {
-    await this.client.query(query);
-  }
-  prepare(sql2, options) {
-    return new PreparedStatement6(this.client, sql2, 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 } 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) {
-    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/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";
-    paramIndex = 0;
-    emitValue(value) {
-      this.sql += `$${++this.paramIndex}`;
-      this.params.push(new ValueParam(value));
-    }
-    emitJsonPath({ target, asSql, segments }) {
-      target.emitTo(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));
-    }
-    emitPlaceholder(name) {
-      this.sql += `$${++this.paramIndex}`;
-      this.params.push(new NamedParam(name));
-    }
-    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/columns.js
-function integer3(name) {
-  return column({ name, type: column.integer() });
-}
-function oid(name) {
-  return column({ name, type: column.oid() });
-}
-function boolean2(name) {
-  return column({ name, type: column.boolean() });
-}
-function text3(name) {
-  return column({ name, type: column.text() });
-}
-
-// node_modules/rado/dist/postgres/diff.js
-var Attr = table("pg_attribute", {
-  name: text3("attname").notNull(),
-  typId: oid("atttypid").notNull(),
-  typMod: integer3("atttypmod").notNull(),
-  notNull: boolean2("attnotnull").notNull(),
-  relId: oid("attrelid").notNull(),
-  isDropped: boolean2("attisdropped").notNull(),
-  num: integer3("attnum").notNull(),
-  identity: text3("attidentity"),
-  hasDef: boolean2("atthasdef").notNull()
-});
-var Class = table("pg_class", {
-  oid: oid().notNull(),
-  relname: text3().notNull(),
-  relnamespace: oid().notNull()
-});
-var Namespace = table("pg_namespace", {
-  oid: oid().notNull(),
-  name: text3("nspname").notNull()
-});
-var Type = table("pg_type", {
-  oid: oid().notNull(),
-  name: text3("typname").notNull()
-});
-var AttrDef = table("pg_attrdef", {
-  relId: oid("adrelid").notNull(),
-  num: integer3("adnum").notNull(),
-  bin: text3("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 = (hasTable2) => {
-  return txGenerator(function* (tx) {
-    const tableApi = getTable(hasTable2);
-    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);
-    const localColumns = new Map(
-      columnInfo.map((column2) => {
-        return [
-          column2.name,
-          {
-            type: sql.unsafe(column2.type.toLowerCase()),
-            notNull: column2.notNull,
-            defaultValue: column2.defaultValue ? sql.unsafe(column2.defaultValue) : void 0
-          }
-        ];
-      })
-    );
-    const schemaColumns = new Map(
-      Object.entries(tableApi.columns).map(([name, column2]) => {
-        const columnApi = getData(column2);
-        return [columnApi.name ?? name, columnApi];
-      })
-    );
-    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, sql.chunk("emitColumn", schemaInstruction)]
-          })
-        );
-      } else {
-        if (inline3(localInstruction.type) !== inline3(schemaInstruction.type)) {
-          stmts.push(
-            sql.query({
-              alterTable,
-              alterColumn: [column2, sql`type ${schemaInstruction.type}`]
-            })
-          );
-        }
-        if (Boolean(localInstruction.notNull) !== Boolean(schemaInstruction.notNull)) {
-          stmts.push(
-            sql.query({
-              alterTable,
-              alterColumn: [
-                column2,
-                schemaInstruction.notNull ? sql`set not null` : sql`drop 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
-var PreparedStatement7 = class {
-  constructor(client, sql2, name) {
-    this.client = client;
-    this.sql = sql2;
-    this.name = 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;
-  }
-  parsesJson = true;
-  supportsTransactions = true;
-  async exec(query) {
-    await this.client.query(query);
-  }
-  prepare(sql2, options) {
-    return new PreparedStatement7(this.client, sql2, options?.name);
-  }
-  async close() {
-    if ("end" in this.client) return this.client.end();
-    if ("release" in this.client) return this.client.release();
-  }
-  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 = "totalCount" in this.client ? await this.client.connect() : this.client;
-    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 {
-      if ("release" in client) client.release();
-    }
-  }
-};
-function connect6(client) {
-  return new AsyncDatabase(new PgDriver(client), postgresDialect, postgresDiff);
-}
-
-// node_modules/rado/dist/driver/pglite.js
-var PreparedStatement8 = class {
-  constructor(client, sql2) {
-    this.client = client;
-    this.sql = sql2;
-  }
-  all(params) {
-    return this.client.query(this.sql, params, {
-      rowMode: "object"
-    }).then((res) => res.rows);
-  }
-  async run(params) {
-    await this.client.query(this.sql, params, {
-      rowMode: "array"
-    });
-  }
-  get(params) {
-    return this.all(params).then((rows) => rows[0] ?? null);
-  }
-  values(params) {
-    return this.client.query(this.sql, params, {
-      rowMode: "array"
-    }).then((res) => res.rows);
-  }
-  free() {
-  }
-};
-var PGliteDriver = class _PGliteDriver {
-  constructor(client, depth = 0) {
-    this.client = client;
-    this.depth = depth;
-  }
-  parsesJson = true;
-  supportsTransactions = true;
-  async exec(query) {
-    await this.client.exec(query);
-  }
-  close() {
-    if ("close" in this.client) {
-      return Promise.resolve();
-    }
-    throw new Error("Cannot close a transaction");
-  }
-  prepare(sql2) {
-    return new PreparedStatement8(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 connect7(db) {
-  return new AsyncDatabase(new PGliteDriver(db), postgresDialect, postgresDiff);
-}
-
-// node_modules/rado/dist/driver/sql.js.js
-var PreparedStatement9 = class {
-  constructor(client, stmt) {
-    this.client = client;
-    this.stmt = 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;
-  }
-  parsesJson = false;
-  supportsTransactions = true;
-  exec(query) {
-    this.client.exec(query);
-  }
-  close() {
-    this.client.close();
-  }
-  prepare(sql2) {
-    return new PreparedStatement9(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 connect8(db) {
-  return new SyncDatabase(new SqlJsDriver(db), sqliteDialect, sqliteDiff);
-}
-
-// src/backend/api/CreateBackend.ts
 import { BasicAuth } from "./BasicAuth.js";
 import { DatabaseApi } from "./DatabaseApi.js";
 import { GithubApi } from "./GithubApi.js";
 import { OAuth2 } from "./OAuth2.js";
-function createBackend(config, options) {
+import { S3Uploads } from "./S3Uploads.js";
+function backendFromOptions(options) {
   const db = driver_exports[options.database.driver](options.database.client);
-  return (context) => {
-    const { user } = context;
-    const author = user?.name && user.email ? { name: user.name, email: user.email } : void 0;
-    const ghApi = new GithubApi({
-      author,
-      ...options.github
-    });
+  return (context, config) => {
+    const ghApi = new GithubApi(options.github);
     const dbApi = new DatabaseApi(context, { db });
+    const uploadsApi = options.uploads?.s3 ? new S3Uploads(options.uploads.s3, config.maxUploadSize) : void 0;
     assert(options.oauth2 ?? options.auth, "No auth method provided");
     const auth = options.oauth2 ? new OAuth2(context, config, options.oauth2) : new BasicAuth(context, options.auth);
-    return createRemote(ghApi, dbApi, auth);
+    return composeBackend(ghApi, dbApi, uploadsApi ?? {}, auth);
+  };
+}
+function createBackend(...parts) {
+  return (context, config) => {
+    return composeBackend(
+      ...parts.map(
+        (part) => typeof part === "function" ? part(context, config) : part
+      )
+    );
   };
 }
-function createRemote(...impl) {
-  const reversed = impl.reverse();
+function composeBackend(...impl) {
+  const hasMethod = (name) => {
+    return impl.some((i) => typeof i[name] === "function");
+  };
+  const fallback = {
+    async enrichUser(user) {
+      return user;
+    },
+    async capabilities() {
+      return {
+        users: hasMethod("listUsers")
+      };
+    }
+  };
+  const reversed = [...impl].reverse().concat(fallback);
   const call = (name) => {
     const use = reversed.find((i) => name in i);
     return use ? use[name].bind(use) : () => {
@@ -2520,6 +56,7 @@ function createRemote(...impl) {
   return {
     authenticate: call("authenticate"),
     verify: call("verify"),
+    capabilities: call("capabilities"),
     getTreeIfDifferent: call("getTreeIfDifferent"),
     getBlobs: call("getBlobs"),
     write: call("write"),
@@ -2529,10 +66,16 @@ function createRemote(...impl) {
     storeDraft: call("storeDraft"),
     prepareUpload: call("prepareUpload"),
     handleUpload: call("handleUpload"),
-    previewUpload: call("previewUpload")
+    previewUpload: call("previewUpload"),
+    enrichUser: call("enrichUser"),
+    listUsers: call("listUsers"),
+    createUser: call("createUser"),
+    updateUser: call("updateUser"),
+    removeUser: call("removeUser")
   };
 }
 export {
-  createBackend,
-  createRemote
+  backendFromOptions,
+  composeBackend,
+  createBackend
 };