flint-orm 0.4.1 → 0.4.3

package/dist/src/entries/turso-sync.js

@@ -0,0 +1,3504 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// node_modules/@tursodatabase/database-common/dist/bind.js
+function bindParams(stmt, params) {
+  const len = params?.length;
+  if (len === 0) {
+    return;
+  }
+  if (len === 1) {
+    const param = params[0];
+    if (isPlainObject(param)) {
+      bindNamedParams(stmt, param);
+      return;
+    }
+    if (Array.isArray(param)) {
+      bindPositionalParams(stmt, [param]);
+      return;
+    }
+    bindValue(stmt, 1, param);
+    return;
+  }
+  bindPositionalParams(stmt, params);
+}
+function isPlainObject(obj) {
+  if (!obj || typeof obj !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(obj);
+  return proto === Object.prototype || proto === null;
+}
+function bindNamedParams(stmt, paramObj) {
+  const paramCount = stmt.parameterCount();
+  for (let i = 1;i <= paramCount; i++) {
+    const paramName = stmt.parameterName(i);
+    if (paramName) {
+      const key = paramName.substring(1);
+      const value = paramObj[key];
+      if (value !== undefined) {
+        bindValue(stmt, i, value);
+      }
+    }
+  }
+}
+function bindPositionalParams(stmt, params) {
+  let bindIndex = 1;
+  for (let i = 0;i < params.length; i++) {
+    const param = params[i];
+    if (Array.isArray(param)) {
+      for (let j = 0;j < param.length; j++) {
+        bindValue(stmt, bindIndex++, param[j]);
+      }
+    } else {
+      bindValue(stmt, bindIndex++, param);
+    }
+  }
+}
+function bindValue(stmt, index, value) {
+  stmt.bindAt(index, value);
+}
+
+// node_modules/@tursodatabase/database-common/dist/sqlite-error.js
+var SqliteError;
+var init_sqlite_error = __esm(() => {
+  SqliteError = class SqliteError extends Error {
+    name;
+    code;
+    rawCode;
+    constructor(message, code, rawCode) {
+      super(message);
+      this.name = "SqliteError";
+      this.code = code;
+      this.rawCode = rawCode;
+      Error.captureStackTrace(this, SqliteError);
+    }
+  };
+});
+
+// node_modules/@tursodatabase/database-common/dist/types.js
+var STEP_ROW = 1, STEP_DONE = 2, STEP_IO = 3;
+
+// node_modules/@tursodatabase/database-common/dist/compat.js
+var init_compat = __esm(() => {
+  init_sqlite_error();
+});
+
+// node_modules/@tursodatabase/database-common/dist/async-lock.js
+class AsyncLock {
+  locked;
+  queue;
+  constructor() {
+    this.locked = false;
+    this.queue = [];
+  }
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return Promise.resolve();
+    } else {
+      const block = new Promise((resolve) => {
+        this.queue.push(resolve);
+      });
+      return block;
+    }
+  }
+  release() {
+    if (this.locked == false) {
+      throw new Error("invalid state: lock was already unlocked");
+    }
+    const item = this.queue.shift();
+    if (item != null) {
+      this.locked = true;
+      item();
+    } else {
+      this.locked = false;
+    }
+  }
+}
+
+// node_modules/@tursodatabase/database-common/dist/promise.js
+function convertError(err) {
+  if ((err.code ?? "").startsWith(CONVERTIBLE_ERROR_PREFIX)) {
+    return createErrorByName(err.code.substring(CONVERTIBLE_ERROR_PREFIX.length), err.message);
+  }
+  return new SqliteError(err.message, err.code, err.rawCode);
+}
+function createErrorByName(name, message) {
+  const ErrorConstructor = convertibleErrorTypes[name];
+  if (!ErrorConstructor) {
+    throw new Error(`unknown error type ${name} from Turso`);
+  }
+  return new ErrorConstructor(message);
+}
+function isQueryOptions(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, "queryTimeout");
+}
+function splitBindParameters(bindParameters) {
+  if (bindParameters.length === 0) {
+    return { params: undefined, queryOptions: undefined };
+  }
+  if (bindParameters.length > 1 && isQueryOptions(bindParameters[bindParameters.length - 1])) {
+    return {
+      params: bindParameters.length === 2 ? bindParameters[0] : bindParameters.slice(0, -1),
+      queryOptions: bindParameters[bindParameters.length - 1]
+    };
+  }
+  return { params: bindParameters.length === 1 ? bindParameters[0] : bindParameters, queryOptions: undefined };
+}
+function toBindArgs(params) {
+  if (params === undefined) {
+    return [];
+  }
+  return [params];
+}
+
+class Database {
+  name;
+  readonly;
+  open;
+  memory;
+  inTransaction;
+  db;
+  ioStep;
+  execLock;
+  _inTransaction = false;
+  connected = false;
+  constructor(db, ioStep) {
+    this.db = db;
+    this.execLock = new AsyncLock;
+    this.ioStep = ioStep ?? (async () => {});
+    Object.defineProperties(this, {
+      name: { get: () => this.db.path },
+      readonly: { get: () => this.db.readonly },
+      open: { get: () => this.db.open },
+      memory: { get: () => this.db.memory },
+      inTransaction: { get: () => this._inTransaction }
+    });
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    await this.db.connectAsync();
+    this.connected = true;
+  }
+  prepare(sql) {
+    if (this.connected && !this.open) {
+      throw new TypeError("The database connection is not open");
+    }
+    if (!sql) {
+      throw new RangeError("The supplied SQL string contains no statements");
+    }
+    try {
+      if (this.connected) {
+        return new Statement(maybeValue(this.db.prepare(sql)), this.db, this.execLock, this.ioStep);
+      } else {
+        return new Statement(maybePromise(() => this.connect().then(() => this.db.prepare(sql))), this.db, this.execLock, this.ioStep);
+      }
+    } catch (err) {
+      throw convertError(err);
+    }
+  }
+  transaction(fn) {
+    if (typeof fn !== "function")
+      throw new TypeError("Expected first argument to be a function");
+    const db = this;
+    const wrapTxn = (mode) => {
+      return async (...bindParameters) => {
+        await db.exec("BEGIN " + mode);
+        db._inTransaction = true;
+        try {
+          const result = await fn(...bindParameters);
+          await db.exec("COMMIT");
+          db._inTransaction = false;
+          return result;
+        } catch (err) {
+          await db.exec("ROLLBACK");
+          db._inTransaction = false;
+          throw err;
+        }
+      };
+    };
+    const properties = {
+      default: { value: wrapTxn("") },
+      deferred: { value: wrapTxn("DEFERRED") },
+      immediate: { value: wrapTxn("IMMEDIATE") },
+      exclusive: { value: wrapTxn("EXCLUSIVE") },
+      database: { value: this, enumerable: true }
+    };
+    Object.defineProperties(properties.default.value, properties);
+    Object.defineProperties(properties.deferred.value, properties);
+    Object.defineProperties(properties.immediate.value, properties);
+    Object.defineProperties(properties.exclusive.value, properties);
+    return properties.default.value;
+  }
+  async run(sql, ...bindParameters) {
+    const stmt = await this.prepare(sql);
+    try {
+      return await stmt.run(...bindParameters);
+    } finally {
+      await stmt.close();
+    }
+  }
+  async get(sql, ...bindParameters) {
+    const stmt = await this.prepare(sql);
+    try {
+      return await stmt.get(...bindParameters);
+    } finally {
+      await stmt.close();
+    }
+  }
+  async all(sql, ...bindParameters) {
+    const stmt = await this.prepare(sql);
+    try {
+      return await stmt.all(...bindParameters);
+    } finally {
+      await stmt.close();
+    }
+  }
+  async* iterate(sql, ...bindParameters) {
+    const stmt = await this.prepare(sql);
+    try {
+      yield* stmt.iterate(...bindParameters);
+    } finally {
+      await stmt.close();
+    }
+  }
+  async pragma(source, options) {
+    if (options == null)
+      options = {};
+    if (typeof source !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    const pragma = `PRAGMA ${source}`;
+    const stmt = await this.prepare(pragma);
+    try {
+      const results = await stmt.all();
+      return results;
+    } finally {
+      await stmt.close();
+    }
+  }
+  backup(filename, options) {
+    throw new Error("not implemented");
+  }
+  serialize(options) {
+    throw new Error("not implemented");
+  }
+  function(name, options, fn) {
+    throw new Error("not implemented");
+  }
+  aggregate(name, options) {
+    throw new Error("not implemented");
+  }
+  table(name, factory) {
+    throw new Error("not implemented");
+  }
+  loadExtension(path) {
+    throw new Error("not implemented");
+  }
+  maxWriteReplicationIndex() {
+    throw new Error("not implemented");
+  }
+  async exec(sql, queryOptions) {
+    if (!this.open) {
+      throw new TypeError("The database connection is not open");
+    }
+    await this.execLock.acquire();
+    const exec = this.db.executor(sql, queryOptions);
+    try {
+      while (true) {
+        const stepResult = exec.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          continue;
+        }
+      }
+    } finally {
+      exec.reset();
+      this.execLock.release();
+    }
+  }
+  interrupt() {
+    throw new Error("not implemented");
+  }
+  defaultSafeIntegers(toggle) {
+    this.db.defaultSafeIntegers(toggle);
+  }
+  async close() {
+    this.db.close();
+  }
+  async io() {
+    await this.ioStep();
+  }
+}
+function maybePromise(arg) {
+  let lazy = arg;
+  let promise = null;
+  let value = null;
+  return {
+    apply(fn) {
+      let previous = lazy;
+      lazy = async () => {
+        const result = await previous();
+        fn(result);
+        return result;
+      };
+    },
+    async resolve() {
+      if (promise != null) {
+        return await promise;
+      }
+      let valueResolve, valueReject;
+      promise = new Promise((resolve, reject) => {
+        valueResolve = (x) => {
+          resolve(x);
+          value = x;
+        };
+        valueReject = reject;
+      });
+      await lazy().then(valueResolve, valueReject);
+      return await promise;
+    },
+    must() {
+      if (value == null) {
+        throw new Error(`database must be connected before execution the function`);
+      }
+      return value;
+    }
+  };
+}
+function maybeValue(value) {
+  return {
+    apply(fn) {
+      fn(value);
+    },
+    resolve() {
+      return Promise.resolve(value);
+    },
+    must() {
+      return value;
+    }
+  };
+}
+
+class Statement {
+  stmt;
+  db;
+  execLock;
+  ioStep;
+  constructor(stmt, db, execLock, ioStep) {
+    this.stmt = stmt;
+    this.db = db;
+    this.execLock = execLock;
+    this.ioStep = ioStep;
+  }
+  raw(raw) {
+    this.stmt.apply((s) => s.raw(raw));
+    return this;
+  }
+  pluck(pluckMode) {
+    this.stmt.apply((s) => s.pluck(pluckMode));
+    return this;
+  }
+  safeIntegers(toggle) {
+    this.stmt.apply((s) => s.safeIntegers(toggle));
+    return this;
+  }
+  columns() {
+    return this.stmt.must().columns();
+  }
+  get source() {
+    throw new Error("not implemented");
+  }
+  get reader() {
+    return this.stmt.must().columns().length > 0;
+  }
+  get database() {
+    return this.db;
+  }
+  async run(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    stmt.setQueryTimeout(queryOptions);
+    bindParams(stmt, toBindArgs(params));
+    const totalChangesBefore = this.db.totalChanges();
+    await this.execLock.acquire();
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          continue;
+        }
+      }
+      const lastInsertRowid = this.db.lastInsertRowid();
+      const changes = this.db.totalChanges() === totalChangesBefore ? 0 : this.db.changes();
+      return { changes, lastInsertRowid };
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async get(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    stmt.setQueryTimeout(queryOptions);
+    bindParams(stmt, toBindArgs(params));
+    await this.execLock.acquire();
+    let row = undefined;
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW && row === undefined) {
+          row = stmt.row();
+          continue;
+        }
+      }
+      return row;
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async* iterate(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    stmt.setQueryTimeout(queryOptions);
+    bindParams(stmt, toBindArgs(params));
+    await this.execLock.acquire();
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          yield stmt.row();
+        }
+      }
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async all(...bindParameters) {
+    let stmt = await this.stmt.resolve();
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    stmt.setQueryTimeout(queryOptions);
+    bindParams(stmt, toBindArgs(params));
+    const rows = [];
+    await this.execLock.acquire();
+    try {
+      while (true) {
+        const stepResult = await stmt.stepSync();
+        if (stepResult === STEP_IO) {
+          await this.io();
+          continue;
+        }
+        if (stepResult === STEP_DONE) {
+          break;
+        }
+        if (stepResult === STEP_ROW) {
+          rows.push(stmt.row());
+        }
+      }
+      return rows;
+    } finally {
+      stmt.reset();
+      this.execLock.release();
+    }
+  }
+  async io() {
+    await this.ioStep();
+  }
+  interrupt() {
+    throw new Error("not implemented");
+  }
+  bind(...bindParameters) {
+    try {
+      bindParams(this.stmt, bindParameters);
+      return this;
+    } catch (err) {
+      throw convertError(err);
+    }
+  }
+  close() {
+    let stmt;
+    try {
+      stmt = this.stmt.must();
+    } catch (e) {
+      return;
+    }
+    stmt.finalize();
+  }
+}
+var convertibleErrorTypes, CONVERTIBLE_ERROR_PREFIX = "[TURSO_CONVERT_TYPE]";
+var init_promise = __esm(() => {
+  init_sqlite_error();
+  convertibleErrorTypes = { TypeError };
+});
+
+// node_modules/@tursodatabase/database-common/dist/index.js
+var init_dist = __esm(() => {
+  init_compat();
+  init_promise();
+  init_sqlite_error();
+});
+
+// node_modules/@tursodatabase/sync-common/dist/run.js
+function trackPromise(p) {
+  let status = { promise: null, finished: false };
+  status.promise = p.finally(() => status.finished = true);
+  return status;
+}
+function timeoutMs(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeUrl(url) {
+  return url.replace(/^libsql:\/\//, "https://");
+}
+async function process2(opts, io, request) {
+  const requestType = request.request();
+  const completion = request.completion();
+  if (requestType.type == "Http") {
+    let url = requestType.url;
+    if (typeof opts.url == "function") {
+      url = opts.url();
+    } else {
+      url = opts.url;
+    }
+    if (url == null) {
+      completion.poison(`url is empty - sync is paused`);
+      return;
+    }
+    url = normalizeUrl(url);
+    try {
+      let headers = typeof opts.headers === "function" ? await opts.headers() : opts.headers;
+      if (requestType.headers != null && requestType.headers.length > 0) {
+        headers = { ...headers };
+        for (let header of requestType.headers) {
+          headers[header[0]] = header[1];
+        }
+      }
+      const fetchImpl = opts.fetch ?? fetch;
+      const response = await fetchImpl(`${url}${requestType.path}`, {
+        method: requestType.method,
+        headers,
+        body: requestType.body != null ? new Uint8Array(requestType.body) : null
+      });
+      completion.status(response.status);
+      const reader = response.body?.getReader();
+      if (reader == null) {
+        throw new Error("reader is null");
+      }
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          completion.done();
+          break;
+        }
+        completion.pushBuffer(value);
+      }
+    } catch (error) {
+      completion.poison(`fetch error: ${error}`);
+    }
+  } else if (requestType.type == "FullRead") {
+    try {
+      const metadata = await io.read(requestType.path);
+      if (metadata != null) {
+        completion.pushBuffer(metadata);
+      }
+      completion.done();
+    } catch (error) {
+      completion.poison(`metadata read error: ${error}`);
+    }
+  } else if (requestType.type == "FullWrite") {
+    try {
+      await io.write(requestType.path, requestType.content);
+      completion.done();
+    } catch (error) {
+      completion.poison(`metadata write error: ${error}`);
+    }
+  } else if (requestType.type == "Transform") {
+    if (opts.transform == null) {
+      completion.poison("transform is not set");
+      return;
+    }
+    const results = [];
+    for (const mutation of requestType.mutations) {
+      const result = opts.transform(mutation);
+      if (result == null) {
+        results.push({ type: "Keep" });
+      } else if (result.operation == "skip") {
+        results.push({ type: "Skip" });
+      } else if (result.operation == "rewrite") {
+        results.push({ type: "Rewrite", stmt: result.stmt });
+      } else {
+        completion.poison("unexpected transform operation");
+        return;
+      }
+    }
+    completion.pushTransform(results);
+    completion.done();
+  }
+}
+function retryFetch(opts = {}) {
+  const attempts = opts.attempts ?? 3;
+  const baseDelay = opts.delayMs ?? 500;
+  const backoff = opts.backoff ?? 2;
+  const underlying = opts.fetch ?? ((input, init) => fetch(input, init));
+  if (!Number.isFinite(attempts) || attempts < 1) {
+    throw new Error(`retryFetch: attempts must be a finite integer >= 1, got ${attempts}`);
+  }
+  return async (input, init) => {
+    let lastError = null;
+    let lastResponse = null;
+    let delay = baseDelay;
+    for (let i = 0;i < attempts; i++) {
+      try {
+        const response = await underlying(input, init);
+        if (response.status < 500 && response.status !== 429) {
+          return response;
+        }
+        lastResponse = response;
+        lastError = null;
+      } catch (error) {
+        lastError = error;
+        lastResponse = null;
+      }
+      if (i + 1 < attempts) {
+        await timeoutMs(delay);
+        delay *= backoff;
+      }
+    }
+    if (lastResponse != null) {
+      return lastResponse;
+    }
+    throw lastError ?? new Error("retryFetch: exhausted with no response");
+  };
+}
+function runner(opts, io, engine) {
+  let tasks = [];
+  return {
+    async wait() {
+      for (let request = engine.protocolIo();request != null; request = engine.protocolIo()) {
+        tasks.push(trackPromise(process2(opts, io, request)));
+      }
+      const tasksRace = tasks.length == 0 ? Promise.resolve() : Promise.race([timeoutMs(opts.preemptionMs), ...tasks.map((t) => t.promise)]);
+      await Promise.all([engine.ioLoopAsync(), tasksRace]);
+      tasks = tasks.filter((t) => !t.finished);
+      engine.protocolIoStep();
+    }
+  };
+}
+async function run(runner2, generator) {
+  while (true) {
+    const { type, ...rest } = await generator.resumeAsync(null);
+    if (type == "Done") {
+      return null;
+    }
+    if (type == "SyncEngineStats") {
+      return rest;
+    }
+    if (type == "SyncEngineChanges") {
+      return rest.changes;
+    }
+    await runner2.wait();
+  }
+}
+
+class SyncEngineGuards {
+  waitLock;
+  pushLock;
+  pullLock;
+  checkpointLock;
+  constructor() {
+    this.waitLock = new AsyncLock;
+    this.pushLock = new AsyncLock;
+    this.pullLock = new AsyncLock;
+    this.checkpointLock = new AsyncLock;
+  }
+  async wait(f) {
+    try {
+      await this.waitLock.acquire();
+      return await f();
+    } finally {
+      this.waitLock.release();
+    }
+  }
+  async push(f) {
+    try {
+      await this.pushLock.acquire();
+      await this.pullLock.acquire();
+      await this.checkpointLock.acquire();
+      return await f();
+    } finally {
+      this.pushLock.release();
+      this.pullLock.release();
+      this.checkpointLock.release();
+    }
+  }
+  async apply(f) {
+    try {
+      await this.waitLock.acquire();
+      await this.pushLock.acquire();
+      await this.pullLock.acquire();
+      await this.checkpointLock.acquire();
+      return await f();
+    } finally {
+      this.waitLock.release();
+      this.pushLock.release();
+      this.pullLock.release();
+      this.checkpointLock.release();
+    }
+  }
+  async checkpoint(f) {
+    try {
+      await this.waitLock.acquire();
+      await this.pushLock.acquire();
+      await this.pullLock.acquire();
+      await this.checkpointLock.acquire();
+      return await f();
+    } finally {
+      this.waitLock.release();
+      this.pushLock.release();
+      this.pullLock.release();
+      this.checkpointLock.release();
+    }
+  }
+}
+var init_run = __esm(() => {
+  init_dist();
+});
+// node_modules/@tursodatabase/serverless/dist/error.js
+var DatabaseError;
+var init_error = __esm(() => {
+  DatabaseError = class DatabaseError extends Error {
+    constructor(message, code, rawCode, cause) {
+      super(message);
+      this.name = "DatabaseError";
+      this.code = code;
+      this.rawCode = rawCode;
+      this.cause = cause;
+      Object.setPrototypeOf(this, DatabaseError.prototype);
+    }
+  };
+});
+
+// node_modules/@tursodatabase/serverless/dist/protocol.js
+function encodeValue(value) {
+  if (value === null || value === undefined) {
+    return { type: "null" };
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Only finite numbers (not Infinity or NaN) can be passed as arguments");
+    }
+    return { type: "float", value };
+  }
+  if (typeof value === "bigint") {
+    return { type: "integer", value: value.toString() };
+  }
+  if (typeof value === "boolean") {
+    return { type: "integer", value: value ? "1" : "0" };
+  }
+  if (typeof value === "string") {
+    return { type: "text", value };
+  }
+  if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
+    const base64 = btoa(String.fromCharCode(...new Uint8Array(value)));
+    return { type: "blob", base64 };
+  }
+  return { type: "text", value: String(value) };
+}
+function decodeValue(value, safeIntegers = false) {
+  switch (value.type) {
+    case "null":
+      return null;
+    case "integer":
+      if (safeIntegers) {
+        return BigInt(value.value);
+      }
+      return parseInt(value.value, 10);
+    case "float":
+      return value.value;
+    case "text":
+      return value.value;
+    case "blob":
+      if (value.base64) {
+        const binaryString = atob(value.base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0;i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return Buffer.from(bytes);
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+async function executeCursor(url, authToken, request, remoteEncryptionKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (authToken) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  if (remoteEncryptionKey) {
+    headers[ENCRYPTION_KEY_HEADER] = remoteEncryptionKey;
+  }
+  const response = await fetch(`${url}/v3/cursor`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    let errorMessage = `HTTP error! status: ${response.status}`;
+    try {
+      const errorBody = await response.text();
+      const errorData = JSON.parse(errorBody);
+      if (errorData.message) {
+        errorMessage = errorData.message;
+      }
+    } catch {}
+    throw new DatabaseError(errorMessage);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new DatabaseError("No response body");
+  }
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let cursorResponse;
+  while (!cursorResponse) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    const newlineIndex = buffer.indexOf(`
+`);
+    if (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line) {
+        cursorResponse = JSON.parse(line);
+        break;
+      }
+    }
+  }
+  if (!cursorResponse) {
+    throw new DatabaseError("No cursor response received");
+  }
+  async function* parseEntries() {
+    try {
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf(`
+`)) !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) {
+          yield JSON.parse(line);
+        }
+      }
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: true });
+        while ((newlineIndex = buffer.indexOf(`
+`)) !== -1) {
+          const line = buffer.slice(0, newlineIndex).trim();
+          buffer = buffer.slice(newlineIndex + 1);
+          if (line) {
+            yield JSON.parse(line);
+          }
+        }
+      }
+      if (buffer.trim()) {
+        yield JSON.parse(buffer.trim());
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  return { response: cursorResponse, entries: parseEntries() };
+}
+async function executePipeline(url, authToken, request, remoteEncryptionKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (authToken) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  if (remoteEncryptionKey) {
+    headers[ENCRYPTION_KEY_HEADER] = remoteEncryptionKey;
+  }
+  const response = await fetch(`${url}/v3/pipeline`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    throw new DatabaseError(`HTTP error! status: ${response.status}`);
+  }
+  return response.json();
+}
+var ENCRYPTION_KEY_HEADER = "x-turso-encryption-key";
+var init_protocol = __esm(() => {
+  init_error();
+});
+
+// node_modules/@tursodatabase/serverless/dist/session.js
+function normalizeUrl2(url) {
+  return url.replace(/^libsql:\/\//, "https://");
+}
+function isValidIdentifier(str) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
+}
+
+class Session {
+  constructor(config) {
+    this.baton = null;
+    this.config = config;
+    this.baseUrl = normalizeUrl2(config.url);
+  }
+  async describe(sql) {
+    const request = {
+      baton: this.baton,
+      requests: [{
+        type: "describe",
+        sql
+      }]
+    };
+    const response = await executePipeline(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey);
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    if (response.results && response.results[0]) {
+      const result = response.results[0];
+      if (result.type === "error") {
+        throw new DatabaseError(result.error?.message || "Describe execution failed", result.error?.code);
+      }
+      if (result.response?.type === "describe" && result.response.result) {
+        return result.response.result;
+      }
+    }
+    throw new DatabaseError("Unexpected describe response");
+  }
+  async execute(sql, args = [], safeIntegers = false) {
+    const { response, entries } = await this.executeRaw(sql, args);
+    const result = await this.processCursorEntries(entries, safeIntegers);
+    return result;
+  }
+  async executeRaw(sql, args = []) {
+    let positionalArgs = [];
+    let namedArgs = [];
+    if (Array.isArray(args)) {
+      positionalArgs = args.map(encodeValue);
+    } else {
+      const keys = Object.keys(args);
+      const isNumericKeys = keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
+      if (isNumericKeys) {
+        const sortedKeys = keys.sort((a, b) => parseInt(a) - parseInt(b));
+        const maxIndex = parseInt(sortedKeys[sortedKeys.length - 1]);
+        positionalArgs = new Array(maxIndex);
+        for (const key of sortedKeys) {
+          const index = parseInt(key) - 1;
+          positionalArgs[index] = encodeValue(args[key]);
+        }
+        for (let i = 0;i < positionalArgs.length; i++) {
+          if (positionalArgs[i] === undefined) {
+            positionalArgs[i] = { type: "null" };
+          }
+        }
+      } else {
+        namedArgs = Object.entries(args).map(([name, value]) => ({
+          name,
+          value: encodeValue(value)
+        }));
+      }
+    }
+    const request = {
+      baton: this.baton,
+      batch: {
+        steps: [{
+          stmt: {
+            sql,
+            args: positionalArgs,
+            named_args: namedArgs,
+            want_rows: true
+          }
+        }]
+      }
+    };
+    const { response, entries } = await executeCursor(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey);
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    return { response, entries };
+  }
+  async processCursorEntries(entries, safeIntegers = false) {
+    let columns = [];
+    let columnTypes = [];
+    let rows = [];
+    let rowsAffected = 0;
+    let lastInsertRowid;
+    for await (const entry of entries) {
+      switch (entry.type) {
+        case "step_begin":
+          if (entry.cols) {
+            columns = entry.cols.map((col) => col.name);
+            columnTypes = entry.cols.map((col) => col.decltype || "");
+          }
+          break;
+        case "row":
+          if (entry.row) {
+            const decodedRow = entry.row.map((value) => decodeValue(value, safeIntegers));
+            const rowObject = this.createRowObject(decodedRow, columns);
+            rows.push(rowObject);
+          }
+          break;
+        case "step_end":
+          if (entry.affected_row_count !== undefined) {
+            rowsAffected = entry.affected_row_count;
+          }
+          if (entry.last_insert_rowid) {
+            lastInsertRowid = parseInt(entry.last_insert_rowid, 10);
+          }
+          break;
+        case "step_error":
+        case "error":
+          throw new DatabaseError(entry.error?.message || "SQL execution failed", entry.error?.code);
+      }
+    }
+    return {
+      columns,
+      columnTypes,
+      rows,
+      rowsAffected,
+      lastInsertRowid
+    };
+  }
+  createRowObject(values, columns) {
+    const row = [...values];
+    columns.forEach((column, index) => {
+      if (column && isValidIdentifier(column)) {
+        Object.defineProperty(row, column, {
+          value: values[index],
+          enumerable: false,
+          writable: false,
+          configurable: true
+        });
+      }
+    });
+    return row;
+  }
+  async batch(statements) {
+    const request = {
+      baton: this.baton,
+      batch: {
+        steps: statements.map((sql) => ({
+          stmt: {
+            sql,
+            args: [],
+            named_args: [],
+            want_rows: false
+          }
+        }))
+      }
+    };
+    const { response, entries } = await executeCursor(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey);
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    let totalRowsAffected = 0;
+    let lastInsertRowid;
+    for await (const entry of entries) {
+      switch (entry.type) {
+        case "step_end":
+          if (entry.affected_row_count !== undefined) {
+            totalRowsAffected += entry.affected_row_count;
+          }
+          if (entry.last_insert_rowid) {
+            lastInsertRowid = parseInt(entry.last_insert_rowid, 10);
+          }
+          break;
+        case "step_error":
+        case "error":
+          throw new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
+      }
+    }
+    return {
+      rowsAffected: totalRowsAffected,
+      lastInsertRowid
+    };
+  }
+  async sequence(sql) {
+    const request = {
+      baton: this.baton,
+      requests: [{
+        type: "sequence",
+        sql
+      }]
+    };
+    const response = await executePipeline(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey);
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    if (response.results && response.results[0]) {
+      const result = response.results[0];
+      if (result.type === "error") {
+        throw new DatabaseError(result.error?.message || "Sequence execution failed", result.error?.code);
+      }
+    }
+  }
+  async close() {
+    if (this.baton) {
+      try {
+        const request = {
+          baton: this.baton,
+          requests: [{
+            type: "close"
+          }]
+        };
+        await executePipeline(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey);
+      } catch (error) {
+        console.error("Error closing session:", error);
+      }
+    }
+    this.baton = null;
+    this.baseUrl = "";
+  }
+}
+var init_session = __esm(() => {
+  init_protocol();
+  init_error();
+});
+
+// node_modules/@tursodatabase/serverless/dist/statement.js
+var init_statement = __esm(() => {
+  init_protocol();
+  init_session();
+  init_error();
+});
+
+// node_modules/@tursodatabase/serverless/dist/connection.js
+var init_connection = __esm(() => {
+  init_session();
+  init_statement();
+});
+
+// node_modules/@tursodatabase/serverless/dist/index.js
+var init_dist2 = __esm(() => {
+  init_connection();
+  init_statement();
+  init_session();
+  init_error();
+  init_protocol();
+});
+
+// node_modules/@tursodatabase/sync-common/dist/remote-writer.js
+class RemoteWriter {
+  session = null;
+  _inRemoteTxn = false;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async resolveAuthToken() {
+    if (typeof this.config.authToken === "function") {
+      return await this.config.authToken();
+    }
+    return this.config.authToken;
+  }
+  async createSession() {
+    const authToken = await this.resolveAuthToken();
+    const sessionConfig = {
+      url: this.config.url,
+      authToken,
+      remoteEncryptionKey: this.config.remoteEncryptionKey
+    };
+    return new Session(sessionConfig);
+  }
+  async execute(sql, args = []) {
+    if (this._inRemoteTxn) {
+      return await this.session.execute(sql, args);
+    }
+    const session = await this.createSession();
+    try {
+      return await session.execute(sql, args);
+    } finally {
+      await session.close();
+    }
+  }
+  async sequence(sql) {
+    if (this._inRemoteTxn) {
+      await this.session.sequence(sql);
+      return;
+    }
+    const session = await this.createSession();
+    try {
+      await session.sequence(sql);
+    } finally {
+      await session.close();
+    }
+  }
+  async beginTransaction(mode) {
+    this.session = await this.createSession();
+    await this.session.sequence("BEGIN " + mode);
+    this._inRemoteTxn = true;
+  }
+  async commitTransaction() {
+    if (!this.session) {
+      throw new Error("No active remote transaction");
+    }
+    try {
+      await this.session.sequence("COMMIT");
+    } finally {
+      this._inRemoteTxn = false;
+      await this.session.close();
+      this.session = null;
+    }
+  }
+  async rollbackTransaction() {
+    if (!this.session) {
+      throw new Error("No active remote transaction");
+    }
+    try {
+      await this.session.sequence("ROLLBACK");
+    } finally {
+      this._inRemoteTxn = false;
+      await this.session.close();
+      this.session = null;
+    }
+  }
+  async execRemote(sql, category) {
+    if (category === "begin") {
+      this.session = await this.createSession();
+      await this.session.sequence(sql);
+      this._inRemoteTxn = true;
+      return { shouldPull: false };
+    }
+    if (category === "commit") {
+      if (!this.session)
+        throw new Error("No active remote transaction");
+      try {
+        await this.session.sequence(sql);
+      } finally {
+        this._inRemoteTxn = false;
+        await this.session.close();
+        this.session = null;
+      }
+      return { shouldPull: true };
+    }
+    if (category === "rollback") {
+      if (!this.session)
+        throw new Error("No active remote transaction");
+      try {
+        await this.session.sequence(sql);
+      } finally {
+        this._inRemoteTxn = false;
+        await this.session.close();
+        this.session = null;
+      }
+      return { shouldPull: false };
+    }
+    await this.sequence(sql);
+    return { shouldPull: !this._inRemoteTxn };
+  }
+  get isInTransaction() {
+    return this._inRemoteTxn;
+  }
+  async close() {
+    if (this.session) {
+      try {
+        if (this._inRemoteTxn) {
+          await this.session.sequence("ROLLBACK");
+        }
+      } catch {}
+      await this.session.close();
+      this.session = null;
+      this._inRemoteTxn = false;
+    }
+  }
+}
+var init_remote_writer = __esm(() => {
+  init_dist2();
+});
+
+// node_modules/@tursodatabase/sync-common/dist/remote-write-statement.js
+class RemoteWriteStatement {
+  localStmt;
+  sql;
+  isStmtReadonly;
+  remoteWriter;
+  pullFn;
+  _boundArgs = [];
+  constructor(localStmt, sql, isStmtReadonly, remoteWriter, pullFn) {
+    this.localStmt = localStmt;
+    this.sql = sql;
+    this.isStmtReadonly = isStmtReadonly;
+    this.remoteWriter = remoteWriter;
+    this.pullFn = pullFn;
+  }
+  shouldGoRemote() {
+    return this.remoteWriter.isInTransaction || !this.isStmtReadonly;
+  }
+  shouldPullAfter() {
+    return !this.isStmtReadonly && !this.remoteWriter.isInTransaction;
+  }
+  raw(toggle) {
+    this.localStmt.raw(toggle);
+    return this;
+  }
+  pluck(toggle) {
+    this.localStmt.pluck(toggle);
+    return this;
+  }
+  safeIntegers(toggle) {
+    this.localStmt.safeIntegers(toggle);
+    return this;
+  }
+  columns() {
+    return this.localStmt.columns();
+  }
+  get reader() {
+    return this.localStmt.reader;
+  }
+  bind(...bindParameters) {
+    this._boundArgs = flattenArgs(bindParameters);
+    this.localStmt.bind(...bindParameters);
+    return this;
+  }
+  async run(...bindParameters) {
+    if (!this.shouldGoRemote()) {
+      return await this.localStmt.run(...bindParameters);
+    }
+    const args = bindParameters.length > 0 ? flattenArgs(bindParameters) : this._boundArgs;
+    const result = await this.remoteWriter.execute(this.sql, args);
+    if (this.shouldPullAfter()) {
+      await this.pullFn();
+    }
+    return {
+      changes: result.rowsAffected,
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+  async get(...bindParameters) {
+    if (!this.shouldGoRemote()) {
+      return await this.localStmt.get(...bindParameters);
+    }
+    const args = bindParameters.length > 0 ? flattenArgs(bindParameters) : this._boundArgs;
+    const result = await this.remoteWriter.execute(this.sql, args);
+    if (this.shouldPullAfter()) {
+      await this.pullFn();
+    }
+    return result.rows.length > 0 ? result.rows[0] : undefined;
+  }
+  async all(...bindParameters) {
+    if (!this.shouldGoRemote()) {
+      return await this.localStmt.all(...bindParameters);
+    }
+    const args = bindParameters.length > 0 ? flattenArgs(bindParameters) : this._boundArgs;
+    const result = await this.remoteWriter.execute(this.sql, args);
+    if (this.shouldPullAfter()) {
+      await this.pullFn();
+    }
+    return result.rows;
+  }
+  async* iterate(...bindParameters) {
+    if (!this.shouldGoRemote()) {
+      yield* this.localStmt.iterate(...bindParameters);
+      return;
+    }
+    const args = bindParameters.length > 0 ? flattenArgs(bindParameters) : this._boundArgs;
+    const result = await this.remoteWriter.execute(this.sql, args);
+    if (this.shouldPullAfter()) {
+      await this.pullFn();
+    }
+    for (const row of result.rows) {
+      yield row;
+    }
+  }
+  close() {
+    this.localStmt.close();
+  }
+}
+function flattenArgs(bindParameters) {
+  if (bindParameters.length === 1 && Array.isArray(bindParameters[0])) {
+    return bindParameters[0];
+  }
+  return bindParameters;
+}
+
+// node_modules/@tursodatabase/sync-common/dist/index.js
+var init_dist3 = __esm(() => {
+  init_run();
+  init_remote_writer();
+});
+
+// node_modules/@tursodatabase/sync/index.js
+import { createRequire } from "module";
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require2(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err);
+    }
+  } else if (process.platform === "android") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./sync.android-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-android-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-android-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./sync.android-arm-eabi.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-android-arm-eabi");
+        const bindingPackageVersion = require2("@tursodatabase/sync-android-arm-eabi/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+    }
+  } else if (process.platform === "win32") {
+    if (process.arch === "x64") {
+      try {
+        return require2("./sync.win32-x64-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-win32-x64-msvc");
+        const bindingPackageVersion = require2("@tursodatabase/sync-win32-x64-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "ia32") {
+      try {
+        return require2("./sync.win32-ia32-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-win32-ia32-msvc");
+        const bindingPackageVersion = require2("@tursodatabase/sync-win32-ia32-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./sync.win32-arm64-msvc.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-win32-arm64-msvc");
+        const bindingPackageVersion = require2("@tursodatabase/sync-win32-arm64-msvc/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+    }
+  } else if (process.platform === "darwin") {
+    try {
+      return require2("./sync.darwin-universal.node");
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    try {
+      const binding = require2("@tursodatabase/sync-darwin-universal");
+      const bindingPackageVersion = require2("@tursodatabase/sync-darwin-universal/package.json").version;
+      if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+        throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+      }
+      return binding;
+    } catch (e) {
+      loadErrors.push(e);
+    }
+    if (process.arch === "x64") {
+      try {
+        return require2("./sync.darwin-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-darwin-x64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-darwin-x64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./sync.darwin-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-darwin-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-darwin-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+    }
+  } else if (process.platform === "freebsd") {
+    if (process.arch === "x64") {
+      try {
+        return require2("./sync.freebsd-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-freebsd-x64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-freebsd-x64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm64") {
+      try {
+        return require2("./sync.freebsd-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-freebsd-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-freebsd-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+    }
+  } else if (process.platform === "linux") {
+    if (process.arch === "x64") {
+      if (isMusl()) {
+        try {
+          return require2("./sync.linux-x64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-x64-musl");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-x64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./sync.linux-x64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-x64-gnu");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-x64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm64") {
+      if (isMusl()) {
+        try {
+          return require2("./sync.linux-arm64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-arm64-musl");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-arm64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./sync.linux-arm64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-arm64-gnu");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-arm64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "arm") {
+      if (isMusl()) {
+        try {
+          return require2("./sync.linux-arm-musleabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-arm-musleabihf");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-arm-musleabihf/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./sync.linux-arm-gnueabihf.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-arm-gnueabihf");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-arm-gnueabihf/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "riscv64") {
+      if (isMusl()) {
+        try {
+          return require2("./sync.linux-riscv64-musl.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-riscv64-musl");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-riscv64-musl/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        try {
+          return require2("./sync.linux-riscv64-gnu.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require2("@tursodatabase/sync-linux-riscv64-gnu");
+          const bindingPackageVersion = require2("@tursodatabase/sync-linux-riscv64-gnu/package.json").version;
+          if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      }
+    } else if (process.arch === "ppc64") {
+      try {
+        return require2("./sync.linux-ppc64-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-linux-ppc64-gnu");
+        const bindingPackageVersion = require2("@tursodatabase/sync-linux-ppc64-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "s390x") {
+      try {
+        return require2("./sync.linux-s390x-gnu.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-linux-s390x-gnu");
+        const bindingPackageVersion = require2("@tursodatabase/sync-linux-s390x-gnu/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+    }
+  } else if (process.platform === "openharmony") {
+    if (process.arch === "arm64") {
+      try {
+        return require2("./sync.openharmony-arm64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-openharmony-arm64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-openharmony-arm64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "x64") {
+      try {
+        return require2("./sync.openharmony-x64.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-openharmony-x64");
+        const bindingPackageVersion = require2("@tursodatabase/sync-openharmony-x64/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else if (process.arch === "arm") {
+      try {
+        return require2("./sync.openharmony-arm.node");
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        const binding = require2("@tursodatabase/sync-openharmony-arm");
+        const bindingPackageVersion = require2("@tursodatabase/sync-openharmony-arm/package.json").version;
+        if (bindingPackageVersion !== "0.6.0-pre.22" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+          throw new Error(`Native binding package version mismatch, expected 0.6.0-pre.22 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+        }
+        return binding;
+      } catch (e) {
+        loadErrors.push(e);
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+  }
+}
+var require2, __dirname2, readFileSync, nativeBinding = null, loadErrors, isMusl = () => {
+  let musl = false;
+  if (process.platform === "linux") {
+    musl = isMuslFromFilesystem();
+    if (musl === null) {
+      musl = isMuslFromReport();
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess();
+    }
+  }
+  return musl;
+}, isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-"), isMuslFromFilesystem = () => {
+  try {
+    return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+  } catch {
+    return null;
+  }
+}, isMuslFromReport = () => {
+  let report = null;
+  if (typeof process.report?.getReport === "function") {
+    process.report.excludeNetwork = true;
+    report = process.report.getReport();
+  }
+  if (!report) {
+    return null;
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true;
+    }
+  }
+  return false;
+}, isMuslFromChildProcess = () => {
+  try {
+    return require2("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+  } catch (e) {
+    return false;
+  }
+}, BatchExecutor, Database3, Statement4, EncryptionCipher, GeneratorHolder, JsDataCompletion, JsProtocolIo, JsProtocolRequestBytes, SyncEngine, SyncEngineChanges, DatabaseChangeTypeJs, SyncEngineProtocolVersion;
+var init_sync = __esm(() => {
+  require2 = createRequire(import.meta.url);
+  __dirname2 = new URL(".", import.meta.url).pathname;
+  ({ readFileSync } = require2("node:fs"));
+  loadErrors = [];
+  nativeBinding = requireNative();
+  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+    try {
+      nativeBinding = require2("./sync.wasi.cjs");
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err);
+      }
+    }
+    if (!nativeBinding) {
+      try {
+        nativeBinding = require2("@tursodatabase/sync-wasm32-wasi");
+      } catch (err) {
+        if (process.env.NAPI_RS_FORCE_WASI) {
+          loadErrors.push(err);
+        }
+      }
+    }
+  }
+  if (!nativeBinding) {
+    if (loadErrors.length > 0) {
+      throw new Error(`Cannot find native binding. ` + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + "Please try `npm i` again after removing both package-lock.json and node_modules directory.", { cause: loadErrors });
+    }
+    throw new Error(`Failed to load native binding`);
+  }
+  ({ BatchExecutor, Database: Database3, Statement: Statement4, EncryptionCipher, GeneratorHolder, JsDataCompletion, JsProtocolIo, JsProtocolRequestBytes, SyncEngine, SyncEngineChanges, DatabaseChangeTypeJs, SyncEngineProtocolVersion } = nativeBinding);
+});
+
+// node_modules/@tursodatabase/sync/dist/promise.js
+var exports_promise = {};
+__export(exports_promise, {
+  retryFetch: () => retryFetch,
+  connect: () => connect2,
+  Database: () => Database4
+});
+import { promises } from "fs";
+function memoryIO2() {
+  let values = new Map;
+  return {
+    async read(path) {
+      return values.get(path);
+    },
+    async write(path, data) {
+      values.set(path, data);
+    }
+  };
+}
+function resolveUrl(url) {
+  if (typeof url === "function") {
+    const resolved = url();
+    if (resolved == null) {
+      throw new Error("remoteWritesExperimental requires a non-null URL");
+    }
+    return resolved;
+  }
+  return url;
+}
+async function connect2(opts) {
+  const db = new Database4(opts);
+  await db.connect();
+  return db;
+}
+var NodeIO, Database4;
+var init_promise2 = __esm(() => {
+  init_dist();
+  init_dist3();
+  init_sync();
+  init_dist3();
+  NodeIO = {
+    async read(path) {
+      try {
+        return await promises.readFile(path);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async write(path, data) {
+      const unix = Math.floor(Date.now() / 1000);
+      const nonce = Math.floor(Math.random() * 1e9);
+      const tmp = `${path}.tmp.${unix}.${nonce}`;
+      await promises.writeFile(tmp, new Uint8Array(data));
+      try {
+        await promises.rename(tmp, path);
+      } catch (err) {
+        await promises.unlink(tmp);
+        throw err;
+      }
+    }
+  };
+  Database4 = class Database4 extends Database {
+    #engine;
+    #guards = null;
+    #runner = null;
+    #remoteWriter = null;
+    #db;
+    constructor(opts) {
+      if (opts.url == null) {
+        const db2 = new Database3(opts.path, { tracing: opts.tracing });
+        super(db2);
+        this.#db = db2;
+        this.#engine = null;
+        return;
+      }
+      let partialSyncOpts = undefined;
+      if (opts.partialSyncExperimental != null) {
+        switch (opts.partialSyncExperimental.bootstrapStrategy.kind) {
+          case "prefix":
+            partialSyncOpts = {
+              bootstrapStrategy: { type: "Prefix", length: opts.partialSyncExperimental.bootstrapStrategy.length },
+              segmentSize: opts.partialSyncExperimental.segmentSize,
+              prefetch: opts.partialSyncExperimental.prefetch
+            };
+            break;
+          case "query":
+            partialSyncOpts = {
+              bootstrapStrategy: { type: "Query", query: opts.partialSyncExperimental.bootstrapStrategy.query },
+              segmentSize: opts.partialSyncExperimental.segmentSize,
+              prefetch: opts.partialSyncExperimental.prefetch
+            };
+            break;
+        }
+      }
+      const engine = new SyncEngine({
+        path: opts.path,
+        clientName: opts.clientName,
+        useTransform: opts.transform != null,
+        protocolVersion: "v1",
+        longPollTimeoutMs: opts.longPollTimeoutMs,
+        tracing: opts.tracing,
+        bootstrapIfEmpty: typeof opts.url != "function" || opts.url() != null,
+        remoteEncryptionCipher: opts.remoteEncryption?.cipher,
+        remoteEncryptionKey: opts.remoteEncryption?.key,
+        partialSyncOpts,
+        pushOperationsThreshold: opts.pushOperationsThreshold,
+        pullBytesThreshold: opts.pullBytesThreshold
+      });
+      let headers;
+      if (typeof opts.authToken == "function") {
+        const authToken = opts.authToken;
+        headers = async () => ({
+          ...opts.authToken != null && { Authorization: `Bearer ${await authToken()}` },
+          ...opts.remoteEncryption != null && {
+            "x-turso-encryption-key": opts.remoteEncryption.key,
+            "x-turso-encryption-cipher": opts.remoteEncryption.cipher
+          }
+        });
+      } else {
+        const authToken = opts.authToken;
+        headers = {
+          ...opts.authToken != null && { Authorization: `Bearer ${authToken}` },
+          ...opts.remoteEncryption != null && {
+            "x-turso-encryption-key": opts.remoteEncryption.key,
+            "x-turso-encryption-cipher": opts.remoteEncryption.cipher
+          }
+        };
+      }
+      const runOpts = {
+        url: opts.url,
+        headers,
+        preemptionMs: 1,
+        transform: opts.transform,
+        fetch: opts.fetch
+      };
+      const db = engine.db();
+      const memory = db.memory;
+      const io = memory ? memoryIO2() : NodeIO;
+      const run2 = runner(runOpts, io, engine);
+      super(engine.db(), () => run2.wait());
+      this.#db = engine.db();
+      this.#runner = run2;
+      this.#engine = engine;
+      this.#guards = new SyncEngineGuards;
+      if (opts.remoteWritesExperimental && opts.url) {
+        const url = resolveUrl(opts.url);
+        this.#remoteWriter = new RemoteWriter({
+          url,
+          authToken: opts.authToken,
+          remoteEncryptionKey: opts.remoteEncryption?.key
+        });
+      }
+    }
+    async connect() {
+      if (this.connected) {
+        return;
+      } else if (this.#engine == null) {
+        await super.connect();
+      } else {
+        await run(this.#runner, this.#engine.connect());
+      }
+      this.connected = true;
+    }
+    async pull() {
+      if (this.#engine == null) {
+        throw new Error("sync is disabled as database was opened without sync support");
+      }
+      const changes = await this.#guards.wait(async () => await run(this.#runner, this.#engine.wait()));
+      if (changes.empty()) {
+        return false;
+      }
+      await this.#guards.apply(async () => await run(this.#runner, this.#engine.apply(changes)));
+      return true;
+    }
+    async push() {
+      if (this.#engine == null) {
+        throw new Error("sync is disabled as database was opened without sync support");
+      }
+      await this.#guards.push(async () => await run(this.#runner, this.#engine.push()));
+    }
+    async checkpoint() {
+      if (this.#engine == null) {
+        throw new Error("sync is disabled as database was opened without sync support");
+      }
+      await this.#guards.checkpoint(async () => await run(this.#runner, this.#engine.checkpoint()));
+    }
+    async stats() {
+      if (this.#engine == null) {
+        throw new Error("sync is disabled as database was opened without sync support");
+      }
+      return await run(this.#runner, this.#engine.stats());
+    }
+    async exec(sql) {
+      if (!this.#remoteWriter)
+        return super.exec(sql);
+      const category = this.#db.classifySql(sql);
+      if (this.#remoteWriter.isInTransaction) {
+        const { shouldPull: shouldPull2 } = await this.#remoteWriter.execRemote(sql, category);
+        if (shouldPull2)
+          await this.pull();
+        return;
+      }
+      if (category === "read")
+        return super.exec(sql);
+      const { shouldPull } = await this.#remoteWriter.execRemote(sql, category);
+      if (shouldPull)
+        await this.pull();
+    }
+    async prepare(sql) {
+      const localStmt = await super.prepare(sql);
+      if (!this.#remoteWriter) {
+        return localStmt;
+      }
+      const category = this.#db.classifySql(sql);
+      const isReadonly = category === "read";
+      return new RemoteWriteStatement(localStmt, sql, isReadonly, this.#remoteWriter, () => this.pull());
+    }
+    transaction(fn) {
+      if (typeof fn !== "function")
+        throw new TypeError("Expected first argument to be a function");
+      if (!this.#remoteWriter) {
+        return super.transaction(fn);
+      }
+      const db = this;
+      const remoteWriter = this.#remoteWriter;
+      const wrapTxn = (mode) => {
+        return async (...bindParameters) => {
+          await remoteWriter.beginTransaction(mode);
+          try {
+            const result = await fn(...bindParameters);
+            await remoteWriter.commitTransaction();
+            await db.pull();
+            return result;
+          } catch (err) {
+            await remoteWriter.rollbackTransaction();
+            throw err;
+          }
+        };
+      };
+      const properties = {
+        default: { value: wrapTxn("") },
+        deferred: { value: wrapTxn("DEFERRED") },
+        immediate: { value: wrapTxn("IMMEDIATE") },
+        exclusive: { value: wrapTxn("EXCLUSIVE") },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    }
+    async close() {
+      if (this.#remoteWriter) {
+        await this.#remoteWriter.close();
+      }
+      await super.close();
+      if (this.#engine != null) {
+        this.#engine.close();
+      }
+    }
+  };
+});
+
+// src/query/conditions.ts
+function isColumnDef(value) {
+  return value !== null && typeof value === "object" && "__internal" in value;
+}
+function eq(left, valueOrColumn) {
+  if (isColumnDef(valueOrColumn)) {
+    return { type: "eqColumn", left, right: valueOrColumn };
+  }
+  return { type: "eq", column: left, value: valueOrColumn };
+}
+function and(...conditions) {
+  return { type: "and", conditions };
+}
+function or(...conditions) {
+  return { type: "or", conditions };
+}
+function isIn(column, values) {
+  return { type: "in", column, values };
+}
+function isNotIn(column, values) {
+  return { type: "notIn", column, values };
+}
+function isNull(column) {
+  return { type: "isNull", column };
+}
+function isNotNull(column) {
+  return { type: "isNotNull", column };
+}
+function like(column, pattern) {
+  return { type: "like", column, pattern };
+}
+function glob(column, pattern) {
+  return { type: "glob", column, pattern };
+}
+function between(column, low, high) {
+  return { type: "between", column, low, high };
+}
+function gt(column, value) {
+  return { type: "gt", column, value };
+}
+function gte(column, value) {
+  return { type: "gte", column, value };
+}
+function lt(column, value) {
+  return { type: "lt", column, value };
+}
+function lte(column, value) {
+  return { type: "lte", column, value };
+}
+function neq(column, value) {
+  return { type: "neq", column, value };
+}
+function compileCondition(cond, params) {
+  switch (cond.type) {
+    case "eq":
+      params.push(cond.column.__internal.encode(cond.value));
+      return `${cond.column.name} = ?`;
+    case "eqColumn": {
+      const leftName = cond.left.__internal.tableName ? `${cond.left.__internal.tableName}.${cond.left.name}` : cond.left.name;
+      const rightName = cond.right.__internal.tableName ? `${cond.right.__internal.tableName}.${cond.right.name}` : cond.right.name;
+      return `${leftName} = ${rightName}`;
+    }
+    case "in": {
+      const encoded = cond.values.map((v) => cond.column.__internal.encode(v));
+      params.push(...encoded);
+      const placeholders = encoded.map(() => "?").join(", ");
+      return `${cond.column.name} IN (${placeholders})`;
+    }
+    case "notIn": {
+      const encoded = cond.values.map((v) => cond.column.__internal.encode(v));
+      params.push(...encoded);
+      const placeholders = encoded.map(() => "?").join(", ");
+      return `${cond.column.name} NOT IN (${placeholders})`;
+    }
+    case "isNull":
+      return `${cond.column.name} IS NULL`;
+    case "isNotNull":
+      return `${cond.column.name} IS NOT NULL`;
+    case "like":
+      params.push(cond.pattern);
+      return `${cond.column.name} LIKE ?`;
+    case "glob":
+      params.push(cond.pattern);
+      return `${cond.column.name} GLOB ?`;
+    case "between":
+      params.push(cond.column.__internal.encode(cond.low));
+      params.push(cond.column.__internal.encode(cond.high));
+      return `${cond.column.name} BETWEEN ? AND ?`;
+    case "gt":
+      params.push(cond.column.__internal.encode(cond.value));
+      return `${cond.column.name} > ?`;
+    case "gte":
+      params.push(cond.column.__internal.encode(cond.value));
+      return `${cond.column.name} >= ?`;
+    case "lt":
+      params.push(cond.column.__internal.encode(cond.value));
+      return `${cond.column.name} < ?`;
+    case "lte":
+      params.push(cond.column.__internal.encode(cond.value));
+      return `${cond.column.name} <= ?`;
+    case "neq":
+      params.push(cond.column.__internal.encode(cond.value));
+      return `${cond.column.name} != ?`;
+    case "and":
+      return cond.conditions.map((c) => compileCondition(c, params)).join(" AND ");
+    case "or":
+      return `(${cond.conditions.map((c) => compileCondition(c, params)).join(" OR ")})`;
+  }
+}
+function compileConditions(conditions, params) {
+  if (conditions.length === 0)
+    return "1=1";
+  return conditions.map((c) => compileCondition(c, params)).join(" AND ");
+}
+
+// src/errors.ts
+var FlintError, FlintValidationError, FlintQueryError;
+var init_errors = __esm(() => {
+  FlintError = class FlintError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "FlintError";
+    }
+  };
+  FlintValidationError = class FlintValidationError extends FlintError {
+    constructor(message) {
+      super(message);
+      this.name = "FlintValidationError";
+    }
+  };
+  FlintQueryError = class FlintQueryError extends FlintError {
+    originalError;
+    constructor(message, originalError) {
+      super(message);
+      this.name = "FlintQueryError";
+      this.originalError = originalError;
+    }
+  };
+});
+
+// src/query/builder.ts
+function getCol(tbl, key) {
+  const col = tbl[key];
+  if (!col)
+    throw new FlintValidationError(`Column "${key}" not found in table`);
+  return col;
+}
+function columnEntries(tbl) {
+  return Object.entries(tbl).filter(([k]) => k !== "_" && k !== "__indexes");
+}
+function decodeRow(raw, tbl) {
+  const out = {};
+  for (const [key, col] of columnEntries(tbl)) {
+    out[key] = col.__internal.decode(raw[col.name]);
+  }
+  return out;
+}
+function decodeSelectedRow(raw, tbl, keys) {
+  const out = {};
+  for (const key of keys) {
+    const col = getCol(tbl, key);
+    out[key] = col.__internal.decode(raw[col.name]);
+  }
+  return out;
+}
+function findPKKey(tbl) {
+  for (const [key, col] of columnEntries(tbl)) {
+    if (col.__internal.isPrimaryKey)
+      return key;
+  }
+  throw new FlintValidationError("Table has no primary key column");
+}
+function resolveForeignKeyCondition(parent, parentName, child, childName) {
+  for (const [, col] of columnEntries(child)) {
+    if (col.__internal.referencesTable === parentName && col.__internal.referencesColumn) {
+      const parentCol = getCol(parent, col.__internal.referencesColumn);
+      if (parentCol) {
+        return eq(parentCol, col);
+      }
+    }
+  }
+  throw new FlintValidationError(`No foreign key reference found from "${childName}" to "${parentName}". Use .references() on the child table or provide an explicit condition.`);
+}
+function extractColumns(cond) {
+  switch (cond.type) {
+    case "eq":
+      return [cond.column];
+    case "eqColumn":
+      return [cond.left, cond.right];
+    case "in":
+    case "notIn":
+    case "isNull":
+    case "isNotNull":
+    case "like":
+    case "glob":
+    case "between":
+      return [cond.column];
+    case "and":
+    case "or":
+      return cond.conditions.flatMap(extractColumns);
+    default:
+      return [];
+  }
+}
+function validateColumnOwnership(conditions, allowedTables, context) {
+  const allowedColumns = new Set(allowedTables.flatMap((t) => columnEntries(t).map(([, c]) => c)));
+  for (const cond of conditions) {
+    const cols = extractColumns(cond);
+    for (const col of cols) {
+      if (!allowedColumns.has(col)) {
+        throw new FlintValidationError(`Column "${col.name}" does not belong to ${context}. ` + `Check that you're using a column from the queried table, not a different table.`);
+      }
+    }
+  }
+}
+function resolveColumns(table, selectedColumns, prefix) {
+  if (selectedColumns) {
+    return selectedColumns.map((k) => {
+      const name = getCol(table, k).name;
+      return prefix ? `${prefix}.${name}` : name;
+    }).join(", ");
+  }
+  const entries = columnEntries(table);
+  return entries.map(([, c]) => prefix ? `${prefix}.${c.name}` : c.name).join(", ");
+}
+
+class SelectFromBuilder {
+  #executor;
+  #conditions;
+  constructor(executor, conditions = []) {
+    this.#executor = executor;
+    this.#conditions = conditions;
+  }
+  from(table) {
+    return new SelectBuilder(this.#executor, table._.name, table, this.#conditions);
+  }
+}
+
+class SelectBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #conditions;
+  #selectedColumns;
+  #orderByClauses;
+  #limitValue;
+  #offsetValue;
+  #distinct;
+  constructor(executor, tableName, table, conditions = [], selectedColumns = null, orderByClauses = [], limitValue = null, offsetValue = null, distinct = false) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#conditions = conditions;
+    this.#selectedColumns = selectedColumns;
+    this.#orderByClauses = orderByClauses;
+    this.#limitValue = limitValue;
+    this.#offsetValue = offsetValue;
+    this.#distinct = distinct;
+  }
+  where(condition) {
+    return new SelectBuilder(this.#executor, this.#tableName, this.#table, [...this.#conditions, condition], this.#selectedColumns, this.#orderByClauses, this.#limitValue, this.#offsetValue, this.#distinct);
+  }
+  columns(keys) {
+    return new NarrowedSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, keys, this.#orderByClauses, this.#limitValue, this.#offsetValue, this.#distinct);
+  }
+  single() {
+    return new SingleSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#offsetValue, this.#distinct);
+  }
+  distinct() {
+    return new SelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#limitValue, this.#offsetValue, true);
+  }
+  orderBy(key, direction = "asc") {
+    const column = getCol(this.#table, key);
+    return new SelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, [...this.#orderByClauses, { column, direction }], this.#limitValue, this.#offsetValue, this.#distinct);
+  }
+  limit(n) {
+    return new SelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, n, this.#offsetValue, this.#distinct);
+  }
+  offset(n) {
+    return new SelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#limitValue, n, this.#distinct);
+  }
+  toSQL() {
+    validateColumnOwnership(this.#conditions, [this.#table], `SELECT from "${this.#tableName}"`);
+    const cols = resolveColumns(this.#table, this.#selectedColumns);
+    const params = [];
+    const distinct = this.#distinct ? "DISTINCT " : "";
+    let sql = `SELECT ${distinct}${cols} FROM ${this.#tableName}`;
+    const where = compileConditions(this.#conditions, params);
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#orderByClauses.length > 0) {
+      const orderClauses = this.#orderByClauses.map((o) => `${o.column.name} ${o.direction.toUpperCase()}`).join(", ");
+      sql += ` ORDER BY ${orderClauses}`;
+    }
+    if (this.#limitValue !== null)
+      sql += ` LIMIT ${this.#limitValue}`;
+    if (this.#offsetValue !== null)
+      sql += ` OFFSET ${this.#offsetValue}`;
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      const rows = await this.#executor.all(sql, params);
+      const records = rows;
+      if (this.#selectedColumns) {
+        return records.map((r) => decodeSelectedRow(r, this.#table, this.#selectedColumns));
+      }
+      return records.map((r) => decodeRow(r, this.#table));
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+
+class NarrowedSelectBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #conditions;
+  #selectedColumns;
+  #orderByClauses;
+  #limitValue;
+  #offsetValue;
+  #distinct;
+  constructor(executor, tableName, table, conditions, selectedColumns, orderByClauses, limitValue, offsetValue, distinct) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#conditions = conditions;
+    this.#selectedColumns = selectedColumns;
+    this.#orderByClauses = orderByClauses;
+    this.#limitValue = limitValue;
+    this.#offsetValue = offsetValue;
+    this.#distinct = distinct;
+  }
+  where(condition) {
+    return new NarrowedSelectBuilder(this.#executor, this.#tableName, this.#table, [...this.#conditions, condition], this.#selectedColumns, this.#orderByClauses, this.#limitValue, this.#offsetValue, this.#distinct);
+  }
+  distinct() {
+    return new NarrowedSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#limitValue, this.#offsetValue, true);
+  }
+  single() {
+    return new NarrowedSingleSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#offsetValue, this.#distinct);
+  }
+  orderBy(key, direction = "asc") {
+    const column = getCol(this.#table, key);
+    return new NarrowedSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, [...this.#orderByClauses, { column, direction }], this.#limitValue, this.#offsetValue, this.#distinct);
+  }
+  limit(n) {
+    return new NarrowedSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, n, this.#offsetValue, this.#distinct);
+  }
+  offset(n) {
+    return new NarrowedSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#limitValue, n, this.#distinct);
+  }
+  toSQL() {
+    validateColumnOwnership(this.#conditions, [this.#table], `SELECT from "${this.#tableName}"`);
+    const cols = resolveColumns(this.#table, this.#selectedColumns);
+    const params = [];
+    const distinct = this.#distinct ? "DISTINCT " : "";
+    let sql = `SELECT ${distinct}${cols} FROM ${this.#tableName}`;
+    const where = compileConditions(this.#conditions, params);
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#orderByClauses.length > 0) {
+      const orderClauses = this.#orderByClauses.map((o) => `${o.column.name} ${o.direction.toUpperCase()}`).join(", ");
+      sql += ` ORDER BY ${orderClauses}`;
+    }
+    if (this.#limitValue !== null)
+      sql += ` LIMIT ${this.#limitValue}`;
+    if (this.#offsetValue !== null)
+      sql += ` OFFSET ${this.#offsetValue}`;
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      const rows = await this.#executor.all(sql, params);
+      return rows.map((r) => decodeSelectedRow(r, this.#table, this.#selectedColumns));
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+
+class SingleSelectBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #conditions;
+  #selectedColumns;
+  #orderByClauses;
+  #offsetValue;
+  #distinct;
+  constructor(executor, tableName, table, conditions, selectedColumns = null, orderByClauses = [], offsetValue = null, distinct = false) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#conditions = conditions;
+    this.#selectedColumns = selectedColumns;
+    this.#orderByClauses = orderByClauses;
+    this.#offsetValue = offsetValue;
+    this.#distinct = distinct;
+  }
+  where(condition) {
+    return new SingleSelectBuilder(this.#executor, this.#tableName, this.#table, [...this.#conditions, condition], this.#selectedColumns, this.#orderByClauses, this.#offsetValue, this.#distinct);
+  }
+  orderBy(key, direction = "asc") {
+    const column = getCol(this.#table, key);
+    return new SingleSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, [...this.#orderByClauses, { column, direction }], this.#offsetValue, this.#distinct);
+  }
+  offset(n) {
+    return new SingleSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, n, this.#distinct);
+  }
+  toSQL() {
+    validateColumnOwnership(this.#conditions, [this.#table], `SELECT from "${this.#tableName}"`);
+    const cols = resolveColumns(this.#table, this.#selectedColumns);
+    const params = [];
+    const distinct = this.#distinct ? "DISTINCT " : "";
+    let sql = `SELECT ${distinct}${cols} FROM ${this.#tableName}`;
+    const where = compileConditions(this.#conditions, params);
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#orderByClauses.length > 0) {
+      const orderClauses = this.#orderByClauses.map((o) => `${o.column.name} ${o.direction.toUpperCase()}`).join(", ");
+      sql += ` ORDER BY ${orderClauses}`;
+    }
+    sql += " LIMIT 1";
+    if (this.#offsetValue !== null)
+      sql += ` OFFSET ${this.#offsetValue}`;
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      const row = await this.#executor.get(sql, params);
+      if (!row)
+        return null;
+      const record = row;
+      if (this.#selectedColumns) {
+        return decodeSelectedRow(record, this.#table, this.#selectedColumns);
+      }
+      return decodeRow(record, this.#table);
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+
+class NarrowedSingleSelectBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #conditions;
+  #selectedColumns;
+  #orderByClauses;
+  #offsetValue;
+  #distinct;
+  constructor(executor, tableName, table, conditions, selectedColumns, orderByClauses, offsetValue, distinct) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#conditions = conditions;
+    this.#selectedColumns = selectedColumns;
+    this.#orderByClauses = orderByClauses;
+    this.#offsetValue = offsetValue;
+    this.#distinct = distinct;
+  }
+  where(condition) {
+    return new NarrowedSingleSelectBuilder(this.#executor, this.#tableName, this.#table, [...this.#conditions, condition], this.#selectedColumns, this.#orderByClauses, this.#offsetValue, this.#distinct);
+  }
+  orderBy(key, direction = "asc") {
+    const column = getCol(this.#table, key);
+    return new NarrowedSingleSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, [...this.#orderByClauses, { column, direction }], this.#offsetValue, this.#distinct);
+  }
+  offset(n) {
+    return new NarrowedSingleSelectBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, this.#selectedColumns, this.#orderByClauses, n, this.#distinct);
+  }
+  toSQL() {
+    validateColumnOwnership(this.#conditions, [this.#table], `SELECT from "${this.#tableName}"`);
+    const cols = resolveColumns(this.#table, this.#selectedColumns);
+    const params = [];
+    const distinct = this.#distinct ? "DISTINCT " : "";
+    let sql = `SELECT ${distinct}${cols} FROM ${this.#tableName}`;
+    const where = compileConditions(this.#conditions, params);
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#orderByClauses.length > 0) {
+      const orderClauses = this.#orderByClauses.map((o) => `${o.column.name} ${o.direction.toUpperCase()}`).join(", ");
+      sql += ` ORDER BY ${orderClauses}`;
+    }
+    sql += " LIMIT 1";
+    if (this.#offsetValue !== null)
+      sql += ` OFFSET ${this.#offsetValue}`;
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      const row = await this.#executor.get(sql, params);
+      if (!row)
+        return null;
+      return decodeSelectedRow(row, this.#table, this.#selectedColumns);
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+
+class JoinStage1 {
+  #executor;
+  #parent;
+  #parentName;
+  #joinType;
+  constructor(executor, parent, parentName, joinType) {
+    this.#executor = executor;
+    this.#parent = parent;
+    this.#parentName = parentName;
+    this.#joinType = joinType;
+  }
+  on(child, condition) {
+    const childName = child._.name;
+    const resolvedCondition = condition ?? resolveForeignKeyCondition(this.#parent, this.#parentName, child, childName);
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, [{ table: child, name: childName, condition: resolvedCondition }], this.#joinType);
+  }
+}
+
+class JoinBuilderImpl {
+  #executor;
+  #parent;
+  #parentName;
+  #joins;
+  #joinType;
+  #conditions;
+  #selectedColumns;
+  #orderByClauses;
+  #limitValue;
+  #offsetValue;
+  constructor(executor, parent, parentName, joins, joinType, conditions = [], selectedColumns = null, orderByClauses = [], limitValue = null, offsetValue = null) {
+    this.#executor = executor;
+    this.#parent = parent;
+    this.#parentName = parentName;
+    this.#joins = joins;
+    this.#joinType = joinType;
+    this.#conditions = conditions;
+    this.#selectedColumns = selectedColumns;
+    this.#orderByClauses = orderByClauses;
+    this.#limitValue = limitValue;
+    this.#offsetValue = offsetValue;
+  }
+  on(child, condition) {
+    const childName = child._.name;
+    const resolvedCondition = condition ?? resolveForeignKeyCondition(this.#parent, this.#parentName, child, childName);
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, [...this.#joins, { table: child, name: childName, condition: resolvedCondition }], this.#joinType, this.#conditions, this.#selectedColumns);
+  }
+  where(condition) {
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, [...this.#conditions, condition], this.#selectedColumns);
+  }
+  columns(keys) {
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, keys, this.#orderByClauses, this.#limitValue, this.#offsetValue);
+  }
+  orderBy(key, direction = "asc") {
+    const column = getCol(this.#parent, key);
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, this.#selectedColumns, [...this.#orderByClauses, { column, direction }], this.#limitValue, this.#offsetValue);
+  }
+  limit(n) {
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, this.#selectedColumns, this.#orderByClauses, n, this.#offsetValue);
+  }
+  offset(n) {
+    return new JoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#limitValue, n);
+  }
+  single() {
+    return new SingleJoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, this.#selectedColumns, this.#orderByClauses, this.#offsetValue);
+  }
+  toSQL() {
+    const allowedTables = [this.#parent, ...this.#joins.map((j) => j.table)];
+    validateColumnOwnership(this.#conditions, allowedTables, `SELECT from "${this.#parentName}"`);
+    const parentCols = resolveColumns(this.#parent, this.#selectedColumns, this.#parentName);
+    const childCols = [];
+    for (const join of this.#joins) {
+      const entries = columnEntries(join.table);
+      for (const [, c] of entries) {
+        childCols.push(`${join.name}.${c.name} AS ${join.name}_${c.name}`);
+      }
+    }
+    const joinKeyword = this.#joinType === "left" ? "LEFT JOIN" : "INNER JOIN";
+    const joinClauses = [];
+    const joinParams = [];
+    for (const join of this.#joins) {
+      const joinOn = compileConditions([join.condition], joinParams);
+      joinClauses.push(`${joinKeyword} ${join.name} ON ${joinOn}`);
+    }
+    const whereParams = [];
+    const where = compileConditions(this.#conditions, whereParams);
+    let sql = `SELECT ${parentCols}${childCols.length ? ", " + childCols.join(", ") : ""} FROM ${this.#parentName} ${joinClauses.join(" ")}`;
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#orderByClauses.length > 0) {
+      const orderClauses = this.#orderByClauses.map((o) => `${o.column.name} ${o.direction.toUpperCase()}`).join(", ");
+      sql += ` ORDER BY ${orderClauses}`;
+    }
+    if (this.#limitValue !== null)
+      sql += ` LIMIT ${this.#limitValue}`;
+    if (this.#offsetValue !== null)
+      sql += ` OFFSET ${this.#offsetValue}`;
+    return { sql, params: [...joinParams, ...whereParams] };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      const rows = await this.#executor.all(sql, params);
+      return this.#decodeJoinRows(rows);
+    } catch (e) {
+      if (e instanceof FlintQueryError)
+        throw e;
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+  #decodeJoinRows(rows) {
+    const parentEntries = columnEntries(this.#parent);
+    const pkKey = findPKKey(this.#parent);
+    const pkColName = getCol(this.#parent, pkKey).name;
+    const childEntryMaps = [];
+    for (const j of this.#joins) {
+      childEntryMaps.push({
+        name: j.name,
+        entries: columnEntries(j.table),
+        table: j.table
+      });
+    }
+    const grouped = new Map;
+    for (const row of rows) {
+      const pk = row[pkColName];
+      if (!grouped.has(pk)) {
+        const parentRow = {};
+        for (const [key, col] of parentEntries) {
+          parentRow[key] = row[col.name];
+        }
+        grouped.set(pk, {
+          parent: parentRow,
+          children: childEntryMaps.map(() => [])
+        });
+      }
+      const group = grouped.get(pk);
+      childEntryMaps.forEach((childMap, i) => {
+        const childRow = {};
+        let hasNonNullChild = false;
+        for (const [key, col] of childMap.entries) {
+          const val = row[`${childMap.name}_${col.name}`];
+          childRow[key] = val;
+          if (val != null)
+            hasNonNullChild = true;
+        }
+        if (this.#joinType === "left" && !hasNonNullChild)
+          return;
+        group.children[i].push(childRow);
+      });
+    }
+    const result = [];
+    for (const { parent, children } of grouped.values()) {
+      const decodedParent = this.#selectedColumns ? decodeSelectedRow(parent, this.#parent, this.#selectedColumns) : decodeRow(parent, this.#parent);
+      const nested = { ...decodedParent };
+      childEntryMaps.forEach((childMap, i) => {
+        nested[childMap.name] = children[i].map((c) => decodeRow(c, childMap.table));
+      });
+      result.push(nested);
+    }
+    return result;
+  }
+}
+
+class SingleJoinBuilderImpl {
+  #executor;
+  #parent;
+  #parentName;
+  #joins;
+  #joinType;
+  #conditions;
+  #selectedColumns;
+  #orderByClauses;
+  #offsetValue;
+  constructor(executor, parent, parentName, joins, joinType, conditions, selectedColumns = null, orderByClauses = [], offsetValue = null) {
+    this.#executor = executor;
+    this.#parent = parent;
+    this.#parentName = parentName;
+    this.#joins = joins;
+    this.#joinType = joinType;
+    this.#conditions = conditions;
+    this.#selectedColumns = selectedColumns;
+    this.#orderByClauses = orderByClauses;
+    this.#offsetValue = offsetValue;
+  }
+  where(condition) {
+    return new SingleJoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, [...this.#conditions, condition], this.#selectedColumns, this.#orderByClauses, this.#offsetValue);
+  }
+  orderBy(key, direction = "asc") {
+    const column = getCol(this.#parent, key);
+    return new SingleJoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, this.#selectedColumns, [...this.#orderByClauses, { column, direction }], this.#offsetValue);
+  }
+  offset(n) {
+    return new SingleJoinBuilderImpl(this.#executor, this.#parent, this.#parentName, this.#joins, this.#joinType, this.#conditions, this.#selectedColumns, this.#orderByClauses, n);
+  }
+  toSQL() {
+    const allowedTables = [this.#parent, ...this.#joins.map((j) => j.table)];
+    validateColumnOwnership(this.#conditions, allowedTables, `SELECT from "${this.#parentName}"`);
+    const parentCols = resolveColumns(this.#parent, this.#selectedColumns, this.#parentName);
+    const childCols = [];
+    for (const join of this.#joins) {
+      const entries = columnEntries(join.table);
+      for (const [, c] of entries) {
+        childCols.push(`${join.name}.${c.name} AS ${join.name}_${c.name}`);
+      }
+    }
+    const joinKeyword = this.#joinType === "left" ? "LEFT JOIN" : "INNER JOIN";
+    const joinClauses = [];
+    const joinParams = [];
+    for (const join of this.#joins) {
+      const joinOn = compileConditions([join.condition], joinParams);
+      joinClauses.push(`${joinKeyword} ${join.name} ON ${joinOn}`);
+    }
+    const whereParams = [];
+    const where = compileConditions(this.#conditions, whereParams);
+    let sql = `SELECT ${parentCols}${childCols.length ? ", " + childCols.join(", ") : ""} FROM ${this.#parentName} ${joinClauses.join(" ")}`;
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#orderByClauses.length > 0) {
+      const orderClauses = this.#orderByClauses.map((o) => `${o.column.name} ${o.direction.toUpperCase()}`).join(", ");
+      sql += ` ORDER BY ${orderClauses}`;
+    }
+    sql += " LIMIT 1";
+    if (this.#offsetValue !== null)
+      sql += ` OFFSET ${this.#offsetValue}`;
+    return { sql, params: [...joinParams, ...whereParams] };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      const rows = await this.#executor.all(sql, params);
+      const records = rows;
+      if (records.length === 0)
+        return null;
+      return this.#decodeJoinRow(records);
+    } catch (e) {
+      if (e instanceof FlintQueryError)
+        throw e;
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+  #decodeJoinRow(rows) {
+    const parentEntries = columnEntries(this.#parent);
+    const pkKey = findPKKey(this.#parent);
+    const pkColName = getCol(this.#parent, pkKey).name;
+    const childEntryMaps = [];
+    for (const j of this.#joins) {
+      childEntryMaps.push({
+        name: j.name,
+        entries: columnEntries(j.table),
+        table: j.table
+      });
+    }
+    const grouped = new Map;
+    for (const r of rows) {
+      const pk = r[pkColName];
+      if (!grouped.has(pk)) {
+        const parentRow = {};
+        for (const [key, col] of parentEntries) {
+          parentRow[key] = r[col.name];
+        }
+        grouped.set(pk, {
+          parent: parentRow,
+          children: childEntryMaps.map(() => [])
+        });
+      }
+      const group = grouped.get(pk);
+      childEntryMaps.forEach((childMap, i) => {
+        const childRow = {};
+        let hasNonNullChild = false;
+        for (const [key, col] of childMap.entries) {
+          const val = r[`${childMap.name}_${col.name}`];
+          childRow[key] = val;
+          if (val != null)
+            hasNonNullChild = true;
+        }
+        if (this.#joinType === "left" && !hasNonNullChild)
+          return;
+        group.children[i].push(childRow);
+      });
+    }
+    const first = grouped.values().next().value;
+    if (!first)
+      return null;
+    const decodedParent = this.#selectedColumns ? decodeSelectedRow(first.parent, this.#parent, this.#selectedColumns) : decodeRow(first.parent, this.#parent);
+    const nested = { ...decodedParent };
+    childEntryMaps.forEach((childMap, i) => {
+      nested[childMap.name] = first.children[i].map((c) => decodeRow(c, childMap.table));
+    });
+    return nested;
+  }
+}
+
+class InsertValuesBuilder {
+  #executor;
+  #tableName;
+  #table;
+  constructor(executor, tableName, table) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+  }
+  values(rowOrRows) {
+    return new InsertBuilder(this.#executor, this.#tableName, this.#table, rowOrRows);
+  }
+}
+
+class InsertBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #rows;
+  #returning;
+  #onConflict;
+  constructor(executor, tableName, table, rowOrRows, returning = false, onConflict) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
+    this.#returning = returning;
+    this.#onConflict = onConflict;
+  }
+  returning(keys) {
+    return new InsertBuilder(this.#executor, this.#tableName, this.#table, this.#rows, keys ?? true, this.#onConflict);
+  }
+  onConflictDoNothing() {
+    return new InsertBuilder(this.#executor, this.#tableName, this.#table, this.#rows, this.#returning, { mode: "nothing" });
+  }
+  onConflictDoUpdate(options) {
+    return new InsertBuilder(this.#executor, this.#tableName, this.#table, this.#rows, this.#returning, {
+      mode: "update",
+      target: options.target,
+      set: options.set
+    });
+  }
+  toSQL() {
+    const entries = columnEntries(this.#table);
+    const inserts = [];
+    for (const [key, c] of entries) {
+      const allUndefined = this.#rows.every((row) => row[key] === undefined);
+      if (allUndefined && (c.__internal.hasDefault || c.__internal.isAutoIncrement)) {
+        continue;
+      }
+      inserts.push([key, c]);
+    }
+    if (inserts.length === 0) {
+      const allDefault = entries.filter(([, c]) => c.__internal.hasDefault || c.__internal.isAutoIncrement || c.__internal.hasDefaultNow);
+      const names2 = allDefault.map(([, c]) => c.name).join(", ");
+      const placeholders = allDefault.map(() => "DEFAULT").join(", ");
+      return {
+        sql: `INSERT INTO ${this.#tableName} (${names2}) VALUES (${placeholders})`,
+        params: []
+      };
+    }
+    const names = inserts.map(([, c]) => c.name).join(", ");
+    const placeholderRow = inserts.map(() => "?").join(", ");
+    const allPlaceholders = this.#rows.map(() => `(${placeholderRow})`).join(", ");
+    const params = [];
+    for (const row of this.#rows) {
+      for (const [key, c] of inserts) {
+        const value = row[key];
+        if (value === undefined && c.__internal.hasDefaultNow) {
+          params.push(c.__internal.encode(new Date));
+        } else {
+          params.push(c.__internal.encode(value));
+        }
+      }
+    }
+    let sql = `INSERT INTO ${this.#tableName} (${names}) VALUES ${allPlaceholders}`;
+    if (this.#onConflict) {
+      if (this.#onConflict.mode === "nothing") {
+        sql += " ON CONFLICT DO NOTHING";
+      } else {
+        const target = this.#onConflict.target;
+        const targetCols = Array.isArray(target) ? target : [target];
+        const targetNames = targetCols.map((c) => c.name).join(", ");
+        const setEntries = Object.entries(this.#onConflict.set);
+        const setClauses = setEntries.map(([key, value]) => {
+          const col = getCol(this.#table, key);
+          if (value === undefined)
+            return null;
+          return `${col.name} = excluded.${col.name}`;
+        }).filter(Boolean);
+        if (setClauses.length > 0) {
+          sql += ` ON CONFLICT (${targetNames}) DO UPDATE SET ${setClauses.join(", ")}`;
+        }
+      }
+    }
+    if (this.#returning) {
+      if (Array.isArray(this.#returning)) {
+        const cols = this.#returning.map((k) => getCol(this.#table, k).name).join(", ");
+        sql += ` RETURNING ${cols}`;
+      } else {
+        sql += " RETURNING *";
+      }
+    }
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      if (this.#returning) {
+        const rows = await this.#executor.all(sql, params);
+        const records = rows;
+        if (Array.isArray(this.#returning)) {
+          return records.map((r) => decodeSelectedRow(r, this.#table, this.#returning));
+        }
+        return records.map((r) => decodeRow(r, this.#table));
+      }
+      await this.#executor.run(sql, params);
+      return;
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+
+class UpdateSetBuilder {
+  #executor;
+  #tableName;
+  #table;
+  constructor(executor, tableName, table) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+  }
+  set(partial) {
+    return new UpdateBuilder(this.#executor, this.#tableName, this.#table, partial);
+  }
+}
+
+class UpdateBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #set;
+  #conditions;
+  #returning;
+  constructor(executor, tableName, table, set, conditions = [], returning = false) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#set = set;
+    this.#conditions = conditions;
+    this.#returning = returning;
+  }
+  set(partial) {
+    return new UpdateBuilder(this.#executor, this.#tableName, this.#table, { ...this.#set, ...partial }, this.#conditions, this.#returning);
+  }
+  where(condition) {
+    return new UpdateBuilder(this.#executor, this.#tableName, this.#table, this.#set, [...this.#conditions, condition], this.#returning);
+  }
+  returning(keys) {
+    return new UpdateBuilder(this.#executor, this.#tableName, this.#table, this.#set, this.#conditions, keys ?? true);
+  }
+  toSQL() {
+    validateColumnOwnership(this.#conditions, [this.#table], `UPDATE "${this.#tableName}"`);
+    const params = [];
+    const setClauses = [];
+    for (const key of Object.keys(this.#set)) {
+      const col = getCol(this.#table, key);
+      if (col.__internal.hasOnUpdate) {
+        setClauses.push(`${col.name} = ?`);
+        params.push(col.__internal.encode(new Date));
+        continue;
+      }
+      setClauses.push(`${col.name} = ?`);
+      params.push(col.__internal.encode(this.#set[key]));
+    }
+    let sql = `UPDATE ${this.#tableName} SET ${setClauses.join(", ")}`;
+    const where = compileConditions(this.#conditions, params);
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#returning) {
+      if (Array.isArray(this.#returning)) {
+        const cols = this.#returning.map((k) => getCol(this.#table, k).name).join(", ");
+        sql += ` RETURNING ${cols}`;
+      } else {
+        sql += " RETURNING *";
+      }
+    }
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      if (this.#returning) {
+        const rows = await this.#executor.all(sql, params);
+        const records = rows;
+        if (Array.isArray(this.#returning)) {
+          return records.map((r) => decodeSelectedRow(r, this.#table, this.#returning));
+        }
+        return records.map((r) => decodeRow(r, this.#table));
+      }
+      await this.#executor.run(sql, params);
+      return;
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+
+class DeleteBuilder {
+  #executor;
+  #tableName;
+  #table;
+  #conditions;
+  #returning;
+  constructor(executor, tableName, table, conditions = [], returning = false) {
+    this.#executor = executor;
+    this.#tableName = tableName;
+    this.#table = table;
+    this.#conditions = conditions;
+    this.#returning = returning;
+  }
+  where(condition) {
+    return new DeleteBuilder(this.#executor, this.#tableName, this.#table, [...this.#conditions, condition], this.#returning);
+  }
+  returning(keys) {
+    return new DeleteBuilder(this.#executor, this.#tableName, this.#table, this.#conditions, keys ?? true);
+  }
+  toSQL() {
+    validateColumnOwnership(this.#conditions, [this.#table], `DELETE from "${this.#tableName}"`);
+    const params = [];
+    let sql = `DELETE FROM ${this.#tableName}`;
+    const where = compileConditions(this.#conditions, params);
+    if (where !== "1=1")
+      sql += ` WHERE ${where}`;
+    if (this.#returning) {
+      if (Array.isArray(this.#returning)) {
+        const cols = this.#returning.map((k) => getCol(this.#table, k).name).join(", ");
+        sql += ` RETURNING ${cols}`;
+      } else {
+        sql += " RETURNING *";
+      }
+    }
+    return { sql, params };
+  }
+  async execute() {
+    const { sql, params } = this.toSQL();
+    try {
+      if (this.#returning) {
+        const rows = await this.#executor.all(sql, params);
+        const records = rows;
+        if (Array.isArray(this.#returning)) {
+          return records.map((r) => decodeSelectedRow(r, this.#table, this.#returning));
+        }
+        return records.map((r) => decodeRow(r, this.#table));
+      }
+      await this.#executor.run(sql, params);
+      return;
+    } catch (e) {
+      throw new FlintQueryError(`Failed to execute query: ${sql}`, e);
+    }
+  }
+}
+var init_builder = __esm(() => {
+  init_errors();
+});
+
+// src/query/aggregates.ts
+function getTableName(table) {
+  return table._.name;
+}
+function getColumnName(column) {
+  return column.name;
+}
+function compileWhere(condition) {
+  if (!condition) {
+    return { whereSql: "", params: [] };
+  }
+  const params = [];
+  const whereSql = compileCondition(condition, params);
+  return { whereSql: ` WHERE ${whereSql}`, params };
+}
+async function count(executor, table, condition) {
+  const tableName = getTableName(table);
+  const { whereSql, params } = compileWhere(condition);
+  const sql = `SELECT count(*) as cnt FROM ${tableName}${whereSql}`;
+  const result = await executor.get(sql, params);
+  return result.cnt;
+}
+async function countColumn(executor, table, column, condition) {
+  const tableName = getTableName(table);
+  const columnName = getColumnName(column);
+  const { whereSql, params } = compileWhere(condition);
+  const sql = `SELECT count(${columnName}) as cnt FROM ${tableName}${whereSql}`;
+  const result = await executor.get(sql, params);
+  return result.cnt;
+}
+async function sum(executor, table, column, condition) {
+  const tableName = getTableName(table);
+  const columnName = getColumnName(column);
+  const { whereSql, params } = compileWhere(condition);
+  const sql = `SELECT sum(${columnName}) as total FROM ${tableName}${whereSql}`;
+  const result = await executor.get(sql, params);
+  return result.total;
+}
+async function avg(executor, table, column, condition) {
+  const tableName = getTableName(table);
+  const columnName = getColumnName(column);
+  const { whereSql, params } = compileWhere(condition);
+  const sql = `SELECT avg(${columnName}) as average FROM ${tableName}${whereSql}`;
+  const result = await executor.get(sql, params);
+  return result.average;
+}
+async function min(executor, table, column, condition) {
+  const tableName = getTableName(table);
+  const columnName = getColumnName(column);
+  const { whereSql, params } = compileWhere(condition);
+  const sql = `SELECT min(${columnName}) as minimum FROM ${tableName}${whereSql}`;
+  const result = await executor.get(sql, params);
+  return result.minimum;
+}
+async function max(executor, table, column, condition) {
+  const tableName = getTableName(table);
+  const columnName = getColumnName(column);
+  const { whereSql, params } = compileWhere(condition);
+  const sql = `SELECT max(${columnName}) as maximum FROM ${tableName}${whereSql}`;
+  const result = await executor.get(sql, params);
+  return result.maximum;
+}
+var init_aggregates = () => {};
+
+// src/flint.ts
+function createClient(executor) {
+  return {
+    select: () => new SelectFromBuilder(executor),
+    insert: (table) => new InsertValuesBuilder(executor, table._.name, table),
+    update: (table) => new UpdateSetBuilder(executor, table._.name, table),
+    delete: (table) => new DeleteBuilder(executor, table._.name, table),
+    leftJoin: (parent) => new JoinStage1(executor, parent, parent._.name, "left"),
+    innerJoin: (parent) => new JoinStage1(executor, parent, parent._.name, "inner"),
+    batch: (queries) => {
+      const stmts = queries.map((q) => q.toSQL());
+      return executor.transaction(async () => {
+        for (const stmt of stmts) {
+          await executor.run(stmt.sql, stmt.params);
+        }
+      });
+    },
+    count: (table, condition) => count(executor, table, condition),
+    countColumn: (table, column, condition) => countColumn(executor, table, column, condition),
+    sum: (table, column, condition) => sum(executor, table, column, condition),
+    avg: (table, column, condition) => avg(executor, table, column, condition),
+    min: (table, column, condition) => min(executor, table, column, condition),
+    max: (table, column, condition) => max(executor, table, column, condition),
+    $run(query, ...params) {
+      return executor.run(query, params);
+    },
+    $executor: executor
+  };
+}
+function sql(strings, ...values) {
+  let query = "";
+  const params = [];
+  for (let i = 0;i < strings.length; i++) {
+    query += strings[i];
+    if (i < values.length) {
+      query += "?";
+      params.push(values[i]);
+    }
+  }
+  return { sql: query, params };
+}
+var init_flint = __esm(() => {
+  init_builder();
+  init_aggregates();
+});
+
+// src/drivers/turso-sync.ts
+var exports_turso_sync = {};
+__export(exports_turso_sync, {
+  flint: () => flint,
+  TursoSyncExecutor: () => TursoSyncExecutor
+});
+import { resolve } from "path";
+function sanitize(params) {
+  return params.map((p) => p === undefined ? null : p);
+}
+
+class TursoSyncExecutor {
+  #db;
+  constructor(db) {
+    this.#db = db;
+  }
+  async all(sql2, params) {
+    return this.#db.all(sql2, ...sanitize(params));
+  }
+  async get(sql2, params) {
+    return this.#db.get(sql2, ...sanitize(params)) ?? null;
+  }
+  async run(sql2, params) {
+    await this.#db.run(sql2, ...sanitize(params));
+  }
+  async transaction(fn) {
+    await this.#db.exec("BEGIN");
+    try {
+      await fn();
+      await this.#db.exec("COMMIT");
+    } catch (e) {
+      await this.#db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  close() {
+    this.#db.close();
+  }
+}
+async function flint(details) {
+  const localPath = details.url.includes("://") ? details.url : resolve(details.url);
+  const db = await connect2({
+    path: localPath,
+    url: details.syncUrl,
+    authToken: details.authToken
+  });
+  return createClient(new TursoSyncExecutor(db));
+}
+var init_turso_sync = __esm(() => {
+  init_promise2();
+  init_flint();
+});
+
+// src/entries/turso-sync.ts
+init_turso_sync();
+export {
+  flint
+};