@noy-db/hub 0.2.0-pre.30 → 0.2.0-pre.31

package/dist/indexing/index.cjs

@@ -1,803 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/indexing/index.ts
-var indexing_exports = {};
-__export(indexing_exports, {
-  COMPOSITE_DELIMITER: () => COMPOSITE_DELIMITER,
-  CollectionIndexes: () => CollectionIndexes,
-  IDX_PREFIX: () => IDX_PREFIX,
-  LazyQuery: () => LazyQuery,
-  PersistedCollectionIndex: () => PersistedCollectionIndex,
-  compositeKey: () => compositeKey,
-  decodeIdxId: () => decodeIdxId,
-  encodeIdxId: () => encodeIdxId,
-  isIdxId: () => isIdxId,
-  withIndexing: () => withIndexing
-});
-module.exports = __toCommonJS(indexing_exports);
-
-// src/errors.ts
-var NoydbError = class extends Error {
-  /** Machine-readable error code. Stable across library versions. */
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "NoydbError";
-    this.code = code;
-  }
-};
-var IndexRequiredError = class extends NoydbError {
-  collection;
-  touchedFields;
-  missingFields;
-  constructor(args) {
-    super(
-      "INDEX_REQUIRED",
-      `Collection "${args.collection}": query references unindexed fields in lazy mode (missing: ${args.missingFields.join(", ")}). Declare an index on each field, or use collection.scan() for non-indexed iteration.`
-    );
-    this.name = "IndexRequiredError";
-    this.collection = args.collection;
-    this.touchedFields = [...args.touchedFields];
-    this.missingFields = [...args.missingFields];
-  }
-};
-
-// src/money/where.ts
-function isMoneyValueObject(v) {
-  return typeof v === "object" && v !== null && "currency" in v;
-}
-function readStored(actual, operand) {
-  let amount;
-  let currency;
-  if (operand.mode === "fixed") {
-    if (typeof actual !== "string" && typeof actual !== "number") return null;
-    amount = actual;
-    currency = operand.entries[0]?.currency ?? "";
-  } else {
-    if (!isMoneyValueObject(actual)) return null;
-    if (typeof actual.currency !== "string") return null;
-    amount = actual.amount;
-    currency = actual.currency;
-  }
-  if (typeof amount !== "string" && typeof amount !== "number") return null;
-  try {
-    return { scaled: BigInt(amount).toString(), currency };
-  } catch {
-    return null;
-  }
-}
-function evaluateMoneyClause(actual, op, operand) {
-  const stored = readStored(actual, operand);
-  if (stored === null) return op === "!=";
-  const a = BigInt(stored.scaled);
-  if (op === "in") {
-    return operand.entries.some(
-      (e2) => e2.currency === stored.currency && BigInt(e2.scaled) === a
-    );
-  }
-  if (op === "between") {
-    const [lo, hi] = operand.entries;
-    if (!lo || !hi || lo.currency !== stored.currency) return false;
-    return a >= BigInt(lo.scaled) && a <= BigInt(hi.scaled);
-  }
-  const e = operand.entries[0];
-  if (!e) return false;
-  if (e.currency !== stored.currency) return op === "!=";
-  const b = BigInt(e.scaled);
-  switch (op) {
-    case "==":
-      return a === b;
-    case "!=":
-      return a !== b;
-    case "<":
-      return a < b;
-    case "<=":
-      return a <= b;
-    case ">":
-      return a > b;
-    case ">=":
-      return a >= b;
-    default:
-      return false;
-  }
-}
-
-// src/query/predicate.ts
-function readPath(record, path) {
-  if (record === null || record === void 0) return void 0;
-  if (!path.includes(".")) {
-    return record[path];
-  }
-  const segments = path.split(".");
-  let cursor = record;
-  for (const segment of segments) {
-    if (cursor === null || cursor === void 0) return void 0;
-    cursor = cursor[segment];
-  }
-  return cursor;
-}
-function evaluateFieldClause(record, clause) {
-  const actual = readPath(record, clause.field);
-  const { op, value } = clause;
-  if (clause.money) return evaluateMoneyClause(actual, op, clause.money);
-  switch (op) {
-    case "==":
-      return actual === value;
-    case "!=":
-      return actual !== value;
-    case "<":
-      return isComparable(actual, value) && actual < value;
-    case "<=":
-      return isComparable(actual, value) && actual <= value;
-    case ">":
-      return isComparable(actual, value) && actual > value;
-    case ">=":
-      return isComparable(actual, value) && actual >= value;
-    case "in":
-      return Array.isArray(value) && value.includes(actual);
-    case "contains":
-      if (typeof actual === "string") return typeof value === "string" && actual.includes(value);
-      if (Array.isArray(actual)) return actual.includes(value);
-      return false;
-    case "startsWith":
-      return typeof actual === "string" && typeof value === "string" && actual.startsWith(value);
-    case "between": {
-      if (!Array.isArray(value) || value.length !== 2) return false;
-      const [lo, hi] = value;
-      if (!isComparable(actual, lo) || !isComparable(actual, hi)) return false;
-      return actual >= lo && actual <= hi;
-    }
-    default: {
-      const _exhaustive = op;
-      void _exhaustive;
-      return false;
-    }
-  }
-}
-function isComparable(a, b) {
-  if (typeof a === "number" && typeof b === "number") return true;
-  if (typeof a === "string" && typeof b === "string") return true;
-  if (a instanceof Date && b instanceof Date) return true;
-  return false;
-}
-function evaluateClause(record, clause, fnRecord) {
-  switch (clause.type) {
-    case "field":
-      return evaluateFieldClause(record, clause);
-    case "filter":
-      return clause.fn(fnRecord !== void 0 ? fnRecord : record);
-    case "wherePredicate":
-      return clause.fn(fnRecord !== void 0 ? fnRecord : record, clause.ctx);
-    case "crossJoin":
-      throw new Error(
-        `evaluateClause: 'crossJoin' clauses are expansion primitives and are not evaluated per-record. This is a query planner routing error \u2014 crossJoin clauses must be extracted from the clause list before calling evaluateClause or filterRecords.`
-      );
-    case "group":
-      if (clause.op === "and") {
-        for (const child of clause.clauses) {
-          if (!evaluateClause(record, child, fnRecord)) return false;
-        }
-        return true;
-      } else {
-        for (const child of clause.clauses) {
-          if (evaluateClause(record, child, fnRecord)) return true;
-        }
-        return false;
-      }
-  }
-}
-
-// src/indexing/eager-indexes.ts
-var CollectionIndexes = class {
-  indexes = /* @__PURE__ */ new Map();
-  /**
-   * Declare an index. Subsequent record additions are tracked under it.
-   * Calling this twice for the same field is a no-op (idempotent).
-   */
-  declare(field) {
-    if (this.indexes.has(field)) return;
-    this.indexes.set(field, { field, buckets: /* @__PURE__ */ new Map() });
-  }
-  /** True if the given field has a declared index. */
-  has(field) {
-    return this.indexes.has(field);
-  }
-  /** All declared field names, in declaration order. */
-  fields() {
-    return [...this.indexes.keys()];
-  }
-  /**
-   * Build all declared indexes from a snapshot of records.
-   * Called once per hydration. O(N × indexes.size).
-   */
-  build(records) {
-    for (const idx of this.indexes.values()) {
-      idx.buckets.clear();
-      for (const { id, record } of records) {
-        addToIndex(idx, id, record);
-      }
-    }
-  }
-  /**
-   * Insert or update a single record across all indexes.
-   * Called by `Collection.put()` after the encrypted write succeeds.
-   *
-   * If `previousRecord` is provided, the record is removed from any old
-   * buckets first — this is the update path. Pass `null` for fresh adds.
-   */
-  upsert(id, newRecord, previousRecord) {
-    if (this.indexes.size === 0) return;
-    if (previousRecord !== null) {
-      this.remove(id, previousRecord);
-    }
-    for (const idx of this.indexes.values()) {
-      addToIndex(idx, id, newRecord);
-    }
-  }
-  /**
-   * Remove a record from all indexes. Called by `Collection.delete()`
-   * (and as the first half of `upsert` for the update path).
-   */
-  remove(id, record) {
-    if (this.indexes.size === 0) return;
-    for (const idx of this.indexes.values()) {
-      removeFromIndex(idx, id, record);
-    }
-  }
-  /** Drop all index data. Called when the collection is invalidated. */
-  clear() {
-    for (const idx of this.indexes.values()) {
-      idx.buckets.clear();
-    }
-  }
-  /**
-   * Equality lookup: return the set of record ids whose `field` matches
-   * the given value. Returns `null` if no index covers the field — the
-   * caller should fall back to a linear scan.
-   *
-   * The returned Set is a reference to the index's internal storage —
-   * callers must NOT mutate it.
-   */
-  lookupEqual(field, value) {
-    const idx = this.indexes.get(field);
-    if (!idx) return null;
-    const key = stringifyKey(value);
-    return idx.buckets.get(key) ?? EMPTY_SET;
-  }
-  /**
-   * Set lookup: return the union of record ids whose `field` matches any
-   * of the given values. Returns `null` if no index covers the field.
-   */
-  lookupIn(field, values) {
-    const idx = this.indexes.get(field);
-    if (!idx) return null;
-    const out = /* @__PURE__ */ new Set();
-    for (const value of values) {
-      const key = stringifyKey(value);
-      const bucket = idx.buckets.get(key);
-      if (bucket) {
-        for (const id of bucket) out.add(id);
-      }
-    }
-    return out;
-  }
-};
-var EMPTY_SET = /* @__PURE__ */ new Set();
-function stringifyKey(value) {
-  if (value === null || value === void 0) return "\0NULL\0";
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  if (value instanceof Date) return value.toISOString();
-  return "\0OBJECT\0";
-}
-function addToIndex(idx, id, record) {
-  const value = readPath(record, idx.field);
-  if (value === null || value === void 0) return;
-  const key = stringifyKey(value);
-  let bucket = idx.buckets.get(key);
-  if (!bucket) {
-    bucket = /* @__PURE__ */ new Set();
-    idx.buckets.set(key, bucket);
-  }
-  bucket.add(id);
-}
-function removeFromIndex(idx, id, record) {
-  const value = readPath(record, idx.field);
-  if (value === null || value === void 0) return;
-  const key = stringifyKey(value);
-  const bucket = idx.buckets.get(key);
-  if (!bucket) return;
-  bucket.delete(id);
-  if (bucket.size === 0) idx.buckets.delete(key);
-}
-
-// src/indexing/persisted-indexes.ts
-var IDX_PREFIX = "_idx/";
-function encodeIdxId(field, recordId) {
-  return `${IDX_PREFIX}${field}/${recordId}`;
-}
-function decodeIdxId(id) {
-  if (!id.startsWith(IDX_PREFIX)) return null;
-  const rest = id.slice(IDX_PREFIX.length);
-  const firstSlash = rest.indexOf("/");
-  if (firstSlash <= 0) return null;
-  const field = rest.slice(0, firstSlash);
-  const recordId = rest.slice(firstSlash + 1);
-  if (recordId.length === 0) return null;
-  return { field, recordId };
-}
-function isIdxId(id) {
-  return decodeIdxId(id) !== null;
-}
-var COMPOSITE_DELIMITER = "|";
-function compositeKey(fields) {
-  return fields.join(COMPOSITE_DELIMITER);
-}
-var PersistedCollectionIndex = class {
-  indexes = /* @__PURE__ */ new Map();
-  defs = /* @__PURE__ */ new Map();
-  /**
-   * Declare a single-field index. Subsequent `upsert` / `ingest` calls
-   * populate the in-memory mirror; calls before `declare` are no-ops
-   * (tolerant bulk-load ordering). Idempotent.
-   */
-  declare(field) {
-    if (this.indexes.has(field)) return;
-    this.indexes.set(field, { buckets: /* @__PURE__ */ new Map(), values: /* @__PURE__ */ new Map() });
-    this.defs.set(field, { kind: "single", field, key: field });
-  }
-  /**
-   * Declare a composite (multi-field) index. The synthetic
-   * key is `fields.join('|')`; it doubles as the in-memory map key and
-   * the `_idx/<key>/<recordId>` side-car field segment. Callers upsert
-   * and lookup via the same `key` as single-field indexes, just with a
-   * tuple value (JSON-stringified for bucketing).
-   */
-  declareComposite(fields) {
-    if (fields.length === 0) {
-      throw new Error("declareComposite: fields array must be non-empty");
-    }
-    for (const f of fields) {
-      if (f.includes(COMPOSITE_DELIMITER)) {
-        throw new Error(
-          `declareComposite: field "${f}" contains the composite delimiter "${COMPOSITE_DELIMITER}" \u2014 pick a different field name or open an issue to add hash-based composite keys.`
-        );
-      }
-    }
-    const key = compositeKey(fields);
-    if (this.indexes.has(key)) return;
-    this.indexes.set(key, { buckets: /* @__PURE__ */ new Map(), values: /* @__PURE__ */ new Map() });
-    this.defs.set(key, { kind: "composite", fields: [...fields], key });
-  }
-  /**
-   * Every declared index's structured definition. Collection walks this
-   * when materialising side-cars on put/delete so it can extract a
-   * single-field value or a composite tuple appropriately.
-   */
-  definitions() {
-    return [...this.defs.values()];
-  }
-  /** True if `field` has been declared as indexable on this mirror. */
-  has(field) {
-    return this.indexes.has(field);
-  }
-  /** All declared field names, in declaration order. */
-  fields() {
-    return [...this.indexes.keys()];
-  }
-  /**
-   * Bulk-load the mirror from decrypted index bodies. Intended to be
-   * called once per field after reading the collection's `_idx/<field>/*`
-   * side-cars. Safe to call twice with the same rows — bucket Sets
-   * deduplicate recordIds. If `field` is not declared, this is a no-op
-   * (tolerates the case where bulk-load runs before `declare()` lands).
-   */
-  ingest(field, rows) {
-    const state = this.indexes.get(field);
-    if (!state) return;
-    for (const row of rows) {
-      addToState(state, row.recordId, row.value);
-    }
-  }
-  /**
-   * Incrementally update a record's index entry for one field. Called by
-   * `Collection.put()` after the main write succeeds. If
-   * `previousValue` is non-null, the record is removed from the old
-   * bucket first — this is the update path. Pass `null` for fresh adds.
-   * No-op if the field is not declared.
-   */
-  upsert(recordId, field, newValue, previousValue) {
-    const state = this.indexes.get(field);
-    if (!state) return;
-    if (previousValue !== null && previousValue !== void 0) {
-      removeFromState(state, recordId, previousValue);
-    }
-    addToState(state, recordId, newValue);
-  }
-  /**
-   * Remove a record from the index for one field. Called by
-   * `Collection.delete()`. No-op if the field is not declared or
-   * the record isn't in the bucket. Empty buckets are dropped to keep
-   * the Map clean.
-   */
-  remove(recordId, field, value) {
-    const state = this.indexes.get(field);
-    if (!state) return;
-    removeFromState(state, recordId, value);
-  }
-  /**
-   * Drop all bucket data while preserving field declarations. Called on
-   * invalidation (incoming sync changes, keyring rotation) — the next
-   * query re-populates via `ingest`.
-   */
-  clear() {
-    for (const state of this.indexes.values()) {
-      state.buckets.clear();
-      state.values.clear();
-    }
-  }
-  /**
-   * Equality lookup — return the set of record ids whose `field` matches
-   * `value`. Returns `null` if the field is not declared (caller falls
-   * back to scan or throws `IndexRequiredError`). Returns a shared empty
-   * set if the field is declared but no record matches — that set MUST
-   * NOT be mutated by the caller.
-   */
-  lookupEqual(field, value) {
-    const state = this.indexes.get(field);
-    if (!state) return null;
-    const key = stringifyKey2(value);
-    return state.buckets.get(key) ?? EMPTY_SET2;
-  }
-  /**
-   * Set lookup — return the union of record ids whose `field` matches any
-   * of `values`. Returns `null` if the field is not declared. Returns a
-   * fresh (non-shared) Set — safe for the caller to mutate.
-   */
-  lookupIn(field, values) {
-    const state = this.indexes.get(field);
-    if (!state) return null;
-    const out = /* @__PURE__ */ new Set();
-    for (const value of values) {
-      const bucket = state.buckets.get(stringifyKey2(value));
-      if (bucket) for (const id of bucket) out.add(id);
-    }
-    return out;
-  }
-  /**
-   * Range lookup. Return record ids whose indexed value
-   * satisfies the predicate. Comparison happens on the ORIGINAL TYPED
-   * value carried in `state.values` — so numeric `<` sorts numerically,
-   * not lexicographically on `String(n)`. Returns `null` if the field
-   * is not declared.
-   *
-   * Supported ops: `'<'`, `'<='`, `'>'`, `'>='`, `'between'`. For
-   * `'between'`, `value` is `[lo, hi]` and both bounds are inclusive
-   * (matches the eager-mode operator contract in `predicate.ts`).
-   */
-  lookupRange(field, op, value) {
-    const state = this.indexes.get(field);
-    if (!state) return null;
-    const out = /* @__PURE__ */ new Set();
-    for (const [recordId, live] of state.values) {
-      if (live === void 0 || live === null) continue;
-      if (matchesRange(live, op, value)) out.add(recordId);
-    }
-    return out;
-  }
-  /**
-   * Sorted iteration — return every entry on `field` as an
-   * `OrderedEntry[]`, sorted by the ORIGINAL TYPED value (no more
-   * `'10' < '2'` surprises on numeric fields). Consumers paginate with
-   * a numeric offset. `OrderedEntry.value` is the typed value.
-   */
-  orderedBy(field, dir) {
-    const state = this.indexes.get(field);
-    if (!state) return null;
-    const entries = [];
-    for (const [recordId, value] of state.values) {
-      entries.push({ recordId, value });
-    }
-    entries.sort((a, b) => compareTyped(a.value, b.value));
-    if (dir === "desc") entries.reverse();
-    return entries;
-  }
-};
-var EMPTY_SET2 = /* @__PURE__ */ new Set();
-function stringifyKey2(value) {
-  if (value === null || value === void 0) return "\0NULL\0";
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  if (value instanceof Date) return value.toISOString();
-  if (Array.isArray(value)) {
-    const parts = [];
-    for (const el of value) parts.push(stringifyKey2(el));
-    return JSON.stringify(parts);
-  }
-  return "\0OBJECT\0";
-}
-function addToState(state, recordId, value) {
-  if (value === null || value === void 0) return;
-  const key = stringifyKey2(value);
-  let bucket = state.buckets.get(key);
-  if (!bucket) {
-    bucket = /* @__PURE__ */ new Set();
-    state.buckets.set(key, bucket);
-  }
-  bucket.add(recordId);
-  state.values.set(recordId, value);
-}
-function removeFromState(state, recordId, value) {
-  if (value === null || value === void 0) return;
-  const key = stringifyKey2(value);
-  const bucket = state.buckets.get(key);
-  if (bucket) {
-    bucket.delete(recordId);
-    if (bucket.size === 0) state.buckets.delete(key);
-  }
-  state.values.delete(recordId);
-}
-function matchesRange(live, op, bound) {
-  if (op === "between") {
-    if (!Array.isArray(bound) || bound.length !== 2) return false;
-    return compareTyped(live, bound[0]) >= 0 && compareTyped(live, bound[1]) <= 0;
-  }
-  const cmp = compareTyped(live, bound);
-  switch (op) {
-    case "<":
-      return cmp < 0;
-    case "<=":
-      return cmp <= 0;
-    case ">":
-      return cmp > 0;
-    case ">=":
-      return cmp >= 0;
-  }
-}
-function compareTyped(a, b) {
-  if (a === void 0 || a === null) return b === void 0 || b === null ? 0 : 1;
-  if (b === void 0 || b === null) return -1;
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
-  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : a > b ? 1 : 0;
-  if (typeof a === "boolean" && typeof b === "boolean") {
-    return a === b ? 0 : a ? 1 : -1;
-  }
-  return 0;
-}
-
-// src/indexing/active.ts
-function withIndexing() {
-  return {
-    createState({ defs, lazy }) {
-      if (lazy) {
-        const persisted = new PersistedCollectionIndex();
-        declareAll(persisted, defs);
-        return makeLazyState(persisted);
-      }
-      const eager = new CollectionIndexes();
-      for (const def of defs) {
-        if (typeof def === "string") {
-          eager.declare(def);
-        } else if (Array.isArray(def)) {
-          for (const f of def) eager.declare(f);
-        } else {
-          for (const f of def.fields) eager.declare(f);
-        }
-      }
-      return makeEagerState(eager);
-    }
-  };
-}
-function declareAll(persisted, defs) {
-  for (const def of defs) {
-    if (typeof def === "string") {
-      persisted.declare(def);
-    } else if (Array.isArray(def)) {
-      persisted.declareComposite(def);
-    } else {
-      persisted.declareComposite(def.fields);
-    }
-  }
-}
-function makeEagerState(eager) {
-  return {
-    isEnabled: true,
-    getEagerIndexes: () => eager,
-    getPersistedIndexes: () => null
-  };
-}
-function makeLazyState(persisted) {
-  return {
-    isEnabled: true,
-    getEagerIndexes: () => null,
-    getPersistedIndexes: () => persisted
-  };
-}
-
-// src/indexing/lazy-builder.ts
-var EMPTY_PLAN = {
-  clauses: [],
-  orderBy: [],
-  limit: void 0,
-  offset: 0
-};
-var LazyQuery = class _LazyQuery {
-  source;
-  plan;
-  constructor(source, plan = EMPTY_PLAN) {
-    this.source = source;
-    this.plan = plan;
-  }
-  where(field, op, value) {
-    const clause = { type: "field", field, op, value };
-    return new _LazyQuery(this.source, {
-      ...this.plan,
-      clauses: [...this.plan.clauses, clause]
-    });
-  }
-  orderBy(field, direction = "asc") {
-    return new _LazyQuery(this.source, {
-      ...this.plan,
-      orderBy: [...this.plan.orderBy, { field, direction }]
-    });
-  }
-  limit(n) {
-    return new _LazyQuery(this.source, { ...this.plan, limit: n });
-  }
-  offset(n) {
-    return new _LazyQuery(this.source, { ...this.plan, offset: n });
-  }
-  async toArray() {
-    await this.source.ensurePersistedIndexesLoaded();
-    const touchedFields = collectTouchedFields(this.plan);
-    const missingFields = touchedFields.filter((f) => !isFieldIndexed(f, this.source.persistedIndexes));
-    if (missingFields.length > 0) {
-      throw new IndexRequiredError({
-        collection: this.source.collectionName,
-        touchedFields,
-        missingFields
-      });
-    }
-    const candidateIds = this.resolveCandidateIds();
-    if (candidateIds === null) {
-      throw new IndexRequiredError({
-        collection: this.source.collectionName,
-        touchedFields,
-        missingFields: touchedFields
-      });
-    }
-    const records = [];
-    for (const id of candidateIds) {
-      const record = await this.source.getRecord(id);
-      if (record === null) continue;
-      if (!matchesAll(record, this.plan.clauses)) continue;
-      records.push(record);
-    }
-    const sorted = this.plan.orderBy.length > 0 ? sortRecords(records, this.plan.orderBy) : records;
-    const offset = this.plan.offset > 0 ? this.plan.offset : 0;
-    const limited = this.plan.limit === void 0 ? sorted.slice(offset) : sorted.slice(offset, offset + this.plan.limit);
-    return limited;
-  }
-  async first() {
-    const out = await this.limit(1).toArray();
-    return out.length > 0 ? out[0] : null;
-  }
-  async count() {
-    const out = await this.toArray();
-    return out.length;
-  }
-  /**
-   * Resolve the candidate record-id set to decrypt. Returns null when the
-   * query has no usable driver — no `==`/`in` clause and no `orderBy`
-   * clause that can scope the scan. Callers interpret null as
-   * IndexRequiredError (see `toArray`).
-   */
-  resolveCandidateIds() {
-    const idx = this.source.persistedIndexes;
-    const eqMap = /* @__PURE__ */ new Map();
-    for (const clause of this.plan.clauses) {
-      if (clause.op === "==") eqMap.set(clause.field, clause.value);
-    }
-    if (eqMap.size >= 2) {
-      for (const def of idx.definitions()) {
-        if (def.kind !== "composite") continue;
-        if (def.fields.every((f) => eqMap.has(f))) {
-          const tuple = def.fields.map((f) => eqMap.get(f));
-          const ids = idx.lookupEqual(def.key, tuple);
-          if (ids) return [...ids];
-        }
-      }
-    }
-    for (const clause of this.plan.clauses) {
-      if (clause.op === "==") {
-        const ids = idx.lookupEqual(clause.field, clause.value);
-        if (ids) return [...ids];
-      } else if (clause.op === "in" && Array.isArray(clause.value)) {
-        const ids = idx.lookupIn(clause.field, clause.value);
-        if (ids) return [...ids];
-      } else if (isRangeOp(clause.op)) {
-        const ids = idx.lookupRange(clause.field, clause.op, clause.value);
-        if (ids) return [...ids];
-      }
-    }
-    if (this.plan.orderBy.length > 0) {
-      const primary = this.plan.orderBy[0];
-      const entries = idx.orderedBy(primary.field, primary.direction);
-      if (entries) return entries.map((e) => e.recordId);
-    }
-    return null;
-  }
-};
-function isFieldIndexed(field, idx) {
-  if (idx.has(field)) return true;
-  for (const def of idx.definitions()) {
-    if (def.kind === "composite" && def.fields.includes(field)) return true;
-  }
-  return false;
-}
-function isRangeOp(op) {
-  return op === "<" || op === "<=" || op === ">" || op === ">=" || op === "between";
-}
-function collectTouchedFields(plan) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const c of plan.clauses) seen.add(c.field);
-  for (const o of plan.orderBy) seen.add(o.field);
-  return [...seen];
-}
-function matchesAll(record, clauses) {
-  for (const c of clauses) {
-    if (!evaluateClause(record, c)) return false;
-  }
-  return true;
-}
-function sortRecords(records, orderBy) {
-  return [...records].sort((a, b) => {
-    for (const { field, direction } of orderBy) {
-      const av = readPath(a, field);
-      const bv = readPath(b, field);
-      const cmp = compareValues(av, bv);
-      if (cmp !== 0) return direction === "asc" ? cmp : -cmp;
-    }
-    return 0;
-  });
-}
-function compareValues(a, b) {
-  if (a === void 0 || a === null) return b === void 0 || b === null ? 0 : 1;
-  if (b === void 0 || b === null) return -1;
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : a > b ? 1 : 0;
-  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
-  return 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  COMPOSITE_DELIMITER,
-  CollectionIndexes,
-  IDX_PREFIX,
-  LazyQuery,
-  PersistedCollectionIndex,
-  compositeKey,
-  decodeIdxId,
-  encodeIdxId,
-  isIdxId,
-  withIndexing
-});
-//# sourceMappingURL=index.cjs.map