@synnaxlabs/client 0.57.1 → 0.57.3

package/src/channel/client.ts

@@ -389,12 +389,14 @@ export class Client extends query.Retriever<
   private readonly cfg: ClientConfig;
   readonly writer: Writer;
   readonly store: query.Table<Key, Channel>;
+  private readonly byName: query.LookupIndex<Key, Channel>;
 
   constructor(cfg: ClientConfig) {
     const { writer, statuses, ranges, cache } = cfg;
     const statusStore = statuses.store;
     const aliasStore = ranges.aliases;
     const sugar = (payload: Payload): Channel => this.sugar(payload);
+    const byName = new query.LookupIndex<Key, Channel>((ch) => ch.name);
     const store = cache.createTable<Key, Channel>({
       name: "channels",
       equal: (a, b) => deep.equal(a.payload, b.payload),
@@ -406,6 +408,7 @@ export class Client extends query.Retriever<
         }),
         query.createDeleteListener(DELETE_CHANNEL_NAME, keyZ),
       ],
+      indexes: [byName],
     });
     const composed = cache.derive<Key, Channel, Channel>({
       name: "channel.composed",
@@ -461,6 +464,7 @@ export class Client extends query.Retriever<
     this.cfg = cfg;
     this.writer = writer;
     this.store = store;
+    this.byName = byName;
   }
 
   /**
@@ -640,7 +644,7 @@ export class Client extends query.Retriever<
     }
     const names = normalized;
     await this.writer.delete({ names });
-    const cached = this.store.get((ch) => names.includes(ch.name));
+    const cached = this.byName.get(names);
     if (cached.length > 0) this.store.delete(cached.map((ch) => ch.key));
   }
 
@@ -765,10 +769,11 @@ export class Client extends query.Retriever<
     const { key, rangeKey } = query;
     let ch = this.store.get(key);
     if (ch == null) {
-      const payloads = await this.execRetrieve([key]);
-      checkForMultipleOrNoResults("channel", key, payloads, true);
-      ch = this.sugar(stripComposed(payloads[0]));
-      this.store.set(key, ch);
+      // Through the table, so concurrent misses coalesce into one request. A plot
+      // panel resolves one channel per telemetry source, all in the same tick.
+      const fetched = await this.store.retrieve([key]);
+      checkForMultipleOrNoResults("channel", key, fetched, true);
+      [ch] = fetched;
     }
     // A cached calculated channel without a cached status is ambiguous: the
     // status may not exist, or may simply never have been fetched.
@@ -794,7 +799,7 @@ export class Client extends query.Retriever<
     const resolved: Channel[] = [];
     const missing: string[] = [];
     for (const name of new Set(names)) {
-      const matches = this.store.get((ch) => ch.name === name);
+      const matches = this.byName.get(name);
       if (matches.length > 1) return null;
       if (matches.length === 0) missing.push(name);
       else resolved.push(matches[0]);

package/src/device/client.ts

@@ -424,10 +424,11 @@ export class Client extends query.Retriever<
   }
 
   private async fetchSingle(q: SingleQuery): Promise<Device> {
-    // A status-bearing hit needs both the record and its status cached.
+    // Status-bearing queries bypass the table, which never holds status.
     if (q.includeStatus !== true) {
-      const cached = this.store.get(q.key);
-      if (cached != null) return cached;
+      const devices = await this.store.retrieve([q.key]);
+      checkForMultipleOrNoResults("Device", q, devices, true);
+      return devices[0];
     }
     const devices = await this.execRetrieve(q);
     checkForMultipleOrNoResults("Device", q, devices, true);

package/src/framer/streamer.ts

@@ -7,8 +7,13 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { EOF, type Stream, type WebSocketClient } from "@synnaxlabs/freighter";
-import { errors, Rate, zod } from "@synnaxlabs/x";
+import {
+  EOF,
+  type Stream,
+  Unreachable,
+  type WebSocketClient,
+} from "@synnaxlabs/freighter";
+import { errors, Rate, TimeSpan, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type channel } from "@/channel";
@@ -23,6 +28,7 @@ const reqZ = z.object({
   downsampleFactor: z.int(),
   throttleRate: Rate.z.optional(),
   excludeGroups: z.uint32().array().optional(),
+  keepAlive: TimeSpan.z.optional(),
 });
 
 /**
@@ -31,7 +37,11 @@ const reqZ = z.object({
  */
 export interface StreamerRequest extends z.infer<typeof reqZ> {}
 
-const resZ = z.object({ frame: frameZ });
+const resZ = z.object({
+  frame: frameZ,
+  /** Marks an empty response the Core emits so a dead connection is detectable. */
+  keepAlive: z.boolean().optional(),
+});
 
 /**
  * Response interface for streaming frames from a Synnax cluster.
@@ -49,6 +59,10 @@ const intermediateStreamerConfigZ = z.object({
   /** excludeGroups sets writer group IDs whose frames should be filtered out by the
    Core. Used for telemetry bypass deduplication. */
   excludeGroups: z.uint32().array().default([]),
+  /** Interval at which the Core emits keep-alive responses so a silently dead
+   connection fails reads instead of hanging forever. TimeSpan.ZERO disables
+   detection. Defaults to 5 seconds. */
+  keepAlive: TimeSpan.z.default(TimeSpan.seconds(5)),
 });
 
 /** Zod schema for {@link StreamerConfig}. A bare channel list parses as a config. */
@@ -73,7 +87,11 @@ export interface Streamer extends AsyncIterator<Frame>, AsyncIterable<Frame> {
   update: (channels: channel.Params) => Promise<void>;
   /** Close the streamer and free all associated resources. */
   close: () => void;
-  /** Read the next frame of telemetry. */
+  /**
+   * Read the next frame of telemetry.
+   * @throws {Unreachable} if keep-alives were flowing and the stream then stays silent
+   * past the keep-alive deadline: the connection is presumed dead.
+   */
   read: () => Promise<Frame>;
 }
 
@@ -101,14 +119,19 @@ export const createStreamOpener =
       cfg.downsampleFactor,
       cfg.throttleRate,
       cfg.excludeGroups,
+      cfg.keepAlive,
     );
     stream.send({
       keys: Array.from(adapter.keys),
       downsampleFactor: cfg.downsampleFactor,
       throttleRate: cfg.throttleRate,
       excludeGroups: cfg.excludeGroups,
+      keepAlive: cfg.keepAlive,
     });
-    await stream.receive();
+    // A keep-alive can beat the open ack onto the wire, so the ack is the first
+    // non-keep-alive response.
+    let res = await stream.receive();
+    while (res.keepAlive === true) res = await stream.receive();
     return streamer;
   };
 
@@ -124,12 +147,20 @@ export const openStreamer = async (
   config: StreamerConfig,
 ): Promise<Streamer> => await createStreamOpener(retrieveChannels, client)(config);
 
+// Missing this many keep-alive intervals in a row fails the pending read: one is normal
+// jitter, three is a dead connection.
+const KEEP_ALIVE_DEADLINE_FACTOR = 3;
+
 class BaseStreamer implements Streamer {
   private readonly stream: StreamProxy<typeof reqZ, typeof resZ>;
   private readonly adapter: ReadAdapter;
   private readonly downsampleFactor: number;
   private readonly throttleRate: Rate;
   private readonly excludeGroups: number[];
+  private readonly deadline: TimeSpan;
+  // Set once the Core proves keep-alive support by sending one, so the deadline never
+  // arms against a Core that will not send them.
+  private armed = false;
 
   constructor(
     stream: Stream<typeof reqZ, typeof resZ>,
@@ -137,12 +168,16 @@ class BaseStreamer implements Streamer {
     downsampleFactor: number = 1,
     throttleRate: Rate = new Rate(0),
     excludeGroups: number[] = [],
+    keepAlive: TimeSpan = TimeSpan.ZERO,
   ) {
     this.stream = new StreamProxy("Streamer", stream);
     this.adapter = adapter;
     this.downsampleFactor = downsampleFactor;
     this.throttleRate = throttleRate;
     this.excludeGroups = excludeGroups;
+    this.deadline = TimeSpan.milliseconds(
+      keepAlive.milliseconds * KEEP_ALIVE_DEADLINE_FACTOR,
+    );
   }
 
   get keys(): channel.Key[] {
@@ -160,7 +195,37 @@ class BaseStreamer implements Streamer {
   }
 
   async read(): Promise<Frame> {
-    return this.adapter.adapt(new Frame((await this.stream.receive()).frame));
+    while (true) {
+      const res = await this.receiveWithDeadline();
+      if (res.keepAlive === true) {
+        if (!this.deadline.isZero) this.armed = true;
+        continue;
+      }
+      return this.adapter.adapt(new Frame(res.frame));
+    }
+  }
+
+  private async receiveWithDeadline(): Promise<z.infer<typeof resZ>> {
+    const received = this.stream.receive();
+    if (!this.armed) return await received;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const deadline = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => {
+        const silence = this.deadline.toString();
+        const message = `streamer received no response for ${silence}`;
+        reject(new Unreachable({ message }));
+      }, this.deadline.milliseconds);
+    });
+    try {
+      return await Promise.race([received, deadline]);
+    } catch (err) {
+      // The read already failed for its caller; a late settle of the losing receive
+      // must not surface as an unhandled rejection.
+      received.catch(() => {});
+      throw errors.fromUnknown(err);
+    } finally {
+      clearTimeout(timer);
+    }
   }
 
   async update(channels: channel.Params): Promise<void> {

package/src/label/store.ts

@@ -21,8 +21,13 @@ export const matchLabeledBy = (rel: ontology.Relationship, id: ontology.ID): boo
 
 /** Returns the cached labels attached to the given ontology ID. */
 export const cachedLabelsOf = (
-  relationships: query.Table<string, ontology.Relationship>,
+  cache: ontology.Cache,
   labels: query.Table<Key, Label>,
   id: ontology.ID,
 ): Label[] =>
-  labels.get(relationships.get((r) => matchLabeledBy(r, id)).map((r) => r.to.key));
+  labels.get(
+    cache
+      .relationshipsFrom(id)
+      .filter((r) => r.type === LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE)
+      .map((r) => r.to.key),
+  );

package/src/ontology/client.ts

@@ -35,6 +35,7 @@ import {
   Cache,
   RELATIONSHIP_DELETE_CHANNEL_NAME,
   RELATIONSHIP_SET_CHANNEL_NAME,
+  type RelationshipIndexes,
   RESOURCE_DELETE_CHANNEL_NAME,
   RESOURCE_SET_CHANNEL_NAME,
 } from "@/ontology/store";
@@ -194,10 +195,15 @@ export class Client extends query.Retriever<
 
   constructor(cfg: ClientConfig) {
     const { unary, cache } = cfg;
+    const relationshipIndexes: RelationshipIndexes = {
+      byTo: new query.LookupIndex<string, Relationship>((r) => idToString(r.to)),
+      byFrom: new query.LookupIndex<string, Relationship>((r) => idToString(r.from)),
+    };
     const relationships = cache.createTable<string, Relationship>({
       name: "relationships",
       equal: (a, b) =>
         idsEqual(a.from, b.from) && idsEqual(a.to, b.to) && a.type === b.type,
+      indexes: [relationshipIndexes.byTo, relationshipIndexes.byFrom],
       listen: [
         query.createSetListener(RELATIONSHIP_SET_CHANNEL_NAME, relationshipZ, {
           key: (changed) => relationshipToString(changed),
@@ -244,7 +250,7 @@ export class Client extends query.Retriever<
     });
     this.cfg = cfg;
     this.writer = new Writer(unary);
-    this.cache = new Cache(relationships, resources);
+    this.cache = new Cache(relationships, resources, relationshipIndexes);
     this.children = this.dependentSurface(cache, "children", "to");
     this.parents = this.dependentSurface(cache, "parents", "from");
   }
@@ -466,13 +472,14 @@ export class Client extends query.Retriever<
   ): boolean {
     if (q.types != null && !q.types.includes(resource.id.type)) return false;
     const anchor = oppositeRelationshipDirection(direction);
-    return (
-      this.cache.relationships.get(
-        (rel) =>
-          rel.type === PARENT_OF_RELATIONSHIP_TYPE &&
-          q.ids.includes(idToString(rel[anchor])) &&
-          idsEqual(rel[direction], resource.id),
-      ).length > 0
+    const rels =
+      direction === "to"
+        ? this.cache.relationshipsTo(resource.id)
+        : this.cache.relationshipsFrom(resource.id);
+    return rels.some(
+      (rel) =>
+        rel.type === PARENT_OF_RELATIONSHIP_TYPE &&
+        q.ids.includes(idToString(rel[anchor])),
     );
   }
 

package/src/ontology/store.ts

@@ -13,7 +13,6 @@ import {
   type ID,
   idsEqual,
   idToString,
-  matchRelationship,
   PARENT_OF_RELATIONSHIP_TYPE,
   type Relationship,
   type Resource,
@@ -26,26 +25,49 @@ export const RESOURCE_DELETE_CHANNEL_NAME = "sy_ontology_resource_delete";
 export const RELATIONSHIP_SET_CHANNEL_NAME = "sy_ontology_relationship_set";
 export const RELATIONSHIP_DELETE_CHANNEL_NAME = "sy_ontology_relationship_delete";
 
+/**
+ * The secondary indexes registered on the relationships table, one per endpoint.
+ * Type filtering runs at the call site over the matched handful.
+ */
+export interface RelationshipIndexes {
+  /** Keyed by the stringified `to` end. */
+  byTo: query.LookupIndex<string, Relationship>;
+  /** Keyed by the stringified `from` end. */
+  byFrom: query.LookupIndex<string, Relationship>;
+}
+
 /** The ontology record tables: resources and the relationships between them. */
 export class Cache {
   readonly relationships: query.Table<string, Relationship>;
   readonly resources: query.Table<string, Resource>;
+  private readonly indexes: RelationshipIndexes;
 
   constructor(
     relationships: query.Table<string, Relationship>,
     resources: query.Table<string, Resource>,
+    indexes: RelationshipIndexes,
   ) {
     this.relationships = relationships;
     this.resources = resources;
+    this.indexes = indexes;
+  }
+
+  /** Returns the cached relationships pointing at the given ID. */
+  relationshipsTo(id: ID): Relationship[] {
+    return this.indexes.byTo.get(idToString(id));
+  }
+
+  /** Returns the cached relationships originating at the given ID. */
+  relationshipsFrom(id: ID): Relationship[] {
+    return this.indexes.byFrom.get(idToString(id));
   }
 
   /** Returns the cached parent ID of the given ontology ID, or null if unknown. */
   parentID(id: ID): ID | null {
-    const res = this.relationships.get((r) =>
-      matchRelationship(r, { type: PARENT_OF_RELATIONSHIP_TYPE, to: id }),
+    const rel = this.relationshipsTo(id).find(
+      (r) => r.type === PARENT_OF_RELATIONSHIP_TYPE,
     );
-    if (res.length === 0) return null;
-    return res[0].from;
+    return rel?.from ?? null;
   }
 
   /**

package/src/query/external.ts

@@ -15,6 +15,7 @@ export {
 } from "@/query/cache";
 export { Deleted } from "@/query/deleted";
 export { type DeriveWatch, deriveWatch } from "@/query/derived";
+export { LookupIndex } from "@/query/indexes";
 export {
   type Cached,
   type ChangeHandler,

package/src/query/indexes.ts

@@ -0,0 +1,94 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { type record, type state } from "@synnaxlabs/x";
+
+/**
+ * An exact-match secondary index over a table's live entries. `extract` reads one
+ * index value from each entry; a null leaves the entry out of the index. Register
+ * the index on its owning table's `indexes` param; the table keeps it current
+ * across every mutation, rollbacks and resets included. Tombstones are never
+ * indexed.
+ */
+export class LookupIndex<
+  Key extends record.Key = record.Key,
+  Value extends state.State = state.State,
+  IndexValue extends record.Key = record.Key,
+> {
+  private readonly extract: (value: Value) => IndexValue | null;
+  private readonly buckets = new Map<IndexValue, Map<Key, Value>>();
+  private readonly indexed = new Map<Key, IndexValue>();
+
+  constructor(extract: (value: Value) => IndexValue | null) {
+    this.extract = extract;
+  }
+
+  /** Returns the entries whose extracted index value equals the given value. */
+  get(value: IndexValue): Value[];
+  /**
+   * Returns the entries matching any of the given values, in the order of the
+   * values and each entry once.
+   */
+  get(values: IndexValue[]): Value[];
+  get(value: IndexValue | IndexValue[]): Value[] {
+    if (Array.isArray(value))
+      return Array.from(new Set(value)).flatMap((v) => this.get(v));
+    const bucket = this.buckets.get(value);
+    if (bucket == null) return [];
+    return Array.from(bucket.values());
+  }
+
+  /**
+   * Records the entry, relocating it when its extracted value changed.
+   * Cache-internal surface: called by the owning table, not domain code.
+   */
+  set(key: Key, value: Value): void {
+    const next = this.extract(value);
+    const prev = this.indexed.get(key);
+    if (prev !== undefined && prev !== next) this.unbucket(prev, key);
+    if (next == null) {
+      this.indexed.delete(key);
+      return;
+    }
+    let bucket = this.buckets.get(next);
+    if (bucket == null) {
+      bucket = new Map();
+      this.buckets.set(next, bucket);
+    }
+    bucket.set(key, value);
+    this.indexed.set(key, next);
+  }
+
+  /**
+   * Removes any mapping for the given entry key.
+   * Cache-internal surface: called by the owning table, not domain code.
+   */
+  delete(key: Key): void {
+    const prev = this.indexed.get(key);
+    if (prev === undefined) return;
+    this.unbucket(prev, key);
+    this.indexed.delete(key);
+  }
+
+  /**
+   * Discards every mapping.
+   * Cache-internal surface: called by the owning table, not domain code.
+   */
+  reset(): void {
+    this.buckets.clear();
+    this.indexed.clear();
+  }
+
+  private unbucket(value: IndexValue, key: Key): void {
+    const bucket = this.buckets.get(value);
+    if (bucket == null) return;
+    bucket.delete(key);
+    if (bucket.size === 0) this.buckets.delete(value);
+  }
+}

package/src/query/table.ts

@@ -23,6 +23,7 @@ import type z from "zod";
 
 import { NotFoundError } from "@/errors";
 import { Deleted } from "@/query/deleted";
+import { type LookupIndex } from "@/query/indexes";
 import { type Listener } from "@/query/streamer";
 
 /**
@@ -98,6 +99,11 @@ export interface TableParams<
    * @default TimeSpan.milliseconds(10)
    */
   fetchDebounce?: CrudeTimeSpan;
+  /**
+   * Secondary indexes over the table's live entries. The table keeps each current
+   * across every mutation, rollbacks and resets included.
+   */
+  indexes?: Array<LookupIndex<Key, Value>>;
 }
 
 /**
@@ -156,6 +162,7 @@ export class Table<
     Key[],
     Array<Keyed<Key, Value>>
   > | null;
+  private readonly indexes: Array<LookupIndex<Key, Value>>;
   private gen = 0;
 
   constructor({
@@ -164,11 +171,13 @@ export class Table<
     fetch,
     hydrate = "set",
     fetchDebounce = DEFAULT_FETCH_DEBOUNCE,
+    indexes = [],
   }: TableParams<Key, Value>) {
     this.onError = onError;
     this.equal = equal;
     this.fetchEntries = fetch;
     this.hydrateMode = hydrate;
+    this.indexes = [...indexes];
     this.fetchBatcher =
       fetch == null
         ? null
@@ -177,7 +186,27 @@ export class Table<
             exec: async (requests) => {
               const keys = new Set<Key>();
               requests.forEach(({ req }) => req.forEach((key) => keys.add(key)));
-              const fetched = await fetch(Array.from(keys));
+              let fetched: Array<Keyed<Key, Value>>;
+              try {
+                fetched = await fetch(Array.from(keys));
+              } catch (exc) {
+                if (!NotFoundError.matches(exc) || requests.length === 1)
+                  throw errors.fromUnknown(exc);
+                // A strict fetch rejects the whole batch when any caller's key
+                // has vanished. Refetch per caller so each settles exactly as
+                // its own request would have, keeping the batch transparent.
+                await Promise.all(
+                  requests.map(async ({ req, resolve, reject }) => {
+                    try {
+                      const mine = new Set(req);
+                      resolve((await fetch(req)).filter(({ key }) => mine.has(key)));
+                    } catch (exc) {
+                      reject(exc);
+                    }
+                  }),
+                );
+                return;
+              }
               // The window's fetch carries other callers' keys too; each caller
               // hydrates only the entries it asked for.
               requests.forEach(({ req, resolve }) => {
@@ -188,6 +217,27 @@ export class Table<
           });
   }
 
+  private applySet(key: Key, value: Value): void {
+    this.entries.set(key, value);
+    for (const index of this.indexes) index.set(key, value);
+  }
+
+  private applyDelete(key: Key): void {
+    this.entries.delete(key);
+    for (const index of this.indexes) index.delete(key);
+  }
+
+  /**
+   * Registers a secondary index and backfills it from the live entries, for a
+   * domain that owns an index's meaning but not the table it reads.
+   * @returns the index.
+   */
+  index<I extends LookupIndex<Key, Value>>(index: I): I {
+    this.entries.forEach((value, key) => index.set(key, value));
+    this.indexes.push(index);
+    return index;
+  }
+
   private setOne(
     key: Key,
     value: state.SetArg<Value | undefined>,
@@ -197,16 +247,16 @@ export class Table<
     if (next == null || (prev != null && this.equal(next, prev, key))) return undefined;
     const prevTombstone = this.tombstones.get(key);
     this.tombstones.delete(key);
-    this.entries.set(key, next);
+    this.applySet(key, next);
     this.notify({ variant: "set", key, value: next });
 
     return () => {
       if (prev === undefined) {
-        this.entries.delete(key);
+        this.applyDelete(key);
         if (prevTombstone != null) this.tombstones.set(key, prevTombstone);
         this.notify({ variant: "delete", key });
       } else {
-        this.entries.set(key, prev);
+        this.applySet(key, prev);
         this.notify({ variant: "set", key, value: prev });
       }
     };
@@ -308,9 +358,10 @@ export class Table<
   /**
    * Resolves the given keys to records: serves cached entries and fetches the misses
    * through the table's fetch, hydrating results under the declared mode. With refresh,
-   * every key is fetched regardless of presence. Returns the table's entries for the
-   * found keys in input order, deduplicated; keys the cluster no longer has are
-   * omitted. Tables without a fetch serve cached entries only.
+   * every key is fetched regardless of presence and cached entries the fetch omits are
+   * tombstoned. Returns the table's entries for the found keys in input order,
+   * deduplicated; keys the cluster no longer has are omitted. Tables without a fetch
+   * serve cached entries only.
    */
   async retrieve(keys: Key[], opts: { refresh?: boolean } = {}): Promise<Value[]> {
     if (this.fetchBatcher != null) {
@@ -319,9 +370,19 @@ export class Table<
       if (misses.length > 0) {
         const gen = this.gen;
         const fetched = await this.fetchBatcher.enqueue(misses);
-        if (gen === this.gen && fetched.length > 0)
-          if (opts.refresh === true) this.set(fetched);
-          else this.ingest(fetched);
+        if (gen === this.gen)
+          if (opts.refresh === true) {
+            // A refresh is authoritative for its keys: cached entries the
+            // fetch omitted vanished from the cluster and are tombstoned.
+            const present = new Set<Key>(fetched.map(({ key }) => key));
+            const vanished = misses.filter(
+              (key) => !present.has(key) && this.entries.has(key),
+            );
+            this.batch(() => {
+              if (vanished.length > 0) this.delete(vanished);
+              if (fetched.length > 0) this.set(fetched);
+            });
+          } else if (fetched.length > 0) this.ingest(fetched);
       }
     }
     const seen = new Set<Key>();
@@ -375,7 +436,7 @@ export class Table<
 
     this.batch(() =>
       toDelete.forEach(({ key: k, value }) => {
-        this.entries.delete(k);
+        this.applyDelete(k);
         if (tombstone && value != null)
           this.tombstones.set(k, new Deleted(value, TimeStamp.now()));
         this.notify({ variant: "delete", key: k });
@@ -387,7 +448,7 @@ export class Table<
         toDelete.forEach(({ key: k, value }) => {
           if (value == null) return;
           this.tombstones.delete(k);
-          this.entries.set(k, value);
+          this.applySet(k, value);
           this.notify({ variant: "set", key: k, value });
         }),
       );
@@ -426,6 +487,7 @@ export class Table<
     this.gen++;
     this.entries.clear();
     this.tombstones.clear();
+    for (const index of this.indexes) index.reset();
   }
 
   /**

package/src/rack/client.ts

@@ -307,11 +307,12 @@ export class Client extends query.Retriever<
   }
 
   private async fetchSingle(q: SingleQuery): Promise<Rack> {
-    // Names are not unique, so only key queries can be served from the table.
-    // A status-bearing hit needs both the record and its status cached.
+    // Names are not unique and the table never holds status, so only keyed status-free
+    // queries can be served from it.
     if ("key" in q && q.includeStatus !== true) {
-      const cached = this.store.get(q.key);
-      if (cached != null) return this.sugar(cached);
+      const racks = await this.store.retrieve([q.key]);
+      checkForMultipleOrNoResults("Rack", q, racks, true);
+      return this.sugar(racks[0]);
     }
     const racks = await this.execRetrieve(q);
     checkForMultipleOrNoResults("Rack", q, racks, true);