@noy-db/hub 0.7.0 → 0.8.0-pre.0

package/dist/chunk-HBRLNOHL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-lookup/indexing/strategy.ts","../src/with-lookup/indexing/persisted-indexes.ts","../src/with-lookup/indexing/lazy-builder.ts"],"sourcesContent":["/**\n * Strategy seam between core Collection and the optional indexing\n * service. Core imports `IndexingStrategy` and `IndexState` as\n * TYPE-ONLY symbols and `NO_INDEXING` as a tiny runtime stub.\n *\n * The heavy classes — `CollectionIndexes`, `PersistedCollectionIndex`,\n * `LazyQuery` — are only instantiated inside the `withIndexing()`\n * factory under `./active.ts`, which in turn is only reachable through\n * the `@noy-db/hub/indexing` subpath export. A consumer that never\n * imports the subpath ships none of those classes in their bundle\n * (ESM tree-shaking + hub's `\"sideEffects\": false`).\n *\n * @internal\n */\n\nimport type { CollectionIndexes, IndexDef } from './eager-indexes.js'\nimport type { PersistedCollectionIndex } from './persisted-indexes.js'\n\n/**\n * Per-collection container for whatever mirrors the active strategy\n * decided to materialize. Both accessors may return `null` — they do\n * for `NO_INDEXING`, and `getEagerIndexes` returns null in a\n * lazy-mode collection even when indexing is active (lazy uses the\n * persisted mirror instead).\n *\n * `isEnabled` is a cheap guard so collection code can short-circuit\n * the full indexing path without inspecting either mirror.\n *\n * @internal\n */\nexport interface IndexState {\n  readonly isEnabled: boolean\n  getEagerIndexes(): CollectionIndexes | null\n  getPersistedIndexes(): PersistedCollectionIndex | null\n}\n\n/**\n * Factory that builds one `IndexState` per Collection. Called exactly\n * once inside each Collection constructor with the declared\n * `IndexDef[]` and the lazy-mode flag (so lazy collections get the\n * persisted mirror and eager collections get the in-memory one).\n *\n * @internal\n */\nexport interface IndexingStrategy {\n  createState(args: {\n    readonly defs: readonly IndexDef[]\n    readonly lazy: boolean\n  }): IndexState\n}\n\n/**\n * No-indexing stub. Every Collection defaults to this; it returns a\n * cheap `IndexState` whose mirrors are both `null`. Collection code\n * null-checks both accessors and short-circuits, so no indexing code\n * path runs and the heavy classes never arrive in the bundle.\n *\n * @internal\n */\nexport const NO_INDEXING: IndexingStrategy = {\n  createState() {\n    return DISABLED_STATE\n  },\n}\n\nconst DISABLED_STATE: IndexState = {\n  isEnabled: false,\n  getEagerIndexes: () => null,\n  getPersistedIndexes: () => null,\n}\n","/**\n * Persistent, encrypted secondary indexes for lazy-mode collections.\n *\n * Parallel to the in-memory `CollectionIndexes` used by eager mode (see\n * `packages/hub/src/query/indexes.ts`): same logical surface, but entries\n * are materialised as encrypted side-car records (`_idx/<field>/<recordId>`)\n * and bulk-loaded into an in-memory mirror on first query.\n *\n * This module only owns the id-namespace convention, the in-memory mirror,\n * and the typed errors. Write-path integration (PR 2 / ), query-planner\n * dispatch (PR 3 / , PR 4 / ), and the rebuild/reconcile utilities\n * (PR 5 / ) live in other files.\n *\n * See the design spec for the full architecture + threat model.\n */\n\n/**\n * Reserved id prefix for encrypted index side-car records.\n * Matches the existing `_keyring`, `_ledger_deltas/…`, `_meta/handle`\n * conventions inside a collection's id namespace.\n */\nexport const IDX_PREFIX = '_idx/' as const\n\n/**\n * Encode the side-car record id for a (field, recordId) pair.\n *\n * Format: `_idx/<field>/<recordId>` — no escaping. Field names may contain\n * dots (for dotted-path access consistent with eager-mode `readPath`);\n * record ids may contain slashes. The first two slash-separated segments\n * are `_idx` and the field; everything after the *second* slash is the\n * record id verbatim.\n */\nexport function encodeIdxId(field: string, recordId: string): string {\n  return `${IDX_PREFIX}${field}/${recordId}`\n}\n\n/**\n * Decode a side-car id back into `{ field, recordId }`, or `null` if the\n * input is not a well-formed idx id. A well-formed id is:\n *   - prefixed with `_idx/`\n *   - contains a field segment (non-empty, no slashes)\n *   - contains a record-id segment (non-empty, may contain slashes)\n */\nexport function decodeIdxId(id: string): { field: string; recordId: string } | null {\n  if (!id.startsWith(IDX_PREFIX)) return null\n  const rest = id.slice(IDX_PREFIX.length)\n  const firstSlash = rest.indexOf('/')\n  if (firstSlash <= 0) return null\n  const field = rest.slice(0, firstSlash)\n  const recordId = rest.slice(firstSlash + 1)\n  if (recordId.length === 0) return null\n  return { field, recordId }\n}\n\n/**\n * Fast-path predicate for discriminating side-car ids from regular record\n * ids and other reserved namespaces. Used by the hub to filter `list()`\n * results during bulk-load of the in-memory mirror.\n */\nexport function isIdxId(id: string): boolean {\n  return decodeIdxId(id) !== null\n}\n\n/**\n * Sorted-value entry returned by `orderedBy()`. Mirrors the body shape\n * used by the write path — but `orderedBy` emits them already sorted by\n * `value` in the requested direction. Consumers (PR 4 / ) treat the\n * array as immutable and paginate via a numeric offset.\n *\n * **Note on `value`:** as of, this is the ORIGINAL TYPED\n * value (number, Date, boolean, etc.), not the stringified bucket key.\n * That's what lets range predicates and `orderedBy` compare numerically\n * instead of stumbling into `'10' < '2'` on `String(n)`.\n */\nexport interface OrderedEntry {\n  readonly recordId: string\n  readonly value: unknown\n}\n\n/**\n * Bulk-load row shape accepted by `ingest()`. The `value` field is the\n * decrypted index body's `value` field verbatim.\n */\nexport interface IngestRow {\n  readonly recordId: string\n  readonly value: unknown\n}\n\n/**\n * In-memory mirror of the persisted index side-car records for a single\n * collection. Populated by bulk-loading `_idx/<field>/*` ids on first\n * query and maintained incrementally by `Collection.put()` / `.delete()`\n * via `upsert()` / `remove()`.\n *\n * API surface is deliberately parallel to `CollectionIndexes` (eager mode)\n * so the query planner in PR 3/4 can dispatch to either polymorphically.\n *\n * Lifecycle:\n *  - `declare(field)` — accept the field as indexable (idempotent)\n *  - `ingest(field, rows[])` — bulk-load from decrypted index bodies\n *  - `upsert(recordId, field, newValue, previousValue)` — incremental update\n *  - `remove(recordId, field, value)` — incremental remove\n *  - `lookupEqual(field, value)` / `lookupIn(field, values)` — equality reads\n *  - `orderedBy(field, dir)` — sorted iteration for orderBy\n *  - `clear()` — drop all buckets (invalidation / rotation)\n */\n/**\n * Per-field storage: the equality bucket map AND a parallel table of typed\n * values keyed by recordId. The typed table exists so range predicates\n * and `orderedBy` can compare on the original typed value rather\n * than the stringified bucket key — String(10) < String(2) is the classic\n * landmine `stringifyKey` introduces for numeric fields.\n */\ninterface PersistedFieldState {\n  readonly buckets: Map<string, Set<string>>\n  readonly values: Map<string, unknown>\n}\n\n/**\n * Structured index definition. Single-field indexes carry just a field\n * name; composite indexes carry the ordered list of fields and\n * the synthetic `key` (= fields joined by `COMPOSITE_DELIMITER`) used\n * as the bucket-map key and side-car envelope id segment.\n */\nexport type PersistedIndexDef =\n  | { readonly kind: 'single'; readonly field: string; readonly key: string }\n  | { readonly kind: 'composite'; readonly fields: readonly string[]; readonly key: string }\n\n/**\n * Delimiter used to synthesize a composite-index key from an ordered\n * field list. Intentionally a character that is extremely unusual in\n * JavaScript object keys (`|`) so collision with a literal field name\n * is vanishingly rare in practice. Composite declarations whose field\n * names contain `|` are rejected at declare-time with an explicit\n * error.\n */\nexport const COMPOSITE_DELIMITER = '|'\n\nexport function compositeKey(fields: readonly string[]): string {\n  return fields.join(COMPOSITE_DELIMITER)\n}\n\nexport class PersistedCollectionIndex {\n  private readonly indexes = new Map<string, PersistedFieldState>()\n  private readonly defs = new Map<string, PersistedIndexDef>()\n\n  /**\n   * Per-field bucket-key canonicalizer (#677 — lazy twin of #672's\n   * `CollectionIndexes.setCanonicalizer`), registered ONCE via\n   * {@link setCanonicalizer} when the collection wires indexing up\n   * (money-aware via `ViaPipeline.canonicalizeIndexKey`). Consulted by\n   * EVERY bucket-mutation site — `ingest`/`upsert`/`remove` — so bucket\n   * membership is symmetric: a legacy non-canonical stored value (e.g.\n   * `'0100'`) and a canonical one (`'100'`) land in the SAME bucket,\n   * mirroring `eager-indexes.ts`'s `addToIndex`/`removeFromIndex`.\n   */\n  private canonicalize?: (field: string, value: unknown) => string | undefined\n\n  /**\n   * Register the bucket-key canonicalizer. Called once, where the\n   * collection constructs its indexing state — safe to call again (the\n   * closure is simply replaced) but there is normally only one caller.\n   */\n  setCanonicalizer(fn: (field: string, value: unknown) => string | undefined): void {\n    this.canonicalize = fn\n  }\n\n  /**\n   * Declare a single-field index. Subsequent `upsert` / `ingest` calls\n   * populate the in-memory mirror; calls before `declare` are no-ops\n   * (tolerant bulk-load ordering). Idempotent.\n   */\n  declare(field: string): void {\n    if (this.indexes.has(field)) return\n    this.indexes.set(field, { buckets: new Map(), values: new Map() })\n    this.defs.set(field, { kind: 'single', field, key: field })\n  }\n\n  /**\n   * Declare a composite (multi-field) index. The synthetic\n   * key is `fields.join('|')`; it doubles as the in-memory map key and\n   * the `_idx/<key>/<recordId>` side-car field segment. Callers upsert\n   * and lookup via the same `key` as single-field indexes, just with a\n   * tuple value (JSON-stringified for bucketing).\n   */\n  declareComposite(fields: readonly string[]): void {\n    if (fields.length === 0) {\n      throw new Error('declareComposite: fields array must be non-empty')\n    }\n    for (const f of fields) {\n      if (f.includes(COMPOSITE_DELIMITER)) {\n        throw new Error(\n          `declareComposite: field \"${f}\" contains the composite delimiter ` +\n          `\"${COMPOSITE_DELIMITER}\" — pick a different field name or open an ` +\n          `issue to add hash-based composite keys.`,\n        )\n      }\n    }\n    const key = compositeKey(fields)\n    if (this.indexes.has(key)) return\n    this.indexes.set(key, { buckets: new Map(), values: new Map() })\n    this.defs.set(key, { kind: 'composite', fields: [...fields], key })\n  }\n\n  /**\n   * Every declared index's structured definition. Collection walks this\n   * when materialising side-cars on put/delete so it can extract a\n   * single-field value or a composite tuple appropriately.\n   */\n  definitions(): PersistedIndexDef[] {\n    return [...this.defs.values()]\n  }\n\n  /** True if `field` has been declared as indexable on this mirror. */\n  has(field: string): boolean {\n    return this.indexes.has(field)\n  }\n\n  /** All declared field names, in declaration order. */\n  fields(): string[] {\n    return [...this.indexes.keys()]\n  }\n\n  /**\n   * Bulk-load the mirror from decrypted index bodies. Intended to be\n   * called once per field after reading the collection's `_idx/<field>/*`\n   * side-cars. Safe to call twice with the same rows — bucket Sets\n   * deduplicate recordIds. If `field` is not declared, this is a no-op\n   * (tolerates the case where bulk-load runs before `declare()` lands).\n   */\n  ingest(field: string, rows: readonly IngestRow[]): void {\n    const state = this.indexes.get(field)\n    if (!state) return\n    for (const row of rows) {\n      addToState(state, row.recordId, row.value, field, this.canonicalize)\n    }\n  }\n\n  /**\n   * Incrementally update a record's index entry for one field. Called by\n   * `Collection.put()` after the main write succeeds. If\n   * `previousValue` is non-null, the record is removed from the old\n   * bucket first — this is the update path. Pass `null` for fresh adds.\n   * No-op if the field is not declared.\n   */\n  upsert(recordId: string, field: string, newValue: unknown, previousValue: unknown): void {\n    const state = this.indexes.get(field)\n    if (!state) return\n    if (previousValue !== null && previousValue !== undefined) {\n      removeFromState(state, recordId, previousValue, field, this.canonicalize)\n    }\n    addToState(state, recordId, newValue, field, this.canonicalize)\n  }\n\n  /**\n   * Remove a record from the index for one field. Called by\n   * `Collection.delete()`. No-op if the field is not declared or\n   * the record isn't in the bucket. Empty buckets are dropped to keep\n   * the Map clean.\n   */\n  remove(recordId: string, field: string, value: unknown): void {\n    const state = this.indexes.get(field)\n    if (!state) return\n    removeFromState(state, recordId, value, field, this.canonicalize)\n  }\n\n  /**\n   * Drop all bucket data while preserving field declarations. Called on\n   * invalidation (incoming sync changes, keyring rotation) — the next\n   * query re-populates via `ingest`.\n   */\n  clear(): void {\n    for (const state of this.indexes.values()) {\n      state.buckets.clear()\n      state.values.clear()\n    }\n  }\n\n  /**\n   * Equality lookup — return the set of record ids whose `field` matches\n   * `value`. Returns `null` if the field is not declared (caller falls\n   * back to scan or throws `IndexRequiredError`). Returns a shared empty\n   * set if the field is declared but no record matches — that set MUST\n   * NOT be mutated by the caller.\n   *\n   * `value` is bucketed via the plain {@link stringifyKey} — it is NOT\n   * canonicalized here. Callers on a Via-covered field (money) canonicalize\n   * `value` themselves BEFORE calling (see `lazy-builder.ts`'s\n   * `resolveCandidateIds()`, #677) — the SAME caller-canonicalizes split\n   * `eager-indexes.ts`'s `lookupEqual`/`lookupIn` use (see `kernel/query/\n   * builder.ts`'s `candidateRecords()`), so probing here twice never\n   * double-canonicalizes.\n   */\n  lookupEqual(field: string, value: unknown): ReadonlySet<string> | null {\n    const state = this.indexes.get(field)\n    if (!state) return null\n    const key = stringifyKey(value)\n    return state.buckets.get(key) ?? EMPTY_SET\n  }\n\n  /**\n   * Equality lookup that applies the registered canonicalizer to `value`\n   * FIRST — the write side (`ingest`/`upsert` → `addToState`) canonicalizes,\n   * so a probe that does not would miss a Via-covered (e.g. money) match.\n   *\n   * {@link lookupEqual} deliberately keeps the caller-canonicalizes contract\n   * because the query planner has already canonicalized by the time it gets\n   * here (#677). The unique-constraint pre-flight (#1358) has not, and has no\n   * access to the Via pipeline, so it probes through this instead. Returns\n   * `null` when the field is not declared.\n   */\n  probeEqual(field: string, value: unknown): ReadonlySet<string> | null {\n    const state = this.indexes.get(field)\n    if (!state) return null\n    const key = this.canonicalize?.(field, value) ?? stringifyKey(value)\n    return state.buckets.get(key) ?? EMPTY_SET\n  }\n\n  /**\n   * Set lookup — return the union of record ids whose `field` matches any\n   * of `values`. Returns `null` if the field is not declared. Returns a\n   * fresh (non-shared) Set — safe for the caller to mutate. Same\n   * caller-canonicalizes contract as {@link lookupEqual} (#677).\n   */\n  lookupIn(field: string, values: readonly unknown[]): ReadonlySet<string> | null {\n    const state = this.indexes.get(field)\n    if (!state) return null\n    const out = new Set<string>()\n    for (const value of values) {\n      const bucket = state.buckets.get(stringifyKey(value))\n      if (bucket) for (const id of bucket) out.add(id)\n    }\n    return out\n  }\n\n  /**\n   * Range lookup. Return record ids whose indexed value\n   * satisfies the predicate. Comparison happens on the ORIGINAL TYPED\n   * value carried in `state.values` — so numeric `<` sorts numerically,\n   * not lexicographically on `String(n)`. Returns `null` if the field\n   * is not declared.\n   *\n   * Supported ops: `'<'`, `'<='`, `'>'`, `'>='`, `'between'`. For\n   * `'between'`, `value` is `[lo, hi]` and both bounds are inclusive\n   * (matches the eager-mode operator contract in `predicate.ts`).\n   *\n   * NOT canonicalized (#677): this method compares `value` against the\n   * ORIGINAL TYPED `state.values`, not a stringified bucket key, so a\n   * `canonicalizeIndexKey`-shaped (`string | undefined`) result would not\n   * even type-check as a bound here. This does NOT mirror eager mode the\n   * way `lookupEqual`/`lookupIn` do: `moneyIndexProbe` (`via/money/\n   * where.ts`) never emits a range probe, so EAGER mode's `candidateRecords`\n   * never calls an index for a range clause and always scans.\n   *\n   * LAZY mode's `resolveCandidateIds()` (`lazy-builder.ts`) no longer\n   * dispatches a Via-covered (e.g. money) range clause through THIS method\n   * at all (#684) — it enumerates the field's indexed ids via `orderedBy()`\n   * instead and leaves the raw/typed comparison here for the (now\n   * Via-aware) post-filter to redo correctly in scaled-int space. A\n   * NON-via range clause still dispatches through this method exactly as\n   * before — the raw/typed comparison here is correct and sufficient for\n   * fields with no decode-transforming Via binding.\n   */\n  lookupRange(\n    field: string,\n    op: '<' | '<=' | '>' | '>=' | 'between',\n    value: unknown,\n  ): ReadonlySet<string> | null {\n    const state = this.indexes.get(field)\n    if (!state) return null\n    const out = new Set<string>()\n    for (const [recordId, live] of state.values) {\n      if (live === undefined || live === null) continue\n      if (matchesRange(live, op, value)) out.add(recordId)\n    }\n    return out\n  }\n\n  /**\n   * Sorted iteration — return every entry on `field` as an\n   * `OrderedEntry[]`, sorted by the ORIGINAL TYPED value (no more\n   * `'10' < '2'` surprises on numeric fields). Consumers paginate with\n   * a numeric offset. `OrderedEntry.value` is the typed value.\n   */\n  orderedBy(field: string, dir: 'asc' | 'desc'): readonly OrderedEntry[] | null {\n    const state = this.indexes.get(field)\n    if (!state) return null\n    const entries: OrderedEntry[] = []\n    for (const [recordId, value] of state.values) {\n      entries.push({ recordId, value })\n    }\n    entries.sort((a, b) => compareTyped(a.value, b.value))\n    if (dir === 'desc') entries.reverse()\n    return entries\n  }\n}\n\nconst EMPTY_SET: ReadonlySet<string> = new Set()\n\n/**\n * Canonicalize a value into a bucket key. Deliberately identical to the\n * eager-mode `stringifyKey` in `query/indexes.ts` so semantics match. When\n * `query/indexes.ts` changes its coercion rules, update this in lockstep.\n *\n * null / undefined values are NOT indexed — callers who pass them to\n * `upsert` / `remove` short-circuit before reaching this function; the\n * sentinel here exists only to make `lookupEqual(field, null)` return\n * an empty bucket (rather than matching some arbitrary record).\n */\nfunction stringifyKey(value: unknown): string {\n  if (value === null || value === undefined) return '\\0NULL\\0'\n  if (typeof value === 'string') return value\n  if (typeof value === 'number' || typeof value === 'boolean') return String(value)\n  if (value instanceof Date) return value.toISOString()\n  // composite index values are tuple arrays. JSON.stringify\n  // gives a delimiter-safe, order-preserving canonical form so buckets\n  // for `['c-A', '2026-Q1']` and `['c-A', '2026-Q2']` never collide.\n  if (Array.isArray(value)) {\n    const parts: string[] = []\n    for (const el of value) parts.push(stringifyKey(el))\n    return JSON.stringify(parts)\n  }\n  return '\\0OBJECT\\0'\n}\n\nfunction addToState(\n  state: PersistedFieldState,\n  recordId: string,\n  value: unknown,\n  field: string,\n  canonicalize?: (field: string, value: unknown) => string | undefined,\n): void {\n  if (value === null || value === undefined) return\n  const key = canonicalize?.(field, value) ?? stringifyKey(value)\n  let bucket = state.buckets.get(key)\n  if (!bucket) {\n    bucket = new Set()\n    state.buckets.set(key, bucket)\n  }\n  bucket.add(recordId)\n  state.values.set(recordId, value)\n}\n\nfunction removeFromState(\n  state: PersistedFieldState,\n  recordId: string,\n  value: unknown,\n  field: string,\n  canonicalize?: (field: string, value: unknown) => string | undefined,\n): void {\n  if (value === null || value === undefined) return\n  const key = canonicalize?.(field, value) ?? stringifyKey(value)\n  const bucket = state.buckets.get(key)\n  if (bucket) {\n    bucket.delete(recordId)\n    if (bucket.size === 0) state.buckets.delete(key)\n  }\n  state.values.delete(recordId)\n}\n\n/**\n * Range-predicate comparator. Runs on the ORIGINAL TYPED value so numeric\n * fields sort numerically (not lexicographically on `String(n)`). ISO-8601\n * date strings already sort correctly lexicographically; Date instances\n * compare via `getTime()` before the string branch to keep the contract\n * honest regardless of which form survived serialization.\n */\nfunction matchesRange(\n  live: unknown,\n  op: '<' | '<=' | '>' | '>=' | 'between',\n  bound: unknown,\n): boolean {\n  if (op === 'between') {\n    if (!Array.isArray(bound) || bound.length !== 2) return false\n    return compareTyped(live, bound[0]) >= 0 && compareTyped(live, bound[1]) <= 0\n  }\n  const cmp = compareTyped(live, bound)\n  switch (op) {\n    case '<':  return cmp < 0\n    case '<=': return cmp <= 0\n    case '>':  return cmp > 0\n    case '>=': return cmp >= 0\n  }\n}\n\nfunction compareTyped(a: unknown, b: unknown): number {\n  if (a === undefined || a === null) return b === undefined || b === null ? 0 : 1\n  if (b === undefined || b === null) return -1\n  if (typeof a === 'number' && typeof b === 'number') return a - b\n  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime()\n  if (typeof a === 'string' && typeof b === 'string') return a < b ? -1 : a > b ? 1 : 0\n  if (typeof a === 'boolean' && typeof b === 'boolean') {\n    return a === b ? 0 : a ? 1 : -1\n  }\n  // Mixed/unsupported types: deliberately treat as equal so sort stays\n  // stable. Matches the eager-mode `compareValues` contract in\n  // builder.ts — we don't silently coerce arbitrary objects to strings\n  // (which would be meaningless) nor throw (which would be hostile).\n  return 0\n}\n","/**\n * Lazy-mode query builder.\n *\n * Companion to `Query<T>` in `builder.ts`, but built for collections in lazy\n * mode where `snapshot()` is unavailable — records live in the adapter and\n * are pulled on demand. Dispatches through `PersistedCollectionIndex` to\n * resolve a candidate record-id set, then decrypts only those records.\n *\n * Scope:\n *   - `.where(field, '==' | 'in', value)` — dispatched through the index\n *   - `.where(field, other-op, value)` — evaluated against the decrypted\n *     candidate set (non-indexed ops still require the field to be indexed\n *     — we need SOMETHING to scope the candidate set)\n *   - `.orderBy(field, dir?)` — dispatched through `orderedBy` when no\n *     `==`/`in` clause is present; otherwise applied as an in-memory sort\n *     over the candidate set\n *   - `.limit(n)` / `.offset(n)` — page slice after filtering\n *   - `.toArray()` / `.first()` / `.count()` — terminals\n *\n * Every field referenced by a where or orderBy clause MUST be indexed;\n * otherwise `toArray()` throws `IndexRequiredError`. This is deliberate:\n * silent scan-fallback would hide the very performance cliff that lazy-mode\n * indexes exist to prevent (see `docs/architecture.md` §indexes).\n */\n\nimport type { Clause, FieldClause, Operator } from '../../kernel/query/predicate.js'\nimport { evaluateClause, normalizeMatches, normalizeSubqueryOperand, readPath } from '../../kernel/query/predicate.js'\nimport type { PersistedCollectionIndex } from './persisted-indexes.js'\nimport { IndexRequiredError, FieldNotQueryableError } from '../../kernel/errors.js'\nimport type { QueryField } from '../../kernel/types.js'\nimport type { ViaPipeline } from '../../kernel/via/pipeline.js'\nimport { isViaPrefixProbe } from '../../kernel/via/index.js'\n\nexport interface LazyOrderBy {\n  readonly field: string\n  readonly direction: 'asc' | 'desc'\n}\n\n/**\n * Source abstraction the LazyQuery runs against. Collection implements it.\n * Kept minimal so the builder stays test-friendly.\n */\nexport interface LazyQuerySource<T> {\n  readonly collectionName: string\n  readonly persistedIndexes: PersistedCollectionIndex\n  /**\n   * Per-field bucket-key canonicalizer (#677 — lazy twin of the eager\n   * `candidateRecords()` probe-resolution in `kernel/query/builder.ts`).\n   * Consulted in `resolveCandidateIds()` for `==`/`in` clause values\n   * BEFORE calling `lookupEqual`/`lookupIn`, so a mixed-era stored value\n   * (money) probes the SAME canonical bucket the write path now\n   * populates. A narrow closure — not the whole `ViaPipeline` — keeps\n   * the with-lookup/kernel seam thin. `undefined` (no via, or no binding\n   * covers the field) is the common case: falls back to the raw value,\n   * unchanged from today.\n   */\n  canonicalizeIndexKey?(field: string, value: unknown): string | undefined\n  /** Ensure `_idx/<field>/*` side-cars have been bulk-loaded into the mirror. */\n  ensurePersistedIndexesLoaded(): Promise<void>\n  /**\n   * Decrypt one record by id in RAW (pre-`present()`, stored-form) shape,\n   * or return null if it's gone (#684 — the raw-fetch seam). Used by the\n   * post-filter (`toArray()`) so a `clause.via.evaluate` (e.g. money) sees\n   * the same operand/actual-value space as eager's `filterRecords` — the\n   * DECODED form (e.g. money's canonical decimal) is only materialized\n   * for survivors, via {@link decodeRecord}.\n   */\n  getRawRecord(id: string): Promise<unknown>\n  /**\n   * Apply this collection's locale/virtual-field decode (`present()`) to a\n   * RAW record already known to match — the output-side twin of\n   * {@link getRawRecord}. Mirrors eager's `Query.decodeVia`.\n   */\n  decodeRecord(record: unknown): Promise<T>\n  /**\n   * This collection's compiled Via pipeline (money, i18n, …), read lazily\n   * (a method, not a captured value) so a late `_setVia` (#666) is honored\n   * — same closure discipline as {@link canonicalizeIndexKey}. `undefined`\n   * when the collection has no Via-covered fields.\n   */\n  via(): ViaPipeline | undefined\n}\n\ninterface LazyPlan {\n  readonly clauses: readonly FieldClause[]\n  readonly orderBy: readonly LazyOrderBy[]\n  readonly limit: number | undefined\n  readonly offset: number\n}\n\nconst EMPTY_PLAN: LazyPlan = {\n  clauses: [],\n  orderBy: [],\n  limit: undefined,\n  offset: 0,\n}\n\nexport class LazyQuery<T, S extends keyof T = never, Q extends keyof T & string = never> {\n  private readonly source: LazyQuerySource<T>\n  private readonly plan: LazyPlan\n\n  constructor(source: LazyQuerySource<T>, plan: LazyPlan = EMPTY_PLAN) {\n    this.source = source\n    this.plan = plan\n  }\n\n  where<V>(field: QueryField<T, S, Q>, op: Operator, value: V): LazyQuery<T, S, Q> {\n    // A Via-covered field (e.g. money) compares in major units, BigInt-exact\n    // in scaled space — same build-time operand rewrite + `clause.via`\n    // attachment as `Query.where()` (`kernel/query/builder.ts`) and\n    // `ScanBuilder.where()` (`kernel/query/scan-builder.ts`). Before #684\n    // this method built a bare clause with no `clause.via` at all, so the\n    // post-filter fell through to the generic (non-Via-aware) comparison —\n    // see `toArray()` below for the raw-record post-filter this feeds.\n    const via = this.source.via()\n    // Consults the Via pipeline's posture BEFORE building a clause — same\n    // gate as `Query.where()` (builder.ts) / `ScanBuilder.where()`\n    // (scan-builder.ts): a field whose posture is `queryable: 'none'`\n    // (e.g. a `blobFields` slot) throws `FieldNotQueryableError` here, at\n    // the call site, instead of building a bare clause that later surfaces\n    // as a deferred `IndexRequiredError` from `toArray()`.\n    if (via?.postureFor(field)?.queryable === 'none') throw new FieldNotQueryableError(field)\n    // #1357: a 'matches' operand is refused-or-normalized HERE, at the call\n    // site — an anchored literal prefix lowers to `startsWith` (taking the\n    // sorted index), anything else serializes to `{ source, flags }` so the\n    // pattern folds into an MV's queryHash. Every other operator is identity.\n    // #1351: a SUBQUERY operand of `in`/`!in` resolves to its id array here,\n    // at build time — same normalization order as `Query.where()`, so all\n    // three builders turn the same call into the same clause.\n    const { op: sop, value: sval, subquery } = normalizeSubqueryOperand(op, value)\n    const { op: mop, value: mval } = normalizeMatches(sop, sval)\n    const viaClause = via?.buildClause(field, mop, mval)\n    const clause: FieldClause = viaClause\n      ? {\n          type: 'field',\n          field,\n          op: mop,\n          value: mval,\n          ...(subquery ? { subquery } : {}),\n          via: {\n            brand: viaClause.brand,\n            payload: viaClause.payload,\n            evaluate: (actual: unknown, evalOp: string) => via!.evaluateClause(viaClause, actual, evalOp),\n            indexValue: via!.indexProbe(viaClause, mop),\n          },\n        }\n      : { type: 'field', field, op: mop, value: mval, ...(subquery ? { subquery } : {}) }\n    return new LazyQuery<T, S, Q>(this.source, {\n      ...this.plan,\n      clauses: [...this.plan.clauses, clause],\n    })\n  }\n\n  orderBy(field: QueryField<T, S>, direction: 'asc' | 'desc' = 'asc'): LazyQuery<T, S, Q> {\n    return new LazyQuery<T, S, Q>(this.source, {\n      ...this.plan,\n      orderBy: [...this.plan.orderBy, { field, direction }],\n    })\n  }\n\n  limit(n: number): LazyQuery<T, S, Q> {\n    return new LazyQuery<T, S, Q>(this.source, { ...this.plan, limit: n })\n  }\n\n  offset(n: number): LazyQuery<T, S, Q> {\n    return new LazyQuery<T, S, Q>(this.source, { ...this.plan, offset: n })\n  }\n\n  /**\n   * **ASYNC here, unlike `Query.toArray()` (#1413).** Same method name, a\n   * different contract, because the surface underneath differs: this one\n   * genuinely fetches through the persisted `_idx/` side-car, so it genuinely awaits. `Query`'s terminal reads an\n   * already-decrypted in-memory cache and returns `T[]` synchronously.\n   */\n  async toArray(): Promise<T[]> {\n    await this.source.ensurePersistedIndexesLoaded()\n\n    const touchedFields = collectTouchedFields(this.plan)\n    const missingFields = touchedFields.filter(f => !isFieldIndexed(f, this.source.persistedIndexes))\n    if (missingFields.length > 0) {\n      throw new IndexRequiredError({\n        collection: this.source.collectionName,\n        touchedFields,\n        missingFields,\n      })\n    }\n\n    const candidateIds = this.resolveCandidateIds()\n    if (candidateIds === null) {\n      // No usable driver — every touched field is indexed but no clause\n      // pins the candidate set. This happens when a query only uses\n      // operators other than `==`/`in` and no `orderBy` clause is\n      // present — we refuse to enumerate the whole index, because that\n      // defeats the purpose of lazy mode.\n      throw new IndexRequiredError({\n        collection: this.source.collectionName,\n        touchedFields,\n        missingFields: touchedFields,\n      })\n    }\n\n    // #684: post-filter the RAW record (mirrors eager's filterRecords on the\n    // raw snapshot) so `clause.via.evaluate` sees the same stored-form\n    // operand/actual-value space `buildClause` quantized into at where()\n    // time. Survivors stay RAW here — #695 sorts them via-aware in that\n    // same stored-form space (mirroring eager's `sortRecords(result, ...,\n    // source.via, ...)` in `kernel/query/builder.ts`) before anything is\n    // decoded (`present()`).\n    const survivors: T[] = []\n    for (const id of candidateIds) {\n      const raw = await this.source.getRawRecord(id)\n      if (raw === null) continue\n      if (!matchesAll(raw, this.plan.clauses)) continue\n      survivors.push(raw as T)\n    }\n\n    // #695: sort the RAW survivors via-aware — a money field's stored form\n    // (scaled-integer string) sorts lexicographically wrong under the\n    // generic comparator ('10.00' < '2.00' once decoded); `via.compareForOrder`\n    // compares in the correct (BigInt-exact scaled) space, same as eager.\n    const sorted = this.plan.orderBy.length > 0\n      ? sortRecords(survivors, this.plan.orderBy, this.source.via())\n      : survivors\n\n    const offset = this.plan.offset > 0 ? this.plan.offset : 0\n    const page = this.plan.limit === undefined\n      ? sorted.slice(offset)\n      : sorted.slice(offset, offset + this.plan.limit)\n\n    // Decode only the final page — fewer decodes than the pre-#695 code,\n    // which decoded every survivor before sorting/slicing.\n    return Promise.all(page.map(r => this.source.decodeRecord(r)))\n  }\n\n  async first(): Promise<T | null> {\n    const out = await this.limit(1).toArray()\n    return out.length > 0 ? out[0]! : null\n  }\n\n  async count(): Promise<number> {\n    const out = await this.toArray()\n    return out.length\n  }\n\n  /**\n   * Resolve the candidate record-id set to decrypt. Returns null when the\n   * query has no usable driver — no `==`/`in` clause and no `orderBy`\n   * clause that can scope the scan. Callers interpret null as\n   * IndexRequiredError (see `toArray`).\n   */\n  /**\n   * #1407 — refuse a NULLISH `==`/`in` operand in lazy mode instead of\n   * answering it with the empty bucket.\n   *\n   * `addToState` skips nullish values outright, so a record whose value IS\n   * nullish is absent from the persisted index. `lookupEqual` then returns the\n   * empty `\\0NULL\\0` bucket, and `[]` reads as \"no rows match\" when the truth\n   * is \"the matching rows are not visible from here\". Measured on an indexed\n   * field: `where('tag','==',null)` returned `[]` from lazy while the eager\n   * scan returned the row.\n   *\n   * ⛔ There is no superset to fall back to, which is what makes this\n   * different from every other unaddressable-operand case in this function.\n   * Enumerating the field's indexed ids returns a set that EXCLUDES every\n   * match — the opposite of a superset — so \"enumerate and post-filter\", the\n   * move the via-declined, via-`in`, via-RANGE and #1355 prefix branches all\n   * make, is unavailable here.\n   *\n   * ⭐ AN OBJECT OPERAND NEEDS NOTHING, and the first draft of this fix gave it\n   * something. `\\0OBJECT\\0` holds every object-valued record, only an object\n   * can `===` an object operand, and `toArray()`'s post-filter applies the\n   * exact predicate — so the bucket is already a sound superset, and a TIGHTER\n   * one than `orderedBy` would produce. Routing it through `orderedBy` was a\n   * silent perf regression dressed as a correctness fix. Verified by deleting\n   * the guard entirely: only the nullish cases fail.\n   */\n  private refuseNullishProbe(field: string, probe: unknown): void {\n    if (probe !== null && probe !== undefined) return\n    throw new IndexRequiredError({\n      collection: this.source.collectionName,\n      touchedFields: [field],\n      missingFields: [],\n      reason:\n        `lazy mode cannot answer where(\"${field}\", …, null | undefined) — the persisted ` +\n        'index never stores nullish values, so the records that match are absent from it ' +\n        'and no candidate set can contain them. This is not a missing index: declaring ' +\n        `one on \"${field}\" would not help. Use collection.scan() and filter, or store an ` +\n        'explicit sentinel value instead of null.',\n    })\n  }\n\n  private resolveCandidateIds(): readonly string[] | null {\n    const idx = this.source.persistedIndexes\n\n    // prefer a composite index when the query's `==`\n    // clauses cover every field of one declared composite. The\n    // composite mirror lookup is O(matches) vs single-field +\n    // post-filter on the decrypted candidate set.\n    const eqMap = new Map<string, unknown>()\n    const viaFields = new Set<string>()\n    for (const clause of this.plan.clauses) {\n      if (clause.op === '==') {\n        eqMap.set(clause.field, clause.value)\n        // #696: the composite mirror buckets on `stringifyKey(tuple)` built\n        // from the RAW clause values — the per-field money canonicalizer\n        // (`canonicalizeIndexKey`) only ever keys off a single field name,\n        // never the joined composite key, so a Via-covered field's tuple\n        // slot never lands in the same bucket a canonical write produced.\n        // Track which `==` fields are Via-covered so the composite branch\n        // below can skip them and fall through to the single-field\n        // Via-aware path (already correct for money) instead.\n        if (clause.via) viaFields.add(clause.field)\n      }\n    }\n    if (eqMap.size >= 2) {\n      for (const def of idx.definitions()) {\n        if (def.kind !== 'composite') continue\n        if (def.fields.some(f => viaFields.has(f))) continue\n        if (def.fields.every(f => eqMap.has(f))) {\n          const tuple = def.fields.map(f => eqMap.get(f))\n          const ids = idx.lookupEqual(def.key, tuple)\n          if (ids) return [...ids]\n        }\n      }\n    }\n\n    for (const clause of this.plan.clauses) {\n      // #1355 — a PREFIX-COVER probe (geo's `near`). Lazy's persisted mirror\n      // has no `startsWith` slice, so there is no prefix fast path to take\n      // here; enumerate the field's indexed ids and let the (via-aware, #684)\n      // post-filter in `toArray()` apply the exact predicate. Same shape as\n      // the via-RANGE branch below, and for the same reason: a candidate\n      // SUPERSET scoped to indexed ids is sound, while refusing the query\n      // outright — which is what the tail of this function does for an op no\n      // branch claims (`null` → `IndexRequiredError`) — would be a lazy-only\n      // behaviour gap against eager mode.\n      //\n      // Placed INSIDE this loop rather than the composite pre-pass above, so\n      // a more selective `==` clause on another field still wins first: the\n      // loop takes the first clause that resolves, in clause order.\n      if (clause.via && isViaPrefixProbe(clause.via.indexValue)) {\n        const entries = idx.orderedBy(clause.field, 'asc')\n        if (entries) return entries.map(e => e.recordId)\n        continue\n      }\n      if (clause.op === '==') {\n        if (clause.via) {\n          // #684: prefer `clause.via.indexValue` — the same STORED-form\n          // probe operand eager's `candidateRecords()` resolves first\n          // (`kernel/query/builder.ts`). `undefined` means the binding\n          // declined to probe this op/payload (e.g. money multi-mode) — no\n          // sound equality bucket exists. Eager's `candidateRecords()`\n          // handles this by skipping the index-eligibility check for the\n          // clause and falling back to a full scan (`builder.ts:1176`); the\n          // lazy equivalent (#684 review-fix 2) is the same move the RANGE branch\n          // below already makes — enumerate the field's full indexed id\n          // set via `orderedBy` and let the (now via-aware) post-filter in\n          // `toArray()` decide, instead of throwing `IndexRequiredError`.\n          if (clause.via.indexValue === undefined) {\n            const entries = idx.orderedBy(clause.field, 'asc')\n            if (entries) return entries.map(e => e.recordId)\n            continue\n          }\n          const ids = idx.lookupEqual(clause.field, clause.via.indexValue)\n          if (ids) return [...ids]\n          continue\n        }\n        // #677: canonicalize the probe value BEFORE the lookup — same\n        // \"resolve before lookupEqual\" shape as eager's `candidateRecords()`,\n        // but through the narrower `canonicalizeIndexKey` seam, used only on\n        // this NON-via path. `undefined` (no via coverage) falls back to the\n        // raw clause value, unchanged from today.\n        const probe = this.source.canonicalizeIndexKey?.(clause.field, clause.value) ?? clause.value\n        this.refuseNullishProbe(clause.field, probe)\n        const ids = idx.lookupEqual(clause.field, probe)\n        if (ids) return [...ids]\n      } else if (clause.op === 'in' && Array.isArray(clause.value)) {\n        if (clause.via) {\n          // Same #684 review-fix 2 fallback as the `==` branch above — a via\n          // payload that declines to probe (e.g. money multi-mode) still\n          // has a sound candidate superset via `orderedBy`.\n          if (clause.via.indexValue === undefined) {\n            const entries = idx.orderedBy(clause.field, 'asc')\n            if (entries) return entries.map(e => e.recordId)\n            continue\n          }\n          if (!Array.isArray(clause.via.indexValue)) continue\n          const ids = idx.lookupIn(clause.field, clause.via.indexValue)\n          if (ids) return [...ids]\n          continue\n        }\n        const probes = clause.value.map(v => this.source.canonicalizeIndexKey?.(clause.field, v) ?? v)\n        // #1407 — ONE nullish element makes the whole answer incomplete, and a\n        // partial answer is the thing with no symptom. Object elements need\n        // nothing: their bucket is already a sound superset (see\n        // `refuseNullishProbe`).\n        // ⚠️ findINDEX, not find: `find` returns the element, and the element\n        // being looked for can BE `undefined`, so `!== undefined` on the result\n        // reads false exactly when the match was a hit.\n        const nullishAt = probes.findIndex((p) => p === null || p === undefined)\n        if (nullishAt >= 0) this.refuseNullishProbe(clause.field, probes[nullishAt])\n        const ids = idx.lookupIn(clause.field, probes)\n        if (ids) return [...ids]\n      } else if (isRangeOp(clause.op)) {\n        if (clause.via) {\n          // #684: a Via-covered range clause (e.g. money) cannot trust\n          // `lookupRange` — it compares the ORIGINAL TYPED stored value,\n          // wrong space for a binding whose stored form isn't directly\n          // orderable that way (money: BigInt-exact scaled-int compare).\n          // No binding emits a range `indexProbe` either (see\n          // `moneyIndexProbe`), so there's no sound bucket lookup at all.\n          // Enumerate the field's full indexed id set via `orderedBy` — the\n          // same superset a scan would consider, just scoped to indexed ids\n          // — and let the (now via-aware) post-filter in `toArray()` apply\n          // the correct scaled-space comparison. Replaces the old\n          // \"always trust lookupRange, no scan fallback\" gap.\n          const entries = idx.orderedBy(clause.field, 'asc')\n          if (entries) return entries.map(e => e.recordId)\n          continue\n        }\n        // range predicates on a NON-via indexed field dispatch through\n        // `lookupRange`, which compares on the original typed value (no\n        // numeric-lexicographic landmines).\n        const ids = idx.lookupRange(clause.field, clause.op, clause.value)\n        if (ids) return [...ids]\n      }\n    }\n\n    // No equality/range driver — try to scope via orderBy.\n    if (this.plan.orderBy.length > 0) {\n      const primary = this.plan.orderBy[0]!\n      const entries = idx.orderedBy(primary.field, primary.direction)\n      if (entries) return entries.map(e => e.recordId)\n    }\n\n    return null\n  }\n}\n\n/**\n * True if the given field name is covered by either a single-field\n * index or appears as a component of a declared composite index.\n * Composite coverage is sufficient for the missing-field check because\n * composite writes also maintain the in-memory mirror — the range /\n * orderBy / single-equality lookup paths fall through to decrypted\n * candidates that still get post-filtered by the composite clause.\n */\nfunction isFieldIndexed(field: string, idx: PersistedCollectionIndex): boolean {\n  if (idx.has(field)) return true\n  for (const def of idx.definitions()) {\n    if (def.kind === 'composite' && def.fields.includes(field)) return true\n  }\n  return false\n}\n\nfunction isRangeOp(op: Operator): op is '<' | '<=' | '>' | '>=' | 'between' {\n  return op === '<' || op === '<=' || op === '>' || op === '>=' || op === 'between'\n}\n\nfunction collectTouchedFields(plan: LazyPlan): string[] {\n  const seen = new Set<string>()\n  for (const c of plan.clauses) seen.add(c.field)\n  for (const o of plan.orderBy) seen.add(o.field)\n  return [...seen]\n}\n\nfunction matchesAll(record: unknown, clauses: readonly Clause[]): boolean {\n  for (const c of clauses) {\n    if (!evaluateClause(record, c)) return false\n  }\n  return true\n}\n\nfunction sortRecords<T>(records: T[], orderBy: readonly LazyOrderBy[], via?: ViaPipeline): T[] {\n  return [...records].sort((a, b) => {\n    for (const { field, direction } of orderBy) {\n      const av = readPath(a, field)\n      const bv = readPath(b, field)\n      // #695: a Via-covered field (e.g. money) may store a representation\n      // the generic comparator would order wrong — ask the pipeline for an\n      // exact ordering first, same as eager's `sortRecords` in\n      // `kernel/query/builder.ts`. `undefined` (no via, or the field isn't\n      // covered) falls back to the generic comparator, unchanged from today.\n      const viaCmp = via?.compareForOrder(field, av, bv)\n      const cmp = viaCmp !== undefined ? viaCmp : compareValues(av, bv)\n      if (cmp !== 0) return direction === 'asc' ? cmp : -cmp\n    }\n    return 0\n  })\n}\n\nfunction compareValues(a: unknown, b: unknown): number {\n  if (a === undefined || a === null) return b === undefined || b === null ? 0 : 1\n  if (b === undefined || b === null) return -1\n  if (typeof a === 'number' && typeof b === 'number') return a - b\n  if (typeof a === 'string' && typeof b === 'string') return a < b ? -1 : a > b ? 1 : 0\n  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime()\n  return 0\n}\n"],"mappings":"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","names":["ids"]}

package/dist/chunk-HLEK5VAN.js

@@ -0,0 +1,275 @@
+import {
+  UnsafePatternError
+} from "./chunk-244VXYPG.js";
+
+// src/kernel/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.via) return clause.via.evaluate(actual, op);
+  return evaluateOperator(actual, op, value);
+}
+function evaluateOperator(actual, op, value) {
+  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 "!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 "matches": {
+      if (typeof actual !== "string") return false;
+      const re = matchesRegExp(value);
+      return re !== null && re.test(actual);
+    }
+    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;
+    }
+    case "near":
+      return false;
+    default: {
+      const _exhaustive = op;
+      void _exhaustive;
+      return false;
+    }
+  }
+}
+function isIdOperandSource(value) {
+  return typeof value === "object" && value !== null && typeof value._asIdOperand === "function";
+}
+function normalizeSubqueryOperand(op, value) {
+  if (op !== "in" && op !== "!in") return { op, value };
+  if (!isIdOperandSource(value)) return { op, value };
+  const { ids, from } = value._asIdOperand();
+  return { op, value: [...ids], subquery: { from, ids: ids.length } };
+}
+var MATCHES_MAX_SOURCE = 200;
+var MATCHES_MAX_GROUP_DEPTH = 5;
+var MATCHES_MAX_QUANTIFIERS = 20;
+function isQuantifier(c) {
+  return c === "*" || c === "+" || c === "?" || c === "{";
+}
+function assertSafePattern(source, flags) {
+  if (source.length > MATCHES_MAX_SOURCE) {
+    throw new UnsafePatternError(
+      `where(..., 'matches', ...): pattern is ${source.length} characters, over the ${MATCHES_MAX_SOURCE}-character budget. Narrow the pattern, or use .filter(fn) and accept that it cannot use an index.`
+    );
+  }
+  for (const f of flags) {
+    if (f === "g" || f === "y") {
+      throw new UnsafePatternError(
+        `where(..., 'matches', ...): the '${f}' flag makes RegExp.test() stateful across records and would silently drop rows. Remove it from /${source}/${flags}.`
+      );
+    }
+  }
+  let quantifiers = 0;
+  let inClass = false;
+  let escaped = false;
+  const groupQuantified = [];
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") {
+      inClass = true;
+      continue;
+    }
+    if (c === "(") {
+      groupQuantified.push(false);
+      if (groupQuantified.length > MATCHES_MAX_GROUP_DEPTH) {
+        throw new UnsafePatternError(
+          `where(..., 'matches', ...): group nesting exceeds the depth-${MATCHES_MAX_GROUP_DEPTH} budget in /${source}/. Flatten the pattern.`
+        );
+      }
+      if (source[i + 1] === "?") i++;
+      continue;
+    }
+    if (c === ")") {
+      const bodyQuantified = groupQuantified.pop() ?? false;
+      if (bodyQuantified && isQuantifier(source[i + 1])) {
+        throw new UnsafePatternError(
+          `where(..., 'matches', ...): nested quantifier at index ${i + 1} of /${source}/ \u2014 a quantified group whose body also quantifies backtracks exponentially. Rewrite it, or use .filter(fn).`
+        );
+      }
+      continue;
+    }
+    if (isQuantifier(c)) {
+      quantifiers++;
+      if (quantifiers > MATCHES_MAX_QUANTIFIERS) {
+        throw new UnsafePatternError(
+          `where(..., 'matches', ...): more than ${MATCHES_MAX_QUANTIFIERS} quantifiers in /${source}/. Narrow the pattern, or use .filter(fn).`
+        );
+      }
+      if (groupQuantified.length > 0) groupQuantified[groupQuantified.length - 1] = true;
+    }
+  }
+}
+function escapeRegExpChar(c) {
+  return /[.*+?^${}()|[\]\\/]/.test(c) ? `\\${c}` : c;
+}
+function likeToSource(like) {
+  let out = "^";
+  for (let i = 0; i < like.length; i++) {
+    const c = like[i];
+    if (c === "\\") {
+      const next = like[i + 1];
+      if (next === void 0) {
+        throw new UnsafePatternError(
+          `where(..., 'matches', ...): LIKE pattern "${like}" ends with a dangling escape.`
+        );
+      }
+      i++;
+      out += escapeRegExpChar(next);
+      continue;
+    }
+    if (c === "%") {
+      out += "[\\s\\S]*";
+      continue;
+    }
+    if (c === "_") {
+      out += "[\\s\\S]";
+      continue;
+    }
+    out += escapeRegExpChar(c);
+  }
+  return `${out}$`;
+}
+function literalPrefixAnchor(source, flags) {
+  if (flags !== "" || !source.startsWith("^")) return null;
+  const rest = source.slice(1);
+  return /^[^\\^$.|?*+()[\]{}]*$/.test(rest) ? rest : null;
+}
+function normalizeMatches(op, value) {
+  if (op !== "matches") return { op, value };
+  let source;
+  let flags;
+  if (typeof value === "string") {
+    if (/^[^%_\\]*%$/.test(value)) return { op: "startsWith", value: value.slice(0, -1) };
+    source = likeToSource(value);
+    flags = "";
+  } else if (value instanceof RegExp) {
+    source = value.source;
+    flags = value.flags;
+  } else {
+    throw new UnsafePatternError(
+      `where(..., 'matches', ...) needs a RegExp or a LIKE string; received ${typeof value}.`
+    );
+  }
+  assertSafePattern(source, flags);
+  const prefix = literalPrefixAnchor(source, flags);
+  if (prefix !== null) return { op: "startsWith", value: prefix };
+  return { op: "matches", value: { source, flags } };
+}
+var MATCHES_CACHE = /* @__PURE__ */ new Map();
+var MATCHES_CACHE_MAX = 256;
+function matchesRegExp(value) {
+  const spec = value instanceof RegExp ? { source: value.source, flags: value.flags } : value;
+  if (typeof spec !== "object" || spec === null) return null;
+  const { source, flags } = spec;
+  if (typeof source !== "string" || typeof flags !== "string") return null;
+  const safeFlags = flags.replace(/[gy]/g, "");
+  const key = `${safeFlags} ${source}`;
+  const cached = MATCHES_CACHE.get(key);
+  if (cached !== void 0) return cached;
+  let re;
+  try {
+    re = new RegExp(source, safeFlags);
+  } catch {
+    return null;
+  }
+  if (MATCHES_CACHE.size >= MATCHES_CACHE_MAX) MATCHES_CACHE.clear();
+  MATCHES_CACHE.set(key, re);
+  return re;
+}
+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;
+      }
+  }
+}
+function hasFnClause(clauses) {
+  for (const c of clauses) {
+    if (c.type === "filter" || c.type === "wherePredicate") return true;
+    if (c.type === "group" && hasFnClause(c.clauses)) return true;
+  }
+  return false;
+}
+
+export {
+  readPath,
+  evaluateFieldClause,
+  evaluateOperator,
+  normalizeSubqueryOperand,
+  normalizeMatches,
+  evaluateClause,
+  hasFnClause
+};
+//# sourceMappingURL=chunk-HLEK5VAN.js.map

package/dist/chunk-HLEK5VAN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/kernel/query/predicate.ts"],"sourcesContent":["/**\n * Operator implementations for the query DSL.\n *\n * All predicates run client-side, AFTER decryption — they never see ciphertext.\n * Field clauses over a Via-covered field (e.g. money) carry their own\n * evaluator closure (see {@link FieldClause.via}), so this module has no\n * dependency on any Via feature's implementation — still tree-shakeable.\n */\n\nimport { UnsafePatternError } from '../errors.js'\n\n/** Comparison operators supported by the where() builder. */\nexport type Operator =\n  | '=='\n  | '!='\n  | '<'\n  | '<='\n  | '>'\n  | '>='\n  | 'in'\n  /**\n   * Set non-membership (#1351) — the anti-semi-join half of `in`.\n   *\n   * ⚠️ A NULLISH stored value MATCHES `!in`, deliberately: this module\n   * treats an absent field as \"not equal\" everywhere (`!=`, and money's\n   * `evaluateMoneyClause`), so `!in` follows. SQL's `NOT IN (…)` is\n   * three-valued and would EXCLUDE the row; noy-db has no NULL logic and\n   * inventing one here would make `!in` disagree with `!=` on the same\n   * record. Spell the SQL behaviour as `.where(f, '!=', undefined)` before\n   * the `!in`.\n   *\n   * ⛔ Never index-served. A hash bucket answers \"which ids hold this\n   * value\"; a negation needs the complement, which is the whole\n   * collection minus a bucket — so `!in` always falls to the scan, the\n   * same as `!=`.\n   */\n  | '!in'\n  | 'contains'\n  | 'startsWith'\n  | 'between'\n  /**\n   * Regex / SQL-LIKE pattern match (#1357). Operand: a `RegExp`, or a\n   * LIKE string. Normalized at `where()` time by {@link normalizeMatches}\n   * — an anchored literal prefix is LOWERED to `startsWith` (so it takes\n   * the sorted index), everything else is stored as `{ source, flags }`\n   * and evaluated per record.\n   */\n  | 'matches'\n  /**\n   * Proximity (#1355) — operand `{ lat, lng, radiusKm }`, matching a\n   * record whose stored point is within `radiusKm` great-circle\n   * kilometres of the centre.\n   *\n   * ⛔ MEANINGFUL ONLY OVER A `geo()`-DECLARED FIELD. Every other field\n   * has no point to measure, so the case below returns false rather than\n   * guessing at a `{lat,lng}`-shaped object — the geo binding owns both\n   * the comparison and the index cover, and an undeclared field has\n   * neither. `where()` is where a malformed operand throws; here a\n   * type mismatch is simply \"no match\", as it is for every operator.\n   */\n  | 'near'\n\n/**\n * A single field comparison clause inside a query plan.\n * Plans are JSON-serializable, so this type uses primitives only.\n */\nexport interface FieldClause {\n  readonly type: 'field'\n  readonly field: string\n  readonly op: Operator\n  readonly value: unknown\n  /**\n   * Present when `field` is covered by a Via feature binding (e.g. a\n   * declared money field): the opaque payload built by the binding's\n   * `buildClause` at query BUILD time, plus a closure that evaluates it\n   * per record via the binding's `evaluateClause`. Attached by\n   * `Query.where()` / `ScanBuilder.where()` when `source.via` covers the\n   * field. The closure keeps this module free of any dependency on a\n   * Via feature's implementation — clauses are in-memory only, never\n   * serialized, so carrying a function here is safe.\n   */\n  readonly via?: {\n    readonly brand: string\n    readonly payload: unknown\n    readonly evaluate: (actual: unknown, op: string) => boolean\n    /**\n     * The binding's `indexProbe` result for this clause's op/payload\n     * (#625) — the STORED-form operand `candidateRecords()` (`kernel/\n     * query/builder.ts`) can hand to `CollectionIndexes.lookupEqual`/\n     * `lookupIn` for a fast path. `undefined` (no `indexProbe` hook, or\n     * the binding declined to probe this op) means the field must fall\n     * back to a linear scan via `evaluate` above.\n     */\n    readonly indexValue?: unknown\n  }\n  /**\n   * Provenance of an `in`/`!in` operand that arrived as a SUBQUERY (#1351)\n   * rather than as a literal array. Set by {@link normalizeSubqueryOperand};\n   * `value` already holds the RESOLVED id array by the time this is present.\n   *\n   * Plain data on purpose — it is part of the plan JSON, so it folds into an\n   * MV's `queryHash` and discriminates two queries whose resolved id sets\n   * happen to coincide but whose inner sources differ.\n   */\n  readonly subquery?: {\n    /** The inner source's `identity` (`<vault>/<collection>`), or `'(unnamed)'`. */\n    readonly from: string\n    /** How many ids the inner query produced. */\n    readonly ids: number\n  }\n}\n\n/**\n * A user-supplied predicate function escape hatch. Not serializable.\n *\n * The predicate accepts `unknown` at the type level so the surrounding\n * Clause type can stay non-parametric — this keeps Collection<T> covariant\n * in T at the public API surface. Builder methods cast user predicates\n * (typed `(record: T) => boolean`) into this shape on the way in.\n */\nexport interface FilterClause {\n  readonly type: 'filter'\n  readonly fn: (record: unknown) => boolean\n}\n\n/**\n * A declared deterministic predicate reference. The query\n * builder produces this via `.wherePredicate(name, ctx?)` when a\n * Query has been augmented with a predicates map (typically by the\n * materialized-view registry).\n *\n * `predicateHash` is the consumer-supplied stable hash for the\n * function body; `ctxHash` is the canonical-JSON SHA-256 of `ctx`.\n * Both fold into the MV's `queryHash` so a function or ctx change\n * forces refresh on next visit.\n *\n * `fn` is resolved at builder time from the predicates map and\n * embedded directly — so `evaluateClause` can fire it without a\n * runtime lookup.\n */\nexport interface WherePredicateClause {\n  readonly type: 'wherePredicate'\n  readonly name: string\n  readonly ctx: unknown\n  readonly predicateHash: string\n  readonly ctxHash: string\n  readonly fn: (record: unknown, ctx?: unknown) => boolean\n}\n\n/** A logical group of clauses combined by AND or OR. */\nexport interface GroupClause {\n  readonly type: 'group'\n  readonly op: 'and' | 'or'\n  readonly clauses: readonly Clause[]\n}\n\n/**\n * Cartesian-product expansion clause. Appended to `QueryPlan.clauses`\n * by `Query.crossJoin()`. Processed in declaration order by\n * `executeClausePipeline` — NOT by `evaluateClause` (which is a\n * per-record predicate and throws on this type).\n */\nexport interface CrossJoinClause {\n  readonly type: 'crossJoin'\n  /** Target collection name to cross-join against. */\n  readonly target: string\n  /** Alias under which the right-side record is exposed on each result row. */\n  readonly as: string\n  /**\n   * Alias under which the LEFT row is exposed (#1289, `.crossJoinWith()`).\n   * `undefined` — every clause `.crossJoin()` builds — spreads the left row's\n   * own fields at the top level, which is the pre-#1289 shape.\n   *\n   * Set, the row becomes `{ [leftAs]: left, [as]: right }` and NO field sits\n   * at the top level. That is the whole point (a self-join needs both sides\n   * distinguishable) and also its whole cost: Via dressing keys by bare field\n   * name, so an aliased row is invisible to the top-level decode and must be\n   * dressed per alias instead. See `dressAliases` in `builder.ts`.\n   */\n  readonly leftAs?: string\n  /**\n   * Lateral filter callback. `undefined` → full cartesian product.\n   * Two call shapes:\n   *   - Subset:    `(left) => TTarget[]`            — returns the right rows for this left row\n   *   - Predicate: `(left) => (right) => boolean`   — executor materializes then filters\n   */\n  readonly on?: (left: unknown) => unknown[] | ((right: unknown) => boolean)\n  /** When `on:` was supplied as `{ predicate: name }`, the name is stored here for queryHash. */\n  readonly onPredicateName?: string\n  /** Per-clause row ceiling override. `undefined` → `DEFAULT_CROSS_JOIN_MAX_ROWS`. */\n  readonly maxRows?: number\n  /**\n   * Left-outer mode (#1130). When the `on:` subset for a left row is empty,\n   * emit that row once with `null` under `as` instead of dropping it.\n   *\n   * Applies to both call shapes. With `on:` the empty thing is that left\n   * row's subset; without it, an empty TARGET collection is what would\n   * otherwise drop every left row.\n   */\n  readonly outer?: boolean\n}\n\nexport type Clause = FieldClause | FilterClause | WherePredicateClause | GroupClause | CrossJoinClause\n\n/**\n * Read a possibly nested field path like \"address.city\" from a record.\n * Returns undefined if any segment is missing.\n */\nexport function readPath(record: unknown, path: string): unknown {\n  if (record === null || record === undefined) return undefined\n  if (!path.includes('.')) {\n    return (record as Record<string, unknown>)[path]\n  }\n  const segments = path.split('.')\n  let cursor: unknown = record\n  for (const segment of segments) {\n    if (cursor === null || cursor === undefined) return undefined\n    cursor = (cursor as Record<string, unknown>)[segment]\n  }\n  return cursor\n}\n\n/**\n * Evaluate a single field clause against a record.\n * Returns false on type mismatches rather than throwing — query results\n * exclude non-matching records by definition.\n */\nexport function evaluateFieldClause(record: unknown, clause: FieldClause): boolean {\n  const actual = readPath(record, clause.field)\n  const { op, value } = clause\n\n  // A Via-covered field (e.g. money) may store a transformed\n  // representation (money: BigInt-exact in scaled-integer space) that the\n  // generic paths below can't compare correctly — the operand was\n  // pre-built at query BUILD time and the binding's own evaluator knows\n  // how to compare it against the raw stored value.\n  if (clause.via) return clause.via.evaluate(actual, op)\n  return evaluateOperator(actual, op, value)\n}\n\n/**\n * The generic comparison, with no record and no Via involved.\n *\n * Split out of {@link evaluateFieldClause} (#1355) so a Via binding can\n * DELEGATE the operators it does not itself define. That matters more than\n * it sounds: a binding that claims a field for one operator and declines\n * the rest leaves the others with `clause.via` unset, and an unset `via` is\n * exactly what tells `candidateRecords()` a secondary index may serve the\n * clause. For a binding that also rewrites the index KEY\n * (`canonicalizeIndexKey`), that combination lets the index and the scan\n * answer the same clause differently. Claiming every operator and routing\n * the uninteresting ones back here keeps the two in step.\n */\nexport function evaluateOperator(actual: unknown, op: Operator, value: unknown): boolean {\n  switch (op) {\n    case '==':\n      return actual === value\n    case '!=':\n      return actual !== value\n    case '<':\n      return isComparable(actual, value) && (actual as number) < (value as number)\n    case '<=':\n      return isComparable(actual, value) && (actual as number) <= (value as number)\n    case '>':\n      return isComparable(actual, value) && (actual as number) > (value as number)\n    case '>=':\n      return isComparable(actual, value) && (actual as number) >= (value as number)\n    case 'in':\n      return Array.isArray(value) && value.includes(actual)\n    case '!in':\n      // An operand that is not an array matches nothing under 'in'; the\n      // negation of that is \"matches everything\", which is what a caller who\n      // wrote a malformed `!in` gets. Same posture as every other type\n      // mismatch here — no throw at evaluation time.\n      return !Array.isArray(value) || !value.includes(actual)\n    case 'contains':\n      if (typeof actual === 'string') return typeof value === 'string' && actual.includes(value)\n      if (Array.isArray(actual)) return actual.includes(value)\n      return false\n    case 'startsWith':\n      return typeof actual === 'string' && typeof value === 'string' && actual.startsWith(value)\n    case 'matches': {\n      if (typeof actual !== 'string') return false\n      const re = matchesRegExp(value)\n      return re !== null && re.test(actual)\n    }\n    case 'between': {\n      if (!Array.isArray(value) || value.length !== 2) return false\n      const [lo, hi] = value\n      if (!isComparable(actual, lo) || !isComparable(actual, hi)) return false\n      return (actual as number) >= (lo as number) && (actual as number) <= (hi as number)\n    }\n    case 'near':\n      // Reached only when NO via binding claimed the field (a `geo()`\n      // clause carries `clause.via` and returned above). Nothing else in\n      // the kernel knows what a point is.\n      return false\n    default: {\n      // Exhaustiveness — TS will error if a new operator is added without a case.\n      const _exhaustive: never = op\n      void _exhaustive\n      return false\n    }\n  }\n}\n\n// --- subquery operands (#1351) ----------------------------------------\n\n/**\n * What a `Query` looks like to this module. Duck-typed rather than imported:\n * `builder.ts` imports THIS file, so naming `Query` here would be a cycle.\n * `Query._asIdOperand()` is the only member of the contract.\n */\ninterface IdOperandSource {\n  _asIdOperand(): { readonly ids: readonly string[]; readonly from: string }\n}\n\nfunction isIdOperandSource(value: unknown): value is IdOperandSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as Partial<IdOperandSource>)._asIdOperand === 'function'\n  )\n}\n\n/**\n * Resolve a SUBQUERY operand of `in`/`!in` into the literal id array the rest\n * of the engine already knows how to handle (#1351).\n *\n * ⭐ THE INNER QUERY RUNS HERE — ONCE, at `where()` BUILD time — and never\n * again. That is the whole design, and it is what keeps an O(n) filter from\n * becoming O(n·m): by the time a record is evaluated the clause holds a plain\n * array, so `candidateRecords()` dispatches it through the hash index exactly\n * as it does a hand-written list. `__tests__/query-subquery-in.test.ts`\n * witnesses it with an evaluation counter, not by inspection.\n *\n * ⚠️ THE PRICE, stated once: the operand is a SNAPSHOT taken when `where()`\n * was called. A query object built now and executed later — `.live()` being\n * the case that matters — keeps the id set it was built with, so a change to\n * the INNER collection does not re-fire the outer live query and does not\n * change its answer. Rebuild the query to pick up a new inner result.\n *\n * Every other operator, and an operand that is not a Query, passes through\n * untouched — including a malformed one, which keeps this a resolution step\n * and not a new validation gate.\n */\nexport function normalizeSubqueryOperand(\n  op: Operator,\n  value: unknown,\n): { op: Operator; value: unknown; subquery?: FieldClause['subquery'] } {\n  if (op !== 'in' && op !== '!in') return { op, value }\n  if (!isIdOperandSource(value)) return { op, value }\n  const { ids, from } = value._asIdOperand()\n  return { op, value: [...ids], subquery: { from, ids: ids.length } }\n}\n\n// --- 'matches' (#1357) ------------------------------------------------\n\n/**\n * The serialized `matches` operand. Plans are JSON-serializable and an MV's\n * `queryHash` is taken over that JSON — a bare `RegExp` canonicalizes to\n * `{}`, so two different patterns would hash the SAME and a stale view would\n * never refresh. Source + flags is what makes the pattern part of the hash.\n */\ninterface MatchesOperand {\n  readonly source: string\n  readonly flags: string\n}\n\n/** ReDoS budget. A refusal, not a sanitiser — see {@link UnsafePatternError}. */\nconst MATCHES_MAX_SOURCE = 200\nconst MATCHES_MAX_GROUP_DEPTH = 5\nconst MATCHES_MAX_QUANTIFIERS = 20\n\nfunction isQuantifier(c: string | undefined): boolean {\n  return c === '*' || c === '+' || c === '?' || c === '{'\n}\n\n/**\n * Refuse a pattern that could backtrack catastrophically, by budget.\n *\n * Deliberately syntactic and conservative: an unescaped `{` counts as a\n * quantifier even when it is a literal brace, because over-counting only\n * ever costs a refusal the caller can see, while under-counting costs a\n * hang. The one structural rule is the real ReDoS shape — a quantified\n * group whose body itself quantifies, `(a+)+`.\n */\nfunction assertSafePattern(source: string, flags: string): void {\n  if (source.length > MATCHES_MAX_SOURCE) {\n    throw new UnsafePatternError(\n      `where(..., 'matches', ...): pattern is ${source.length} characters, over the ` +\n        `${MATCHES_MAX_SOURCE}-character budget. Narrow the pattern, or use .filter(fn) ` +\n        `and accept that it cannot use an index.`,\n    )\n  }\n  for (const f of flags) {\n    if (f === 'g' || f === 'y') {\n      throw new UnsafePatternError(\n        `where(..., 'matches', ...): the '${f}' flag makes RegExp.test() stateful across ` +\n          `records and would silently drop rows. Remove it from /${source}/${flags}.`,\n      )\n    }\n  }\n  let quantifiers = 0\n  let inClass = false\n  let escaped = false\n  const groupQuantified: boolean[] = []\n  for (let i = 0; i < source.length; i++) {\n    const c = source[i]!\n    if (escaped) { escaped = false; continue }\n    if (c === '\\\\') { escaped = true; continue }\n    if (inClass) { if (c === ']') inClass = false; continue }\n    if (c === '[') { inClass = true; continue }\n    if (c === '(') {\n      groupQuantified.push(false)\n      if (groupQuantified.length > MATCHES_MAX_GROUP_DEPTH) {\n        throw new UnsafePatternError(\n          `where(..., 'matches', ...): group nesting exceeds the depth-${MATCHES_MAX_GROUP_DEPTH} ` +\n            `budget in /${source}/. Flatten the pattern.`,\n        )\n      }\n      // `(?:` / `(?=` / `(?<name>` — that '?' is a group marker, not a quantifier.\n      if (source[i + 1] === '?') i++\n      continue\n    }\n    if (c === ')') {\n      const bodyQuantified = groupQuantified.pop() ?? false\n      if (bodyQuantified && isQuantifier(source[i + 1])) {\n        throw new UnsafePatternError(\n          `where(..., 'matches', ...): nested quantifier at index ${i + 1} of /${source}/ ` +\n            `— a quantified group whose body also quantifies backtracks exponentially. ` +\n            `Rewrite it, or use .filter(fn).`,\n        )\n      }\n      continue\n    }\n    if (isQuantifier(c)) {\n      quantifiers++\n      if (quantifiers > MATCHES_MAX_QUANTIFIERS) {\n        throw new UnsafePatternError(\n          `where(..., 'matches', ...): more than ${MATCHES_MAX_QUANTIFIERS} quantifiers in ` +\n            `/${source}/. Narrow the pattern, or use .filter(fn).`,\n        )\n      }\n      if (groupQuantified.length > 0) groupQuantified[groupQuantified.length - 1] = true\n    }\n  }\n}\n\n/** Escape one character for literal use inside a RegExp source. */\nfunction escapeRegExpChar(c: string): string {\n  return /[.*+?^${}()|[\\]\\\\/]/.test(c) ? `\\\\${c}` : c\n}\n\n/**\n * LIKE semantics, stated once: the pattern is ANCHORED at both ends (SQL\n * `LIKE`, not a substring find), `%` is any run of characters including\n * none, `_` is exactly one, and a BACKSLASH escapes the next character —\n * `\\%` and `\\_` are literal, `\\\\` is a literal backslash. Both wildcards\n * match newlines.\n */\nfunction likeToSource(like: string): string {\n  let out = '^'\n  for (let i = 0; i < like.length; i++) {\n    const c = like[i]!\n    if (c === '\\\\') {\n      const next = like[i + 1]\n      if (next === undefined) {\n        throw new UnsafePatternError(\n          `where(..., 'matches', ...): LIKE pattern \"${like}\" ends with a dangling escape.`,\n        )\n      }\n      i++\n      out += escapeRegExpChar(next)\n      continue\n    }\n    if (c === '%') { out += '[\\\\s\\\\S]*'; continue }\n    if (c === '_') { out += '[\\\\s\\\\S]'; continue }\n    out += escapeRegExpChar(c)\n  }\n  return `${out}$`\n}\n\n/**\n * The literal prefix a pattern is EXACTLY equivalent to, or `null`.\n *\n * Conservative by construction, because a wrong lowering returns wrong rows\n * silently while a missed one only costs a scan. It lowers only when the\n * source is `^` followed by characters that carry no regex meaning at all —\n * no escapes, no classes, no alternation, no quantifiers, no `$` — and the\n * flags are EMPTY. `i` in particular must never lower: the sorted index is\n * case-sensitive, so `/^client-b/i` would lose rows.\n */\nfunction literalPrefixAnchor(source: string, flags: string): string | null {\n  if (flags !== '' || !source.startsWith('^')) return null\n  const rest = source.slice(1)\n  return /^[^\\\\^$.|?*+()[\\]{}]*$/.test(rest) ? rest : null\n}\n\n/**\n * Normalize a `where(field, 'matches', operand)` at BUILD time: refuse an\n * unsafe pattern, lower an anchored literal prefix to `startsWith`, and\n * otherwise serialize to `{ source, flags }`. Every other operator passes\n * through untouched.\n *\n * Called by every `where()` (`Query`, `ScanBuilder`, `LazyQuery`) so all\n * three build the same clause for the same call.\n */\nexport function normalizeMatches(op: Operator, value: unknown): { op: Operator, value: unknown } {\n  if (op !== 'matches') return { op, value }\n  let source: string\n  let flags: string\n  if (typeof value === 'string') {\n    // `abc%` — a literal run then an open tail — IS startsWith('abc').\n    if (/^[^%_\\\\]*%$/.test(value)) return { op: 'startsWith', value: value.slice(0, -1) }\n    source = likeToSource(value)\n    flags = ''\n  } else if (value instanceof RegExp) {\n    source = value.source\n    flags = value.flags\n  } else {\n    throw new UnsafePatternError(\n      `where(..., 'matches', ...) needs a RegExp or a LIKE string; received ${typeof value}.`,\n    )\n  }\n  assertSafePattern(source, flags)\n  const prefix = literalPrefixAnchor(source, flags)\n  if (prefix !== null) return { op: 'startsWith', value: prefix }\n  return { op: 'matches', value: { source, flags } satisfies MatchesOperand }\n}\n\n/**\n * Compiled-pattern cache, keyed by flags + source. `evaluateFieldClause`\n * runs per record, so recompiling would dominate the scan. Cleared wholesale\n * at a small cap rather than evicting — a query's live patterns recompile\n * once and the map cannot grow without bound.\n */\nconst MATCHES_CACHE = new Map<string, RegExp>()\nconst MATCHES_CACHE_MAX = 256\n\n/**\n * The RegExp for a clause operand. Accepts the normalized\n * {@link MatchesOperand} and — for a hand-built plan that never went through\n * `where()` — a raw `RegExp`, whose `g`/`y` flags are stripped so `test()`\n * cannot carry `lastIndex` from one record to the next. Returns `null` for\n * anything else: a clause that cannot compile matches nothing, the same\n * posture as every other type mismatch in this module.\n */\nfunction matchesRegExp(value: unknown): RegExp | null {\n  const spec = value instanceof RegExp ? { source: value.source, flags: value.flags } : value\n  if (typeof spec !== 'object' || spec === null) return null\n  const { source, flags } = spec as Partial<MatchesOperand>\n  if (typeof source !== 'string' || typeof flags !== 'string') return null\n  const safeFlags = flags.replace(/[gy]/g, '')\n  const key = `${safeFlags} ${source}`\n  const cached = MATCHES_CACHE.get(key)\n  if (cached !== undefined) return cached\n  let re: RegExp\n  try {\n    re = new RegExp(source, safeFlags)\n  } catch {\n    return null\n  }\n  if (MATCHES_CACHE.size >= MATCHES_CACHE_MAX) MATCHES_CACHE.clear()\n  MATCHES_CACHE.set(key, re)\n  return re\n}\n\n/**\n * Two values are \"comparable\" if they share an order-defined runtime type.\n * Strings compare lexicographically; numbers and Dates numerically; otherwise false.\n */\nfunction isComparable(a: unknown, b: unknown): boolean {\n  if (typeof a === 'number' && typeof b === 'number') return true\n  if (typeof a === 'string' && typeof b === 'string') return true\n  if (a instanceof Date && b instanceof Date) return true\n  return false\n}\n\n/**\n * Evaluate any clause (field / filter / group) against a record.\n * The recursion depth is bounded by the user's query expression — no risk of\n * blowing the stack on a 50K-record collection.\n *\n * `fnRecord`, when provided, is the view handed to USER CALLBACK clauses\n * (`filter` / `wherePredicate`) instead of `record` — the executor passes\n * the money-decoded view there so user code never sees the stored\n * scaled-int form, while field clauses keep evaluating against the raw\n * record (their money operands are pre-quantized to that space).\n */\nexport function evaluateClause(record: unknown, clause: Clause, fnRecord?: unknown): boolean {\n  switch (clause.type) {\n    case 'field':\n      return evaluateFieldClause(record, clause)\n    case 'filter':\n      return clause.fn(fnRecord !== undefined ? fnRecord : record)\n    case 'wherePredicate':\n      return clause.fn(fnRecord !== undefined ? fnRecord : record, clause.ctx)\n    case 'crossJoin':\n      throw new Error(\n        `evaluateClause: 'crossJoin' clauses are expansion primitives and are not ` +\n          `evaluated per-record. This is a query planner routing error — ` +\n          `crossJoin clauses must be extracted from the clause list before calling ` +\n          `evaluateClause or filterRecords.`,\n      )\n    case 'group':\n      if (clause.op === 'and') {\n        for (const child of clause.clauses) {\n          if (!evaluateClause(record, child, fnRecord)) return false\n        }\n        return true\n      } else {\n        for (const child of clause.clauses) {\n          if (evaluateClause(record, child, fnRecord)) return true\n        }\n        return false\n      }\n  }\n}\n\n/**\n * Does the clause list contain any user-callback clause (filter /\n * wherePredicate), at any group nesting depth? Used by executors to\n * decide whether the per-record decoded view needs materializing.\n */\nexport function hasFnClause(clauses: readonly Clause[]): boolean {\n  for (const c of clauses) {\n    if (c.type === 'filter' || c.type === 'wherePredicate') return true\n    if (c.type === 'group' && hasFnClause(c.clauses)) return true\n  }\n  return false\n}\n"],"mappings":";;;;;AAgNO,SAAS,SAAS,QAAiB,MAAuB;AAC/D,MAAI,WAAW,QAAQ,WAAW,OAAW,QAAO;AACpD,MAAI,CAAC,KAAK,SAAS,GAAG,GAAG;AACvB,WAAQ,OAAmC,IAAI;AAAA,EACjD;AACA,QAAM,WAAW,KAAK,MAAM,GAAG;AAC/B,MAAI,SAAkB;AACtB,aAAW,WAAW,UAAU;AAC9B,QAAI,WAAW,QAAQ,WAAW,OAAW,QAAO;AACpD,aAAU,OAAmC,OAAO;AAAA,EACtD;AACA,SAAO;AACT;AAOO,SAAS,oBAAoB,QAAiB,QAA8B;AACjF,QAAM,SAAS,SAAS,QAAQ,OAAO,KAAK;AAC5C,QAAM,EAAE,IAAI,MAAM,IAAI;AAOtB,MAAI,OAAO,IAAK,QAAO,OAAO,IAAI,SAAS,QAAQ,EAAE;AACrD,SAAO,iBAAiB,QAAQ,IAAI,KAAK;AAC3C;AAeO,SAAS,iBAAiB,QAAiB,IAAc,OAAyB;AACvF,UAAQ,IAAI;AAAA,IACV,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,aAAa,QAAQ,KAAK,KAAM,SAAqB;AAAA,IAC9D,KAAK;AACH,aAAO,aAAa,QAAQ,KAAK,KAAM,UAAsB;AAAA,IAC/D,KAAK;AACH,aAAO,aAAa,QAAQ,KAAK,KAAM,SAAqB;AAAA,IAC9D,KAAK;AACH,aAAO,aAAa,QAAQ,KAAK,KAAM,UAAsB;AAAA,IAC/D,KAAK;AACH,aAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS,MAAM;AAAA,IACtD,KAAK;AAKH,aAAO,CAAC,MAAM,QAAQ,KAAK,KAAK,CAAC,MAAM,SAAS,MAAM;AAAA,IACxD,KAAK;AACH,UAAI,OAAO,WAAW,SAAU,QAAO,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK;AACzF,UAAI,MAAM,QAAQ,MAAM,EAAG,QAAO,OAAO,SAAS,KAAK;AACvD,aAAO;AAAA,IACT,KAAK;AACH,aAAO,OAAO,WAAW,YAAY,OAAO,UAAU,YAAY,OAAO,WAAW,KAAK;AAAA,IAC3F,KAAK,WAAW;AACd,UAAI,OAAO,WAAW,SAAU,QAAO;AACvC,YAAM,KAAK,cAAc,KAAK;AAC9B,aAAO,OAAO,QAAQ,GAAG,KAAK,MAAM;AAAA,IACtC;AAAA,IACA,KAAK,WAAW;AACd,UAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,EAAG,QAAO;AACxD,YAAM,CAAC,IAAI,EAAE,IAAI;AACjB,UAAI,CAAC,aAAa,QAAQ,EAAE,KAAK,CAAC,aAAa,QAAQ,EAAE,EAAG,QAAO;AACnE,aAAQ,UAAsB,MAAkB,UAAsB;AAAA,IACxE;AAAA,IACA,KAAK;AAIH,aAAO;AAAA,IACT,SAAS;AAEP,YAAM,cAAqB;AAC3B,WAAK;AACL,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAaA,SAAS,kBAAkB,OAA0C;AACnE,SACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAmC,iBAAiB;AAEhE;AAuBO,SAAS,yBACd,IACA,OACsE;AACtE,MAAI,OAAO,QAAQ,OAAO,MAAO,QAAO,EAAE,IAAI,MAAM;AACpD,MAAI,CAAC,kBAAkB,KAAK,EAAG,QAAO,EAAE,IAAI,MAAM;AAClD,QAAM,EAAE,KAAK,KAAK,IAAI,MAAM,aAAa;AACzC,SAAO,EAAE,IAAI,OAAO,CAAC,GAAG,GAAG,GAAG,UAAU,EAAE,MAAM,KAAK,IAAI,OAAO,EAAE;AACpE;AAgBA,IAAM,qBAAqB;AAC3B,IAAM,0BAA0B;AAChC,IAAM,0BAA0B;AAEhC,SAAS,aAAa,GAAgC;AACpD,SAAO,MAAM,OAAO,MAAM,OAAO,MAAM,OAAO,MAAM;AACtD;AAWA,SAAS,kBAAkB,QAAgB,OAAqB;AAC9D,MAAI,OAAO,SAAS,oBAAoB;AACtC,UAAM,IAAI;AAAA,MACR,0CAA0C,OAAO,MAAM,yBAClD,kBAAkB;AAAA,IAEzB;AAAA,EACF;AACA,aAAW,KAAK,OAAO;AACrB,QAAI,MAAM,OAAO,MAAM,KAAK;AAC1B,YAAM,IAAI;AAAA,QACR,oCAAoC,CAAC,oGACsB,MAAM,IAAI,KAAK;AAAA,MAC5E;AAAA,IACF;AAAA,EACF;AACA,MAAI,cAAc;AAClB,MAAI,UAAU;AACd,MAAI,UAAU;AACd,QAAM,kBAA6B,CAAC;AACpC,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,IAAI,OAAO,CAAC;AAClB,QAAI,SAAS;AAAE,gBAAU;AAAO;AAAA,IAAS;AACzC,QAAI,MAAM,MAAM;AAAE,gBAAU;AAAM;AAAA,IAAS;AAC3C,QAAI,SAAS;AAAE,UAAI,MAAM,IAAK,WAAU;AAAO;AAAA,IAAS;AACxD,QAAI,MAAM,KAAK;AAAE,gBAAU;AAAM;AAAA,IAAS;AAC1C,QAAI,MAAM,KAAK;AACb,sBAAgB,KAAK,KAAK;AAC1B,UAAI,gBAAgB,SAAS,yBAAyB;AACpD,cAAM,IAAI;AAAA,UACR,+DAA+D,uBAAuB,eACtE,MAAM;AAAA,QACxB;AAAA,MACF;AAEA,UAAI,OAAO,IAAI,CAAC,MAAM,IAAK;AAC3B;AAAA,IACF;AACA,QAAI,MAAM,KAAK;AACb,YAAM,iBAAiB,gBAAgB,IAAI,KAAK;AAChD,UAAI,kBAAkB,aAAa,OAAO,IAAI,CAAC,CAAC,GAAG;AACjD,cAAM,IAAI;AAAA,UACR,0DAA0D,IAAI,CAAC,QAAQ,MAAM;AAAA,QAG/E;AAAA,MACF;AACA;AAAA,IACF;AACA,QAAI,aAAa,CAAC,GAAG;AACnB;AACA,UAAI,cAAc,yBAAyB;AACzC,cAAM,IAAI;AAAA,UACR,yCAAyC,uBAAuB,oBAC1D,MAAM;AAAA,QACd;AAAA,MACF;AACA,UAAI,gBAAgB,SAAS,EAAG,iBAAgB,gBAAgB,SAAS,CAAC,IAAI;AAAA,IAChF;AAAA,EACF;AACF;AAGA,SAAS,iBAAiB,GAAmB;AAC3C,SAAO,sBAAsB,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK;AACpD;AASA,SAAS,aAAa,MAAsB;AAC1C,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,IAAI,KAAK,CAAC;AAChB,QAAI,MAAM,MAAM;AACd,YAAM,OAAO,KAAK,IAAI,CAAC;AACvB,UAAI,SAAS,QAAW;AACtB,cAAM,IAAI;AAAA,UACR,6CAA6C,IAAI;AAAA,QACnD;AAAA,MACF;AACA;AACA,aAAO,iBAAiB,IAAI;AAC5B;AAAA,IACF;AACA,QAAI,MAAM,KAAK;AAAE,aAAO;AAAa;AAAA,IAAS;AAC9C,QAAI,MAAM,KAAK;AAAE,aAAO;AAAY;AAAA,IAAS;AAC7C,WAAO,iBAAiB,CAAC;AAAA,EAC3B;AACA,SAAO,GAAG,GAAG;AACf;AAYA,SAAS,oBAAoB,QAAgB,OAA8B;AACzE,MAAI,UAAU,MAAM,CAAC,OAAO,WAAW,GAAG,EAAG,QAAO;AACpD,QAAM,OAAO,OAAO,MAAM,CAAC;AAC3B,SAAO,yBAAyB,KAAK,IAAI,IAAI,OAAO;AACtD;AAWO,SAAS,iBAAiB,IAAc,OAAkD;AAC/F,MAAI,OAAO,UAAW,QAAO,EAAE,IAAI,MAAM;AACzC,MAAI;AACJ,MAAI;AACJ,MAAI,OAAO,UAAU,UAAU;AAE7B,QAAI,cAAc,KAAK,KAAK,EAAG,QAAO,EAAE,IAAI,cAAc,OAAO,MAAM,MAAM,GAAG,EAAE,EAAE;AACpF,aAAS,aAAa,KAAK;AAC3B,YAAQ;AAAA,EACV,WAAW,iBAAiB,QAAQ;AAClC,aAAS,MAAM;AACf,YAAQ,MAAM;AAAA,EAChB,OAAO;AACL,UAAM,IAAI;AAAA,MACR,wEAAwE,OAAO,KAAK;AAAA,IACtF;AAAA,EACF;AACA,oBAAkB,QAAQ,KAAK;AAC/B,QAAM,SAAS,oBAAoB,QAAQ,KAAK;AAChD,MAAI,WAAW,KAAM,QAAO,EAAE,IAAI,cAAc,OAAO,OAAO;AAC9D,SAAO,EAAE,IAAI,WAAW,OAAO,EAAE,QAAQ,MAAM,EAA2B;AAC5E;AAQA,IAAM,gBAAgB,oBAAI,IAAoB;AAC9C,IAAM,oBAAoB;AAU1B,SAAS,cAAc,OAA+B;AACpD,QAAM,OAAO,iBAAiB,SAAS,EAAE,QAAQ,MAAM,QAAQ,OAAO,MAAM,MAAM,IAAI;AACtF,MAAI,OAAO,SAAS,YAAY,SAAS,KAAM,QAAO;AACtD,QAAM,EAAE,QAAQ,MAAM,IAAI;AAC1B,MAAI,OAAO,WAAW,YAAY,OAAO,UAAU,SAAU,QAAO;AACpE,QAAM,YAAY,MAAM,QAAQ,SAAS,EAAE;AAC3C,QAAM,MAAM,GAAG,SAAS,IAAI,MAAM;AAClC,QAAM,SAAS,cAAc,IAAI,GAAG;AACpC,MAAI,WAAW,OAAW,QAAO;AACjC,MAAI;AACJ,MAAI;AACF,SAAK,IAAI,OAAO,QAAQ,SAAS;AAAA,EACnC,QAAQ;AACN,WAAO;AAAA,EACT;AACA,MAAI,cAAc,QAAQ,kBAAmB,eAAc,MAAM;AACjE,gBAAc,IAAI,KAAK,EAAE;AACzB,SAAO;AACT;AAMA,SAAS,aAAa,GAAY,GAAqB;AACrD,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SAAU,QAAO;AAC3D,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SAAU,QAAO;AAC3D,MAAI,aAAa,QAAQ,aAAa,KAAM,QAAO;AACnD,SAAO;AACT;AAaO,SAAS,eAAe,QAAiB,QAAgB,UAA6B;AAC3F,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK;AACH,aAAO,oBAAoB,QAAQ,MAAM;AAAA,IAC3C,KAAK;AACH,aAAO,OAAO,GAAG,aAAa,SAAY,WAAW,MAAM;AAAA,IAC7D,KAAK;AACH,aAAO,OAAO,GAAG,aAAa,SAAY,WAAW,QAAQ,OAAO,GAAG;AAAA,IACzE,KAAK;AACH,YAAM,IAAI;AAAA,QACR;AAAA,MAIF;AAAA,IACF,KAAK;AACH,UAAI,OAAO,OAAO,OAAO;AACvB,mBAAW,SAAS,OAAO,SAAS;AAClC,cAAI,CAAC,eAAe,QAAQ,OAAO,QAAQ,EAAG,QAAO;AAAA,QACvD;AACA,eAAO;AAAA,MACT,OAAO;AACL,mBAAW,SAAS,OAAO,SAAS;AAClC,cAAI,eAAe,QAAQ,OAAO,QAAQ,EAAG,QAAO;AAAA,QACtD;AACA,eAAO;AAAA,MACT;AAAA,EACJ;AACF;AAOO,SAAS,YAAY,SAAqC;AAC/D,aAAW,KAAK,SAAS;AACvB,QAAI,EAAE,SAAS,YAAY,EAAE,SAAS,iBAAkB,QAAO;AAC/D,QAAI,EAAE,SAAS,WAAW,YAAY,EAAE,OAAO,EAAG,QAAO;AAAA,EAC3D;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-RMS3NEA3.js → chunk-HT2AHGQI.js}

@@ -1,7 +1,7 @@
 import {
   NonAdditiveSchemaChangeError,
   SchemaLockedError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/with-shape/schema-update/strategies.ts
 function blindUpdate() {
@@ -62,4 +62,4 @@ export {
   lockSchema,
   coordinatedCutover
 };
-//# sourceMappingURL=chunk-RMS3NEA3.js.map
+//# sourceMappingURL=chunk-HT2AHGQI.js.map

package/dist/{chunk-CHJBLCOG.js → chunk-HVSCEIYL.js}

@@ -1,25 +1,25 @@
 import {
   freezeSnapshotOnly
-} from "./chunk-BSFNRLK2.js";
+} from "./chunk-S57HTZ6X.js";
 import {
   resolveManagedSecret
-} from "./chunk-4GVM6QZA.js";
+} from "./chunk-ENAG3IY7.js";
 import {
   assertRosterTagValid,
   createOwnerKeyring,
   mintRosterTag,
   nextRosterEpoch,
   requireRosterKey
-} from "./chunk-G56KBWFY.js";
+} from "./chunk-M7NI3IWE.js";
 import {
   buildRecordEnvelope
-} from "./chunk-SZJ3DLZA.js";
+} from "./chunk-SEE332EV.js";
 import {
   wrapKey
-} from "./chunk-SL3JAAKN.js";
+} from "./chunk-UYB234ZR.js";
 import {
   PermissionDeniedError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-244VXYPG.js";
 
 // src/with-party/team/deed.ts
 var DEED_RECORD_ID = "deed";
@@ -137,4 +137,4 @@ export {
   isDeedVault,
   liberateVault
 };
-//# sourceMappingURL=chunk-CHJBLCOG.js.map
+//# sourceMappingURL=chunk-HVSCEIYL.js.map