@thomasfosterau/pulpit 0.0.0-stage → 0.1.0

package/dist/testing.d.ts

@@ -0,0 +1,675 @@
+/**
+ * **In-memory fakes of the kernel's seams** — a store for each of the
+ * version-chain, leaf, document, edge, proposal, path, report, publication, purge and embedding seams, an
+ * endpoint view, a follower seam, a search branch (with a scope check) and a resource cache, all held in memory with no SQL. They are the reference semantics of
+ * each seam's contract in the package README → Seams, and the fakes the
+ * kernel's own suites run against; an adapter's or an application's tests can
+ * run the kernel's operations over them too.
+ *
+ * **Not for production.** Every store here keeps its rows in a closure for the
+ * life of the value, persists nothing, never opens a transaction and has no
+ * concurrency control beyond what a single JavaScript thread gives it. Each
+ * store enforces what the real table's schema enforces (a primary or unique
+ * key) and nothing the operations are responsible for, so a test of the
+ * operations over a fake exercises the operations' policy, not the store's.
+ * Each also carries a few test hooks (`rows`, `dropState`, `raceNextAppend`,
+ * …) that a real store has no counterpart for: they read what was written,
+ * or simulate a state a real database reaches only through a race or a
+ * missing row.
+ *
+ * The follower seam's `in` set is a `HashSet` of account ids
+ * ({@link InMemoryFollowing}) throughout, where a SQL store's is a subquery.
+ *
+ * @example
+ * ```ts
+ * import { deepStrictEqual } from "node:assert";
+ * import * as Effect from "effect/Effect";
+ * import * as Option from "effect/Option";
+ * import { defineVersionChain } from "@thomasfosterau/pulpit/version-chain";
+ * import { makeInMemoryChainStore } from "@thomasfosterau/pulpit/testing";
+ *
+ * const store = makeInMemoryChainStore();
+ * const chain = defineVersionChain("notes", store);
+ * const { id } = Effect.runSync(
+ *   chain.create({ id: Option.none(), state: { title: "Hello" }, actorId: Option.none() }),
+ * );
+ *
+ * // The chain operations appended version 0, and the fake recorded it.
+ * deepStrictEqual(
+ *   store.rows().map((row) => [row.id, row.version, row.action]),
+ *   [[id, 0n, "create"]],
+ * );
+ * ```
+ *
+ * @copyright Thomas Foster
+ * @module pulpit/testing
+ * @since 0.1.0
+ */
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { type BlobHead, type BlobStore } from "./blobs.ts";
+import type { BudgetCounter, BudgetRequest, WriteCountStore } from "./budgets.ts";
+import { type DocumentHash, type DocumentStore } from "./documents.ts";
+import { type EdgeEnds, type EdgeRow, type EdgeStore, type EdgeValues, type EndpointView } from "./edges.ts";
+import { type FilterRow } from "./filter.ts";
+import type { PurgeStore } from "./purge.ts";
+import { SearchScopeLeak, type EmbeddingStore, type SearchBranch } from "./search.ts";
+import type { ReactionRow, ReactionStore } from "./reactions.ts";
+import type { KvEntry, VersionedKv } from "./cache.ts";
+import type { CollectionEntry, CollectionStore } from "./collections.ts";
+import type { Relationship, SocialStore } from "./social.ts";
+import { type PathEntry, type PathStore } from "./paths.ts";
+import type { ReportRow, ReportStore } from "./moderation.ts";
+import type { ProposalRow, ProposalStore } from "./proposals.ts";
+import type { WorkingCopy, WorkingCopyStore } from "./working-copy.ts";
+import type { FollowerSeam, LeafRow, LeafStore, LiveView, PublicationFact, PublicationStore, ResourceCacheSeam } from "./subtype.ts";
+import { type VersionChainStore, type VersionRow } from "./version-chain.ts";
+/**
+ * The follower seam's `in` set in every fake here: the ids of the accounts a
+ * viewer follows. A SQL store's is a subquery; the in-memory list filters
+ * test membership in this set instead.
+ *
+ * @since 0.1.0
+ */
+export type InMemoryFollowing = HashSet.HashSet<string>;
+/**
+ * An in-memory {@link FollowerSeam} over an explicit table of who follows
+ * whom: each entry is a follower's id and the ids of the accounts it
+ * follows. `isFollower` answers from the table and `following` returns the
+ * follower's row as an {@link InMemoryFollowing} set (empty for an account the
+ * table doesn't name), the in-memory reading of effect-auth's `IsFollower`
+ * (README → Seams → the follower seam). In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryFollowers: (table: Iterable<readonly [follower: string, followed: ReadonlyArray<string>]>) => FollowerSeam<InMemoryFollowing, never>;
+/**
+ * An in-memory {@link VersionChainStore}, plus the hooks a test reads and
+ * steers it through. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryChainStore extends VersionChainStore<never, never> {
+    /** Every row ever appended, in append order — what the append-only assertions read. */
+    readonly rows: () => ReadonlyArray<VersionRow>;
+    /** Simulate a partial chain: the state at `(id, version)` is no longer reconstructable. */
+    readonly dropState: (id: string, version: bigint) => void;
+    /** Simulate a concurrent writer: the next append for `id` finds its version taken. */
+    readonly raceNextAppend: (id: string) => void;
+    /**
+     * Hard-delete every row of `id` and return them: what
+     * {@link makeInMemoryPurgeStore} erases a node through, and nothing else
+     * may call (`VERSION-CHAIN-001/002`).
+     */
+    readonly erase: (id: string) => ReadonlyArray<VersionRow>;
+}
+/**
+ * An in-memory {@link VersionChainStore}: the seam's contract (README → Seams
+ * → `VersionChainStore`) over an append log. It enforces what the Drizzle
+ * store's schema enforces, the `(id, version)` primary key (an `append` at a
+ * taken pair fails `VersionConflict`), and nothing the operations are
+ * responsible for. `mintId` mints sequential UUID-shaped ids.
+ *
+ * `dropState` simulates a partial chain (a level with no row at a version),
+ * which a real database reaches through a missing leaf row, and
+ * `raceNextAppend` a writer that takes the next version first. In memory
+ * only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryChainStore: () => InMemoryChainStore;
+/**
+ * An in-memory {@link LeafStore} over an {@link InMemoryChainStore}, plus the
+ * hooks a test reads and steers its owner stamps through. In memory only; not
+ * for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryLeafStore extends LeafStore<LeafRow, InMemoryFollowing, never, never> {
+    /** Every owner stamp, node id → owner id — what the owner-stamp assertions read. */
+    readonly owners: () => HashMap.HashMap<string, string>;
+    /** Simulate an ownerless owned node: drop `id`'s owner stamp (the apps' `core.node_owner` row). */
+    readonly dropOwner: (id: string) => void;
+}
+/**
+ * Options for {@link makeInMemoryLeafStore}.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryLeafStoreOptions {
+    /** The view's leaf columns; `id`, `action` and `ownerId` are always in its `columns`. */
+    readonly columns: ReadonlyArray<string>;
+    /**
+     * A localised leaf's view (pulpit#56): its `columns` gain
+     * {@link LOCALE_COLUMN}, and `list` reads one row per `(id, locale)`.
+     * `get` / `getMany` read the shared row either way.
+     */
+    readonly localised?: boolean | undefined;
+    /** The instant `published` / `notPublished` compare against; the Effect `Clock`'s at each `list` when absent. */
+    readonly now?: Date | undefined;
+}
+/**
+ * An in-memory {@link LeafStore}: the seam's contract (README → Seams →
+ * `LeafStore`) as a current-version view over an {@link InMemoryChainStore}.
+ * Each node's row is its head version's state with its head `version` and `action`, and
+ * `ownerId` merged in from the owner stamps (the apps' `core.node_owner`
+ * join); `list` evaluates its {@link ListFilter} in memory, orders by its
+ * `orderBy` keys then `id` ascending as the seam's contract renders it
+ * (`NULLS LAST` in both directions, a string by code point as `COLLATE "C"`
+ * sorts it, a `Date` by its instant), and returns the unpaged total. Like a
+ * SQL store, it takes `orderBy` as already checked against `columns`. It
+ * applies no visibility policy, as a real view applies none. In memory only;
+ * not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryLeafStore: (chain: InMemoryChainStore, options: InMemoryLeafStoreOptions) => InMemoryLeafStore;
+/**
+ * An in-memory {@link PathStore}, plus the read a test checks it through. In
+ * memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryPathStore extends PathStore<never, never> {
+    /** Every stored path and its entry, aliases included. */
+    readonly entries: () => HashMap.HashMap<string, PathEntry>;
+}
+/**
+ * An in-memory {@link PathStore}: the seam's contract (README → Seams →
+ * `PathStore`) as one map from path to entry, its key the path table's
+ * primary key, so each path is stored once. `claim` fails {@link PathTaken}
+ * for another node's canonical path, replaces an alias at the path, and
+ * demotes the node's previous canonical path to its alias, in one step;
+ * `release` drops the node's canonical path and keeps its aliases. In memory
+ * only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryPathStore: () => InMemoryPathStore;
+/**
+ * An in-memory {@link ResourceCacheSeam}, plus the reads a test checks it
+ * through. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryResourceCache<Resource> extends ResourceCacheSeam<Resource, never> {
+    /** The resource the cache would serve for `id`: none when evicted, refused or never set. */
+    readonly get: (id: string) => Option.Option<Resource>;
+    /** The highest version the cache holds for `id`, set or evicted, or none. */
+    readonly versionOf: (id: string) => Option.Option<bigint>;
+}
+/**
+ * An in-memory {@link ResourceCacheSeam}: the seam's compare-on-set contract
+ * (README → Seams → the resource cache, pulpit#121). It keeps, per id, the
+ * highest version either call has given it: a `set` below it is a no-op, a
+ * `set` at or above it stores the resource when `serveable` admits it and
+ * evicts it otherwise, and a `delete` evicts and raises the version. Each
+ * call compares and writes in one step, as the real cache's conditional write
+ * must. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryResourceCache: <Resource>(serveable: (resource: Resource) => boolean) => InMemoryResourceCache<Resource>;
+/**
+ * An in-memory {@link DocumentStore}, plus the hooks a test reads it through.
+ * In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryDocumentStore<Document extends Schema.Json> extends DocumentStore<Document, never, never> {
+    /** Every stored document by hash — what the never-rewritten assertions read. */
+    readonly stored: () => HashMap.HashMap<DocumentHash, Document>;
+    /**
+     * How many times `put` wrote a row: a real insert counts, a no-op `put` of a
+     * stored hash does not. The never-rewritten assertions read it, because
+     * `HashMap.set` with a structurally equal value is indistinguishable from no
+     * write in {@link InMemoryDocumentStore.stored}.
+     */
+    readonly writes: () => number;
+    /**
+     * Delete the documents at `hashes`: what {@link makeInMemoryPurgeStore}
+     * deletes an unreferenced document through, and nothing else may call
+     * (`DOC-001`).
+     */
+    readonly remove: (hashes: ReadonlyArray<DocumentHash>) => void;
+}
+/**
+ * An in-memory {@link DocumentStore}: the seam's contract (README → Seams →
+ * `DocumentStore`), hash contract included. It hashes exactly as a Postgres
+ * store does, SHA-256 over the UTF-8 bytes of the document's
+ * {@link canonicalText}, so its hashes are the ones the database generates
+ * (the kernel's suite pins it to hashes taken from Postgres). Like a store's
+ * primary key on the hash with `ON CONFLICT DO NOTHING`, it keeps the first
+ * document stored at a hash and never replaces it (`DOC-001`). It hashes with
+ * Web Crypto (`crypto.subtle`), which Node.js 22 and every browser provide.
+ * In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryDocumentStore: <Document extends Schema.Json>() => InMemoryDocumentStore<Document>;
+/**
+ * An in-memory {@link EndpointView} whose nodes a test writes directly. In
+ * memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryNodes extends EndpointView<never, never> {
+    /** Store (or replace) a node's current-version row. */
+    readonly put: (row: LeafRow) => void;
+}
+/**
+ * An in-memory {@link EndpointView}: an edge end's current-version view
+ * (README → Seams → `EdgeStore`) as rows a test puts by hand, for an edge
+ * suite that doesn't need the endpoint leaf's version chain. Its `columns`
+ * are `id`, `version`, `action` and `columns`. An {@link InMemoryLeafStore} is an
+ * endpoint view too. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryNodes: (columns: ReadonlyArray<string>) => InMemoryNodes;
+/**
+ * An in-memory {@link EdgeStore}, plus the hooks a test reads and steers it
+ * through. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryEdgeStore extends EdgeStore<EdgeRow, InMemoryFollowing, never, never> {
+    /** Every stored edge, hidden ones included, in insertion order. */
+    readonly rows: () => ReadonlyArray<EdgeRow>;
+    /**
+     * Simulate a concurrent writer: the next insert finds its unique key just
+     * taken by `winner`, which is stored in its place (the racing writer's
+     * values, which share the key and may differ elsewhere).
+     */
+    readonly raceNextInsert: (winner: EdgeValues) => void;
+}
+/**
+ * Options for {@link makeInMemoryEdgeStore}.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryEdgeStoreOptions {
+    /** The ends the list joins, by alias (the family declaration's `ends`). */
+    readonly ends: EdgeEnds<never, never>;
+    /** The unique key's columns; empty for a family with none. */
+    readonly uniqueKey: ReadonlyArray<string>;
+    /**
+     * The instant `published` / `notPublished` compare against, and the base of
+     * the minted `createdAt`s; the Effect `Clock`'s at each call when absent.
+     */
+    readonly now?: Date | undefined;
+}
+/**
+ * An in-memory {@link EdgeStore}: the seam's contract (README → Seams →
+ * `EdgeStore`) over one edge family's rows. It enforces what an edge table's
+ * schema enforces, the family's unique key (with `NULLS NOT DISTINCT`, as
+ * gardeneria's `page_slugs_unique_variant`), and nothing the operations are
+ * responsible for. `list`, `countAt`, `members` and `countBy` join each end's view the way the SQL
+ * store's INNER JOIN does: under the end's alias, dropping an edge whose end
+ * has no row. `list` orders by `createdAt` then `id` and reports the unpaged
+ * total as the SQL store's window column does (`0` for an empty page).
+ *
+ * Ids are minted `edge-0001`, `edge-0002`, …; the n-th insert is stamped
+ * `now + n` milliseconds, except that every third shares its predecessor's
+ * instant, so the `id` tie-break of the list order is exercised. In memory
+ * only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryEdgeStore: (options: InMemoryEdgeStoreOptions) => InMemoryEdgeStore;
+/**
+ * An in-memory {@link ProposalStore}, plus the hook a test reads it through.
+ * In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryProposalStore extends ProposalStore<never, never> {
+    /** Every row, in insert order, as it now stands. */
+    readonly rows: () => ReadonlyArray<ProposalRow>;
+}
+/**
+ * An in-memory {@link ProposalStore}: the seam's contract (README → Seams →
+ * `ProposalStore`). A listing's `targetVersion` is the `chain`'s head for
+ * the target, and the `targetOwnerId` its `list` filters on is `leaves`'
+ * owner stamp (or `null`), as the SQL store's joins read them. `lock`
+ * locks nothing (one JavaScript thread has no concurrent decision to
+ * serialise). `mintId` mints sequential UUID-shaped ids. In memory only;
+ * not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryProposalStore: (options: {
+    readonly chain: InMemoryChainStore;
+    readonly leaves: InMemoryLeafStore;
+}) => InMemoryProposalStore;
+/**
+ * An in-memory {@link ReportStore}, plus the hook a test reads it through.
+ * In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryReportStore extends ReportStore<never, never> {
+    /** Every report, in filing order, as it now stands. */
+    readonly rows: () => ReadonlyArray<ReportRow>;
+}
+/**
+ * An in-memory {@link ReportStore}: the seam's contract (README → Seams →
+ * `ReportStore`). `list` evaluates the filter in memory, newest first with
+ * `id` descending on a tie; `lock` locks nothing (one JavaScript thread has
+ * no concurrent resolution to serialise); `mintId` mints sequential
+ * UUID-shaped ids. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryReportStore: () => InMemoryReportStore;
+declare const InMemoryBlobFailure_base: Schema.Class<InMemoryBlobFailure, Schema.TaggedStruct<"InMemoryBlobFailure", {
+    readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
+/**
+ * The in-memory blob store's one failure: a simulated outage.
+ *
+ * @since 0.1.0
+ */
+export declare class InMemoryBlobFailure extends InMemoryBlobFailure_base {
+}
+/**
+ * One object in an {@link InMemoryBlobStore}.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryBlob {
+    readonly bytes: Uint8Array;
+    readonly head: BlobHead;
+}
+/**
+ * An in-memory {@link BlobStore}, plus the hooks a test reads and steers it
+ * through. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryBlobStore extends BlobStore<InMemoryBlobFailure, never> {
+    /** Every stored object by key. */
+    readonly objects: () => HashMap.HashMap<string, InMemoryBlob>;
+    /** Simulate an outage: the next `put` fails with {@link InMemoryBlobFailure}. */
+    readonly failNextPut: () => void;
+}
+/**
+ * An in-memory {@link BlobStore}: the seam's contract (README → Seams →
+ * `BlobStore`). `publicUrl` is `memory://<key>`; there is no signed upload
+ * URL. `failNextPut` simulates the byte write failing after the commit. In
+ * memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryBlobStore: () => InMemoryBlobStore;
+/**
+ * A publish-gated leaf's in-memory seams, over an in-memory chain and leaf
+ * store, plus the hook a test reads the log through. In memory only; not
+ * for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryPublication {
+    /** The publication log. */
+    readonly facts: PublicationStore<never, never>;
+    /** The live-version view. */
+    readonly live: LiveView<LeafRow, InMemoryFollowing, never, never>;
+    /** The leaf's current-version view, with `draft` computed from the log. */
+    readonly leaves: LeafStore<LeafRow, InMemoryFollowing, never, never>;
+    /** Every fact, in record order. */
+    readonly recorded: () => ReadonlyArray<PublicationFact>;
+}
+/**
+ * The in-memory seams of a publish-gated leaf: the seam contracts (README →
+ * Seams → `PublicationStore`, `LiveView`). The effective fact is the last
+ * recorded one whose `at` has arrived at `now` (the Effect `Clock`'s when
+ * absent, so `TestClock` steers a schedule). A live row is the state at the
+ * effective fact's version, with that version as its `version`, the
+ * head's `action` and owner, `draft: false` and the fact's `at` as
+ * `publishedAt`; a head row's `draft`
+ * is whether the node has no live version. In memory only; not for
+ * production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryPublication: (options: {
+    readonly chain: InMemoryChainStore;
+    readonly leaves: InMemoryLeafStore;
+    readonly now?: Date | undefined;
+}) => InMemoryPublication;
+/**
+ * An in-memory {@link WorkingCopyStore}, plus the hook a test reads it
+ * through. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryWorkingCopyStore extends WorkingCopyStore<never, never> {
+    /** Every copy, keyed `id:userId`. */
+    readonly copies: () => HashMap.HashMap<string, WorkingCopy>;
+}
+/**
+ * An in-memory {@link WorkingCopyStore}: the seam's contract (README →
+ * Seams → `WorkingCopyStore`), one copy per `(id, userId)`. In memory only;
+ * not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryWorkingCopyStore: () => InMemoryWorkingCopyStore;
+/**
+ * Options for {@link makeInMemoryPurgeStore}.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryPurgeStoreOptions {
+    /**
+     * Every chain whose version rows may reference a document or bytes: the
+     * purged node's rows are erased from each, and a hash is unreferenced when
+     * no row left in any of them carries it.
+     */
+    readonly chains: ReadonlyArray<InMemoryChainStore>;
+    /** The documents an unreferenced hash is deleted from; omitted, none is deleted (or reported). */
+    readonly documents?: Pick<InMemoryDocumentStore<Schema.Json>, "remove"> | undefined;
+    /** The state columns that carry a `DocumentHash`; omitted, none do. */
+    readonly documentColumns?: ReadonlyArray<string> | undefined;
+    /** The state columns that carry a `ContentHash` (a file leaf's `contentHash`); omitted, none do. */
+    readonly blobColumns?: ReadonlyArray<string> | undefined;
+    /**
+     * What else `eraseNode` deletes for the node: the rows other fakes keep
+     * for it (an owner stamp through `InMemoryLeafStore.dropOwner`, working
+     * copies, edges, …), as a real store's `ON DELETE CASCADE` would.
+     */
+    readonly dependents?: ReadonlyArray<(id: string) => void> | undefined;
+}
+/**
+ * An in-memory {@link PurgeStore} over in-memory chains and a document
+ * store: the seam's contract (README → Seams → `PurgeStore`). `eraseNode`
+ * erases the node's rows from every chain and runs the `dependents`;
+ * a hash is referenced while any row left in any chain carries it in a
+ * declared column. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryPurgeStore: (options: InMemoryPurgeStoreOptions) => PurgeStore<never, never>;
+/**
+ * An in-memory {@link SearchBranch} over `rows`: each row the scope admits
+ * (evaluated at `now` over {@link InMemoryFollowing}) and `score` gives a
+ * score for the query is a hit, best score first, ties by id, at most
+ * `request.limit`. The reference semantics of the branch contract: it
+ * applies the scope it is handed in the same pass that ranks.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemorySearchBranch: (options: {
+    readonly name: string;
+    readonly weight?: number | undefined;
+    readonly rows: () => ReadonlyArray<FilterRow & {
+        readonly id: string;
+    }>;
+    /** The row's score for `query`, or none when it doesn't match. */
+    readonly score: (row: FilterRow, query: string) => Option.Option<number>;
+    readonly now: Date;
+}) => SearchBranch<InMemoryFollowing, never, never>;
+/**
+ * Wrap a {@link SearchBranch} so it fails {@link SearchScopeLeak} when it
+ * returns a hit whose row (looked up in `rows` by id) the scope it was
+ * handed does not admit, or that `rows` lacks: the test seam an
+ * application wraps around its own SQL branches to prove each applies the
+ * scope (`SEC-AUTH-ENUM-001`).
+ *
+ * @since 0.1.0
+ */
+export declare const scopeCheckedBranch: <E, R>(branch: SearchBranch<InMemoryFollowing, E, R>, options: {
+    readonly rows: () => ReadonlyArray<FilterRow & {
+        readonly id: string;
+    }>;
+    readonly now: Date;
+}) => SearchBranch<InMemoryFollowing, E | SearchScopeLeak, R>;
+/**
+ * {@link makeInMemoryEmbeddingStore}'s fake: the seam plus test hooks.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryEmbeddingStore extends EmbeddingStore<never, never> {
+    /** The queued hashes, in queue order. */
+    readonly queued: () => ReadonlyArray<DocumentHash>;
+    /** The written vectors, by hash. */
+    readonly vectors: () => HashMap.HashMap<DocumentHash, ReadonlyArray<number>>;
+}
+/**
+ * An in-memory {@link EmbeddingStore}: a queue in insertion order
+ * (`enqueue` is idempotent, and a hash with a vector is never queued again),
+ * `pending` the oldest `limit` queued, `write` storing each vector and
+ * dequeuing it, and `discard` dequeuing.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryEmbeddingStore: () => InMemoryEmbeddingStore;
+/**
+ * One write {@link makeInMemoryWriteCountStore} has recorded.
+ *
+ * @since 0.1.0
+ */
+export interface RecordedWrite {
+    readonly type: string;
+    readonly action: string;
+    readonly accountId: string;
+    readonly at: Date;
+}
+/**
+ * An in-memory atomic {@link BudgetCounter}, plus the hook a test reads it
+ * through. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryBudgetCounter extends BudgetCounter<never, never> {
+    /** Every spend it admitted, in order. */
+    readonly spends: () => ReadonlyArray<BudgetRequest>;
+}
+/**
+ * An in-memory atomic {@link BudgetCounter} (README → Seams →
+ * `BudgetCounter`): it counts the spends it admitted at or after the
+ * request's `since`, and records a spend only when it answers `true`. One
+ * JavaScript thread makes its check-and-record atomic. In memory only; not
+ * for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryBudgetCounter: () => InMemoryBudgetCounter;
+/**
+ * An in-memory {@link WriteCountStore}, plus `record`, the row a write
+ * inserts. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryWriteCountStore extends WriteCountStore<never, never> {
+    /** Record one write, as the family's own row would. */
+    readonly record: (write: RecordedWrite) => void;
+}
+/**
+ * An in-memory {@link WriteCountStore} (README → Seams →
+ * `WriteCountStore`): `countSince` counts the recorded writes of the key at
+ * or after `since`. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryWriteCountStore: () => InMemoryWriteCountStore;
+/**
+ * {@link makeInMemoryReactionStore}'s fake: the seam plus a test hook.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryReactionStore extends ReactionStore<never, never> {
+    /** Every stored reaction. */
+    readonly rows: () => ReadonlyArray<ReactionRow>;
+}
+/**
+ * An in-memory {@link ReactionStore}, keyed `(nodeId, accountId)` as the
+ * real table is: `upsert` replaces, `tally` groups by node and kind,
+ * `byAccount` is newest first (`nodeId` breaking a tie).
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryReactionStore: () => InMemoryReactionStore;
+/**
+ * {@link makeInMemoryVersionedKv}'s fake: the seam plus test hooks.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryVersionedKv extends VersionedKv<never, never> {
+    /** The stored entry at `key` with its expiry instant (ms), expired or not. */
+    readonly peek: (key: string) => Option.Option<KvEntry & {
+        readonly expiresAt: number;
+    }>;
+    /** Overwrite `key` unconditionally (a corrupt or foreign value, for a decode test). */
+    readonly poke: (key: string, entry: KvEntry) => void;
+}
+/**
+ * An in-memory {@link VersionedKv}: `putIfNotBehind` compares and writes in
+ * one step, and an entry past its TTL reads as absent (the Effect `Clock`,
+ * so `TestClock` steers expiry). In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryVersionedKv: () => InMemoryVersionedKv;
+/**
+ * {@link makeInMemoryCollectionStore}'s fake: the seam plus a test hook.
+ *
+ * @since 0.1.0
+ */
+export interface InMemoryCollectionStore extends CollectionStore<never, never> {
+    /** Every parent's entries, as stored. */
+    readonly rows: () => HashMap.HashMap<string, ReadonlyArray<CollectionEntry>>;
+}
+/**
+ * An in-memory {@link CollectionStore}: each parent's entries, replaced
+ * whole, read back by position then member id. In memory only; not for
+ * production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemoryCollectionStore: () => InMemoryCollectionStore;
+/**
+ * {@link makeInMemorySocialStore}'s fake: the seam plus a test hook.
+ *
+ * @since 0.1.0
+ */
+export interface InMemorySocialStore extends SocialStore<InMemoryFollowing, never, never> {
+    /** Every stored relationship. */
+    readonly rows: () => ReadonlyArray<Relationship>;
+}
+/**
+ * An in-memory {@link SocialStore}, keyed `(kind, from, to)` as the real
+ * table is; `followingOf` and `silencedBy` return {@link InMemoryFollowing}
+ * sets, where SQL's are subqueries. `addFollow` and `addBlock` each run as
+ * one synchronous step, so they are atomic against each other as the seam
+ * requires. In memory only; not for production.
+ *
+ * @since 0.1.0
+ */
+export declare const makeInMemorySocialStore: () => InMemorySocialStore;
+export {};
+//# sourceMappingURL=testing.d.ts.map