@rocicorp/zero 1.11.0-head-86ca5eff-20261014 → 1.11.1

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":"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"}
+{"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.js

@@ -11,7 +11,7 @@ var CREATE_STORAGE_TABLE = `
   `;
 var defaultOptions = {
 	commitInterval: 5e3,
-	compactionThresholdBytes: 50 * 1024 * 1024
+	compactionThresholdBytes: 52428800
 };
 var DatabaseStorage = class DatabaseStorage {
 	static create(lc, path, options = defaultOptions) {
@@ -130,6 +130,6 @@ var DatabaseStorage = class DatabaseStorage {
 	}
 };
 //#endregion
-export { DatabaseStorage };
+export { CREATE_STORAGE_TABLE, DatabaseStorage };
 
 //# sourceMappingURL=database-storage.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"database-storage.js","names":["#stmts","#options","#db","#checkpoint","#maybeCheckpoint","#numWrites","#scan","#get","#set","#del","#destroy"],"sources":["../../../../zqlite/src/database-storage.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {JSONValue} from '../../shared/src/json.ts';\nimport type {Storage} from '../../zql/src/ivm/operator.ts';\nimport type {Stream} from '../../zql/src/ivm/stream.ts';\nimport type {Statement} from './db.ts';\nimport {Database} from './db.ts';\n\nexport interface ClientGroupStorage {\n  /** Creates a {@link Storage} instance for a single operator. */\n  createStorage(): Storage;\n\n  /** Deletes all storage for the client group. */\n  destroy(): void;\n}\n\ntype Statements = {\n  get: Statement;\n  set: Statement;\n  del: Statement;\n  scan: Statement;\n  clear: Statement;\n  clearOp: Statement;\n  commit: Statement;\n  begin: Statement;\n};\n\n// Exported for testing.\nexport 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  `;\n\nconst defaultOptions = {\n  commitInterval: 5_000,\n  compactionThresholdBytes: 50 * 1024 * 1024,\n};\n\nexport class DatabaseStorage {\n  static create(\n    lc: LogContext,\n    path: string,\n    options = defaultOptions,\n  ): DatabaseStorage {\n    // SQLite is used for ephemeral storage (i.e. similar to RAM) that can spill to\n    // disk to avoid consuming too much memory. Each worker thread gets its own\n    // database (file) and acts as the single reader/writer of the DB, so\n    // `locking_mode` is set to `EXCLUSIVE` for performance. Similarly, since\n    // durability is not important, `synchronous` is set to `OFF` for performance.\n    const db = new Database(lc, path);\n    db.unsafeMode(true); // Allows journal_mode = OFF\n    db.pragma('locking_mode = EXCLUSIVE');\n    db.pragma('foreign_keys = OFF');\n    db.pragma('journal_mode = OFF');\n    db.pragma('synchronous = OFF');\n    db.pragma('auto_vacuum = INCREMENTAL');\n\n    db.prepare(CREATE_STORAGE_TABLE).run();\n    lc.debug?.(`Created DatabaseStorage backed by ${path}`);\n    return new DatabaseStorage(db, options);\n  }\n\n  readonly #stmts: Statements;\n  readonly #options: typeof defaultOptions;\n  readonly #db: Database;\n  #numWrites = 0;\n\n  constructor(db: Database, options = defaultOptions) {\n    this.#stmts = {\n      get: db.prepare(`\n        SELECT val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      set: db.prepare(`\n        INSERT INTO storage (clientGroupID, op, key, val)\n          VALUES(?, ?, ?, ?)\n        ON CONFLICT(clientGroupID, op, key) \n        DO \n          UPDATE SET val = excluded.val\n      `),\n      del: db.prepare(`\n        DELETE FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      scan: db.prepare(`\n        SELECT key, val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key >= ?\n      `),\n      clear: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ?\n      `),\n      clearOp: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ? AND op = ?\n      `),\n      commit: db.prepare('COMMIT'),\n      begin: db.prepare('BEGIN'),\n    };\n    this.#stmts.begin.run();\n    this.#options = options;\n    this.#db = db;\n  }\n\n  close() {\n    this.#checkpoint();\n    this.#db.close();\n  }\n\n  #get(\n    cgID: string,\n    opID: number,\n    key: string,\n    def?: JSONValue,\n  ): JSONValue | undefined {\n    this.#maybeCheckpoint();\n    const row = this.#stmts.get.get<{val: string}>(cgID, opID, key);\n    return row ? JSON.parse(row.val) : def;\n  }\n\n  #set(cgID: string, opID: number, key: string, val: JSONValue) {\n    this.#maybeCheckpoint();\n    this.#stmts.set.run(cgID, opID, key, JSON.stringify(val));\n  }\n\n  #del(cgID: string, opID: number, key: string) {\n    this.#maybeCheckpoint();\n    this.#stmts.del.run(cgID, opID, key);\n  }\n\n  #destroy(cgID: string, opID: number) {\n    this.#maybeCheckpoint();\n    this.#stmts.clearOp.run(cgID, opID);\n  }\n\n  /**\n   * We don't need to commit every single write to the DB\n   * since we're not concerned with durability.\n   * Waiting on commits can be expensive, so we commit\n   * every `COMMIT_INTERVAL` writes.\n   */\n  #maybeCheckpoint() {\n    if (++this.#numWrites >= this.#options.commitInterval) {\n      this.#checkpoint();\n    }\n  }\n\n  #checkpoint() {\n    this.#stmts.commit.run();\n    this.#stmts.begin.run();\n    this.#numWrites = 0;\n  }\n\n  *#scan(\n    cgID: string,\n    opID: number,\n    opts: {prefix: string} = {prefix: ''},\n  ): Stream<[string, JSONValue]> {\n    const {prefix} = opts;\n    for (const {key, val} of this.#stmts.scan.iterate<{\n      key: string;\n      val: string;\n    }>(cgID, opID, prefix)) {\n      if (!key.startsWith(prefix)) {\n        return;\n      }\n      yield [key, JSON.parse(val)];\n    }\n  }\n\n  createClientGroupStorage(cgID: string): ClientGroupStorage {\n    const destroy = () => {\n      this.#stmts.clear.run(cgID);\n      this.#checkpoint();\n      this.#db.compact(this.#options.compactionThresholdBytes);\n    };\n    this.#stmts.clear.run(cgID);\n\n    let nextOpID = 1;\n    return {\n      createStorage: () => {\n        const opID = nextOpID++;\n        return {\n          get: (key, def?) => this.#get(cgID, opID, key, def),\n          set: (key, val) => this.#set(cgID, opID, key, val),\n          del: key => this.#del(cgID, opID, key),\n          scan: opts => this.#scan(cgID, opID, opts),\n          destroy: () => this.#destroy(cgID, opID),\n        };\n      },\n\n      destroy,\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"database-storage.js","names":[],"sources":["../../../../zqlite/src/database-storage.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {JSONValue} from '../../shared/src/json.ts';\nimport type {Storage} from '../../zql/src/ivm/operator.ts';\nimport type {Stream} from '../../zql/src/ivm/stream.ts';\nimport type {Statement} from './db.ts';\nimport {Database} from './db.ts';\n\nexport interface ClientGroupStorage {\n  /** Creates a {@link Storage} instance for a single operator. */\n  createStorage(): Storage;\n\n  /** Deletes all storage for the client group. */\n  destroy(): void;\n}\n\ntype Statements = {\n  get: Statement;\n  set: Statement;\n  del: Statement;\n  scan: Statement;\n  clear: Statement;\n  clearOp: Statement;\n  commit: Statement;\n  begin: Statement;\n};\n\n// Exported for testing.\nexport 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  `;\n\nconst defaultOptions = {\n  commitInterval: 5_000,\n  compactionThresholdBytes: 50 * 1024 * 1024,\n};\n\nexport class DatabaseStorage {\n  static create(\n    lc: LogContext,\n    path: string,\n    options = defaultOptions,\n  ): DatabaseStorage {\n    // SQLite is used for ephemeral storage (i.e. similar to RAM) that can spill to\n    // disk to avoid consuming too much memory. Each worker thread gets its own\n    // database (file) and acts as the single reader/writer of the DB, so\n    // `locking_mode` is set to `EXCLUSIVE` for performance. Similarly, since\n    // durability is not important, `synchronous` is set to `OFF` for performance.\n    const db = new Database(lc, path);\n    db.unsafeMode(true); // Allows journal_mode = OFF\n    db.pragma('locking_mode = EXCLUSIVE');\n    db.pragma('foreign_keys = OFF');\n    db.pragma('journal_mode = OFF');\n    db.pragma('synchronous = OFF');\n    db.pragma('auto_vacuum = INCREMENTAL');\n\n    db.prepare(CREATE_STORAGE_TABLE).run();\n    lc.debug?.(`Created DatabaseStorage backed by ${path}`);\n    return new DatabaseStorage(db, options);\n  }\n\n  readonly #stmts: Statements;\n  readonly #options: typeof defaultOptions;\n  readonly #db: Database;\n  #numWrites = 0;\n\n  constructor(db: Database, options = defaultOptions) {\n    this.#stmts = {\n      get: db.prepare(`\n        SELECT val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      set: db.prepare(`\n        INSERT INTO storage (clientGroupID, op, key, val)\n          VALUES(?, ?, ?, ?)\n        ON CONFLICT(clientGroupID, op, key) \n        DO \n          UPDATE SET val = excluded.val\n      `),\n      del: db.prepare(`\n        DELETE FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key = ?\n      `),\n      scan: db.prepare(`\n        SELECT key, val FROM storage WHERE\n          clientGroupID = ? AND op = ? AND key >= ?\n      `),\n      clear: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ?\n      `),\n      clearOp: db.prepare(`\n        DELETE FROM storage WHERE clientGroupID = ? AND op = ?\n      `),\n      commit: db.prepare('COMMIT'),\n      begin: db.prepare('BEGIN'),\n    };\n    this.#stmts.begin.run();\n    this.#options = options;\n    this.#db = db;\n  }\n\n  close() {\n    this.#checkpoint();\n    this.#db.close();\n  }\n\n  #get(\n    cgID: string,\n    opID: number,\n    key: string,\n    def?: JSONValue,\n  ): JSONValue | undefined {\n    this.#maybeCheckpoint();\n    const row = this.#stmts.get.get<{val: string}>(cgID, opID, key);\n    return row ? JSON.parse(row.val) : def;\n  }\n\n  #set(cgID: string, opID: number, key: string, val: JSONValue) {\n    this.#maybeCheckpoint();\n    this.#stmts.set.run(cgID, opID, key, JSON.stringify(val));\n  }\n\n  #del(cgID: string, opID: number, key: string) {\n    this.#maybeCheckpoint();\n    this.#stmts.del.run(cgID, opID, key);\n  }\n\n  #destroy(cgID: string, opID: number) {\n    this.#maybeCheckpoint();\n    this.#stmts.clearOp.run(cgID, opID);\n  }\n\n  /**\n   * We don't need to commit every single write to the DB\n   * since we're not concerned with durability.\n   * Waiting on commits can be expensive, so we commit\n   * every `COMMIT_INTERVAL` writes.\n   */\n  #maybeCheckpoint() {\n    if (++this.#numWrites >= this.#options.commitInterval) {\n      this.#checkpoint();\n    }\n  }\n\n  #checkpoint() {\n    this.#stmts.commit.run();\n    this.#stmts.begin.run();\n    this.#numWrites = 0;\n  }\n\n  *#scan(\n    cgID: string,\n    opID: number,\n    opts: {prefix: string} = {prefix: ''},\n  ): Stream<[string, JSONValue]> {\n    const {prefix} = opts;\n    for (const {key, val} of this.#stmts.scan.iterate<{\n      key: string;\n      val: string;\n    }>(cgID, opID, prefix)) {\n      if (!key.startsWith(prefix)) {\n        return;\n      }\n      yield [key, JSON.parse(val)];\n    }\n  }\n\n  createClientGroupStorage(cgID: string): ClientGroupStorage {\n    const destroy = () => {\n      this.#stmts.clear.run(cgID);\n      this.#checkpoint();\n      this.#db.compact(this.#options.compactionThresholdBytes);\n    };\n    this.#stmts.clear.run(cgID);\n\n    let nextOpID = 1;\n    return {\n      createStorage: () => {\n        const opID = nextOpID++;\n        return {\n          get: (key, def?) => this.#get(cgID, opID, key, def),\n          set: (key, val) => this.#set(cgID, opID, key, val),\n          del: key => this.#del(cgID, opID, key),\n          scan: opts => this.#scan(cgID, opID, opts),\n          destroy: () => this.#destroy(cgID, opID),\n        };\n      },\n\n      destroy,\n    };\n  }\n}\n"],"mappings":"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"}

package/out/zqlite/src/db.js

@@ -5,7 +5,7 @@ import SQLite3Database, { SqliteError } from "@rocicorp/zero-sqlite3";
 //#region ../zqlite/src/db.ts
 var tracer = trace.getTracer("view-syncer", version);
 var AUTO_VACUUM_INCREMENTAL = 2;
-var MB = 1024 * 1024;
+var MB = 1048576;
 function mb(bytes) {
 	return (bytes / MB).toFixed(2);
 }
@@ -251,6 +251,6 @@ function logSlow(lc, elapsed, attrs, message = "Slow SQLite query") {
 */
 var DatabaseInitError = class extends Error {};
 //#endregion
-export { Database, DatabaseInitError };
+export { Database, DatabaseInitError, Statement };
 
 //# sourceMappingURL=db.js.map

package/out/zqlite/src/db.js.map

@@ -1 +1 @@
-{"version":3,"file":"db.js","names":["#db","#threshold","#lc","#pageSize","#run","#bytes","#stmt","#attrs","#logIfSlow","#it","#start","#sqliteRowTimeSum","#log","#logged"],"sources":["../../../../zqlite/src/db.ts"],"sourcesContent":["import {trace, type Attributes} from '@opentelemetry/api';\nimport type {LogContext} from '@rocicorp/logger';\nimport SQLite3Database, {\n  SqliteError,\n  type RunResult,\n  type Statement as SQLite3Statement,\n} from '@rocicorp/zero-sqlite3';\nimport {manualSpan} from '../../otel/src/span.ts';\nimport {version} from '../../otel/src/version.ts';\n\nconst tracer = trace.getTracer('view-syncer', version);\n\n// https://www.sqlite.org/pragma.html#pragma_auto_vacuum\nconst AUTO_VACUUM_INCREMENTAL = 2;\n\nconst MB = 1024 * 1024;\n\nfunction mb(bytes: number): string {\n  return (bytes / MB).toFixed(2);\n}\n\nexport class Database implements Disposable {\n  readonly #db: SQLite3Database.Database;\n  readonly #threshold: number;\n  readonly #lc: LogContext;\n  readonly #pageSize: number;\n\n  constructor(\n    lc: LogContext,\n    path: string,\n    options?: SQLite3Database.Options,\n    slowQueryThreshold = 100,\n  ) {\n    try {\n      this.#lc = lc.withContext('class', 'Database').withContext('path', path);\n      this.#db = new SQLite3Database(path, options);\n      this.#threshold = slowQueryThreshold;\n\n      // Keep the WAL when this is the last connection to close the database,\n      // which would otherwise checkpoint and delete it. Deleting it discards\n      // the WAL that a litestream backup continues from, forcing a new\n      // snapshot. See persistWal() for switching out of WAL mode.\n      this.#db.persistWal();\n\n      // Match Postgres LIKE/ILIKE semantics. Postgres LIKE is case-sensitive,\n      // but SQLite's LIKE operator is case-insensitive by default; enable\n      // case-sensitive LIKE so the bare operator matches Postgres. Case-\n      // insensitive ILIKE is handled in query-builder.ts by lower()-ing both\n      // operands (using the Unicode-aware lower() that @rocicorp/zero-sqlite3\n      // provides via ICU).\n      this.pragma('case_sensitive_like = ON');\n\n      const [{page_size: pageSize}] = this.pragma<{page_size: number}>(\n        'page_size',\n      );\n      this.#pageSize = pageSize;\n    } catch (cause) {\n      throw new DatabaseInitError(String(cause), {cause});\n    }\n  }\n\n  prepare(sql: string): Statement {\n    return this.#run(\n      'prepare',\n      sql,\n      () =>\n        new Statement(\n          this.#lc.withContext('sql', sql),\n          {class: 'Statement', sql},\n          this.#db.prepare(sql),\n          this.#threshold,\n        ),\n    );\n  }\n\n  exec(sql: string): void {\n    this.#run('exec', sql, () => this.#db.exec(sql));\n  }\n\n  pragma<T = unknown>(sql: string): T[] {\n    return this.#run<T[]>('pragma', sql, () => this.#db.pragma(sql) as T[]);\n  }\n\n  #bytes(pages: number) {\n    return pages * this.#pageSize;\n  }\n\n  compact(freeableBytesThreshold: number) {\n    const [{freelist_count: freelistCount}] = this.pragma<{\n      freelist_count: number;\n    }>('freelist_count');\n\n    const freeable = this.#bytes(freelistCount);\n    if (freeable < freeableBytesThreshold) {\n      this.#lc.debug?.(\n        `Not compacting ${this.#db.name}: ${mb(freeable)} freeable MB`,\n      );\n      return;\n    }\n    const [{auto_vacuum: autoVacuumMode}] = this.pragma<{auto_vacuum: number}>(\n      'auto_vacuum',\n    );\n    if (autoVacuumMode !== AUTO_VACUUM_INCREMENTAL) {\n      this.#lc.warn?.(\n        `Cannot compact ${mb(freeable)} MB of ` +\n          `${this.#db.name} because AUTO_VACUUM mode is ${autoVacuumMode}.`,\n      );\n      return;\n    }\n    const start = Date.now();\n    const [{page_count: pageCountBefore}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.pragma('incremental_vacuum');\n\n    const [{page_count: pageCountAfter}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.#lc.info?.(\n      `Compacted ${this.#db.name} from ` +\n        `${mb(this.#bytes(pageCountBefore))} MB to ` +\n        `${mb(this.#bytes(pageCountAfter))} MB ` +\n        `(${Date.now() - start} ms)`,\n    );\n  }\n\n  unsafeMode(unsafe: boolean) {\n    this.#db.unsafeMode(unsafe);\n  }\n\n  /**\n   * Toggles whether the WAL is kept when this is the last connection to close\n   * the database (on by default). Turn it off before switching the database\n   * out of WAL mode (e.g. `journal_mode = DELETE` or `OFF`): with it on, the\n   * WAL file is left behind and reopened by the next transaction, so the\n   * database effectively stays in WAL mode.\n   */\n  persistWal(persist: boolean) {\n    this.#db.persistWal(persist);\n  }\n\n  #run<T>(method: string, sql: string, fn: () => T): T {\n    const start = performance.now();\n    try {\n      return fn();\n    } catch (e) {\n      if (e instanceof SqliteError) {\n        e.message += `: ${sql}`;\n      }\n      throw e;\n    } finally {\n      const elapsed = performance.now() - start;\n      if (elapsed >= this.#threshold) {\n        logSlow(this.#lc.withContext('method', method), elapsed, {method});\n      }\n    }\n  }\n\n  /**\n   * Closes the database. For writable connections, `PRAGMA optimize` is run\n   * first (as recommended by SQLite) unless `optimize` is `false`, which is\n   * appropriate for short-lived handles on a database whose statistics are\n   * maintained by a longer-lived writer.\n   */\n  close({optimize = true}: {optimize?: boolean | undefined} = {}): void {\n    const start = Date.now();\n    if (optimize && !this.#db.readonly) {\n      try {\n        this.#db.pragma('optimize');\n        const elapsed = Date.now() - start;\n        if (elapsed > 2) {\n          this.#lc.debug?.(`PRAGMA optimized (${elapsed} ms)`);\n        }\n      } catch (e) {\n        this.#lc.warn?.('error running PRAGMA optimize', e);\n      }\n    }\n    this.#db.close();\n  }\n\n  transaction<T>(fn: () => T): T {\n    return this.#db.transaction(fn)();\n  }\n\n  get name() {\n    return this.#db.name;\n  }\n\n  get inTransaction() {\n    return this.#db.inTransaction;\n  }\n\n  [Symbol.dispose](): void {\n    this.close();\n  }\n}\n\nexport class Statement {\n  readonly #stmt: SQLite3Statement;\n  readonly #lc: LogContext;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  readonly scanStatus: SQLite3Statement['scanStatusV2'];\n  readonly scanStatusReset: SQLite3Statement['scanStatusReset'];\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    stmt: SQLite3Statement,\n    threshold: number,\n  ) {\n    this.#lc = lc.withContext('class', 'Statement');\n    this.#attrs = attrs;\n    this.#stmt = stmt;\n    this.#threshold = threshold;\n    this.scanStatus = this.#stmt.scanStatusV2.bind(this.#stmt);\n    this.scanStatusReset = this.#stmt.scanStatusReset.bind(this.#stmt);\n  }\n\n  safeIntegers(useBigInt: boolean): this {\n    this.#stmt.safeIntegers(useBigInt);\n    return this;\n  }\n\n  run(...params: unknown[]): RunResult {\n    const start = performance.now();\n    const ret = this.#stmt.run(...params);\n    this.#logIfSlow('run', performance.now() - start);\n    return ret;\n  }\n\n  get<T>(...params: unknown[]): T {\n    const start = performance.now();\n    const ret = this.#stmt.get(...params);\n    this.#logIfSlow('get', performance.now() - start);\n    return ret as T;\n  }\n\n  all<T>(...params: unknown[]): T[] {\n    const start = performance.now();\n    const ret = this.#stmt.all(...params);\n    this.#logIfSlow('all', performance.now() - start);\n    return ret as T[];\n  }\n\n  #logIfSlow(method: string, elapsed: number): void {\n    if (elapsed >= this.#threshold) {\n      logSlow(this.#lc.withContext('method', method), elapsed, {\n        ...this.#attrs,\n        method,\n      });\n    }\n  }\n\n  iterate<T>(...params: unknown[]): IterableIterator<T> {\n    return new LoggingIterableIterator(\n      this.#lc,\n      this.#attrs,\n      this.#stmt.iterate(...params),\n      this.#threshold,\n    ) as IterableIterator<T>;\n  }\n}\n\n// Bound consumer-time warnings across all databases and SQL statements in this\n// process. Nested iterators can all outlive the threshold during the same stall.\nconst ITERATOR_TOTAL_LOG_WINDOW_MS = 60_000;\nconst ITERATOR_TOTAL_LOG_LIMIT = 10;\nlet iteratorTotalLogWindowStart = -Infinity;\nlet iteratorTotalLogsInWindow = 0;\nlet suppressedIteratorTotalLogs = 0;\n\nfunction admitIteratorTotalLog(now: number): number | undefined {\n  if (now - iteratorTotalLogWindowStart >= ITERATOR_TOTAL_LOG_WINDOW_MS) {\n    iteratorTotalLogWindowStart = now;\n    iteratorTotalLogsInWindow = 0;\n  }\n  if (iteratorTotalLogsInWindow >= ITERATOR_TOTAL_LOG_LIMIT) {\n    suppressedIteratorTotalLogs++;\n    return undefined;\n  }\n  iteratorTotalLogsInWindow++;\n  const suppressedCount = suppressedIteratorTotalLogs;\n  suppressedIteratorTotalLogs = 0;\n  return suppressedCount;\n}\n\nclass LoggingIterableIterator<T> implements IterableIterator<T> {\n  readonly #lc: LogContext;\n  readonly #it: IterableIterator<T>;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  #start: number;\n  #sqliteRowTimeSum: number;\n  #logged = false;\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    it: IterableIterator<T>,\n    slowQueryThreshold: number,\n  ) {\n    this.#lc = lc;\n    this.#attrs = attrs;\n    this.#it = it;\n    this.#start = performance.now();\n    this.#threshold = slowQueryThreshold;\n    this.#sqliteRowTimeSum = 0;\n  }\n\n  next(): IteratorResult<T> {\n    const start = performance.now();\n    const ret = this.#it.next();\n    const elapsed = performance.now() - start;\n    this.#sqliteRowTimeSum += elapsed;\n    if (ret.done) {\n      this.#log();\n    }\n    return ret;\n  }\n\n  #log() {\n    // TableSource closes iterators in finally, including after next() is done.\n    if (this.#logged) {\n      return;\n    }\n    this.#logged = true;\n\n    // Total time includes downstream consumer work and waits between rows.\n    // Check it independently of the time spent stepping SQLite.\n    const now = performance.now();\n    const totalMs = now - this.#start;\n    if (totalMs >= this.#threshold) {\n      const suppressedCount = admitIteratorTotalLog(now);\n      if (suppressedCount !== undefined) {\n        logSlow(\n          this.#lc,\n          totalMs,\n          {\n            ...this.#attrs,\n            type: 'total',\n            method: 'iterate',\n            sqliteMs: this.#sqliteRowTimeSum,\n            ...(suppressedCount > 0 ? {suppressedCount} : undefined),\n          },\n          'Slow SQLite iterator total time (including consumer work and waits between rows)',\n        );\n      }\n    }\n    if (this.#sqliteRowTimeSum >= this.#threshold) {\n      logSlow(\n        this.#lc.withContext('method', 'iterate').withContext('type', 'sqlite'),\n        this.#sqliteRowTimeSum,\n        {\n          ...this.#attrs,\n          type: 'sqlite',\n          method: 'iterate',\n          totalMs,\n        },\n      );\n    }\n  }\n\n  [Symbol.iterator](): IterableIterator<T> {\n    return this;\n  }\n\n  return(): IteratorResult<T> {\n    this.#log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.return?.() as any;\n  }\n\n  throw(e: unknown): IteratorResult<T> {\n    this.#log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.throw?.(e) as any;\n  }\n}\n\nfunction logSlow(\n  lc: LogContext,\n  elapsed: number,\n  attrs: Attributes,\n  message = 'Slow SQLite query',\n): void {\n  for (const [key, value] of Object.entries(attrs)) {\n    lc = lc.withContext(key, value);\n  }\n  lc.warn?.(message, elapsed);\n  manualSpan(tracer, 'db.slow-query', elapsed, attrs);\n}\n\n/**\n * An error indicating that the Database failed to open. This essentially\n * wraps the TypeError thrown by the better-sqlite3 package with something\n * more specific.\n */\nexport class DatabaseInitError extends Error {}\n"],"mappings":"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"}
+{"version":3,"file":"db.js","names":[],"sources":["../../../../zqlite/src/db.ts"],"sourcesContent":["import {trace, type Attributes} from '@opentelemetry/api';\nimport type {LogContext} from '@rocicorp/logger';\nimport SQLite3Database, {\n  SqliteError,\n  type RunResult,\n  type Statement as SQLite3Statement,\n} from '@rocicorp/zero-sqlite3';\nimport {manualSpan} from '../../otel/src/span.ts';\nimport {version} from '../../otel/src/version.ts';\n\nconst tracer = trace.getTracer('view-syncer', version);\n\n// https://www.sqlite.org/pragma.html#pragma_auto_vacuum\nconst AUTO_VACUUM_INCREMENTAL = 2;\n\nconst MB = 1024 * 1024;\n\nfunction mb(bytes: number): string {\n  return (bytes / MB).toFixed(2);\n}\n\nexport class Database implements Disposable {\n  readonly #db: SQLite3Database.Database;\n  readonly #threshold: number;\n  readonly #lc: LogContext;\n  readonly #pageSize: number;\n\n  constructor(\n    lc: LogContext,\n    path: string,\n    options?: SQLite3Database.Options,\n    slowQueryThreshold = 100,\n  ) {\n    try {\n      this.#lc = lc.withContext('class', 'Database').withContext('path', path);\n      this.#db = new SQLite3Database(path, options);\n      this.#threshold = slowQueryThreshold;\n\n      // Keep the WAL when this is the last connection to close the database,\n      // which would otherwise checkpoint and delete it. Deleting it discards\n      // the WAL that a litestream backup continues from, forcing a new\n      // snapshot. See persistWal() for switching out of WAL mode.\n      this.#db.persistWal();\n\n      // Match Postgres LIKE/ILIKE semantics. Postgres LIKE is case-sensitive,\n      // but SQLite's LIKE operator is case-insensitive by default; enable\n      // case-sensitive LIKE so the bare operator matches Postgres. Case-\n      // insensitive ILIKE is handled in query-builder.ts by lower()-ing both\n      // operands (using the Unicode-aware lower() that @rocicorp/zero-sqlite3\n      // provides via ICU).\n      this.pragma('case_sensitive_like = ON');\n\n      const [{page_size: pageSize}] = this.pragma<{page_size: number}>(\n        'page_size',\n      );\n      this.#pageSize = pageSize;\n    } catch (cause) {\n      throw new DatabaseInitError(String(cause), {cause});\n    }\n  }\n\n  prepare(sql: string): Statement {\n    return this.#run(\n      'prepare',\n      sql,\n      () =>\n        new Statement(\n          this.#lc.withContext('sql', sql),\n          {class: 'Statement', sql},\n          this.#db.prepare(sql),\n          this.#threshold,\n        ),\n    );\n  }\n\n  exec(sql: string): void {\n    this.#run('exec', sql, () => this.#db.exec(sql));\n  }\n\n  pragma<T = unknown>(sql: string): T[] {\n    return this.#run<T[]>('pragma', sql, () => this.#db.pragma(sql) as T[]);\n  }\n\n  #bytes(pages: number) {\n    return pages * this.#pageSize;\n  }\n\n  compact(freeableBytesThreshold: number) {\n    const [{freelist_count: freelistCount}] = this.pragma<{\n      freelist_count: number;\n    }>('freelist_count');\n\n    const freeable = this.#bytes(freelistCount);\n    if (freeable < freeableBytesThreshold) {\n      this.#lc.debug?.(\n        `Not compacting ${this.#db.name}: ${mb(freeable)} freeable MB`,\n      );\n      return;\n    }\n    const [{auto_vacuum: autoVacuumMode}] = this.pragma<{auto_vacuum: number}>(\n      'auto_vacuum',\n    );\n    if (autoVacuumMode !== AUTO_VACUUM_INCREMENTAL) {\n      this.#lc.warn?.(\n        `Cannot compact ${mb(freeable)} MB of ` +\n          `${this.#db.name} because AUTO_VACUUM mode is ${autoVacuumMode}.`,\n      );\n      return;\n    }\n    const start = Date.now();\n    const [{page_count: pageCountBefore}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.pragma('incremental_vacuum');\n\n    const [{page_count: pageCountAfter}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.#lc.info?.(\n      `Compacted ${this.#db.name} from ` +\n        `${mb(this.#bytes(pageCountBefore))} MB to ` +\n        `${mb(this.#bytes(pageCountAfter))} MB ` +\n        `(${Date.now() - start} ms)`,\n    );\n  }\n\n  unsafeMode(unsafe: boolean) {\n    this.#db.unsafeMode(unsafe);\n  }\n\n  /**\n   * Toggles whether the WAL is kept when this is the last connection to close\n   * the database (on by default). Turn it off before switching the database\n   * out of WAL mode (e.g. `journal_mode = DELETE` or `OFF`): with it on, the\n   * WAL file is left behind and reopened by the next transaction, so the\n   * database effectively stays in WAL mode.\n   */\n  persistWal(persist: boolean) {\n    this.#db.persistWal(persist);\n  }\n\n  #run<T>(method: string, sql: string, fn: () => T): T {\n    const start = performance.now();\n    try {\n      return fn();\n    } catch (e) {\n      if (e instanceof SqliteError) {\n        e.message += `: ${sql}`;\n      }\n      throw e;\n    } finally {\n      const elapsed = performance.now() - start;\n      if (elapsed >= this.#threshold) {\n        logSlow(this.#lc.withContext('method', method), elapsed, {method});\n      }\n    }\n  }\n\n  /**\n   * Closes the database. For writable connections, `PRAGMA optimize` is run\n   * first (as recommended by SQLite) unless `optimize` is `false`, which is\n   * appropriate for short-lived handles on a database whose statistics are\n   * maintained by a longer-lived writer.\n   */\n  close({optimize = true}: {optimize?: boolean | undefined} = {}): void {\n    const start = Date.now();\n    if (optimize && !this.#db.readonly) {\n      try {\n        this.#db.pragma('optimize');\n        const elapsed = Date.now() - start;\n        if (elapsed > 2) {\n          this.#lc.debug?.(`PRAGMA optimized (${elapsed} ms)`);\n        }\n      } catch (e) {\n        this.#lc.warn?.('error running PRAGMA optimize', e);\n      }\n    }\n    this.#db.close();\n  }\n\n  transaction<T>(fn: () => T): T {\n    return this.#db.transaction(fn)();\n  }\n\n  get name() {\n    return this.#db.name;\n  }\n\n  get inTransaction() {\n    return this.#db.inTransaction;\n  }\n\n  [Symbol.dispose](): void {\n    this.close();\n  }\n}\n\nexport class Statement {\n  readonly #stmt: SQLite3Statement;\n  readonly #lc: LogContext;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  readonly scanStatus: SQLite3Statement['scanStatusV2'];\n  readonly scanStatusReset: SQLite3Statement['scanStatusReset'];\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    stmt: SQLite3Statement,\n    threshold: number,\n  ) {\n    this.#lc = lc.withContext('class', 'Statement');\n    this.#attrs = attrs;\n    this.#stmt = stmt;\n    this.#threshold = threshold;\n    this.scanStatus = this.#stmt.scanStatusV2.bind(this.#stmt);\n    this.scanStatusReset = this.#stmt.scanStatusReset.bind(this.#stmt);\n  }\n\n  safeIntegers(useBigInt: boolean): this {\n    this.#stmt.safeIntegers(useBigInt);\n    return this;\n  }\n\n  run(...params: unknown[]): RunResult {\n    const start = performance.now();\n    const ret = this.#stmt.run(...params);\n    this.#logIfSlow('run', performance.now() - start);\n    return ret;\n  }\n\n  get<T>(...params: unknown[]): T {\n    const start = performance.now();\n    const ret = this.#stmt.get(...params);\n    this.#logIfSlow('get', performance.now() - start);\n    return ret as T;\n  }\n\n  all<T>(...params: unknown[]): T[] {\n    const start = performance.now();\n    const ret = this.#stmt.all(...params);\n    this.#logIfSlow('all', performance.now() - start);\n    return ret as T[];\n  }\n\n  #logIfSlow(method: string, elapsed: number): void {\n    if (elapsed >= this.#threshold) {\n      logSlow(this.#lc.withContext('method', method), elapsed, {\n        ...this.#attrs,\n        method,\n      });\n    }\n  }\n\n  iterate<T>(...params: unknown[]): IterableIterator<T> {\n    return new LoggingIterableIterator(\n      this.#lc,\n      this.#attrs,\n      this.#stmt.iterate(...params),\n      this.#threshold,\n    ) as IterableIterator<T>;\n  }\n}\n\n// Bound consumer-time warnings across all databases and SQL statements in this\n// process. Nested iterators can all outlive the threshold during the same stall.\nconst ITERATOR_TOTAL_LOG_WINDOW_MS = 60_000;\nconst ITERATOR_TOTAL_LOG_LIMIT = 10;\nlet iteratorTotalLogWindowStart = -Infinity;\nlet iteratorTotalLogsInWindow = 0;\nlet suppressedIteratorTotalLogs = 0;\n\nfunction admitIteratorTotalLog(now: number): number | undefined {\n  if (now - iteratorTotalLogWindowStart >= ITERATOR_TOTAL_LOG_WINDOW_MS) {\n    iteratorTotalLogWindowStart = now;\n    iteratorTotalLogsInWindow = 0;\n  }\n  if (iteratorTotalLogsInWindow >= ITERATOR_TOTAL_LOG_LIMIT) {\n    suppressedIteratorTotalLogs++;\n    return undefined;\n  }\n  iteratorTotalLogsInWindow++;\n  const suppressedCount = suppressedIteratorTotalLogs;\n  suppressedIteratorTotalLogs = 0;\n  return suppressedCount;\n}\n\nclass LoggingIterableIterator<T> implements IterableIterator<T> {\n  readonly #lc: LogContext;\n  readonly #it: IterableIterator<T>;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  #start: number;\n  #sqliteRowTimeSum: number;\n  #logged = false;\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    it: IterableIterator<T>,\n    slowQueryThreshold: number,\n  ) {\n    this.#lc = lc;\n    this.#attrs = attrs;\n    this.#it = it;\n    this.#start = performance.now();\n    this.#threshold = slowQueryThreshold;\n    this.#sqliteRowTimeSum = 0;\n  }\n\n  next(): IteratorResult<T> {\n    const start = performance.now();\n    const ret = this.#it.next();\n    const elapsed = performance.now() - start;\n    this.#sqliteRowTimeSum += elapsed;\n    if (ret.done) {\n      this.#log();\n    }\n    return ret;\n  }\n\n  #log() {\n    // TableSource closes iterators in finally, including after next() is done.\n    if (this.#logged) {\n      return;\n    }\n    this.#logged = true;\n\n    // Total time includes downstream consumer work and waits between rows.\n    // Check it independently of the time spent stepping SQLite.\n    const now = performance.now();\n    const totalMs = now - this.#start;\n    if (totalMs >= this.#threshold) {\n      const suppressedCount = admitIteratorTotalLog(now);\n      if (suppressedCount !== undefined) {\n        logSlow(\n          this.#lc,\n          totalMs,\n          {\n            ...this.#attrs,\n            type: 'total',\n            method: 'iterate',\n            sqliteMs: this.#sqliteRowTimeSum,\n            ...(suppressedCount > 0 ? {suppressedCount} : undefined),\n          },\n          'Slow SQLite iterator total time (including consumer work and waits between rows)',\n        );\n      }\n    }\n    if (this.#sqliteRowTimeSum >= this.#threshold) {\n      logSlow(\n        this.#lc.withContext('method', 'iterate').withContext('type', 'sqlite'),\n        this.#sqliteRowTimeSum,\n        {\n          ...this.#attrs,\n          type: 'sqlite',\n          method: 'iterate',\n          totalMs,\n        },\n      );\n    }\n  }\n\n  [Symbol.iterator](): IterableIterator<T> {\n    return this;\n  }\n\n  return(): IteratorResult<T> {\n    this.#log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.return?.() as any;\n  }\n\n  throw(e: unknown): IteratorResult<T> {\n    this.#log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.throw?.(e) as any;\n  }\n}\n\nfunction logSlow(\n  lc: LogContext,\n  elapsed: number,\n  attrs: Attributes,\n  message = 'Slow SQLite query',\n): void {\n  for (const [key, value] of Object.entries(attrs)) {\n    lc = lc.withContext(key, value);\n  }\n  lc.warn?.(message, elapsed);\n  manualSpan(tracer, 'db.slow-query', elapsed, attrs);\n}\n\n/**\n * An error indicating that the Database failed to open. This essentially\n * wraps the TypeError thrown by the better-sqlite3 package with something\n * more specific.\n */\nexport class DatabaseInitError extends Error {}\n"],"mappings":"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"}

package/out/zqlite/src/explain-queries.js.map

@@ -1 +1 @@
-{"version":3,"file":"explain-queries.js","names":[],"sources":["../../../../zqlite/src/explain-queries.ts"],"sourcesContent":["import type {RowCountsBySource} from '../../zero-protocol/src/analyze-query-result.ts';\nimport type {Database} from './db.ts';\n\nexport function explainQueries(counts: RowCountsBySource, db: Database) {\n  const plans: Record<string, string[]> = {};\n  for (const querySet of Object.values(counts)) {\n    const queries = Object.keys(querySet);\n    for (const query of queries) {\n      const plan = db\n        // we should be more intelligent about value replacement.\n        // Different values result in different plans. E.g., picking a value at the start\n        // of an index will result in `scan` vs `search`. The scan is fine in that case.\n        .prepare(`EXPLAIN QUERY PLAN ${query.replaceAll('?', \"'sdfse'\")}`)\n        .all<{detail: string}>()\n        .map(r => r.detail);\n      plans[query] = plan;\n    }\n  }\n\n  return plans;\n}\n"],"mappings":";AAGA,SAAgB,eAAe,QAA2B,IAAc;CACtE,MAAM,QAAkC,CAAC;CACzC,KAAK,MAAM,YAAY,OAAO,OAAO,MAAM,GAAG;EAC5C,MAAM,UAAU,OAAO,KAAK,QAAQ;EACpC,KAAK,MAAM,SAAS,SAQlB,MAAM,SAPO,GAIV,QAAQ,sBAAsB,MAAM,WAAW,KAAK,SAAS,GAAG,EAChE,IAAsB,EACtB,KAAI,MAAK,EAAE,MACC;CAEnB;CAEA,OAAO;AACT"}
+{"version":3,"file":"explain-queries.js","names":[],"sources":["../../../../zqlite/src/explain-queries.ts"],"sourcesContent":["import type {RowCountsBySource} from '../../zero-protocol/src/analyze-query-result.ts';\nimport type {Database} from './db.ts';\n\nexport function explainQueries(counts: RowCountsBySource, db: Database) {\n  const plans: Record<string, string[]> = {};\n  for (const querySet of Object.values(counts)) {\n    const queries = Object.keys(querySet);\n    for (const query of queries) {\n      const plan = db\n        // we should be more intelligent about value replacement.\n        // Different values result in different plans. E.g., picking a value at the start\n        // of an index will result in `scan` vs `search`. The scan is fine in that case.\n        .prepare(`EXPLAIN QUERY PLAN ${query.replaceAll('?', \"'sdfse'\")}`)\n        .all<{detail: string}>()\n        .map(r => r.detail);\n      plans[query] = plan;\n    }\n  }\n\n  return plans;\n}\n"],"mappings":";AAGA,SAAgB,eAAe,QAA2B,IAAc;CACtE,MAAM,QAAkC,CAAC;CACzC,KAAK,MAAM,YAAY,OAAO,OAAO,MAAM,GAAG;EAC5C,MAAM,UAAU,OAAO,KAAK,QAAQ;EACpC,KAAK,MAAM,SAAS,SAQlB,MAAM,SAPO,GAIV,QAAQ,sBAAsB,MAAM,WAAW,KAAK,SAAS,GAAG,CAAC,CACjE,IAAsB,CAAC,CACvB,KAAI,MAAK,EAAE,MACC;CAEnB;CAEA,OAAO;AACT"}

package/out/zqlite/src/index-usage.js.map

@@ -1 +1 @@
-{"version":3,"file":"index-usage.js","names":[],"sources":["../../../../zqlite/src/index-usage.ts"],"sourcesContent":["import SQLite3Database from '@rocicorp/zero-sqlite3';\nimport type {Statement} from './db.ts';\n\nlet uses = new Map<string, number>();\n\n/**\n * The table-valued function that the SQL of `IN` and `NOT IN` conditions reads\n * its values from (see `simpleConditionToSQL()` in `query-builder.ts`).\n */\nconst JSON_EACH = 'json_each';\n\n/**\n * Counts a run of `stmt`, a read of `table`, against each index of the table\n * that SQLite's plan for it read. Loops that read the table itself (a scan,\n * or a lookup by rowid), or the values of an `IN` (from `json_each`), are not\n * counted, and an index that more than one loop of the plan reads (e.g. for\n * an `OR` of two of its ranges) is counted once.\n *\n * The plan is read after every run rather than once per statement: SQLite\n * plans a statement again when a new binding can change the best plan, as it\n * can with `sqlite_stat4` statistics or for `LIKE`.\n */\nexport function recordIndexUsage(stmt: Statement, table: string): void {\n  let counted: string[] | undefined;\n  // Without SQLITE_SCANSTAT_COMPLEX, scanstatus lists only the loops, each of\n  // which has the name of the index or table it reads, so the first missing\n  // name is the end of the list.\n  for (let i = 0; ; i++) {\n    const name = stmt.scanStatus(i, SQLite3Database.SQLITE_SCANSTAT_NAME, 0);\n    if (name === undefined) {\n      return;\n    }\n    if (\n      name === table ||\n      counted?.includes(name) ||\n      (name === JSON_EACH && readsJsonEach(stmt, i))\n    ) {\n      continue;\n    }\n    (counted ??= []).push(name);\n    uses.set(name, (uses.get(name) ?? 0) + 1);\n  }\n}\n\n/**\n * Whether loop `i` of `stmt` reads the values of `json_each`, rather than an\n * index that happens to have the same name.\n */\nfunction readsJsonEach(stmt: Statement, i: number): boolean {\n  const explain = stmt.scanStatus(\n    i,\n    SQLite3Database.SQLITE_SCANSTAT_EXPLAIN,\n    0,\n  );\n  return explain?.startsWith(`SCAN ${JSON_EACH} VIRTUAL TABLE`) ?? false;\n}\n\n/**\n * Returns the runs recorded by {@link recordIndexUsage} in this process since\n * the last call, by the name of the index they read.\n */\nexport function takeIndexUsage(): Map<string, number> {\n  const taken = uses;\n  uses = new Map();\n  return taken;\n}\n"],"mappings":";;AAGA,IAAI,uBAAO,IAAI,IAAoB;;;;;AAMnC,IAAM,YAAY;;;;;;;;;;;;AAalB,SAAgB,iBAAiB,MAAiB,OAAqB;CACrE,IAAI;CAIJ,KAAK,IAAI,IAAI,IAAK,KAAK;EACrB,MAAM,OAAO,KAAK,WAAW,GAAG,gBAAgB,sBAAsB,CAAC;EACvE,IAAI,SAAS,KAAA,GACX;EAEF,IACE,SAAS,SACT,SAAS,SAAS,IAAI,KACrB,SAAS,aAAa,cAAc,MAAM,CAAC,GAE5C;EAEF,CAAC,YAAY,CAAC,GAAG,KAAK,IAAI;EAC1B,KAAK,IAAI,OAAO,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC;CAC1C;AACF;;;;;AAMA,SAAS,cAAc,MAAiB,GAAoB;CAM1D,OALgB,KAAK,WACnB,GACA,gBAAgB,yBAChB,CAEK,GAAS,WAAW,QAAQ,UAAU,eAAe,KAAK;AACnE;;;;;AAMA,SAAgB,iBAAsC;CACpD,MAAM,QAAQ;CACd,uBAAO,IAAI,IAAI;CACf,OAAO;AACT"}
+{"version":3,"file":"index-usage.js","names":[],"sources":["../../../../zqlite/src/index-usage.ts"],"sourcesContent":["import SQLite3Database from '@rocicorp/zero-sqlite3';\nimport type {Statement} from './db.ts';\n\nlet uses = new Map<string, number>();\n\n/**\n * The table-valued function that the SQL of `IN` and `NOT IN` conditions reads\n * its values from (see `simpleConditionToSQL()` in `query-builder.ts`).\n */\nconst JSON_EACH = 'json_each';\n\n/**\n * Counts a run of `stmt`, a read of `table`, against each index of the table\n * that SQLite's plan for it read. Loops that read the table itself (a scan,\n * or a lookup by rowid), or the values of an `IN` (from `json_each`), are not\n * counted, and an index that more than one loop of the plan reads (e.g. for\n * an `OR` of two of its ranges) is counted once.\n *\n * The plan is read after every run rather than once per statement: SQLite\n * plans a statement again when a new binding can change the best plan, as it\n * can with `sqlite_stat4` statistics or for `LIKE`.\n */\nexport function recordIndexUsage(stmt: Statement, table: string): void {\n  let counted: string[] | undefined;\n  // Without SQLITE_SCANSTAT_COMPLEX, scanstatus lists only the loops, each of\n  // which has the name of the index or table it reads, so the first missing\n  // name is the end of the list.\n  for (let i = 0; ; i++) {\n    const name = stmt.scanStatus(i, SQLite3Database.SQLITE_SCANSTAT_NAME, 0);\n    if (name === undefined) {\n      return;\n    }\n    if (\n      name === table ||\n      counted?.includes(name) ||\n      (name === JSON_EACH && readsJsonEach(stmt, i))\n    ) {\n      continue;\n    }\n    (counted ??= []).push(name);\n    uses.set(name, (uses.get(name) ?? 0) + 1);\n  }\n}\n\n/**\n * Whether loop `i` of `stmt` reads the values of `json_each`, rather than an\n * index that happens to have the same name.\n */\nfunction readsJsonEach(stmt: Statement, i: number): boolean {\n  const explain = stmt.scanStatus(\n    i,\n    SQLite3Database.SQLITE_SCANSTAT_EXPLAIN,\n    0,\n  );\n  return explain?.startsWith(`SCAN ${JSON_EACH} VIRTUAL TABLE`) ?? false;\n}\n\n/**\n * Returns the runs recorded by {@link recordIndexUsage} in this process since\n * the last call, by the name of the index they read.\n */\nexport function takeIndexUsage(): Map<string, number> {\n  const taken = uses;\n  uses = new Map();\n  return taken;\n}\n"],"mappings":";;AAGA,IAAI,uBAAO,IAAI,IAAoB;;;;;AAMnC,IAAM,YAAY;;;;;;;;;;;;AAalB,SAAgB,iBAAiB,MAAiB,OAAqB;CACrE,IAAI;CAIJ,KAAK,IAAI,IAAI,IAAK,KAAK;EACrB,MAAM,OAAO,KAAK,WAAW,GAAG,gBAAgB,sBAAsB,CAAC;EACvE,IAAI,SAAS,KAAA,GACX;EAEF,IACE,SAAS,SACT,SAAS,SAAS,IAAI,KACrB,SAAS,aAAa,cAAc,MAAM,CAAC,GAE5C;EAEF,CAAC,YAAY,CAAC,EAAA,CAAG,KAAK,IAAI;EAC1B,KAAK,IAAI,OAAO,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC;CAC1C;AACF;;;;;AAMA,SAAS,cAAc,MAAiB,GAAoB;CAM1D,OALgB,KAAK,WACnB,GACA,gBAAgB,yBAChB,CAEK,CAAA,EAAS,WAAW,QAAQ,UAAU,eAAe,KAAK;AACnE;;;;;AAMA,SAAgB,iBAAsC;CACpD,MAAM,QAAQ;CACd,uBAAO,IAAI,IAAI;CACf,OAAO;AACT"}

package/out/zqlite/src/internal/sql-inline.js.map

@@ -1 +1 @@
-{"version":3,"file":"sql-inline.js","names":[],"sources":["../../../../../zqlite/src/internal/sql-inline.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig} from '@databases/sql';\nimport type {SQLQuery} from '@databases/sql';\n\n/**\n * Escapes a SQLite string value by doubling single quotes.\n * SQLite uses single quotes for string literals and doubles them for escaping.\n */\nfunction escapeSQLiteString(str: string): string {\n  return `'${str.replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Formats a value for inline inclusion in SQL (not as a placeholder).\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner,\n * not for user-facing queries. All production queries must use parameterized\n * statements to prevent SQL injection.\n *\n * @param value The value to inline into SQL\n * @returns SQL literal representation of the value\n */\nfunction inlineValue(value: unknown): string {\n  if (value === null) {\n    return 'NULL';\n  }\n  if (typeof value === 'string') {\n    return escapeSQLiteString(value);\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'boolean') {\n    // SQLite uses 1 and 0 for booleans\n    return value ? '1' : '0';\n  }\n  if (Array.isArray(value)) {\n    // For arrays, use JSON representation (same as query-builder.ts does for IN clauses)\n    return escapeSQLiteString(JSON.stringify(value));\n  }\n  // For objects/other JSON types\n  return escapeSQLiteString(JSON.stringify(value));\n}\n\n/**\n * Format configuration that inlines values directly into SQL instead of using placeholders.\n *\n * This is used ONLY for cost estimation in the SQLite cost model, where we want SQLite's\n * query planner to see actual values to make better decisions about index usage and query plans.\n *\n * Production code must use the standard parameterized format from sql.ts.\n */\nconst sqliteInlineFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value =>\n    // undefined is our signal to use a placeholder\n    // IMPORTANT. Changing this will break the planner as it will assume `NULL`\n    // for constraints!\n    value === undefined\n      ? {\n          placeholder: '?',\n          value,\n        }\n      : {\n          placeholder: inlineValue(value),\n          value: undefined, // No binding needed since value is inlined\n        },\n};\n\n/**\n * Compiles a SQL query with values inlined directly into the SQL string.\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner.\n * Never use this for user-facing queries - always use the standard `compile()`\n * function from sql.ts which uses parameterized queries.\n *\n * @param sql The SQL query to compile\n * @returns SQL string with values inlined\n */\nexport function compileInline(sql: SQLQuery): string {\n  return sql.format(sqliteInlineFormat).text;\n}\n"],"mappings":";;;;;;AAQA,SAAS,mBAAmB,KAAqB;CAC/C,OAAO,IAAI,IAAI,QAAQ,MAAM,IAAI,EAAE;AACrC;;;;;;;;;;;AAYA,SAAS,YAAY,OAAwB;CAC3C,IAAI,UAAU,MACZ,OAAO;CAET,IAAI,OAAO,UAAU,UACnB,OAAO,mBAAmB,KAAK;CAEjC,IAAI,OAAO,UAAU,UACnB,OAAO,OAAO,KAAK;CAErB,IAAI,OAAO,UAAU,WAEnB,OAAO,QAAQ,MAAM;CAEvB,IAAI,MAAM,QAAQ,KAAK,GAErB,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;CAGjD,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;AACjD;;;;;;;;;AAUA,IAAM,qBAAmC;CACvC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,UAIX,UAAU,KAAA,IACN;EACE,aAAa;EACb;CACF,IACA;EACE,aAAa,YAAY,KAAK;EAC9B,OAAO,KAAA;CACT;AACR;;;;;;;;;;;AAYA,SAAgB,cAAc,KAAuB;CACnD,OAAO,IAAI,OAAO,kBAAkB,EAAE;AACxC"}
+{"version":3,"file":"sql-inline.js","names":[],"sources":["../../../../../zqlite/src/internal/sql-inline.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig} from '@databases/sql';\nimport type {SQLQuery} from '@databases/sql';\n\n/**\n * Escapes a SQLite string value by doubling single quotes.\n * SQLite uses single quotes for string literals and doubles them for escaping.\n */\nfunction escapeSQLiteString(str: string): string {\n  return `'${str.replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Formats a value for inline inclusion in SQL (not as a placeholder).\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner,\n * not for user-facing queries. All production queries must use parameterized\n * statements to prevent SQL injection.\n *\n * @param value The value to inline into SQL\n * @returns SQL literal representation of the value\n */\nfunction inlineValue(value: unknown): string {\n  if (value === null) {\n    return 'NULL';\n  }\n  if (typeof value === 'string') {\n    return escapeSQLiteString(value);\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'boolean') {\n    // SQLite uses 1 and 0 for booleans\n    return value ? '1' : '0';\n  }\n  if (Array.isArray(value)) {\n    // For arrays, use JSON representation (same as query-builder.ts does for IN clauses)\n    return escapeSQLiteString(JSON.stringify(value));\n  }\n  // For objects/other JSON types\n  return escapeSQLiteString(JSON.stringify(value));\n}\n\n/**\n * Format configuration that inlines values directly into SQL instead of using placeholders.\n *\n * This is used ONLY for cost estimation in the SQLite cost model, where we want SQLite's\n * query planner to see actual values to make better decisions about index usage and query plans.\n *\n * Production code must use the standard parameterized format from sql.ts.\n */\nconst sqliteInlineFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value =>\n    // undefined is our signal to use a placeholder\n    // IMPORTANT. Changing this will break the planner as it will assume `NULL`\n    // for constraints!\n    value === undefined\n      ? {\n          placeholder: '?',\n          value,\n        }\n      : {\n          placeholder: inlineValue(value),\n          value: undefined, // No binding needed since value is inlined\n        },\n};\n\n/**\n * Compiles a SQL query with values inlined directly into the SQL string.\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner.\n * Never use this for user-facing queries - always use the standard `compile()`\n * function from sql.ts which uses parameterized queries.\n *\n * @param sql The SQL query to compile\n * @returns SQL string with values inlined\n */\nexport function compileInline(sql: SQLQuery): string {\n  return sql.format(sqliteInlineFormat).text;\n}\n"],"mappings":";;;;;;AAQA,SAAS,mBAAmB,KAAqB;CAC/C,OAAO,IAAI,IAAI,QAAQ,MAAM,IAAI,EAAE;AACrC;;;;;;;;;;;AAYA,SAAS,YAAY,OAAwB;CAC3C,IAAI,UAAU,MACZ,OAAO;CAET,IAAI,OAAO,UAAU,UACnB,OAAO,mBAAmB,KAAK;CAEjC,IAAI,OAAO,UAAU,UACnB,OAAO,OAAO,KAAK;CAErB,IAAI,OAAO,UAAU,WAEnB,OAAO,QAAQ,MAAM;CAEvB,IAAI,MAAM,QAAQ,KAAK,GAErB,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;CAGjD,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;AACjD;;;;;;;;;AAUA,IAAM,qBAAmC;CACvC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,UAIX,UAAU,KAAA,IACN;EACE,aAAa;EACb;CACF,IACA;EACE,aAAa,YAAY,KAAK;EAC9B,OAAO,KAAA;CACT;AACR;;;;;;;;;;;AAYA,SAAgB,cAAc,KAAuB;CACnD,OAAO,IAAI,OAAO,kBAAkB,CAAC,CAAC;AACxC"}

package/out/zqlite/src/internal/sql.js.map

@@ -1 +1 @@
-{"version":3,"file":"sql.js","names":[],"sources":["../../../../../zqlite/src/internal/sql.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig, SQLQuery} from '@databases/sql';\nimport sql from '@databases/sql';\n\nconst sqliteFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value => ({placeholder: '?', value}),\n};\n\nexport function compile(sql: SQLQuery): string {\n  return sql.format(sqliteFormat).text;\n}\n\nexport function format(sql: SQLQuery) {\n  return sql.format(sqliteFormat);\n}\n\nexport {sql};\n"],"mappings":";;;AAIA,IAAM,eAA6B;CACjC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,WAAU;EAAC,aAAa;EAAK;CAAK;AACjD;AAEA,SAAgB,QAAQ,KAAuB;CAC7C,OAAO,IAAI,OAAO,YAAY,EAAE;AAClC;AAEA,SAAgB,OAAO,KAAe;CACpC,OAAO,IAAI,OAAO,YAAY;AAChC"}
+{"version":3,"file":"sql.js","names":[],"sources":["../../../../../zqlite/src/internal/sql.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig, SQLQuery} from '@databases/sql';\nimport sql from '@databases/sql';\n\nconst sqliteFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value => ({placeholder: '?', value}),\n};\n\nexport function compile(sql: SQLQuery): string {\n  return sql.format(sqliteFormat).text;\n}\n\nexport function format(sql: SQLQuery) {\n  return sql.format(sqliteFormat);\n}\n\nexport {sql};\n"],"mappings":";;;AAIA,IAAM,eAA6B;CACjC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,WAAU;EAAC,aAAa;EAAK;CAAK;AACjD;AAEA,SAAgB,QAAQ,KAAuB;CAC7C,OAAO,IAAI,OAAO,YAAY,CAAC,CAAC;AAClC;AAEA,SAAgB,OAAO,KAAe;CACpC,OAAO,IAAI,OAAO,YAAY;AAChC"}

package/out/zqlite/src/internal/statement-cache.js

@@ -145,6 +145,6 @@ function normalizeWhitespace(sql) {
 	return sql.replaceAll(/\s+/g, " ");
 }
 //#endregion
-export { StatementCache };
+export { DEFAULT_MAX_CACHED_STATEMENTS, StatementCache };
 
 //# sourceMappingURL=statement-cache.js.map

package/out/zqlite/src/internal/statement-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"statement-cache.js","names":["#db","#maxSize","#size","#evictLeastRecentlyUsed","#cache"],"sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../db.ts';\n\nexport type CachedStatementMap = Map<string, Statement[]>;\nexport type CachedStatement = {\n  sql: string;\n  statement: Statement;\n};\n\n/**\n * The default maximum number of statements retained by a StatementCache.\n *\n * Each cached statement holds a native `sqlite3_stmt` handle (prepared\n * bytecode + SQLite-side memory), so the cache must be bounded. The bound\n * needs enough headroom for callers with a large working set of distinct\n * SQL — e.g. the replication change-processor prepares several statements\n * per table (with additional variants for partial-column updates) through\n * a single cache — while still capping growth from unbounded key spaces\n * such as client-influenced query shapes.\n */\nexport const DEFAULT_MAX_CACHED_STATEMENTS = 1_000;\n\n/**\n * SQLite statement preparation isn't cheap as it involves evaluating possible\n * query plans and picking the best one (in addition to parsing the SQL).\n *\n * This statement cache prevents the need to re-prepare the same statement\n * multiple times.\n *\n * One extra wrinkle is that a single statement cannot be used by multiple\n * callers at the same time. As in, we can't `iterate` the same statement\n * many times concurrently.\n *\n * Given that, statements are removed from the cache while in use.\n * - `get` removes the statement from the cache\n * - `return` adds it back.\n *\n * If a request for the same sql is made while a\n * statement is gotten, a new statement will be prepared.\n * Both statements can be returned to the cache even though they both\n * serve the same SQL. Having both copies returned to the cache allows\n * the cache to serve multiple callers concurrently in the future.\n *\n * It is not an error to fail to call `return` on a statement.\n * Failing to call return will only prevent the statement from being reused\n * by other callers. It will not cause a resource leak.\n *\n * The cache is bounded: it retains at most `maxSize` statements, evicting\n * the least recently used statements when the bound is exceeded. Only idle\n * (returned) statements are ever evicted — statements checked out via `get`\n * are not in the cache and thus never touched by eviction. Evicting a\n * statement drops the cache's reference to it; the native `sqlite3_stmt`\n * handle is finalized when the Statement object is garbage collected.\n */\nexport class StatementCache {\n  // Map insertion order doubles as recency order: entries are re-inserted\n  // on every `get` hit and `return`, so the first entry in the map is the\n  // least recently used. Within an entry's array, the first statement is\n  // the least recently returned.\n  #cache: CachedStatementMap = new Map<string, Statement[]>();\n  readonly #db: Database;\n  readonly #maxSize: number;\n  #size: number = 0;\n\n  /**\n   * The db connection used to prepare the statement.\n   * It is an error to use a statement prepared on one connection with another connection.\n   * @param db\n   * @param maxSize the maximum number of statements to retain in the cache.\n   */\n  constructor(db: Database, maxSize: number = DEFAULT_MAX_CACHED_STATEMENTS) {\n    assert(maxSize >= 0, 'maxSize must not be negative');\n    this.#db = db;\n    this.#maxSize = maxSize;\n  }\n\n  // the number of statements in the cache\n  get size() {\n    return this.#size;\n  }\n\n  // the maximum number of statements the cache will retain\n  get maxSize() {\n    return this.#maxSize;\n  }\n\n  drop(n: number) {\n    assert(n >= 0, 'Cannot drop a negative number of items');\n    assert(n <= this.#size, 'Cannot drop more items than are in the cache');\n\n    for (let i = 0; i < n; i++) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  /**\n   * Prepares a statement for the given sql unless one is already cached.\n   * If one is cached, it is removed from the cache and returned.\n   *\n   * Since `get` removes the item from the cache it is not an error to fail to call\n   * `return`. The gotten statement will be correctly garbage collected.\n   *\n   * When a gotten statement is not returned, future calls to\n   * `get` with the same `sql` will prepare a new statement.\n   *\n   * @param sql\n   * @returns\n   */\n  get(sql: string): CachedStatement {\n    sql = normalizeWhitespace(sql);\n    const statements = this.#cache.get(sql);\n    if (statements && statements.length > 0) {\n      const statement = statements.pop()!;\n      this.#size--;\n      this.#cache.delete(sql);\n      if (statements.length > 0) {\n        // Re-insert so the remaining statements for this sql are marked\n        // as most recently used.\n        this.#cache.set(sql, statements);\n      }\n      return {sql, statement};\n    }\n    const statement = this.#db.prepare(sql);\n    return {sql, statement};\n  }\n\n  /**\n   * Handles `get` and `return` for the caller by invoking them before\n   * and after the callback.\n   */\n  use<T>(sql: string, cb: (statement: CachedStatement) => T) {\n    const statement = this.get(sql);\n    try {\n      return cb(statement);\n    } finally {\n      this.return(statement);\n    }\n  }\n\n  /**\n   * Add a statement back to the cache so someone else can use it later.\n   *\n   * If this pushes the cache over its maximum size, the least recently\n   * used statements are evicted.\n   * @param statement\n   */\n  return(statement: CachedStatement) {\n    const {sql} = statement;\n    let statements = this.#cache.get(sql);\n    if (statements === undefined) {\n      statements = [];\n    } else {\n      // Delete so the re-insert below moves this sql to the most recently\n      // used position.\n      this.#cache.delete(sql);\n    }\n    statements.push(statement.statement);\n    this.#cache.set(sql, statements);\n    this.#size++;\n\n    while (this.#size > this.#maxSize) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  #evictLeastRecentlyUsed() {\n    const lru = this.#cache.entries().next();\n    assert(!lru.done, 'Cannot evict from an empty cache');\n    const [sql, statements] = lru.value;\n    statements.shift();\n    this.#size--;\n    if (statements.length === 0) {\n      this.#cache.delete(sql);\n    }\n  }\n}\n\nfunction normalizeWhitespace(sql: string) {\n  return sql.replaceAll(/\\s+/g, ' ');\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,IAAa,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC7C,IAAa,iBAAb,MAA4B;CAK1B,yBAA6B,IAAI,IAAyB;CAC1D;CACA;CACA,QAAgB;;;;;;;CAQhB,YAAY,IAAc,UAAkB,+BAA+B;EACzE,OAAO,WAAW,GAAG,8BAA8B;EACnD,KAAKA,MAAM;EACX,KAAKC,WAAW;CAClB;CAGA,IAAI,OAAO;EACT,OAAO,KAAKC;CACd;CAGA,IAAI,UAAU;EACZ,OAAO,KAAKD;CACd;CAEA,KAAK,GAAW;EACd,OAAO,KAAK,GAAG,wCAAwC;EACvD,OAAO,KAAK,KAAKC,OAAO,8CAA8C;EAEtE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,KAAKC,wBAAwB;CAEjC;;;;;;;;;;;;;;CAeA,IAAI,KAA8B;EAChC,MAAM,oBAAoB,GAAG;EAC7B,MAAM,aAAa,KAAKC,OAAO,IAAI,GAAG;EACtC,IAAI,cAAc,WAAW,SAAS,GAAG;GACvC,MAAM,YAAY,WAAW,IAAI;GACjC,KAAKF;GACL,KAAKE,OAAO,OAAO,GAAG;GACtB,IAAI,WAAW,SAAS,GAGtB,KAAKA,OAAO,IAAI,KAAK,UAAU;GAEjC,OAAO;IAAC;IAAK;GAAS;EACxB;EACA,MAAM,YAAY,KAAKJ,IAAI,QAAQ,GAAG;EACtC,OAAO;GAAC;GAAK;EAAS;CACxB;;;;;CAMA,IAAO,KAAa,IAAuC;EACzD,MAAM,YAAY,KAAK,IAAI,GAAG;EAC9B,IAAI;GACF,OAAO,GAAG,SAAS;EACrB,UAAU;GACR,KAAK,OAAO,SAAS;EACvB;CACF;;;;;;;;CASA,OAAO,WAA4B;EACjC,MAAM,EAAC,QAAO;EACd,IAAI,aAAa,KAAKI,OAAO,IAAI,GAAG;EACpC,IAAI,eAAe,KAAA,GACjB,aAAa,CAAC;OAId,KAAKA,OAAO,OAAO,GAAG;EAExB,WAAW,KAAK,UAAU,SAAS;EACnC,KAAKA,OAAO,IAAI,KAAK,UAAU;EAC/B,KAAKF;EAEL,OAAO,KAAKA,QAAQ,KAAKD,UACvB,KAAKE,wBAAwB;CAEjC;CAEA,0BAA0B;EACxB,MAAM,MAAM,KAAKC,OAAO,QAAQ,EAAE,KAAK;EACvC,OAAO,CAAC,IAAI,MAAM,kCAAkC;EACpD,MAAM,CAAC,KAAK,cAAc,IAAI;EAC9B,WAAW,MAAM;EACjB,KAAKF;EACL,IAAI,WAAW,WAAW,GACxB,KAAKE,OAAO,OAAO,GAAG;CAE1B;AACF;AAEA,SAAS,oBAAoB,KAAa;CACxC,OAAO,IAAI,WAAW,QAAQ,GAAG;AACnC"}
+{"version":3,"file":"statement-cache.js","names":[],"sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../db.ts';\n\nexport type CachedStatementMap = Map<string, Statement[]>;\nexport type CachedStatement = {\n  sql: string;\n  statement: Statement;\n};\n\n/**\n * The default maximum number of statements retained by a StatementCache.\n *\n * Each cached statement holds a native `sqlite3_stmt` handle (prepared\n * bytecode + SQLite-side memory), so the cache must be bounded. The bound\n * needs enough headroom for callers with a large working set of distinct\n * SQL — e.g. the replication change-processor prepares several statements\n * per table (with additional variants for partial-column updates) through\n * a single cache — while still capping growth from unbounded key spaces\n * such as client-influenced query shapes.\n */\nexport const DEFAULT_MAX_CACHED_STATEMENTS = 1_000;\n\n/**\n * SQLite statement preparation isn't cheap as it involves evaluating possible\n * query plans and picking the best one (in addition to parsing the SQL).\n *\n * This statement cache prevents the need to re-prepare the same statement\n * multiple times.\n *\n * One extra wrinkle is that a single statement cannot be used by multiple\n * callers at the same time. As in, we can't `iterate` the same statement\n * many times concurrently.\n *\n * Given that, statements are removed from the cache while in use.\n * - `get` removes the statement from the cache\n * - `return` adds it back.\n *\n * If a request for the same sql is made while a\n * statement is gotten, a new statement will be prepared.\n * Both statements can be returned to the cache even though they both\n * serve the same SQL. Having both copies returned to the cache allows\n * the cache to serve multiple callers concurrently in the future.\n *\n * It is not an error to fail to call `return` on a statement.\n * Failing to call return will only prevent the statement from being reused\n * by other callers. It will not cause a resource leak.\n *\n * The cache is bounded: it retains at most `maxSize` statements, evicting\n * the least recently used statements when the bound is exceeded. Only idle\n * (returned) statements are ever evicted — statements checked out via `get`\n * are not in the cache and thus never touched by eviction. Evicting a\n * statement drops the cache's reference to it; the native `sqlite3_stmt`\n * handle is finalized when the Statement object is garbage collected.\n */\nexport class StatementCache {\n  // Map insertion order doubles as recency order: entries are re-inserted\n  // on every `get` hit and `return`, so the first entry in the map is the\n  // least recently used. Within an entry's array, the first statement is\n  // the least recently returned.\n  #cache: CachedStatementMap = new Map<string, Statement[]>();\n  readonly #db: Database;\n  readonly #maxSize: number;\n  #size: number = 0;\n\n  /**\n   * The db connection used to prepare the statement.\n   * It is an error to use a statement prepared on one connection with another connection.\n   * @param db\n   * @param maxSize the maximum number of statements to retain in the cache.\n   */\n  constructor(db: Database, maxSize: number = DEFAULT_MAX_CACHED_STATEMENTS) {\n    assert(maxSize >= 0, 'maxSize must not be negative');\n    this.#db = db;\n    this.#maxSize = maxSize;\n  }\n\n  // the number of statements in the cache\n  get size() {\n    return this.#size;\n  }\n\n  // the maximum number of statements the cache will retain\n  get maxSize() {\n    return this.#maxSize;\n  }\n\n  drop(n: number) {\n    assert(n >= 0, 'Cannot drop a negative number of items');\n    assert(n <= this.#size, 'Cannot drop more items than are in the cache');\n\n    for (let i = 0; i < n; i++) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  /**\n   * Prepares a statement for the given sql unless one is already cached.\n   * If one is cached, it is removed from the cache and returned.\n   *\n   * Since `get` removes the item from the cache it is not an error to fail to call\n   * `return`. The gotten statement will be correctly garbage collected.\n   *\n   * When a gotten statement is not returned, future calls to\n   * `get` with the same `sql` will prepare a new statement.\n   *\n   * @param sql\n   * @returns\n   */\n  get(sql: string): CachedStatement {\n    sql = normalizeWhitespace(sql);\n    const statements = this.#cache.get(sql);\n    if (statements && statements.length > 0) {\n      const statement = statements.pop()!;\n      this.#size--;\n      this.#cache.delete(sql);\n      if (statements.length > 0) {\n        // Re-insert so the remaining statements for this sql are marked\n        // as most recently used.\n        this.#cache.set(sql, statements);\n      }\n      return {sql, statement};\n    }\n    const statement = this.#db.prepare(sql);\n    return {sql, statement};\n  }\n\n  /**\n   * Handles `get` and `return` for the caller by invoking them before\n   * and after the callback.\n   */\n  use<T>(sql: string, cb: (statement: CachedStatement) => T) {\n    const statement = this.get(sql);\n    try {\n      return cb(statement);\n    } finally {\n      this.return(statement);\n    }\n  }\n\n  /**\n   * Add a statement back to the cache so someone else can use it later.\n   *\n   * If this pushes the cache over its maximum size, the least recently\n   * used statements are evicted.\n   * @param statement\n   */\n  return(statement: CachedStatement) {\n    const {sql} = statement;\n    let statements = this.#cache.get(sql);\n    if (statements === undefined) {\n      statements = [];\n    } else {\n      // Delete so the re-insert below moves this sql to the most recently\n      // used position.\n      this.#cache.delete(sql);\n    }\n    statements.push(statement.statement);\n    this.#cache.set(sql, statements);\n    this.#size++;\n\n    while (this.#size > this.#maxSize) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  #evictLeastRecentlyUsed() {\n    const lru = this.#cache.entries().next();\n    assert(!lru.done, 'Cannot evict from an empty cache');\n    const [sql, statements] = lru.value;\n    statements.shift();\n    this.#size--;\n    if (statements.length === 0) {\n      this.#cache.delete(sql);\n    }\n  }\n}\n\nfunction normalizeWhitespace(sql: string) {\n  return sql.replaceAll(/\\s+/g, ' ');\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,IAAa,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC7C,IAAa,iBAAb,MAA4B;CAK1B,yBAA6B,IAAI,IAAyB;CAC1D;CACA;CACA,QAAgB;;;;;;;CAQhB,YAAY,IAAc,UAAkB,+BAA+B;EACzE,OAAO,WAAW,GAAG,8BAA8B;EACnD,KAAK,MAAM;EACX,KAAK,WAAW;CAClB;CAGA,IAAI,OAAO;EACT,OAAO,KAAK;CACd;CAGA,IAAI,UAAU;EACZ,OAAO,KAAK;CACd;CAEA,KAAK,GAAW;EACd,OAAO,KAAK,GAAG,wCAAwC;EACvD,OAAO,KAAK,KAAK,OAAO,8CAA8C;EAEtE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,KAAK,wBAAwB;CAEjC;;;;;;;;;;;;;;CAeA,IAAI,KAA8B;EAChC,MAAM,oBAAoB,GAAG;EAC7B,MAAM,aAAa,KAAK,OAAO,IAAI,GAAG;EACtC,IAAI,cAAc,WAAW,SAAS,GAAG;GACvC,MAAM,YAAY,WAAW,IAAI;GACjC,KAAK;GACL,KAAK,OAAO,OAAO,GAAG;GACtB,IAAI,WAAW,SAAS,GAGtB,KAAK,OAAO,IAAI,KAAK,UAAU;GAEjC,OAAO;IAAC;IAAK;GAAS;EACxB;EACA,MAAM,YAAY,KAAK,IAAI,QAAQ,GAAG;EACtC,OAAO;GAAC;GAAK;EAAS;CACxB;;;;;CAMA,IAAO,KAAa,IAAuC;EACzD,MAAM,YAAY,KAAK,IAAI,GAAG;EAC9B,IAAI;GACF,OAAO,GAAG,SAAS;EACrB,UAAU;GACR,KAAK,OAAO,SAAS;EACvB;CACF;;;;;;;;CASA,OAAO,WAA4B;EACjC,MAAM,EAAC,QAAO;EACd,IAAI,aAAa,KAAK,OAAO,IAAI,GAAG;EACpC,IAAI,eAAe,KAAA,GACjB,aAAa,CAAC;OAId,KAAK,OAAO,OAAO,GAAG;EAExB,WAAW,KAAK,UAAU,SAAS;EACnC,KAAK,OAAO,IAAI,KAAK,UAAU;EAC/B,KAAK;EAEL,OAAO,KAAK,QAAQ,KAAK,UACvB,KAAK,wBAAwB;CAEjC;CAEA,0BAA0B;EACxB,MAAM,MAAM,KAAK,OAAO,QAAQ,CAAC,CAAC,KAAK;EACvC,OAAO,CAAC,IAAI,MAAM,kCAAkC;EACpD,MAAM,CAAC,KAAK,cAAc,IAAI;EAC9B,WAAW,MAAM;EACjB,KAAK;EACL,IAAI,WAAW,WAAW,GACxB,KAAK,OAAO,OAAO,GAAG;CAE1B;AACF;AAEA,SAAS,oBAAoB,KAAa;CACxC,OAAO,IAAI,WAAW,QAAQ,GAAG;AACnC"}

package/out/zqlite/src/mod.js

@@ -1,5 +1,5 @@
-import "../../zero-types/src/format.js";
-import "../../zql/src/query/query-impl.js";
-import "./db.js";
-import "./query-delegate.js";
-export {};
+import { defaultFormat } from "../../zero-types/src/format.js";
+import { QueryImpl } from "../../zql/src/query/query-impl.js";
+import { Database } from "./db.js";
+import { QueryDelegateImpl } from "./query-delegate.js";
+export { Database, QueryDelegateImpl as QueryDelegate, QueryImpl, defaultFormat };