@rocicorp/zero 1.12.0-canary.3 → 1.12.0-canary.4

package/out/zql/src/query/query-transitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"query-transitions.js","names":["#bounded","#firstKey","#firstValue","#firstDelta","#first","#rest","#restSize","#maybeSweep","#sweepAt","#byHash"],"sources":["../../../../../zql/src/query/query-transitions.ts"],"sourcesContent":["import {deepEqual, type ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getOrInsertComputed, newMap} from '../../../shared/src/map.ts';\n\n/**\n * A transition tree for interning immutable builder objects, modelled on V8's\n * hidden-class transitions.\n *\n * Each node keeps a map from a *transition* (an operation plus its arguments) to\n * the node that operation produces. Applying the same operation to the same node\n * twice therefore yields the same object both times.\n *\n * ## Why not hash?\n *\n * Hashing the resulting AST would work but is far too expensive to do on every\n * builder call. Instead a transition is identified by three things, in\n * decreasing order of how cheap they are to compare:\n *\n * 1. `key` — a short string naming the operation. Callers are expected to hand\n *    in a *stable* string rather than build one per call; see below.\n * 2. `value` — the operation's varying argument, when it is a primitive, used\n *    directly as a `Map` key.\n * 3. `delta` — anything left over, compared with {@link deepEqual}.\n *\n * Splitting 1 from 2 is what makes this fast. Folding the value into the key\n * instead means building a fresh string on every call, and a fresh string has to\n * be hashed from scratch before a `Map` can look it up: measured at ~148ns,\n * against ~10ns to look up the caller's own string, whose hash V8 has already\n * cached on the string object. That difference is larger than everything else a\n * transition does.\n *\n * Comparing only the delta is sound because the parent node is already canonical:\n * two children of the same parent are equal exactly when the operations that\n * produced them are equal. We never deep-compare a whole AST.\n *\n * ## Liveness\n *\n * Children point back at their parents strongly (see `QueryImpl`), so holding a\n * query holds its whole ancestor spine and re-deriving it from the root gives\n * the same object back. The other direction has to be weak, or an interned root\n * — which lives as long as its schema — would retain every query ever derived\n * from it.\n *\n * Weak is expensive, though: `new WeakRef` costs on the order of a hundred\n * nanoseconds, more than everything else a transition does put together, and it\n * adds GC work later. So the *first* transition out of a node is held strongly\n * instead, in fields on this object, with no `WeakRef` at all.\n *\n * That is safe because strong first-children form a path, not a tree: each node\n * pins at most one child, which pins at most one of its own. The retained set\n * per root is bounded by the depth of a builder chain — a handful of queries —\n * rather than by how many distinct queries an app builds. Everything past the\n * first child is weak, so the unbounded cases (a search box typing into\n * `where:title:=:s<text>`, a row id per list item) stay collectible.\n *\n * It is also where the wins are: a chain like `q.where(…).orderBy(…).limit(…)`\n * gives every node exactly one child, so building it allocates no `WeakRef`s and\n * looks up through a field compare rather than a hash lookup.\n *\n * What a collected child leaves behind is a cleared `WeakRef` and its map key. A\n * lookup drops those as it walks, which covers every key that is asked for\n * again. A key that is *never* asked for again is handled by the sweep.\n *\n * ## Best effort\n *\n * Interning is a cache, not a guarantee: a missed lookup only costs an extra\n * object. See {@link MAX_SCAN} for the one case where we deliberately give\n * up.\n *\n * ## Identity vs. hash\n *\n * Identity implies an equal query hash, but the tree alone does not give the\n * converse. `normalizeAST` sorts `related` and `and`/`or` conditions, so\n * `q.where(a).where(b)` and `q.where(b).where(a)` hash the same while being\n * distinct paths, and so distinct nodes. {@link HashIndex} is the second\n * level that folds those together once they have been hashed. Callers that\n * need the normalizing behavior for a query that may not have been must keep\n * using the hash.\n */\n\n/**\n * The delta identifying a transition, or `undefined` when the key already\n * determines the result on its own.\n */\nexport type Delta = ReadonlyJSONValue | undefined;\n\ntype Entry<T extends object> = {\n  readonly delta: Delta;\n  readonly ref: WeakRef<T>;\n};\n\n/**\n * A bucket holds a bare entry in the common single-entry case and is promoted to\n * a `Set` only on collision, so the usual transition allocates no container.\n *\n * A `Set` rather than an array: deleting during iteration is well defined, so a\n * lookup prunes collected entries and stops at its match in a single pass, and\n * removing an entry is O(1) rather than a scan.\n */\ntype Bucket<T extends object> = Entry<T> | Set<Entry<T>>;\n\n/** The varying argument of a transition, when it is one. */\nexport type TransitionValue = string | number | boolean | null | undefined;\n\n/**\n * The longest `deepEqual` scan we are willing to do on a lookup.\n *\n * This is a *latency* bound, not a memory bound — memory is already handled,\n * since entries are weak and are pruned both by the sweep and by any lookup that\n * walks past them, so a bucket only ever holds children that are still alive.\n *\n * Note what happens at the limit: we stop *storing*, we do not evict. Evicting\n * would de-intern objects that are still in use, and on a sequential sweep of a\n * live set larger than the limit it drives the hit rate to zero — each lookup\n * throws out the entry the next one needs. Refusing to store instead leaves\n * every already-shared sibling shared and degrades the surplus to the old\n * behavior of a fresh instance per call.\n *\n * Buckets should rarely get near this. Keys carry the discriminating value\n * wherever it is cheap to, and a key that carries it is *exact*, so it costs no\n * comparison at all: every simple comparison goes that way, and so does a\n * one-hop `exists`, via its sub-query's identity. What is left sharing a bucket\n * is two-hop `exists`, the `and`/`or` trees an expression factory builds, and\n * relationships whose callback varies.\n */\nexport const MAX_SCAN = 64;\n\n/** How large the weak map must get before its first sweep. */\nconst SWEEP_INITIAL = 64;\n\n/** The transitions out of one node. */\nexport class Transitions<T extends object> {\n  // The first transition, held strongly and in place. See \"Liveness\" above.\n  #firstKey: string | undefined;\n  #firstValue: TransitionValue;\n  #firstDelta: Delta;\n  #first: T | undefined;\n\n  // Transitions whose key space is finite and comes from the schema rather than\n  // from user data, held strongly. See `storeBounded`.\n  #bounded: Map<string, T> | undefined;\n\n  // Everything else, weakly. Allocated only if there is a second. Nested so the\n  // value stays a `Map` key of its own rather than part of the string.\n  #rest: Map<string, Map<TransitionValue, Bucket<T>>> | undefined;\n  #sweepAt = SWEEP_INITIAL;\n  #restSize = 0;\n\n  lookupBounded(key: string): T | undefined {\n    return this.#bounded?.get(key);\n  }\n\n  /**\n   * Records a transition whose key space is finite and schema-derived — the base\n   * sub-query handed to a `related`/`exists` callback, keyed by relationship\n   * name.\n   *\n   * These are held strongly. Retention is bounded by the number of relationships\n   * on the table, so it cannot grow with what an app queries for, and in exchange\n   * a relationship traversal allocates no `WeakRef`. Anything keyed by a *value*\n   * — a row id, a search string, a limit — must not come through here.\n   */\n  storeBounded(key: string, value: T): void {\n    (this.#bounded ??= new Map()).set(key, value);\n  }\n\n  lookup(key: string, value: TransitionValue, delta: Delta): T | undefined {\n    if (\n      this.#firstKey === key &&\n      this.#firstValue === value &&\n      deepEqual(this.#firstDelta, delta)\n    ) {\n      return this.#first;\n    }\n    const byValue = this.#rest?.get(key);\n    if (byValue === undefined) {\n      return undefined;\n    }\n    const bucket = byValue.get(value);\n    if (bucket === undefined) {\n      return undefined;\n    }\n\n    if (!(bucket instanceof Set)) {\n      const found = bucket.ref.deref();\n      if (found === undefined) {\n        byValue.delete(value);\n        this.#restSize--;\n        return undefined;\n      }\n      // deepEqual short-circuits on reference equality, which is the fast path\n      // we rely on for deltas built out of already-interned sub-queries.\n      return deepEqual(bucket.delta, delta) ? found : undefined;\n    }\n\n    // One pass: drop what has been collected, stop at the match. Deleting from a\n    // Set while iterating it is well defined — the iterator simply skips what is\n    // gone — so this stays O(n) with no compaction step, and returns early on a\n    // hit rather than walking the whole bucket first.\n    for (const entry of bucket) {\n      const found = entry.ref.deref();\n      if (found === undefined) {\n        bucket.delete(entry);\n        this.#restSize--;\n        continue;\n      }\n      if (deepEqual(entry.delta, delta)) {\n        return found;\n      }\n    }\n    if (bucket.size === 0) {\n      byValue.delete(value);\n    }\n    return undefined;\n  }\n\n  store(key: string, value: TransitionValue, delta: Delta, node: T): void {\n    if (this.#firstKey === undefined) {\n      this.#firstKey = key;\n      this.#firstValue = value;\n      this.#firstDelta = delta;\n      this.#first = node;\n      return;\n    }\n\n    const rest = (this.#rest ??= new Map());\n    const byValue = getOrInsertComputed(rest, key, newMap);\n\n    const entry: Entry<T> = {delta, ref: new WeakRef(node)};\n    const bucket = byValue.get(value);\n\n    if (bucket === undefined) {\n      byValue.set(value, entry);\n    } else if (!(bucket instanceof Set)) {\n      byValue.set(value, new Set([bucket, entry]));\n    } else {\n      if (bucket.size >= MAX_SCAN) {\n        // Leave the bucket alone; see MAX_SCAN. `node` is simply not shared.\n        // A store only follows a failed lookup, which has just pruned, so this\n        // is measured against entries that are actually still alive.\n        return;\n      }\n      bucket.add(entry);\n    }\n    this.#restSize++;\n    this.#maybeSweep(rest);\n  }\n\n  /**\n   * Re-points the transition that produced `from` at `to`, so the next lookup\n   * along that path yields `to` instead. This is how {@link HashIndex}\n   * converges two paths on one node: `from` keeps its identity, since it has\n   * already been handed out, and its path is redirected for the rebuilds that\n   * follow.\n   *\n   * Scans rather than taking a key. This runs once per redirected path, so a\n   * walk here is cheaper than the fields every node would need to carry to\n   * name its own transition.\n   */\n  replace(from: T, to: T): boolean {\n    if (this.#first === from) {\n      this.#first = to;\n      return true;\n    }\n    const rest = this.#rest;\n    if (rest === undefined) {\n      return false;\n    }\n    for (const byValue of rest.values()) {\n      for (const [value, bucket] of byValue) {\n        if (!(bucket instanceof Set)) {\n          if (bucket.ref.deref() === from) {\n            byValue.set(value, {delta: bucket.delta, ref: new WeakRef(to)});\n            return true;\n          }\n          continue;\n        }\n        for (const entry of bucket) {\n          if (entry.ref.deref() === from) {\n            bucket.delete(entry);\n            bucket.add({delta: entry.delta, ref: new WeakRef(to)});\n            return true;\n          }\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Drops entries for collected values, if the map has grown enough to be worth\n   * walking.\n   *\n   * A lookup already prunes whatever it walks past, which covers every key that\n   * is asked for again. This is for the key that is not: a miss on a fresh key\n   * returns without touching any existing entry, so nothing would ever notice\n   * that those had died. Doubling the threshold off whatever survives keeps this\n   * amortized O(1) per insert whether or not there was anything to reclaim, and\n   * it is self-limiting — only a node that keeps taking inserts can keep\n   * accumulating, and taking inserts is what triggers the sweep.\n   */\n  #maybeSweep(rest: Map<string, Map<TransitionValue, Bucket<T>>>): void {\n    if (this.#restSize < this.#sweepAt) {\n      return;\n    }\n    let live = 0;\n    for (const [key, byValue] of rest) {\n      for (const [value, bucket] of byValue) {\n        if (!(bucket instanceof Set)) {\n          if (bucket.ref.deref() === undefined) {\n            byValue.delete(value);\n          } else {\n            live++;\n          }\n          continue;\n        }\n        for (const entry of bucket) {\n          if (entry.ref.deref() === undefined) {\n            bucket.delete(entry);\n          } else {\n            live++;\n          }\n        }\n        if (bucket.size === 0) {\n          byValue.delete(value);\n        }\n      }\n      if (byValue.size === 0) {\n        rest.delete(key);\n      }\n    }\n    this.#restSize = live;\n    this.#sweepAt = Math.max(SWEEP_INITIAL, live * 2);\n  }\n}\n\n/**\n * The second level of interning: nodes keyed by *content* rather than by the\n * path that built them.\n *\n * The transition tree cannot see that `q.where(a).where(b)` and\n * `q.where(b).where(a)` are the same query. `normalizeAST` sorts conditions\n * and `related` entries, so the two build byte-identical ASTs, but they are\n * different paths and so different nodes. This index closes that gap, keyed by\n * the query's hash.\n *\n * It is consulted when a query is *hashed*, not when it is built. Hashing on\n * every tree miss would make a cold chain pay for a hash per node, where the\n * uninterned code paid for one at the end, if at all -- and server-side queries\n * are built cold, once, per request. The consumers that key by hash already\n * hash the queries they care about, so doing the work there costs one map\n * lookup on top of a hash that was being computed anyway, and nothing at all\n * for a query nobody hashes.\n *\n * On a hit the query being hashed keeps its identity, since it has already\n * been handed out. Its *transition* is re-pointed at the existing node instead\n * (see {@link Transitions.replace}), so the next rebuild along that path\n * yields the shared instance. As with the tree this is a cache: the rebuild\n * after a redirect is what converges, not the call that found the duplicate.\n *\n * One index per root, which is what scopes it. Two roots never share an index,\n * so queries against different schemas or different delegates -- neither of\n * which the hash covers -- can never be conflated. Entries are weak: a cleared\n * one is dropped by the lookup that finds it, or by a sweep once the map has\n * doubled since the last one.\n */\nexport class HashIndex<T extends object> {\n  readonly #byHash = new Map<string, WeakRef<T>>();\n  #sweepAt = SWEEP_INITIAL;\n\n  get(hash: string): T | undefined {\n    const ref = this.#byHash.get(hash);\n    if (ref === undefined) {\n      return undefined;\n    }\n    const node = ref.deref();\n    if (node === undefined) {\n      this.#byHash.delete(hash);\n    }\n    return node;\n  }\n\n  set(hash: string, node: T): void {\n    const byHash = this.#byHash;\n    byHash.set(hash, new WeakRef(node));\n    if (byHash.size < this.#sweepAt) {\n      return;\n    }\n    for (const [h, ref] of byHash) {\n      if (ref.deref() === undefined) {\n        byHash.delete(h);\n      }\n    }\n    this.#sweepAt = Math.max(SWEEP_INITIAL, byHash.size * 2);\n  }\n}\n"],"mappings":";;;AA+HA,IAAM,gBAAgB;;AAGtB,IAAa,cAAb,MAA2C;CAEzC;CACA;CACA;CACA;CAIA;CAIA;CACA,WAAW;CACX,YAAY;CAEZ,cAAc,KAA4B;EACxC,OAAO,KAAKA,UAAU,IAAI,GAAG;CAC/B;;;;;;;;;;;CAYA,aAAa,KAAa,OAAgB;EACxC,CAAC,KAAKA,6BAAa,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;CAC9C;CAEA,OAAO,KAAa,OAAwB,OAA6B;EACvE,IACE,KAAKC,cAAc,OACnB,KAAKC,gBAAgB,SACrB,UAAU,KAAKC,aAAa,KAAK,GAEjC,OAAO,KAAKC;EAEd,MAAM,UAAU,KAAKC,OAAO,IAAI,GAAG;EACnC,IAAI,YAAY,KAAA,GACd;EAEF,MAAM,SAAS,QAAQ,IAAI,KAAK;EAChC,IAAI,WAAW,KAAA,GACb;EAGF,IAAI,EAAE,kBAAkB,MAAM;GAC5B,MAAM,QAAQ,OAAO,IAAI,MAAM;GAC/B,IAAI,UAAU,KAAA,GAAW;IACvB,QAAQ,OAAO,KAAK;IACpB,KAAKC;IACL;GACF;GAGA,OAAO,UAAU,OAAO,OAAO,KAAK,IAAI,QAAQ,KAAA;EAClD;EAMA,KAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,QAAQ,MAAM,IAAI,MAAM;GAC9B,IAAI,UAAU,KAAA,GAAW;IACvB,OAAO,OAAO,KAAK;IACnB,KAAKA;IACL;GACF;GACA,IAAI,UAAU,MAAM,OAAO,KAAK,GAC9B,OAAO;EAEX;EACA,IAAI,OAAO,SAAS,GAClB,QAAQ,OAAO,KAAK;CAGxB;CAEA,MAAM,KAAa,OAAwB,OAAc,MAAe;EACtE,IAAI,KAAKL,cAAc,KAAA,GAAW;GAChC,KAAKA,YAAY;GACjB,KAAKC,cAAc;GACnB,KAAKC,cAAc;GACnB,KAAKC,SAAS;GACd;EACF;EAEA,MAAM,OAAQ,KAAKC,0BAAU,IAAI,IAAI;EACrC,MAAM,UAAU,oBAAoB,MAAM,KAAK,MAAM;EAErD,MAAM,QAAkB;GAAC;GAAO,KAAK,IAAI,QAAQ,IAAI;EAAC;EACtD,MAAM,SAAS,QAAQ,IAAI,KAAK;EAEhC,IAAI,WAAW,KAAA,GACb,QAAQ,IAAI,OAAO,KAAK;OACnB,IAAI,EAAE,kBAAkB,MAC7B,QAAQ,IAAI,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,CAAC,CAAC;OACtC;GACL,IAAI,OAAO,QAAA,IAIT;GAEF,OAAO,IAAI,KAAK;EAClB;EACA,KAAKC;EACL,KAAKC,YAAY,IAAI;CACvB;;;;;;;;;;;;CAaA,QAAQ,MAAS,IAAgB;EAC/B,IAAI,KAAKH,WAAW,MAAM;GACxB,KAAKA,SAAS;GACd,OAAO;EACT;EACA,MAAM,OAAO,KAAKC;EAClB,IAAI,SAAS,KAAA,GACX,OAAO;EAET,KAAK,MAAM,WAAW,KAAK,OAAO,GAChC,KAAK,MAAM,CAAC,OAAO,WAAW,SAAS;GACrC,IAAI,EAAE,kBAAkB,MAAM;IAC5B,IAAI,OAAO,IAAI,MAAM,MAAM,MAAM;KAC/B,QAAQ,IAAI,OAAO;MAAC,OAAO,OAAO;MAAO,KAAK,IAAI,QAAQ,EAAE;KAAC,CAAC;KAC9D,OAAO;IACT;IACA;GACF;GACA,KAAK,MAAM,SAAS,QAClB,IAAI,MAAM,IAAI,MAAM,MAAM,MAAM;IAC9B,OAAO,OAAO,KAAK;IACnB,OAAO,IAAI;KAAC,OAAO,MAAM;KAAO,KAAK,IAAI,QAAQ,EAAE;IAAC,CAAC;IACrD,OAAO;GACT;EAEJ;EAEF,OAAO;CACT;;;;;;;;;;;;;CAcA,YAAY,MAA0D;EACpE,IAAI,KAAKC,YAAY,KAAKE,UACxB;EAEF,IAAI,OAAO;EACX,KAAK,MAAM,CAAC,KAAK,YAAY,MAAM;GACjC,KAAK,MAAM,CAAC,OAAO,WAAW,SAAS;IACrC,IAAI,EAAE,kBAAkB,MAAM;KAC5B,IAAI,OAAO,IAAI,MAAM,MAAM,KAAA,GACzB,QAAQ,OAAO,KAAK;UAEpB;KAEF;IACF;IACA,KAAK,MAAM,SAAS,QAClB,IAAI,MAAM,IAAI,MAAM,MAAM,KAAA,GACxB,OAAO,OAAO,KAAK;SAEnB;IAGJ,IAAI,OAAO,SAAS,GAClB,QAAQ,OAAO,KAAK;GAExB;GACA,IAAI,QAAQ,SAAS,GACnB,KAAK,OAAO,GAAG;EAEnB;EACA,KAAKF,YAAY;EACjB,KAAKE,WAAW,KAAK,IAAI,eAAe,OAAO,CAAC;CAClD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,YAAb,MAAyC;CACvC,0BAAmB,IAAI,IAAwB;CAC/C,WAAW;CAEX,IAAI,MAA6B;EAC/B,MAAM,MAAM,KAAKC,QAAQ,IAAI,IAAI;EACjC,IAAI,QAAQ,KAAA,GACV;EAEF,MAAM,OAAO,IAAI,MAAM;EACvB,IAAI,SAAS,KAAA,GACX,KAAKA,QAAQ,OAAO,IAAI;EAE1B,OAAO;CACT;CAEA,IAAI,MAAc,MAAe;EAC/B,MAAM,SAAS,KAAKA;EACpB,OAAO,IAAI,MAAM,IAAI,QAAQ,IAAI,CAAC;EAClC,IAAI,OAAO,OAAO,KAAKD,UACrB;EAEF,KAAK,MAAM,CAAC,GAAG,QAAQ,QACrB,IAAI,IAAI,MAAM,MAAM,KAAA,GAClB,OAAO,OAAO,CAAC;EAGnB,KAAKA,WAAW,KAAK,IAAI,eAAe,OAAO,OAAO,CAAC;CACzD;AACF"}
+{"version":3,"file":"query-transitions.js","names":[],"sources":["../../../../../zql/src/query/query-transitions.ts"],"sourcesContent":["import {deepEqual, type ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getOrInsertComputed, newMap} from '../../../shared/src/map.ts';\n\n/**\n * A transition tree for interning immutable builder objects, modelled on V8's\n * hidden-class transitions.\n *\n * Each node keeps a map from a *transition* (an operation plus its arguments) to\n * the node that operation produces. Applying the same operation to the same node\n * twice therefore yields the same object both times.\n *\n * ## Why not hash?\n *\n * Hashing the resulting AST would work but is far too expensive to do on every\n * builder call. Instead a transition is identified by three things, in\n * decreasing order of how cheap they are to compare:\n *\n * 1. `key` — a short string naming the operation. Callers are expected to hand\n *    in a *stable* string rather than build one per call; see below.\n * 2. `value` — the operation's varying argument, when it is a primitive, used\n *    directly as a `Map` key.\n * 3. `delta` — anything left over, compared with {@link deepEqual}.\n *\n * Splitting 1 from 2 is what makes this fast. Folding the value into the key\n * instead means building a fresh string on every call, and a fresh string has to\n * be hashed from scratch before a `Map` can look it up: measured at ~148ns,\n * against ~10ns to look up the caller's own string, whose hash V8 has already\n * cached on the string object. That difference is larger than everything else a\n * transition does.\n *\n * Comparing only the delta is sound because the parent node is already canonical:\n * two children of the same parent are equal exactly when the operations that\n * produced them are equal. We never deep-compare a whole AST.\n *\n * ## Liveness\n *\n * Children point back at their parents strongly (see `QueryImpl`), so holding a\n * query holds its whole ancestor spine and re-deriving it from the root gives\n * the same object back. The other direction has to be weak, or an interned root\n * — which lives as long as its schema — would retain every query ever derived\n * from it.\n *\n * Weak is expensive, though: `new WeakRef` costs on the order of a hundred\n * nanoseconds, more than everything else a transition does put together, and it\n * adds GC work later. So the *first* transition out of a node is held strongly\n * instead, in fields on this object, with no `WeakRef` at all.\n *\n * That is safe because strong first-children form a path, not a tree: each node\n * pins at most one child, which pins at most one of its own. The retained set\n * per root is bounded by the depth of a builder chain — a handful of queries —\n * rather than by how many distinct queries an app builds. Everything past the\n * first child is weak, so the unbounded cases (a search box typing into\n * `where:title:=:s<text>`, a row id per list item) stay collectible.\n *\n * It is also where the wins are: a chain like `q.where(…).orderBy(…).limit(…)`\n * gives every node exactly one child, so building it allocates no `WeakRef`s and\n * looks up through a field compare rather than a hash lookup.\n *\n * What a collected child leaves behind is a cleared `WeakRef` and its map key. A\n * lookup drops those as it walks, which covers every key that is asked for\n * again. A key that is *never* asked for again is handled by the sweep.\n *\n * ## Best effort\n *\n * Interning is a cache, not a guarantee: a missed lookup only costs an extra\n * object. See {@link MAX_SCAN} for the one case where we deliberately give\n * up.\n *\n * ## Identity vs. hash\n *\n * Identity implies an equal query hash, but the tree alone does not give the\n * converse. `normalizeAST` sorts `related` and `and`/`or` conditions, so\n * `q.where(a).where(b)` and `q.where(b).where(a)` hash the same while being\n * distinct paths, and so distinct nodes. {@link HashIndex} is the second\n * level that folds those together once they have been hashed. Callers that\n * need the normalizing behavior for a query that may not have been must keep\n * using the hash.\n */\n\n/**\n * The delta identifying a transition, or `undefined` when the key already\n * determines the result on its own.\n */\nexport type Delta = ReadonlyJSONValue | undefined;\n\ntype Entry<T extends object> = {\n  readonly delta: Delta;\n  readonly ref: WeakRef<T>;\n};\n\n/**\n * A bucket holds a bare entry in the common single-entry case and is promoted to\n * a `Set` only on collision, so the usual transition allocates no container.\n *\n * A `Set` rather than an array: deleting during iteration is well defined, so a\n * lookup prunes collected entries and stops at its match in a single pass, and\n * removing an entry is O(1) rather than a scan.\n */\ntype Bucket<T extends object> = Entry<T> | Set<Entry<T>>;\n\n/** The varying argument of a transition, when it is one. */\nexport type TransitionValue = string | number | boolean | null | undefined;\n\n/**\n * The longest `deepEqual` scan we are willing to do on a lookup.\n *\n * This is a *latency* bound, not a memory bound — memory is already handled,\n * since entries are weak and are pruned both by the sweep and by any lookup that\n * walks past them, so a bucket only ever holds children that are still alive.\n *\n * Note what happens at the limit: we stop *storing*, we do not evict. Evicting\n * would de-intern objects that are still in use, and on a sequential sweep of a\n * live set larger than the limit it drives the hit rate to zero — each lookup\n * throws out the entry the next one needs. Refusing to store instead leaves\n * every already-shared sibling shared and degrades the surplus to the old\n * behavior of a fresh instance per call.\n *\n * Buckets should rarely get near this. Keys carry the discriminating value\n * wherever it is cheap to, and a key that carries it is *exact*, so it costs no\n * comparison at all: every simple comparison goes that way, and so does a\n * one-hop `exists`, via its sub-query's identity. What is left sharing a bucket\n * is two-hop `exists`, the `and`/`or` trees an expression factory builds, and\n * relationships whose callback varies.\n */\nexport const MAX_SCAN = 64;\n\n/** How large the weak map must get before its first sweep. */\nconst SWEEP_INITIAL = 64;\n\n/** The transitions out of one node. */\nexport class Transitions<T extends object> {\n  // The first transition, held strongly and in place. See \"Liveness\" above.\n  #firstKey: string | undefined;\n  #firstValue: TransitionValue;\n  #firstDelta: Delta;\n  #first: T | undefined;\n\n  // Transitions whose key space is finite and comes from the schema rather than\n  // from user data, held strongly. See `storeBounded`.\n  #bounded: Map<string, T> | undefined;\n\n  // Everything else, weakly. Allocated only if there is a second. Nested so the\n  // value stays a `Map` key of its own rather than part of the string.\n  #rest: Map<string, Map<TransitionValue, Bucket<T>>> | undefined;\n  #sweepAt = SWEEP_INITIAL;\n  #restSize = 0;\n\n  lookupBounded(key: string): T | undefined {\n    return this.#bounded?.get(key);\n  }\n\n  /**\n   * Records a transition whose key space is finite and schema-derived — the base\n   * sub-query handed to a `related`/`exists` callback, keyed by relationship\n   * name.\n   *\n   * These are held strongly. Retention is bounded by the number of relationships\n   * on the table, so it cannot grow with what an app queries for, and in exchange\n   * a relationship traversal allocates no `WeakRef`. Anything keyed by a *value*\n   * — a row id, a search string, a limit — must not come through here.\n   */\n  storeBounded(key: string, value: T): void {\n    (this.#bounded ??= new Map()).set(key, value);\n  }\n\n  lookup(key: string, value: TransitionValue, delta: Delta): T | undefined {\n    if (\n      this.#firstKey === key &&\n      this.#firstValue === value &&\n      deepEqual(this.#firstDelta, delta)\n    ) {\n      return this.#first;\n    }\n    const byValue = this.#rest?.get(key);\n    if (byValue === undefined) {\n      return undefined;\n    }\n    const bucket = byValue.get(value);\n    if (bucket === undefined) {\n      return undefined;\n    }\n\n    if (!(bucket instanceof Set)) {\n      const found = bucket.ref.deref();\n      if (found === undefined) {\n        byValue.delete(value);\n        this.#restSize--;\n        return undefined;\n      }\n      // deepEqual short-circuits on reference equality, which is the fast path\n      // we rely on for deltas built out of already-interned sub-queries.\n      return deepEqual(bucket.delta, delta) ? found : undefined;\n    }\n\n    // One pass: drop what has been collected, stop at the match. Deleting from a\n    // Set while iterating it is well defined — the iterator simply skips what is\n    // gone — so this stays O(n) with no compaction step, and returns early on a\n    // hit rather than walking the whole bucket first.\n    for (const entry of bucket) {\n      const found = entry.ref.deref();\n      if (found === undefined) {\n        bucket.delete(entry);\n        this.#restSize--;\n        continue;\n      }\n      if (deepEqual(entry.delta, delta)) {\n        return found;\n      }\n    }\n    if (bucket.size === 0) {\n      byValue.delete(value);\n    }\n    return undefined;\n  }\n\n  store(key: string, value: TransitionValue, delta: Delta, node: T): void {\n    if (this.#firstKey === undefined) {\n      this.#firstKey = key;\n      this.#firstValue = value;\n      this.#firstDelta = delta;\n      this.#first = node;\n      return;\n    }\n\n    const rest = (this.#rest ??= new Map());\n    const byValue = getOrInsertComputed(rest, key, newMap);\n\n    const entry: Entry<T> = {delta, ref: new WeakRef(node)};\n    const bucket = byValue.get(value);\n\n    if (bucket === undefined) {\n      byValue.set(value, entry);\n    } else if (!(bucket instanceof Set)) {\n      byValue.set(value, new Set([bucket, entry]));\n    } else {\n      if (bucket.size >= MAX_SCAN) {\n        // Leave the bucket alone; see MAX_SCAN. `node` is simply not shared.\n        // A store only follows a failed lookup, which has just pruned, so this\n        // is measured against entries that are actually still alive.\n        return;\n      }\n      bucket.add(entry);\n    }\n    this.#restSize++;\n    this.#maybeSweep(rest);\n  }\n\n  /**\n   * Re-points the transition that produced `from` at `to`, so the next lookup\n   * along that path yields `to` instead. This is how {@link HashIndex}\n   * converges two paths on one node: `from` keeps its identity, since it has\n   * already been handed out, and its path is redirected for the rebuilds that\n   * follow.\n   *\n   * Scans rather than taking a key. This runs once per redirected path, so a\n   * walk here is cheaper than the fields every node would need to carry to\n   * name its own transition.\n   */\n  replace(from: T, to: T): boolean {\n    if (this.#first === from) {\n      this.#first = to;\n      return true;\n    }\n    const rest = this.#rest;\n    if (rest === undefined) {\n      return false;\n    }\n    for (const byValue of rest.values()) {\n      for (const [value, bucket] of byValue) {\n        if (!(bucket instanceof Set)) {\n          if (bucket.ref.deref() === from) {\n            byValue.set(value, {delta: bucket.delta, ref: new WeakRef(to)});\n            return true;\n          }\n          continue;\n        }\n        for (const entry of bucket) {\n          if (entry.ref.deref() === from) {\n            bucket.delete(entry);\n            bucket.add({delta: entry.delta, ref: new WeakRef(to)});\n            return true;\n          }\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Drops entries for collected values, if the map has grown enough to be worth\n   * walking.\n   *\n   * A lookup already prunes whatever it walks past, which covers every key that\n   * is asked for again. This is for the key that is not: a miss on a fresh key\n   * returns without touching any existing entry, so nothing would ever notice\n   * that those had died. Doubling the threshold off whatever survives keeps this\n   * amortized O(1) per insert whether or not there was anything to reclaim, and\n   * it is self-limiting — only a node that keeps taking inserts can keep\n   * accumulating, and taking inserts is what triggers the sweep.\n   */\n  #maybeSweep(rest: Map<string, Map<TransitionValue, Bucket<T>>>): void {\n    if (this.#restSize < this.#sweepAt) {\n      return;\n    }\n    let live = 0;\n    for (const [key, byValue] of rest) {\n      for (const [value, bucket] of byValue) {\n        if (!(bucket instanceof Set)) {\n          if (bucket.ref.deref() === undefined) {\n            byValue.delete(value);\n          } else {\n            live++;\n          }\n          continue;\n        }\n        for (const entry of bucket) {\n          if (entry.ref.deref() === undefined) {\n            bucket.delete(entry);\n          } else {\n            live++;\n          }\n        }\n        if (bucket.size === 0) {\n          byValue.delete(value);\n        }\n      }\n      if (byValue.size === 0) {\n        rest.delete(key);\n      }\n    }\n    this.#restSize = live;\n    this.#sweepAt = Math.max(SWEEP_INITIAL, live * 2);\n  }\n}\n\n/**\n * The second level of interning: nodes keyed by *content* rather than by the\n * path that built them.\n *\n * The transition tree cannot see that `q.where(a).where(b)` and\n * `q.where(b).where(a)` are the same query. `normalizeAST` sorts conditions\n * and `related` entries, so the two build byte-identical ASTs, but they are\n * different paths and so different nodes. This index closes that gap, keyed by\n * the query's hash.\n *\n * It is consulted when a query is *hashed*, not when it is built. Hashing on\n * every tree miss would make a cold chain pay for a hash per node, where the\n * uninterned code paid for one at the end, if at all -- and server-side queries\n * are built cold, once, per request. The consumers that key by hash already\n * hash the queries they care about, so doing the work there costs one map\n * lookup on top of a hash that was being computed anyway, and nothing at all\n * for a query nobody hashes.\n *\n * On a hit the query being hashed keeps its identity, since it has already\n * been handed out. Its *transition* is re-pointed at the existing node instead\n * (see {@link Transitions.replace}), so the next rebuild along that path\n * yields the shared instance. As with the tree this is a cache: the rebuild\n * after a redirect is what converges, not the call that found the duplicate.\n *\n * One index per root, which is what scopes it. Two roots never share an index,\n * so queries against different schemas or different delegates -- neither of\n * which the hash covers -- can never be conflated. Entries are weak: a cleared\n * one is dropped by the lookup that finds it, or by a sweep once the map has\n * doubled since the last one.\n */\nexport class HashIndex<T extends object> {\n  readonly #byHash = new Map<string, WeakRef<T>>();\n  #sweepAt = SWEEP_INITIAL;\n\n  get(hash: string): T | undefined {\n    const ref = this.#byHash.get(hash);\n    if (ref === undefined) {\n      return undefined;\n    }\n    const node = ref.deref();\n    if (node === undefined) {\n      this.#byHash.delete(hash);\n    }\n    return node;\n  }\n\n  set(hash: string, node: T): void {\n    const byHash = this.#byHash;\n    byHash.set(hash, new WeakRef(node));\n    if (byHash.size < this.#sweepAt) {\n      return;\n    }\n    for (const [h, ref] of byHash) {\n      if (ref.deref() === undefined) {\n        byHash.delete(h);\n      }\n    }\n    this.#sweepAt = Math.max(SWEEP_INITIAL, byHash.size * 2);\n  }\n}\n"],"mappings":"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"}

package/out/zql/src/query/runnable-query-impl.js

@@ -10,7 +10,8 @@ import { QueryImpl } from "./query-impl.js";
 */
 var rootsByDelegate = /* @__PURE__ */ new WeakMap();
 function newRunnableQuery(delegate, schema, table) {
-	const roots = getOrInsertComputed(getOrInsertComputed(rootsByDelegate, delegate, newWeakMap), schema, newMap);
+	const bySchema = getOrInsertComputed(rootsByDelegate, delegate, newWeakMap);
+	const roots = getOrInsertComputed(bySchema, schema, newMap);
 	const existing = roots.get(table)?.deref();
 	if (existing) return existing;
 	const created = new RunnableQueryImpl(delegate, schema, table, tableAST(table), defaultFormat, void 0);
@@ -43,6 +44,6 @@ var RunnableQueryImpl = class RunnableQueryImpl extends QueryImpl {
 	}
 };
 //#endregion
-export { newRunnableQuery };
+export { RunnableQueryImpl, newRunnableQuery };
 
 //# sourceMappingURL=runnable-query-impl.js.map

package/out/zql/src/query/runnable-query-impl.js.map

@@ -1 +1 @@
-{"version":3,"file":"runnable-query-impl.js","names":["#delegate"],"sources":["../../../../../zql/src/query/runnable-query-impl.ts"],"sourcesContent":["import {\n  getOrInsertComputed,\n  newMap,\n  newWeakMap,\n} from '../../../shared/src/map.ts';\nimport {\n  tableAST,\n  type NormalizedAST,\n  type System,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport {defaultFormat} from '../ivm/default-format.ts';\nimport type {Format, ViewFactory} from '../ivm/view.ts';\nimport type {CustomQueryID} from './named.ts';\nimport type {QueryDelegate} from './query-delegate.ts';\nimport {QueryImpl} from './query-impl.ts';\nimport type {\n  HumanReadable,\n  MaterializeOptions,\n  PreloadOptions,\n  PullRow,\n  Query,\n  RunOptions,\n} from './query.ts';\nimport type {TTL} from './ttl.ts';\nimport type {TypedView} from './typed-view.ts';\n\n/**\n * Runnable roots are interned per delegate *and* schema -- a query is only\n * interchangeable with another if it would run against the same delegate. See\n * `query-transitions.ts` for why roots need to be shared at all.\n */\nconst rootsByDelegate = new WeakMap<\n  QueryDelegate,\n  // oxlint-disable-next-line no-explicit-any\n  WeakMap<Schema, Map<string, WeakRef<RunnableQueryImpl<any, any, any>>>>\n>();\n\nexport function newRunnableQuery<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n>(\n  delegate: QueryDelegate,\n  schema: TSchema,\n  table: TTable,\n): Query<TTable, TSchema> {\n  const bySchema = getOrInsertComputed(rootsByDelegate, delegate, newWeakMap);\n  const roots = getOrInsertComputed(bySchema, schema, newMap);\n\n  const existing = roots.get(table)?.deref();\n  if (existing) {\n    return existing as RunnableQueryImpl<TTable, TSchema>;\n  }\n\n  const created = new RunnableQueryImpl<TTable, TSchema>(\n    delegate,\n    schema,\n    table,\n    tableAST(table),\n    defaultFormat,\n    undefined,\n  );\n  roots.set(table, new WeakRef(created));\n  return created;\n}\n\nexport class RunnableQueryImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn = PullRow<TTable, TSchema>,\n>\n  extends QueryImpl<TTable, TSchema, TReturn>\n  implements Query<TTable, TSchema, TReturn>\n{\n  readonly #delegate: QueryDelegate;\n\n  constructor(\n    delegate: QueryDelegate,\n    schema: TSchema,\n    tableName: TTable,\n    ast: NormalizedAST = tableAST(tableName),\n    format: Format = defaultFormat,\n    system: System = 'client',\n    customQueryID?: CustomQueryID,\n    currentJunction?: string,\n  ) {\n    super(\n      schema,\n      tableName,\n      ast,\n      format,\n      system,\n      customQueryID,\n      currentJunction,\n      (tableName, ast, format, customQueryID, currentJunction) =>\n        new RunnableQueryImpl(\n          delegate,\n          schema,\n          tableName,\n          ast,\n          format,\n          system,\n          customQueryID,\n          currentJunction,\n        ),\n    );\n    this.#delegate = delegate;\n  }\n\n  override run(options?: RunOptions): Promise<HumanReadable<TReturn>> {\n    // The type arguments on the delegate calls in this class are written out\n    // because tsc 7.0.2 fails to infer them in some program layouts (the\n    // packages/zero declaration build, apps/zero-throughput): inference\n    // collapses TSchema to its constraint and the call misreports as a\n    // TS2345 assignability error. Explicit arguments are inert where\n    // inference works and correct where it does not.\n    return this.#delegate.run<TTable, TSchema, TReturn>(this, options);\n  }\n\n  override preload(options?: PreloadOptions): {\n    cleanup: () => void;\n    complete: Promise<void>;\n    cached: Promise<void>;\n  } {\n    return this.#delegate.preload<TTable, TSchema, TReturn>(this, options);\n  }\n\n  override materialize(ttl?: TTL): TypedView<HumanReadable<TReturn>>;\n  override materialize<T>(\n    factory: ViewFactory<TTable, TSchema, TReturn, T>,\n    ttl?: TTL,\n  ): T;\n  override materialize<T>(\n    factory?: unknown,\n    ttl?: unknown,\n  ): T | TypedView<HumanReadable<TReturn>> {\n    let actualFactory: ViewFactory<TTable, TSchema, TReturn, T> | undefined;\n    let options: MaterializeOptions | undefined;\n\n    if (typeof factory === 'function') {\n      actualFactory = factory as ViewFactory<TTable, TSchema, TReturn, T>;\n      options = {ttl: ttl as TTL | undefined};\n    } else {\n      actualFactory = undefined;\n      options = {ttl: factory as TTL | undefined};\n    }\n\n    return this.#delegate.materialize<TTable, TSchema, TReturn, T>(\n      this,\n      actualFactory,\n      options,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;AAgCA,IAAM,kCAAkB,IAAI,QAI1B;AAEF,SAAgB,iBAId,UACA,QACA,OACwB;CAExB,MAAM,QAAQ,oBADG,oBAAoB,iBAAiB,UAAU,UAC9B,GAAU,QAAQ,MAAM;CAE1D,MAAM,WAAW,MAAM,IAAI,KAAK,GAAG,MAAM;CACzC,IAAI,UACF,OAAO;CAGT,MAAM,UAAU,IAAI,kBAClB,UACA,QACA,OACA,SAAS,KAAK,GACd,eACA,KAAA,CACF;CACA,MAAM,IAAI,OAAO,IAAI,QAAQ,OAAO,CAAC;CACrC,OAAO;AACT;AAEA,IAAa,oBAAb,MAAa,0BAKH,UAEV;CACE;CAEA,YACE,UACA,QACA,WACA,MAAqB,SAAS,SAAS,GACvC,SAAiB,eACjB,SAAiB,UACjB,eACA,iBACA;EACA,MACE,QACA,WACA,KACA,QACA,QACA,eACA,kBACC,WAAW,KAAK,QAAQ,eAAe,oBACtC,IAAI,kBACF,UACA,QACA,WACA,KACA,QACA,QACA,eACA,eACF,CACJ;EACA,KAAKA,YAAY;CACnB;CAEA,IAAa,SAAuD;EAOlE,OAAO,KAAKA,UAAU,IAA8B,MAAM,OAAO;CACnE;CAEA,QAAiB,SAIf;EACA,OAAO,KAAKA,UAAU,QAAkC,MAAM,OAAO;CACvE;CAOA,YACE,SACA,KACuC;EACvC,IAAI;EACJ,IAAI;EAEJ,IAAI,OAAO,YAAY,YAAY;GACjC,gBAAgB;GAChB,UAAU,EAAM,IAAsB;EACxC,OAAO;GACL,gBAAgB,KAAA;GAChB,UAAU,EAAC,KAAK,QAA0B;EAC5C;EAEA,OAAO,KAAKA,UAAU,YACpB,MACA,eACA,OACF;CACF;AACF"}
+{"version":3,"file":"runnable-query-impl.js","names":[],"sources":["../../../../../zql/src/query/runnable-query-impl.ts"],"sourcesContent":["import {\n  getOrInsertComputed,\n  newMap,\n  newWeakMap,\n} from '../../../shared/src/map.ts';\nimport {\n  tableAST,\n  type NormalizedAST,\n  type System,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport {defaultFormat} from '../ivm/default-format.ts';\nimport type {Format, ViewFactory} from '../ivm/view.ts';\nimport type {CustomQueryID} from './named.ts';\nimport type {QueryDelegate} from './query-delegate.ts';\nimport {QueryImpl} from './query-impl.ts';\nimport type {\n  HumanReadable,\n  MaterializeOptions,\n  PreloadOptions,\n  PullRow,\n  Query,\n  RunOptions,\n} from './query.ts';\nimport type {TTL} from './ttl.ts';\nimport type {TypedView} from './typed-view.ts';\n\n/**\n * Runnable roots are interned per delegate *and* schema -- a query is only\n * interchangeable with another if it would run against the same delegate. See\n * `query-transitions.ts` for why roots need to be shared at all.\n */\nconst rootsByDelegate = new WeakMap<\n  QueryDelegate,\n  // oxlint-disable-next-line no-explicit-any\n  WeakMap<Schema, Map<string, WeakRef<RunnableQueryImpl<any, any, any>>>>\n>();\n\nexport function newRunnableQuery<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n>(\n  delegate: QueryDelegate,\n  schema: TSchema,\n  table: TTable,\n): Query<TTable, TSchema> {\n  const bySchema = getOrInsertComputed(rootsByDelegate, delegate, newWeakMap);\n  const roots = getOrInsertComputed(bySchema, schema, newMap);\n\n  const existing = roots.get(table)?.deref();\n  if (existing) {\n    return existing as RunnableQueryImpl<TTable, TSchema>;\n  }\n\n  const created = new RunnableQueryImpl<TTable, TSchema>(\n    delegate,\n    schema,\n    table,\n    tableAST(table),\n    defaultFormat,\n    undefined,\n  );\n  roots.set(table, new WeakRef(created));\n  return created;\n}\n\nexport class RunnableQueryImpl<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn = PullRow<TTable, TSchema>,\n>\n  extends QueryImpl<TTable, TSchema, TReturn>\n  implements Query<TTable, TSchema, TReturn>\n{\n  readonly #delegate: QueryDelegate;\n\n  constructor(\n    delegate: QueryDelegate,\n    schema: TSchema,\n    tableName: TTable,\n    ast: NormalizedAST = tableAST(tableName),\n    format: Format = defaultFormat,\n    system: System = 'client',\n    customQueryID?: CustomQueryID,\n    currentJunction?: string,\n  ) {\n    super(\n      schema,\n      tableName,\n      ast,\n      format,\n      system,\n      customQueryID,\n      currentJunction,\n      (tableName, ast, format, customQueryID, currentJunction) =>\n        new RunnableQueryImpl(\n          delegate,\n          schema,\n          tableName,\n          ast,\n          format,\n          system,\n          customQueryID,\n          currentJunction,\n        ),\n    );\n    this.#delegate = delegate;\n  }\n\n  override run(options?: RunOptions): Promise<HumanReadable<TReturn>> {\n    // The type arguments on the delegate calls in this class are written out\n    // because tsc 7.0.2 fails to infer them in some program layouts (the\n    // packages/zero declaration build, apps/zero-throughput): inference\n    // collapses TSchema to its constraint and the call misreports as a\n    // TS2345 assignability error. Explicit arguments are inert where\n    // inference works and correct where it does not.\n    return this.#delegate.run<TTable, TSchema, TReturn>(this, options);\n  }\n\n  override preload(options?: PreloadOptions): {\n    cleanup: () => void;\n    complete: Promise<void>;\n    cached: Promise<void>;\n  } {\n    return this.#delegate.preload<TTable, TSchema, TReturn>(this, options);\n  }\n\n  override materialize(ttl?: TTL): TypedView<HumanReadable<TReturn>>;\n  override materialize<T>(\n    factory: ViewFactory<TTable, TSchema, TReturn, T>,\n    ttl?: TTL,\n  ): T;\n  override materialize<T>(\n    factory?: unknown,\n    ttl?: unknown,\n  ): T | TypedView<HumanReadable<TReturn>> {\n    let actualFactory: ViewFactory<TTable, TSchema, TReturn, T> | undefined;\n    let options: MaterializeOptions | undefined;\n\n    if (typeof factory === 'function') {\n      actualFactory = factory as ViewFactory<TTable, TSchema, TReturn, T>;\n      options = {ttl: ttl as TTL | undefined};\n    } else {\n      actualFactory = undefined;\n      options = {ttl: factory as TTL | undefined};\n    }\n\n    return this.#delegate.materialize<TTable, TSchema, TReturn, T>(\n      this,\n      actualFactory,\n      options,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;AAgCA,IAAM,kCAAkB,IAAI,QAI1B;AAEF,SAAgB,iBAId,UACA,QACA,OACwB;CACxB,MAAM,WAAW,oBAAoB,iBAAiB,UAAU,UAAU;CAC1E,MAAM,QAAQ,oBAAoB,UAAU,QAAQ,MAAM;CAE1D,MAAM,WAAW,MAAM,IAAI,KAAK,CAAC,EAAE,MAAM;CACzC,IAAI,UACF,OAAO;CAGT,MAAM,UAAU,IAAI,kBAClB,UACA,QACA,OACA,SAAS,KAAK,GACd,eACA,KAAA,CACF;CACA,MAAM,IAAI,OAAO,IAAI,QAAQ,OAAO,CAAC;CACrC,OAAO;AACT;AAEA,IAAa,oBAAb,MAAa,0BAKH,UAEV;CACE;CAEA,YACE,UACA,QACA,WACA,MAAqB,SAAS,SAAS,GACvC,SAAiB,eACjB,SAAiB,UACjB,eACA,iBACA;EACA,MACE,QACA,WACA,KACA,QACA,QACA,eACA,kBACC,WAAW,KAAK,QAAQ,eAAe,oBACtC,IAAI,kBACF,UACA,QACA,WACA,KACA,QACA,QACA,eACA,eACF,CACJ;EACA,KAAK,YAAY;CACnB;CAEA,IAAa,SAAuD;EAOlE,OAAO,KAAK,UAAU,IAA8B,MAAM,OAAO;CACnE;CAEA,QAAiB,SAIf;EACA,OAAO,KAAK,UAAU,QAAkC,MAAM,OAAO;CACvE;CAOA,YACE,SACA,KACuC;EACvC,IAAI;EACJ,IAAI;EAEJ,IAAI,OAAO,YAAY,YAAY;GACjC,gBAAgB;GAChB,UAAU,EAAM,IAAsB;EACxC,OAAO;GACL,gBAAgB,KAAA;GAChB,UAAU,EAAC,KAAK,QAA0B;EAC5C;EAEA,OAAO,KAAK,UAAU,YACpB,MACA,eACA,OACF;CACF;AACF"}

package/out/zql/src/query/static-query.js.map

@@ -1 +1 @@
-{"version":3,"file":"static-query.js","names":[],"sources":["../../../../../zql/src/query/static-query.ts"],"sourcesContent":["import type {Schema} from '../../../zero-types/src/schema.ts';\nimport {defaultFormat} from '../ivm/default-format.ts';\nimport {newQueryImpl, type QueryImpl} from './query-impl.ts';\nimport type {PullRow, Query} from './query.ts';\n\nexport function newStaticQuery<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn = PullRow<TTable, TSchema>,\n>(schema: TSchema, tableName: TTable): Query<TTable, TSchema, TReturn> {\n  return newQueryImpl(\n    schema,\n    tableName,\n    {table: tableName},\n    defaultFormat,\n    'permissions',\n  );\n}\n\nexport function newExpressionBuilder<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n>(schema: TSchema, tableName: TTable) {\n  const q = newStaticQuery(schema, tableName);\n  return (q as QueryImpl<TTable, TSchema>).expressionBuilder();\n}\n"],"mappings":";;;AAKA,SAAgB,eAId,QAAiB,WAAoD;CACrE,OAAO,aACL,QACA,WACA,EAAC,OAAO,UAAS,GACjB,eACA,aACF;AACF;AAEA,SAAgB,qBAGd,QAAiB,WAAmB;CAEpC,OADU,eAAe,QAAQ,SACzB,EAAiC,kBAAkB;AAC7D"}
+{"version":3,"file":"static-query.js","names":[],"sources":["../../../../../zql/src/query/static-query.ts"],"sourcesContent":["import type {Schema} from '../../../zero-types/src/schema.ts';\nimport {defaultFormat} from '../ivm/default-format.ts';\nimport {newQueryImpl, type QueryImpl} from './query-impl.ts';\nimport type {PullRow, Query} from './query.ts';\n\nexport function newStaticQuery<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n  TReturn = PullRow<TTable, TSchema>,\n>(schema: TSchema, tableName: TTable): Query<TTable, TSchema, TReturn> {\n  return newQueryImpl(\n    schema,\n    tableName,\n    {table: tableName},\n    defaultFormat,\n    'permissions',\n  );\n}\n\nexport function newExpressionBuilder<\n  TTable extends keyof TSchema['tables'] & string,\n  TSchema extends Schema,\n>(schema: TSchema, tableName: TTable) {\n  const q = newStaticQuery(schema, tableName);\n  return (q as QueryImpl<TTable, TSchema>).expressionBuilder();\n}\n"],"mappings":";;;AAKA,SAAgB,eAId,QAAiB,WAAoD;CACrE,OAAO,aACL,QACA,WACA,EAAC,OAAO,UAAS,GACjB,eACA,aACF;AACF;AAEA,SAAgB,qBAGd,QAAiB,WAAmB;CAEpC,OADU,eAAe,QAAQ,SACzB,CAAA,CAAiC,kBAAkB;AAC7D"}

package/out/zql/src/query/ttl.js

@@ -1,12 +1,12 @@
 //#region ../zql/src/query/ttl.ts
-var DEFAULT_TTL_MS = 1e3 * 60 * 5;
-var MAX_TTL_MS = 1e3 * 60 * 10;
+var DEFAULT_TTL_MS = 3e5;
+var MAX_TTL_MS = 6e5;
 var multiplier = {
 	s: 1e3,
-	m: 60 * 1e3,
-	h: 3600 * 1e3,
-	d: 1440 * 60 * 1e3,
-	y: 365 * 24 * 60 * 60 * 1e3
+	m: 6e4,
+	h: 36e5,
+	d: 864e5,
+	y: 31536e6
 };
 function parseTTL(ttl) {
 	if (typeof ttl === "number") return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;
@@ -42,13 +42,13 @@ function normalizeTTL(ttl) {
 }
 function clampTTL(ttl, lc) {
 	const parsedTTL = parseTTL(ttl);
-	if (parsedTTL === -1 || parsedTTL > 600 * 1e3) {
+	if (parsedTTL === -1 || parsedTTL > 6e5) {
 		lc?.warn?.(`TTL (${ttl}) is too high, clamping to 10m`);
 		return parseTTL("10m");
 	}
 	return parsedTTL;
 }
 //#endregion
-export { DEFAULT_TTL_MS, MAX_TTL_MS, clampTTL, compareTTL, normalizeTTL };
+export { DEFAULT_TTL_MS, MAX_TTL_MS, clampTTL, compareTTL, normalizeTTL, parseTTL };
 
 //# sourceMappingURL=ttl.js.map

package/out/zql/src/query/ttl.js.map

@@ -1 +1 @@
-{"version":3,"file":"ttl.js","names":[],"sources":["../../../../../zql/src/query/ttl.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\n\nexport type TimeUnit = 's' | 'm' | 'h' | 'd' | 'y';\n\n/**\n * Time To Live. This is used for query expiration.\n * - `forever` means the query will never expire.\n * - `none` means the query will expire immediately.\n * - A number means the query will expire after that many milliseconds.\n * - A negative number means the query will never expire, this is same as 'forever'.\n * - A string like `1s` means the query will expire after that many seconds.\n * - A string like `1m` means the query will expire after that many minutes.\n * - A string like `1h` means the query will expire after that many hours.\n * - A string like `1d` means the query will expire after that many days.\n * - A string like `1y` means the query will expire after that many years.\n */\nexport type TTL = `${number}${TimeUnit}` | 'forever' | 'none' | number;\n\nexport const DEFAULT_TTL: TTL = '5m';\nexport const DEFAULT_TTL_MS = 1_000 * 60 * 5;\n\nexport const DEFAULT_PRELOAD_TTL: TTL = 'none';\nexport const DEFAULT_PRELOAD_TTL_MS = 0;\n\nexport const MAX_TTL: TTL = '10m';\nexport const MAX_TTL_MS = 1_000 * 60 * 10;\n\nconst multiplier = {\n  s: 1000,\n  m: 60 * 1000,\n  h: 60 * 60 * 1000,\n  d: 24 * 60 * 60 * 1000,\n  y: 365 * 24 * 60 * 60 * 1000,\n} as const;\n\nexport function parseTTL(ttl: TTL): number {\n  if (typeof ttl === 'number') {\n    return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;\n  }\n  if (ttl === 'none') {\n    return 0;\n  }\n  if (ttl === 'forever') {\n    return -1;\n  }\n  const multi = multiplier[ttl.at(-1) as TimeUnit];\n  return Number(ttl.slice(0, -1)) * multi;\n}\n\nexport function compareTTL(a: TTL, b: TTL): number {\n  const ap = parseTTL(a);\n  const bp = parseTTL(b);\n  if (ap === -1 && bp !== -1) {\n    return 1;\n  }\n  if (ap !== -1 && bp === -1) {\n    return -1;\n  }\n  return ap - bp;\n}\n\nexport function normalizeTTL(ttl: TTL): TTL {\n  if (typeof ttl === 'string') {\n    return ttl;\n  }\n\n  if (ttl < 0) {\n    return 'forever';\n  }\n\n  if (ttl === 0) {\n    return 'none';\n  }\n\n  let shortest = ttl.toString();\n  const lengthOfNumber = shortest.length;\n  for (const unit of ['y', 'd', 'h', 'm', 's'] as const) {\n    const multi = multiplier[unit];\n    const value = ttl / multi;\n    const candidate = `${value}${unit}`;\n    if (candidate.length < shortest.length) {\n      shortest = candidate;\n    }\n  }\n\n  return (shortest.length < lengthOfNumber ? shortest : ttl) as TTL;\n}\n\nexport function clampTTL(ttl: TTL, lc?: Pick<LogContext, 'warn'>): number {\n  const parsedTTL = parseTTL(ttl);\n  if (parsedTTL === -1 || parsedTTL > 10 * 60 * 1000) {\n    // 10 minutes in milliseconds\n    lc?.warn?.(`TTL (${ttl}) is too high, clamping to ${MAX_TTL}`);\n    return parseTTL(MAX_TTL);\n  }\n  return parsedTTL;\n}\n"],"mappings":";AAmBA,IAAa,iBAAiB,MAAQ,KAAK;AAM3C,IAAa,aAAa,MAAQ,KAAK;AAEvC,IAAM,aAAa;CACjB,GAAG;CACH,GAAG,KAAK;CACR,GAAG,OAAU;CACb,GAAG,OAAU,KAAK;CAClB,GAAG,MAAM,KAAK,KAAK,KAAK;AAC1B;AAEA,SAAgB,SAAS,KAAkB;CACzC,IAAI,OAAO,QAAQ,UACjB,OAAO,OAAO,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,SAAS,GAAG,KAAK,MAAM,IAAI,KAAK;CAEzE,IAAI,QAAQ,QACV,OAAO;CAET,IAAI,QAAQ,WACV,OAAO;CAET,MAAM,QAAQ,WAAW,IAAI,GAAG,EAAE;CAClC,OAAO,OAAO,IAAI,MAAM,GAAG,EAAE,CAAC,IAAI;AACpC;AAEA,SAAgB,WAAW,GAAQ,GAAgB;CACjD,MAAM,KAAK,SAAS,CAAC;CACrB,MAAM,KAAK,SAAS,CAAC;CACrB,IAAI,OAAO,MAAM,OAAO,IACtB,OAAO;CAET,IAAI,OAAO,MAAM,OAAO,IACtB,OAAO;CAET,OAAO,KAAK;AACd;AAEA,SAAgB,aAAa,KAAe;CAC1C,IAAI,OAAO,QAAQ,UACjB,OAAO;CAGT,IAAI,MAAM,GACR,OAAO;CAGT,IAAI,QAAQ,GACV,OAAO;CAGT,IAAI,WAAW,IAAI,SAAS;CAC5B,MAAM,iBAAiB,SAAS;CAChC,KAAK,MAAM,QAAQ;EAAC;EAAK;EAAK;EAAK;EAAK;CAAG,GAAY;EAGrD,MAAM,YAAY,GADJ,MADA,WAAW,QAEI;EAC7B,IAAI,UAAU,SAAS,SAAS,QAC9B,WAAW;CAEf;CAEA,OAAQ,SAAS,SAAS,iBAAiB,WAAW;AACxD;AAEA,SAAgB,SAAS,KAAU,IAAuC;CACxE,MAAM,YAAY,SAAS,GAAG;CAC9B,IAAI,cAAc,MAAM,YAAY,MAAU,KAAM;EAElD,IAAI,OAAO,QAAQ,IAAI,+BAAsC;EAC7D,OAAO,SAAA,KAAgB;CACzB;CACA,OAAO;AACT"}
+{"version":3,"file":"ttl.js","names":[],"sources":["../../../../../zql/src/query/ttl.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\n\nexport type TimeUnit = 's' | 'm' | 'h' | 'd' | 'y';\n\n/**\n * Time To Live. This is used for query expiration.\n * - `forever` means the query will never expire.\n * - `none` means the query will expire immediately.\n * - A number means the query will expire after that many milliseconds.\n * - A negative number means the query will never expire, this is same as 'forever'.\n * - A string like `1s` means the query will expire after that many seconds.\n * - A string like `1m` means the query will expire after that many minutes.\n * - A string like `1h` means the query will expire after that many hours.\n * - A string like `1d` means the query will expire after that many days.\n * - A string like `1y` means the query will expire after that many years.\n */\nexport type TTL = `${number}${TimeUnit}` | 'forever' | 'none' | number;\n\nexport const DEFAULT_TTL: TTL = '5m';\nexport const DEFAULT_TTL_MS = 1_000 * 60 * 5;\n\nexport const DEFAULT_PRELOAD_TTL: TTL = 'none';\nexport const DEFAULT_PRELOAD_TTL_MS = 0;\n\nexport const MAX_TTL: TTL = '10m';\nexport const MAX_TTL_MS = 1_000 * 60 * 10;\n\nconst multiplier = {\n  s: 1000,\n  m: 60 * 1000,\n  h: 60 * 60 * 1000,\n  d: 24 * 60 * 60 * 1000,\n  y: 365 * 24 * 60 * 60 * 1000,\n} as const;\n\nexport function parseTTL(ttl: TTL): number {\n  if (typeof ttl === 'number') {\n    return Number.isNaN(ttl) ? 0 : !Number.isFinite(ttl) || ttl < 0 ? -1 : ttl;\n  }\n  if (ttl === 'none') {\n    return 0;\n  }\n  if (ttl === 'forever') {\n    return -1;\n  }\n  const multi = multiplier[ttl.at(-1) as TimeUnit];\n  return Number(ttl.slice(0, -1)) * multi;\n}\n\nexport function compareTTL(a: TTL, b: TTL): number {\n  const ap = parseTTL(a);\n  const bp = parseTTL(b);\n  if (ap === -1 && bp !== -1) {\n    return 1;\n  }\n  if (ap !== -1 && bp === -1) {\n    return -1;\n  }\n  return ap - bp;\n}\n\nexport function normalizeTTL(ttl: TTL): TTL {\n  if (typeof ttl === 'string') {\n    return ttl;\n  }\n\n  if (ttl < 0) {\n    return 'forever';\n  }\n\n  if (ttl === 0) {\n    return 'none';\n  }\n\n  let shortest = ttl.toString();\n  const lengthOfNumber = shortest.length;\n  for (const unit of ['y', 'd', 'h', 'm', 's'] as const) {\n    const multi = multiplier[unit];\n    const value = ttl / multi;\n    const candidate = `${value}${unit}`;\n    if (candidate.length < shortest.length) {\n      shortest = candidate;\n    }\n  }\n\n  return (shortest.length < lengthOfNumber ? shortest : ttl) as TTL;\n}\n\nexport function clampTTL(ttl: TTL, lc?: Pick<LogContext, 'warn'>): number {\n  const parsedTTL = parseTTL(ttl);\n  if (parsedTTL === -1 || parsedTTL > 10 * 60 * 1000) {\n    // 10 minutes in milliseconds\n    lc?.warn?.(`TTL (${ttl}) is too high, clamping to ${MAX_TTL}`);\n    return parseTTL(MAX_TTL);\n  }\n  return parsedTTL;\n}\n"],"mappings":";AAmBA,IAAa,iBAAiB;AAM9B,IAAa,aAAa;AAE1B,IAAM,aAAa;CACjB,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;AACL;AAEA,SAAgB,SAAS,KAAkB;CACzC,IAAI,OAAO,QAAQ,UACjB,OAAO,OAAO,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,SAAS,GAAG,KAAK,MAAM,IAAI,KAAK;CAEzE,IAAI,QAAQ,QACV,OAAO;CAET,IAAI,QAAQ,WACV,OAAO;CAET,MAAM,QAAQ,WAAW,IAAI,GAAG,EAAE;CAClC,OAAO,OAAO,IAAI,MAAM,GAAG,EAAE,CAAC,IAAI;AACpC;AAEA,SAAgB,WAAW,GAAQ,GAAgB;CACjD,MAAM,KAAK,SAAS,CAAC;CACrB,MAAM,KAAK,SAAS,CAAC;CACrB,IAAI,OAAO,MAAM,OAAO,IACtB,OAAO;CAET,IAAI,OAAO,MAAM,OAAO,IACtB,OAAO;CAET,OAAO,KAAK;AACd;AAEA,SAAgB,aAAa,KAAe;CAC1C,IAAI,OAAO,QAAQ,UACjB,OAAO;CAGT,IAAI,MAAM,GACR,OAAO;CAGT,IAAI,QAAQ,GACV,OAAO;CAGT,IAAI,WAAW,IAAI,SAAS;CAC5B,MAAM,iBAAiB,SAAS;CAChC,KAAK,MAAM,QAAQ;EAAC;EAAK;EAAK;EAAK;EAAK;CAAG,GAAY;EAGrD,MAAM,YAAY,GADJ,MADA,WAAW,QAEI;EAC7B,IAAI,UAAU,SAAS,SAAS,QAC9B,WAAW;CAEf;CAEA,OAAQ,SAAS,SAAS,iBAAiB,WAAW;AACxD;AAEA,SAAgB,SAAS,KAAU,IAAuC;CACxE,MAAM,YAAY,SAAS,GAAG;CAC9B,IAAI,cAAc,MAAM,YAAY,KAAgB;EAElD,IAAI,OAAO,QAAQ,IAAI,+BAAsC;EAC7D,OAAO,SAAA,KAAgB;CACzB;CACA,OAAO;AACT"}

package/out/zql/src/query/validate-input.js.map

@@ -1 +1 @@
-{"version":3,"file":"validate-input.js","names":[],"sources":["../../../../../zql/src/query/validate-input.ts"],"sourcesContent":["import type {StandardSchemaV1} from '@standard-schema/spec';\n\nexport class InputValidationError extends Error {\n  readonly result: StandardSchemaV1.FailureResult;\n\n  // will get picked up by `getErrorDetails` when mapping to an `ApplicationError`\n  readonly details: {\n    type: 'InputValidationError';\n    result: StandardSchemaV1.FailureResult;\n  };\n\n  constructor(message: string, result: StandardSchemaV1.FailureResult) {\n    super(message);\n    this.name = 'InputValidationError';\n    this.result = result;\n    this.details = {type: 'InputValidationError', result};\n  }\n}\n\n/**\n * Validates input using a StandardSchema validator if provided.\n * This is shared validation logic used by both defineQuery and defineMutator.\n *\n * @param name - The name of the query or mutator (for error messages)\n * @param input - The input value to validate\n * @param validator - Optional StandardSchema validator\n * @param kind - Type of definition ('query' or 'mutator') for error messages\n * @returns The validated output (either transformed by validator or input as-is)\n * @throws Error if validation fails or if an async validator is used\n * @internal\n */\nexport function validateInput<TInput, TOutput>(\n  name: string,\n  input: TInput,\n  validator: StandardSchemaV1<TInput, TOutput> | undefined,\n  kind: 'query' | 'mutator',\n): TOutput {\n  if (!validator) {\n    // No validator, so input and output are the same\n    return input as unknown as TOutput;\n  }\n\n  const result = validator['~standard'].validate(input);\n  if (result instanceof Promise) {\n    throw new Error(\n      `Async validators are not supported. ${titleCase(kind)} name ${name}`,\n    );\n  }\n  if (result.issues) {\n    throw new InputValidationError(\n      `Validation failed for ${kind} ${name}: ${result.issues\n        .map(issue => issue.message)\n        .join(', ')}`,\n      result,\n    );\n  }\n  return result.value;\n}\n\nfunction titleCase(kind: string): string {\n  return kind.charAt(0).toUpperCase() + kind.slice(1);\n}\n"],"mappings":";AAEA,IAAa,uBAAb,cAA0C,MAAM;CAC9C;CAGA;CAKA,YAAY,SAAiB,QAAwC;EACnE,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS;EACd,KAAK,UAAU;GAAC,MAAM;GAAwB;EAAM;CACtD;AACF;;;;;;;;;;;;;AAcA,SAAgB,cACd,MACA,OACA,WACA,MACS;CACT,IAAI,CAAC,WAEH,OAAO;CAGT,MAAM,SAAS,UAAU,aAAa,SAAS,KAAK;CACpD,IAAI,kBAAkB,SACpB,MAAM,IAAI,MACR,uCAAuC,UAAU,IAAI,EAAE,QAAQ,MACjE;CAEF,IAAI,OAAO,QACT,MAAM,IAAI,qBACR,yBAAyB,KAAK,GAAG,KAAK,IAAI,OAAO,OAC9C,KAAI,UAAS,MAAM,OAAO,EAC1B,KAAK,IAAI,KACZ,MACF;CAEF,OAAO,OAAO;AAChB;AAEA,SAAS,UAAU,MAAsB;CACvC,OAAO,KAAK,OAAO,CAAC,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC;AACpD"}
+{"version":3,"file":"validate-input.js","names":[],"sources":["../../../../../zql/src/query/validate-input.ts"],"sourcesContent":["import type {StandardSchemaV1} from '@standard-schema/spec';\n\nexport class InputValidationError extends Error {\n  readonly result: StandardSchemaV1.FailureResult;\n\n  // will get picked up by `getErrorDetails` when mapping to an `ApplicationError`\n  readonly details: {\n    type: 'InputValidationError';\n    result: StandardSchemaV1.FailureResult;\n  };\n\n  constructor(message: string, result: StandardSchemaV1.FailureResult) {\n    super(message);\n    this.name = 'InputValidationError';\n    this.result = result;\n    this.details = {type: 'InputValidationError', result};\n  }\n}\n\n/**\n * Validates input using a StandardSchema validator if provided.\n * This is shared validation logic used by both defineQuery and defineMutator.\n *\n * @param name - The name of the query or mutator (for error messages)\n * @param input - The input value to validate\n * @param validator - Optional StandardSchema validator\n * @param kind - Type of definition ('query' or 'mutator') for error messages\n * @returns The validated output (either transformed by validator or input as-is)\n * @throws Error if validation fails or if an async validator is used\n * @internal\n */\nexport function validateInput<TInput, TOutput>(\n  name: string,\n  input: TInput,\n  validator: StandardSchemaV1<TInput, TOutput> | undefined,\n  kind: 'query' | 'mutator',\n): TOutput {\n  if (!validator) {\n    // No validator, so input and output are the same\n    return input as unknown as TOutput;\n  }\n\n  const result = validator['~standard'].validate(input);\n  if (result instanceof Promise) {\n    throw new Error(\n      `Async validators are not supported. ${titleCase(kind)} name ${name}`,\n    );\n  }\n  if (result.issues) {\n    throw new InputValidationError(\n      `Validation failed for ${kind} ${name}: ${result.issues\n        .map(issue => issue.message)\n        .join(', ')}`,\n      result,\n    );\n  }\n  return result.value;\n}\n\nfunction titleCase(kind: string): string {\n  return kind.charAt(0).toUpperCase() + kind.slice(1);\n}\n"],"mappings":";AAEA,IAAa,uBAAb,cAA0C,MAAM;CAC9C;CAGA;CAKA,YAAY,SAAiB,QAAwC;EACnE,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS;EACd,KAAK,UAAU;GAAC,MAAM;GAAwB;EAAM;CACtD;AACF;;;;;;;;;;;;;AAcA,SAAgB,cACd,MACA,OACA,WACA,MACS;CACT,IAAI,CAAC,WAEH,OAAO;CAGT,MAAM,SAAS,UAAU,YAAY,CAAC,SAAS,KAAK;CACpD,IAAI,kBAAkB,SACpB,MAAM,IAAI,MACR,uCAAuC,UAAU,IAAI,EAAE,QAAQ,MACjE;CAEF,IAAI,OAAO,QACT,MAAM,IAAI,qBACR,yBAAyB,KAAK,GAAG,KAAK,IAAI,OAAO,OAC9C,KAAI,UAAS,MAAM,OAAO,CAAC,CAC3B,KAAK,IAAI,KACZ,MACF;CAEF,OAAO,OAAO;AAChB;AAEA,SAAS,UAAU,MAAsB;CACvC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,KAAK,MAAM,CAAC;AACpD"}

package/out/zqlite/src/database-storage.d.ts

@@ -8,17 +8,36 @@ export interface ClientGroupStorage {
     destroy(): void;
 }
 export declare const CREATE_STORAGE_TABLE = "\n  CREATE TABLE storage (\n    clientGroupID TEXT,\n    op NUMBER,\n    key TEXT,\n    val TEXT,\n    PRIMARY KEY(clientGroupID, op, key)\n  )\n  ";
+export type DatabaseStorageOptions = {
+    commitInterval?: number | undefined;
+    compactionThresholdBytes?: number | undefined;
+    /**
+     * The most heap bytes, as estimated from {@link getSizeOfEntry}, that the
+     * operators of all client groups keep in memory before the least recently
+     * used ones spill to SQLite. 0, the default, keeps every operator's values
+     * in SQLite.
+     */
+    maxMemoryBytes?: number | undefined;
+};
+/**
+ * Operator storage for the client groups of a sync worker.
+ *
+ * Each operator keeps its values in a `Map`, so reading a key that was never
+ * written does not ask SQLite. When the values of all of the operators go
+ * over `maxMemoryBytes`, the least recently used operators spill: their
+ * values are written to SQLite, where they stay until the operator is
+ * destroyed.
+ *
+ * Like `MemoryStorage`, `get` returns the stored value itself, which
+ * operators do not mutate.
+ */
 export declare class DatabaseStorage {
     #private;
-    static create(lc: LogContext, path: string, options?: {
-        commitInterval: number;
-        compactionThresholdBytes: number;
-    }): DatabaseStorage;
-    constructor(db: Database, options?: {
-        commitInterval: number;
-        compactionThresholdBytes: number;
-    });
+    static create(lc: LogContext, path: string, options?: DatabaseStorageOptions): DatabaseStorage;
+    constructor(db: Database, options?: DatabaseStorageOptions);
     close(): void;
+    /** The estimated size of the values that operators keep in memory. */
+    get memoryBytes(): number;
     createClientGroupStorage(cgID: string): ClientGroupStorage;
 }
 //# sourceMappingURL=database-storage.d.ts.map

package/out/zqlite/src/database-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database-storage.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/database-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAEjC,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,aAAa,IAAI,OAAO,CAAC;IAEzB,gDAAgD;IAChD,OAAO,IAAI,IAAI,CAAC;CACjB;AAcD,eAAO,MAAM,oBAAoB,wJAQ9B,CAAC;AAeJ,qBAAa,eAAe;;IAC1B,MAAM,CAAC,MAAM,CACX,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,EACZ,OAAO;;;KAAiB,GACvB,eAAe,CAiBjB;IAOD,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO;;;KAAiB,EAiCjD;IAED,KAAK,SAGJ;IA0DD,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CA4DzD;CACF"}
+{"version":3,"file":"database-storage.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/database-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAIjD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAEjC,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,aAAa,IAAI,OAAO,CAAC;IAEzB,gDAAgD;IAChD,OAAO,IAAI,IAAI,CAAC;CACjB;AAcD,eAAO,MAAM,oBAAoB,wJAQ9B,CAAC;AAsBJ,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,wBAAwB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC,CAAC;AA4CF;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;;IAC1B,MAAM,CAAC,MAAM,CACX,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,eAAe,CAiBjB;IAgBD,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAE,sBAA2B,EAgD7D;IAED,KAAK,SAGJ;IAED,sEAAsE;IACtE,IAAI,WAAW,IAAI,MAAM,CAExB;IA+KD,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAoCzD;CACF"}

package/out/zqlite/src/database-storage.js

@@ -1,3 +1,5 @@
+import { getSizeOfEntry } from "../../shared/src/size-of-value.js";
+import { compareValues } from "../../zql/src/ivm/data.js";
 import { Database } from "./db.js";
 //#region ../zqlite/src/database-storage.ts
 var CREATE_STORAGE_TABLE = `
@@ -10,18 +12,72 @@ var CREATE_STORAGE_TABLE = `
   )
   `;
 /**
-* The most values each operator's storage keeps in memory. The storage is in
-* SQLite so that operator state can spill to disk, so only a few values per
-* operator are kept: profiles of the view-syncer gain as much from 64 as from
-* 1,024.
+* The most values the storage of a spilled operator keeps in memory. Profiles
+* of the view-syncer gain as much from 64 as from 1,024.
 */
 var MAX_CACHED_ENTRIES_PER_OP = 64;
+/**
+* When the operators' values go over `maxMemoryBytes`, operators are spilled
+* until they are back under this proportion of it, so that spilling, which
+* sorts the operators by last use, happens in batches.
+*/
+var SPILL_TARGET_PROPORTION = .9;
+/**
+* The heap bytes that operator state takes per byte of {@link getSizeOfEntry}.
+* Measured with `heapUsed` on view-syncer operator state, mostly Cap's
+* `{size, pks}` and Take's `{size, bound}`.
+*/
+var HEAP_BYTES_PER_SIZE = 2.6;
 var defaultOptions = {
 	commitInterval: 5e3,
-	compactionThresholdBytes: 50 * 1024 * 1024
+	compactionThresholdBytes: 52428800,
+	maxMemoryBytes: 0
 };
+/**
+* The storage of one operator. Its values live in `values` until the
+* operator is spilled, and in SQLite afterwards, with the most recently used
+* of them in `cache`.
+*/
+var OpStorage = class {
+	cgID;
+	opID;
+	/** `undefined` once spilled. */
+	values;
+	/** The {@link getSizeOfEntry} of `values`. */
+	size = 0;
+	lastUsed = 0;
+	/**
+	* Once spilled, the operator's most recently read and written values,
+	* `undefined` for a key known to be absent. Operators read the same key
+	* again and again (Cap and Take read their state on every fetch and push),
+	* so this saves most of the SQLite reads.
+	*/
+	cache = /* @__PURE__ */ new Map();
+	constructor(cgID, opID, inMemory) {
+		this.cgID = cgID;
+		this.opID = opID;
+		this.values = inMemory ? /* @__PURE__ */ new Map() : void 0;
+	}
+	cacheSet(key, val) {
+		const { cache } = this;
+		if (cache.size >= MAX_CACHED_ENTRIES_PER_OP && !cache.has(key)) cache.clear();
+		cache.set(key, val);
+	}
+};
+/**
+* Operator storage for the client groups of a sync worker.
+*
+* Each operator keeps its values in a `Map`, so reading a key that was never
+* written does not ask SQLite. When the values of all of the operators go
+* over `maxMemoryBytes`, the least recently used operators spill: their
+* values are written to SQLite, where they stay until the operator is
+* destroyed.
+*
+* Like `MemoryStorage`, `get` returns the stored value itself, which
+* operators do not mutate.
+*/
 var DatabaseStorage = class DatabaseStorage {
-	static create(lc, path, options = defaultOptions) {
+	static create(lc, path, options = {}) {
 		const db = new Database(lc, path);
 		db.unsafeMode(true);
 		db.pragma("locking_mode = EXCLUSIVE");
@@ -37,12 +93,20 @@ var DatabaseStorage = class DatabaseStorage {
 	#options;
 	#db;
 	#numWrites = 0;
-	constructor(db, options = defaultOptions) {
+	/** The operators whose values are in memory. */
+	#inMemory = /* @__PURE__ */ new Set();
+	/** The {@link getSizeOfEntry} of the values of the operators in `#inMemory`. */
+	#size = 0;
+	/** `maxMemoryBytes` in units of {@link getSizeOfEntry}. */
+	#maxSize;
+	/** Orders the operators by last use. */
+	#clock = 0;
+	constructor(db, options = {}) {
 		this.#stmts = {
 			get: db.prepare(`
         SELECT val FROM storage WHERE
           clientGroupID = ? AND op = ? AND key = ?
-      `),
+      `).pluck(true),
 			set: db.prepare(`
         INSERT INTO storage (clientGroupID, op, key, val)
           VALUES(?, ?, ?, ?)
@@ -57,7 +121,7 @@ var DatabaseStorage = class DatabaseStorage {
 			scan: db.prepare(`
         SELECT key, val FROM storage WHERE
           clientGroupID = ? AND op = ? AND key >= ?
-      `),
+      `).raw(true),
 			clear: db.prepare(`
         DELETE FROM storage WHERE clientGroupID = ?
       `),
@@ -68,29 +132,110 @@ var DatabaseStorage = class DatabaseStorage {
 			begin: db.prepare("BEGIN")
 		};
 		this.#stmts.begin.run();
-		this.#options = options;
+		this.#options = {
+			commitInterval: options.commitInterval ?? defaultOptions.commitInterval,
+			compactionThresholdBytes: options.compactionThresholdBytes ?? defaultOptions.compactionThresholdBytes,
+			maxMemoryBytes: options.maxMemoryBytes ?? defaultOptions.maxMemoryBytes
+		};
+		this.#maxSize = this.#options.maxMemoryBytes / HEAP_BYTES_PER_SIZE;
 		this.#db = db;
 	}
 	close() {
 		this.#checkpoint();
 		this.#db.close();
 	}
-	#get(cgID, opID, key) {
-		this.#maybeCheckpoint();
-		const row = this.#stmts.get.get(cgID, opID, key);
-		return row ? JSON.parse(row.val) : void 0;
+	/** The estimated size of the values that operators keep in memory. */
+	get memoryBytes() {
+		return Math.round(this.#size * HEAP_BYTES_PER_SIZE);
 	}
-	#set(cgID, opID, key, val) {
-		this.#maybeCheckpoint();
-		this.#stmts.set.run(cgID, opID, key, JSON.stringify(val));
+	#get(op, key, def) {
+		op.lastUsed = ++this.#clock;
+		const { values } = op;
+		if (values) {
+			const val = values.get(key);
+			return val === void 0 ? def : val;
+		}
+		let val = op.cache.get(key);
+		if (val === void 0 && !op.cache.has(key)) {
+			this.#maybeCheckpoint();
+			const json = this.#stmts.get.get(op.cgID, op.opID, key);
+			val = json === void 0 ? void 0 : JSON.parse(json);
+			op.cacheSet(key, val);
+		}
+		return val === void 0 ? def : val;
+	}
+	#set(op, key, val) {
+		op.lastUsed = ++this.#clock;
+		const { values } = op;
+		if (values) {
+			if (values.size === 0) this.#inMemory.add(op);
+			const old = values.get(key);
+			const delta = getSizeOfEntry(key, val) - (old === void 0 ? 0 : getSizeOfEntry(key, old));
+			values.set(key, val);
+			op.size += delta;
+			this.#size += delta;
+			if (this.#size > this.#maxSize) this.#spillLeastRecentlyUsed();
+			return;
+		}
+		this.#write(op, key, val);
+		op.cacheSet(key, val);
 	}
-	#del(cgID, opID, key) {
+	#del(op, key) {
+		op.lastUsed = ++this.#clock;
+		const { values } = op;
+		if (values) {
+			const old = values.get(key);
+			if (old !== void 0) {
+				values.delete(key);
+				const size = getSizeOfEntry(key, old);
+				op.size -= size;
+				this.#size -= size;
+			}
+			return;
+		}
 		this.#maybeCheckpoint();
-		this.#stmts.del.run(cgID, opID, key);
+		this.#stmts.del.run(op.cgID, op.opID, key);
+		op.cacheSet(key, void 0);
 	}
-	#destroy(cgID, opID) {
+	#write(op, key, val) {
 		this.#maybeCheckpoint();
-		this.#stmts.clearOp.run(cgID, opID);
+		this.#stmts.set.run(op.cgID, op.opID, key, JSON.stringify(val));
+	}
+	/**
+	* Spills the least recently used operators until the values in memory are
+	* under {@link SPILL_TARGET_PROPORTION} of the budget.
+	*/
+	#spillLeastRecentlyUsed() {
+		const target = this.#maxSize * SPILL_TARGET_PROPORTION;
+		const ops = [];
+		for (const op of this.#inMemory) ops.push(op);
+		ops.sort((a, b) => a.lastUsed - b.lastUsed);
+		for (const op of ops) {
+			if (this.#size <= target) break;
+			this.#spill(op);
+		}
+	}
+	#spill(op) {
+		const { values } = op;
+		if (!values) return;
+		for (const [key, val] of values) this.#write(op, key, val);
+		this.#release(op);
+		op.values = void 0;
+	}
+	/** Drops the values that `op` keeps in memory. */
+	#release(op) {
+		this.#size -= op.size;
+		op.size = 0;
+		op.values?.clear();
+		op.cache.clear();
+		this.#inMemory.delete(op);
+	}
+	#destroy(op) {
+		if (!op.values) {
+			this.#maybeCheckpoint();
+			this.#stmts.clearOp.run(op.cgID, op.opID);
+		}
+		this.#release(op);
 	}
 	/**
 	* We don't need to commit every single write to the DB
@@ -106,18 +251,29 @@ var DatabaseStorage = class DatabaseStorage {
 		this.#stmts.begin.run();
 		this.#numWrites = 0;
 	}
-	*#scan(cgID, opID, opts = { prefix: "" }) {
+	*#scan(op, opts = { prefix: "" }) {
 		const { prefix } = opts;
-		for (const { key, val } of this.#stmts.scan.iterate(cgID, opID, prefix)) {
+		const { values } = op;
+		if (values) {
+			const keys = [];
+			for (const key of values.keys()) if (key.startsWith(prefix)) keys.push(key);
+			keys.sort(compareValues);
+			for (const key of keys) {
+				const val = this.#get(op, key);
+				if (val !== void 0) yield [key, val];
+			}
+			return;
+		}
+		for (const [key, val] of this.#stmts.scan.iterate(op.cgID, op.opID, prefix)) {
 			if (!key.startsWith(prefix)) return;
 			yield [key, JSON.parse(val)];
 		}
 	}
 	createClientGroupStorage(cgID) {
-		const caches = /* @__PURE__ */ new Set();
+		const ops = /* @__PURE__ */ new Set();
 		const destroy = () => {
 			this.#stmts.clear.run(cgID);
-			for (const cache of caches) cache.clear();
+			for (const op of ops) this.#release(op);
 			this.#checkpoint();
 			this.#db.compact(this.#options.compactionThresholdBytes);
 		};
@@ -125,35 +281,16 @@ var DatabaseStorage = class DatabaseStorage {
 		let nextOpID = 1;
 		return {
 			createStorage: () => {
-				const opID = nextOpID++;
-				const cache = /* @__PURE__ */ new Map();
-				caches.add(cache);
-				const cacheSet = (key, val) => {
-					if (cache.size >= MAX_CACHED_ENTRIES_PER_OP && !cache.has(key)) cache.clear();
-					cache.set(key, val);
-				};
+				const op = new OpStorage(cgID, nextOpID++, this.#options.maxMemoryBytes > 0);
+				ops.add(op);
 				return {
-					get: (key, def) => {
-						let val = cache.get(key);
-						if (val === void 0 && !cache.has(key)) {
-							val = this.#get(cgID, opID, key);
-							cacheSet(key, val);
-						}
-						return val === void 0 ? def : val;
-					},
-					set: (key, val) => {
-						this.#set(cgID, opID, key, val);
-						cacheSet(key, val);
-					},
-					del: (key) => {
-						this.#del(cgID, opID, key);
-						cacheSet(key, void 0);
-					},
-					scan: (opts) => this.#scan(cgID, opID, opts),
+					get: (key, def) => this.#get(op, key, def),
+					set: (key, val) => this.#set(op, key, val),
+					del: (key) => this.#del(op, key),
+					scan: (opts) => this.#scan(op, opts),
 					destroy: () => {
-						this.#destroy(cgID, opID);
-						cache.clear();
-						caches.delete(cache);
+						this.#destroy(op);
+						ops.delete(op);
 					}
 				};
 			},
@@ -162,6 +299,6 @@ var DatabaseStorage = class DatabaseStorage {
 	}
 };
 //#endregion
-export { DatabaseStorage };
+export { CREATE_STORAGE_TABLE, DatabaseStorage };
 
 //# sourceMappingURL=database-storage.js.map