@synnaxlabs/client 0.56.2 → 0.57.1

package/src/project/client.ts

@@ -0,0 +1,273 @@
+// 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 FileTransport,
+  type UnaryClient,
+  type UploadBody,
+} from "@synnaxlabs/freighter";
+import {
+  array,
+  caseconv,
+  type destructor,
+  primitive,
+  record,
+  zod,
+} from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { imex } from "@/imex";
+import { type ontology } from "@/ontology";
+import {
+  type Key,
+  keyZ,
+  type New,
+  ontologyID,
+  type Project,
+  projectZ,
+} from "@/project/types.gen";
+import { query } from "@/query";
+
+export const SET_CHANNEL_NAME = "sy_project_set";
+export const DELETE_CHANNEL_NAME = "sy_project_delete";
+
+const retrieveReqZ = z.object({
+  keys: keyZ.array().optional(),
+  searchTerm: z.string().optional(),
+  offset: z.int().optional(),
+  limit: z.int().optional(),
+  ignoreNotFoundError: z.boolean().optional(),
+});
+const retrieveMultiParamsZ = retrieveReqZ.or(query.keyListZ(keyZ));
+export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
+const createReqZ = z.object({ projects: projectZ.array() });
+const renameReqZ = z.object({ key: keyZ, name: z.string() });
+const setLayoutReqZ = z.object({
+  key: keyZ,
+  layout: caseconv.preserveCase(record.unknownZ()),
+});
+const deleteReqZ = z.object({ keys: keyZ.array() });
+const exportReqZ = z.object({ key: keyZ, encoding: imex.encodingZ });
+
+const importParamsZ = z.object({ fileName: z.string().min(1) });
+
+const retrieveResZ = z.object({ projects: projectZ.array().default(() => []) });
+const createResZ = z.object({ projects: projectZ.array() });
+const importResZ = z.object({ project: projectZ });
+const emptyResZ = z.object({});
+
+/** Options for a project import call. */
+export interface ImportOptions {
+  /**
+   * The name of the uploaded archive or picked directory. Its extension-stripped form
+   * names the project when the bundle carries no name.
+   */
+  fileName: string;
+}
+
+export interface SetLayoutParams extends z.input<typeof setLayoutReqZ> {}
+
+/**
+ * Client-side matching for a request: key sets. Server-computed shapes
+ * (search, limit/offset) never reach this filter; they refetch instead.
+ */
+const requestFilter = (req: RetrieveRequest): ((p: Project) => boolean) => {
+  const keySet = primitive.isNonZero(req.keys) ? new Set(req.keys) : undefined;
+  return (p) => keySet == null || keySet.has(p.key);
+};
+
+export interface ClientConfig {
+  unary: UnaryClient;
+  file: FileTransport;
+  cache: query.Cache;
+  ontology: ontology.Client;
+}
+
+export class Client extends query.Retriever<typeof retrieveMultiParamsZ, Key, Project> {
+  private readonly cfg: ClientConfig;
+  private readonly store: query.Table<Key, Project>;
+
+  constructor(cfg: ClientConfig) {
+    const { cache } = cfg;
+    const store = cache.createTable<Key, Project>({
+      name: "projects",
+      fetch: async (keys) => await this.execRetrieve({ keys }),
+      listen: [
+        query.createSetListener(SET_CHANNEL_NAME, projectZ),
+        query.createDeleteListener(DELETE_CHANNEL_NAME, keyZ),
+      ],
+    });
+    super(cache, {
+      name: "project",
+      table: store,
+      request: {
+        schema: retrieveMultiParamsZ,
+        fetch: async (req) => await this.execRetrieve(req),
+        matches: (project, req) => requestFilter(req)(project),
+      },
+    });
+    this.cfg = cfg;
+    this.store = store;
+  }
+
+  async create(project: New, opts?: query.WriteOptions<Project[]>): Promise<Project>;
+  async create(
+    projects: New[],
+    opts?: query.WriteOptions<Project[]>,
+  ): Promise<Project[]>;
+  async create(
+    projects: New | New[],
+    opts: query.WriteOptions<Project[]> = {},
+  ): Promise<Project | Project[]> {
+    const isMany = Array.isArray(projects);
+    const optimistic = array
+      .toArray(projects)
+      .map((p) => zod.parse(projectZ, p, { label: "project" }));
+    const res = await query.optimistic({
+      rollbacks: [this.store.set(optimistic)],
+      onOptimistic: () => opts.onOptimistic?.(optimistic),
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/project/create",
+          { projects: optimistic },
+          createReqZ,
+          createResZ,
+        ),
+    });
+    this.store.set(res.projects);
+    return isMany ? res.projects : res.projects[0];
+  }
+
+  async rename(key: Key, name: string, opts: query.WriteOptions = {}): Promise<void> {
+    const rename = () => [
+      query.partialUpdate(this.store, key, { name }),
+      this.cfg.ontology.cache.renameResource(ontologyID(key), name),
+    ];
+    await query.optimistic({
+      rollbacks: rename(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/project/rename",
+          { key, name },
+          renameReqZ,
+          emptyResZ,
+        ),
+    });
+    rename();
+  }
+
+  async setLayout(
+    key: Key,
+    layout: record.Unknown,
+    opts: query.WriteOptions = {},
+  ): Promise<void> {
+    await query.optimistic({
+      rollbacks: [query.partialUpdate(this.store, key, { layout })],
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/project/set-layout",
+          { key, layout },
+          setLayoutReqZ,
+          emptyResZ,
+        ),
+    });
+    this.mergeThrough(key, { layout });
+  }
+
+  async delete(key: Key, opts?: query.WriteOptions): Promise<void>;
+  async delete(keys: Key[], opts?: query.WriteOptions): Promise<void>;
+  async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
+    const keysArr = array.toArray(keys);
+    const drop = () => [
+      this.cfg.ontology.cache.deleteResources(ontologyID(keysArr)),
+      this.store.delete(keysArr),
+    ];
+    await query.optimistic({
+      rollbacks: drop(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/project/delete",
+          { keys: keysArr },
+          deleteReqZ,
+          emptyResZ,
+        ),
+    });
+    drop();
+  }
+
+  /**
+   * Exports the project and its contents as a bundle: a zip archive holding one JSON
+   * file per document and panel, group children as directories, and a manifest.json
+   * naming the project. Two members of one directory that take the same file name keep
+   * distinct names through a numeric suffix. The caller pipes the stream wherever it
+   * likes without the client buffering the whole archive.
+   * @param options - the export options, including the serialization member files are
+   * written in.
+   * @returns the bundle as a stream of zip bytes.
+   */
+  async export(key: Key, options: imex.Options): Promise<ReadableStream<Uint8Array>> {
+    return await this.cfg.file.download(
+      "/project/export",
+      { key, encoding: options.encoding },
+      exportReqZ,
+      { encoding: "ZIP" },
+    );
+  }
+
+  /**
+   * Imports a project bundle: a zip archive holding one JSON envelope per document and
+   * panel, group children as directories, and a manifest.json naming the project. The
+   * Core creates a fresh project and imports every member in a single transaction, so a
+   * failure leaves nothing behind. Legacy project directories (a root LAYOUT.json with
+   * no manifest) import through the same call.
+   *
+   * @param data - the bundle as zip bytes.
+   * @param options - the import options, including the source file's name.
+   * @returns the created project.
+   * @throws {ValidationError} if the manifest is missing, malformed, or of another
+   * bundle kind, if two member names collide, or if a member cannot be imported.
+   */
+  async import(data: UploadBody, options: ImportOptions): Promise<Project> {
+    const res = await this.cfg.file.upload(
+      "/project/import",
+      data,
+      { encoding: "ZIP", params: options, paramsSchema: importParamsZ },
+      importResZ,
+    );
+    this.store.set(res.project);
+    return res.project;
+  }
+
+  /** Subscribes to every project delete delivered to the cache. */
+  onDelete(handler: (key: Key) => void): destructor.Destructor {
+    return this.store.subscribe((event) => {
+      if (event.variant === "delete") handler(event.key);
+    });
+  }
+
+  // Undefined fields are dropped: the server keeps prior values for them.
+  private mergeThrough(key: Key, changes: Partial<Project>): void {
+    const prev = this.store.get(key);
+    if (prev != null)
+      this.store.set(key, { ...prev, ...record.purgeUndefined(changes) });
+  }
+
+  private async execRetrieve(req: RetrieveRequest): Promise<Project[]> {
+    const res = await this.cfg.unary.send(
+      "/project/retrieve",
+      req,
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return res.projects;
+  }
+}

package/src/project/external.ts

@@ -0,0 +1,11 @@
+// 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.
+
+export * from "@/project/client";
+export * from "@/project/types.gen";

package/src/project/index.ts

@@ -0,0 +1,10 @@
+// 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.
+
+export * as project from "@/project/external";

package/src/project/types.gen.ts

@@ -0,0 +1,40 @@
+// 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.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { caseconv, record, uuid } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+export const keyZ = z.uuid();
+export type Key = z.infer<typeof keyZ>;
+
+/**
+ * Project is a named, persistable container that stores the layout and organization of
+ * the Console application. Projects allow users to save and restore custom arrangements
+ * of visualizations, tabs, and window configurations.
+ */
+export const projectZ = z.object({
+  /** key is the unique identifier for this project. */
+  key: keyZ.default(uuid.create),
+  /** name is a human-readable name for the project. */
+  name: z.string().min(1, "name is required"),
+  /**
+   * layout is the mosaic tree structure that defines how visualizations are arranged.
+   * Contains tab layout, split configurations, and window positions.
+   */
+  layout: caseconv.preserveCase(record.unknownZ().default(() => ({}))),
+});
+export interface Project extends z.infer<typeof projectZ> {}
+export interface New extends z.input<typeof projectZ> {}
+
+export const ontologyID = ontology.createIDFactory<Key>("project");
+export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/query/cache.ts

@@ -0,0 +1,326 @@
+// 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 breaker,
+  type destructor,
+  errors,
+  observe,
+  type record,
+  type state,
+} from "@synnaxlabs/x";
+import type z from "zod";
+
+import { AccessDeniedError, isConnectionError } from "@/errors";
+import { type framer } from "@/framer";
+import { bindDerived, type DeriveParams } from "@/query/derived";
+import { type Retrieves, Space, type SpaceConfig } from "@/query/query";
+import { createStreamer, type Listener, type Streamer } from "@/query/streamer";
+import { type Keyed, type ListenerSpec, Table, type TableParams } from "@/query/table";
+import { type Data, type Params } from "@/query/types";
+
+export interface CacheParams {
+  /**
+   * Opens the raw frame streamer used to receive change signals; reconnect hardening is
+   * applied internally. Null constructs a detached cache: purely local tables and no
+   * change stream. Used for clients constructed with `cache: false`.
+   */
+  openStreamer: framer.StreamOpener | null;
+  /** Retry behavior for change-stream reconnect attempts. */
+  breaker?: breaker.Config;
+  /** Called whenever the change stream goes live, before reconciliation begins. */
+  onStreamLive?: () => void;
+  /** Called when the change stream fails and reconnection begins. */
+  onStreamDrop?: (error: Error) => void;
+  /**
+   * Called when the change stream is refused because the caller lacks access to
+   * the mirrored channels. Only a policy change lifts a denial.
+   */
+  onStreamDenied?: (error: Error) => void;
+  /**
+   * Receives errors that have no caller to throw to: listener fan-out, streamer frame
+   * handling, and background reconciliation. Defaults to console logging.
+   */
+  onError?: (error: Error) => void;
+}
+
+/** Configuration for a derived table owned by a {@link Cache}. */
+export interface DerivedConfig<
+  Key extends record.Key,
+  Value extends Keyed<Key>,
+  Composed extends Keyed<Key>,
+> extends DeriveParams<Key, Value, Composed> {
+  /** Names the table in diagnostics. */
+  name: string;
+  /** Overrides the deep-equality default used to silence redundant sets. */
+  equal?: (a: Composed, b: Composed, key: Key) => boolean;
+}
+
+/** Configuration for a table owned by a {@link Cache}. */
+export interface TableConfig<
+  Key extends record.Key = record.Key,
+  Value extends state.State = state.State,
+> extends Omit<TableParams<Key, Value>, "onError"> {
+  /** Names the table in diagnostics (reconciliation errors). */
+  name: string;
+  /** Mirror listeners keeping this table current from stream channels. */
+  listen?: Array<ListenerSpec<Key, Value>>;
+}
+
+interface RegisteredTable {
+  name: string;
+  listeners: Listener[];
+  reconcile?: () => Promise<void>;
+  reset: () => void;
+}
+
+/** The cache-facing lifecycle of an answer space, generics erased. */
+interface SpaceLifecycle {
+  close: () => void;
+  reset: () => void;
+}
+
+/**
+ * The client's local mirror of cluster state: keyed tables, the change-stream loop,
+ * connection epochs, and reconciliation. Holds zero domain knowledge — domain clients
+ * create their tables here and expose typed query spaces. Always present on a client; a
+ * null {@link CacheParams.openStreamer} stands in for "disabled" or "not yet connected"
+ * rather than a null cache. The change stream opens lazily: nothing touches the network
+ * until the first {@link ensureStreaming} call. All tables and listeners must be
+ * declared before streaming starts.
+ */
+export class Cache {
+  private readonly tables: RegisteredTable[] = [];
+  private readonly reactions: Listener[] = [];
+  private readonly spaces: SpaceLifecycle[] = [];
+  private readonly detachers: destructor.Destructor[] = [];
+  private readonly epochObserver = new observe.Observer<number>();
+  private readonly params: CacheParams;
+  private streamer: Streamer | null = null;
+  private epochCount = 0;
+  private unmaintained = false;
+
+  /**
+   * Stable error sink for machinery built on this cache (dispatch
+   * controllers, answer spaces).
+   */
+  readonly onError: (error: Error) => void;
+
+  constructor(params: CacheParams) {
+    this.params = params;
+    this.onError = params.onError ?? console.error;
+  }
+
+  /**
+   * Creates a table owned by this cache and returns it, binding its declared mirror
+   * listeners. Must be called before streaming starts; creating after {@link
+   * ensureStreaming} throws, as the new table's channels would never be streamed.
+   */
+  createTable<Key extends record.Key, Value extends state.State>(
+    config: TableConfig<Key, Value>,
+  ): Table<Key, Value> {
+    if (this.streamer != null)
+      throw new Error(`cannot create table ${config.name} after streaming has started`);
+    const { name, listen, ...params } = config;
+    const table = new Table<Key, Value>({ ...params, onError: this.onError });
+    this.tables.push({
+      name,
+      listeners: (listen ?? []).map((spec) => spec.bind(table)),
+      reconcile: config.fetch == null ? undefined : async () => await table.reconcile(),
+      reset: () => table.reset(),
+    });
+    return table;
+  }
+
+  /**
+   * Creates a table materialized from another table owned by this cache. Composed
+   * entries are replaced on source and watch events, so entry identity changes exactly
+   * when composition changes; misses on read fetch through the source. Resets with the
+   * cache. No stream listeners of its own, so it may be created at any time.
+   */
+  derive<Key extends record.Key, Value extends Keyed<Key>, Composed extends Keyed<Key>>(
+    config: DerivedConfig<Key, Value, Composed>,
+  ): Table<Key, Composed> {
+    const { name, source, compose, watch, equal } = config;
+    const table = new Table<Key, Composed>({
+      onError: this.onError,
+      equal,
+      fetch: async (keys) => (await source.retrieve(keys)).map(compose),
+    });
+    this.detachers.push(bindDerived(table, { source, compose, watch }));
+    this.tables.push({ name, listeners: [], reset: () => table.reset() });
+    return table;
+  }
+
+  /**
+   * Registers a channel reaction: a listener that is not a table mirror
+   * (dispatch wires, cross-table side effects). Same pre-streaming
+   * constraint as {@link createTable}.
+   */
+  listen<Z extends z.ZodType>(listener: Listener<Z>): void {
+    if (this.streamer != null)
+      throw new Error(
+        `cannot listen to ${listener.channel} after streaming has started`,
+      );
+    this.reactions.push(listener);
+  }
+
+  /**
+   * Constructs an answer space wired to this cache: reads open the change
+   * stream, maintained answers refetch on epoch bumps, maintenance errors
+   * report to the cache's error sink, and the space closes with the cache.
+   */
+  queries<
+    Q extends Params,
+    D extends Data,
+    K extends record.Key = record.Key,
+    V extends state.State = state.State,
+  >(config: SpaceConfig<Q, D, K, V>): Retrieves<Q, D> {
+    const space = new Space(config, {
+      ensureStreaming: async () => await this.ensureStreaming(),
+      onEpoch: (callback) => this.onEpoch(callback),
+      maintained: () => !this.unmaintained && this.params.openStreamer != null,
+      onError: this.onError,
+    });
+    this.spaces.push(space);
+    return space;
+  }
+
+  /**
+   * Ensures the change stream is open, opening it on first call. Callers that
+   * populate or read tables await this first so no change is missed between a
+   * fetch and the stream opening.
+   * @throws {AccessDeniedError} if the caller cannot stream the mirrored
+   * channels. Answers stop being maintained until a later call succeeds.
+   */
+  async ensureStreaming(): Promise<void> {
+    const { openStreamer, breaker, onStreamLive, onStreamDrop, onStreamDenied } =
+      this.params;
+    if (openStreamer == null) return;
+    if (this.streamer == null) {
+      // A reset can retire the streamer while its open is in flight; a
+      // retired streamer's lifecycle callbacks must not touch the epoch.
+      const streamer = createStreamer({
+        openStreamer,
+        breaker,
+        listeners: [
+          ...this.tables.flatMap(({ listeners }) => listeners),
+          ...this.reactions,
+        ],
+        onError: this.onError,
+        onLive: onStreamLive,
+        onDrop: onStreamDrop,
+        onOpen: () => {
+          if (this.streamer !== streamer) return;
+          this.unmaintained = false;
+          this.epochCount = 1;
+          this.epochObserver.notify(this.epochCount);
+        },
+        onReopen: () => {
+          if (this.streamer !== streamer) return;
+          this.bumpEpoch();
+        },
+        onDead: (error) => {
+          if (this.streamer !== streamer) return;
+          this.unmaintained = true;
+          if (AccessDeniedError.matches(error)) onStreamDenied?.(error);
+        },
+      });
+      this.streamer = streamer;
+    }
+    try {
+      await this.streamer.demand();
+    } catch (exc) {
+      this.unmaintained = true;
+      const error = errors.fromUnknown(exc);
+      // The first open never reaches onDead: the stream dies before there is
+      // one to observe.
+      if (AccessDeniedError.matches(error)) onStreamDenied?.(error);
+      throw error;
+    }
+  }
+
+  /**
+   * The connection epoch: 0 before streaming starts, 1 once live, incremented
+   * on every reconnect. Changes may have been missed between epochs.
+   */
+  get epoch(): number {
+    return this.epochCount;
+  }
+
+  /** Subscribes to epoch changes. Returns a destructor that unsubscribes. */
+  onEpoch(callback: (epoch: number) => void): destructor.Destructor {
+    return this.epochObserver.onChange(callback);
+  }
+
+  /**
+   * Re-checks every cached entry against the cluster: refreshes entries that
+   * still exist and tombstones entries that vanished. Runs after every
+   * reconnect for tables that declare a fetch.
+   */
+  private async reconcile(): Promise<void> {
+    await Promise.all(
+      this.tables.map(async ({ name, reconcile }) => {
+        if (reconcile == null) return;
+        try {
+          await reconcile();
+        } catch (exc) {
+          // The next reopen reconciles again, so an unreachable cluster is churn.
+          if (isConnectionError(exc)) return;
+          this.onError(new Error(`failed to reconcile ${name} cache`, { cause: exc }));
+        }
+      }),
+    );
+  }
+
+  /**
+   * Discards every cached entry, tombstone, and answer, closes the change
+   * stream so it reopens fresh, and returns the epoch to 0. Called when the
+   * cluster behind the connection is replaced: no cached record, corpse, or
+   * answer remains meaningful, so nothing is tombstoned or diffed.
+   */
+  async reset(): Promise<void> {
+    const { streamer } = this;
+    this.streamer = null;
+    // Drain the retired stream first so a late frame cannot repopulate the
+    // tables cleared below. A close failure must not block the reset: the
+    // stream is retired either way.
+    try {
+      await streamer?.close();
+    } catch (exc) {
+      console.error("failed to close retired stream", exc);
+    }
+    this.tables.forEach(({ reset }) => reset());
+    this.spaces.forEach((space) => space.reset());
+    this.unmaintained = false;
+    this.epochCount = 0;
+    this.epochObserver.notify(0);
+  }
+
+  private bumpEpoch(): void {
+    this.epochCount++;
+    this.epochObserver.notify(this.epochCount);
+    this.reconcile().catch((exc: unknown) =>
+      this.onError(
+        new Error("failed to reconcile caches after reconnect", { cause: exc }),
+      ),
+    );
+  }
+
+  /**
+   * Closes the change stream and every answer space this cache constructed.
+   * A no-op for the stream when streaming never started.
+   */
+  async close(): Promise<void> {
+    this.detachers.forEach((detach) => detach());
+    this.spaces.forEach((space) => space.close());
+    if (this.streamer == null) return;
+    await this.streamer.close();
+  }
+}

package/src/query/deleted.ts

@@ -0,0 +1,38 @@
+// 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 TimeStamp } from "@synnaxlabs/x";
+
+// Brands instances through the global symbol registry so matches() holds across
+// duplicated module instances (dual CJS/ESM builds), where instanceof does not.
+const BRAND = Symbol.for("synnaxlabs.client.query.deleted");
+
+/**
+ * The last value of a deleted record, delivered wherever a cached answer would be, so
+ * deletion can never be mistaken for live data. One instance exists per deletion:
+ * repeated reads of a deleted answer return the same reference.
+ */
+export class Deleted<D = unknown> {
+  /** The record's value at the moment it was deleted. */
+  readonly corpse: D;
+  /** When the deletion was applied. */
+  readonly deletedAt: TimeStamp;
+  protected readonly [BRAND] = true;
+
+  constructor(corpse: D, deletedAt: TimeStamp) {
+    this.corpse = corpse;
+    this.deletedAt = deletedAt;
+  }
+
+  /** Narrows a cached answer to the deleted case, carrying its record type
+   *  onto the corpse. */
+  static matches<D>(value: D | Deleted<D> | undefined): value is Deleted<D> {
+    return typeof value === "object" && value !== null && BRAND in value;
+  }
+}