@thomasfosterau/pulpit 0.0.0-stage → 0.1.0

package/dist/testing.js

@@ -0,0 +1,1022 @@
+/**
+ * **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 Arr from "effect/Array";
+import * as Clock from "effect/Clock";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as HashMap from "effect/HashMap";
+import * as HashSet from "effect/HashSet";
+import * as Option from "effect/Option";
+import * as Order from "effect/Order";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+import * as Schema from "effect/Schema";
+import { sha256Hex } from "./blobs.js";
+import { canonicalText } from "./documents.js";
+import { endpointColumn, } from "./edges.js";
+import { evaluate, LOCALE_COLUMN, } from "./filter.js";
+import { byCodePoint, rowOrder } from "./internal/list-order.js";
+import { SearchScopeLeak, } from "./search.js";
+import { PathTaken } from "./paths.js";
+import { localesOf, VersionConflict, } from "./version-chain.js";
+/** The instant a fake's `published` / `notPublished` compare against: the fixed `now`, else the Effect `Clock`'s. */
+const instantOf = (now) => Option.match(now, {
+    onNone: () => Effect.map(Clock.currentTimeMillis, (millis) => DateTime.toDate(DateTime.makeUnsafe(millis))),
+    onSome: Effect.succeed,
+});
+/** The list filter's evaluation context at `now`, over an {@link InMemoryFollowing} set. */
+const contextAt = (now) => ({
+    now,
+    contains: (set, value) => Predicate.isString(value) && HashSet.has(set, value),
+});
+/**
+ * A node's rows in a localised view (pulpit#56): one per locale its version
+ * carries, the locale's columns over the shared row and the tag in
+ * {@link LOCALE_COLUMN}; a version carrying none is its shared row alone,
+ * the `NULL`-locale row a left join gives.
+ */
+const localeRows = (row, locales) => Record.isEmptyRecord(locales)
+    ? [row]
+    : Arr.map(Record.toEntries(locales), ([tag, columns]) => ({
+        ...row,
+        ...columns,
+        [LOCALE_COLUMN]: tag,
+    }));
+/** The locale level of `id` at `version` in an in-memory chain, `{}` for none. */
+const localesAt = (chain, id, version) => Option.match(Arr.findFirst(chain.rows(), (row) => row.id === id && row.version === version), { onNone: () => ({}), onSome: localesOf });
+/**
+ * The distinct string values of `column` among the rows matching `where` at
+ * `now`, in code-point order, paged: `LeafStore.distinct`'s contract.
+ */
+const distinctPage = (rows, query, now) => {
+    const values = Arr.sort(Arr.dedupe(Arr.flatMap(rows, (row) => {
+        const value = row[query.column];
+        return evaluate(query.where, row, contextAt(now)) && Predicate.isString(value)
+            ? [value]
+            : [];
+    })), byCodePoint);
+    return {
+        rows: values.slice(query.offset, query.offset + query.limit),
+        total: values.length,
+    };
+};
+/** A view page: the rows matching `where` at `now`, in the list order contract's order. */
+const viewPage = (rows, query, now) => {
+    const matching = Arr.sort(rows.filter((row) => evaluate(query.where, row, contextAt(now))), rowOrder(query.orderBy));
+    return {
+        rows: matching.slice(query.offset, query.offset + query.limit),
+        total: matching.length,
+    };
+};
+/**
+ * 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 const makeInMemoryFollowers = (table) => {
+    const follows = HashMap.fromIterable(table);
+    const followedBy = (followerId) => Option.getOrElse(HashMap.get(follows, followerId), Arr.empty);
+    return {
+        isFollower: (followerId, ownerId) => Effect.succeed(followedBy(followerId).includes(ownerId)),
+        following: (followerId) => HashSet.fromIterable(followedBy(followerId)),
+    };
+};
+/**
+ * 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 const makeInMemoryChainStore = () => {
+    let log = [];
+    let dropped = HashSet.empty();
+    let raced = HashSet.empty();
+    let minted = 0;
+    const key = (id, version) => `${id}@${version}`;
+    const chain = (id) => log.filter((row) => row.id === id);
+    const entryOf = (row) => ({
+        version: row.version,
+        action: row.action,
+        timestamp: row.timestamp,
+    });
+    /** Whether the next append for `id` is raced, consuming the race. */
+    const takeRace = (id) => {
+        const wasRaced = HashSet.has(raced, id);
+        raced = HashSet.remove(raced, id);
+        return wasRaced;
+    };
+    return {
+        head: (id) => Effect.sync(() => Option.map(Arr.last(chain(id)), entryOf)),
+        snapshot: (id, version) => Effect.sync(() => HashSet.has(dropped, key(id, version))
+            ? Option.none()
+            : Option.map(Arr.findFirst(chain(id), (candidate) => candidate.version === version), (row) => row.locales === undefined
+                ? { ...entryOf(row), state: row.state }
+                : { ...entryOf(row), state: row.state, locales: row.locales })),
+        append: (row) => Effect.suspend(() => {
+            if (takeRace(row.id) || chain(row.id).some((taken) => taken.version === row.version)) {
+                return Effect.fail(new VersionConflict({ id: row.id, version: row.version }));
+            }
+            log = [...log, row];
+            return Effect.void;
+        }),
+        entries: (id, limit) => Effect.sync(() => chain(id).slice(0, limit).map(entryOf)),
+        mintId: Effect.sync(() => {
+            minted += 1;
+            return `00000000-0000-4000-8000-${String(minted).padStart(12, "0")}`;
+        }),
+        rows: () => log,
+        dropState: (id, version) => {
+            dropped = HashSet.add(dropped, key(id, version));
+        },
+        raceNextAppend: (id) => {
+            raced = HashSet.add(raced, id);
+        },
+        erase: (id) => {
+            const erased = chain(id);
+            log = log.filter((row) => row.id !== id);
+            return erased;
+        },
+    };
+};
+/**
+ * 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 const makeInMemoryLeafStore = (chain, options) => {
+    const fixedNow = Option.fromNullishOr(options.now);
+    let owners = HashMap.empty();
+    const headOf = (row) => {
+        const base = { ...row.state, id: row.id, version: row.version, action: row.action };
+        return Option.match(HashMap.get(owners, row.id), {
+            onNone: () => base,
+            onSome: (ownerId) => ({ ...base, ownerId }),
+        });
+    };
+    /** The rows `list` reads: one per `(id, locale)` on a localised view. */
+    const listed = () => options.localised === true
+        ? Arr.flatMap(view(), (row) => localeRows(row, localesAt(chain, row.id, row.version)))
+        : view();
+    const view = () => Arr.sort(HashMap.toValues(Arr.reduce(chain.rows(), HashMap.empty(), (heads, row) => HashMap.set(heads, row.id, headOf(row)))), rowOrder([]));
+    return {
+        // oxlint-disable-next-line effect/avoid-native-object-helpers -- the seam's column set is the native `ReadonlySet` `LeafStore.columns` names
+        columns: new Set([
+            "id",
+            "version",
+            "action",
+            "ownerId",
+            ...options.columns,
+            ...(options.localised === true ? [LOCALE_COLUMN] : []),
+        ]),
+        get: (id) => Effect.sync(() => Arr.findFirst(view(), (row) => row.id === id)),
+        getMany: (ids) => Effect.sync(() => view().filter((row) => ids.includes(row.id))),
+        list: (query) => Effect.map(instantOf(fixedNow), (now) => viewPage(listed(), query, now)),
+        distinct: (query) => Effect.map(instantOf(fixedNow), (now) => distinctPage(listed(), query, now)),
+        ownerOf: (id) => Effect.sync(() => HashMap.get(owners, id)),
+        stampOwner: (id, ownerId) => Effect.sync(() => {
+            owners = HashMap.set(owners, id, ownerId);
+        }),
+        owners: () => owners,
+        dropOwner: (id) => {
+            owners = HashMap.remove(owners, id);
+        },
+    };
+};
+/**
+ * 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 const makeInMemoryPathStore = () => {
+    let entries = HashMap.empty();
+    const canonicalOf = (nodeId) => Option.map(Arr.findFirst(HashMap.toEntries(entries), ([, entry]) => entry.canonical && entry.nodeId === nodeId), ([path]) => path);
+    return {
+        lookup: (path) => Effect.sync(() => HashMap.get(entries, path)),
+        canonicalOf: (nodeId) => Effect.sync(() => canonicalOf(nodeId)),
+        claim: (nodeId, path) => Effect.suspend(() => {
+            const held = HashMap.get(entries, path);
+            if (Option.exists(held, (entry) => entry.canonical && entry.nodeId !== nodeId)) {
+                return Effect.fail(new PathTaken({ path }));
+            }
+            entries = Option.match(canonicalOf(nodeId), {
+                onNone: () => entries,
+                onSome: (previous) => HashMap.set(entries, previous, { nodeId, canonical: false }),
+            });
+            entries = HashMap.set(entries, path, { nodeId, canonical: true });
+            return Effect.void;
+        }),
+        release: (nodeId) => Effect.sync(() => {
+            entries = Option.match(canonicalOf(nodeId), {
+                onNone: () => entries,
+                onSome: (path) => HashMap.remove(entries, path),
+            });
+        }),
+        entries: () => entries,
+    };
+};
+/**
+ * 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 const makeInMemoryResourceCache = (serveable) => {
+    let entries = HashMap.empty();
+    const versionOf = (id) => Option.map(HashMap.get(entries, id), (entry) => entry.version);
+    const behind = (id, version) => Option.exists(versionOf(id), (held) => version < held);
+    return {
+        set: (id, resource, version) => Effect.sync(() => {
+            if (behind(id, version))
+                return;
+            entries = HashMap.set(entries, id, {
+                version,
+                resource: serveable(resource) ? Option.some(resource) : Option.none(),
+            });
+        }),
+        delete: (id, version) => Effect.sync(() => {
+            if (behind(id, version))
+                return;
+            entries = HashMap.set(entries, id, { version, resource: Option.none() });
+        }),
+        get: (id) => Option.flatMap(HashMap.get(entries, id), (entry) => entry.resource),
+        versionOf,
+    };
+};
+// ── Documents ─────────────────────────────────────────────────────────
+const utf8 = new TextEncoder();
+/** SHA-256 over the canonical text's UTF-8 bytes, as 64 lowercase hex characters. */
+const hashOf = (document) => sha256Hex(utf8.encode(canonicalText(document)));
+/**
+ * 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 const makeInMemoryDocumentStore = () => {
+    let documents = HashMap.empty();
+    let writes = 0;
+    return {
+        put: (document) => Effect.map(hashOf(document), (hash) => {
+            // `ON CONFLICT DO NOTHING`: the first document at a hash is kept.
+            const inserted = !HashMap.has(documents, hash);
+            if (inserted) {
+                documents = HashMap.set(documents, hash, document);
+                writes += 1;
+            }
+            return { hash, inserted };
+        }),
+        get: (hash) => Effect.sync(() => HashMap.get(documents, hash)),
+        getMany: (hashes) => Effect.sync(() => HashMap.filter(documents, (_document, hash) => hashes.includes(hash))),
+        stored: () => documents,
+        writes: () => writes,
+        remove: (hashes) => {
+            documents = HashMap.filter(documents, (_document, hash) => !hashes.includes(hash));
+        },
+    };
+};
+/**
+ * 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 const makeInMemoryNodes = (columns) => {
+    let nodes = HashMap.empty();
+    return {
+        // oxlint-disable-next-line effect/avoid-native-object-helpers -- the seam's column set is a `ReadonlySet`, the type `LeafStore.columns` already has, so a `LeafStore` satisfies `EndpointView`
+        columns: new Set(["id", "version", "action", ...columns]),
+        get: (id) => Effect.sync(() => HashMap.get(nodes, id)),
+        put: (row) => {
+            nodes = HashMap.set(nodes, row.id, row);
+        },
+    };
+};
+/** Two column values the unique key treats as equal: `NULLS NOT DISTINCT`, an absent key read as `NULL`. */
+const sameKey = (row, values, column) => (row[column] ?? null) === (values[column] ?? null);
+/** The edge list's total order: `createdAt`, then `id`. */
+const byCreation = Order.combine(Order.mapInput(Order.Date, (row) => row.createdAt), Order.mapInput(Order.String, (row) => row.id));
+/**
+ * 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 const makeInMemoryEdgeStore = (options) => {
+    const fixedNow = Option.fromNullishOr(options.now);
+    let stored = [];
+    let minted = 0;
+    let race = Option.none();
+    const collides = (values) => Arr.findFirst(stored, (row) => Arr.isReadonlyArrayNonEmpty(options.uniqueKey) &&
+        options.uniqueKey.every((column) => sameKey(row, values, column)));
+    const write = (values, now) => {
+        minted += 1;
+        const id = `edge-${String(minted).padStart(4, "0")}`;
+        const createdAt = DateTime.toDate(DateTime.makeUnsafe(now.getTime() + minted - (minted % 3 === 0 ? 1 : 0)));
+        stored = [...stored, { ...values, id, createdAt }];
+        return id;
+    };
+    /** The edge joined with each end's node under its alias, or none when an end has no row (INNER JOIN). */
+    const joined = (row) => Effect.map(Effect.forEach(Record.toEntries(options.ends), ([alias, end]) => {
+        const nodeId = row[end.column];
+        return Predicate.isString(nodeId)
+            ? Effect.map(end.nodes.get(nodeId), Option.map((node) => Record.mapKeys(node, (column) => endpointColumn(alias, column))))
+            : Effect.succeedNone;
+    }, { concurrency: 1 }), (nodes) => Option.map(Option.all(nodes), (all) => Object.assign({}, row, ...all)));
+    /** The stored edges whose join satisfies `where`, in the list's total order. */
+    const matching = (where) => Effect.flatMap(instantOf(fixedNow), (now) => Effect.filter(Arr.sort(stored, byCreation), (row) => Effect.map(joined(row), Option.exists((present) => evaluate(where, present, contextAt(now))))));
+    return {
+        get: (id) => Effect.sync(() => Arr.findFirst(stored, (row) => row.id === id)),
+        // The total as the SQL store's window column reads it: every matching
+        // row when the page has one, and 0 for an empty page (past the end too).
+        list: ({ where, limit, offset }) => Effect.map(matching(where), (rows) => {
+            const page = rows.slice(offset, offset + limit);
+            return { rows: page, total: Arr.isReadonlyArrayNonEmpty(page) ? rows.length : 0 };
+        }),
+        // The count over the list's joins, as the SQL store's `count(*)` reads
+        // them: the edges at the node that satisfy `where`.
+        countAt: ({ column, nodeId, where }) => Effect.map(matching(where), (rows) => rows.filter((row) => row[column] === nodeId).length),
+        existing: (values) => Effect.sync(() => Option.map(collides(values), (row) => row.id)),
+        insert: (values) => Effect.map(instantOf(fixedNow), (now) => {
+            if (Option.isSome(race)) {
+                write(race.value, now);
+                race = Option.none();
+                return Option.none();
+            }
+            return Option.isSome(collides(values)) ? Option.none() : Option.some(write(values, now));
+        }),
+        delete: (id) => Effect.sync(() => {
+            const before = stored.length;
+            stored = stored.filter((row) => row.id !== id);
+            return stored.length < before;
+        }),
+        closeValidity: (id, column, to) => Effect.sync(() => {
+            const found = stored.some((row) => row.id === id);
+            stored = stored.map((row) => (row.id === id ? { ...row, [column]: to } : row));
+            return found;
+        }),
+        // The SQL store's subquery, computed eagerly over the list's joins: the
+        // member end's ids of the edges whose other end is named and that
+        // satisfy `where`. A non-string member id is never in the set.
+        members: ({ column, otherColumn, ids, where }) => Effect.map(matching(where), (rows) => HashSet.fromIterable(Arr.flatMap(rows, (row) => {
+            const member = row[column];
+            const other = row[otherColumn];
+            return Predicate.isString(member) && Predicate.isString(other) && ids.includes(other)
+                ? [member]
+                : [];
+        }))),
+        // The SQL store's grouped count over the list's joins: per requested
+        // node, the edges at it that satisfy `where`; a node with none, no key.
+        countBy: ({ column, ids, where }) => Effect.map(matching(where), (rows) => Arr.reduce(rows, HashMap.empty(), (counts, row) => {
+            const node = row[column];
+            return Predicate.isString(node) && ids.includes(node)
+                ? HashMap.set(counts, node, Option.getOrElse(HashMap.get(counts, node), () => 0) + 1)
+                : counts;
+        })),
+        rows: () => stored,
+        raceNextInsert: (winner) => {
+            race = Option.some(winner);
+        },
+    };
+};
+/**
+ * The table both plain-row fakes keep: insert order, sequential UUID-shaped
+ * ids under `prefix`, `close` on an `open`-status row only, and a page
+ * newest first by `at`, `id` descending on a tie, evaluated in memory.
+ */
+const plainRowTable = (options) => {
+    let rows = [];
+    let minted = 0;
+    const newestFirst = Order.combine(Order.flip(Order.mapInput(Order.Date, options.at)), Order.flip(Order.mapInput(Order.String, (row) => row.id)));
+    // No plain-row column is a publication stamp, so `now` is never read.
+    const context = {
+        now: DateTime.toDate(DateTime.makeUnsafe(0)),
+        contains: () => false,
+    };
+    const find = (id) => Arr.findFirst(rows, (row) => row.id === id);
+    return {
+        rows: () => rows,
+        find,
+        mintId: Effect.sync(() => {
+            minted += 1;
+            return `00000000-0000-4000-${options.prefix}-${String(minted).padStart(12, "0")}`;
+        }),
+        insert: (row) => Effect.sync(() => {
+            rows = [...rows, row];
+        }),
+        lock: (id) => Effect.sync(() => find(id)),
+        close: (id, closed) => Effect.sync(() => {
+            rows = Arr.map(rows, (row) => row.id === id && row.status === options.open ? closed(row) : row);
+        }),
+        matching: (where) => Arr.sort(Arr.filter(rows, (row) => evaluate(where, options.filterRow(row), context)), newestFirst),
+    };
+};
+/**
+ * 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 const makeInMemoryProposalStore = (options) => {
+    const table = plainRowTable({
+        prefix: "9000",
+        open: "pending",
+        at: (row) => row.submittedAt,
+        filterRow: (row) => ({
+            id: row.id,
+            authorId: row.authorId,
+            targetId: row.targetId,
+            targetType: row.targetType,
+            status: row.status,
+            submittedAt: row.submittedAt,
+            targetOwnerId: Option.getOrElse(HashMap.get(options.leaves.owners(), row.targetId), () => null),
+        }),
+    });
+    const listingOf = (row) => Effect.map(options.chain.head(row.targetId), (head) => ({
+        row,
+        targetVersion: Option.map(head, (entry) => entry.version),
+    }));
+    return {
+        mintId: table.mintId,
+        insert: table.insert,
+        get: (id) => Effect.suspend(() => Option.match(table.find(id), {
+            onNone: () => Effect.succeedNone,
+            onSome: (row) => Effect.asSome(listingOf(row)),
+        })),
+        lock: table.lock,
+        close: (id, decision) => table.close(id, (row) => ({
+            ...row,
+            status: decision.status,
+            decidedAt: Option.some(decision.decidedAt),
+            decidedBy: Option.some(decision.decidedBy),
+            decisionNote: decision.decisionNote,
+            appliedVersion: decision.appliedVersion,
+        })),
+        list: ({ where, limit, offset }) => Effect.suspend(() => {
+            const matching = table.matching(where);
+            return Effect.map(Effect.forEach(matching.slice(offset, offset + limit), listingOf, { concurrency: 1 }), (page) => ({ rows: page, total: matching.length }));
+        }),
+        rows: table.rows,
+    };
+};
+/**
+ * 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 const makeInMemoryReportStore = () => {
+    const table = plainRowTable({
+        prefix: "a000",
+        open: "open",
+        at: (row) => row.filedAt,
+        filterRow: (row) => ({
+            id: row.id,
+            reporterId: row.reporterId,
+            targetId: row.targetId,
+            targetType: row.targetType,
+            status: row.status,
+        }),
+    });
+    return {
+        mintId: table.mintId,
+        insert: table.insert,
+        get: (id) => Effect.sync(() => table.find(id)),
+        lock: table.lock,
+        close: (id, resolution) => table.close(id, (row) => ({
+            ...row,
+            status: resolution.status,
+            resolvedAt: Option.some(resolution.resolvedAt),
+            resolvedBy: Option.some(resolution.resolvedBy),
+            resolutionNote: resolution.resolutionNote,
+        })),
+        list: ({ where, limit, offset }) => Effect.sync(() => {
+            const matching = table.matching(where);
+            return { rows: matching.slice(offset, offset + limit), total: matching.length };
+        }),
+        rows: table.rows,
+    };
+};
+// ── Blobs ─────────────────────────────────────────────────────────────
+/**
+ * The in-memory blob store's one failure: a simulated outage.
+ *
+ * @since 0.1.0
+ */
+export class InMemoryBlobFailure extends Schema.TaggedError()("InMemoryBlobFailure", { key: Schema.String }) {
+}
+/**
+ * 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 const makeInMemoryBlobStore = () => {
+    let objects = HashMap.empty();
+    let failing = false;
+    return {
+        put: (key, bytes, head) => Effect.suspend(() => {
+            if (failing) {
+                failing = false;
+                return Effect.fail(new InMemoryBlobFailure({ key }));
+            }
+            objects = HashMap.set(objects, key, { bytes: Uint8Array.from(bytes), head });
+            return Effect.void;
+        }),
+        get: (key) => Effect.sync(() => Option.map(HashMap.get(objects, key), (object) => object.bytes)),
+        head: (key) => Effect.sync(() => Option.map(HashMap.get(objects, key), (object) => object.head)),
+        delete: (key) => Effect.sync(() => {
+            objects = HashMap.remove(objects, key);
+        }),
+        publicUrl: (key) => Option.some(`memory://${key}`),
+        signedUploadUrl: Option.none(),
+        objects: () => objects,
+        failNextPut: () => {
+            failing = true;
+        },
+    };
+};
+/**
+ * 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 const makeInMemoryPublication = (options) => {
+    const fixedNow = Option.fromNullishOr(options.now);
+    const localised = options.leaves.columns.has(LOCALE_COLUMN);
+    /** A row as a localised view lists it: one per locale its version carries. */
+    const listed = (row) => localised ? localeRows(row, localesAt(options.chain, row.id, row.version)) : [row];
+    let log = [];
+    const effectiveAt = (id, now) => Arr.findLast(log, (fact) => fact.id === id && fact.at.getTime() <= now.getTime());
+    const liveVersion = (id, now) => Option.flatMap(effectiveAt(id, now), (fact) => Option.map(fact.version, (version) => ({ version, at: fact.at })));
+    const liveOf = (head, now) => Option.flatMap(liveVersion(head.id, now), ({ version, at }) => Option.map(Arr.findFirst(options.chain.rows(), (row) => row.id === head.id && row.version === version), (row) => {
+        const base = {
+            ...row.state,
+            id: head.id,
+            version,
+            action: head.action,
+            draft: false,
+            publishedAt: at,
+        };
+        return Option.match(Option.fromUndefinedOr(head["ownerId"]), {
+            onNone: () => base,
+            onSome: (ownerId) => ({ ...base, ownerId }),
+        });
+    }));
+    const headOf = (head, now) => ({
+        ...head,
+        draft: Option.isNone(liveVersion(head.id, now)),
+    });
+    const atNow = (read) => Effect.flatMap(instantOf(fixedNow), read);
+    const heads = () => options.leaves.getMany(Arr.dedupe(Arr.map(options.chain.rows(), (row) => row.id)));
+    /** The rows a live list reads: per node, its head for `headFor`, else its live row, else none. */
+    const chosen = (headFor, now) => Effect.map(heads(), (rows) => Arr.flatMap(Arr.getSomes(Arr.map(rows, (head) => evaluate(headFor, head, contextAt(now))
+        ? Option.some(headOf(head, now))
+        : liveOf(head, now))), listed));
+    const facts = {
+        record: (fact) => Effect.sync(() => {
+            log = [...log, fact];
+        }),
+        effective: (id) => Effect.map(instantOf(fixedNow), (now) => effectiveAt(id, now)),
+        facts: (id, limit) => Effect.sync(() => log.filter((fact) => fact.id === id).slice(0, limit)),
+    };
+    const live = {
+        get: (id) => atNow((now) => Effect.map(options.leaves.get(id), (head) => Option.flatMap(head, (row) => liveOf(row, now)))),
+        getMany: (ids) => atNow((now) => Effect.map(options.leaves.getMany(ids), (rows) => Arr.getSomes(Arr.map(rows, (row) => liveOf(row, now))))),
+        list: (query) => atNow((now) => Effect.map(chosen(query.headFor, now), (rows) => viewPage(rows, query, now))),
+        distinct: (query) => atNow((now) => Effect.map(chosen(query.headFor, now), (rows) => distinctPage(rows, query, now))),
+    };
+    const leaves = {
+        ...options.leaves,
+        get: (id) => atNow((now) => Effect.map(options.leaves.get(id), (head) => Option.map(head, (row) => headOf(row, now)))),
+        getMany: (ids) => atNow((now) => Effect.map(options.leaves.getMany(ids), (rows) => Arr.map(rows, (row) => headOf(row, now)))),
+        list: (query) => atNow((now) => Effect.map(heads(), (rows) => viewPage(Arr.flatMap(rows, (row) => listed(headOf(row, now))), query, now))),
+        distinct: (query) => atNow((now) => Effect.map(heads(), (rows) => distinctPage(Arr.flatMap(rows, (row) => listed(headOf(row, now))), query, now))),
+    };
+    return { facts, live, leaves, recorded: () => log };
+};
+/**
+ * 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 const makeInMemoryWorkingCopyStore = () => {
+    let copies = HashMap.empty();
+    const keyOf = (key) => `${key.id}:${key.userId}`;
+    return {
+        put: (key, copy) => Effect.sync(() => {
+            copies = HashMap.set(copies, keyOf(key), copy);
+        }),
+        get: (key) => Effect.sync(() => HashMap.get(copies, keyOf(key))),
+        discard: (key) => Effect.sync(() => {
+            copies = HashMap.remove(copies, keyOf(key));
+        }),
+        copies: () => copies,
+    };
+};
+/** The string values `columns` hold across `rows`, each once. */
+const hashesIn = (rows, columns) => Arr.dedupe(Arr.flatMap(rows, (row) => Arr.flatMap(columns, (column) => {
+    const value = row.state[column];
+    return Predicate.isString(value) ? [value] : [];
+})));
+/**
+ * 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 const makeInMemoryPurgeStore = (options) => {
+    const documentColumns = options.documentColumns ?? [];
+    const blobColumns = options.blobColumns ?? [];
+    const remaining = () => Arr.flatMap(options.chains, (chain) => chain.rows());
+    const unreferenced = (hashes, columns) => {
+        const referenced = hashesIn(remaining(), columns);
+        return hashes.filter((hash) => !referenced.includes(hash));
+    };
+    return {
+        eraseNode: (id) => Effect.sync(() => {
+            const erased = Arr.flatMap(options.chains, (chain) => chain.erase(id));
+            Arr.forEach(options.dependents ?? [], (dependent) => dependent(id));
+            return {
+                documents: hashesIn(erased, documentColumns),
+                blobs: hashesIn(erased, blobColumns),
+            };
+        }),
+        deleteUnreferencedDocuments: (hashes) => Effect.sync(() => {
+            if (options.documents === undefined)
+                return [];
+            const deleted = unreferenced(hashes, documentColumns);
+            options.documents.remove(deleted);
+            return deleted;
+        }),
+        unreferencedBlobs: (hashes) => Effect.sync(() => unreferenced(hashes, blobColumns)),
+    };
+};
+/** Best score first, ties by id in code-point order. */
+const scoredOrder = Order.combine(Order.mapInput(Order.flip(Order.Number), (hit) => hit.score), Order.mapInput(byCodePoint, (hit) => hit.row.id));
+/**
+ * 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 const makeInMemorySearchBranch = (options) => ({
+    name: options.name,
+    weight: options.weight,
+    search: (request) => Effect.sync(() => Arr.take(Arr.sort(Arr.getSomes(Arr.map(Arr.filter(options.rows(), (row) => evaluate(request.scope, row, contextAt(options.now))), (row) => Option.map(options.score(row, request.query), (score) => ({ row, score })))), scoredOrder).map(({ row }) => ({ id: row.id })), Math.max(0, request.limit))),
+});
+/**
+ * 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 const scopeCheckedBranch = (branch, options) => ({
+    ...branch,
+    search: (request) => Effect.flatMap(branch.search(request), (hits) => {
+        const byId = HashMap.fromIterable(Arr.map(options.rows(), (row) => [row.id, row]));
+        const leak = Arr.findFirst(hits, (hit) => !Option.exists(HashMap.get(byId, hit.id), (row) => evaluate(request.scope, row, contextAt(options.now))));
+        return Option.match(leak, {
+            onNone: () => Effect.succeed(hits),
+            onSome: (hit) => Effect.fail(new SearchScopeLeak({ branch: branch.name, id: hit.id })),
+        });
+    }),
+});
+/**
+ * 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 const makeInMemoryEmbeddingStore = () => {
+    let queue = [];
+    let vectors = HashMap.empty();
+    const dequeue = (hashes) => {
+        queue = Arr.filter(queue, (hash) => !Arr.contains(hashes, hash));
+    };
+    return {
+        enqueue: (hash) => Effect.sync(() => {
+            if (!Arr.contains(queue, hash) && !HashMap.has(vectors, hash))
+                queue = [...queue, hash];
+        }),
+        pending: (limit) => Effect.sync(() => Arr.take(queue, Math.max(0, limit))),
+        write: (written) => Effect.sync(() => {
+            vectors = Arr.reduce(written, vectors, (acc, { hash, vector }) => HashMap.set(acc, hash, vector));
+            dequeue(Arr.map(written, ({ hash }) => hash));
+        }),
+        discard: (hashes) => Effect.sync(() => dequeue(hashes)),
+        queued: () => queue,
+        vectors: () => vectors,
+    };
+};
+const sameBudgetKey = (left, right) => left.type === right.type && left.action === right.action && left.accountId === right.accountId;
+/**
+ * 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 const makeInMemoryBudgetCounter = () => {
+    let spends = [];
+    return {
+        take: (request) => Effect.sync(() => {
+            const used = Arr.filter(spends, (spend) => sameBudgetKey(spend, request) && spend.now.getTime() >= request.since.getTime()).length;
+            if (used >= request.limit)
+                return false;
+            spends = [...spends, request];
+            return true;
+        }),
+        spends: () => spends,
+    };
+};
+/**
+ * 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 const makeInMemoryWriteCountStore = () => {
+    let writes = [];
+    return {
+        countSince: (query) => Effect.sync(() => Arr.filter(writes, (write) => sameBudgetKey(write, query) && write.at.getTime() >= query.since.getTime()).length),
+        record: (write) => {
+            writes = [...writes, write];
+        },
+    };
+};
+/**
+ * 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 const makeInMemoryReactionStore = () => {
+    let rows = [];
+    const same = (nodeId, accountId) => (row) => row.nodeId === nodeId && row.accountId === accountId;
+    const newestFirst = Order.combine(Order.mapInput(Order.flip(Order.Number), (row) => row.reactedAt.getTime()), Order.mapInput(byCodePoint, (row) => row.nodeId));
+    return {
+        upsert: (row) => Effect.sync(() => {
+            const before = Arr.findFirst(rows, same(row.nodeId, row.accountId));
+            rows = [...Arr.filter(rows, (held) => !same(row.nodeId, row.accountId)(held)), row];
+            return Option.map(before, (held) => held.kind);
+        }),
+        delete: (nodeId, accountId) => Effect.sync(() => {
+            const before = rows.length;
+            rows = Arr.filter(rows, (held) => !same(nodeId, accountId)(held));
+            return rows.length < before;
+        }),
+        tally: (nodeIds) => Effect.sync(() => Arr.reduce(Arr.filter(rows, (row) => Arr.contains(nodeIds, row.nodeId)), HashMap.empty(), (acc, row) => {
+            const counts = Option.getOrElse(HashMap.get(acc, row.nodeId), () => ({}));
+            return HashMap.set(acc, row.nodeId, {
+                ...counts,
+                [row.kind]: Option.getOrElse(Record.get(counts, row.kind), () => 0) + 1,
+            });
+        })),
+        byAccount: ({ accountId, limit, offset }) => Effect.sync(() => Arr.sort(Arr.filter(rows, (row) => row.accountId === accountId), newestFirst).slice(offset, offset + limit)),
+        eraseAccount: (accountId) => Effect.sync(() => {
+            const before = rows.length;
+            rows = Arr.filter(rows, (row) => row.accountId !== accountId);
+            return before - rows.length;
+        }),
+        rows: () => rows,
+    };
+};
+/**
+ * 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 const makeInMemoryVersionedKv = () => {
+    let entries = HashMap.empty();
+    const live = (key, now) => Option.filter(HashMap.get(entries, key), (entry) => entry.expiresAt > now);
+    return {
+        get: (key) => Effect.map(Clock.currentTimeMillis, (now) => Option.map(live(key, now), ({ version, value }) => ({ version, value }))),
+        putIfNotBehind: (key, entry, ttlSeconds) => Effect.map(Clock.currentTimeMillis, (now) => {
+            if (Option.exists(live(key, now), (held) => held.version > entry.version))
+                return false;
+            entries = HashMap.set(entries, key, { ...entry, expiresAt: now + ttlSeconds * 1000 });
+            return true;
+        }),
+        peek: (key) => HashMap.get(entries, key),
+        poke: (key, entry) => {
+            entries = HashMap.set(entries, key, { ...entry, expiresAt: Number.POSITIVE_INFINITY });
+        },
+    };
+};
+/**
+ * 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 const makeInMemoryCollectionStore = () => {
+    let byParent = HashMap.empty();
+    const entryOrder = Order.combine(Order.mapInput(Order.Number, (entry) => entry.position), Order.mapInput(byCodePoint, (entry) => entry.memberId));
+    return {
+        entries: (parentId, limit) => Effect.sync(() => Arr.take(Arr.sort(Option.getOrElse(HashMap.get(byParent, parentId), Arr.empty), entryOrder), Math.max(0, limit))),
+        replace: (parentId, entries) => Effect.sync(() => {
+            byParent = HashMap.set(byParent, parentId, [...entries]);
+        }),
+        rows: () => byParent,
+    };
+};
+/**
+ * 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 const makeInMemorySocialStore = () => {
+    let rows = [];
+    const matches = (kind, from, to) => (row) => row.kind === kind && row.from === from && row.to === to;
+    const toIds = (from, kinds) => HashSet.fromIterable(Arr.map(Arr.filter(rows, (row) => row.from === from && kinds.includes(row.kind)), (row) => row.to));
+    const newestFirst = Order.combine(Order.mapInput(Order.flip(Order.Number), (row) => row.at.getTime()), Order.mapInput(byCodePoint, (row) => row.accountId));
+    return {
+        add: (relationship) => Effect.sync(() => {
+            if (rows.some(matches(relationship.kind, relationship.from, relationship.to)))
+                return false;
+            rows = [...rows, relationship];
+            return true;
+        }),
+        addFollow: (relationship) => Effect.sync(() => {
+            const { from, to } = relationship;
+            if (rows.some(matches("block", from, to)) || rows.some(matches("block", to, from))) {
+                return "blocked";
+            }
+            if (rows.some(matches("follow", from, to)))
+                return "present";
+            rows = [...rows, relationship];
+            return "added";
+        }),
+        addBlock: (relationship) => Effect.sync(() => {
+            const { from, to } = relationship;
+            const written = !rows.some(matches("block", from, to));
+            rows = [
+                ...Arr.filter(rows, (row) => !matches("follow", from, to)(row) && !matches("follow", to, from)(row)),
+                ...(written ? [relationship] : []),
+            ];
+            return written;
+        }),
+        remove: (kind, from, to) => Effect.sync(() => {
+            const before = rows.length;
+            rows = Arr.filter(rows, (row) => !matches(kind, from, to)(row));
+            return rows.length < before;
+        }),
+        has: (kind, from, to) => Effect.sync(() => rows.some(matches(kind, from, to))),
+        list: ({ kind, side, accountId, limit, offset }) => Effect.sync(() => {
+            const related = Arr.sort(Arr.map(Arr.filter(rows, (row) => row.kind === kind && row[side] === accountId), (row) => ({ accountId: side === "from" ? row.to : row.from, at: row.at })), newestFirst);
+            return { rows: related.slice(offset, offset + limit), total: related.length };
+        }),
+        isFollowing: (follower, followed) => Effect.sync(() => rows.some(matches("follow", follower, followed))),
+        followingOf: (follower) => toIds(follower, ["follow"]),
+        silencedBy: (viewer) => toIds(viewer, ["mute", "block"]),
+        eraseAccount: (accountId) => Effect.sync(() => {
+            const before = rows.length;
+            rows = Arr.filter(rows, (row) => row.from !== accountId && row.to !== accountId);
+            return before - rows.length;
+        }),
+        rows: () => rows,
+    };
+};
+//# sourceMappingURL=testing.js.map