okengine 0.23.0 → 0.23.2

package/src/elements/store/cache.ts

@@ -81,6 +81,21 @@ export function isInvalidatedByWrite(key: string, writeEffects: Effects): boolea
   return (writeEffects.writes ?? []).some((w) => w === resource);
 }
 
+/** Options for {@link createStoreCache}. */
+export interface CreateStoreCacheOptions {
+  /** Clock for TTL expiry. */
+  readonly now?: () => number;
+  /** Entry cap. Default 10_000. Oldest entry is dropped. */
+  readonly maxEntries?: number;
+  /** TTL applied when a put does not set one. Default 60_000. */
+  readonly defaultTtlMs?: number;
+  /**
+   * Tell other instances which resources changed. Not called for
+   * {@link StoreCache.acceptRemote}.
+   */
+  readonly fanout?: (resources: readonly ResourceRef[]) => void;
+}
+
 /** In-memory multi-tier cache used by the store runtime and tests. */
 export interface StoreCache {
   /**
@@ -111,6 +126,32 @@ export interface StoreCache {
   keys(): string[];
   /** Clear all tiers. */
   clear(): void;
+  /** Default TTL for puts that omit one. */
+  readonly defaultTtlMs: number;
+  /** Current generation for a resource. Invalidation increments it. */
+  generationOf(resource: string): number;
+  /** True when every resource is still at the captured generation. */
+  sameGeneration(snapshot: Readonly<Record<string, number>>): boolean;
+  /**
+   * Apply an invalidation that arrived from another instance.
+   * Does not call `fanout`.
+   *
+   * @param resources - Resources the other instance wrote
+   */
+  acceptRemote(resources: readonly ResourceRef[]): InvalidationEvent;
+  /**
+   * Run `task` once per key. A caller that joined before an invalidation
+   * refetches once instead of keeping a value the cache will not store.
+   *
+   * @param key - Flight key
+   * @param resources - Resources read by the flight
+   * @param task - Loader
+   */
+  coalesce<T>(
+    key: string,
+    resources: readonly string[],
+    task: () => Promise<T>,
+  ): Promise<{ readonly value: T; readonly cacheable: boolean }>;
 }
 
 /**
@@ -118,37 +159,133 @@ export interface StoreCache {
  *
  * @param now - Clock for TTL expiry
  */
-export function createStoreCache(now: () => number = () => Date.now()): StoreCache {
+export function createStoreCache(
+  nowOrOptions: (() => number) | CreateStoreCacheOptions = {},
+): StoreCache {
+  const options: CreateStoreCacheOptions =
+    typeof nowOrOptions === "function" ? { now: nowOrOptions } : nowOrOptions;
+  const now = options.now ?? (() => Date.now());
+  const maxEntries = options.maxEntries ?? 10_000;
+  const defaultTtlMs = options.defaultTtlMs ?? 60_000;
   const entries = new Map<string, CacheEntry>();
+  const byResource = new Map<string, Set<string>>();
+  const generations = new Map<string, number>();
+  const flights = new Map<
+    string,
+    {
+      readonly promise: Promise<unknown>;
+      readonly resources: readonly string[];
+      readonly generation: Readonly<Record<string, number>>;
+    }
+  >();
 
   function alive(entry: CacheEntry): boolean {
     return entry.expiresAt === null || entry.expiresAt > now();
   }
 
-  return {
+  function forget(key: string): void {
+    const entry = entries.get(key);
+    entries.delete(key);
+    if (!entry) return;
+    for (const resource of entry.resources) byResource.get(resource)?.delete(key);
+  }
+
+  function snapshot(resources: readonly string[]): Record<string, number> {
+    const out: Record<string, number> = {};
+    for (const resource of resources) out[resource] = generations.get(resource) ?? 0;
+    return out;
+  }
+
+  function dropFlights(resources: readonly ResourceRef[]): void {
+    const set = new Set(resources);
+    for (const [key, flight] of flights) {
+      if (flight.resources.some((resource) => set.has(resource as ResourceRef))) {
+        flights.delete(key);
+      }
+    }
+  }
+
+  function invalidateLocal(resources: readonly ResourceRef[]): InvalidationEvent {
+    const keys: string[] = [];
+    for (const resource of resources) {
+      generations.set(resource, (generations.get(resource) ?? 0) + 1);
+      const held = byResource.get(resource);
+      if (!held) continue;
+      for (const key of held) {
+        keys.push(key);
+        forget(key);
+      }
+      held.clear();
+    }
+    dropFlights(resources);
+    return { resources: [...resources], keys };
+  }
+
+  const api: StoreCache = {
+    defaultTtlMs,
     get<T = unknown>(key: string): T | undefined {
       const entry = entries.get(key);
       if (!entry) return undefined;
       if (!alive(entry)) {
-        entries.delete(key);
+        forget(key);
         return undefined;
       }
+      entries.delete(key);
+      entries.set(key, entry);
       return entry.value as T;
     },
     set<T>(entry: CacheEntry<T>): void {
+      forget(entry.key);
       entries.set(entry.key, entry as CacheEntry);
+      for (const resource of entry.resources) {
+        const set = byResource.get(resource) ?? new Set<string>();
+        set.add(entry.key);
+        byResource.set(resource, set);
+      }
+      while (entries.size > maxEntries) {
+        const oldest = entries.keys().next().value;
+        if (oldest === undefined) break;
+        forget(oldest);
+      }
     },
     invalidate(resources: readonly ResourceRef[]): InvalidationEvent {
-      const set = new Set(resources);
-      const keys: string[] = [];
-      for (const [key, entry] of entries) {
-        if (entry.tier !== 1) continue;
-        if (entry.resources.some((r) => set.has(r))) {
-          keys.push(key);
-          entries.delete(key);
-        }
+      const event = invalidateLocal(resources);
+      options.fanout?.(resources);
+      return event;
+    },
+    generationOf(resource: string): number {
+      return generations.get(resource) ?? 0;
+    },
+    sameGeneration(shot: Readonly<Record<string, number>>): boolean {
+      for (const [resource, generation] of Object.entries(shot)) {
+        if ((generations.get(resource) ?? 0) !== generation) return false;
+      }
+      return true;
+    },
+    acceptRemote(resources: readonly ResourceRef[]): InvalidationEvent {
+      return invalidateLocal(resources);
+    },
+    async coalesce<T>(
+      key: string,
+      resources: readonly string[],
+      task: () => Promise<T>,
+    ): Promise<{ readonly value: T; readonly cacheable: boolean }> {
+      const existing = flights.get(key);
+      if (existing) {
+        const value = (await existing.promise) as T;
+        if (api.sameGeneration(existing.generation)) return { value, cacheable: true };
+        const again = await task();
+        return { value: again, cacheable: api.sameGeneration(snapshot(resources)) };
+      }
+      const generation = snapshot(resources);
+      const promise = task();
+      flights.set(key, { promise, resources, generation });
+      try {
+        const value = await promise;
+        return { value, cacheable: api.sameGeneration(generation) };
+      } finally {
+        if (flights.get(key)?.promise === promise) flights.delete(key);
       }
-      return { resources: [...resources], keys };
     },
     invalidateFromEffects(writeEffects: Effects): InvalidationEvent {
       return this.invalidate(resourcesTouchedByWrites(writeEffects));
@@ -158,8 +295,10 @@ export function createStoreCache(now: () => number = () => Date.now()): StoreCac
     },
     clear(): void {
       entries.clear();
+      byResource.clear();
     },
   };
+  return api;
 }
 
 /** Store resource refs that participate in the automatic cache cycle. */
@@ -174,44 +313,158 @@ export function isStoreResourceRef(ref: string): ref is ResourceRef {
   return STORE_REF.test(ref) && ref !== "runs";
 }
 
+/** Effect list keys that disqualify tier-1 auto-cache when non-empty. */
+const DISQUALIFYING_EFFECTS = [
+  "writes",
+  "emits",
+  "sends",
+  "asks",
+  "embeds",
+  "secrets",
+  "calls",
+  "fetches",
+  "decides",
+] as const satisfies readonly (keyof Effects)[];
+
 /**
- * Store reads / writes / asks recorded on one invocation's ledger.
+ * Store and non-store effects recorded on one invocation's ledger.
  *
- * Used when the flow has no stamped `effects` (open capability token) so
- * the cache cycle still runs from what `fx.store` actually touched.
+ * Side effects stay on the result so auto-cache can refuse a flow that
+ * also fetched, emitted, or called — a learned store read is not enough.
  *
  * @param entries - Ledger entries from the invocation
  */
 export function effectsFromLedger(
   entries: readonly { readonly kind: string; readonly resource: string }[],
 ): Effects {
-  const reads: ResourceRef[] = [];
-  const writes: ResourceRef[] = [];
+  const reads: string[] = [];
+  const writes: string[] = [];
   const asks: string[] = [];
-  const seenRead = new Set<string>();
-  const seenWrite = new Set<string>();
+  const emits: string[] = [];
+  const sends: string[] = [];
+  const embeds: string[] = [];
+  const secrets: string[] = [];
+  const calls: string[] = [];
+  const fetches: string[] = [];
+  const decides: string[] = [];
+  const seen = new Set<string>();
+  const push = (bucket: string[], kind: string, resource: string): void => {
+    const key = `${kind}:${resource}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    bucket.push(resource);
+  };
   for (const entry of entries) {
-    if (entry.kind === "ask") {
-      asks.push(entry.resource);
-      continue;
-    }
-    if (!isStoreResourceRef(entry.resource)) continue;
-    if (entry.kind === "read" && !seenRead.has(entry.resource)) {
-      seenRead.add(entry.resource);
-      reads.push(entry.resource);
-    }
-    if (entry.kind === "write" && !seenWrite.has(entry.resource)) {
-      seenWrite.add(entry.resource);
-      writes.push(entry.resource);
+    switch (entry.kind) {
+      case "read":
+        push(reads, entry.kind, entry.resource);
+        break;
+      case "write":
+        push(writes, entry.kind, entry.resource);
+        break;
+      case "ask":
+        push(asks, entry.kind, entry.resource);
+        break;
+      case "emit":
+        push(emits, entry.kind, entry.resource);
+        break;
+      case "send":
+        push(sends, entry.kind, entry.resource);
+        break;
+      case "embed":
+        push(embeds, entry.kind, entry.resource);
+        break;
+      case "secret":
+        push(secrets, entry.kind, entry.resource);
+        break;
+      case "call":
+        push(calls, entry.kind, entry.resource);
+        break;
+      case "fetch":
+        push(fetches, entry.kind, entry.resource);
+        break;
+      case "decide":
+        push(decides, entry.kind, entry.resource);
+        break;
+      default:
+        break;
     }
   }
+  return {
+    ...(reads.length > 0 ? { reads: reads as Effects["reads"] } : {}),
+    ...(writes.length > 0 ? { writes: writes as Effects["writes"] } : {}),
+    ...(asks.length > 0 ? { asks } : {}),
+    ...(emits.length > 0 ? { emits } : {}),
+    ...(sends.length > 0 ? { sends } : {}),
+    ...(embeds.length > 0 ? { embeds } : {}),
+    ...(secrets.length > 0 ? { secrets } : {}),
+    ...(calls.length > 0 ? { calls } : {}),
+    ...(fetches.length > 0 ? { fetches } : {}),
+    ...(decides.length > 0 ? { decides } : {}),
+  };
+}
+
+/**
+ * True when every effect is a store read (`sql:` / `kv:` / `files:` / `index:`).
+ *
+ * Sends, emits, fetches, vault reads, asks, decides, calls, writes, and
+ * non-store reads (`runs`, `signal:`) are not cacheable.
+ *
+ * @param effects - Declared or ledgered effects
+ */
+export function autoCachePure(effects: Effects | undefined): boolean {
+  if (!effects) return false;
+  for (const key of DISQUALIFYING_EFFECTS) {
+    if ((effects[key]?.length ?? 0) > 0) return false;
+  }
+  const reads = effects.reads ?? [];
+  if (reads.length === 0) return false;
+  return reads.every((ref) => isStoreResourceRef(ref));
+}
+
+/**
+ * Union two effect bags. Used so a ledgered fetch cannot be dropped
+ * before the auto-cache eligibility check.
+ *
+ * @param left - Declared or previously resolved effects
+ * @param right - Ledgered effects
+ */
+export function mergeEffects(left: Effects, right: Effects): Effects {
+  const reads = union(left.reads, right.reads);
+  const writes = union(left.writes, right.writes);
+  const emits = union(left.emits, right.emits);
+  const sends = union(left.sends, right.sends);
+  const asks = union(left.asks, right.asks);
+  const embeds = union(left.embeds, right.embeds);
+  const secrets = union(left.secrets, right.secrets);
+  const calls = union(left.calls, right.calls);
+  const fetches = union(left.fetches, right.fetches);
+  const decides = union(left.decides, right.decides);
   return {
     ...(reads.length > 0 ? { reads } : {}),
     ...(writes.length > 0 ? { writes } : {}),
+    ...(emits.length > 0 ? { emits } : {}),
+    ...(sends.length > 0 ? { sends } : {}),
     ...(asks.length > 0 ? { asks } : {}),
+    ...(embeds.length > 0 ? { embeds } : {}),
+    ...(secrets.length > 0 ? { secrets } : {}),
+    ...(calls.length > 0 ? { calls } : {}),
+    ...(fetches.length > 0 ? { fetches } : {}),
+    ...(decides.length > 0 ? { decides } : {}),
   };
 }
 
+/**
+ * Stable union of two effect lists.
+ *
+ * @param left - First list
+ * @param right - Second list
+ */
+function union<T extends string>(left?: readonly T[], right?: readonly T[]): T[] {
+  if ((left?.length ?? 0) === 0 && (right?.length ?? 0) === 0) return [];
+  return [...new Set([...(left ?? []), ...(right ?? [])])];
+}
+
 /**
  * Effects the auto-cache lookup should use: stamped reads when present,
  * otherwise reads learned from a previous run's ledger.
@@ -223,6 +476,9 @@ export function resolveCacheEffects(
   declared: Effects | undefined,
   learnedReads: readonly ResourceRef[] | undefined,
 ): Effects {
+  if (declared && !autoCachePure(declared) && hasAnyEffect(declared)) {
+    return declared;
+  }
   const declaredReads = (declared?.reads ?? []).filter((r) => isStoreResourceRef(r));
   if (declaredReads.length > 0 || (declared?.writes?.length ?? 0) > 0) {
     return declared ?? {};
@@ -233,6 +489,16 @@ export function resolveCacheEffects(
   return declared ?? {};
 }
 
+/**
+ * Whether the effect bag records anything.
+ *
+ * @param effects - Declared or ledgered effects
+ */
+function hasAnyEffect(effects: Effects): boolean {
+  const keys = ["reads", ...DISQUALIFYING_EFFECTS] as const;
+  return keys.some((key) => (effects[key]?.length ?? 0) > 0);
+}
+
 /**
  * Tier-1 hit only when every key is still present (a write to any
  * contributing resource must miss).
@@ -255,48 +521,88 @@ export function tier1Lookup<T>(
   return value;
 }
 
+/**
+ * Caller dimensions stamped into a tier-1 cache key.
+ *
+ * Segments are always present so an empty tenant cannot collide with a set one.
+ */
+export interface Tier1Caller {
+  /** Authenticated user id. Empty when anonymous. */
+  readonly userId?: string | null;
+  /** Active tenant id. Empty when tenancy is off. */
+  readonly tenantId?: string | null;
+  /** Resolved request locale. */
+  readonly locale?: string | null;
+  /** Effective scopes, including the tenant-role union. */
+  readonly scopes?: Iterable<string>;
+  /**
+   * Membership role names. Cache identity only — gates do not read this.
+   */
+  readonly roles?: Iterable<string>;
+  /** Email / session verified bit. `v:0` and `v:1` must not share an entry. */
+  readonly verified?: boolean;
+  /** Operator id when the caller is on the operator plane. */
+  readonly operatorId?: string | null;
+}
+
 /**
  * Whether a flow should use automatic tier-1 cache.
  *
- * Read-only flows (inferred, declared, or ledgered `reads`, no `writes`)
- * cache by default. Opt out with `cache: false`. Mutations, AI asks,
- * durable flows, and empty effect sets stay uncached — no `cache: "30s"`
- * or hand-declared `effects` required on the flow.
+ * On by default for a pure store read that is not durable. `auto: false`
+ * turns the app default off; a flow can still opt in with `cache: true` or a
+ * duration. `cache: false` always disables. Sends, emits, fetches, secrets,
+ * calls, asks, embeds, decides, and writes are never cached.
  *
- * @param options - Flow cache flag, durability, and effect set
+ * @param options - Flow cache flag, app switch, durability, and effect set
  */
 export function autoCacheEligible(options: {
   readonly cache?: boolean | string;
+  /** App-level switch. Omitted means on. `false` turns auto-cache off. */
+  readonly auto?: boolean;
   readonly durable?: boolean;
   readonly effects?: Effects;
 }): boolean {
   if (options.cache === false) return false;
   if (options.durable === true) return false;
-  const effects = options.effects ?? {};
-  if ((effects.asks?.length ?? 0) > 0) return false;
-  if ((effects.writes?.length ?? 0) > 0) return false;
-  const reads = (effects.reads ?? []).filter((r) => isStoreResourceRef(r));
-  return reads.length > 0;
+  if (options.auto === false && options.cache !== true && typeof options.cache !== "string") {
+    return false;
+  }
+  return autoCachePure(options.effects);
 }
 
 /**
  * Dimension suffixes for a flow-scoped tier-1 key.
  *
- * Format after {@link computedCacheKey}: `computed:{resource}/{flow}/{input}[/{userId}]`.
+ * Format after {@link computedCacheKey}:
+ * `computed:{resource}/{flow}/{input}/{userId}/t:{tenant}/l:{locale}/s:{scopes}/r:{roles}`.
  * Invalidation still keys off the resource segment.
  *
+ * A string third argument is the user id (older call shape).
+ *
  * @param flowName - Flow id
  * @param input - Validated flow input
- * @param userId - Caller id when present (per-user lists)
+ * @param caller - Caller identity, or a user id string
  */
 export function tier1FlowDims(
   flowName: string,
   input: unknown,
-  userId?: string | null,
+  caller?: Tier1Caller | string | null,
 ): readonly string[] {
-  const dims = [flowName, fingerprintInput(input)];
-  if (userId) dims.push(userId);
-  return dims;
+  const identity: Tier1Caller =
+    typeof caller === "string" || caller == null ? { userId: caller ?? null } : caller;
+  const scopes = [...(identity.scopes ?? [])].sort();
+  const roles = [...(identity.roles ?? [])].sort();
+  return [
+    flowName,
+    fingerprintInput(input),
+    identity.userId ?? "",
+    `t:${identity.tenantId ?? ""}`,
+    `l:${identity.locale ?? ""}`,
+    `s:${scopes.join(",")}`,
+    `r:${roles.join(",")}`,
+    `v:${identity.verified === true ? "1" : "0"}`,
+    `o:${identity.operatorId ?? ""}`,
+  ];
 }
 
 /**
@@ -305,18 +611,18 @@ export function tier1FlowDims(
  * @param effects - Read effects
  * @param flowName - Flow id
  * @param input - Validated flow input
- * @param userId - Caller id when present
+ * @param caller - Caller identity, or a user id string
  */
 export function tier1DimsByResource(
   effects: Effects,
   flowName: string,
   input: unknown,
-  userId?: string | null,
+  caller?: Tier1Caller | string | null,
 ): Readonly<Record<string, readonly string[]>> {
-  const dims = tier1FlowDims(flowName, input, userId);
+  const dims = tier1FlowDims(flowName, input, caller);
   const out: Record<string, readonly string[]> = {};
   for (const resource of effects.reads ?? []) {
-    if (resource === "runs") continue;
+    if (!isStoreResourceRef(resource)) continue;
     out[resource] = dims;
   }
   return out;

package/src/elements/store/prepare-row.test.ts

@@ -142,8 +142,12 @@ describe("SqlStoreHandle upsert — epoch-ms into timestamp (Postgres)", () => {
   });
 
   test("select/update WHERE coerces epoch-ms on timestamp columns", async () => {
-    await handle.insert(notesTs).values({ id: "old", title: "old", createdAt: 1 });
-    await handle.insert(notesTs).values({ id: "new", title: "new", createdAt: 100 });
+    await handle
+      .insert(notesTs)
+      .values({ id: "old", title: "old", createdAt: 1 as unknown as Date });
+    await handle
+      .insert(notesTs)
+      .values({ id: "new", title: "new", createdAt: 100 as unknown as Date });
 
     // Drizzle types timestamp `{ mode: "date" }` as Date; the store still
     // coerces epoch-ms binds (`fx.clock.now()`) at WHERE compile time.

package/src/elements/store/runtime.ts

@@ -33,6 +33,7 @@ import {
   tier1KeysForReads,
   type StoreCache,
 } from "./cache.ts";
+import { openCacheInvalidation, type CacheBusOptions } from "./cache-bus.ts";
 import { resolveSqlTarget, type SqlBindingConfig } from "./replica.ts";
 import { createSqlStoreHandle, type SqlStoreHandle } from "./sql-session.ts";
 import { classificationsFromTable, type TableHandle } from "./table.ts";
@@ -96,6 +97,15 @@ export interface CreateStoreRuntimeOptions {
   >;
   /** Clock for cache TTLs. */
   readonly now?: () => number;
+  /** Auto-cache entry cap. Default 10_000. */
+  readonly cacheMaxEntries?: number;
+  /** Auto-cache TTL when a flow sets none. Default 60_000. */
+  readonly cacheDefaultTtlMs?: number;
+  /**
+   * Cross-instance invalidation. Omit for a single process.
+   * Redis is push. Postgres is polled from the scheduler.
+   */
+  readonly cacheBus?: CacheBusOptions;
   /**
    * Domain DDL policy for SQL handles. Default `ensure` (test-friendly).
    * Boot sets `off` for docker/prod and local+autoPush.
@@ -277,6 +287,13 @@ export interface StoreRuntime {
   ): string[];
   /** Close all open connections. */
   close(): Promise<void>;
+  /**
+   * Pull Postgres cache invalidations. No-op unless {@link CreateStoreRuntimeOptions.cacheBus}
+   * is `postgres`.
+   */
+  pollCacheInvalidations(): Promise<void>;
+  /** Which invalidation transport this runtime opened. */
+  readonly cacheInvalidation: "off" | "redis" | "postgres";
   /**
    * Capability-gated files handle for `fx.store` (CRUD + image pipeline).
    *
@@ -300,7 +317,26 @@ export interface StoreRuntime {
  */
 export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRuntime {
   const now = options.now ?? (() => Date.now());
-  const cache = createStoreCache(now);
+  let publishInvalidation: ((resources: readonly ResourceRef[]) => void) | undefined;
+  const cache = createStoreCache({
+    now,
+    fanout: (resources) => {
+      publishInvalidation?.(resources);
+    },
+    ...(options.cacheMaxEntries !== undefined ? { maxEntries: options.cacheMaxEntries } : {}),
+    ...(options.cacheDefaultTtlMs !== undefined ? { defaultTtlMs: options.cacheDefaultTtlMs } : {}),
+  });
+  const cacheInvalidation = options.cacheBus?.kind ?? "off";
+  let pollInvalidation: (() => Promise<void>) | undefined;
+  let stopInvalidation: (() => Promise<void>) | undefined;
+  if (options.cacheBus) {
+    const bus = openCacheInvalidation(cache, options.cacheBus);
+    publishInvalidation = (resources) => {
+      bus.publish(resources);
+    };
+    pollInvalidation = () => bus.poll();
+    stopInvalidation = () => bus.stop();
+  }
   const declarations = new Map<string, StoreDecl>();
   const sqlConns = new Map<string, SqlConnection>();
   const kvNs = new Map<string, KvNamespace>();
@@ -570,7 +606,8 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
     putTier1(effects, value, dimsByResource, ttlMs) {
       const keys = tier1KeysForReads(effects, dimsByResource);
       const resources = (effects.reads ?? []).filter((r): r is ResourceRef => r !== "runs");
-      const expiresAt = ttlMs !== undefined && ttlMs !== null && ttlMs > 0 ? now() + ttlMs : null;
+      const ttl = ttlMs !== undefined && ttlMs !== null && ttlMs > 0 ? ttlMs : cache.defaultTtlMs;
+      const expiresAt = now() + ttl;
       for (const key of keys) {
         cache.set({
           tier: 1,
@@ -582,7 +619,12 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
       }
       return keys;
     },
+    cacheInvalidation,
+    async pollCacheInvalidations() {
+      if (pollInvalidation) await pollInvalidation();
+    },
     async close() {
+      if (stopInvalidation) await stopInvalidation();
       for (const c of sqlConns.values()) await c.close();
       for (const n of kvNs.values()) await n.close();
       for (const b of fileBuckets.values()) await b.close();