@peerbit/indexer-sqlite3 3.0.5 → 3.0.7

package/dist/index.min.js

@@ -18431,275 +18431,6 @@ var resize = (arr, newSize, defaultValue) => {
   arr.length = newSize;
 };
 
-// ../../../../node_modules/.pnpm/multiformats@13.4.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/.pnpm/multiformats@13.4.1/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/.pnpm/multiformats@13.4.1/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/.pnpm/multiformats@13.4.1/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/.pnpm/@stablelib+int@2.0.1/node_modules/@stablelib/int/lib/int.js
 var isInteger = Number.isInteger;
 var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
@@ -19001,7 +18732,278 @@ function hashBlocks(w, v2, p, pos, len) {
 }
 
 // ../../crypto/dist/src/utils.js
-var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
+var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
+
+// ../../../../node_modules/.pnpm/multiformats@13.4.2/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/.pnpm/multiformats@13.4.2/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/.pnpm/multiformats@13.4.2/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/.pnpm/multiformats@13.4.2/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 fromHexString = (hexString) => import_libsodium_wrappers.default.from_hex(hexString);
 var asU8 = (bytes) => {
   return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
@@ -21217,15 +21219,15 @@ var resolveInstanceFromValue = async (fromTablePrefixedValues, tables, table, re
   }
   return Object.assign(Object.create(table.ctor.prototype), obj);
 };
-var convertDeleteRequestToQuery = (request, tables, table) => {
-  const { query, bindable } = convertRequestToQuery("delete", { query: coerceLocalQueries(request.query) }, tables, table);
+var convertDeleteRequestToQuery = (request, tables, table, options) => {
+  const { query, bindable } = convertRequestToQuery("delete", { query: coerceLocalQueries(request.query) }, tables, table, void 0, [], options);
   return {
     sql: `DELETE FROM ${table.name} WHERE ${table.name}.${table.primary} IN (SELECT ${table.primary} from ${table.name} ${query}) returning ${table.primary}`,
     bindable
   };
 };
-var convertSumRequestToQuery = (request, tables, table) => {
-  const { query, bindable } = convertRequestToQuery("sum", { query: coerceLocalQueries(request.query), key: request.key }, tables, table);
+var convertSumRequestToQuery = (request, tables, table, options) => {
+  const { query, bindable } = convertRequestToQuery("sum", { query: coerceLocalQueries(request.query), key: request.key }, tables, table, void 0, [], options);
   const inlineName = getInlineTableFieldName(request.key);
   const field2 = table.fields.find((x) => x.name === inlineName);
   if (unwrapNestedType(field2.from.type) === "u64") {
@@ -21402,7 +21404,12 @@ var _buildJoin = (table, options) => {
   if (table.columns.length > 0) {
     const usedColumns = removeDuplicatesOrdered(table.columns);
     const usesImplicitPrimaryKeyIndex = table.type === "root" && table.table.primary !== false && usedColumns.length === 1 && usedColumns[0] === table.table.primary;
-    indexedBy = options?.planner && !usesImplicitPrimaryKeyIndex ? ` INDEXED BY ${options.planner.resolveIndex(table.table.name, usedColumns)} ` : "";
+    if (options?.planner && !usesImplicitPrimaryKeyIndex) {
+      const indexKey = options.planner.resolveIndex(table.table.name, usedColumns);
+      indexedBy = options.planner.forceIndex ? ` INDEXED BY ${indexKey} ` : "";
+    } else {
+      indexedBy = "";
+    }
   }
   if (table.type !== "root") {
     let nonInlinedParent = table.table.parent && getNonInlinedTable(table.table.parent);
@@ -21690,10 +21697,14 @@ var __runInitializers4 = function(thisArg, initializers, value) {
   }
   return useValue ? value : void 0;
 };
-var getSortedNameKey = (tableName, names) => [tableName, ...names.sort()].join(",");
-var createIndexKey = (tableName, fields) => `${tableName}_index_${fields.map((x) => x).join("_")}`;
+var getSortedNameKey = (tableName, names) => [tableName, ...[...names].sort()].join(",");
+var getIndexColumnKey = (field2) => `${field2.name}${field2.collation ? `_collate_${field2.collation.toLowerCase()}` : ""}`;
+var createIndexKey = (tableName, fields) => `${tableName}_index_${fields.map((x) => getIndexColumnKey(x).replace(/[^a-zA-Z0-9_]/g, "_")).join("_")}`;
+var createIndexColumnSQL = (field2) => `${escapeColumnName(field2.name)}${field2.collation ? ` COLLATE ${field2.collation}` : ""}`;
 var HALF_MAX_U32 = 2147483647;
 var HALF_MAX_U64 = 9223372036854775807n;
+var PARENT_TABLE_ID2 = "__parent_id";
+var AMBIGUOUS_CHILD_FORCE_AFTER_USES = 6e3;
 var flattenQuery = function* (props) {
   if (!props) {
     return yield props;
@@ -21848,21 +21859,40 @@ var QueryPlanner = class {
     let indexCreateCommands = void 0;
     let pickedIndexKeys = /* @__PURE__ */ new Map();
     let indexCreationPromiseToAwait = [];
+    let forceIndex = this.props.forceIndexes !== false;
     return {
+      get forceIndex() {
+        return forceIndex;
+      },
       beforePrepare: async () => {
         if (indexCreateCommands != null) {
-          for (const { key, cmd, deferred } of indexCreateCommands) {
+          const commandsToCreate = [];
+          for (const command of indexCreateCommands) {
+            if (this.pendingIndexCreation.has(command.key)) {
+              await this.pendingIndexCreation.get(command.key);
+              continue;
+            }
+            commandsToCreate.push(command);
+          }
+          if (commandsToCreate.length > 0) {
+            const creationPromise = Promise.resolve(this.props.exec([
+              ...commandsToCreate.map((command) => command.cmd),
+              ...this.props.optimizeAfterCreate === false ? [] : ["PRAGMA optimize"]
+            ].join(";")));
+            for (const { key } of commandsToCreate) {
+              this.pendingIndexCreation.set(key, creationPromise);
+            }
             try {
-              if (this.pendingIndexCreation.has(key)) {
-                await this.pendingIndexCreation.get(key);
+              await creationPromise;
+              for (const { key, deferred } of commandsToCreate) {
+                this.pendingIndexCreation.delete(key);
+                deferred.resolve();
               }
-              const promise = this.props.exec(cmd);
-              this.pendingIndexCreation.set(key, promise);
-              await promise;
-              this.pendingIndexCreation.delete(key);
-              deferred.resolve();
             } catch (error2) {
-              deferred.reject(error2);
+              for (const { key, deferred } of commandsToCreate) {
+                this.pendingIndexCreation.delete(key);
+                deferred.reject(error2);
+              }
             }
           }
         }
@@ -21874,6 +21904,7 @@ var QueryPlanner = class {
         await Promise.all(indexCreationPromiseToAwait);
       },
       resolveIndex: (tableName, columns) => {
+        forceIndex = this.props.forceIndexes !== false;
         const sortedNameKey = getSortedNameKey(tableName, columns);
         let indexStats = obj.columnsToIndexes.get(sortedNameKey);
         if (indexStats === void 0) {
@@ -21883,10 +21914,10 @@ var QueryPlanner = class {
           obj.columnsToIndexes.set(sortedNameKey, indexStats);
         }
         if (indexStats.results.length === 0) {
-          const permutations = generatePermutations(columns);
-          for (const columns2 of permutations) {
+          const candidates = generateIndexCandidates(query, columns);
+          for (const columns2 of candidates) {
             const indexKey = createIndexKey(tableName, columns2);
-            const command = `create index if not exists ${indexKey} on ${tableName} (${columns2.map((n) => escapeColumnName(n)).join(", ")})`;
+            const command = `create index if not exists ${indexKey} on ${tableName} (${columns2.map((n) => createIndexColumnSQL(n)).join(", ")})`;
             let deferred = pDefer();
             (indexCreateCommands || (indexCreateCommands = [])).push({
               cmd: command,
@@ -21903,11 +21934,17 @@ var QueryPlanner = class {
               avg: -1,
               // setting -1 will force the first time to be the fastest (i.e. new indices are always tested once)
               indexKey,
+              columns: columns2,
               created: () => created,
               creationPromiseDeferred: deferred
             });
           }
         }
+        const isAmbiguousChildPredicate = query.sort.length === 0 && columns.includes(PARENT_TABLE_ID2) && columns.length > 1;
+        if (isAmbiguousChildPredicate) {
+          const totalUses = indexStats.results.reduce((sum, result) => sum + result.used, 0);
+          forceIndex = this.props.forceIndexes !== false && totalUses >= AMBIGUOUS_CHILD_FORCE_AFTER_USES;
+        }
         let fastestIndex = indexStats.results[0];
         fastestIndex.used++;
         if (!fastestIndex.created()) {
@@ -21942,10 +21979,132 @@ var QueryPlanner = class {
     };
   }
 };
-var generatePermutations = (list) => {
-  if (list.length === 1)
-    return [list];
-  return [list, [...list].reverse()];
+var queryKeyToColumnName = (key) => {
+  if (key.length > 2) {
+    return `${key.slice(0, -1).join("_")}__${key[key.length - 1]}`;
+  }
+  return key.join("__");
+};
+var pushUniqueColumn = (list, column) => {
+  const key = getIndexColumnKey(column);
+  if (!list.some((x) => getIndexColumnKey(x) === key)) {
+    list.push(column);
+  }
+};
+var pushColumns = (target, columns) => {
+  for (const column of columns) {
+    pushUniqueColumn(target, column);
+  }
+};
+var getIndexableQueryColumns = (query, availableColumns) => {
+  const equality = [];
+  const range = [];
+  const visit = (item, path = []) => {
+    if (item instanceof And) {
+      for (const condition of item.and) {
+        visit(condition, path);
+      }
+      return;
+    }
+    if (item instanceof Or) {
+      for (const condition of item.or) {
+        visit(condition, path);
+      }
+      return;
+    }
+    if (item instanceof Not) {
+      return;
+    }
+    if (item instanceof Nested) {
+      for (const condition of item.query) {
+        visit(condition, [...path, ...item.path]);
+      }
+      return;
+    }
+    let key;
+    let target;
+    let collation;
+    if (item instanceof IntegerCompare) {
+      key = item.key;
+      target = item.compare === Compare.Equal ? equality : range;
+    } else if (item instanceof StringMatch) {
+      key = item.key;
+      if (item.method === StringMatchMethod.contains) {
+        return;
+      }
+      target = item.method === StringMatchMethod.exact ? equality : range;
+      collation = item.caseInsensitive ? "NOCASE" : void 0;
+    } else if (item instanceof ByteMatchQuery || item instanceof BoolQuery || item instanceof IsNull) {
+      key = item.key;
+      target = equality;
+    }
+    if (!key || !target) {
+      return;
+    }
+    const columnName = queryKeyToColumnName([...path, ...key]);
+    if (availableColumns.has(columnName)) {
+      pushUniqueColumn(target, { name: columnName, collation });
+    }
+  };
+  for (const item of query) {
+    visit(item);
+  }
+  return { equality, range };
+};
+var getSortableColumns = (sort, availableColumns) => {
+  const out = [];
+  for (const item of sort) {
+    const columnName = queryKeyToColumnName(item.key);
+    if (availableColumns.has(columnName)) {
+      pushUniqueColumn(out, { name: columnName });
+    }
+  }
+  return out;
+};
+var normalizeCandidate = (columns) => {
+  const out = [];
+  pushColumns(out, columns);
+  return out;
+};
+var generateIndexCandidates = (query, columns) => {
+  if (columns.length === 0) {
+    return [];
+  }
+  const availableColumns = new Set(columns);
+  const { equality, range } = getIndexableQueryColumns(query.query, availableColumns);
+  const sort = getSortableColumns(query.sort, availableColumns);
+  const join = availableColumns.has(PARENT_TABLE_ID2) ? [{ name: PARENT_TABLE_ID2 }] : [];
+  const knownColumnNames = new Set([...join, ...equality, ...range, ...sort].map((x) => x.name));
+  const remaining = columns.filter((column) => !knownColumnNames.has(column)).map((name) => ({ name }));
+  const candidates = [];
+  const pushCandidate = (...parts) => {
+    const candidate = normalizeCandidate(parts.flat());
+    if (candidate.length > 0 && !candidates.some((existing) => existing.map(getIndexColumnKey).join(",") === candidate.map(getIndexColumnKey).join(","))) {
+      candidates.push(candidate);
+    }
+  };
+  if (sort.length > 0 && range.length > 0) {
+    pushCandidate(join, equality, sort, range, remaining);
+    pushCandidate(join, equality, range, sort, remaining);
+  } else if (sort.length > 0) {
+    pushCandidate(join, equality, sort, range, remaining);
+  } else {
+    if (join.length > 0 && (equality.length > 0 || range.length > 0)) {
+      pushCandidate(equality, range, join, remaining);
+    }
+    pushCandidate(join, equality, range, remaining);
+  }
+  if (join.length > 0 && (equality.length > 0 || range.length > 0)) {
+    if (sort.length > 0 && range.length > 0) {
+      pushCandidate(equality, sort, range, join, remaining);
+      pushCandidate(equality, range, sort, join, remaining);
+    } else if (sort.length > 0) {
+      pushCandidate(equality, range, sort, join, remaining);
+    }
+  }
+  pushCandidate(columns.map((name) => ({ name })));
+  pushCandidate([...columns].reverse().map((name) => ({ name })));
+  return candidates;
 };
 
 // dist/src/utils.js
@@ -22011,13 +22170,16 @@ var createBatchInsertSQL = (table, rows) => {
     length: rows
   }).map(() => rowPlaceholder).join(", ")};`;
 };
+var createInsertReturningSQL = (table) => `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
+var createInsertKnownIdSQL = (table) => `insert into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
+var createReplaceSQL = (table) => `insert or replace into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
 var canUseWithoutRowId = (table) => {
   if (table.inline || table.primary === false || !table.primaryField) {
     return false;
   }
   return !/^INTEGER\b/i.test(table.primaryField.type);
 };
-var SQLiteIndex = class {
+var SQLiteIndex = class _SQLiteIndex {
   properties;
   // SQLite writes are inherently serialized per connection.
   // We still need an explicit async barrier because our API is async and
@@ -22047,13 +22209,14 @@ var SQLiteIndex = class {
   primaryKeyString;
   planner;
   scopeString;
-  _rootTables;
-  _tables;
-  _cursor;
+  _rootTables = [];
+  _tables = /* @__PURE__ */ new Map();
+  _cursor = /* @__PURE__ */ new Map();
   // TODO choose limit better
   cursorPruner;
   iteratorTimeout;
   closed = true;
+  state = "closed";
   fkMode;
   id;
   constructor(properties, options) {
@@ -22070,21 +22233,74 @@ var SQLiteIndex = class {
   persisted() {
     return this.properties.persisted ?? true;
   }
+  static _emptyTables = /* @__PURE__ */ new Map();
+  static _emptyRootTables = [];
+  static _emptyCursor = /* @__PURE__ */ new Map();
+  static closedIterator() {
+    return {
+      all: async () => [],
+      close: async () => void 0,
+      done: () => true,
+      next: async () => [],
+      pending: async () => 0
+    };
+  }
+  async ifOpen(fallback, fn) {
+    if (this.isClosing()) {
+      return fallback;
+    }
+    this.assertOpen();
+    try {
+      return await fn();
+    } catch (error2) {
+      if (this.isClosing()) {
+        return fallback;
+      }
+      throw error2;
+    }
+  }
+  async withWriteIfOpen(fallback, fn) {
+    if (this.isClosing()) {
+      return fallback;
+    }
+    this.assertOpen();
+    return this.withWriteBarrier(() => this.ifOpen(fallback, fn));
+  }
+  assertOpen() {
+    if (this.state !== "open") {
+      throw new NotStartedError();
+    }
+  }
+  isClosing() {
+    return this.state === "closing";
+  }
+  setClosing() {
+    this.state = "closing";
+    this.closed = true;
+  }
+  setClosed() {
+    this.state = "closed";
+    this.closed = true;
+  }
+  setOpen() {
+    this.state = "open";
+    this.closed = false;
+  }
   get tables() {
     if (this.closed) {
-      throw new NotStartedError();
+      return _SQLiteIndex._emptyTables;
     }
     return this._tables;
   }
   get rootTables() {
     if (this.closed) {
-      throw new NotStartedError();
+      return _SQLiteIndex._emptyRootTables;
     }
     return this._rootTables;
   }
   get cursor() {
     if (this.closed) {
-      throw new NotStartedError();
+      return _SQLiteIndex._emptyCursor;
     }
     return this._cursor;
   }
@@ -22105,9 +22321,12 @@ var SQLiteIndex = class {
     return this;
   }
   async start() {
-    if (this.closed === false) {
+    if (this.state === "open") {
       return;
     }
+    if (this.state === "closing") {
+      throw new NotStartedError();
+    }
     if (this.primaryKeyArr == null || this.primaryKeyArr.length === 0) {
       throw new Error("Not initialized");
     }
@@ -22125,6 +22344,8 @@ var SQLiteIndex = class {
     );
     this._rootTables = tables.filter((x) => x.parent == null);
     const allTables = tables;
+    const startupStatements = [];
+    const startupTableStatements = /* @__PURE__ */ new Map();
     for (const table of allTables) {
       this._tables.set(table.name, table);
       for (const child of table.children) {
@@ -22135,15 +22356,38 @@ var SQLiteIndex = class {
       }
       const tableOptions = canUseWithoutRowId(table) ? " strict, without rowid" : " strict";
       const sqlCreateTable = `create table if not exists ${table.name} (${[...table.fields, ...table.constraints].map((s) => s.definition).join(", ")})${tableOptions}`;
-      this.properties.db.exec(sqlCreateTable);
-      let sqlPut = `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
-      let sqlInsertKnownId = `insert into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-      let sqlReplace = `insert or replace into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-      await this.properties.db.prepare(sqlPut, putStatementKey(table));
-      await this.properties.db.prepare(sqlInsertKnownId, insertKnownIdStatementKey(table));
-      await this.properties.db.prepare(sqlReplace, replaceStatementKey(table));
+      startupTableStatements.set(table.name, sqlCreateTable);
+      startupStatements.push({
+        id: putStatementKey(table),
+        sql: createInsertReturningSQL(table)
+      }, {
+        id: insertKnownIdStatementKey(table),
+        sql: createInsertKnownIdSQL(table)
+      }, {
+        id: replaceStatementKey(table),
+        sql: createReplaceSQL(table)
+      });
       if (table.parent) {
-        await this.properties.db.prepare(selectChildren(table), resolveChildrenStatement(table));
+        startupStatements.push({
+          id: resolveChildrenStatement(table),
+          sql: selectChildren(table)
+        });
+      }
+    }
+    if (startupTableStatements.size > 0) {
+      const existingTables = await this.getExistingSQLiteObjects("table", [
+        ...startupTableStatements.keys()
+      ]);
+      const missingTableStatements = [...startupTableStatements.entries()].filter(([tableName]) => !existingTables.has(tableName)).map(([, sql]) => sql);
+      if (missingTableStatements.length > 0) {
+        await this.properties.db.exec(missingTableStatements.join(";"));
+      }
+    }
+    if (this.properties.db.prepareMany) {
+      await this.properties.db.prepareMany(startupStatements);
+    } else {
+      for (const statement of startupStatements) {
+        await this.properties.db.prepare(statement.sql, statement.id);
       }
     }
     this.cursorPruner = setInterval(() => {
@@ -22154,7 +22398,17 @@ var SQLiteIndex = class {
         }
       }
     }, this.iteratorTimeout);
-    this.closed = false;
+    this.setOpen();
+  }
+  async getExistingSQLiteObjects(type, names) {
+    if (names.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    const sql = `select name from sqlite_master where type = ? and name in (${names.map(() => "?").join(", ")})`;
+    const statement = this.properties.db.statements.get(sql) || await this.properties.db.prepare(sql, sql);
+    const rows = await statement.all([type, ...names]);
+    await statement.reset?.();
+    return new Set(rows.map((row) => row.name).filter((name) => typeof name === "string"));
   }
   async clearStatements() {
     if (await this.properties.db.status() === "closed") {
@@ -22162,52 +22416,82 @@ var SQLiteIndex = class {
     }
   }
   async stop() {
-    if (this.closed) {
+    if (this.state === "closed") {
       return;
     }
-    this.closed = true;
-    clearInterval(this.cursorPruner);
-    await this.clearStatements();
-    this._tables.clear();
-    for (const [k, _v] of this._cursor) {
-      await this.clearupIterator(k);
-    }
-    await this.planner.stop();
-  }
-  async drop() {
-    if (!this.closed) {
-      this.closed = true;
+    if (this.state === "closing") {
+      await this._writeBarrier.catch(() => void 0);
+      return;
     }
-    if (this.cursorPruner != null) {
+    this.setClosing();
+    try {
       clearInterval(this.cursorPruner);
-      this.cursorPruner = void 0;
-    }
-    const status = await this.properties.db.status?.();
-    if (status === "closed") {
-      this._tables.clear();
-      return;
+      await this._writeBarrier.catch(() => void 0);
+      await this.clearStatements();
+      this._tables?.clear();
+      if (this._cursor) {
+        for (const [k, _v] of this._cursor) {
+          await this.clearupIterator(k);
+        }
+      }
+      await this.planner.stop();
+    } finally {
+      this.setClosed();
     }
-    await this.clearStatements();
-    for (const table of this._rootTables) {
-      await this.properties.db.exec(`drop table if exists ${table.name}`);
+  }
+  async drop() {
+    const wasOpen = this.state === "open";
+    if (wasOpen) {
+      this.setClosing();
     }
-    this._tables.clear();
-    for (const [k, _v] of this._cursor) {
-      await this.clearupIterator(k);
+    try {
+      if (this.cursorPruner != null) {
+        clearInterval(this.cursorPruner);
+        this.cursorPruner = void 0;
+      }
+      if (wasOpen) {
+        await this._writeBarrier.catch(() => void 0);
+      }
+      const status = await this.properties.db.status?.();
+      if (status === "closed") {
+        this._tables?.clear();
+        return;
+      }
+      await this.clearStatements();
+      if (this._rootTables) {
+        for (const table of this._rootTables) {
+          await this.properties.db.exec(`drop table if exists ${table.name}`);
+        }
+      }
+      this._tables?.clear();
+      if (this._cursor) {
+        for (const [k, _v] of this._cursor) {
+          await this.clearupIterator(k);
+        }
+      }
+      await this.planner.stop();
+    } finally {
+      this.setClosed();
     }
-    await this.planner.stop();
   }
   async resolveDependencies(parentId, table) {
-    const stmt = this.properties.db.statements.get(resolveChildrenStatement(table));
+    const stmt = await this.getOrPrepareStatement(resolveChildrenStatement(table), selectChildren(table));
     const results = await stmt.all([parentId]);
     await stmt.reset?.();
     return results;
   }
+  async getOrPrepareStatement(key, sql) {
+    const existing = this.properties.db.statements.get(key);
+    if (existing) {
+      return existing;
+    }
+    return this.properties.db.prepare(sql, key);
+  }
   async get(id, options) {
-    for (const table of this._rootTables) {
-      const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
-      const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${table.name}.${this.primaryKeyString} = ? limit 1`;
-      try {
+    return this.ifOpen(void 0, async () => {
+      for (const table of this._rootTables) {
+        const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
+        const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${table.name}.${this.primaryKeyString} = ? limit 1`;
         const stmt = await this.properties.db.prepare(sql, sql);
         const rows = await stmt.get([
           table.primaryField?.from?.type ? convertToSQLType(id.key, table.primaryField.from.type) : id.key
@@ -22219,17 +22503,12 @@ var SQLiteIndex = class {
           value: await resolveInstanceFromValue(rows, this.tables, table, this.resolveDependencies.bind(this), true, options?.shape),
           id
         };
-      } catch (error2) {
-        if (this.closed) {
-          throw new NotStartedError();
-        }
-        throw error2;
       }
-    }
-    return void 0;
+      return void 0;
+    });
   }
   async put(value, _id, options) {
-    return this.withWriteBarrier(async () => {
+    return this.withWriteIfOpen(void 0, async () => {
       const classOfValue = value.constructor;
       return insert(async (values, table) => {
         let preId = values[table.primaryIndex];
@@ -22238,7 +22517,7 @@ var SQLiteIndex = class {
           if (preId != null) {
             const shouldReplace = options?.replace ?? true;
             if (!shouldReplace) {
-              statement = this.properties.db.statements.get(insertKnownIdStatementKey(table));
+              statement = await this.getOrPrepareStatement(insertKnownIdStatementKey(table), createInsertKnownIdSQL(table));
               try {
                 this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
               } catch (error2) {
@@ -22246,16 +22525,16 @@ var SQLiteIndex = class {
                   throw error2;
                 }
                 await statement.reset?.();
-                statement = this.properties.db.statements.get(replaceStatementKey(table));
+                statement = await this.getOrPrepareStatement(replaceStatementKey(table), createReplaceSQL(table));
                 this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
               }
             } else {
-              statement = this.properties.db.statements.get(replaceStatementKey(table));
+              statement = await this.getOrPrepareStatement(replaceStatementKey(table), createReplaceSQL(table));
               this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
             }
             return preId;
           } else {
-            statement = this.properties.db.statements.get(putStatementKey(table));
+            statement = await this.getOrPrepareStatement(putStatementKey(table), createInsertReturningSQL(table));
             const out = this.fkMode === "race-tolerant" ? await getIgnoreFK(statement, values) : await statement.get(values);
             if (out == null) {
               return void 0;
@@ -22282,6 +22561,10 @@ var SQLiteIndex = class {
     });
   }
   iterate(request, options) {
+    if (this.isClosing()) {
+      return _SQLiteIndex.closedIterator();
+    }
+    this.assertOpen();
     let offset = 0;
     let once = false;
     let requestId = v4_default();
@@ -22296,43 +22579,60 @@ var SQLiteIndex = class {
     });
     let planningScope;
     const fetch2 = async (amount) => {
-      kept = void 0;
-      if (!once) {
-        planningScope = this.planner.scope(normalizedQuery);
-        let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
-          planner: planningScope,
-          shape: options?.shape,
-          fetchAll: amount === "all"
-          // if we are to fetch all, we dont need stable sorting
-        });
-        sqlFetch = sql;
-        bindable = toBind;
-        await planningScope.beforePrepare();
-        stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
-        iterator.expire = Date.now() + this.iteratorTimeout;
-      }
-      once = true;
-      const allResults = await planningScope.perform(async () => {
-        const allResults2 = await stmt.all([
-          ...bindable,
-          ...amount !== "all" ? [amount, offset] : []
-        ]);
-        return allResults2;
-      });
-      let results = await Promise.all(allResults.map(async (row) => {
-        let selectedTable = this._rootTables.find((table) => row[getTablePrefixedField(table, this.primaryKeyString)] != null);
-        const value = await resolveInstanceFromValue(row, this.tables, selectedTable, this.resolveDependencies.bind(this), true, options?.shape);
-        return {
-          value,
-          id: toId(convertFromSQLType(row[getTablePrefixedField(selectedTable, this.primaryKeyString)], selectedTable.primaryField.from.type))
-        };
-      }));
-      offset += results.length;
-      if (amount === "all" || results.length < amount) {
+      const closeAsDone = () => {
+        once = true;
         hasMore = false;
-        await this.clearupIterator(requestId);
+        kept = 0;
+        return [];
+      };
+      if (this.isClosing()) {
+        return closeAsDone();
+      }
+      this.assertOpen();
+      try {
+        kept = void 0;
+        if (!once) {
+          planningScope = this.planner.scope(normalizedQuery);
+          let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
+            planner: planningScope,
+            shape: options?.shape,
+            fetchAll: amount === "all"
+            // if we are to fetch all, we dont need stable sorting
+          });
+          sqlFetch = sql;
+          bindable = toBind;
+          await planningScope.beforePrepare();
+          stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
+          iterator.expire = Date.now() + this.iteratorTimeout;
+        }
+        once = true;
+        const allResults = await planningScope.perform(async () => {
+          const allResults2 = await stmt.all([
+            ...bindable,
+            ...amount !== "all" ? [amount, offset] : []
+          ]);
+          return allResults2;
+        });
+        let results = await Promise.all(allResults.map(async (row) => {
+          let selectedTable = this._rootTables.find((table) => row[getTablePrefixedField(table, this.primaryKeyString)] != null);
+          const value = await resolveInstanceFromValue(row, this.tables, selectedTable, this.resolveDependencies.bind(this), true, options?.shape);
+          return {
+            value,
+            id: toId(convertFromSQLType(row[getTablePrefixedField(selectedTable, this.primaryKeyString)], selectedTable.primaryField.from.type))
+          };
+        }));
+        offset += results.length;
+        if (amount === "all" || results.length < amount) {
+          hasMore = false;
+          await this.clearupIterator(requestId);
+        }
+        return results;
+      } catch (error2) {
+        if (this.isClosing()) {
+          return closeAsDone();
+        }
+        throw error2;
       }
-      return results;
     };
     const iterator = {
       fetch: fetch2,
@@ -22354,12 +22654,20 @@ var SQLiteIndex = class {
         return results;
       },
       close: () => {
+        once = true;
         hasMore = false;
         kept = 0;
         this.clearupIterator(requestId);
       },
       next: (amount) => fetch2(amount),
       pending: async () => {
+        if (this.isClosing()) {
+          once = true;
+          hasMore = false;
+          kept = 0;
+          return 0;
+        }
+        this.assertOpen();
         if (!hasMore) {
           return 0;
         }
@@ -22371,7 +22679,12 @@ var SQLiteIndex = class {
         hasMore = kept > 0;
         return kept;
       },
-      done: () => once ? !hasMore : void 0
+      done: () => {
+        if (this.isClosing()) {
+          return true;
+        }
+        return once ? !hasMore : void 0;
+      }
     };
   }
   async clearupIterator(id) {
@@ -22382,21 +22695,29 @@ var SQLiteIndex = class {
     this._cursor.delete(id);
   }
   async getSize() {
-    if (this.tables.size === 0) {
-      return 0;
-    }
-    return this.count();
+    return this.ifOpen(0, async () => {
+      if (this.tables.size === 0) {
+        return 0;
+      }
+      return this.count();
+    });
   }
   async del(query) {
-    return this.withWriteBarrier(async () => {
+    return this.withWriteIfOpen([], async () => {
       let ret = [];
       let once = false;
       let lastError = void 0;
       for (const table of this._rootTables) {
         try {
-          const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table);
+          const planningScope = this.planner.scope(new PlannableQuery({
+            query: coerceLocalQueries(query.query)
+          }));
+          const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table, {
+            planner: planningScope
+          });
+          await planningScope.beforePrepare();
           const stmt = await this.properties.db.prepare(sql, sql);
-          const results = await stmt.all(bindable);
+          const results = await planningScope.perform(async () => stmt.all(bindable));
           for (const result of results) {
             ret.push(toId(convertFromSQLType(result[table.primary], table.primaryField.from.type)));
           }
@@ -22416,69 +22737,79 @@ var SQLiteIndex = class {
     });
   }
   async sum(query) {
-    let ret = void 0;
-    let once = false;
-    let lastError = void 0;
-    let inlinedName = getInlineTableFieldName(query.key);
-    for (const table of this._rootTables) {
-      try {
-        if (table.fields.find((x) => x.name === inlinedName) == null) {
-          lastError = new MissingFieldError("Missing field: " + (Array.isArray(query.key) ? query.key : [query.key]).join("."));
-          continue;
-        }
-        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) {
-          const value = result.sum;
-          if (ret == null) {
-            ret = value;
-          } else {
-            ret += value;
+    return this.ifOpen(0, async () => {
+      let ret = void 0;
+      let once = false;
+      let lastError = void 0;
+      let inlinedName = getInlineTableFieldName(query.key);
+      for (const table of this._rootTables) {
+        try {
+          if (table.fields.find((x) => x.name === inlinedName) == null) {
+            lastError = new MissingFieldError("Missing field: " + (Array.isArray(query.key) ? query.key : [query.key]).join("."));
+            continue;
           }
-          once = true;
-        }
-      } catch (error2) {
-        if (error2 instanceof MissingFieldError) {
-          lastError = error2;
-          continue;
+          const planningScope = this.planner.scope(new PlannableQuery({
+            query: coerceLocalQueries(query.query)
+          }));
+          const { sql, bindable } = convertSumRequestToQuery(query, this.tables, table, {
+            planner: planningScope
+          });
+          await planningScope.beforePrepare();
+          const stmt = await this.properties.db.prepare(sql, sql);
+          const result = await planningScope.perform(async () => stmt.get(bindable));
+          if (result != null) {
+            const value = result.sum;
+            if (ret == null) {
+              ret = value;
+            } else {
+              ret += value;
+            }
+            once = true;
+          }
+        } catch (error2) {
+          if (error2 instanceof MissingFieldError) {
+            lastError = error2;
+            continue;
+          }
+          throw error2;
         }
-        throw error2;
       }
-    }
-    if (!once) {
-      throw lastError;
-    }
-    return ret != null ? ret : 0;
+      if (!once) {
+        throw lastError;
+      }
+      return ret != null ? ret : 0;
+    });
   }
   async count(request) {
-    let ret = 0;
-    let once = false;
-    let lastError = void 0;
-    for (const table of this._rootTables) {
-      try {
-        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;
-          continue;
+    return this.ifOpen(0, async () => {
+      let ret = 0;
+      let once = false;
+      let lastError = void 0;
+      for (const table of this._rootTables) {
+        try {
+          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;
+            continue;
+          }
+          throw error2;
         }
-        throw error2;
       }
-    }
-    if (!once) {
-      throw lastError;
-    }
-    return ret;
+      if (!once) {
+        throw lastError;
+      }
+      return ret;
+    });
   }
   get cursorCount() {
-    return this.cursor.size;
+    return this.closed ? 0 : this._cursor.size;
   }
 };
 var SQLiteIndices = class _SQLiteIndices {
@@ -22537,7 +22868,10 @@ var SQLiteIndices = class _SQLiteIndices {
   async start() {
     this.closed = false;
     if (!this.properties.parent) {
-      await this.properties.db.open();
+      const status = await this.properties.db.status();
+      if (status !== "open") {
+        await this.properties.db.open();
+      }
     }
     for (const scope of this.scopes.values()) {
       await scope.start();
@@ -22828,7 +23162,6 @@ var create = async (directory, options) => {
         directory: poolDirectory
       });
       poolUtil = activePoolUtil;
-      await activePoolUtil.reserveMinimumCapacity(100);
       sqliteDb = new activePoolUtil.OpfsSAHPoolDb(dbFileName);
     } else {
       sqliteDb = new sqlite32.oo1.DB(":memory:");
@@ -23085,6 +23418,27 @@ var ProxyDatabase = class {
     }
     return statement;
   }
+  async prepareMany(statements) {
+    if (statements.length === 0) {
+      return [];
+    }
+    const missing = statements.filter((statement) => !this.statements.get(statement.id));
+    if (missing.length > 0) {
+      const statementIds = await this.send({
+        type: "prepare-many",
+        statements: missing,
+        id: v4_default(),
+        databaseId: this.databaseId
+      });
+      for (const [index, statementId] of statementIds.entries()) {
+        const definition = missing[index];
+        const statement = new ProxyStatement(this.send.bind(this), this.databaseId, statementId, definition.sql, this.options);
+        this.statements.set(statementId, statement);
+        this.statements.set(definition.id, statement);
+      }
+    }
+    return statements.map((statement) => this.statements.get(statement.id));
+  }
   async open() {
     return this.send({ type: "open", id: v4_default(), databaseId: this.databaseId });
   }