@peerbit/indexer-sqlite3 1.0.7 → 1.1.0

package/dist/peerbit/sqlite3.min.js

@@ -5587,9 +5587,6 @@ var FixedArrayKind = class extends WrappedType {
     this.length = length;
   }
 };
-var fixedArray = (type, length) => {
-  return new FixedArrayKind(type, length);
-};
 var StructKind = class {
   constructor(properties) {
     if (properties) {
@@ -6668,6 +6665,273 @@ var resize = (arr, newSize, defaultValue) => {
   arr.length = newSize;
 };
 
+// ../../../../node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+
+// ../../../../node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      pbegin++;
+    }
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../../../node_modules/multiformats/dist/src/bases/base.js
+var Encoder = class {
+  name;
+  prefix;
+  baseEncode;
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  name;
+  prefix;
+  baseDecode;
+  prefixCodePoint;
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    const prefixCodePoint = prefix.codePointAt(0);
+    if (prefixCodePoint === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+var Codec = class {
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+function from({ name, prefix, encode, decode }) {
+  return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode, decode } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode,
+    decode: (text) => coerce(decode(text))
+  });
+}
+
+// ../../../../node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
 // ../../../../node_modules/@stablelib/int/lib/int.js
 var isInteger = Number.isInteger;
 var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
@@ -6685,7 +6949,7 @@ function writeUint32BE(value, out = new Uint8Array(4), offset = 0) {
   return out;
 }
 
-// ../../../../node_modules/@stablelib/sha256/node_modules/@stablelib/wipe/lib/wipe.js
+// ../../../../node_modules/@stablelib/wipe/lib/wipe.js
 function wipe(array) {
   for (let i = 0; i < array.length; i++) {
     array[i] = 0;
@@ -6933,311 +7197,43 @@ function hashBlocks(w, v2, p, pos, len) {
     let h = v2[7];
     for (let i = 0; i < 16; i++) {
       let j = pos + i * 4;
-      w[i] = readUint32BE(p, j);
-    }
-    for (let i = 16; i < 64; i++) {
-      let u = w[i - 2];
-      let t1 = (u >>> 17 | u << 32 - 17) ^ (u >>> 19 | u << 32 - 19) ^ u >>> 10;
-      u = w[i - 15];
-      let t2 = (u >>> 7 | u << 32 - 7) ^ (u >>> 18 | u << 32 - 18) ^ u >>> 3;
-      w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
-    }
-    for (let i = 0; i < 64; i++) {
-      let t1 = (((e >>> 6 | e << 32 - 6) ^ (e >>> 11 | e << 32 - 11) ^ (e >>> 25 | e << 32 - 25)) + (e & f ^ ~e & g) | 0) + (h + (K[i] + w[i] | 0) | 0) | 0;
-      let t2 = ((a >>> 2 | a << 32 - 2) ^ (a >>> 13 | a << 32 - 13) ^ (a >>> 22 | a << 32 - 22)) + (a & b ^ a & c ^ b & c) | 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + t1 | 0;
-      d = c;
-      c = b;
-      b = a;
-      a = t1 + t2 | 0;
-    }
-    v2[0] += a;
-    v2[1] += b;
-    v2[2] += c;
-    v2[3] += d;
-    v2[4] += e;
-    v2[5] += f;
-    v2[6] += g;
-    v2[7] += h;
-    pos += 64;
-    len -= 64;
-  }
-  return pos;
-}
-
-// ../../crypto/dist/src/utils.js
-var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
-
-// ../../../../node_modules/multiformats/dist/src/bytes.js
-var empty = new Uint8Array(0);
-function coerce(o) {
-  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
-    return o;
-  if (o instanceof ArrayBuffer)
-    return new Uint8Array(o);
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
-  }
-  throw new Error("Unknown type, must be binary type");
-}
-
-// ../../../../node_modules/multiformats/dist/src/vendor/base-x.js
-function base(ALPHABET, name) {
-  if (ALPHABET.length >= 255) {
-    throw new TypeError("Alphabet too long");
-  }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) {
-      throw new TypeError(x + " is ambiguous");
-    }
-    BASE_MAP[xc] = i;
-  }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256);
-  var iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length = i2;
-      pbegin++;
-    }
-    var it2 = size - length;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
-    }
-    return str;
-  }
-  function decodeUnsafe(source) {
-    if (typeof source !== "string") {
-      throw new TypeError("Expected String");
-    }
-    if (source.length === 0) {
-      return new Uint8Array();
-    }
-    var psz = 0;
-    if (source[psz] === " ") {
-      return;
-    }
-    var zeroes = 0;
-    var length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    var size = (source.length - psz) * FACTOR + 1 >>> 0;
-    var b256 = new Uint8Array(size);
-    while (source[psz]) {
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-      if (carry === 255) {
-        return;
-      }
-      var i2 = 0;
-      for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length = i2;
-      psz++;
-    }
-    if (source[psz] === " ") {
-      return;
-    }
-    var it4 = size - length;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j2 = zeroes;
-    while (it4 !== size) {
-      vch[j2++] = b256[it4++];
-    }
-    return vch;
-  }
-  function decode(string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) {
-      return buffer;
-    }
-    throw new Error(`Non-${name} character`);
-  }
-  return {
-    encode,
-    decodeUnsafe,
-    decode
-  };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../../../node_modules/multiformats/dist/src/bases/base.js
-var Encoder = class {
-  name;
-  prefix;
-  baseEncode;
-  constructor(name, prefix, baseEncode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-  encode(bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`;
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-var Decoder = class {
-  name;
-  prefix;
-  baseDecode;
-  prefixCodePoint;
-  constructor(name, prefix, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    if (prefix.codePointAt(0) === void 0) {
-      throw new Error("Invalid prefix character");
-    }
-    this.prefixCodePoint = prefix.codePointAt(0);
-    this.baseDecode = baseDecode;
-  }
-  decode(text) {
-    if (typeof text === "string") {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-      }
-      return this.baseDecode(text.slice(this.prefix.length));
-    } else {
-      throw Error("Can only multibase decode strings");
-    }
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-};
-var ComposedDecoder = class {
-  decoders;
-  constructor(decoders) {
-    this.decoders = decoders;
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-  decode(input) {
-    const prefix = input[0];
-    const decoder = this.decoders[prefix];
-    if (decoder != null) {
-      return decoder.decode(input);
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+      w[i] = readUint32BE(p, j);
     }
+    for (let i = 16; i < 64; i++) {
+      let u = w[i - 2];
+      let t1 = (u >>> 17 | u << 32 - 17) ^ (u >>> 19 | u << 32 - 19) ^ u >>> 10;
+      u = w[i - 15];
+      let t2 = (u >>> 7 | u << 32 - 7) ^ (u >>> 18 | u << 32 - 18) ^ u >>> 3;
+      w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
+    }
+    for (let i = 0; i < 64; i++) {
+      let t1 = (((e >>> 6 | e << 32 - 6) ^ (e >>> 11 | e << 32 - 11) ^ (e >>> 25 | e << 32 - 25)) + (e & f ^ ~e & g) | 0) + (h + (K[i] + w[i] | 0) | 0) | 0;
+      let t2 = ((a >>> 2 | a << 32 - 2) ^ (a >>> 13 | a << 32 - 13) ^ (a >>> 22 | a << 32 - 22)) + (a & b ^ a & c ^ b & c) | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    v2[0] += a;
+    v2[1] += b;
+    v2[2] += c;
+    v2[3] += d;
+    v2[4] += e;
+    v2[5] += f;
+    v2[6] += g;
+    v2[7] += h;
+    pos += 64;
+    len -= 64;
   }
-};
-function or(left, right) {
-  return new ComposedDecoder({
-    ...left.decoders ?? { [left.prefix]: left },
-    ...right.decoders ?? { [right.prefix]: right }
-  });
-}
-var Codec = class {
-  name;
-  prefix;
-  baseEncode;
-  baseDecode;
-  encoder;
-  decoder;
-  constructor(name, prefix, baseEncode, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
-  }
-  encode(input) {
-    return this.encoder.encode(input);
-  }
-  decode(input) {
-    return this.decoder.decode(input);
-  }
-};
-function from({ name, prefix, encode, decode }) {
-  return new Codec(name, prefix, encode, decode);
-}
-function baseX({ name, prefix, alphabet }) {
-  const { encode, decode } = base_x_default(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode,
-    decode: (text) => coerce(decode(text))
-  });
+  return pos;
 }
 
-// ../../../../node_modules/multiformats/dist/src/bases/base58.js
-var base58btc = baseX({
-  name: "base58btc",
-  prefix: "z",
-  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-});
-var base58flickr = baseX({
-  name: "base58flickr",
-  prefix: "Z",
-  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-});
-
 // ../../crypto/dist/src/utils.js
+var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
 var toHexString = (bytes) => import_libsodium_wrappers.default.to_hex(bytes);
 var toBase64 = (arr) => {
   return import_libsodium_wrappers.default.to_base64(arr, import_libsodium_wrappers.default.base64_variants.ORIGINAL);
@@ -7247,7 +7243,6 @@ var toBase58 = (arr) => {
 };
 
 // ../../crypto/dist/src/hash.browser.js
-var sha256Base64Sync = (bytes) => toBase64(new SHA256().update(bytes).digest());
 var sha256Sync = (bytes) => new SHA256().update(bytes).digest();
 
 // ../../../../node_modules/uint8-varint/dist/src/index.js
@@ -7372,9 +7367,6 @@ function decodeUint8Array(buf, offset) {
   throw new RangeError("Could not decode varint");
 }
 
-// ../../crypto/dist/src/random.browser.js
-var randomBytes = (len) => globalThis.crypto.getRandomValues(new Uint8Array(len));
-
 // ../interface/dist/src/id.js
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -7543,6 +7535,16 @@ var toId = (obj) => {
   throw new Error("Unexpected index key: " + typeof obj + ", expected: string, number, bigint or Uint8Array");
 };
 
+// ../../../../node_modules/uuid/dist/esm-browser/stringify.js
+var byteToHex = [];
+for (i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+var i;
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
 // ../../../../node_modules/uuid/dist/esm-browser/rng.js
 var getRandomValues;
 var rnds8 = new Uint8Array(16);
@@ -7556,15 +7558,6 @@ function rng() {
   return getRandomValues(rnds8);
 }
 
-// ../../../../node_modules/uuid/dist/esm-browser/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
-}
-
 // ../../../../node_modules/uuid/dist/esm-browser/native.js
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 var native_default = {
@@ -7577,12 +7570,12 @@ function v4(options, buf, offset) {
     return native_default.randomUUID();
   }
   options = options || {};
-  const rnds = options.random || (options.rng || rng)();
+  var rnds = options.random || (options.rng || rng)();
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   if (buf) {
     offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
+    for (var i = 0; i < 16; ++i) {
       buf[offset + i] = rnds[i];
     }
     return buf;
@@ -7649,94 +7642,6 @@ Sort = __decorate2([
   variant(0),
   __metadata2("design:paramtypes", [Object])
 ], Sort);
-var AbstractSearchRequest = class {
-};
-var toArray = (arr) => (arr ? Array.isArray(arr) ? arr : [arr] : void 0) || [];
-var SearchRequest = class SearchRequest2 extends AbstractSearchRequest {
-  id;
-  // Session id
-  query;
-  sort;
-  fetch;
-  constructor(props) {
-    super();
-    this.id = randomBytes(32);
-    this.query = props?.query ? toQuery(props.query) : [];
-    this.sort = toArray(props?.sort);
-    this.fetch = props?.fetch ?? 10;
-  }
-  _idString;
-  get idString() {
-    return this._idString || (this._idString = sha256Base64Sync(this.id));
-  }
-};
-__decorate2([
-  field({ type: fixedArray("u8", 32) }),
-  __metadata2("design:type", Uint8Array)
-], SearchRequest.prototype, "id", void 0);
-__decorate2([
-  field({ type: vec(Query) }),
-  __metadata2("design:type", Array)
-], SearchRequest.prototype, "query", void 0);
-__decorate2([
-  field({ type: vec(Sort) }),
-  __metadata2("design:type", Array)
-], SearchRequest.prototype, "sort", void 0);
-__decorate2([
-  field({ type: "u32" }),
-  __metadata2("design:type", Number)
-], SearchRequest.prototype, "fetch", void 0);
-SearchRequest = __decorate2([
-  variant(0),
-  __metadata2("design:paramtypes", [Object])
-], SearchRequest);
-var CollectNextRequest = class CollectNextRequest2 extends AbstractSearchRequest {
-  id;
-  // collect with id
-  amount;
-  // number of documents to ask for
-  constructor(properties) {
-    super();
-    this.id = properties.id;
-    this.amount = properties.amount;
-  }
-  _idString;
-  get idString() {
-    return this._idString || (this._idString = sha256Base64Sync(this.id));
-  }
-};
-__decorate2([
-  field({ type: fixedArray("u8", 32) }),
-  __metadata2("design:type", Uint8Array)
-], CollectNextRequest.prototype, "id", void 0);
-__decorate2([
-  field({ type: "u32" }),
-  __metadata2("design:type", Number)
-], CollectNextRequest.prototype, "amount", void 0);
-CollectNextRequest = __decorate2([
-  variant(2),
-  __metadata2("design:paramtypes", [Object])
-], CollectNextRequest);
-var CloseIteratorRequest = class CloseIteratorRequest2 extends AbstractSearchRequest {
-  id;
-  // collect with id
-  constructor(properties) {
-    super();
-    this.id = properties.id;
-  }
-  _idString;
-  get idString() {
-    return this._idString || (this._idString = sha256Base64Sync(this.id));
-  }
-};
-__decorate2([
-  field({ type: fixedArray("u8", 32) }),
-  __metadata2("design:type", Uint8Array)
-], CloseIteratorRequest.prototype, "id", void 0);
-CloseIteratorRequest = __decorate2([
-  variant(3),
-  __metadata2("design:paramtypes", [Object])
-], CloseIteratorRequest);
 var LogicalQuery = class LogicalQuery2 extends Query {
 };
 LogicalQuery = __decorate2([
@@ -7967,84 +7872,10 @@ Nested = __decorate2([
   variant(2),
   __metadata2("design:paramtypes", [Object])
 ], Nested);
-var AbstractAggregationRequest = class {
-};
-var SumRequest = class SumRequest2 extends AbstractAggregationRequest {
-  id;
-  query;
-  key;
-  constructor(props) {
-    super();
-    this.id = randomBytes(32);
-    this.query = props.query ? toQuery(props.query) : [];
-    this.key = Array.isArray(props.key) ? props.key : [props.key];
-  }
-};
-__decorate2([
-  field({ type: fixedArray("u8", 32) }),
-  __metadata2("design:type", Uint8Array)
-], SumRequest.prototype, "id", void 0);
-__decorate2([
-  field({ type: vec(Query) }),
-  __metadata2("design:type", Array)
-], SumRequest.prototype, "query", void 0);
-__decorate2([
-  field({ type: vec("string") }),
-  __metadata2("design:type", Array)
-], SumRequest.prototype, "key", void 0);
-SumRequest = __decorate2([
-  variant(0),
-  __metadata2("design:paramtypes", [Object])
-], SumRequest);
-var AbstractCountRequest = class {
-};
-var CountRequest = class CountRequest2 extends AbstractCountRequest {
-  id;
-  // Session id
-  query;
-  constructor(props = { query: [] }) {
-    super();
-    this.id = randomBytes(32);
-    this.query = toQuery(props.query);
-  }
-};
-__decorate2([
-  field({ type: fixedArray("u8", 32) }),
-  __metadata2("design:type", Uint8Array)
-], CountRequest.prototype, "id", void 0);
-__decorate2([
-  field({ type: vec(Query) }),
-  __metadata2("design:type", Array)
-], CountRequest.prototype, "query", void 0);
-CountRequest = __decorate2([
-  variant(0),
-  __metadata2("design:paramtypes", [Object])
-], CountRequest);
-var AbstractDeleteRequest = class {
-};
-var DeleteRequest = class DeleteRequest2 extends AbstractDeleteRequest {
-  id;
-  // Session id
-  query;
-  constructor(props) {
-    super();
-    this.id = randomBytes(32);
-    this.query = toQuery(props.query);
-  }
-};
-__decorate2([
-  field({ type: fixedArray("u8", 32) }),
-  __metadata2("design:type", Uint8Array)
-], DeleteRequest.prototype, "id", void 0);
-__decorate2([
-  field({ type: vec(Query) }),
-  __metadata2("design:type", Array)
-], DeleteRequest.prototype, "query", void 0);
-DeleteRequest = __decorate2([
-  variant(0),
-  __metadata2("design:paramtypes", [Object])
-], DeleteRequest);
 var toQuery = (query) => {
+  if (!query) {
+    return [];
+  }
   if (Array.isArray(query)) {
     return query;
   }
@@ -8608,8 +8439,17 @@ var insert = async (insertFn, obj, tables, table, fields, handleNestedCallback,
 var getTablePrefixedField = (table, key, skipPrefix = false) => `${skipPrefix ? "" : table.name + "#"}${getInlineTableFieldName(table.path.slice(1), key)}`;
 var getInlineTableFieldName = (path, key) => {
   if (key) {
-    return path && path.length > 0 ? `${path.join("_")}__${key}` : key;
+    if (Array.isArray(path)) {
+      return path && path.length > 0 ? `${path.join("_")}__${key}` : key;
+    }
+    return path + "__" + key;
   } else {
+    if (!Array.isArray(path)) {
+      if (!path) {
+        throw new Error("Unexpected missing path");
+      }
+      return path;
+    }
     return path.length > 2 ? `${path.slice(0, -1).join("_")}__${path[path.length - 1]}` : path.join("__");
   }
 };
@@ -8630,7 +8470,11 @@ var matchFieldInShape = (shape, path, field2) => {
       if (nextShape === true) {
         return true;
       }
-      currentShape = nextShape;
+      if (Array.isArray(nextShape)) {
+        currentShape = nextShape[0];
+      } else {
+        currentShape = nextShape;
+      }
     }
   }
   throw new Error("Unexpected");
@@ -8690,7 +8534,7 @@ var selectAllFieldsFromTable = (table, shape) => {
         if (!maybeShape) {
           continue;
         }
-        childShape = maybeShape === true ? void 0 : maybeShape;
+        childShape = maybeShape === true ? void 0 : Array.isArray(maybeShape) ? maybeShape[0] : maybeShape;
       }
       stack.push({ table: child, shape: childShape });
       if (!child.inline) {
@@ -8723,7 +8567,11 @@ var resolveInstanceFromValue = async (fromTablePrefixedValues, tables, table, re
   const handleNested = async (field2, isOptional, isArray) => {
     const subTables = getTableFromField(table, tables, field2);
     let maybeShape = shape?.[field2.key];
-    let subshape = maybeShape === true ? void 0 : maybeShape;
+    const subshapeIsArray = Array.isArray(maybeShape);
+    if (isArray && maybeShape && !subshapeIsArray && maybeShape !== true) {
+      throw new Error("Shape is not matching the array field type: " + field2.key + ". Shape: " + JSON.stringify(shape));
+    }
+    let subshape = maybeShape === true ? void 0 : subshapeIsArray ? maybeShape[0] : maybeShape;
     if (isArray) {
       let once = false;
       let resolvedArr = [];
@@ -8808,13 +8656,25 @@ var resolveInstanceFromValue = async (fromTablePrefixedValues, tables, table, re
   return Object.assign(Object.create(table.ctor.prototype), obj);
 };
 var convertDeleteRequestToQuery = (request, tables, table) => {
-  return `DELETE FROM ${table.name} WHERE ${table.primary} IN (SELECT ${table.primary} from ${table.name} ${convertRequestToQuery(request, tables, table).query}) returning ${table.primary}`;
+  const { query, bindable } = convertRequestToQuery("delete", request, tables, table);
+  return {
+    sql: `DELETE FROM ${table.name} WHERE ${table.primary} IN (SELECT ${table.primary} from ${table.name} ${query}) returning ${table.primary}`,
+    bindable
+  };
 };
 var convertSumRequestToQuery = (request, tables, table) => {
-  return `SELECT SUM(${table.name}.${getInlineTableFieldName(request.key)}) as sum FROM ${table.name} ${convertRequestToQuery(request, tables, table).query}`;
+  const { query, bindable } = convertRequestToQuery("sum", request, tables, table);
+  return {
+    sql: `SELECT SUM(${table.name}.${getInlineTableFieldName(request.key)}) as sum FROM ${table.name} ${query}`,
+    bindable
+  };
 };
 var convertCountRequestToQuery = (request, tables, table) => {
-  return `SELECT count(*) as count FROM ${table.name} ${convertRequestToQuery(request, tables, table).query}`;
+  const { query, bindable } = convertRequestToQuery("count", request, tables, table);
+  return {
+    sql: `SELECT count(*) as count FROM ${table.name} ${query}`,
+    bindable
+  };
 };
 var convertSearchRequestToQuery = (request, tables, rootTables, shape) => {
   let unionBuilder = "";
@@ -8822,14 +8682,16 @@ var convertSearchRequestToQuery = (request, tables, rootTables, shape) => {
   let matchedOnce = false;
   let lastError = void 0;
   const selectsPerTable = selectAllFieldsFromTables(rootTables, shape);
+  let bindableBuilder = [];
   for (const [i, table] of rootTables.entries()) {
     const { selects, joins: joinFromSelect } = selectsPerTable[i];
     const selectQuery = generateSelectQuery(table, selects);
     try {
-      const { orderBy, query } = convertRequestToQuery(request, tables, table, joinFromSelect);
+      const { orderBy, query, bindable } = convertRequestToQuery("iterate", request, tables, table, joinFromSelect);
       unionBuilder += `${unionBuilder.length > 0 ? " UNION ALL " : ""} ${selectQuery} ${query}`;
       orderByClause = orderBy?.length > 0 ? orderByClause.length > 0 ? orderByClause + ", " + orderBy : orderBy : orderByClause;
       matchedOnce = true;
+      bindableBuilder.push(...bindable);
     } catch (error2) {
       if (error2 instanceof MissingFieldError) {
         lastError = error2;
@@ -8841,31 +8703,44 @@ var convertSearchRequestToQuery = (request, tables, rootTables, shape) => {
   if (!matchedOnce) {
     throw lastError;
   }
-  return `${unionBuilder} ${orderByClause ? "ORDER BY " + orderByClause : ""} limit ? offset ?`;
+  return {
+    sql: `${unionBuilder} ${orderByClause ? "ORDER BY " + orderByClause : ""} limit ? offset ?`,
+    bindable: bindableBuilder
+  };
 };
-var convertRequestToQuery = (request, tables, table, extraJoin, path = []) => {
+function isIterateRequest(request, type) {
+  return type === "iterate";
+}
+var convertRequestToQuery = (type, request, tables, table, extraJoin, path = []) => {
   let whereBuilder = "";
+  let bindableBuilder = [];
   let orderByBuilder = void 0;
   let joinBuilder = extraJoin || /* @__PURE__ */ new Map();
-  if (request.query.length === 1) {
-    const { where: where2 } = convertQueryToSQLQuery(request.query[0], tables, table, joinBuilder, path);
+  const coercedQuery = toQuery(request?.query);
+  if (coercedQuery.length === 1) {
+    const { where: where2, bindable } = convertQueryToSQLQuery(coercedQuery[0], tables, table, joinBuilder, path);
     whereBuilder += where2;
-  } else if (request.query.length > 1) {
-    const { where: where2 } = convertQueryToSQLQuery(new And(request.query), tables, table, joinBuilder, path);
+    bindableBuilder.push(...bindable);
+  } else if (coercedQuery.length > 1) {
+    const { where: where2, bindable } = convertQueryToSQLQuery(new And(coercedQuery), tables, table, joinBuilder, path);
     whereBuilder += where2;
-  }
-  if (request instanceof SearchRequest) {
-    if (request.sort.length > 0) {
-      orderByBuilder = "";
-      let once = false;
-      for (const sort of request.sort) {
-        const { foreignTables, queryKey } = resolveTableToQuery(table, tables, joinBuilder, [...path, ...sort.key], void 0, true);
-        for (const table2 of foreignTables) {
-          if (once) {
-            orderByBuilder += ", ";
+    bindableBuilder.push(...bindable);
+  }
+  if (isIterateRequest(request, type)) {
+    if (request?.sort) {
+      let sortArr = Array.isArray(request.sort) ? request.sort : [request.sort];
+      if (sortArr.length > 0) {
+        orderByBuilder = "";
+        let once = false;
+        for (const sort of sortArr) {
+          const { foreignTables, queryKey } = resolveTableToQuery(table, tables, joinBuilder, [...path, ...sort.key], void 0, true);
+          for (const table2 of foreignTables) {
+            if (once) {
+              orderByBuilder += ", ";
+            }
+            once = true;
+            orderByBuilder += `${table2.as}.${queryKey} ${sort.direction === SortDirection.ASC ? "ASC" : "DESC"}`;
           }
-          once = true;
-          orderByBuilder += `${table2.as}.${queryKey} ${sort.direction === SortDirection.ASC ? "ASC" : "DESC"}`;
         }
       }
     }
@@ -8874,11 +8749,12 @@ var convertRequestToQuery = (request, tables, table, extraJoin, path = []) => {
   if (extraJoin && extraJoin.size > 0) {
     insertMapIntoMap(joinBuilder, extraJoin);
   }
-  let join = buildJoin(joinBuilder, request instanceof SearchRequest ? true : false);
+  let join = buildJoin(joinBuilder, type === "iterate" ? true : false);
   const query = `${join ? join : ""} ${where ? where : ""}`;
   return {
     query,
-    orderBy: orderByBuilder
+    orderBy: orderByBuilder,
+    bindable: bindableBuilder
   };
 };
 var buildJoin = (joinBuilder, resolveAllColumns) => {
@@ -8907,15 +8783,18 @@ var insertMapIntoMap = (map, insert2) => {
 };
 var convertQueryToSQLQuery = (query, tables, table, joinBuilder, path = [], tableAlias = void 0) => {
   let whereBuilder = "";
+  let bindableBuilder = [];
   const handleAnd = (queries, path2, tableAlias2) => {
     for (const query2 of queries) {
-      const { where } = convertQueryToSQLQuery(query2, tables, table, joinBuilder, path2, tableAlias2);
+      const { where, bindable } = convertQueryToSQLQuery(query2, tables, table, joinBuilder, path2, tableAlias2);
       whereBuilder = whereBuilder.length > 0 ? `(${whereBuilder}) AND (${where})` : where;
+      bindableBuilder.push(...bindable);
     }
   };
   if (query instanceof StateFieldQuery) {
-    const { where } = convertStateFieldQuery(query, tables, table, joinBuilder, path, tableAlias);
+    const { where, bindable } = convertStateFieldQuery(query, tables, table, joinBuilder, path, tableAlias);
     whereBuilder += where;
+    bindableBuilder.push(...bindable);
   } else if (query instanceof Nested) {
     let joinPrefix = "__" + String(tables.size);
     path = [...path, query.path];
@@ -8925,12 +8804,14 @@ var convertQueryToSQLQuery = (query, tables, table, joinBuilder, path = [], tabl
       handleAnd(query.and, path, tableAlias);
     } else if (query instanceof Or) {
       for (const subquery of query.or) {
-        const { where } = convertQueryToSQLQuery(subquery, tables, table, joinBuilder, path, tableAlias);
+        const { where, bindable } = convertQueryToSQLQuery(subquery, tables, table, joinBuilder, path, tableAlias);
         whereBuilder = whereBuilder.length > 0 ? `(${whereBuilder}) OR (${where})` : where;
+        bindableBuilder.push(...bindable);
       }
     } else if (query instanceof Not) {
-      const { where } = convertQueryToSQLQuery(query.not, tables, table, joinBuilder, path, tableAlias);
+      const { where, bindable } = convertQueryToSQLQuery(query.not, tables, table, joinBuilder, path, tableAlias);
       whereBuilder = `NOT (${where})`;
+      bindableBuilder.push(...bindable);
     } else {
       throw new Error("Unsupported query type: " + query.constructor.name);
     }
@@ -8938,7 +8819,8 @@ var convertQueryToSQLQuery = (query, tables, table, joinBuilder, path = [], tabl
     throw new Error("Unsupported query type: " + query.constructor.name);
   }
   return {
-    where: whereBuilder
+    where: whereBuilder,
+    bindable: bindableBuilder
   };
 };
 var cloneQuery = (query) => {
@@ -9026,70 +8908,85 @@ var convertStateFieldQuery = (query, tables, table, join, path, tableAlias = voi
     query = cloneQuery(query);
     query.key = [queryKey];
     let whereBuilder = [];
+    let bindableBuilder = [];
     for (const ftable of foreignTables) {
       if (ftable.table === table) {
         throw new Error("Unexpected");
       }
-      const { where: where2 } = convertQueryToSQLQuery(query, tables, ftable.table, join, path, ftable.as);
+      const { where: where2, bindable: bindable2 } = convertQueryToSQLQuery(query, tables, ftable.table, join, path, ftable.as);
       whereBuilder.push(where2);
+      bindableBuilder.push(bindable2);
     }
-    return { where: whereBuilder.join(" OR ") };
+    return {
+      where: whereBuilder.join(" OR "),
+      bindable: bindableBuilder.flat()
+    };
   }
+  let bindable = [];
   const keyWithTable = (tableAlias || table.name) + "." + escapeColumnName(inlinedName);
   let where;
   if (query instanceof StringMatch) {
     let statement = "";
     if (query.method === StringMatchMethod.contains) {
-      statement = `${keyWithTable} LIKE '%${query.value}%'`;
+      statement = `${keyWithTable} LIKE ?`;
+      bindable.push(`%${query.value}%`);
     } else if (query.method === StringMatchMethod.prefix) {
-      statement = `${keyWithTable} LIKE '${query.value}%'`;
+      statement = `${keyWithTable} LIKE ?`;
+      bindable.push(`${query.value}%`);
     } else if (query.method === StringMatchMethod.exact) {
-      statement = `${keyWithTable} = '${query.value}'`;
+      statement = `${keyWithTable} = ?`;
+      bindable.push(`${query.value}`);
     }
     if (query.caseInsensitive) {
       statement += " COLLATE NOCASE";
     }
     where = statement;
   } else if (query instanceof ByteMatchQuery) {
-    const statement = `${keyWithTable} = x'${toHexString(query.value)}'`;
+    const statement = `${keyWithTable} = ?`;
+    bindable.push(query.value);
     where = statement;
   } else if (query instanceof IntegerCompare) {
     if (tableField.type === "BLOB") {
-      where = `hex(${keyWithTable}) LIKE '%${toHexString(new Uint8Array([Number(query.value.value)]))}%'`;
-    } else if (query.compare === Compare.Equal) {
-      where = `${keyWithTable} = ${query.value.value}`;
-    } else if (query.compare === Compare.Greater) {
-      where = `${keyWithTable} > ${query.value.value}`;
-    } else if (query.compare === Compare.Less) {
-      where = `${keyWithTable} < ${query.value.value}`;
-    } else if (query.compare === Compare.GreaterOrEqual) {
-      where = `${keyWithTable} >= ${query.value.value}`;
-    } else if (query.compare === Compare.LessOrEqual) {
-      where = `${keyWithTable} <= ${query.value.value}`;
+      where = `hex(${keyWithTable}) LIKE ?`;
+      bindable.push(`%${toHexString(new Uint8Array([Number(query.value.value)]))}%`);
     } else {
-      throw new Error(`Unsupported compare type: ${query.compare}`);
+      if (query.compare === Compare.Equal) {
+        where = `${keyWithTable} = ?`;
+      } else if (query.compare === Compare.Greater) {
+        where = `${keyWithTable} > ?`;
+      } else if (query.compare === Compare.Less) {
+        where = `${keyWithTable} < ?`;
+      } else if (query.compare === Compare.GreaterOrEqual) {
+        where = `${keyWithTable} >= ?`;
+      } else if (query.compare === Compare.LessOrEqual) {
+        where = `${keyWithTable} <= ?`;
+      } else {
+        throw new Error(`Unsupported compare type: ${query.compare}`);
+      }
+      bindable.push(query.value.value);
     }
   } else if (query instanceof IsNull) {
     where = `${keyWithTable} IS NULL`;
   } else if (query instanceof BoolQuery) {
-    where = `${keyWithTable} = ${query.value}`;
+    where = `${keyWithTable} = ?`;
+    bindable.push(query.value ? 1 : 0);
   } else {
     throw new Error("Unsupported query type: " + query.constructor.name);
   }
-  return { where };
+  return { where, bindable };
 };
 
 // dist/src/engine.js
 var escapePathToSQLName = (path) => {
   return path.map((x) => x.replace(/[^a-zA-Z0-9]/g, "_"));
 };
+var putStatementKey = (table) => table.name + "_put";
+var replaceStatementKey = (table) => table.name + "_replicate";
+var resolveChildrenStatement = (table) => table.name + "_resolve_children";
 var SQLLiteIndex = class {
   properties;
   primaryKeyArr;
   primaryKeyString;
-  putStatement;
-  replaceStatement;
-  resolveChildrenStatement;
   scopeString;
   _rootTables;
   _tables;
@@ -9147,9 +9044,6 @@ var SQLLiteIndex = class {
       throw new Error("Not initialized");
     }
     await this.properties.start?.();
-    this.putStatement = /* @__PURE__ */ new Map();
-    this.replaceStatement = /* @__PURE__ */ new Map();
-    this.resolveChildrenStatement = /* @__PURE__ */ new Map();
     this._tables = /* @__PURE__ */ new Map();
     this._cursor = /* @__PURE__ */ new Map();
     const tables = getSQLTable(
@@ -9177,10 +9071,10 @@ var SQLLiteIndex = class {
       this.properties.db.exec(sqlCreateIndex);
       let sqlPut = `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
       let sqlReplace = `insert or replace into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-      this.putStatement.set(table.name, await this.properties.db.prepare(sqlPut));
-      this.replaceStatement.set(table.name, await this.properties.db.prepare(sqlReplace));
+      await this.properties.db.prepare(sqlPut, putStatementKey(table));
+      await this.properties.db.prepare(sqlReplace, replaceStatementKey(table));
       if (table.parent) {
-        this.resolveChildrenStatement.set(table.name, await this.properties.db.prepare(selectChildren(table)));
+        await this.properties.db.prepare(selectChildren(table), resolveChildrenStatement(table));
       }
     }
     this.closed = false;
@@ -9189,18 +9083,6 @@ var SQLLiteIndex = class {
     if (await this.properties.db.status() === "closed") {
       return;
     }
-    for (const [_k, v2] of this.putStatement) {
-      await v2.finalize?.();
-    }
-    for (const [_k, v2] of this.replaceStatement) {
-      await v2.finalize?.();
-    }
-    for (const [_k, v2] of this.resolveChildrenStatement) {
-      await v2.finalize?.();
-    }
-    this.putStatement.clear();
-    this.replaceStatement.clear();
-    this.resolveChildrenStatement.clear();
   }
   async stop() {
     if (this.closed) {
@@ -9225,7 +9107,7 @@ var SQLLiteIndex = class {
     }
   }
   async resolveDependencies(parentId, table) {
-    const stmt = this.resolveChildrenStatement.get(table.name);
+    const stmt = this.properties.db.statements.get(resolveChildrenStatement(table));
     const results = await stmt.all([parentId]);
     await stmt.reset?.();
     return results;
@@ -9234,9 +9116,8 @@ var SQLLiteIndex = class {
     for (const table of this._rootTables) {
       const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
       const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap, true)} where ${this.primaryKeyString} = ? `;
-      const stmt = await this.properties.db.prepare(sql);
+      const stmt = await this.properties.db.prepare(sql, sql);
       const rows = await stmt.get([id.key]);
-      await stmt.finalize?.();
       if (!rows) {
         continue;
       }
@@ -9252,34 +9133,42 @@ var SQLLiteIndex = class {
     return insert(async (values, table) => {
       const preId = values[table.primaryIndex];
       if (preId != null) {
-        const statement = this.replaceStatement.get(table.name);
+        const statement = this.properties.db.statements.get(replaceStatementKey(table));
         await statement.run(values.map((x) => typeof x === "boolean" ? x ? 1 : 0 : x));
         await statement.reset?.();
         return preId;
       } else {
-        const statement = this.putStatement.get(table.name);
+        const statement = this.properties.db.statements.get(putStatementKey(table));
         const out = await statement.get(values.map((x) => typeof x === "boolean" ? x ? 1 : 0 : x));
         await statement.reset?.();
+        if (out == null) {
+          return void 0;
+        }
         return out[table.primary];
       }
     }, value, this.tables, resolveTable(this.scopeString ? [this.scopeString] : [], this.tables, classOfValue, true), getSchema(classOfValue).fields, (_fn) => {
       throw new Error("Unexpected");
     });
   }
-  async query(request, options) {
-    let sqlFetch = convertSearchRequestToQuery(request, this.tables, this._rootTables, options?.shape);
-    const stmt = await this.properties.db.prepare(sqlFetch);
+  iterate(request, options) {
+    let { sql: sqlFetch, bindable } = convertSearchRequestToQuery(request, this.tables, this._rootTables, options?.shape);
     let offset = 0;
-    let first = false;
+    let once = false;
+    let requestId = v4_default();
+    let hasMore = true;
+    let stmt;
+    let kept = void 0;
     const fetch2 = async (amount) => {
-      if (!first) {
-        stmt.reset?.();
+      kept = void 0;
+      if (!once) {
+        stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
         clearTimeout(iterator.timeout);
-        iterator.timeout = setTimeout(() => this.clearupIterator(request.idString), this.iteratorTimeout);
+        iterator.timeout = setTimeout(() => this.clearupIterator(requestId), this.iteratorTimeout);
       }
-      first = true;
+      once = true;
       const offsetStart = offset;
       const allResults = await stmt.all([
+        ...bindable,
         amount,
         offsetStart
       ]);
@@ -9291,38 +9180,53 @@ var SQLLiteIndex = class {
           id: toId(row[getTablePrefixedField(selectedTable, this.primaryKeyString)])
         };
       }));
-      offset += amount;
-      if (results.length > 0) {
-        const totalCount = await this.count(new CountRequest({ query: request.query }));
-        iterator.kept = totalCount - results.length - offsetStart;
-      } else {
-        iterator.kept = 0;
-      }
-      if (iterator.kept === 0) {
-        await this.clearupIterator(request.idString);
+      offset += results.length;
+      if (results.length < amount) {
+        hasMore = false;
+        await this.clearupIterator(requestId);
         clearTimeout(iterator.timeout);
       }
-      return { results, kept: iterator.kept };
+      return results;
     };
     const iterator = {
-      kept: 0,
       fetch: fetch2,
-      fetchStatement: stmt,
       /* countStatement: countStmt, */
-      timeout: setTimeout(() => this.clearupIterator(request.idString), this.iteratorTimeout)
+      timeout: setTimeout(() => this.clearupIterator(requestId), this.iteratorTimeout)
+    };
+    this.cursor.set(requestId, iterator);
+    let totalCount = void 0;
+    return {
+      all: async () => {
+        const results = [];
+        while (true) {
+          const res = await fetch2(100);
+          results.push(...res);
+          if (res.length === 0) {
+            break;
+          }
+        }
+        return results;
+      },
+      close: () => {
+        hasMore = false;
+        kept = 0;
+        this.clearupIterator(requestId);
+      },
+      next: (amount) => fetch2(amount),
+      pending: async () => {
+        if (!hasMore) {
+          return 0;
+        }
+        if (kept != null) {
+          return kept;
+        }
+        totalCount = totalCount ?? await this.count(request);
+        kept = totalCount - offset;
+        hasMore = kept > 0;
+        return kept;
+      },
+      done: () => once ? !hasMore : void 0
     };
-    this.cursor.set(request.idString, iterator);
-    return fetch2(request.fetch);
-  }
-  next(query) {
-    const cache = this.cursor.get(query.idString);
-    if (!cache) {
-      throw new Error("No cursor found with id: " + query.idString);
-    }
-    return cache.fetch(query.amount);
-  }
-  close(query) {
-    return this.clearupIterator(query.idString);
   }
   async clearupIterator(id) {
     const cache = this._cursor.get(id);
@@ -9330,14 +9234,13 @@ var SQLLiteIndex = class {
       return;
     }
     clearTimeout(cache.timeout);
-    await cache.fetchStatement.finalize?.();
     this._cursor.delete(id);
   }
   async getSize() {
     if (this.tables.size === 0) {
       return 0;
     }
-    return this.count(new CountRequest({ query: {} }));
+    return this.count();
   }
   async del(query) {
     let ret = [];
@@ -9345,9 +9248,9 @@ var SQLLiteIndex = class {
     let lastError = void 0;
     for (const table of this._rootTables) {
       try {
-        const stmt = await this.properties.db.prepare(convertDeleteRequestToQuery(query, this.tables, table));
-        const results = await stmt.all([]);
-        await stmt.finalize?.();
+        const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table);
+        const stmt = await this.properties.db.prepare(sql, sql);
+        const results = await stmt.all(bindable);
         for (const result of results) {
           ret.push(toId(result[table.primary]));
         }
@@ -9373,18 +9276,20 @@ var SQLLiteIndex = class {
     for (const table of this._rootTables) {
       try {
         if (table.fields.find((x) => x.name === inlinedName) == null) {
-          lastError = new MissingFieldError("Missing field: " + query.key.join("."));
+          lastError = new MissingFieldError("Missing field: " + (Array.isArray(query.key) ? query.key : [query.key]).join("."));
           continue;
         }
-        const stmt = await this.properties.db.prepare(convertSumRequestToQuery(query, this.tables, table));
-        const result = await stmt.get();
-        await stmt.finalize?.();
-        if (ret == null) {
-          ret = result.sum;
-        } else {
-          ret += result.sum;
+        const { sql, bindable } = convertSumRequestToQuery(query, this.tables, table);
+        const stmt = await this.properties.db.prepare(sql, sql);
+        const result = await stmt.get(bindable);
+        if (result != null) {
+          if (ret == null) {
+            ret = result.sum;
+          } else {
+            ret += result.sum;
+          }
+          once = true;
         }
-        once = true;
       } catch (error2) {
         if (error2 instanceof MissingFieldError) {
           lastError = error2;
@@ -9404,11 +9309,13 @@ var SQLLiteIndex = class {
     let lastError = void 0;
     for (const table of this._rootTables) {
       try {
-        const stmt = await this.properties.db.prepare(convertCountRequestToQuery(request, this.tables, table));
-        const result = await stmt.get();
-        await stmt.finalize?.();
-        ret += Number(result.count);
-        once = true;
+        const { sql, bindable } = convertCountRequestToQuery(request, this.tables, table);
+        const stmt = await this.properties.db.prepare(sql, sql);
+        const result = await stmt.get(bindable);
+        if (result != null) {
+          ret += Number(result.count);
+          once = true;
+        }
       } catch (error2) {
         if (error2 instanceof MissingFieldError) {
           lastError = error2;
@@ -9422,13 +9329,6 @@ var SQLLiteIndex = class {
     }
     return ret;
   }
-  getPending(cursorId) {
-    const cursor = this.cursor.get(cursorId);
-    if (!cursor) {
-      return;
-    }
-    return cursor.kept;
-  }
   get cursorCount() {
     return this.cursor.size;
   }
@@ -21522,12 +21422,13 @@ var Statement = class {
     return this;
   }
   async finalize() {
-    if (await this.statement.finalize() > 0) {
+    const out = await this.statement.finalize();
+    if (out != null && out > 0) {
       throw new Error("Error finalizing statement");
     }
   }
   get(values) {
-    if (values) {
+    if (values && values?.length > 0) {
       this.statement.bind(values);
     }
     let step = this.statement.step();
@@ -21601,10 +21502,15 @@ var create = async (directory) => {
       return sqliteDb.exec(sql);
     },
     open,
-    prepare: (sql, id) => {
+    prepare: async (sql, id) => {
       if (id == null) {
         id = v4_default();
       }
+      let prev = statements.get(id);
+      if (prev) {
+        await prev.reset();
+        return prev;
+      }
       const statement = sqliteDb.prepare(sql);
       const wrappedStatement = new Statement(statement, id);
       statements.set(id, wrappedStatement);
@@ -21716,7 +21622,14 @@ var ProxyDatabase = class {
       databaseId: this.databaseId
     });
   }
-  async prepare(sql) {
+  async prepare(sql, id) {
+    if (id != null) {
+      const prev = this.statements.get(id);
+      if (prev) {
+        await prev.reset();
+        return prev;
+      }
+    }
     const statementId = await this.send({
       type: "prepare",
       sql,
@@ -21725,6 +21638,9 @@ var ProxyDatabase = class {
     });
     const statement = new ProxyStatement(this.send, this.databaseId, statementId);
     this.statements.set(statementId, statement);
+    if (id != null) {
+      this.statements.set(id, statement);
+    }
     return statement;
   }
   async open() {