zen-code 1.0.0

package/dist/checkpoint-DxiUsHMy-BWKnWBL7.mjs

@@ -0,0 +1,393 @@
+import { T as l, B as N, W as k, m as y } from "./app-CV_FJyjI.mjs";
+import w from "pg";
+const S = (h) => [
+  "checkpoints",
+  "checkpoint_blobs",
+  "checkpoint_migrations",
+  "checkpoint_writes"
+].reduce((t, i) => (t[i] = `${h}.${i}`, t), {}), b = (h) => {
+  const e = S(h);
+  return {
+    SELECT_SQL: `select
+    thread_id,
+    checkpoint,
+    checkpoint_ns,
+    checkpoint_id,
+    parent_checkpoint_id,
+    metadata,
+    (
+      select array_agg(array[bl.channel::bytea, bl.type::bytea, bl.blob])
+      from jsonb_each_text(checkpoint -> 'channel_versions')
+      inner join ${e.checkpoint_blobs} bl
+        on bl.thread_id = cp.thread_id
+        and bl.checkpoint_ns = cp.checkpoint_ns
+        and bl.channel = jsonb_each_text.key
+        and bl.version = jsonb_each_text.value
+    ) as channel_values,
+    (
+      select
+      array_agg(array[cw.task_id::text::bytea, cw.channel::bytea, cw.type::bytea, cw.blob] order by cw.task_id, cw.idx)
+      from ${e.checkpoint_writes} cw
+      where cw.thread_id = cp.thread_id
+        and cw.checkpoint_ns = cp.checkpoint_ns
+        and cw.checkpoint_id = cp.checkpoint_id
+    ) as pending_writes
+  from ${e.checkpoints} cp `,
+    SELECT_PENDING_SENDS_SQL: `select
+      checkpoint_id,
+      array_agg(array[cw.type::bytea, cw.blob] order by cw.task_id, cw.idx) as pending_sends
+    from ${e.checkpoint_writes} cw
+    where cw.thread_id = $1
+      and cw.checkpoint_id = any($2)
+      and cw.channel = '${l}'
+    group by cw.checkpoint_id
+  `,
+    UPSERT_CHECKPOINT_BLOBS_SQL: `INSERT INTO ${e.checkpoint_blobs} (thread_id, checkpoint_ns, channel, version, type, blob)
+  VALUES ($1, $2, $3, $4, $5, $6)
+  ON CONFLICT (thread_id, checkpoint_ns, channel, version) DO NOTHING
+  `,
+    UPSERT_CHECKPOINTS_SQL: `INSERT INTO ${e.checkpoints} (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, checkpoint, metadata)
+  VALUES ($1, $2, $3, $4, $5, $6)
+  ON CONFLICT (thread_id, checkpoint_ns, checkpoint_id)
+  DO UPDATE SET
+    checkpoint = EXCLUDED.checkpoint,
+    metadata = EXCLUDED.metadata;
+  `,
+    UPSERT_CHECKPOINT_WRITES_SQL: `INSERT INTO ${e.checkpoint_writes} (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+  ON CONFLICT (thread_id, checkpoint_ns, checkpoint_id, task_id, idx) DO UPDATE SET
+    channel = EXCLUDED.channel,
+    type = EXCLUDED.type,
+    blob = EXCLUDED.blob;
+  `,
+    INSERT_CHECKPOINT_WRITES_SQL: `INSERT INTO ${e.checkpoint_writes} (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, blob)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+  ON CONFLICT (thread_id, checkpoint_ns, checkpoint_id, task_id, idx) DO NOTHING
+  `,
+    DELETE_CHECKPOINTS_SQL: `DELETE FROM ${e.checkpoints} WHERE thread_id = $1`,
+    DELETE_CHECKPOINT_BLOBS_SQL: `DELETE FROM ${e.checkpoint_blobs} WHERE thread_id = $1`,
+    DELETE_CHECKPOINT_WRITES_SQL: `DELETE FROM ${e.checkpoint_writes} WHERE thread_id = $1`
+  };
+}, O = (h) => {
+  const e = S(h);
+  return [
+    `CREATE TABLE IF NOT EXISTS ${e.checkpoint_migrations} (
+    v INTEGER PRIMARY KEY
+  );`,
+    `CREATE TABLE IF NOT EXISTS ${e.checkpoints} (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    checkpoint_id TEXT NOT NULL,
+    parent_checkpoint_id TEXT,
+    type TEXT,
+    checkpoint JSONB NOT NULL,
+    metadata JSONB NOT NULL DEFAULT '{}',
+    PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+  );`,
+    `CREATE TABLE IF NOT EXISTS ${e.checkpoint_blobs} (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    channel TEXT NOT NULL,
+    version TEXT NOT NULL,
+    type TEXT NOT NULL,
+    blob BYTEA,
+    PRIMARY KEY (thread_id, checkpoint_ns, channel, version)
+  );`,
+    `CREATE TABLE IF NOT EXISTS ${e.checkpoint_writes} (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    checkpoint_id TEXT NOT NULL,
+    task_id TEXT NOT NULL,
+    idx INTEGER NOT NULL,
+    channel TEXT NOT NULL,
+    type TEXT,
+    blob BYTEA NOT NULL,
+    PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+  );`,
+    `ALTER TABLE ${e.checkpoint_blobs} ALTER COLUMN blob DROP not null;`
+  ];
+}, C = { schema: "public" }, g = (h) => ({
+  ...h,
+  schema: h?.schema ?? C.schema
+}), { Pool: I } = w;
+var $ = class L extends N {
+  pool;
+  options;
+  SQL_STATEMENTS;
+  isSetup;
+  constructor(e, t, i) {
+    super(t), this.pool = e, this.isSetup = !1, this.options = g(i), this.SQL_STATEMENTS = b(this.options.schema);
+  }
+  /**
+  * Creates a new instance of PostgresSaver from a connection string.
+  *
+  * @param {string} connString - The connection string to connect to the Postgres database.
+  * @param {PostgresSaverOptions} [options] - Optional configuration object.
+  * @returns {PostgresSaver} A new instance of PostgresSaver.
+  *
+  * @example
+  * const connString = "postgresql://user:password@localhost:5432/db";
+  * const checkpointer = PostgresSaver.fromConnString(connString, {
+  *  schema: "custom_schema" // defaults to "public"
+  * });
+  * await checkpointer.setup();
+  */
+  static fromConnString(e, t) {
+    const i = new I({ connectionString: e });
+    return new L(i, void 0, t);
+  }
+  /**
+  * Set up the checkpoint database asynchronously.
+  *
+  * This method creates the necessary tables in the Postgres database if they don't
+  * already exist and runs database migrations. It MUST be called directly by the user
+  * the first time checkpointer is used.
+  */
+  async setup() {
+    const e = await this.pool.connect(), t = S(this.options.schema);
+    try {
+      await e.query(`CREATE SCHEMA IF NOT EXISTS ${this.options.schema}`);
+      let i = -1;
+      const c = O(this.options.schema);
+      try {
+        const n = await e.query(`SELECT v FROM ${t.checkpoint_migrations} ORDER BY v DESC LIMIT 1`);
+        n.rows.length > 0 && (i = n.rows[0].v);
+      } catch (n) {
+        if (typeof n == "object" && n !== null && "code" in n && typeof n.code == "string" && n.code === "42P01") i = -1;
+        else throw n;
+      }
+      for (let n = i + 1; n < c.length; n += 1)
+        await e.query(c[n]), await e.query(`INSERT INTO ${t.checkpoint_migrations} (v) VALUES ($1)`, [n]);
+    } finally {
+      e.release();
+    }
+  }
+  async _loadCheckpoint(e, t) {
+    return {
+      ...e,
+      channel_values: await this._loadBlobs(t)
+    };
+  }
+  async _loadBlobs(e) {
+    if (!e || e.length === 0) return {};
+    const t = new TextDecoder(), i = await Promise.all(e.filter(([, c]) => t.decode(c) !== "empty").map(async ([c, n, a]) => [t.decode(c), await this.serde.loadsTyped(t.decode(n), a)]));
+    return Object.fromEntries(i);
+  }
+  async _loadMetadata(e) {
+    const [t, i] = await this.serde.dumpsTyped(e);
+    return this.serde.loadsTyped(t, i);
+  }
+  async _loadWrites(e) {
+    const t = new TextDecoder();
+    return e ? await Promise.all(e.map(async ([i, c, n, a]) => [
+      t.decode(i),
+      t.decode(c),
+      await this.serde.loadsTyped(t.decode(n), a)
+    ])) : [];
+  }
+  async _dumpBlobs(e, t, i, c) {
+    return Object.keys(c).length === 0 ? [] : Promise.all(Object.entries(c).map(async ([n, a]) => {
+      const [r, o] = n in i ? await this.serde.dumpsTyped(i[n]) : ["empty", null];
+      return [
+        e,
+        t,
+        n,
+        a.toString(),
+        r,
+        o ? new Uint8Array(o) : void 0
+      ];
+    }));
+  }
+  _dumpCheckpoint(e) {
+    const t = { ...e };
+    return "channel_values" in t && delete t.channel_values, t;
+  }
+  async _dumpMetadata(e) {
+    const [, t] = await this.serde.dumpsTyped(e);
+    return JSON.parse(new TextDecoder().decode(t).replace(/\0/g, ""));
+  }
+  async _dumpWrites(e, t, i, c, n) {
+    return Promise.all(n.map(async ([a, r], o) => {
+      const [d, p] = await this.serde.dumpsTyped(r);
+      return [
+        e,
+        t,
+        i,
+        c,
+        k[a] ?? o,
+        a,
+        d,
+        new Uint8Array(p)
+      ];
+    }));
+  }
+  /**
+  * Return WHERE clause predicates for a given list() config, filter, cursor.
+  *
+  * This method returns a tuple of a string and a tuple of values. The string
+  * is the parameterized WHERE clause predicate (including the WHERE keyword):
+  * "WHERE column1 = $1 AND column2 IS $2". The list of values contains the
+  * values for each of the corresponding parameters.
+  */
+  _searchWhere(e, t, i) {
+    const c = [], n = [];
+    return e?.configurable?.thread_id && (c.push(`thread_id = $${n.length + 1}`), n.push(e.configurable.thread_id)), e?.configurable?.checkpoint_ns !== void 0 && e?.configurable?.checkpoint_ns !== null && (c.push(`checkpoint_ns = $${n.length + 1}`), n.push(e.configurable.checkpoint_ns)), e?.configurable?.checkpoint_id && (c.push(`checkpoint_id = $${n.length + 1}`), n.push(e.configurable.checkpoint_id)), t && Object.keys(t).length > 0 && (c.push(`metadata @> $${n.length + 1}`), n.push(JSON.stringify(t))), i?.configurable?.checkpoint_id !== void 0 && (c.push(`checkpoint_id < $${n.length + 1}`), n.push(i.configurable.checkpoint_id)), [c.length > 0 ? `WHERE ${c.join(" AND ")}` : "", n];
+  }
+  /**
+  * Get a checkpoint tuple from the database.
+  * This method retrieves a checkpoint tuple from the Postgres database
+  * based on the provided config. If the config's configurable field contains
+  * a "checkpoint_id" key, the checkpoint with the matching thread_id and
+  * namespace is retrieved. Otherwise, the latest checkpoint for the given
+  * thread_id is retrieved.
+  * @param config The config to use for retrieving the checkpoint.
+  * @returns The retrieved checkpoint tuple, or undefined.
+  */
+  async getTuple(e) {
+    const { thread_id: t, checkpoint_ns: i = "", checkpoint_id: c } = e.configurable ?? {};
+    let n, a;
+    c ? (a = "WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3", n = [
+      t,
+      i,
+      c
+    ]) : (a = "WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1", n = [t, i]);
+    const r = await this.pool.query(this.SQL_STATEMENTS.SELECT_SQL + a, n), [o] = r.rows;
+    if (o === void 0) return;
+    if (o.checkpoint.v < 4 && o.parent_checkpoint_id != null) {
+      const T = await this.pool.query(this.SQL_STATEMENTS.SELECT_PENDING_SENDS_SQL, [t, [o.parent_checkpoint_id]]), [u] = T.rows;
+      u != null && await this._migratePendingSends(u.pending_sends, o);
+    }
+    const d = await this._loadCheckpoint(o.checkpoint, o.channel_values), p = { configurable: {
+      thread_id: t,
+      checkpoint_ns: i,
+      checkpoint_id: o.checkpoint_id
+    } }, s = await this._loadMetadata(o.metadata), E = o.parent_checkpoint_id ? { configurable: {
+      thread_id: t,
+      checkpoint_ns: i,
+      checkpoint_id: o.parent_checkpoint_id
+    } } : void 0, _ = await this._loadWrites(o.pending_writes);
+    return {
+      config: p,
+      checkpoint: d,
+      metadata: s,
+      parentConfig: E,
+      pendingWrites: _
+    };
+  }
+  /**
+  * List checkpoints from the database.
+  *
+  * This method retrieves a list of checkpoint tuples from the Postgres database based
+  * on the provided config. The checkpoints are ordered by checkpoint ID in descending order (newest first).
+  */
+  async *list(e, t) {
+    const { filter: i, before: c, limit: n } = t ?? {}, [a, r] = this._searchWhere(e, i, c);
+    let o = `${this.SQL_STATEMENTS.SELECT_SQL}${a} ORDER BY checkpoint_id DESC`;
+    n !== void 0 && (o += ` LIMIT ${Number.parseInt(n.toString(), 10)}`);
+    const d = await this.pool.query(o, r), p = d.rows.filter((s) => s.checkpoint.v < 4 && s.parent_checkpoint_id != null);
+    if (p.length > 0) {
+      const s = await this.pool.query(this.SQL_STATEMENTS.SELECT_PENDING_SENDS_SQL, [p[0].thread_id, p.map((_) => _.parent_checkpoint_id)]), E = p.reduce((_, T) => (T.parent_checkpoint_id && (_[T.parent_checkpoint_id] ??= [], _[T.parent_checkpoint_id].push(T)), _), {});
+      for (const _ of s.rows) for (const T of E[_.checkpoint_id]) await this._migratePendingSends(_.pending_sends, T);
+    }
+    for (const s of d.rows) yield {
+      config: { configurable: {
+        thread_id: s.thread_id,
+        checkpoint_ns: s.checkpoint_ns,
+        checkpoint_id: s.checkpoint_id
+      } },
+      checkpoint: await this._loadCheckpoint(s.checkpoint, s.channel_values),
+      metadata: await this._loadMetadata(s.metadata),
+      parentConfig: s.parent_checkpoint_id ? { configurable: {
+        thread_id: s.thread_id,
+        checkpoint_ns: s.checkpoint_ns,
+        checkpoint_id: s.parent_checkpoint_id
+      } } : void 0,
+      pendingWrites: await this._loadWrites(s.pending_writes)
+    };
+  }
+  /** @internal */
+  async _migratePendingSends(e, t) {
+    const i = new TextEncoder(), c = new TextDecoder(), n = t, [a, r] = await this.serde.dumpsTyped(await Promise.all(e.map(([o, d]) => this.serde.loadsTyped(c.decode(o), d))));
+    n.channel_values ??= [], n.channel_values.push([
+      i.encode(l),
+      i.encode(a),
+      r
+    ]), n.checkpoint.channel_versions[l] = Object.keys(t.checkpoint.channel_versions).length > 0 ? y(...Object.values(t.checkpoint.channel_versions)) : this.getNextVersion(void 0);
+  }
+  /**
+  * Save a checkpoint to the database.
+  *
+  * This method saves a checkpoint to the Postgres database. The checkpoint is associated
+  * with the provided config and its parent config (if any).
+  * @param config
+  * @param checkpoint
+  * @param metadata
+  * @returns
+  */
+  async put(e, t, i, c) {
+    if (e.configurable === void 0) throw new Error('Missing "configurable" field in "config" param');
+    const { thread_id: n, checkpoint_ns: a = "", checkpoint_id: r } = e.configurable, o = { configurable: {
+      thread_id: n,
+      checkpoint_ns: a,
+      checkpoint_id: t.id
+    } }, d = await this.pool.connect(), p = this._dumpCheckpoint(t);
+    try {
+      await d.query("BEGIN");
+      const s = await this._dumpBlobs(n, a, t.channel_values, c);
+      for (const E of s) await d.query(this.SQL_STATEMENTS.UPSERT_CHECKPOINT_BLOBS_SQL, E);
+      await d.query(this.SQL_STATEMENTS.UPSERT_CHECKPOINTS_SQL, [
+        n,
+        a,
+        t.id,
+        r,
+        p,
+        await this._dumpMetadata(i)
+      ]), await d.query("COMMIT");
+    } catch (s) {
+      throw await d.query("ROLLBACK"), s;
+    } finally {
+      d.release();
+    }
+    return o;
+  }
+  /**
+  * Store intermediate writes linked to a checkpoint.
+  *
+  * This method saves intermediate writes associated with a checkpoint to the Postgres database.
+  * @param config Configuration of the related checkpoint.
+  * @param writes List of writes to store.
+  * @param taskId Identifier for the task creating the writes.
+  */
+  async putWrites(e, t, i) {
+    const c = t.every((r) => r[0] in k) ? this.SQL_STATEMENTS.UPSERT_CHECKPOINT_WRITES_SQL : this.SQL_STATEMENTS.INSERT_CHECKPOINT_WRITES_SQL, n = await this._dumpWrites(e.configurable?.thread_id, e.configurable?.checkpoint_ns, e.configurable?.checkpoint_id, i, t), a = await this.pool.connect();
+    try {
+      await a.query("BEGIN");
+      for await (const r of n) await a.query(c, r);
+      await a.query("COMMIT");
+    } catch (r) {
+      throw await a.query("ROLLBACK"), r;
+    } finally {
+      a.release();
+    }
+  }
+  async end() {
+    return this.pool.end();
+  }
+  async deleteThread(e) {
+    const t = await this.pool.connect();
+    try {
+      await t.query("BEGIN"), await t.query(this.SQL_STATEMENTS.DELETE_CHECKPOINT_BLOBS_SQL, [e]), await t.query(this.SQL_STATEMENTS.DELETE_CHECKPOINTS_SQL, [e]), await t.query(this.SQL_STATEMENTS.DELETE_CHECKPOINT_WRITES_SQL, [e]), await t.query("COMMIT");
+    } catch (i) {
+      throw await t.query("ROLLBACK"), i;
+    } finally {
+      t.release();
+    }
+  }
+};
+const A = async () => {
+  const h = $.fromConnString(process.env.DATABASE_URL);
+  return process.env.DATABASE_INIT === "true" && (console.debug("LG | Initializing postgres checkpoint"), await h.setup()), h;
+};
+export {
+  A as createPGCheckpoint
+};

package/dist/chunk-YWE62C55-DID9N9eS.mjs

@@ -0,0 +1,193 @@
+import { D as w, b as y, c as b, a as f, C as o } from "./migrator-BatO36Tk.mjs";
+import { F as g, aS as p, ah as v } from "./sql-CJsUpKEQ.mjs";
+const _ = /"/g;
+class T extends w {
+  visitOrAction(e) {
+    this.append("or "), this.append(e.action);
+  }
+  getCurrentParameterPlaceholder() {
+    return "?";
+  }
+  getLeftExplainOptionsWrapper() {
+    return "";
+  }
+  getRightExplainOptionsWrapper() {
+    return "";
+  }
+  getLeftIdentifierWrapper() {
+    return '"';
+  }
+  getRightIdentifierWrapper() {
+    return '"';
+  }
+  getAutoIncrement() {
+    return "autoincrement";
+  }
+  sanitizeIdentifier(e) {
+    return e.replace(_, '""');
+  }
+  visitDefaultInsertValue(e) {
+    this.append("null");
+  }
+}
+class k {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  async getSchemas() {
+    return [];
+  }
+  async getTables(e = { withInternalKyselyTables: !1 }) {
+    return await this.#a(e);
+  }
+  async getMetadata(e) {
+    return {
+      tables: await this.getTables(e)
+    };
+  }
+  #t(e, r) {
+    let n = e.selectFrom("sqlite_master").where("type", "in", ["table", "view"]).where("name", "not like", "sqlite_%").select(["name", "sql", "type"]).orderBy("name");
+    return r.withInternalKyselyTables || (n = n.where("name", "!=", y).where("name", "!=", b)), n;
+  }
+  async #a(e) {
+    const r = await this.#t(this.#e, e).execute(), n = await this.#e.with("table_list", (i) => this.#t(i, e)).selectFrom([
+      "table_list as tl",
+      g`pragma_table_info(tl.name)`.as("p")
+    ]).select([
+      "tl.name as table",
+      "p.cid",
+      "p.name",
+      "p.type",
+      "p.notnull",
+      "p.dflt_value",
+      "p.pk"
+    ]).orderBy("tl.name").orderBy("p.cid").execute(), s = {};
+    for (const i of n)
+      s[i.table] ??= [], s[i.table].push(i);
+    return r.map(({ name: i, sql: m, type: h }) => {
+      let l = m?.split(/[\(\),]/)?.find((a) => a.toLowerCase().includes("autoincrement"))?.trimStart()?.split(/\s+/)?.[0]?.replace(/["`]/g, "");
+      const u = s[i] ?? [];
+      if (!l) {
+        const a = u.filter((d) => d.pk > 0);
+        a.length === 1 && a[0].type.toLowerCase() === "integer" && (l = a[0].name);
+      }
+      return {
+        name: i,
+        isView: h === "view",
+        columns: u.map((a) => ({
+          name: a.name,
+          dataType: a.type,
+          isNullable: !a.notnull,
+          isAutoIncrementing: a.name === l,
+          hasDefaultValue: a.dflt_value != null,
+          comment: void 0
+        }))
+      };
+    });
+  }
+}
+class C extends f {
+  get supportsTransactionalDdl() {
+    return !1;
+  }
+  get supportsReturning() {
+    return !0;
+  }
+  async acquireMigrationLock(e, r) {
+  }
+  async releaseMigrationLock(e, r) {
+  }
+}
+var A = class {
+  /**
+   * Base class that implements {@link Dialect}
+   * @param create function that create {@link Driver}
+   */
+  constructor(t) {
+    this.createDriver = t;
+  }
+  createDriver;
+  createQueryCompiler() {
+    return new T();
+  }
+  createAdapter() {
+    return new C();
+  }
+  createIntrospector(t) {
+    return new k(t);
+  }
+}, S = class {
+  promise;
+  resolve;
+  async lock() {
+    for (; this.promise; )
+      await this.promise;
+    this.promise = new Promise((t) => {
+      this.resolve = t;
+    });
+  }
+  unlock() {
+    const t = this.resolve;
+    this.promise = void 0, this.resolve = void 0, t?.();
+  }
+};
+async function c(t, e, r, n, s) {
+  await r.executeQuery(
+    s(
+      p.createWithChildren([
+        p.createWithSql(`${t} `),
+        v.create(n)
+        // ensures savepointName gets sanitized
+      ]),
+      e()
+    )
+  );
+}
+var D = class {
+  mutex = new S();
+  conn;
+  savepoint;
+  releaseSavepoint;
+  rollbackToSavepoint;
+  init;
+  /**
+   * Base abstract class that implements {@link Driver}
+   *
+   * You **MUST** assign `this.conn` in `init` and implement `destroy` method
+   */
+  constructor(t) {
+    this.init = () => import("./index-DS5HVciX.mjs").then(({ createQueryId: e }) => {
+      e && (this.savepoint = c.bind(null, "savepoint", e), this.releaseSavepoint = c.bind(null, "release", e), this.rollbackToSavepoint = c.bind(null, "rollback to", e));
+    }).then(t);
+  }
+  async acquireConnection() {
+    return await this.mutex.lock(), this.conn;
+  }
+  async beginTransaction(t) {
+    await t.executeQuery(o.raw("begin"));
+  }
+  async commitTransaction(t) {
+    await t.executeQuery(o.raw("commit"));
+  }
+  async rollbackTransaction(t) {
+    await t.executeQuery(o.raw("rollback"));
+  }
+  async releaseConnection() {
+    this.mutex.unlock();
+  }
+};
+function q(t) {
+  return async (e, r, n) => {
+    const s = await t.all(r, n);
+    return e || s.length ? { rows: s } : { rows: [], ...await t.run("select 1") };
+  };
+}
+export {
+  A as B,
+  T as S,
+  k as a,
+  C as b,
+  D as c,
+  q as d
+};