mtok-relay 0.2.6 → 0.2.8

package/dist/mtok-relay.mjs

@@ -13,11 +13,11 @@ function anumber(n) {
   if (!Number.isSafeInteger(n) || n < 0)
     throw new Error("positive integer expected, got " + n);
 }
-function abytes(b, ...lengths) {
-  if (!isBytes(b))
+function abytes(b2, ...lengths) {
+  if (!isBytes(b2))
     throw new Error("Uint8Array expected");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+  if (lengths.length > 0 && !lengths.includes(b2.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b2.length);
 }
 function ahash(h) {
   if (typeof h !== "function" || typeof h.create !== "function")
@@ -251,12 +251,12 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   let v = u8n(hashLen);
   let k = u8n(hashLen);
   let i = 0;
-  const reset = () => {
+  const reset2 = () => {
     v.fill(1);
     k.fill(0);
     i = 0;
   };
-  const h = (...b) => hmacFn(k, v, ...b);
+  const h = (...b2) => hmacFn(k, v, ...b2);
   const reseed = (seed = u8n(0)) => {
     k = h(u8fr([0]), seed);
     v = h();
@@ -279,12 +279,12 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     return concatBytes2(...out);
   };
   const genUntil = (seed, pred) => {
-    reset();
+    reset2();
     reseed(seed);
     let res = void 0;
     while (!(res = pred(gen2())))
       reseed();
-    reset();
+    reset2();
     return res;
   };
   return genUntil;
@@ -338,9 +338,9 @@ var _3n = /* @__PURE__ */ BigInt(3);
 var _4n = /* @__PURE__ */ BigInt(4);
 var _5n = /* @__PURE__ */ BigInt(5);
 var _8n = /* @__PURE__ */ BigInt(8);
-function mod(a, b) {
-  const result = a % b;
-  return result >= _0n2 ? result : b + result;
+function mod(a, b2) {
+  const result = a % b2;
+  return result >= _0n2 ? result : b2 + result;
 }
 function pow2(x, power, modulo) {
   let res = x;
@@ -356,16 +356,16 @@ function invert(number, modulo) {
   if (modulo <= _0n2)
     throw new Error("invert: expected positive modulus, got " + modulo);
   let a = mod(number, modulo);
-  let b = modulo;
+  let b2 = modulo;
   let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
   while (a !== _0n2) {
-    const q = b / a;
-    const r = b % a;
+    const q = b2 / a;
+    const r = b2 % a;
     const m = x - u * q;
     const n = y - v * q;
-    b = a, a = r, x = u, y = v, u = m, v = n;
+    b2 = a, a = r, x = u, y = v, u = m, v = n;
   }
-  const gcd = b;
+  const gcd = b2;
   if (gcd !== _1n2)
     throw new Error("invert: does not exist");
   return mod(x, modulo);
@@ -428,11 +428,11 @@ function tonelliShanks(P) {
           throw new Error("Cannot find square root");
       }
       const exponent = _1n2 << BigInt(M - i - 1);
-      const b = Fp.pow(c, exponent);
+      const b2 = Fp.pow(c, exponent);
       M = i;
-      c = Fp.sqr(b);
+      c = Fp.sqr(b2);
       t = Fp.mul(t, c);
-      R = Fp.mul(R, b);
+      R = Fp.mul(R, b2);
     }
     return R;
   };
@@ -579,7 +579,7 @@ function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
     invertBatch: (lst) => FpInvertBatch(f, lst),
     // We can't move this out because Fp6, Fp12 implement it
     // and it's unclear what to return in there.
-    cmov: (a, b, c) => c ? b : a
+    cmov: (a, b2, c) => c ? b2 : a
   });
   return Object.freeze(f);
 }
@@ -617,11 +617,11 @@ function setBigUint64(view, byteOffset, value, isLE2) {
   view.setUint32(byteOffset + h, wh, isLE2);
   view.setUint32(byteOffset + l, wl, isLE2);
 }
-function Chi(a, b, c) {
-  return a & b ^ ~a & c;
+function Chi(a, b2, c) {
+  return a & b2 ^ ~a & c;
 }
-function Maj(a, b, c) {
-  return a & b ^ a & c ^ b & c;
+function Maj(a, b2, c) {
+  return a & b2 ^ a & c ^ b2 & c;
 }
 var HashMD = class extends Hash {
   constructor(blockLen, outputLen, padOffset, isLE2) {
@@ -641,7 +641,7 @@ var HashMD = class extends Hash {
     aexists(this);
     data = toBytes(data);
     abytes(data);
-    const { view, buffer, blockLen } = this;
+    const { view, buffer: buffer2, blockLen } = this;
     const len = data.length;
     for (let pos = 0; pos < len; ) {
       const take = Math.min(blockLen - this.pos, len - pos);
@@ -651,7 +651,7 @@ var HashMD = class extends Hash {
           this.process(dataView, pos);
         continue;
       }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
+      buffer2.set(data.subarray(pos, pos + take), this.pos);
       this.pos += take;
       pos += take;
       if (this.pos === blockLen) {
@@ -667,16 +667,16 @@ var HashMD = class extends Hash {
     aexists(this);
     aoutput(out, this);
     this.finished = true;
-    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    const { buffer: buffer2, view, blockLen, isLE: isLE2 } = this;
     let { pos } = this;
-    buffer[pos++] = 128;
+    buffer2[pos++] = 128;
     clean(this.buffer.subarray(pos));
     if (this.padOffset > blockLen - pos) {
       this.process(view, 0);
       pos = 0;
     }
     for (let i = pos; i < blockLen; i++)
-      buffer[i] = 0;
+      buffer2[i] = 0;
     setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
     this.process(view, 0);
     const oview = createView(out);
@@ -691,22 +691,22 @@ var HashMD = class extends Hash {
       oview.setUint32(4 * i, state[i], isLE2);
   }
   digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
+    const { buffer: buffer2, outputLen } = this;
+    this.digestInto(buffer2);
+    const res = buffer2.slice(0, outputLen);
     this.destroy();
     return res;
   }
   _cloneInto(to) {
     to || (to = new this.constructor());
     to.set(...this.get());
-    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    const { blockLen, buffer: buffer2, length, finished, destroyed, pos } = this;
     to.destroyed = destroyed;
     to.finished = finished;
     to.length = length;
     to.pos = pos;
     if (length % blockLen)
-      to.buffer.set(buffer);
+      to.buffer.set(buffer2);
     return to;
   }
   clone() {
@@ -1269,8 +1269,8 @@ var DER = {
           throw new E("tlv.decode: length bytes not complete");
         if (lengthBytes[0] === 0)
           throw new E("tlv.decode(long): zero leftmost byte");
-        for (const b of lengthBytes)
-          length = length << 8 | b;
+        for (const b2 of lengthBytes)
+          length = length << 8 | b2;
         pos += lenLen;
         if (length < 128)
           throw new E("tlv.decode(long): not minimal encoding");
@@ -1326,8 +1326,8 @@ var DER = {
     return tlv.encode(48, seq);
   }
 };
-function numToSizedHex(num, size2) {
-  return bytesToHex(numberToBytesBE(num, size2));
+function numToSizedHex(num, size3) {
+  return bytesToHex(numberToBytesBE(num, size3));
 }
 var _0n4 = BigInt(0);
 var _1n4 = BigInt(1);
@@ -1349,10 +1349,10 @@ function weierstrassPoints(opts) {
     return { x, y };
   });
   function weierstrassEquation(x) {
-    const { a, b } = CURVE;
+    const { a, b: b2 } = CURVE;
     const x2 = Fp.sqr(x);
     const x3 = Fp.mul(x2, x);
-    return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
+    return Fp.add(Fp.add(x3, Fp.mul(x, a)), b2);
   }
   function isValidXY(x, y) {
     const left = Fp.sqr(y);
@@ -1518,8 +1518,8 @@ function weierstrassPoints(opts) {
     // https://eprint.iacr.org/2015/1060, algorithm 3
     // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
     double() {
-      const { a, b } = CURVE;
-      const b3 = Fp.mul(b, _3n2);
+      const { a, b: b2 } = CURVE;
+      const b3 = Fp.mul(b2, _3n2);
       const { px: X1, py: Y1, pz: Z1 } = this;
       let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
       let t0 = Fp.mul(X1, X1);
@@ -1687,10 +1687,10 @@ function weierstrassPoints(opts) {
      * The trick could be useful if both P and Q are not G (not in our case).
      * @returns non-zero affine point
      */
-    multiplyAndAddUnsafe(Q, a, b) {
+    multiplyAndAddUnsafe(Q, a, b2) {
       const G = Point.BASE;
       const mul = (P, a2) => a2 === _0n4 || a2 === _1n4 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
-      const sum = mul(this, a).add(mul(Q, b));
+      const sum = mul(this, a).add(mul(Q, b2));
       return sum.is0() ? void 0 : sum;
     }
     // Converts Projective point to affine (x, y) coordinates.
@@ -1813,7 +1813,7 @@ function weierstrass(curveDef) {
   function normalizeS(s) {
     return isBiggerThanHalfOrder(s) ? modN(-s) : s;
   }
-  const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
+  const slcNum = (b2, from, to) => bytesToNumberBE(b2.slice(from, to));
   class Signature {
     constructor(r, s, recovery) {
       aInRange("r", r, _1n4, CURVE_ORDER);
@@ -1943,8 +1943,8 @@ function weierstrass(curveDef) {
       throw new Error("first arg must be private key");
     if (isProbPub(publicB) === false)
       throw new Error("second arg must be public key");
-    const b = Point.fromHex(publicB);
-    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
+    const b2 = Point.fromHex(publicB);
+    return b2.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
   }
   const bits2int = CURVE.bits2int || function(bytes) {
     if (bytes.length > 8192)
@@ -2094,7 +2094,7 @@ var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25
 var _0n5 = BigInt(0);
 var _1n5 = BigInt(1);
 var _2n3 = BigInt(2);
-var divNearest = (a, b) => (a + b / _2n3) / b;
+var divNearest = (a, b2) => (a + b2 / _2n3) / b2;
 function sqrtMod(y) {
   const P = secp256k1P;
   const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
@@ -2245,8 +2245,8 @@ function walk(err, fn) {
 
 // node_modules/viem/_esm/errors/encoding.js
 var IntegerOutOfRangeError = class extends BaseError {
-  constructor({ max, min, signed, size: size2, value }) {
-    super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+  constructor({ max, min, signed, size: size3, value }) {
+    super(`Number "${value}" is not in safe ${size3 ? `${size3 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
   }
 };
 var SizeOverflowError = class extends BaseError {
@@ -2257,47 +2257,47 @@ var SizeOverflowError = class extends BaseError {
 
 // node_modules/viem/_esm/errors/data.js
 var SliceOffsetOutOfBoundsError = class extends BaseError {
-  constructor({ offset, position, size: size2 }) {
-    super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
+  constructor({ offset, position, size: size3 }) {
+    super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size3}).`, { name: "SliceOffsetOutOfBoundsError" });
   }
 };
 var SizeExceedsPaddingSizeError = class extends BaseError {
-  constructor({ size: size2, targetSize, type }) {
-    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+  constructor({ size: size3, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size3}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
   }
 };
 
 // node_modules/viem/_esm/utils/data/pad.js
-function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+function pad(hexOrBytes, { dir, size: size3 = 32 } = {}) {
   if (typeof hexOrBytes === "string")
-    return padHex(hexOrBytes, { dir, size: size2 });
-  return padBytes(hexOrBytes, { dir, size: size2 });
+    return padHex(hexOrBytes, { dir, size: size3 });
+  return padBytes(hexOrBytes, { dir, size: size3 });
 }
-function padHex(hex_, { dir, size: size2 = 32 } = {}) {
-  if (size2 === null)
+function padHex(hex_, { dir, size: size3 = 32 } = {}) {
+  if (size3 === null)
     return hex_;
   const hex = hex_.replace("0x", "");
-  if (hex.length > size2 * 2)
+  if (hex.length > size3 * 2)
     throw new SizeExceedsPaddingSizeError({
       size: Math.ceil(hex.length / 2),
-      targetSize: size2,
+      targetSize: size3,
       type: "hex"
     });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
 }
-function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
-  if (size2 === null)
+function padBytes(bytes, { dir, size: size3 = 32 } = {}) {
+  if (size3 === null)
     return bytes;
-  if (bytes.length > size2)
+  if (bytes.length > size3)
     throw new SizeExceedsPaddingSizeError({
       size: bytes.length,
-      targetSize: size2,
+      targetSize: size3,
       type: "bytes"
     });
-  const paddedBytes = new Uint8Array(size2);
-  for (let i = 0; i < size2; i++) {
+  const paddedBytes = new Uint8Array(size3);
+  for (let i = 0; i < size3; i++) {
     const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+    paddedBytes[padEnd ? i : size3 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
   }
   return paddedBytes;
 }
@@ -2409,11 +2409,11 @@ function stringToBytes(value, opts = {}) {
 }
 
 // node_modules/viem/_esm/utils/encoding/fromHex.js
-function assertSize(hexOrBytes, { size: size2 }) {
-  if (size(hexOrBytes) > size2)
+function assertSize(hexOrBytes, { size: size3 }) {
+  if (size(hexOrBytes) > size3)
     throw new SizeOverflowError({
       givenSize: size(hexOrBytes),
-      maxSize: size2
+      maxSize: size3
     });
 }
 function hexToBigInt(hex, opts = {}) {
@@ -2423,11 +2423,11 @@ function hexToBigInt(hex, opts = {}) {
   const value = BigInt(hex);
   if (!signed)
     return value;
-  const size2 = Math.ceil((hex.length - 2) / 2);
-  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  const size3 = Math.ceil((hex.length - 2) / 2);
+  const max = (1n << BigInt(size3) * 8n - 1n) - 1n;
   if (value <= max)
     return value;
-  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
+  return value - BigInt(`0x${"f".padStart(size3 * 2, "f")}`) - 1n;
 }
 function hexToNumber2(hex, opts = {}) {
   const value = hexToBigInt(hex, opts);
@@ -2476,14 +2476,14 @@ function bytesToHex2(value, opts = {}) {
   return hex;
 }
 function numberToHex(value_, opts = {}) {
-  const { signed, size: size2 } = opts;
+  const { signed, size: size3 } = opts;
   const value = BigInt(value_);
   let maxValue;
-  if (size2) {
+  if (size3) {
     if (signed)
-      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+      maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
     else
-      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+      maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
   } else if (typeof value_ === "number") {
     maxValue = BigInt(Number.MAX_SAFE_INTEGER);
   }
@@ -2494,13 +2494,13 @@ function numberToHex(value_, opts = {}) {
       max: maxValue ? `${maxValue}${suffix}` : void 0,
       min: `${minValue}${suffix}`,
       signed,
-      size: size2,
+      size: size3,
       value: `${value_}${suffix}`
     });
   }
-  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
-  if (size2)
-    return pad(hex, { size: size2 });
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size3 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size3)
+    return pad(hex, { size: size3 });
   return hex;
 }
 var encoder2 = /* @__PURE__ */ new TextEncoder();
@@ -2511,7 +2511,7 @@ function stringToHex(value_, opts = {}) {
 
 // node_modules/viem/_esm/utils/lru.js
 var LruMap = class extends Map {
-  constructor(size2) {
+  constructor(size3) {
     super();
     Object.defineProperty(this, "maxSize", {
       enumerable: true,
@@ -2519,7 +2519,7 @@ var LruMap = class extends Map {
       writable: true,
       value: void 0
     });
-    this.maxSize = size2;
+    this.maxSize = size3;
   }
   get(key) {
     const value = super.get(key);
@@ -2854,26 +2854,26 @@ async function sign({ hash, privateKey, to = "object" }) {
 }
 
 // node_modules/viem/_esm/utils/data/concat.js
-function concat(values) {
-  if (typeof values[0] === "string")
-    return concatHex(values);
-  return concatBytes3(values);
+function concat(values2) {
+  if (typeof values2[0] === "string")
+    return concatHex(values2);
+  return concatBytes3(values2);
 }
-function concatBytes3(values) {
+function concatBytes3(values2) {
   let length = 0;
-  for (const arr of values) {
+  for (const arr of values2) {
     length += arr.length;
   }
   const result = new Uint8Array(length);
   let offset = 0;
-  for (const arr of values) {
+  for (const arr of values2) {
     result.set(arr, offset);
     offset += arr.length;
   }
   return result;
 }
-function concatHex(values) {
-  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+function concatHex(values2) {
+  return `0x${values2.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
 }
 
 // node_modules/viem/_esm/errors/cursor.js
@@ -3002,11 +3002,11 @@ var staticCursor = {
     this.position++;
     return value;
   },
-  readBytes(length, size2) {
+  readBytes(length, size3) {
     this.assertReadLimit();
     this._touch();
     const value = this.inspectBytes(length);
-    this.position += size2 ?? length;
+    this.position += size3 ?? length;
     return value;
   },
   readUint8() {
@@ -3396,9 +3396,9 @@ var versionedHashVersionKzg = 1;
 
 // node_modules/viem/_esm/errors/blob.js
 var BlobSizeTooLargeError = class extends BaseError {
-  constructor({ maxSize, size: size2 }) {
+  constructor({ maxSize, size: size3 }) {
     super("Blob size is too large.", {
-      metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size2} bytes`],
+      metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size3} bytes`],
       name: "BlobSizeTooLargeError"
     });
   }
@@ -3409,9 +3409,9 @@ var EmptyBlobError = class extends BaseError {
   }
 };
 var InvalidVersionedHashSizeError = class extends BaseError {
-  constructor({ hash, size: size2 }) {
+  constructor({ hash, size: size3 }) {
     super(`Versioned hash "${hash}" size is invalid.`, {
-      metaMessages: ["Expected: 32", `Received: ${size2}`],
+      metaMessages: ["Expected: 32", `Received: ${size3}`],
       name: "InvalidVersionedHashSizeError"
     });
   }
@@ -3445,8 +3445,8 @@ function toBlobs(parameters) {
   let position = 0;
   while (active) {
     const blob = createCursor(new Uint8Array(bytesPerBlob));
-    let size2 = 0;
-    while (size2 < fieldElementsPerBlob) {
+    let size3 = 0;
+    while (size3 < fieldElementsPerBlob) {
       const bytes = data.slice(position, position + (bytesPerFieldElement - 1));
       blob.pushByte(0);
       blob.pushBytes(bytes);
@@ -3455,7 +3455,7 @@ function toBlobs(parameters) {
         active = false;
         break;
       }
-      size2++;
+      size3++;
       position += 31;
     }
     blobs.push(blob);
@@ -4174,22 +4174,22 @@ var bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
 var integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
 
 // node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
-function encodeAbiParameters(params, values) {
-  if (params.length !== values.length)
+function encodeAbiParameters(params, values2) {
+  if (params.length !== values2.length)
     throw new AbiEncodingLengthMismatchError({
       expectedLength: params.length,
-      givenLength: values.length
+      givenLength: values2.length
     });
   const preparedParams = prepareParams({
     params,
-    values
+    values: values2
   });
   return encodeParams(preparedParams);
 }
-function prepareParams({ params, values }) {
+function prepareParams({ params, values: values2 }) {
   const preparedParams = [];
   for (let i = 0; i < params.length; i++) {
-    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+    preparedParams.push(prepareParam({ param: params[i], value: values2[i] }));
   }
   return preparedParams;
 }
@@ -4212,10 +4212,10 @@ function prepareParam({ param, value }) {
   }
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
     const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
+    const [, , size3 = "256"] = integerRegex.exec(param.type) ?? [];
     return encodeNumber(value, {
       signed,
-      size: Number(size2)
+      size: Number(size3)
     });
   }
   if (param.type.startsWith("bytes")) {
@@ -4322,16 +4322,16 @@ function encodeBool(value) {
     throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
   return { dynamic: false, encoded: padHex(boolToHex(value)) };
 }
-function encodeNumber(value, { signed, size: size2 = 256 }) {
-  if (typeof size2 === "number") {
-    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
+function encodeNumber(value, { signed, size: size3 = 256 }) {
+  if (typeof size3 === "number") {
+    const max = 2n ** (BigInt(size3) - (signed ? 1n : 0n)) - 1n;
     const min = signed ? -max - 1n : 0n;
     if (value > max || value < min)
       throw new IntegerOutOfRangeError({
         max: max.toString(),
         min: min.toString(),
         signed,
-        size: size2 / 8,
+        size: size3 / 8,
         value: value.toString()
       });
   }
@@ -4417,8 +4417,8 @@ var InvalidDomainError = class extends BaseError {
   }
 };
 var InvalidPrimaryTypeError = class extends BaseError {
-  constructor({ primaryType, types }) {
-    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
+  constructor({ primaryType, types: types2 }) {
+    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types2))}\`.`, {
       docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
       metaMessages: ["Check that the primary type is a key in `types`."]
     });
@@ -4444,7 +4444,7 @@ var InvalidTypedDataTypeError = class extends BaseError {
 
 // node_modules/viem/_esm/utils/typedData.js
 function validateTypedData(parameters) {
-  const { domain, message, primaryType, types } = parameters;
+  const { domain, message, primaryType, types: types2 } = parameters;
   const validateData = (struct, data) => {
     for (const param of struct) {
       const { name, type } = param;
@@ -4471,23 +4471,23 @@ function validateTypedData(parameters) {
             givenSize: size(value)
           });
       }
-      const struct2 = types[type];
+      const struct2 = types2[type];
       if (struct2) {
         validateReference(type);
         validateData(struct2, value);
       }
     }
   };
-  if (types.EIP712Domain && domain) {
+  if (types2.EIP712Domain && domain) {
     if (typeof domain !== "object")
       throw new InvalidDomainError({ domain });
-    validateData(types.EIP712Domain, domain);
+    validateData(types2.EIP712Domain, domain);
   }
   if (primaryType !== "EIP712Domain") {
-    if (types[primaryType])
-      validateData(types[primaryType], message);
+    if (types2[primaryType])
+      validateData(types2[primaryType], message);
     else
-      throw new InvalidPrimaryTypeError({ primaryType, types });
+      throw new InvalidPrimaryTypeError({ primaryType, types: types2 });
   }
 }
 function getTypesForEIP712Domain({ domain }) {
@@ -4513,7 +4513,7 @@ function validateReference(type) {
 // node_modules/viem/_esm/utils/signature/hashTypedData.js
 function hashTypedData(parameters) {
   const { domain = {}, message, primaryType } = parameters;
-  const types = {
+  const types2 = {
     EIP712Domain: getTypesForEIP712Domain({ domain }),
     ...parameters.types
   };
@@ -4521,43 +4521,43 @@ function hashTypedData(parameters) {
     domain,
     message,
     primaryType,
-    types
+    types: types2
   });
   const parts = ["0x1901"];
   if (domain)
     parts.push(hashDomain({
       domain,
-      types
+      types: types2
     }));
   if (primaryType !== "EIP712Domain")
     parts.push(hashStruct({
       data: message,
       primaryType,
-      types
+      types: types2
     }));
   return keccak256(concat(parts));
 }
-function hashDomain({ domain, types }) {
+function hashDomain({ domain, types: types2 }) {
   return hashStruct({
     data: domain,
     primaryType: "EIP712Domain",
-    types
+    types: types2
   });
 }
-function hashStruct({ data, primaryType, types }) {
+function hashStruct({ data, primaryType, types: types2 }) {
   const encoded = encodeData({
     data,
     primaryType,
-    types
+    types: types2
   });
   return keccak256(encoded);
 }
-function encodeData({ data, primaryType, types }) {
+function encodeData({ data, primaryType, types: types2 }) {
   const encodedTypes = [{ type: "bytes32" }];
-  const encodedValues = [hashType({ primaryType, types })];
-  for (const field of types[primaryType]) {
+  const encodedValues = [hashType({ primaryType, types: types2 })];
+  for (const field of types2[primaryType]) {
     const [type, value] = encodeField({
-      types,
+      types: types2,
       name: field.name,
       type: field.type,
       value: data[field.name]
@@ -4567,37 +4567,37 @@ function encodeData({ data, primaryType, types }) {
   }
   return encodeAbiParameters(encodedTypes, encodedValues);
 }
-function hashType({ primaryType, types }) {
-  const encodedHashType = toHex(encodeType({ primaryType, types }));
+function hashType({ primaryType, types: types2 }) {
+  const encodedHashType = toHex(encodeType({ primaryType, types: types2 }));
   return keccak256(encodedHashType);
 }
-function encodeType({ primaryType, types }) {
+function encodeType({ primaryType, types: types2 }) {
   let result = "";
-  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  const unsortedDeps = findTypeDependencies({ primaryType, types: types2 });
   unsortedDeps.delete(primaryType);
   const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
   for (const type of deps) {
-    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+    result += `${type}(${types2[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
   }
   return result;
 }
-function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
+function findTypeDependencies({ primaryType: primaryType_, types: types2 }, results = /* @__PURE__ */ new Set()) {
   const match = primaryType_.match(/^\w*/u);
   const primaryType = match?.[0];
-  if (results.has(primaryType) || types[primaryType] === void 0) {
+  if (results.has(primaryType) || types2[primaryType] === void 0) {
     return results;
   }
   results.add(primaryType);
-  for (const field of types[primaryType]) {
-    findTypeDependencies({ primaryType: field.type, types }, results);
+  for (const field of types2[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types: types2 }, results);
   }
   return results;
 }
-function encodeField({ types, name, type, value }) {
-  if (types[type] !== void 0) {
+function encodeField({ types: types2, name, type, value }) {
+  if (types2[type] !== void 0) {
     return [
       { type: "bytes32" },
-      keccak256(encodeData({ data: value, primaryType: type, types }))
+      keccak256(encodeData({ data: value, primaryType: type, types: types2 }))
     ];
   }
   if (type === "bytes")
@@ -4609,7 +4609,7 @@ function encodeField({ types, name, type, value }) {
     const typeValuePairs = value.map((item) => encodeField({
       name,
       type: parsedType,
-      types,
+      types: types2,
       value: item
     }));
     return [
@@ -4681,6 +4681,13 @@ function readRelayConfig({ argv = process.argv.slice(2), env = process.env } = {
   const redemptionFlag = flag(argv, "--redemption-file") ?? env.RELAY_REDEMPTION_FILE;
   if (redemptionFlag === "") throw new Error("--redemption-file cannot be empty; paid serves require durable redemption");
   const redemptionFile = redemptionFlag === void 0 ? "./.mtok-redemption.jsonl" : redemptionFlag;
+  const redemptionDatabaseUrl = env.RELAY_REDEMPTION_DATABASE_URL;
+  if (redemptionDatabaseUrl !== void 0) {
+    if (!["postgres:", "postgresql:"].includes(new URL(redemptionDatabaseUrl).protocol)) {
+      throw new Error("RELAY_REDEMPTION_DATABASE_URL must use PostgreSQL");
+    }
+    if (redemptionFlag !== void 0) throw new Error("choose PostgreSQL or a redemption file, not both");
+  }
   const denylistRaw = flag(argv, "--payer-denylist") ?? env.RELAY_PAYER_DENYLIST ?? "";
   const payerDenylist = String(denylistRaw).split(",").map((a) => a.trim().toLowerCase()).filter(Boolean);
   const maxOutputRaw = flag(argv, "--max-output-tokens") ?? env.RELAY_MAX_OUTPUT_TOKENS;
@@ -4732,6 +4739,7 @@ function readRelayConfig({ argv = process.argv.slice(2), env = process.env } = {
     outPrice,
     inPrice,
     redemptionFile,
+    redemptionDatabaseUrl,
     mtokApiKey,
     upstreamKey,
     settlementAddr,
@@ -4793,11 +4801,11 @@ function readBody(req, { maxBytes = MAX_BODY_BYTES, timeoutMs = 1e4 } = {}) {
     const fail = (error) => {
       if (settled) return;
       settled = true;
-      clearTimeout(timer);
+      clearTimeout(timer2);
       chunks.length = 0;
       reject(error);
     };
-    const timer = setTimeout(() => fail(Object.assign(new Error("body_timeout"), { code: "body_timeout" })), timeoutMs);
+    const timer2 = setTimeout(() => fail(Object.assign(new Error("body_timeout"), { code: "body_timeout" })), timeoutMs);
     req.on("data", (d) => {
       bytes += d.length;
       if (bytes > maxBytes && !settled) {
@@ -4811,7 +4819,7 @@ function readBody(req, { maxBytes = MAX_BODY_BYTES, timeoutMs = 1e4 } = {}) {
     req.on("end", () => {
       if (settled) return;
       settled = true;
-      clearTimeout(timer);
+      clearTimeout(timer2);
       const raw = Buffer.concat(chunks).toString("utf8");
       try {
         resolve(JSON.parse(raw || "{}"));
@@ -5065,6 +5073,2289 @@ function createRedemptionStore({ file = null, retentionMs = DEFAULT_RETENTION_MS
   };
 }
 
+// src/postgres-redemption.mjs
+import { createHash } from "node:crypto";
+
+// node_modules/postgres/src/index.js
+import os from "os";
+import fs2 from "fs";
+
+// node_modules/postgres/src/query.js
+var originCache = /* @__PURE__ */ new Map();
+var originStackCache = /* @__PURE__ */ new Map();
+var originError = /* @__PURE__ */ Symbol("OriginError");
+var CLOSE = {};
+var Query = class extends Promise {
+  constructor(strings, args, handler, canceller, options = {}) {
+    let resolve, reject;
+    super((a, b2) => {
+      resolve = a;
+      reject = b2;
+    });
+    this.tagged = Array.isArray(strings.raw);
+    this.strings = strings;
+    this.args = args;
+    this.handler = handler;
+    this.canceller = canceller;
+    this.options = options;
+    this.state = null;
+    this.statement = null;
+    this.resolve = (x) => (this.active = false, resolve(x));
+    this.reject = (x) => (this.active = false, reject(x));
+    this.active = false;
+    this.cancelled = null;
+    this.executed = false;
+    this.signature = "";
+    this[originError] = this.handler.debug ? new Error() : this.tagged && cachedError(this.strings);
+  }
+  get origin() {
+    return (this.handler.debug ? this[originError].stack : this.tagged && originStackCache.has(this.strings) ? originStackCache.get(this.strings) : originStackCache.set(this.strings, this[originError].stack).get(this.strings)) || "";
+  }
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  cancel() {
+    return this.canceller && (this.canceller(this), this.canceller = null);
+  }
+  simple() {
+    this.options.simple = true;
+    this.options.prepare = false;
+    return this;
+  }
+  async readable() {
+    this.simple();
+    this.streaming = true;
+    return this;
+  }
+  async writable() {
+    this.simple();
+    this.streaming = true;
+    return this;
+  }
+  cursor(rows = 1, fn) {
+    this.options.simple = false;
+    if (typeof rows === "function") {
+      fn = rows;
+      rows = 1;
+    }
+    this.cursorRows = rows;
+    if (typeof fn === "function")
+      return this.cursorFn = fn, this;
+    let prev;
+    return {
+      [Symbol.asyncIterator]: () => ({
+        next: () => {
+          if (this.executed && !this.active)
+            return { done: true };
+          prev && prev();
+          const promise = new Promise((resolve, reject) => {
+            this.cursorFn = (value) => {
+              resolve({ value, done: false });
+              return new Promise((r) => prev = r);
+            };
+            this.resolve = () => (this.active = false, resolve({ done: true }));
+            this.reject = (x) => (this.active = false, reject(x));
+          });
+          this.execute();
+          return promise;
+        },
+        return() {
+          prev && prev(CLOSE);
+          return { done: true };
+        }
+      })
+    };
+  }
+  describe() {
+    this.options.simple = false;
+    this.onlyDescribe = this.options.prepare = true;
+    return this;
+  }
+  stream() {
+    throw new Error(".stream has been renamed to .forEach");
+  }
+  forEach(fn) {
+    this.forEachFn = fn;
+    this.handle();
+    return this;
+  }
+  raw() {
+    this.isRaw = true;
+    return this;
+  }
+  values() {
+    this.isRaw = "values";
+    return this;
+  }
+  async handle() {
+    !this.executed && (this.executed = true) && await 1 && this.handler(this);
+  }
+  execute() {
+    this.handle();
+    return this;
+  }
+  then() {
+    this.handle();
+    return super.then.apply(this, arguments);
+  }
+  catch() {
+    this.handle();
+    return super.catch.apply(this, arguments);
+  }
+  finally() {
+    this.handle();
+    return super.finally.apply(this, arguments);
+  }
+};
+function cachedError(xs) {
+  if (originCache.has(xs))
+    return originCache.get(xs);
+  const x = Error.stackTraceLimit;
+  Error.stackTraceLimit = 4;
+  originCache.set(xs, new Error());
+  Error.stackTraceLimit = x;
+  return originCache.get(xs);
+}
+
+// node_modules/postgres/src/errors.js
+var PostgresError = class extends Error {
+  constructor(x) {
+    super(x.message);
+    this.name = this.constructor.name;
+    Object.assign(this, x);
+  }
+};
+var Errors = {
+  connection,
+  postgres,
+  generic,
+  notSupported
+};
+function connection(x, options, socket) {
+  const { host, port } = socket || options;
+  const error = Object.assign(
+    new Error("write " + x + " " + (options.path || host + ":" + port)),
+    {
+      code: x,
+      errno: x,
+      address: options.path || host
+    },
+    options.path ? {} : { port }
+  );
+  Error.captureStackTrace(error, connection);
+  return error;
+}
+function postgres(x) {
+  const error = new PostgresError(x);
+  Error.captureStackTrace(error, postgres);
+  return error;
+}
+function generic(code, message) {
+  const error = Object.assign(new Error(code + ": " + message), { code });
+  Error.captureStackTrace(error, generic);
+  return error;
+}
+function notSupported(x) {
+  const error = Object.assign(
+    new Error(x + " (B) is not supported"),
+    {
+      code: "MESSAGE_NOT_SUPPORTED",
+      name: x
+    }
+  );
+  Error.captureStackTrace(error, notSupported);
+  return error;
+}
+
+// node_modules/postgres/src/types.js
+var types = {
+  string: {
+    to: 25,
+    from: null,
+    // defaults to string
+    serialize: (x) => "" + x
+  },
+  number: {
+    to: 0,
+    from: [21, 23, 26, 700, 701],
+    serialize: (x) => "" + x,
+    parse: (x) => +x
+  },
+  json: {
+    to: 114,
+    from: [114, 3802],
+    serialize: (x) => JSON.stringify(x),
+    parse: (x) => JSON.parse(x)
+  },
+  boolean: {
+    to: 16,
+    from: 16,
+    serialize: (x) => x === true ? "t" : "f",
+    parse: (x) => x === "t"
+  },
+  date: {
+    to: 1184,
+    from: [1082, 1114, 1184],
+    serialize: (x) => (x instanceof Date ? x : new Date(x)).toISOString(),
+    parse: (x) => new Date(x)
+  },
+  bytea: {
+    to: 17,
+    from: 17,
+    serialize: (x) => "\\x" + Buffer.from(x).toString("hex"),
+    parse: (x) => Buffer.from(x.slice(2), "hex")
+  }
+};
+var NotTagged = class {
+  then() {
+    notTagged();
+  }
+  catch() {
+    notTagged();
+  }
+  finally() {
+    notTagged();
+  }
+};
+var Identifier = class extends NotTagged {
+  constructor(value) {
+    super();
+    this.value = escapeIdentifier(value);
+  }
+};
+var Parameter = class extends NotTagged {
+  constructor(value, type, array) {
+    super();
+    this.value = value;
+    this.type = type;
+    this.array = array;
+  }
+};
+var Builder = class extends NotTagged {
+  constructor(first, rest) {
+    super();
+    this.first = first;
+    this.rest = rest;
+  }
+  build(before, parameters, types2, options) {
+    const keyword = builders.map(([x, fn]) => ({ fn, i: before.search(x) })).sort((a, b2) => a.i - b2.i).pop();
+    return keyword.i === -1 ? escapeIdentifiers(this.first, options) : keyword.fn(this.first, this.rest, parameters, types2, options);
+  }
+};
+function handleValue(x, parameters, types2, options) {
+  let value = x instanceof Parameter ? x.value : x;
+  if (value === void 0) {
+    x instanceof Parameter ? x.value = options.transform.undefined : value = x = options.transform.undefined;
+    if (value === void 0)
+      throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
+  }
+  return "$" + types2.push(
+    x instanceof Parameter ? (parameters.push(x.value), x.array ? x.array[x.type || inferType(x.value)] || x.type || firstIsString(x.value) : x.type) : (parameters.push(x), inferType(x))
+  );
+}
+var defaultHandlers = typeHandlers(types);
+function stringify2(q, string, value, parameters, types2, options) {
+  for (let i = 1; i < q.strings.length; i++) {
+    string += stringifyValue(string, value, parameters, types2, options) + q.strings[i];
+    value = q.args[i];
+  }
+  return string;
+}
+function stringifyValue(string, value, parameters, types2, o) {
+  return value instanceof Builder ? value.build(string, parameters, types2, o) : value instanceof Query ? fragment(value, parameters, types2, o) : value instanceof Identifier ? value.value : value && value[0] instanceof Query ? value.reduce((acc, x) => acc + " " + fragment(x, parameters, types2, o), "") : handleValue(value, parameters, types2, o);
+}
+function fragment(q, parameters, types2, options) {
+  q.fragment = true;
+  return stringify2(q, q.strings[0], q.args[0], parameters, types2, options);
+}
+function valuesBuilder(first, parameters, types2, columns, options) {
+  return first.map(
+    (row) => "(" + columns.map(
+      (column) => stringifyValue("values", row[column], parameters, types2, options)
+    ).join(",") + ")"
+  ).join(",");
+}
+function values(first, rest, parameters, types2, options) {
+  const multi = Array.isArray(first[0]);
+  const columns = rest.length ? rest.flat() : Object.keys(multi ? first[0] : first);
+  return valuesBuilder(multi ? first : [first], parameters, types2, columns, options);
+}
+function select(first, rest, parameters, types2, options) {
+  typeof first === "string" && (first = [first].concat(rest));
+  if (Array.isArray(first))
+    return escapeIdentifiers(first, options);
+  let value;
+  const columns = rest.length ? rest.flat() : Object.keys(first);
+  return columns.map((x) => {
+    value = first[x];
+    return (value instanceof Query ? fragment(value, parameters, types2, options) : value instanceof Identifier ? value.value : handleValue(value, parameters, types2, options)) + " as " + escapeIdentifier(options.transform.column.to ? options.transform.column.to(x) : x);
+  }).join(",");
+}
+var builders = Object.entries({
+  values,
+  in: (...xs) => {
+    const x = values(...xs);
+    return x === "()" ? "(null)" : x;
+  },
+  select,
+  as: select,
+  returning: select,
+  "\\(": select,
+  update(first, rest, parameters, types2, options) {
+    return (rest.length ? rest.flat() : Object.keys(first)).map(
+      (x) => escapeIdentifier(options.transform.column.to ? options.transform.column.to(x) : x) + "=" + stringifyValue("values", first[x], parameters, types2, options)
+    );
+  },
+  insert(first, rest, parameters, types2, options) {
+    const columns = rest.length ? rest.flat() : Object.keys(Array.isArray(first) ? first[0] : first);
+    return "(" + escapeIdentifiers(columns, options) + ")values" + valuesBuilder(Array.isArray(first) ? first : [first], parameters, types2, columns, options);
+  }
+}).map(([x, fn]) => [new RegExp("((?:^|[\\s(])" + x + "(?:$|[\\s(]))(?![\\s\\S]*\\1)", "i"), fn]);
+function notTagged() {
+  throw Errors.generic("NOT_TAGGED_CALL", "Query not called as a tagged template literal");
+}
+var serializers = defaultHandlers.serializers;
+var parsers = defaultHandlers.parsers;
+function firstIsString(x) {
+  if (Array.isArray(x))
+    return firstIsString(x[0]);
+  return typeof x === "string" ? 1009 : 0;
+}
+var mergeUserTypes = function(types2) {
+  const user = typeHandlers(types2 || {});
+  return {
+    serializers: Object.assign({}, serializers, user.serializers),
+    parsers: Object.assign({}, parsers, user.parsers)
+  };
+};
+function typeHandlers(types2) {
+  return Object.keys(types2).reduce((acc, k) => {
+    types2[k].from && [].concat(types2[k].from).forEach((x) => acc.parsers[x] = types2[k].parse);
+    if (types2[k].serialize) {
+      acc.serializers[types2[k].to] = types2[k].serialize;
+      types2[k].from && [].concat(types2[k].from).forEach((x) => acc.serializers[x] = types2[k].serialize);
+    }
+    return acc;
+  }, { parsers: {}, serializers: {} });
+}
+function escapeIdentifiers(xs, { transform: { column } }) {
+  return xs.map((x) => escapeIdentifier(column.to ? column.to(x) : x)).join(",");
+}
+var escapeIdentifier = function escape(str) {
+  return '"' + str.replace(/"/g, '""').replace(/\./g, '"."') + '"';
+};
+var inferType = function inferType2(x) {
+  return x instanceof Parameter ? x.type : x instanceof Date ? 1184 : x instanceof Uint8Array ? 17 : x === true || x === false ? 16 : typeof x === "bigint" ? 20 : Array.isArray(x) ? inferType2(x[0]) : 0;
+};
+var escapeBackslash = /\\/g;
+var escapeQuote = /"/g;
+function arrayEscape(x) {
+  return x.replace(escapeBackslash, "\\\\").replace(escapeQuote, '\\"');
+}
+var arraySerializer = function arraySerializer2(xs, serializer, options, typarray) {
+  if (Array.isArray(xs) === false)
+    return xs;
+  if (!xs.length)
+    return "{}";
+  const first = xs[0];
+  const delimiter = typarray === 1020 ? ";" : ",";
+  if (Array.isArray(first) && !first.type)
+    return "{" + xs.map((x) => arraySerializer2(x, serializer, options, typarray)).join(delimiter) + "}";
+  return "{" + xs.map((x) => {
+    if (x === void 0) {
+      x = options.transform.undefined;
+      if (x === void 0)
+        throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
+    }
+    return x === null ? "null" : '"' + arrayEscape(serializer ? serializer(x.type ? x.value : x) : "" + x) + '"';
+  }).join(delimiter) + "}";
+};
+var arrayParserState = {
+  i: 0,
+  char: null,
+  str: "",
+  quoted: false,
+  last: 0
+};
+var arrayParser = function arrayParser2(x, parser, typarray) {
+  arrayParserState.i = arrayParserState.last = 0;
+  return arrayParserLoop(arrayParserState, x, parser, typarray);
+};
+function arrayParserLoop(s, x, parser, typarray) {
+  const xs = [];
+  const delimiter = typarray === 1020 ? ";" : ",";
+  for (; s.i < x.length; s.i++) {
+    s.char = x[s.i];
+    if (s.quoted) {
+      if (s.char === "\\") {
+        s.str += x[++s.i];
+      } else if (s.char === '"') {
+        xs.push(parser ? parser(s.str) : s.str);
+        s.str = "";
+        s.quoted = x[s.i + 1] === '"';
+        s.last = s.i + 2;
+      } else {
+        s.str += s.char;
+      }
+    } else if (s.char === '"') {
+      s.quoted = true;
+    } else if (s.char === "{") {
+      s.last = ++s.i;
+      xs.push(arrayParserLoop(s, x, parser, typarray));
+    } else if (s.char === "}") {
+      s.quoted = false;
+      s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i));
+      s.last = s.i + 1;
+      break;
+    } else if (s.char === delimiter && s.p !== "}" && s.p !== '"') {
+      xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i));
+      s.last = s.i + 1;
+    }
+    s.p = s.char;
+  }
+  s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i + 1)) : x.slice(s.last, s.i + 1));
+  return xs;
+}
+var toCamel = (x) => {
+  let str = x[0];
+  for (let i = 1; i < x.length; i++)
+    str += x[i] === "_" ? x[++i].toUpperCase() : x[i];
+  return str;
+};
+var toPascal = (x) => {
+  let str = x[0].toUpperCase();
+  for (let i = 1; i < x.length; i++)
+    str += x[i] === "_" ? x[++i].toUpperCase() : x[i];
+  return str;
+};
+var toKebab = (x) => x.replace(/_/g, "-");
+var fromCamel = (x) => x.replace(/([A-Z])/g, "_$1").toLowerCase();
+var fromPascal = (x) => (x.slice(0, 1) + x.slice(1).replace(/([A-Z])/g, "_$1")).toLowerCase();
+var fromKebab = (x) => x.replace(/-/g, "_");
+function createJsonTransform(fn) {
+  return function jsonTransform(x, column) {
+    return typeof x === "object" && x !== null && (column.type === 114 || column.type === 3802) ? Array.isArray(x) ? x.map((x2) => jsonTransform(x2, column)) : Object.entries(x).reduce((acc, [k, v]) => Object.assign(acc, { [fn(k)]: jsonTransform(v, column) }), {}) : x;
+  };
+}
+toCamel.column = { from: toCamel };
+toCamel.value = { from: createJsonTransform(toCamel) };
+fromCamel.column = { to: fromCamel };
+var camel = { ...toCamel };
+camel.column.to = fromCamel;
+toPascal.column = { from: toPascal };
+toPascal.value = { from: createJsonTransform(toPascal) };
+fromPascal.column = { to: fromPascal };
+var pascal = { ...toPascal };
+pascal.column.to = fromPascal;
+toKebab.column = { from: toKebab };
+toKebab.value = { from: createJsonTransform(toKebab) };
+fromKebab.column = { to: fromKebab };
+var kebab = { ...toKebab };
+kebab.column.to = fromKebab;
+
+// node_modules/postgres/src/connection.js
+import net from "net";
+import tls from "tls";
+import crypto4 from "crypto";
+import Stream from "stream";
+import { performance } from "perf_hooks";
+
+// node_modules/postgres/src/result.js
+var Result = class extends Array {
+  constructor() {
+    super();
+    Object.defineProperties(this, {
+      count: { value: null, writable: true },
+      state: { value: null, writable: true },
+      command: { value: null, writable: true },
+      columns: { value: null, writable: true },
+      statement: { value: null, writable: true }
+    });
+  }
+  static get [Symbol.species]() {
+    return Array;
+  }
+};
+
+// node_modules/postgres/src/queue.js
+var queue_default = Queue;
+function Queue(initial = []) {
+  let xs = initial.slice();
+  let index = 0;
+  return {
+    get length() {
+      return xs.length - index;
+    },
+    remove: (x) => {
+      const index2 = xs.indexOf(x);
+      return index2 === -1 ? null : (xs.splice(index2, 1), x);
+    },
+    push: (x) => (xs.push(x), x),
+    shift: () => {
+      const out = xs[index++];
+      if (index === xs.length) {
+        index = 0;
+        xs = [];
+      } else {
+        xs[index - 1] = void 0;
+      }
+      return out;
+    }
+  };
+}
+
+// node_modules/postgres/src/bytes.js
+var size2 = 256;
+var buffer = Buffer.allocUnsafe(size2);
+var messages = "BCcDdEFfHPpQSX".split("").reduce((acc, x) => {
+  const v = x.charCodeAt(0);
+  acc[x] = () => {
+    buffer[0] = v;
+    b.i = 5;
+    return b;
+  };
+  return acc;
+}, {});
+var b = Object.assign(reset, messages, {
+  N: String.fromCharCode(0),
+  i: 0,
+  inc(x) {
+    b.i += x;
+    return b;
+  },
+  str(x) {
+    const length = Buffer.byteLength(x);
+    fit(length);
+    b.i += buffer.write(x, b.i, length, "utf8");
+    return b;
+  },
+  i16(x) {
+    fit(2);
+    buffer.writeUInt16BE(x, b.i);
+    b.i += 2;
+    return b;
+  },
+  i32(x, i) {
+    if (i || i === 0) {
+      buffer.writeUInt32BE(x, i);
+      return b;
+    }
+    fit(4);
+    buffer.writeUInt32BE(x, b.i);
+    b.i += 4;
+    return b;
+  },
+  z(x) {
+    fit(x);
+    buffer.fill(0, b.i, b.i + x);
+    b.i += x;
+    return b;
+  },
+  raw(x) {
+    buffer = Buffer.concat([buffer.subarray(0, b.i), x]);
+    b.i = buffer.length;
+    return b;
+  },
+  end(at = 1) {
+    buffer.writeUInt32BE(b.i - at, at);
+    const out = buffer.subarray(0, b.i);
+    b.i = 0;
+    buffer = Buffer.allocUnsafe(size2);
+    return out;
+  }
+});
+var bytes_default = b;
+function fit(x) {
+  if (buffer.length - b.i < x) {
+    const prev = buffer, length = prev.length;
+    buffer = Buffer.allocUnsafe(length + (length >> 1) + x);
+    prev.copy(buffer);
+  }
+}
+function reset() {
+  b.i = 0;
+  return b;
+}
+
+// node_modules/postgres/src/connection.js
+var connection_default = Connection;
+var uid = 1;
+var Sync = bytes_default().S().end();
+var Flush = bytes_default().H().end();
+var SSLRequest = bytes_default().i32(8).i32(80877103).end(8);
+var ExecuteUnnamed = Buffer.concat([bytes_default().E().str(bytes_default.N).i32(0).end(), Sync]);
+var DescribeUnnamed = bytes_default().D().str("S").str(bytes_default.N).end();
+var noop = () => {
+};
+var retryRoutines = /* @__PURE__ */ new Set([
+  "FetchPreparedStatement",
+  "RevalidateCachedQuery",
+  "transformAssignedExpr"
+]);
+var errorFields = {
+  83: "severity_local",
+  // S
+  86: "severity",
+  // V
+  67: "code",
+  // C
+  77: "message",
+  // M
+  68: "detail",
+  // D
+  72: "hint",
+  // H
+  80: "position",
+  // P
+  112: "internal_position",
+  // p
+  113: "internal_query",
+  // q
+  87: "where",
+  // W
+  115: "schema_name",
+  // s
+  116: "table_name",
+  // t
+  99: "column_name",
+  // c
+  100: "data type_name",
+  // d
+  110: "constraint_name",
+  // n
+  70: "file",
+  // F
+  76: "line",
+  // L
+  82: "routine"
+  // R
+};
+function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose = noop } = {}) {
+  const {
+    sslnegotiation,
+    ssl,
+    max,
+    user,
+    host,
+    port,
+    database,
+    parsers: parsers2,
+    transform,
+    onnotice,
+    onnotify,
+    onparameter,
+    max_pipeline,
+    keep_alive,
+    backoff: backoff2,
+    target_session_attrs
+  } = options;
+  const sent = queue_default(), id = uid++, backend = { pid: null, secret: null }, idleTimer = timer(end, options.idle_timeout), lifeTimer = timer(end, options.max_lifetime), connectTimer = timer(connectTimedOut, options.connect_timeout);
+  let socket = null, cancelMessage, errorResponse = null, result = new Result(), incoming = Buffer.alloc(0), needsTypes = options.fetch_types, backendParameters = {}, statements = {}, statementId = Math.random().toString(36).slice(2), statementCount = 1, closedTime = 0, remaining = 0, hostIndex = 0, retries = 0, length = 0, delay = 0, rows = 0, serverSignature = null, nextWriteTimer = null, terminated = false, incomings = null, results = null, initial = null, ending = null, stream = null, chunk = null, ended = null, nonce = null, query = null, final = null;
+  const connection2 = {
+    queue: queues.closed,
+    idleTimer,
+    connect(query2) {
+      initial = query2;
+      reconnect();
+    },
+    terminate,
+    execute,
+    cancel,
+    end,
+    count: 0,
+    id
+  };
+  queues.closed && queues.closed.push(connection2);
+  return connection2;
+  async function createSocket() {
+    let x;
+    try {
+      x = options.socket ? await Promise.resolve(options.socket(options)) : new net.Socket();
+    } catch (e) {
+      error(e);
+      return;
+    }
+    x.on("error", error);
+    x.on("close", closed);
+    x.on("drain", drain);
+    return x;
+  }
+  async function cancel({ pid, secret }, resolve, reject) {
+    try {
+      cancelMessage = bytes_default().i32(16).i32(80877102).i32(pid).i32(secret).end(16);
+      await connect();
+      socket.once("error", reject);
+      socket.once("close", resolve);
+    } catch (error2) {
+      reject(error2);
+    }
+  }
+  function execute(q) {
+    if (terminated)
+      return queryError(q, Errors.connection("CONNECTION_DESTROYED", options));
+    if (stream)
+      return queryError(q, Errors.generic("COPY_IN_PROGRESS", "You cannot execute queries during copy"));
+    if (q.cancelled)
+      return;
+    try {
+      q.state = backend;
+      query ? sent.push(q) : (query = q, query.active = true);
+      build(q);
+      return write(toBuffer(q)) && !q.describeFirst && !q.cursorFn && sent.length < max_pipeline && (!q.options.onexecute || q.options.onexecute(connection2));
+    } catch (error2) {
+      sent.length === 0 && write(Sync);
+      errored(error2);
+      return true;
+    }
+  }
+  function toBuffer(q) {
+    if (q.parameters.length >= 65534)
+      throw Errors.generic("MAX_PARAMETERS_EXCEEDED", "Max number of parameters (65534) exceeded");
+    return q.options.simple ? bytes_default().Q().str(q.statement.string + bytes_default.N).end() : q.describeFirst ? Buffer.concat([describe(q), Flush]) : q.prepare ? q.prepared ? prepared(q) : Buffer.concat([describe(q), prepared(q)]) : unnamed(q);
+  }
+  function describe(q) {
+    return Buffer.concat([
+      Parse(q.statement.string, q.parameters, q.statement.types, q.statement.name),
+      Describe("S", q.statement.name)
+    ]);
+  }
+  function prepared(q) {
+    return Buffer.concat([
+      Bind(q.parameters, q.statement.types, q.statement.name, q.cursorName),
+      q.cursorFn ? Execute("", q.cursorRows) : ExecuteUnnamed
+    ]);
+  }
+  function unnamed(q) {
+    return Buffer.concat([
+      Parse(q.statement.string, q.parameters, q.statement.types),
+      DescribeUnnamed,
+      prepared(q)
+    ]);
+  }
+  function build(q) {
+    const parameters = [], types2 = [];
+    const string = stringify2(q, q.strings[0], q.args[0], parameters, types2, options);
+    !q.tagged && q.args.forEach((x) => handleValue(x, parameters, types2, options));
+    q.prepare = options.prepare && ("prepare" in q.options ? q.options.prepare : true);
+    q.string = string;
+    q.signature = q.prepare && types2 + string;
+    q.onlyDescribe && delete statements[q.signature];
+    q.parameters = q.parameters || parameters;
+    q.prepared = q.prepare && q.signature in statements;
+    q.describeFirst = q.onlyDescribe || parameters.length && !q.prepared;
+    q.statement = q.prepared ? statements[q.signature] : { string, types: types2, name: q.prepare ? statementId + statementCount++ : "" };
+    typeof options.debug === "function" && options.debug(id, string, parameters, types2);
+  }
+  function write(x, fn) {
+    chunk = chunk ? Buffer.concat([chunk, x]) : Buffer.from(x);
+    if (fn || chunk.length >= 1024)
+      return nextWrite(fn);
+    nextWriteTimer === null && (nextWriteTimer = setImmediate(nextWrite));
+    return true;
+  }
+  function nextWrite(fn) {
+    const x = socket.write(chunk, fn);
+    nextWriteTimer !== null && clearImmediate(nextWriteTimer);
+    chunk = nextWriteTimer = null;
+    return x;
+  }
+  function connectTimedOut() {
+    errored(Errors.connection("CONNECT_TIMEOUT", options, socket));
+    socket.destroy();
+  }
+  async function secure() {
+    if (sslnegotiation !== "direct") {
+      write(SSLRequest);
+      const canSSL = await new Promise((r) => socket.once("data", (x) => r(x[0] === 83)));
+      if (!canSSL && ssl === "prefer")
+        return connected();
+    }
+    const options2 = {
+      socket,
+      servername: net.isIP(socket.host) ? void 0 : socket.host
+    };
+    if (sslnegotiation === "direct")
+      options2.ALPNProtocols = ["postgresql"];
+    if (ssl === "require" || ssl === "allow" || ssl === "prefer")
+      options2.rejectUnauthorized = false;
+    else if (typeof ssl === "object")
+      Object.assign(options2, ssl);
+    socket.removeAllListeners();
+    socket = tls.connect(options2);
+    socket.on("secureConnect", connected);
+    socket.on("error", error);
+    socket.on("close", closed);
+    socket.on("drain", drain);
+  }
+  function drain() {
+    !query && onopen(connection2);
+  }
+  function data(x) {
+    if (incomings) {
+      incomings.push(x);
+      remaining -= x.length;
+      if (remaining > 0)
+        return;
+    }
+    incoming = incomings ? Buffer.concat(incomings, length - remaining) : incoming.length === 0 ? x : Buffer.concat([incoming, x], incoming.length + x.length);
+    while (incoming.length > 4) {
+      length = incoming.readUInt32BE(1);
+      if (length >= incoming.length) {
+        remaining = length - incoming.length;
+        incomings = [incoming];
+        break;
+      }
+      try {
+        handle(incoming.subarray(0, length + 1));
+      } catch (e) {
+        query && (query.cursorFn || query.describeFirst) && write(Sync);
+        errored(e);
+      }
+      incoming = incoming.subarray(length + 1);
+      remaining = 0;
+      incomings = null;
+    }
+  }
+  async function connect() {
+    terminated = false;
+    backendParameters = {};
+    socket || (socket = await createSocket());
+    if (!socket)
+      return;
+    connectTimer.start();
+    if (options.socket)
+      return ssl ? secure() : connected();
+    socket.on("connect", ssl ? secure : connected);
+    if (options.path)
+      return socket.connect(options.path);
+    socket.ssl = ssl;
+    socket.connect(port[hostIndex], host[hostIndex]);
+    socket.host = host[hostIndex];
+    socket.port = port[hostIndex];
+    hostIndex = (hostIndex + 1) % port.length;
+  }
+  function reconnect() {
+    setTimeout(connect, closedTime ? Math.max(0, closedTime + delay - performance.now()) : 0);
+  }
+  function connected() {
+    try {
+      statements = {};
+      needsTypes = options.fetch_types;
+      statementId = Math.random().toString(36).slice(2);
+      statementCount = 1;
+      lifeTimer.start();
+      socket.on("data", data);
+      keep_alive && socket.setKeepAlive && socket.setKeepAlive(true, 1e3 * keep_alive);
+      const s = StartupMessage();
+      write(s);
+    } catch (err) {
+      error(err);
+    }
+  }
+  function error(err) {
+    if (connection2.queue === queues.connecting && options.host[retries + 1])
+      return;
+    errored(err);
+    while (sent.length)
+      queryError(sent.shift(), err);
+  }
+  function errored(err) {
+    stream && (stream.destroy(err), stream = null);
+    query && queryError(query, err);
+    initial && (queryError(initial, err), initial = null);
+  }
+  function queryError(query2, err) {
+    if (query2.reserve)
+      return query2.reject(err);
+    if (!err || typeof err !== "object")
+      err = new Error(err);
+    "query" in err || "parameters" in err || Object.defineProperties(err, {
+      stack: { value: err.stack + query2.origin.replace(/.*\n/, "\n"), enumerable: options.debug },
+      query: { value: query2.string, enumerable: options.debug },
+      parameters: { value: query2.parameters, enumerable: options.debug },
+      args: { value: query2.args, enumerable: options.debug },
+      types: { value: query2.statement && query2.statement.types, enumerable: options.debug }
+    });
+    query2.reject(err);
+  }
+  function end() {
+    return ending || (!connection2.reserved && onend(connection2), !connection2.reserved && !initial && !query && sent.length === 0 ? (terminate(), new Promise((r) => socket && socket.readyState !== "closed" ? socket.once("close", r) : r())) : ending = new Promise((r) => ended = r));
+  }
+  function terminate() {
+    terminated = true;
+    if (stream || query || initial || sent.length)
+      error(Errors.connection("CONNECTION_DESTROYED", options));
+    clearImmediate(nextWriteTimer);
+    if (socket) {
+      socket.removeListener("data", data);
+      socket.removeListener("connect", connected);
+      socket.readyState === "open" && socket.end(bytes_default().X().end());
+    }
+    ended && (ended(), ending = ended = null);
+  }
+  async function closed(hadError) {
+    incoming = Buffer.alloc(0);
+    remaining = 0;
+    incomings = null;
+    clearImmediate(nextWriteTimer);
+    socket.removeListener("data", data);
+    socket.removeListener("connect", connected);
+    idleTimer.cancel();
+    lifeTimer.cancel();
+    connectTimer.cancel();
+    socket.removeAllListeners();
+    socket = null;
+    if (initial)
+      return reconnect();
+    !hadError && (query || sent.length) && error(Errors.connection("CONNECTION_CLOSED", options, socket));
+    closedTime = performance.now();
+    hadError && options.shared.retries++;
+    delay = (typeof backoff2 === "function" ? backoff2(options.shared.retries) : backoff2) * 1e3;
+    onclose(connection2, Errors.connection("CONNECTION_CLOSED", options, socket));
+  }
+  function handle(xs, x = xs[0]) {
+    (x === 68 ? DataRow : (
+      // D
+      x === 100 ? CopyData : (
+        // d
+        x === 65 ? NotificationResponse : (
+          // A
+          x === 83 ? ParameterStatus : (
+            // S
+            x === 90 ? ReadyForQuery : (
+              // Z
+              x === 67 ? CommandComplete : (
+                // C
+                x === 50 ? BindComplete : (
+                  // 2
+                  x === 49 ? ParseComplete : (
+                    // 1
+                    x === 116 ? ParameterDescription : (
+                      // t
+                      x === 84 ? RowDescription : (
+                        // T
+                        x === 82 ? Authentication : (
+                          // R
+                          x === 110 ? NoData : (
+                            // n
+                            x === 75 ? BackendKeyData : (
+                              // K
+                              x === 69 ? ErrorResponse : (
+                                // E
+                                x === 115 ? PortalSuspended : (
+                                  // s
+                                  x === 51 ? CloseComplete : (
+                                    // 3
+                                    x === 71 ? CopyInResponse : (
+                                      // G
+                                      x === 78 ? NoticeResponse : (
+                                        // N
+                                        x === 72 ? CopyOutResponse : (
+                                          // H
+                                          x === 99 ? CopyDone : (
+                                            // c
+                                            x === 73 ? EmptyQueryResponse : (
+                                              // I
+                                              x === 86 ? FunctionCallResponse : (
+                                                // V
+                                                x === 118 ? NegotiateProtocolVersion : (
+                                                  // v
+                                                  x === 87 ? CopyBothResponse : (
+                                                    // W
+                                                    /* c8 ignore next */
+                                                    UnknownMessage
+                                                  )
+                                                )
+                                              )
+                                            )
+                                          )
+                                        )
+                                      )
+                                    )
+                                  )
+                                )
+                              )
+                            )
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    ))(xs);
+  }
+  function DataRow(x) {
+    let index = 7;
+    let length2;
+    let column;
+    let value;
+    const row = query.isRaw ? new Array(query.statement.columns.length) : {};
+    for (let i = 0; i < query.statement.columns.length; i++) {
+      column = query.statement.columns[i];
+      length2 = x.readInt32BE(index);
+      index += 4;
+      value = length2 === -1 ? null : query.isRaw === true ? x.subarray(index, index += length2) : column.parser === void 0 ? x.toString("utf8", index, index += length2) : column.parser.array === true ? column.parser(x.toString("utf8", index + 1, index += length2)) : column.parser(x.toString("utf8", index, index += length2));
+      query.isRaw ? row[i] = query.isRaw === true ? value : transform.value.from ? transform.value.from(value, column) : value : row[column.name] = transform.value.from ? transform.value.from(value, column) : value;
+    }
+    query.forEachFn ? query.forEachFn(transform.row.from ? transform.row.from(row) : row, result) : result[rows++] = transform.row.from ? transform.row.from(row) : row;
+  }
+  function ParameterStatus(x) {
+    const [k, v] = x.toString("utf8", 5, x.length - 1).split(bytes_default.N);
+    backendParameters[k] = v;
+    if (options.parameters[k] !== v) {
+      options.parameters[k] = v;
+      onparameter && onparameter(k, v);
+    }
+  }
+  function ReadyForQuery(x) {
+    if (query) {
+      if (errorResponse) {
+        query.retried ? errored(query.retried) : query.prepared && retryRoutines.has(errorResponse.routine) ? retry(query, errorResponse) : errored(errorResponse);
+      } else {
+        query.resolve(results || result);
+      }
+    } else if (errorResponse) {
+      errored(errorResponse);
+    }
+    query = results = errorResponse = null;
+    result = new Result();
+    connectTimer.cancel();
+    if (initial) {
+      if (target_session_attrs) {
+        if (!backendParameters.in_hot_standby || !backendParameters.default_transaction_read_only)
+          return fetchState();
+        else if (tryNext(target_session_attrs, backendParameters))
+          return terminate();
+      }
+      if (needsTypes) {
+        initial.reserve && (initial = null);
+        return fetchArrayTypes();
+      }
+      initial && !initial.reserve && execute(initial);
+      options.shared.retries = retries = 0;
+      initial = null;
+      return;
+    }
+    while (sent.length && (query = sent.shift()) && (query.active = true, query.cancelled))
+      Connection(options).cancel(query.state, query.cancelled.resolve, query.cancelled.reject);
+    if (query)
+      return;
+    connection2.reserved ? !connection2.reserved.release && x[5] === 73 ? ending ? terminate() : (connection2.reserved = null, onopen(connection2)) : connection2.reserved() : ending ? terminate() : onopen(connection2);
+  }
+  function CommandComplete(x) {
+    rows = 0;
+    for (let i = x.length - 1; i > 0; i--) {
+      if (x[i] === 32 && x[i + 1] < 58 && result.count === null)
+        result.count = +x.toString("utf8", i + 1, x.length - 1);
+      if (x[i - 1] >= 65) {
+        result.command = x.toString("utf8", 5, i);
+        result.state = backend;
+        break;
+      }
+    }
+    final && (final(), final = null);
+    if (result.command === "BEGIN" && max !== 1 && !connection2.reserved)
+      return errored(Errors.generic("UNSAFE_TRANSACTION", "Only use sql.begin, sql.reserved or max: 1"));
+    if (query.options.simple)
+      return BindComplete();
+    if (query.cursorFn) {
+      result.count && query.cursorFn(result);
+      write(Sync);
+    }
+  }
+  function ParseComplete() {
+    query.parsing = false;
+  }
+  function BindComplete() {
+    !result.statement && (result.statement = query.statement);
+    result.columns = query.statement.columns;
+  }
+  function ParameterDescription(x) {
+    const length2 = x.readUInt16BE(5);
+    for (let i = 0; i < length2; ++i)
+      !query.statement.types[i] && (query.statement.types[i] = x.readUInt32BE(7 + i * 4));
+    query.prepare && (statements[query.signature] = query.statement);
+    query.describeFirst && !query.onlyDescribe && (write(prepared(query)), query.describeFirst = false);
+  }
+  function RowDescription(x) {
+    if (result.command) {
+      results = results || [result];
+      results.push(result = new Result());
+      result.count = null;
+      query.statement.columns = null;
+    }
+    const length2 = x.readUInt16BE(5);
+    let index = 7;
+    let start;
+    query.statement.columns = Array(length2);
+    for (let i = 0; i < length2; ++i) {
+      start = index;
+      while (x[index++] !== 0) ;
+      const table = x.readUInt32BE(index);
+      const number = x.readUInt16BE(index + 4);
+      const type = x.readUInt32BE(index + 6);
+      query.statement.columns[i] = {
+        name: transform.column.from ? transform.column.from(x.toString("utf8", start, index - 1)) : x.toString("utf8", start, index - 1),
+        parser: parsers2[type],
+        table,
+        number,
+        type
+      };
+      index += 18;
+    }
+    result.statement = query.statement;
+    if (query.onlyDescribe)
+      return query.resolve(query.statement), write(Sync);
+  }
+  async function Authentication(x, type = x.readUInt32BE(5)) {
+    (type === 3 ? AuthenticationCleartextPassword : type === 5 ? AuthenticationMD5Password : type === 10 ? SASL : type === 11 ? SASLContinue : type === 12 ? SASLFinal : type !== 0 ? UnknownAuth : noop)(x, type);
+  }
+  async function AuthenticationCleartextPassword() {
+    const payload = await Pass();
+    write(
+      bytes_default().p().str(payload).z(1).end()
+    );
+  }
+  async function AuthenticationMD5Password(x) {
+    const payload = "md5" + await md5(
+      Buffer.concat([
+        Buffer.from(await md5(await Pass() + user)),
+        x.subarray(9)
+      ])
+    );
+    write(
+      bytes_default().p().str(payload).z(1).end()
+    );
+  }
+  async function SASL() {
+    nonce = (await crypto4.randomBytes(18)).toString("base64");
+    bytes_default().p().str("SCRAM-SHA-256" + bytes_default.N);
+    const i = bytes_default.i;
+    write(bytes_default.inc(4).str("n,,n=*,r=" + nonce).i32(bytes_default.i - i - 4, i).end());
+  }
+  async function SASLContinue(x) {
+    const res = x.toString("utf8", 9).split(",").reduce((acc, x2) => (acc[x2[0]] = x2.slice(2), acc), {});
+    const saltedPassword = await crypto4.pbkdf2Sync(
+      await Pass(),
+      Buffer.from(res.s, "base64"),
+      parseInt(res.i),
+      32,
+      "sha256"
+    );
+    const clientKey = await hmac2(saltedPassword, "Client Key");
+    const auth = "n=*,r=" + nonce + ",r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
+    serverSignature = (await hmac2(await hmac2(saltedPassword, "Server Key"), auth)).toString("base64");
+    const payload = "c=biws,r=" + res.r + ",p=" + xor(
+      clientKey,
+      Buffer.from(await hmac2(await sha2564(clientKey), auth))
+    ).toString("base64");
+    write(
+      bytes_default().p().str(payload).end()
+    );
+  }
+  function SASLFinal(x) {
+    if (x.toString("utf8", 9).split(bytes_default.N, 1)[0].slice(2) === serverSignature)
+      return;
+    errored(Errors.generic("SASL_SIGNATURE_MISMATCH", "The server did not return the correct signature"));
+    socket.destroy();
+  }
+  function Pass() {
+    return Promise.resolve(
+      typeof options.pass === "function" ? options.pass() : options.pass
+    );
+  }
+  function NoData() {
+    result.statement = query.statement;
+    result.statement.columns = [];
+    if (query.onlyDescribe)
+      return query.resolve(query.statement), write(Sync);
+  }
+  function BackendKeyData(x) {
+    backend.pid = x.readUInt32BE(5);
+    backend.secret = x.readUInt32BE(9);
+  }
+  async function fetchArrayTypes() {
+    needsTypes = false;
+    const types2 = await new Query([`
+      select b.oid, b.typarray
+      from pg_catalog.pg_type a
+      left join pg_catalog.pg_type b on b.oid = a.typelem
+      where a.typcategory = 'A'
+      group by b.oid, b.typarray
+      order by b.oid
+    `], [], execute);
+    types2.forEach(({ oid, typarray }) => addArrayType(oid, typarray));
+  }
+  function addArrayType(oid, typarray) {
+    if (!!options.parsers[typarray] && !!options.serializers[typarray]) return;
+    const parser = options.parsers[oid];
+    options.shared.typeArrayMap[oid] = typarray;
+    options.parsers[typarray] = (xs) => arrayParser(xs, parser, typarray);
+    options.parsers[typarray].array = true;
+    options.serializers[typarray] = (xs) => arraySerializer(xs, options.serializers[oid], options, typarray);
+  }
+  function tryNext(x, xs) {
+    return x === "read-write" && xs.default_transaction_read_only === "on" || x === "read-only" && xs.default_transaction_read_only === "off" || x === "primary" && xs.in_hot_standby === "on" || x === "standby" && xs.in_hot_standby === "off" || x === "prefer-standby" && xs.in_hot_standby === "off" && options.host[retries];
+  }
+  function fetchState() {
+    const query2 = new Query([`
+      show transaction_read_only;
+      select pg_catalog.pg_is_in_recovery()
+    `], [], execute, null, { simple: true });
+    query2.resolve = ([[a], [b2]]) => {
+      backendParameters.default_transaction_read_only = a.transaction_read_only;
+      backendParameters.in_hot_standby = b2.pg_is_in_recovery ? "on" : "off";
+    };
+    query2.execute();
+  }
+  function ErrorResponse(x) {
+    if (query) {
+      (query.cursorFn || query.describeFirst) && write(Sync);
+      errorResponse = Errors.postgres(parseError(x));
+    } else {
+      errored(Errors.postgres(parseError(x)));
+    }
+  }
+  function retry(q, error2) {
+    delete statements[q.signature];
+    q.retried = error2;
+    execute(q);
+  }
+  function NotificationResponse(x) {
+    if (!onnotify)
+      return;
+    let index = 9;
+    while (x[index++] !== 0) ;
+    onnotify(
+      x.toString("utf8", 9, index - 1),
+      x.toString("utf8", index, x.length - 1)
+    );
+  }
+  async function PortalSuspended() {
+    try {
+      const x = await Promise.resolve(query.cursorFn(result));
+      rows = 0;
+      x === CLOSE ? write(Close(query.portal)) : (result = new Result(), write(Execute("", query.cursorRows)));
+    } catch (err) {
+      write(Sync);
+      query.reject(err);
+    }
+  }
+  function CloseComplete() {
+    result.count && query.cursorFn(result);
+    query.resolve(result);
+  }
+  function CopyInResponse() {
+    stream = new Stream.Writable({
+      autoDestroy: true,
+      write(chunk2, encoding, callback) {
+        socket.write(bytes_default().d().raw(chunk2).end(), callback);
+      },
+      destroy(error2, callback) {
+        callback(error2);
+        socket.write(bytes_default().f().str(error2 + bytes_default.N).end());
+        stream = null;
+      },
+      final(callback) {
+        socket.write(bytes_default().c().end());
+        final = callback;
+        stream = null;
+      }
+    });
+    query.resolve(stream);
+  }
+  function CopyOutResponse() {
+    stream = new Stream.Readable({
+      read() {
+        socket.resume();
+      }
+    });
+    query.resolve(stream);
+  }
+  function CopyBothResponse() {
+    stream = new Stream.Duplex({
+      autoDestroy: true,
+      read() {
+        socket.resume();
+      },
+      /* c8 ignore next 11 */
+      write(chunk2, encoding, callback) {
+        socket.write(bytes_default().d().raw(chunk2).end(), callback);
+      },
+      destroy(error2, callback) {
+        callback(error2);
+        socket.write(bytes_default().f().str(error2 + bytes_default.N).end());
+        stream = null;
+      },
+      final(callback) {
+        socket.write(bytes_default().c().end());
+        final = callback;
+      }
+    });
+    query.resolve(stream);
+  }
+  function CopyData(x) {
+    stream && (stream.push(x.subarray(5)) || socket.pause());
+  }
+  function CopyDone() {
+    stream && stream.push(null);
+    stream = null;
+  }
+  function NoticeResponse(x) {
+    onnotice ? onnotice(parseError(x)) : console.log(parseError(x));
+  }
+  function EmptyQueryResponse() {
+  }
+  function FunctionCallResponse() {
+    errored(Errors.notSupported("FunctionCallResponse"));
+  }
+  function NegotiateProtocolVersion() {
+    errored(Errors.notSupported("NegotiateProtocolVersion"));
+  }
+  function UnknownMessage(x) {
+    console.error("Postgres.js : Unknown Message:", x[0]);
+  }
+  function UnknownAuth(x, type) {
+    console.error("Postgres.js : Unknown Auth:", type);
+  }
+  function Bind(parameters, types2, statement = "", portal = "") {
+    let prev, type;
+    bytes_default().B().str(portal + bytes_default.N).str(statement + bytes_default.N).i16(0).i16(parameters.length);
+    parameters.forEach((x, i) => {
+      if (x === null)
+        return bytes_default.i32(4294967295);
+      type = types2[i];
+      parameters[i] = x = type in options.serializers ? options.serializers[type](x) : "" + x;
+      prev = bytes_default.i;
+      bytes_default.inc(4).str(x).i32(bytes_default.i - prev - 4, prev);
+    });
+    bytes_default.i16(0);
+    return bytes_default.end();
+  }
+  function Parse(str, parameters, types2, name = "") {
+    bytes_default().P().str(name + bytes_default.N).str(str + bytes_default.N).i16(parameters.length);
+    parameters.forEach((x, i) => bytes_default.i32(types2[i] || 0));
+    return bytes_default.end();
+  }
+  function Describe(x, name = "") {
+    return bytes_default().D().str(x).str(name + bytes_default.N).end();
+  }
+  function Execute(portal = "", rows2 = 0) {
+    return Buffer.concat([
+      bytes_default().E().str(portal + bytes_default.N).i32(rows2).end(),
+      Flush
+    ]);
+  }
+  function Close(portal = "") {
+    return Buffer.concat([
+      bytes_default().C().str("P").str(portal + bytes_default.N).end(),
+      bytes_default().S().end()
+    ]);
+  }
+  function StartupMessage() {
+    return cancelMessage || bytes_default().inc(4).i16(3).z(2).str(
+      Object.entries(Object.assign(
+        {
+          user,
+          database,
+          client_encoding: "UTF8"
+        },
+        options.connection
+      )).filter(([, v]) => v).map(([k, v]) => k + bytes_default.N + v).join(bytes_default.N)
+    ).z(2).end(0);
+  }
+}
+function parseError(x) {
+  const error = {};
+  let start = 5;
+  for (let i = 5; i < x.length - 1; i++) {
+    if (x[i] === 0) {
+      error[errorFields[x[start]]] = x.toString("utf8", start + 1, i);
+      start = i + 1;
+    }
+  }
+  return error;
+}
+function md5(x) {
+  return crypto4.createHash("md5").update(x).digest("hex");
+}
+function hmac2(key, x) {
+  return crypto4.createHmac("sha256", key).update(x).digest();
+}
+function sha2564(x) {
+  return crypto4.createHash("sha256").update(x).digest();
+}
+function xor(a, b2) {
+  const length = Math.max(a.length, b2.length);
+  const buffer2 = Buffer.allocUnsafe(length);
+  for (let i = 0; i < length; i++)
+    buffer2[i] = a[i] ^ b2[i];
+  return buffer2;
+}
+function timer(fn, seconds) {
+  seconds = typeof seconds === "function" ? seconds() : seconds;
+  if (!seconds)
+    return { cancel: noop, start: noop };
+  let timer2;
+  return {
+    cancel() {
+      timer2 && (clearTimeout(timer2), timer2 = null);
+    },
+    start() {
+      timer2 && clearTimeout(timer2);
+      timer2 = setTimeout(done, seconds * 1e3, arguments);
+    }
+  };
+  function done(args) {
+    fn.apply(null, args);
+    timer2 = null;
+  }
+}
+
+// node_modules/postgres/src/subscribe.js
+var noop2 = () => {
+};
+function Subscribe(postgres2, options) {
+  const subscribers = /* @__PURE__ */ new Map(), slot = "postgresjs_" + Math.random().toString(36).slice(2), state = {};
+  let connection2, stream, ended = false;
+  const sql = subscribe.sql = postgres2({
+    ...options,
+    transform: { column: {}, value: {}, row: {} },
+    max: 1,
+    fetch_types: false,
+    idle_timeout: null,
+    max_lifetime: null,
+    connection: {
+      ...options.connection,
+      replication: "database"
+    },
+    onclose: async function() {
+      if (ended)
+        return;
+      stream = null;
+      state.pid = state.secret = void 0;
+      connected(await init(sql, slot, options.publications));
+      subscribers.forEach((event) => event.forEach(({ onsubscribe }) => onsubscribe()));
+    },
+    no_subscribe: true
+  });
+  const end = sql.end, close = sql.close;
+  sql.end = async () => {
+    ended = true;
+    stream && await new Promise((r) => (stream.once("close", r), stream.end()));
+    return end();
+  };
+  sql.close = async () => {
+    stream && await new Promise((r) => (stream.once("close", r), stream.end()));
+    return close();
+  };
+  return subscribe;
+  async function subscribe(event, fn, onsubscribe = noop2, onerror = noop2) {
+    event = parseEvent(event);
+    if (!connection2)
+      connection2 = init(sql, slot, options.publications);
+    const subscriber = { fn, onsubscribe };
+    const fns = subscribers.has(event) ? subscribers.get(event).add(subscriber) : subscribers.set(event, /* @__PURE__ */ new Set([subscriber])).get(event);
+    const unsubscribe = () => {
+      fns.delete(subscriber);
+      fns.size === 0 && subscribers.delete(event);
+    };
+    return connection2.then((x) => {
+      connected(x);
+      onsubscribe();
+      stream && stream.on("error", onerror);
+      return { unsubscribe, state, sql };
+    });
+  }
+  function connected(x) {
+    stream = x.stream;
+    state.pid = x.state.pid;
+    state.secret = x.state.secret;
+  }
+  async function init(sql2, slot2, publications) {
+    if (!publications)
+      throw new Error("Missing publication names");
+    const xs = await sql2.unsafe(
+      `CREATE_REPLICATION_SLOT ${slot2} TEMPORARY LOGICAL pgoutput NOEXPORT_SNAPSHOT`
+    );
+    const [x] = xs;
+    const stream2 = await sql2.unsafe(
+      `START_REPLICATION SLOT ${slot2} LOGICAL ${x.consistent_point} (proto_version '1', publication_names '${publications}')`
+    ).writable();
+    const state2 = {
+      lsn: Buffer.concat(x.consistent_point.split("/").map((x2) => Buffer.from(("00000000" + x2).slice(-8), "hex")))
+    };
+    stream2.on("data", data);
+    stream2.on("error", error);
+    stream2.on("close", sql2.close);
+    return { stream: stream2, state: xs.state };
+    function error(e) {
+      console.error("Unexpected error during logical streaming - reconnecting", e);
+    }
+    function data(x2) {
+      if (x2[0] === 119) {
+        parse(x2.subarray(25), state2, sql2.options.parsers, handle, options.transform);
+      } else if (x2[0] === 107 && x2[17]) {
+        state2.lsn = x2.subarray(1, 9);
+        pong();
+      }
+    }
+    function handle(a, b2) {
+      const path2 = b2.relation.schema + "." + b2.relation.table;
+      call("*", a, b2);
+      call("*:" + path2, a, b2);
+      b2.relation.keys.length && call("*:" + path2 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
+      call(b2.command, a, b2);
+      call(b2.command + ":" + path2, a, b2);
+      b2.relation.keys.length && call(b2.command + ":" + path2 + "=" + b2.relation.keys.map((x2) => a[x2.name]), a, b2);
+    }
+    function pong() {
+      const x2 = Buffer.alloc(34);
+      x2[0] = "r".charCodeAt(0);
+      x2.fill(state2.lsn, 1);
+      x2.writeBigInt64BE(BigInt(Date.now() - Date.UTC(2e3, 0, 1)) * BigInt(1e3), 25);
+      stream2.write(x2);
+    }
+  }
+  function call(x, a, b2) {
+    subscribers.has(x) && subscribers.get(x).forEach(({ fn }) => fn(a, b2, x));
+  }
+}
+function Time(x) {
+  return new Date(Date.UTC(2e3, 0, 1) + Number(x / BigInt(1e3)));
+}
+function parse(x, state, parsers2, handle, transform) {
+  const char = (acc, [k, v]) => (acc[k.charCodeAt(0)] = v, acc);
+  Object.entries({
+    R: (x2) => {
+      let i = 1;
+      const r = state[x2.readUInt32BE(i)] = {
+        schema: x2.toString("utf8", i += 4, i = x2.indexOf(0, i)) || "pg_catalog",
+        table: x2.toString("utf8", i + 1, i = x2.indexOf(0, i + 1)),
+        columns: Array(x2.readUInt16BE(i += 2)),
+        keys: []
+      };
+      i += 2;
+      let columnIndex = 0, column;
+      while (i < x2.length) {
+        column = r.columns[columnIndex++] = {
+          key: x2[i++],
+          name: transform.column.from ? transform.column.from(x2.toString("utf8", i, i = x2.indexOf(0, i))) : x2.toString("utf8", i, i = x2.indexOf(0, i)),
+          type: x2.readUInt32BE(i += 1),
+          parser: parsers2[x2.readUInt32BE(i)],
+          atttypmod: x2.readUInt32BE(i += 4)
+        };
+        column.key && r.keys.push(column);
+        i += 4;
+      }
+    },
+    Y: () => {
+    },
+    // Type
+    O: () => {
+    },
+    // Origin
+    B: (x2) => {
+      state.date = Time(x2.readBigInt64BE(9));
+      state.lsn = x2.subarray(1, 9);
+    },
+    I: (x2) => {
+      let i = 1;
+      const relation = state[x2.readUInt32BE(i)];
+      const { row } = tuples(x2, relation.columns, i += 7, transform);
+      handle(row, {
+        command: "insert",
+        relation
+      });
+    },
+    D: (x2) => {
+      let i = 1;
+      const relation = state[x2.readUInt32BE(i)];
+      i += 4;
+      const key = x2[i] === 75;
+      handle(
+        key || x2[i] === 79 ? tuples(x2, relation.columns, i += 3, transform).row : null,
+        {
+          command: "delete",
+          relation,
+          key
+        }
+      );
+    },
+    U: (x2) => {
+      let i = 1;
+      const relation = state[x2.readUInt32BE(i)];
+      i += 4;
+      const key = x2[i] === 75;
+      const xs = key || x2[i] === 79 ? tuples(x2, relation.columns, i += 3, transform) : null;
+      xs && (i = xs.i);
+      const { row } = tuples(x2, relation.columns, i + 3, transform);
+      handle(row, {
+        command: "update",
+        relation,
+        key,
+        old: xs && xs.row
+      });
+    },
+    T: () => {
+    },
+    // Truncate,
+    C: () => {
+    }
+    // Commit
+  }).reduce(char, {})[x[0]](x);
+}
+function tuples(x, columns, xi, transform) {
+  let type, column, value;
+  const row = transform.raw ? new Array(columns.length) : {};
+  for (let i = 0; i < columns.length; i++) {
+    type = x[xi++];
+    column = columns[i];
+    value = type === 110 ? null : type === 117 ? void 0 : column.parser === void 0 ? x.toString("utf8", xi + 4, xi += 4 + x.readUInt32BE(xi)) : column.parser.array === true ? column.parser(x.toString("utf8", xi + 5, xi += 4 + x.readUInt32BE(xi))) : column.parser(x.toString("utf8", xi + 4, xi += 4 + x.readUInt32BE(xi)));
+    transform.raw ? row[i] = transform.raw === true ? value : transform.value.from ? transform.value.from(value, column) : value : row[column.name] = transform.value.from ? transform.value.from(value, column) : value;
+  }
+  return { i: xi, row: transform.row.from ? transform.row.from(row) : row };
+}
+function parseEvent(x) {
+  const xs = x.match(/^(\*|insert|update|delete)?:?([^.]+?\.?[^=]+)?=?(.+)?/i) || [];
+  if (!xs)
+    throw new Error("Malformed subscribe pattern: " + x);
+  const [, command, path2, key] = xs;
+  return (command || "*") + (path2 ? ":" + (path2.indexOf(".") === -1 ? "public." + path2 : path2) : "") + (key ? "=" + key : "");
+}
+
+// node_modules/postgres/src/large.js
+import Stream2 from "stream";
+function largeObject(sql, oid, mode = 131072 | 262144) {
+  return new Promise(async (resolve, reject) => {
+    await sql.begin(async (sql2) => {
+      let finish;
+      !oid && ([{ oid }] = await sql2`select lo_creat(-1) as oid`);
+      const [{ fd }] = await sql2`select lo_open(${oid}, ${mode}) as fd`;
+      const lo = {
+        writable,
+        readable,
+        close: () => sql2`select lo_close(${fd})`.then(finish),
+        tell: () => sql2`select lo_tell64(${fd})`,
+        read: (x) => sql2`select loread(${fd}, ${x}) as data`,
+        write: (x) => sql2`select lowrite(${fd}, ${x})`,
+        truncate: (x) => sql2`select lo_truncate64(${fd}, ${x})`,
+        seek: (x, whence = 0) => sql2`select lo_lseek64(${fd}, ${x}, ${whence})`,
+        size: () => sql2`
+          select
+            lo_lseek64(${fd}, location, 0) as position,
+            seek.size
+          from (
+            select
+              lo_lseek64($1, 0, 2) as size,
+              tell.location
+            from (select lo_tell64($1) as location) tell
+          ) seek
+        `
+      };
+      resolve(lo);
+      return new Promise(async (r) => finish = r);
+      async function readable({
+        highWaterMark = 2048 * 8,
+        start = 0,
+        end = Infinity
+      } = {}) {
+        let max = end - start;
+        start && await lo.seek(start);
+        return new Stream2.Readable({
+          highWaterMark,
+          async read(size3) {
+            const l = size3 > max ? size3 - max : size3;
+            max -= size3;
+            const [{ data }] = await lo.read(l);
+            this.push(data);
+            if (data.length < size3)
+              this.push(null);
+          }
+        });
+      }
+      async function writable({
+        highWaterMark = 2048 * 8,
+        start = 0
+      } = {}) {
+        start && await lo.seek(start);
+        return new Stream2.Writable({
+          highWaterMark,
+          write(chunk, encoding, callback) {
+            lo.write(chunk).then(() => callback(), callback);
+          }
+        });
+      }
+    }).catch(reject);
+  });
+}
+
+// node_modules/postgres/src/index.js
+Object.assign(Postgres, {
+  PostgresError,
+  toPascal,
+  pascal,
+  toCamel,
+  camel,
+  toKebab,
+  kebab,
+  fromPascal,
+  fromCamel,
+  fromKebab,
+  BigInt: {
+    to: 20,
+    from: [20],
+    parse: (x) => BigInt(x),
+    // eslint-disable-line
+    serialize: (x) => x.toString()
+  }
+});
+var src_default = Postgres;
+function Postgres(a, b2) {
+  const options = parseOptions(a, b2), subscribe = options.no_subscribe || Subscribe(Postgres, { ...options });
+  let ending = false;
+  const queries = queue_default(), connecting = queue_default(), reserved = queue_default(), closed = queue_default(), ended = queue_default(), open = queue_default(), busy = queue_default(), full = queue_default(), queues = { connecting, reserved, closed, ended, open, busy, full };
+  const connections = [...Array(options.max)].map(() => connection_default(options, queues, { onopen, onend, onclose }));
+  const sql = Sql(handler);
+  Object.assign(sql, {
+    get parameters() {
+      return options.parameters;
+    },
+    largeObject: largeObject.bind(null, sql),
+    subscribe,
+    CLOSE,
+    END: CLOSE,
+    PostgresError,
+    options,
+    reserve,
+    listen,
+    begin,
+    close,
+    end
+  });
+  return sql;
+  function Sql(handler2) {
+    handler2.debug = options.debug;
+    Object.entries(options.types).reduce((acc, [name, type]) => {
+      acc[name] = (x) => new Parameter(x, type.to);
+      return acc;
+    }, typed);
+    Object.assign(sql2, {
+      types: typed,
+      typed,
+      unsafe,
+      notify,
+      array,
+      json,
+      file
+    });
+    return sql2;
+    function typed(value, type) {
+      return new Parameter(value, type);
+    }
+    function sql2(strings, ...args) {
+      const query = strings && Array.isArray(strings.raw) ? new Query(strings, args, handler2, cancel) : typeof strings === "string" && !args.length ? new Identifier(options.transform.column.to ? options.transform.column.to(strings) : strings) : new Builder(strings, args);
+      return query;
+    }
+    function unsafe(string, args = [], options2 = {}) {
+      arguments.length === 2 && !Array.isArray(args) && (options2 = args, args = []);
+      const query = new Query([string], args, handler2, cancel, {
+        prepare: false,
+        ...options2,
+        simple: "simple" in options2 ? options2.simple : args.length === 0
+      });
+      return query;
+    }
+    function file(path2, args = [], options2 = {}) {
+      arguments.length === 2 && !Array.isArray(args) && (options2 = args, args = []);
+      const query = new Query([], args, (query2) => {
+        fs2.readFile(path2, "utf8", (err, string) => {
+          if (err)
+            return query2.reject(err);
+          query2.strings = [string];
+          handler2(query2);
+        });
+      }, cancel, {
+        ...options2,
+        simple: "simple" in options2 ? options2.simple : args.length === 0
+      });
+      return query;
+    }
+  }
+  async function listen(name, fn, onlisten) {
+    const listener = { fn, onlisten };
+    const sql2 = listen.sql || (listen.sql = Postgres({
+      ...options,
+      max: 1,
+      idle_timeout: null,
+      max_lifetime: null,
+      fetch_types: false,
+      onclose() {
+        Object.entries(listen.channels).forEach(([name2, { listeners }]) => {
+          delete listen.channels[name2];
+          Promise.all(listeners.map((l) => listen(name2, l.fn, l.onlisten).catch(() => {
+          })));
+        });
+      },
+      onnotify(c, x) {
+        c in listen.channels && listen.channels[c].listeners.forEach((l) => l.fn(x));
+      }
+    }));
+    const channels = listen.channels || (listen.channels = {}), exists = name in channels;
+    if (exists) {
+      channels[name].listeners.push(listener);
+      const result2 = await channels[name].result;
+      listener.onlisten && listener.onlisten();
+      return { state: result2.state, unlisten };
+    }
+    channels[name] = { result: sql2`listen ${sql2.unsafe('"' + name.replace(/"/g, '""') + '"')}`, listeners: [listener] };
+    const result = await channels[name].result;
+    listener.onlisten && listener.onlisten();
+    return { state: result.state, unlisten };
+    async function unlisten() {
+      if (name in channels === false)
+        return;
+      channels[name].listeners = channels[name].listeners.filter((x) => x !== listener);
+      if (channels[name].listeners.length)
+        return;
+      delete channels[name];
+      return sql2`unlisten ${sql2.unsafe('"' + name.replace(/"/g, '""') + '"')}`;
+    }
+  }
+  async function notify(channel, payload) {
+    return await sql`select pg_notify(${channel}, ${"" + payload})`;
+  }
+  async function reserve() {
+    const queue = queue_default();
+    const c = open.length ? open.shift() : await new Promise((resolve, reject) => {
+      const query = { reserve: resolve, reject };
+      queries.push(query);
+      closed.length && connect(closed.shift(), query);
+    });
+    move(c, reserved);
+    c.reserved = () => queue.length ? c.execute(queue.shift()) : move(c, reserved);
+    c.reserved.release = true;
+    const sql2 = Sql(handler2);
+    sql2.release = () => {
+      c.reserved = null;
+      onopen(c);
+    };
+    return sql2;
+    function handler2(q) {
+      c.queue === full ? queue.push(q) : c.execute(q) || move(c, full);
+    }
+  }
+  async function begin(options2, fn) {
+    !fn && (fn = options2, options2 = "");
+    const queries2 = queue_default();
+    let savepoints = 0, connection2, prepare = null;
+    try {
+      await sql.unsafe("begin " + options2.replace(/[^a-z ]/ig, ""), [], { onexecute }).execute();
+      return await Promise.race([
+        scope(connection2, fn),
+        new Promise((_, reject) => connection2.onclose = reject)
+      ]);
+    } catch (error) {
+      throw error;
+    }
+    async function scope(c, fn2, name) {
+      const sql2 = Sql(handler2);
+      sql2.savepoint = savepoint;
+      sql2.prepare = (x) => prepare = x.replace(/[^a-z0-9$-_. ]/gi);
+      let uncaughtError, result;
+      name && await sql2`savepoint ${sql2(name)}`;
+      try {
+        result = await new Promise((resolve, reject) => {
+          const x = fn2(sql2);
+          Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve, reject);
+        });
+        if (uncaughtError)
+          throw uncaughtError;
+      } catch (e) {
+        await (name ? sql2`rollback to ${sql2(name)}` : sql2`rollback`);
+        throw e instanceof PostgresError && e.code === "25P02" && uncaughtError || e;
+      }
+      if (!name) {
+        prepare ? await sql2`prepare transaction '${sql2.unsafe(prepare)}'` : await sql2`commit`;
+      }
+      return result;
+      function savepoint(name2, fn3) {
+        if (name2 && Array.isArray(name2.raw))
+          return savepoint((sql3) => sql3.apply(sql3, arguments));
+        arguments.length === 1 && (fn3 = name2, name2 = null);
+        return scope(c, fn3, "s" + savepoints++ + (name2 ? "_" + name2 : ""));
+      }
+      function handler2(q) {
+        q.catch((e) => uncaughtError || (uncaughtError = e));
+        c.queue === full ? queries2.push(q) : c.execute(q) || move(c, full);
+      }
+    }
+    function onexecute(c) {
+      connection2 = c;
+      move(c, reserved);
+      c.reserved = () => queries2.length ? c.execute(queries2.shift()) : move(c, reserved);
+    }
+  }
+  function move(c, queue) {
+    c.queue.remove(c);
+    queue.push(c);
+    c.queue = queue;
+    queue === open ? c.idleTimer.start() : c.idleTimer.cancel();
+    return c;
+  }
+  function json(x) {
+    return new Parameter(x, 3802);
+  }
+  function array(x, type) {
+    if (!Array.isArray(x))
+      return array(Array.from(arguments));
+    return new Parameter(x, type || (x.length ? inferType(x) || 25 : 0), options.shared.typeArrayMap);
+  }
+  function handler(query) {
+    if (ending)
+      return query.reject(Errors.connection("CONNECTION_ENDED", options, options));
+    if (open.length)
+      return go(open.shift(), query);
+    if (closed.length)
+      return connect(closed.shift(), query);
+    busy.length ? go(busy.shift(), query) : queries.push(query);
+  }
+  function go(c, query) {
+    return c.execute(query) ? move(c, busy) : move(c, full);
+  }
+  function cancel(query) {
+    return new Promise((resolve, reject) => {
+      query.state ? query.active ? connection_default(options).cancel(query.state, resolve, reject) : query.cancelled = { resolve, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve());
+    });
+  }
+  async function end({ timeout = null } = {}) {
+    if (ending)
+      return ending;
+    await 1;
+    let timer2;
+    return ending = Promise.race([
+      new Promise((r) => timeout !== null && (timer2 = setTimeout(destroy, timeout * 1e3, r))),
+      Promise.all(connections.map((c) => c.end()).concat(
+        listen.sql ? listen.sql.end({ timeout: 0 }) : [],
+        subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []
+      ))
+    ]).then(() => clearTimeout(timer2));
+  }
+  async function close() {
+    await Promise.all(connections.map((c) => c.end()));
+  }
+  async function destroy(resolve) {
+    await Promise.all(connections.map((c) => c.terminate()));
+    while (queries.length)
+      queries.shift().reject(Errors.connection("CONNECTION_DESTROYED", options));
+    resolve();
+  }
+  function connect(c, query) {
+    move(c, connecting);
+    c.connect(query);
+    return c;
+  }
+  function onend(c) {
+    move(c, ended);
+  }
+  function onopen(c) {
+    if (queries.length === 0)
+      return move(c, open);
+    let max = Math.ceil(queries.length / (connecting.length + 1)), ready = true;
+    while (ready && queries.length && max-- > 0) {
+      const query = queries.shift();
+      if (query.reserve)
+        return query.reserve(c);
+      ready = c.execute(query);
+    }
+    ready ? move(c, busy) : move(c, full);
+  }
+  function onclose(c, e) {
+    move(c, closed);
+    c.reserved = null;
+    c.onclose && (c.onclose(e), c.onclose = null);
+    options.onclose && options.onclose(c.id);
+    queries.length && connect(c, queries.shift());
+  }
+}
+function parseOptions(a, b2) {
+  if (a && a.shared)
+    return a;
+  const env = process.env, o = (!a || typeof a === "string" ? b2 : a) || {}, { url, multihost } = parseUrl(a), query = [...url.searchParams].reduce((a2, [b3, c]) => (a2[b3] = c, a2), {}), host = o.hostname || o.host || multihost || url.hostname || env.PGHOST || "localhost", port = o.port || url.port || env.PGPORT || 5432, user = o.user || o.username || url.username || env.PGUSERNAME || env.PGUSER || osUsername();
+  o.no_prepare && (o.prepare = false);
+  query.sslmode && (query.ssl = query.sslmode, delete query.sslmode);
+  "timeout" in o && (console.log("The timeout option is deprecated, use idle_timeout instead"), o.idle_timeout = o.timeout);
+  query.sslrootcert === "system" && (query.ssl = "verify-full");
+  const ints = ["idle_timeout", "connect_timeout", "max_lifetime", "max_pipeline", "backoff", "keep_alive"];
+  const defaults = {
+    max: globalThis.Cloudflare ? 3 : 10,
+    ssl: false,
+    sslnegotiation: null,
+    idle_timeout: null,
+    connect_timeout: 30,
+    max_lifetime,
+    max_pipeline: 100,
+    backoff,
+    keep_alive: 60,
+    prepare: true,
+    debug: false,
+    fetch_types: true,
+    publications: "alltables",
+    target_session_attrs: null
+  };
+  return {
+    host: Array.isArray(host) ? host : host.split(",").map((x) => x.split(":")[0]),
+    port: Array.isArray(port) ? port : host.split(",").map((x) => parseInt(x.split(":")[1] || port)),
+    path: o.path || host.indexOf("/") > -1 && host + "/.s.PGSQL." + port,
+    database: o.database || o.db || (url.pathname || "").slice(1) || env.PGDATABASE || user,
+    user,
+    pass: o.pass || o.password || url.password || env.PGPASSWORD || "",
+    ...Object.entries(defaults).reduce(
+      (acc, [k, d]) => {
+        const value = k in o ? o[k] : k in query ? query[k] === "disable" || query[k] === "false" ? false : query[k] : env["PG" + k.toUpperCase()] || d;
+        acc[k] = typeof value === "string" && ints.includes(k) ? +value : value;
+        return acc;
+      },
+      {}
+    ),
+    connection: {
+      application_name: env.PGAPPNAME || "postgres.js",
+      ...o.connection,
+      ...Object.entries(query).reduce((acc, [k, v]) => (k in defaults || (acc[k] = v), acc), {})
+    },
+    types: o.types || {},
+    target_session_attrs: tsa(o, url, env),
+    onnotice: o.onnotice,
+    onnotify: o.onnotify,
+    onclose: o.onclose,
+    onparameter: o.onparameter,
+    socket: o.socket,
+    transform: parseTransform(o.transform || { undefined: void 0 }),
+    parameters: {},
+    shared: { retries: 0, typeArrayMap: {} },
+    ...mergeUserTypes(o.types)
+  };
+}
+function tsa(o, url, env) {
+  const x = o.target_session_attrs || url.searchParams.get("target_session_attrs") || env.PGTARGETSESSIONATTRS;
+  if (!x || ["read-write", "read-only", "primary", "standby", "prefer-standby"].includes(x))
+    return x;
+  throw new Error("target_session_attrs " + x + " is not supported");
+}
+function backoff(retries) {
+  return (0.5 + Math.random() / 2) * Math.min(3 ** retries / 100, 20);
+}
+function max_lifetime() {
+  return 60 * (30 + Math.random() * 30);
+}
+function parseTransform(x) {
+  return {
+    undefined: x.undefined,
+    column: {
+      from: typeof x.column === "function" ? x.column : x.column && x.column.from,
+      to: x.column && x.column.to
+    },
+    value: {
+      from: typeof x.value === "function" ? x.value : x.value && x.value.from,
+      to: x.value && x.value.to
+    },
+    row: {
+      from: typeof x.row === "function" ? x.row : x.row && x.row.from,
+      to: x.row && x.row.to
+    }
+  };
+}
+function parseUrl(url) {
+  if (!url || typeof url !== "string")
+    return { url: { searchParams: /* @__PURE__ */ new Map() } };
+  let host = url;
+  host = host.slice(host.indexOf("://") + 3).split(/[?/]/)[0];
+  host = decodeURIComponent(host.slice(host.indexOf("@") + 1));
+  const urlObj = new URL(url.replace(host, host.split(",")[0]));
+  return {
+    url: {
+      username: decodeURIComponent(urlObj.username),
+      password: decodeURIComponent(urlObj.password),
+      host: urlObj.host,
+      hostname: urlObj.hostname,
+      port: urlObj.port,
+      pathname: urlObj.pathname,
+      searchParams: urlObj.searchParams
+    },
+    multihost: host.indexOf(",") > -1 && host
+  };
+}
+function osUsername() {
+  try {
+    return os.userInfo().username;
+  } catch (_) {
+    return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
+  }
+}
+
+// src/postgres-redemption.mjs
+var claimId = (key) => createHash("sha256").update(String(key)).digest("hex");
+var EXPIRY_GRACE_MS = 60001;
+async function createPostgresRedemptionStore({ url } = {}) {
+  const retentionMs = DEFAULT_RETENTION_MS;
+  const sql = src_default(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 20,
+    connection: { application_name: "mtok-relay", statement_timeout: 5e3, lock_timeout: 5e3, synchronous_commit: "on" },
+    onnotice() {
+    }
+  });
+  const expiryMs = retentionMs + EXPIRY_GRACE_MS;
+  let initialized = false;
+  try {
+    await sql.begin(async (tx) => {
+      await tx`select pg_advisory_xact_lock(hashtext('mtok_redemptions_v1'))`;
+      await tx`
+        create table if not exists mtok_redemptions (
+            claimkey text primary key
+          , state text not null check (state in ('pending', 'complete'))
+          , payload jsonb
+          , expiresat timestamptz not null
+          , check ((state = 'pending' and payload is null) or (state = 'complete' and payload is not null))
+        )
+      `;
+      await tx`create index if not exists mtok_redemptions_expiry on mtok_redemptions (expiresat)`;
+      await tx`
+        create table if not exists mtok_redemption_keys (
+            keyid text primary key
+          , claimkey text not null references mtok_redemptions (claimkey) on delete cascade
+        )
+      `;
+      await tx`create index if not exists mtok_redemption_keys_claim on mtok_redemption_keys (claimkey)`;
+      await tx`
+        delete from mtok_redemptions
+        where
+          claimkey in (
+          select claimkey from mtok_redemptions
+          where expiresat < current_timestamp
+          order by expiresat
+          limit 256
+        )
+      `;
+    });
+    initialized = true;
+  } finally {
+    if (!initialized) await sql.end({ timeout: 1 });
+  }
+  const store = {
+    durable: true,
+    retentionMs,
+    async state(key) {
+      const [row] = await sql`
+        select
+          r.state
+        from
+          mtok_redemption_keys k
+          join mtok_redemptions r on
+            r.claimkey = k.claimkey
+        where
+          k.keyid = ${claimId(key)}
+      `;
+      return row?.state ?? null;
+    },
+    async get(key) {
+      const [row] = await sql`
+        select
+          r.payload
+        from
+          mtok_redemption_keys k
+          join mtok_redemptions r on
+            r.claimkey = k.claimkey
+            and r.state = 'complete'
+        where
+          k.keyid = ${claimId(key)}
+      `;
+      return row?.payload;
+    },
+    async claim(key, markerKey = key) {
+      const id = claimId(key);
+      if (markerKey !== key && key !== `legacy-v0:${markerKey}`) throw new TypeError("redemption marker does not match its claim");
+      const aliases = [.../* @__PURE__ */ new Set([id, claimId(markerKey)])].sort();
+      try {
+        await sql.begin(async (tx) => {
+          await tx`
+            insert into mtok_redemptions (claimkey, state, expiresat)
+            values (${id}, 'pending', current_timestamp + ${expiryMs} * interval '1 millisecond')
+          `;
+          await tx`
+            insert into mtok_redemption_keys (keyid, claimkey)
+            select
+                unnest(${aliases}::text[])
+              , ${id}
+          `;
+        });
+        return true;
+      } catch (error) {
+        if (error.code === "23505" && ["mtok_redemptions_pkey", "mtok_redemption_keys_pkey"].includes(error.constraint_name)) return false;
+        throw error;
+      }
+    },
+    async complete(key, payload) {
+      const rows = await sql`
+        update mtok_redemptions
+        set payload = ${sql.json(payload)}
+          , state = 'complete'
+          , expiresat = current_timestamp + ${expiryMs} * interval '1 millisecond'
+        where
+          claimkey = (select claimkey from mtok_redemption_keys where keyid = ${claimId(key)})
+          and state = 'pending'
+        returning claimkey
+      `;
+      if (rows.length !== 1) throw new Error("redemption is not pending");
+    },
+    async importRecord({ key, state, payload }) {
+      if (!["pending", "complete"].includes(state)) throw new TypeError("invalid imported redemption state");
+      if (state === "complete" && payload == null) throw new TypeError("completed redemption needs a payload");
+      await store.claim(key);
+      if (state === "pending") return;
+      await sql.begin(async (tx) => {
+        const [existing] = await tx`
+          select
+            r.claimkey
+          from
+            mtok_redemption_keys k
+            join mtok_redemptions r on
+              r.claimkey = k.claimkey
+          where
+            k.keyid = ${claimId(key)}
+          for update of r
+        `;
+        await tx`
+          update mtok_redemptions
+          set state = 'complete', payload = ${tx.json(payload)}
+          where
+            claimkey = ${existing.claimkey}
+            and state = 'pending'
+        `;
+        const [row] = await tx`
+          select
+            payload = ${tx.json(payload)} as matches
+          from
+            mtok_redemptions
+          where
+            claimkey = ${existing.claimkey}
+        `;
+        if (!row.matches) throw new Error("conflicting completed redemption records");
+      });
+    },
+    close() {
+      return sql.end({ timeout: 5 });
+    }
+  };
+  return store;
+}
+
 // core/onchain.js
 var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
 var DRAW_PAID_TOPIC = "0xb0243f80521d0dccd159389597aba96047e60ba5d7a9df12b67e5cb75230ac41";
@@ -5080,9 +7371,9 @@ var asciiFromHex = (hex) => {
   const bytes = strip0x(hex);
   const out = [];
   for (let i = 0; i < bytes.length; i += 2) {
-    const b = parseInt(bytes.slice(i, i + 2), 16);
-    if (!Number.isFinite(b)) break;
-    out.push(b);
+    const b2 = parseInt(bytes.slice(i, i + 2), 16);
+    if (!Number.isFinite(b2)) break;
+    out.push(b2);
   }
   return new TextDecoder().decode(new Uint8Array(out));
 };
@@ -5369,7 +7660,7 @@ var REQUEST_KEYS = /* @__PURE__ */ new Set(["model", "messages", "max_tokens", "
 async function hash32(v) {
   const bytes = new TextEncoder().encode(typeof v === "string" ? v : JSON.stringify(v ?? null));
   const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return "0x" + [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return "0x" + [...new Uint8Array(digest)].map((b2) => b2.toString(16).padStart(2, "0")).join("");
 }
 function legacyContentText(content) {
   const render = (part) => {
@@ -5447,10 +7738,10 @@ function normalizeModelId(m) {
 }
 function modelsCompatible(upstreamModel, offerModel) {
   const a = normalizeModelId(upstreamModel);
-  const b = normalizeModelId(offerModel);
-  if (!a || !b) return false;
-  if (a === b) return true;
-  const [longer, shorter] = a.length >= b.length ? [a, b] : [b, a];
+  const b2 = normalizeModelId(offerModel);
+  if (!a || !b2) return false;
+  if (a === b2) return true;
+  const [longer, shorter] = a.length >= b2.length ? [a, b2] : [b2, a];
   if (!longer.startsWith(shorter)) return false;
   const rest = longer.slice(shorter.length);
   return /^([-._]\d+)+$/.test(rest);
@@ -5466,11 +7757,11 @@ function configuredFeeAtomic({ sellerUsdAtomic, feeAddress, feeBps }) {
 }
 var MESSAGE_OVERHEAD_TOKENS = 4;
 var BYTES_PER_TOKEN_EST = 3.2;
-function estimateInputTokens(messages) {
+function estimateInputTokens(messages2) {
   const utf8 = new TextEncoder();
   let bytes = 0;
   let envelope = 3;
-  for (const m of messages ?? []) {
+  for (const m of messages2 ?? []) {
     envelope += MESSAGE_OVERHEAD_TOKENS;
     bytes += utf8.encode(String(m?.role ?? "")).length;
     bytes += utf8.encode(typeof m?.content === "string" ? m.content : JSON.stringify(m?.content ?? null)).length;
@@ -5478,8 +7769,8 @@ function estimateInputTokens(messages) {
   return envelope + Math.ceil(bytes / BYTES_PER_TOKEN_EST);
 }
 var DEFAULT_MAX_OUTPUT_TOKENS = 32768;
-function boundServe({ messages, budgetUsd, inPrice, outPrice, reqMax, contextCeil = DEFAULT_MAX_OUTPUT_TOKENS }) {
-  const estIn = estimateInputTokens(messages);
+function boundServe({ messages: messages2, budgetUsd, inPrice, outPrice, reqMax, contextCeil = DEFAULT_MAX_OUTPUT_TOKENS }) {
+  const estIn = estimateInputTokens(messages2);
   const estInCostUsd = estIn * (Number(inPrice) > 0 ? Number(inPrice) : 0) / 1e6;
   if (estInCostUsd >= budgetUsd) return { refuse: true, reason: "input", estIn, estInCostUsd };
   const outBudgetUsd = budgetUsd - estInCostUsd;
@@ -5532,19 +7823,20 @@ function createServeCore({
     const requestHash = hasRequestNonce ? await hash32({ request, requestNonce }) : await hash32(request);
     const cacheKey = `${requestHashScheme}:${bookingId}:${n}:${requestHash}`;
     const oldLegacyKey = hasRequestNonce ? null : `${bookingId}:${n}:${requestHash}`;
+    const redemptionContext = { claimKey: cacheKey };
     if (!dripContractAddress) {
       return { status: 402, body: { error: "contract_mode_required", detail: "this relay only serves contract-mode draws; the platform is not reporting a dripContractAddress" } };
     }
     if (!drawPaidTxHash) return { status: 402, body: { error: "draw_payment_required", detail: "contract mode requires drawPaidTxHash before upstream delivery" } };
     let storedKey = cacheKey;
-    let redemptionState = await redemption.state(storedKey);
+    let redemptionState = await redemption.state(storedKey, redemptionContext);
     if (!redemptionState && oldLegacyKey) {
-      const oldLegacyState = await redemption.state(oldLegacyKey);
+      const oldLegacyState = await redemption.state(oldLegacyKey, redemptionContext);
       if (oldLegacyState) {
         storedKey = oldLegacyKey;
         redemptionState = oldLegacyState;
       } else {
-        redemptionState = await redemption.state(cacheKey);
+        redemptionState = await redemption.state(cacheKey, redemptionContext);
       }
     }
     let paid;
@@ -5580,7 +7872,11 @@ function createServeCore({
         return { status: 403, body: { error: "payer_denied", detail: "payer screening failed: " + e.message } };
       }
     }
-    if (redemptionState === "complete") return { status: 200, body: await redemption.get(storedKey) };
+    if (redemptionState === "complete") {
+      const payload2 = await redemption.get(storedKey, redemptionContext);
+      if (payload2 == null) return { status: 503, body: { error: "redemption_unavailable", detail: "saved completion is no longer readable; retry this same paid draw", _bookingId: bookingId } };
+      return { status: 200, body: payload2 };
+    }
     if (redemptionState === "pending") {
       return { status: 409, body: { error: "draw_pending", detail: "this paid draw was already claimed; refusing to run upstream again", _bookingId: bookingId } };
     }
@@ -5611,7 +7907,7 @@ function createServeCore({
     }
     const safeRequest = { ...checked.safeRequest, model, max_tokens: bound.maxTok };
     try {
-      if (!await redemption.claim(cacheKey, oldLegacyKey ?? cacheKey)) {
+      if (!await redemption.claim(cacheKey, oldLegacyKey ?? cacheKey, { paidAtMs: paid.paidAtMs })) {
         return { status: 409, body: { error: "draw_pending", detail: "this paid draw was already claimed; refusing to run upstream again", _bookingId: bookingId } };
       }
     } catch (e) {
@@ -5685,7 +7981,6 @@ var rpcUrlsFor = (chainId, override) => override ? [override] : Number(chainId)
 
 // src/runtime.mjs
 async function createRelayRuntime(config) {
-  const served = createRedemptionStore({ file: config.redemptionFile, log: config.log });
   const drawLocks = /* @__PURE__ */ new Map();
   const platform = await fetchPlatformConfig(config);
   const FEE_REFRESH_MS = 6e4;
@@ -5709,6 +8004,7 @@ async function createRelayRuntime(config) {
   };
   const verifier = createOnchainVerifier({ rpcUrls: rpcUrlsFor(platform.chainId, config.rpcFlag), usdcAddress: platform.usdcAddress, expectedChainId: platform.chainId });
   if (!verifier.configured) throw new Error("onchain verifier not configured (missing usdcAddress in /api/config)");
+  const served = config.redemptionDatabaseUrl ? await createPostgresRedemptionStore({ url: config.redemptionDatabaseUrl }) : createRedemptionStore({ file: config.redemptionFile, log: config.log });
   const payerDenylist = new Set((config.payerDenylist ?? []).map((a) => String(a).trim().toLowerCase()).filter(Boolean));
   const screenPayer = typeof config.screenPayer === "function" ? config.screenPayer : null;
   const upstream = httpUpstream({ baseUrl: config.upstream + "/v1", key: config.upstreamKey, timeoutMs: config.upstreamTimeoutMs ?? 12e4 });
@@ -5773,7 +8069,7 @@ async function createRelayRuntime(config) {
       active--;
     }
   };
-  return { handleDraw };
+  return { handleDraw, close: () => served.close?.() };
 }
 async function fetchPlatformConfig(config) {
   const r = await fetch(config.apiBase + "/api/config", { signal: AbortSignal.timeout(5e3) });
@@ -5789,11 +8085,58 @@ async function fetchPlatformConfig(config) {
   };
 }
 
+// src/import-redemptions.mjs
+import fs3 from "node:fs";
+import path from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+async function importRedemptionFiles(store, files) {
+  let imported = 0;
+  for (const file of files) {
+    for (const [index, line] of fs3.readFileSync(file, "utf8").split("\n").entries()) {
+      if (!line.trim()) continue;
+      const record = JSON.parse(line);
+      const state = record.state ?? "complete";
+      if (typeof record.k !== "string" || !record.k || !Number.isFinite(Number(record.at))) {
+        throw new Error(`malformed redemption record at ${file}:${index + 1}`);
+      }
+      await store.importRecord({ key: record.k, state, payload: record.payload });
+      imported++;
+    }
+    const directory = `${file}.claims`;
+    if (!fs3.existsSync(directory)) continue;
+    for (const name of fs3.readdirSync(directory)) {
+      const text = fs3.readFileSync(path.join(directory, name), "utf8");
+      const key = text.endsWith("\n") ? text.slice(0, -1) : text;
+      if (!key || createHash2("sha256").update(key).digest("hex") !== name) {
+        throw new Error(`malformed redemption marker in ${directory}`);
+      }
+      await store.importRecord({ key, state: "pending" });
+      imported++;
+    }
+  }
+  return imported;
+}
+
 // mtok-relay.mjs
 try {
-  const config = readRelayConfig();
-  const runtime = await createRelayRuntime(config);
-  startRelayServer({ config, ...runtime });
+  if (process.argv[2] === "import-redemptions") {
+    const files = process.argv.slice(3);
+    if (!files.length || !process.env.RELAY_REDEMPTION_DATABASE_URL) {
+      throw new Error("import-redemptions needs one or more JSONL paths and RELAY_REDEMPTION_DATABASE_URL");
+    }
+    const store = await createPostgresRedemptionStore({ url: process.env.RELAY_REDEMPTION_DATABASE_URL });
+    try {
+      const count = await importRedemptionFiles(store, files);
+      console.log(`mtok-relay: imported ${count} redemption records and markers`);
+    } finally {
+      await store.close();
+    }
+  } else {
+    const config = readRelayConfig();
+    const runtime = await createRelayRuntime(config);
+    const server = startRelayServer({ config, ...runtime });
+    server.on("close", () => runtime.close());
+  }
 } catch (e) {
   console.error("mtok-relay: boot failed -", e.message);
   process.exit(1);