@noy-db/hub 0.1.0-pre.3

package/dist/indexing/index.cjs

@@ -0,0 +1,736 @@
+"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/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;
+  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) {
+  switch (clause.type) {
+    case "field":
+      return evaluateFieldClause(record, clause);
+    case "filter":
+      return clause.fn(record);
+    case "group":
+      if (clause.op === "and") {
+        for (const child of clause.clauses) {
+          if (!evaluateClause(record, child)) return false;
+        }
+        return true;
+      } else {
+        for (const child of clause.clauses) {
+          if (evaluateClause(record, child)) 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 (#275: 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/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/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