@synnaxlabs/client 0.56.2 → 0.57.1

package/dist/src/query/retriever.d.ts

@@ -0,0 +1,135 @@
+import { destructor, record } from '@synnaxlabs/x';
+import { default as z } from 'zod';
+import { Cache } from './cache';
+import { Cached, ChangeHandler, Retrieves, Watch } from './query';
+import { Keyed, Table } from './table';
+import { Data, FetchOptions, Params } from './types';
+/**
+ * Request schema arm reading a bare key list as `{ keys }`. Union it onto a
+ * domain's request schema to opt that domain into the shorthand:
+ * `retrieveRequestZ.or(keyListZ(keyZ))`.
+ */
+export declare const keyListZ: <K extends z.ZodType<record.Key>>(key: K) => z.ZodPipe<z.ZodArray<K>, z.ZodTransform<{
+    keys: z.core.output<K>[];
+}, z.core.output<K>[]>>;
+interface ComposeProp<V, D> {
+    /**
+     * Per-record enrichment applied to every answer, receiving the normalized
+     * query the record answers. Defaults to identity.
+     */
+    compose: (record: V, query: Params) => D;
+}
+/** Optional only when a record is a valid answer as-is (V assignable to D):
+ *  the identity default is unsound for any narrower D. */
+type ComposeParam<V, D> = [V] extends [D] ? Partial<ComposeProp<V, D>> : ComposeProp<V, D>;
+/**
+ * Declaration of a domain client's read surface. The single space is derived
+ * from the table and its fetch: `{ key }` params resolve one record, with
+ * deletion flipping the answer to deleted. Declare `single` only when the
+ * domain's single query is richer than a key.
+ */
+export type RetrieverParams<Z extends z.ZodType<Params>, K extends record.Key, V extends Keyed<K>, D extends Data = V, SingleInput = {
+    key: K;
+}, SingleQuery extends Params = K> = ComposeParam<V, D> & {
+    /** Resource name used in error messages, e.g. "range". */
+    name: string;
+    /** The table owning this domain's record content. */
+    table: Table<K, V>;
+    /** The space answering every non-single query shape. */
+    request: {
+        /**
+         * Parses and canonicalizes request params so equivalent queries hash
+         * identically; its output type is the space's query type.
+         */
+        schema: Z;
+        /**
+         * Fetches matching records from the cluster. Keys-only requests never
+         * reach it; they resolve through the table's fetch. Results hydrate the
+         * table under its declared mode.
+         */
+        fetch: (query: z.output<Z>, options?: FetchOptions) => Promise<V[]>;
+        /** Rule 2: whether a record satisfies the query. Pure; no network. */
+        matches?: (record: V, query: z.output<Z>) => boolean;
+        /** Overrides {@link DEFAULT_SERVER_FIELDS} for this request shape. */
+        serverFields?: readonly string[];
+        /** Foreign tables whose events affect this space's answers. */
+        watch?: Array<Watch<z.output<Z>, K>>;
+    };
+    /** Custom single space for domains whose single query is richer than a key. */
+    single?: {
+        /**
+         * Discriminates and canonicalizes single params: parse success routes the
+         * query to the single space, and the output is the space's query. Object
+         * schemas must reject unknown keys so request params fall through. Union
+         * in a bare-key arm to accept `retrieve(key)`.
+         */
+        schema: z.ZodType<SingleQuery, SingleInput | record.Key>;
+        /** The space answering single queries, built via the cache. */
+        space: Retrieves<SingleQuery, D>;
+    };
+};
+/**
+ * A domain client's cached read surface, routing each query to the single or
+ * request answer space. The arity of the result follows the query: params
+ * addressing one record yield a record, every other shape yields an array.
+ *
+ * Extend it and call `super(cache, { ... })`:
+ *
+ * ```ts
+ * export class Client extends query.Retriever<typeof requestZ, Key, Label> {
+ *   constructor(client: UnaryClient, cache: query.Cache) {
+ *     const store = cache.createTable({ ... });
+ *     super(cache, { name: "label", table: store, request: { ... } });
+ *   }
+ * }
+ * ```
+ *
+ * Anything evaluated eagerly inside `super` must come from a local, since
+ * `this` is unavailable until it returns. Closures may reference `this`: an
+ * arrow captures it lexically and does not read it until called.
+ *
+ * The read surface is not designed for overriding: a domain with more query
+ * kinds exposes them as named {@link Retrieves} members instead.
+ */
+export declare abstract class Retriever<Z extends z.ZodType<Params>, K extends record.Key, V extends Keyed<K>, D extends Data = V, SingleInput = {
+    key: K;
+}, SingleQuery extends Params = K> {
+    private readonly singleSpace;
+    private readonly requestSpace;
+    private readonly trySingle;
+    private readonly normalizeRequest;
+    private readonly routes;
+    constructor(cache: Cache, params: RetrieverParams<Z, K, V, D, SingleInput, SingleQuery>);
+    /**
+     * Routes params to their answer space, memoized per params object identity.
+     * {@link Params} is readonly, so a given object always routes identically;
+     * repeat reads of the same object skip schema validation entirely.
+     */
+    private route;
+    /**
+     * Reads the record the params address, or every record matching them.
+     * Serves the cache when the answer is fresh, fetching otherwise. A bare key
+     * is shorthand for `{ key }`; a bare key list is accepted by domains whose
+     * request schema unions in {@link keyListZ}.
+     * @throws {NotFoundError} if a single-record query matches nothing or the
+     * record was deleted.
+     * @throws {ValidationError} if params contain `key` (or are a bare key)
+     * but fail the single-query schema.
+     */
+    retrieve(params: K | SingleInput, options?: FetchOptions): Promise<D>;
+    retrieve(params: K[] | z.input<Z>, options?: FetchOptions): Promise<D[]>;
+    /**
+     * Subscribes to changes in the cached answer to the given query. The handler
+     * fires on every change or deletion. Returns a destructor that unsubscribes.
+     */
+    onChange(params: K | SingleInput, handler: ChangeHandler<D>): destructor.Destructor;
+    onChange(params: K[] | z.input<Z>, handler: ChangeHandler<D[]>): destructor.Destructor;
+    /**
+     * Returns the cached answer to the given query without touching the network, or
+     * undefined when nothing is cached. May be stale for unsubscribed queries.
+     */
+    getCached(params: K | SingleInput): Cached<D> | undefined;
+    getCached(params: K[] | z.input<Z>): Cached<D[]> | undefined;
+}
+export {};
+//# sourceMappingURL=retriever.d.ts.map

package/dist/src/query/retriever.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.d.ts","sourceRoot":"","sources":["../../../src/query/retriever.ts"],"names":[],"mappings":"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"}

package/dist/src/query/streamer.d.ts

@@ -0,0 +1,67 @@
+import { breaker } from '@synnaxlabs/x';
+import { default as z } from 'zod';
+import { framer } from '../framer';
+/**
+ * A raw channel reaction: parses frames from the channel with the schema and invokes
+ * onChange once per frame with every parsed value, in order. Mirror listeners bind to
+ * this shape internally; domains register reactions via the cache's listen.
+ */
+export interface Listener<Z extends z.ZodType = z.ZodType> {
+    /** The name of the Synnax channel to listen to */
+    channel: string;
+    /** Zod schema for parsing and validating channel data */
+    schema: Z;
+    /** Receives the frame's parsed values for the channel as one batch. */
+    onChange(this: void, changed: z.output<Z>[]): Promise<unknown> | unknown;
+}
+/** Arguments for opening a cache streamer. */
+export interface StreamerParams {
+    /** Receives frame-handling and listener errors. */
+    onError: (error: Error) => void;
+    /** The channel listeners to drive with streamed changes. */
+    listeners: Listener[];
+    /** Opens the raw frame stream; hardening is applied internally. */
+    openStreamer: framer.StreamOpener;
+    /** Retry behavior for stream reconnect attempts. */
+    breaker?: breaker.Config;
+    /** Called once when the stream first opens, before any frame is processed. */
+    onOpen?: () => void;
+    /**
+     * Called after every successful reconnect of the underlying stream (not the
+     * initial open). Changes may have been missed while disconnected.
+     */
+    onReopen?: () => void;
+    /**
+     * Called whenever the stream goes live: after the initial open and before every
+     * onReopen, so reconciliation fetches never race a stale liveness verdict.
+     */
+    onLive?: () => void;
+    /** Called when the underlying stream fails and reconnection begins. */
+    onDrop?: (error: Error) => void;
+    /**
+     * Called when the stream ends on a failure it cannot recover from. The next
+     * demand opens a new stream.
+     */
+    onDead?: (error: Error) => void;
+}
+/**
+ * A lazily-opened change stream over the channels named in a table config.
+ * Construction is synchronous and network-free; the underlying stream opens
+ * on the first {@link Streamer.demand} call.
+ */
+export interface Streamer {
+    /**
+     * Ensures the underlying stream is open, opening it on first call. Resolves
+     * once streaming is live. Safe to call concurrently and repeatedly.
+     */
+    demand: () => Promise<void>;
+    /** Closes the stream. A no-op when the stream was never demanded. */
+    close: () => Promise<void>;
+}
+/**
+ * Creates a lazy streamer that, once demanded, listens to configured channels and
+ * invokes the appropriate listeners when data changes.
+ * @returns The lazy streamer handle
+ */
+export declare const createStreamer: ({ openStreamer, breaker: breakerConfig, listeners: allListeners, onError, onOpen, onReopen, onLive, onDrop, onDead, }: StreamerParams) => Streamer;
+//# sourceMappingURL=streamer.d.ts.map

package/dist/src/query/streamer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamer.d.ts","sourceRoot":"","sources":["../../../src/query/streamer.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAGvC;;;;GAIG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO;IACvD,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,MAAM,EAAE,CAAC,CAAC;IACV,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC1E;AAgBD,8CAA8C;AAC9C,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAChC,4DAA4D;IAC5D,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC;IAClC,oDAAoD;IACpD,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC;IACzB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,uEAAuE;IACvE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAChC;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,qEAAqE;IACrE,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,uHAU5B,cAAc,KAAG,QAoGnB,CAAC"}

package/dist/src/query/table.d.ts

@@ -0,0 +1,219 @@
+import { CrudeTimeSpan, destructor, record, state } from '@synnaxlabs/x';
+import { default as z } from 'zod';
+import { Deleted } from './deleted';
+import { Listener } from './streamer';
+/**
+ * Presence of a key in a table: "present" when a live entry exists, "tombstoned"
+ * when the entry was deleted and its corpse is retained, "unknown" when the
+ * table has never seen the key or the corpse was cleared.
+ */
+export type EntryStatus = "present" | "tombstoned" | "unknown";
+/** A change to a single entry of a {@link Table}. */
+export type TableEvent<Key extends record.Key = record.Key, Value extends state.State = state.State> = {
+    variant: "set";
+    key: Key;
+    value: Value;
+} | {
+    variant: "delete";
+    key: Key;
+};
+/** Receives {@link TableEvent}s. Must be synchronous; thrown errors are
+ *  reported to the table's error sink and do not stop delivery. */
+export interface TableSubscriber<Key extends record.Key = record.Key, Value extends state.State = state.State> {
+    (event: TableEvent<Key, Value>): void;
+}
+/**
+ * Receives every event of a batched write as one call, in event order. A single write
+ * delivers a batch of one. Same synchrony and error contract as
+ * {@link TableSubscriber}.
+ */
+export interface BatchSubscriber<Key extends record.Key = record.Key, Value extends state.State = state.State> {
+    (events: TableEvent<Key, Value>[]): void;
+}
+/**
+ * How fetched records hydrate a table: "set" overwrites entries, "if-absent"
+ * preserves existing entries.
+ */
+export type HydrateMode = "set" | "if-absent";
+/** A table value carrying its entry key, so batch writes and fetches can derive
+ *  each entry's key from the record itself. */
+export type Keyed<Key extends record.Key = record.Key, Value extends state.State = state.State> = Value & record.Keyed<Key>;
+/** Construction arguments for a {@link Table}. */
+export interface TableParams<Key extends record.Key = record.Key, Value extends state.State = state.State> {
+    /** Receives subscriber and fetch errors that have no caller to throw to. */
+    onError: (error: Error) => void;
+    /** Overrides the deep-equality default used to silence redundant sets. */
+    equal?: (a: Value, b: Value, key: Key) => boolean;
+    /**
+     * Fetches the current records for the given keys from the cluster,
+     * returning only the entries that still exist. Powers {@link Table.retrieve},
+     * key-announce listeners, and reconciliation. Omit for tables with no
+     * server backing (they are skipped by all three).
+     */
+    fetch?: (keys: Key[]) => Promise<Array<Keyed<Key, Value>>>;
+    /**
+     * Hydration mode, "set" by default. Dispatch-backed document tables use
+     * "if-absent" so fetches never clobber locally replayed edits.
+     */
+    hydrate?: HydrateMode;
+    /**
+     * Window for coalescing concurrent miss fetches into one fetch call.
+     * @default TimeSpan.milliseconds(10)
+     */
+    fetchDebounce?: CrudeTimeSpan;
+}
+/**
+ * The sole owner of one resource's record content and tombstones. Everything else in
+ * the cache holds keys into it: answers store key lists, dispatch bookkeeping rides
+ * entry deletion, and consumers assemble content at read time. An equal-value set
+ * announces nothing: writers echoing state the table already holds (server echoes of
+ * optimistic writes, idempotent backfills) are silenced by the equality check rather
+ * than by writer identity.
+ */
+export declare class Table<Key extends record.Key = record.Key, Value extends state.State = state.State> {
+    private readonly entries;
+    private readonly tombstones;
+    private readonly broadSubscribers;
+    private readonly batchSubscribers;
+    private readonly keyedSubscribers;
+    private batching;
+    private readonly onError;
+    private readonly equal;
+    private readonly fetchEntries?;
+    private readonly hydrateMode;
+    private readonly fetchBatcher;
+    private gen;
+    constructor({ onError, equal, fetch, hydrate, fetchDebounce, }: TableParams<Key, Value>);
+    private setOne;
+    /**
+     * Sets the value for the given key, or applies a setter to the previous value. A
+     * setter producing null/undefined, or a value equal to the current one, is a no-op.
+     * @returns A rollback that undoes the set.
+     */
+    set(key: Key, value: state.SetArg<Value | undefined>): destructor.Destructor;
+    /**
+     * Sets every given keyed value, keying each entry by its key property.
+     * @returns A rollback that undoes the inserted values in reverse order.
+     */
+    set(values: Keyed<Key, Value> | Array<Keyed<Key, Value>>): destructor.Destructor;
+    private setIfAbsent;
+    /**
+     * Writes fetched records into the table under its declared hydrate mode:
+     * "set" overwrites entries, "if-absent" leaves existing entries untouched.
+     * @returns A rollback that undoes the entries this call wrote.
+     */
+    ingest(values: Keyed<Key, Value> | Array<Keyed<Key, Value>>): destructor.Destructor;
+    /** Returns every entry in the table. */
+    get(): Value[];
+    get(key: Key): Value | undefined;
+    get(keys: Key[]): Value[];
+    get(filter: (value: Value) => boolean): Value[];
+    has(key: Key): boolean;
+    /** Returns the key of every live entry. */
+    keys(): Key[];
+    /**
+     * Returns the presence of the given key: present, tombstoned, or unknown.
+     * Cache-internal surface: consumed by the query machinery, not domain code.
+     */
+    status(key: Key): EntryStatus;
+    /**
+     * Returns the tombstone for the given key, or undefined if none exists.
+     * Cache-internal surface: consumed by the query machinery, not domain code.
+     */
+    getTombstone(key: Key): Deleted<Value> | undefined;
+    /**
+     * 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.
+     */
+    retrieve(keys: Key[], opts?: {
+        refresh?: boolean;
+    }): Promise<Value[]>;
+    /**
+     * Deletes entries and notifies subscribers. Deleted values are retained as
+     * tombstones until a subsequent set for the key.
+     * @param key - The key(s) to delete or a filter function
+     * @returns A rollback that restores the deleted entries
+     */
+    delete(key: Key | Key[] | ((value: Value, key: Key) => boolean)): destructor.Destructor;
+    /**
+     * Removes entries and notifies subscribers, retaining no corpses: the undo of a write
+     * the record never survived, not a deletion. A reader finds the key unknown rather
+     * than deleted.
+     * @returns A rollback that restores the removed entries
+     */
+    evict(key: Key | Key[]): destructor.Destructor;
+    private remove;
+    /**
+     * Re-checks every cached entry against the cluster through the table's
+     * fetch: refreshes entries that still exist and tombstones entries that
+     * vanished. A no-op for empty tables and tables without a fetch.
+     */
+    reconcile(): Promise<void>;
+    /**
+     * Discards every entry and tombstone without notifying subscribers. Called
+     * only by the cache's reset, which resets the answer spaces itself:
+     * per-entry delete events would masquerade as deletions of live records.
+     * Fetches in flight when the reset runs discard their results.
+     */
+    reset(): void;
+    /**
+     * Subscribes to entry changes delivered per batched write: one call carrying every
+     * event of the batch, in order, after all of the batch's entries have applied.
+     * Cache-internal surface: consumed by the query machinery, not domain code;
+     * per-record consumers use {@link subscribe}.
+     * @returns A destructor that unsubscribes.
+     */
+    subscribeBatch(subscriber: BatchSubscriber<Key, Value>): destructor.Destructor;
+    /**
+     * Subscribes to entry changes. With a key, only changes to that entry fire.
+     * @returns A destructor that unsubscribes.
+     */
+    subscribe(subscriber: TableSubscriber<Key, Value>, key?: Key): destructor.Destructor;
+    /**
+     * Runs fn with event delivery deferred: writes apply to entries immediately, and
+     * every event they produce is delivered as one batch when the outermost batch
+     * exits. Delivery stays synchronous, inside this call. Nested batches join the
+     * outermost one. Events flush even when fn throws, since the entries they describe
+     * were already applied.
+     */
+    batch<T>(fn: () => T): T;
+    private notify;
+    private flush;
+    private deliver;
+}
+/**
+ * A mirror listener declaration: keeps the owning table current from one stream
+ * channel. Built with {@link createSetListener}, {@link createDeleteListener}, or
+ * {@link createFetchListener}; bound to its table by the cache.
+ */
+export interface ListenerSpec<Key extends record.Key = record.Key, Value extends state.State = state.State> {
+    /** Binds the declaration to the owning table as a raw channel listener. */
+    bind: (table: Table<Key, Value>) => Listener;
+}
+/**
+ * Declares that the channel broadcasts records to mirror into the table.
+ * By default the parsed record keys itself (`changed.key`) and is stored
+ * as-is; `key` derives the entry key, `value` transforms the record and may
+ * merge with the previous entry (return null/undefined to skip the write).
+ */
+export declare const createSetListener: <Z extends z.ZodType, Key extends record.Key = record.Key, Value extends state.State = state.State>(channel: string, schema: Z, opts?: {
+    key?: (changed: z.output<Z>) => Key;
+    value?: (changed: z.output<Z>, prev: Value | undefined) => Value | null | undefined;
+}) => ListenerSpec<Key, Value>;
+/**
+ * Declares that the channel broadcasts deletions to mirror into the table.
+ * By default the parsed value is the entry key; `key` derives it instead.
+ */
+export declare const createDeleteListener: <Z extends z.ZodType, Key extends record.Key = record.Key, Value extends state.State = state.State>(channel: string, schema: Z, opts?: {
+    key?: (changed: z.output<Z>) => Key;
+}) => ListenerSpec<Key, Value>;
+/**
+ * Declares that the channel announces keys whose records changed. Announced
+ * keys are refetched through the table's fetch and overwrite their entries.
+ */
+export declare const createFetchListener: <Z extends z.ZodType<Key | Key[]>, Key extends record.Key = record.Key, Value extends state.State = state.State>(channel: string, schema: Z) => ListenerSpec<Key, Value>;
+export declare const partialUpdate: <Key extends record.Key, Value extends object>(table: Table<Key, Value>, key: Key, value: Partial<Value>) => destructor.Destructor;
+//# sourceMappingURL=table.d.ts.map

package/dist/src/query/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../src/query/table.ts"],"names":[],"mappings":"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"}

package/dist/src/query/types.d.ts

@@ -0,0 +1,35 @@
+import { primitive, state } from '@synnaxlabs/x';
+/** Options to control async operations. */
+export interface FetchOptions {
+    /** Optional AbortSignal to cancel the operation */
+    signal?: AbortSignal;
+}
+/** Options for write methods that apply the change locally before the send. */
+export interface WriteOptions<T = void> {
+    /**
+     * Called after the optimistic cache apply and before the network send, with
+     * the optimistically applied value. UI layers use it to react to a write
+     * (e.g. open a tab) without waiting on the server.
+     */
+    onOptimistic?: (value: T) => Promise<void> | void;
+}
+/**
+ * Plain-data shape used to address a record in the cache query system. Queries are
+ * hashed by {@link hash} to produce stable cache keys, so they must be primitives,
+ * arrays of queries, plain string-keyed objects of queries, or class instances
+ * implementing {@link primitive.Hashable}. Maps, Sets, Dates, and non-Hashable class
+ * instances are rejected at compile time because their fields don't recursively reduce
+ * to {@link Params}. Consumer query types must be declared with `type` aliases, not
+ * `interface`, because TypeScript interfaces lack an implicit string index signature
+ * and fail the `{ readonly [k: string]: Params }` branch.
+ */
+export type Params = string | number | bigint | boolean | null | undefined | primitive.Hashable | readonly Params[] | {
+    readonly [key: string]: Params;
+};
+/**
+ * Shape of values returned and stored by the cache query system. Unlike
+ * {@link Params}, data values do not need to be hashable — they may carry
+ * arbitrary state including class instances or non-serializable references.
+ */
+export type Data = state.State;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/query/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/query/types.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3D,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,+EAA+E;AAC/E,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,IAAI;IACpC;;;;OAIG;IACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACnD;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,MAAM,GACd,MAAM,GACN,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,SAAS,CAAC,QAAQ,GAClB,SAAS,MAAM,EAAE,GACjB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAEvC;;;;GAIG;AACH,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC"}

package/dist/src/query/write.d.ts

@@ -0,0 +1,21 @@
+import { destructor } from '@synnaxlabs/x';
+export interface OptimisticParams<R> {
+    /**
+     * Rollbacks for the already-applied optimistic cache changes, run in
+     * reverse order when commit fails.
+     */
+    rollbacks: destructor.Destructor[];
+    /**
+     * Notified after the rollbacks are captured and before commit runs. Value-bearing
+     * writes close over their optimistic value: `() => opts.onOptimistic?.(value)`.
+     */
+    onOptimistic?: () => Promise<void> | void;
+    /** The network send. Its result is returned when it succeeds. */
+    commit: () => Promise<R>;
+}
+/**
+ * Runs an optimistic write. When commit or `onOptimistic` fails the rollbacks
+ * run and the error rethrows; on success the cache keeps the optimistic state.
+ */
+export declare const optimistic: <R>({ rollbacks, onOptimistic, commit, }: OptimisticParams<R>) => Promise<R>;
+//# sourceMappingURL=write.d.ts.map

package/dist/src/query/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../src/query/write.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC;;;OAGG;IACH,SAAS,EAAE,UAAU,CAAC,UAAU,EAAE,CAAC;IACnC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1C,iEAAiE;IACjE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,sCAIjC,gBAAgB,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAOjC,CAAC"}

package/dist/src/rack/client.d.ts

@@ -1,27 +1,42 @@
 import { UnaryClient } from '@synnaxlabs/freighter';
 import { z } from 'zod';
+import { ontology } from '../ontology';
+import { query } from '../query';
 import { Key, New, Payload, Status } from './types.gen';
+import { status } from '../status';
 import { task } from '../task';
 export declare const SET_CHANNEL_NAME = "sy_rack_set";
 export declare const DELETE_CHANNEL_NAME = "sy_rack_delete";
+declare const retrieveMultiParamsZ: z.ZodUnion<[z.ZodObject<{
+    keys: z.ZodOptional<z.ZodArray<z.ZodUInt32>>;
+    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    integration: z.ZodOptional<z.ZodString>;
+    searchTerm: z.ZodOptional<z.ZodString>;
+    embedded: z.ZodOptional<z.ZodBoolean>;
+    hostIsNode: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodInt>;
+    offset: z.ZodOptional<z.ZodInt>;
+    includeStatus: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodPipe<z.ZodArray<z.ZodUInt32>, z.ZodTransform<{
+    keys: number[];
+}, number[]>>]>;
 export declare const rackZ: z.ZodObject<{
     key: z.ZodUInt32;
     name: z.ZodString;
-    taskCounter: z.ZodOptional<z.ZodUInt32>;
-    embedded: z.ZodOptional<z.ZodBoolean>;
-    status: z.ZodOptional<import('@synnaxlabs/x/dist/src/status/types.gen').StatusZodObject<z.ZodObject<{
+    embedded: z.ZodDefault<z.ZodBoolean>;
+    status: z.ZodOptional<status.StatusZodObject<z.ZodObject<{
         rack: z.ZodUInt32;
     }, z.core.$strip>, z.ZodEnum<{
-        success: "success";
         error: "error";
+        success: "success";
         info: "info";
         warning: "warning";
         loading: "loading";
         disabled: "disabled";
     }>>>;
-    integrations: z.ZodOptional<z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodString>>, z.ZodTransform<string[] | undefined, string[] | null>>>;
+    integrations: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-declare const singleRetrieveArgsZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+declare const singleRetrieveParamsZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
     key: z.ZodUInt32;
     includeStatus: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodTransform<{
@@ -40,8 +55,8 @@ declare const singleRetrieveArgsZ: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
     name: string;
     includeStatus?: boolean | undefined;
 }>>]>;
-export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
-declare const multiRetrieveArgsZ: z.ZodObject<{
+export type RetrieveSingleParams = z.input<typeof singleRetrieveParamsZ>;
+declare const multiRetrieveParamsZ: z.ZodObject<{
     keys: z.ZodOptional<z.ZodArray<z.ZodUInt32>>;
     names: z.ZodOptional<z.ZodArray<z.ZodString>>;
     integration: z.ZodOptional<z.ZodString>;
@@ -52,8 +67,8 @@ declare const multiRetrieveArgsZ: z.ZodObject<{
     offset: z.ZodOptional<z.ZodInt>;
     includeStatus: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-export type RetrieveMultipleParams = z.input<typeof multiRetrieveArgsZ>;
-declare const retrieveArgsZ: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+export type RetrieveMultipleParams = z.input<typeof multiRetrieveParamsZ>;
+declare const retrieveParamsZ: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
     key: z.ZodUInt32;
     includeStatus: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodTransform<{
@@ -82,26 +97,49 @@ declare const retrieveArgsZ: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodPipe
     offset: z.ZodOptional<z.ZodInt>;
     includeStatus: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>]>;
-export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
-export declare class Client {
-    private readonly client;
-    private readonly tasks;
-    constructor(client: UnaryClient, taskClient: task.Client);
-    delete(keys: Key | Key[]): Promise<void>;
+export type RetrieveParams = z.input<typeof retrieveParamsZ>;
+type SingleQuery = {
+    key: Key;
+    includeStatus?: boolean;
+} | {
+    name: string;
+    includeStatus?: boolean;
+};
+export interface ClientConfig {
+    unary: UnaryClient;
+    tasks: task.Client;
+    cache: query.Cache;
+    statusStore: query.Table<status.Key, status.Status>;
+    ontology: ontology.Client;
+}
+export declare class Client extends query.Retriever<typeof retrieveMultiParamsZ, Key, Omit<Payload, "status">, Rack, RetrieveSingleParams, SingleQuery> {
+    private readonly cfg;
+    private readonly store;
+    constructor(cfg: ClientConfig);
+    delete(keys: Key | Key[], opts?: query.WriteOptions): Promise<void>;
+    rename(key: Key, name: string, opts?: query.WriteOptions): Promise<void>;
     create(rack: New): Promise<Rack>;
     create(racks: New[]): Promise<Rack[]>;
-    retrieve(args: RetrieveSingleParams): Promise<Rack>;
-    retrieve(args: RetrieveMultipleParams): Promise<Rack[]>;
     sugar(payload: Payload): Rack;
     sugar(payloads: Payload[]): Rack[];
+    /** Rebuilds a cached rack, attaching its cached status when requested. */
+    private compose;
+    private statusOf;
+    /** Writes fetched racks and their included statuses. */
+    private writeThrough;
+    private execRetrieve;
+    /** Fetches racks and writes their included statuses through the caches. */
+    private fetchThrough;
+    private fetchSingle;
 }
 export declare class Rack {
     key: Key;
     name: string;
     status?: Status;
-    integrations?: string[];
+    integrations: string[];
+    embedded: boolean;
     private readonly tasks;
-    constructor(key: Key, name: string, taskClient: task.Client, status?: Status, integrations?: string[]);
+    constructor(key: Key, name: string, taskClient: task.Client, status?: Status, integrations?: string[], embedded?: boolean);
     listTasks(): Promise<task.Task[]>;
     createTask(task: task.New): Promise<task.Task>;
     createTask<Schemas extends task.Schemas = task.Schemas>(task: task.New<Schemas>, schemas: Schemas): Promise<task.Task<Schemas>>;