@optimystic/db-core 0.22.0 → 0.24.0

package/src/reactivity/subscriber.ts

@@ -1,132 +1,132 @@
-/**
- * Reactivity — subscriber delivery path (`docs/reactivity.md` §Delivery).
- *
- * A subscriber receiving a notification:
- *  1. **verifies** `sig` against the cached tail-cohort `MembershipCertV1` (the {@link NotificationVerifier}
- *     owns the **one fetch-and-retry** on a stale cache);
- *  2. checks `revision == lastRevision + 1`. If not, requests a backfill for the gap
- *     `[lastRevision + 1, revision]` via the {@link requestBackfill} seam (the `BackfillV1` request shape
- *     lands in [reactivity-backfill-resume-checkpoints]; this ticket only *detects* the gap and calls the
- *     hook);
- *  3. updates `lastRevision` once revisions are contiguous;
- *  4. surfaces the notification to the application layer.
- *
- * Subscribers dedupe by `(collectionId, revision)`; duplicates from forwarder retries are discarded.
- * A fresh subscription (`lastKnownRev == 0`, uninitialized) adopts the first verified notification as its
- * baseline rather than demanding a backfill from revision 1.
- */
-
-import type { NotificationV1 } from "./wire.js";
-import type { NotificationVerifier } from "./verify.js";
-
-/** The delivery outcome for one inbound notification. */
-export type DeliveryOutcome =
-	/** Verified and contiguous: surfaced to the application, `lastRevision` advanced. */
-	| "delivered"
-	/** `(collectionId, revision)` already delivered: discarded. */
-	| "duplicate"
-	/** Verified but ahead of `lastRevision + 1`: a backfill was requested; not yet surfaced. */
-	| "gap"
-	/** Signature did not verify (even after the one refetch): dropped. */
-	| "untrusted"
-	/** For a different collection than this subscription: ignored. */
-	| "foreign";
-
-/** Application sink + backfill seam for a {@link ReactivitySubscriber}. */
-export interface ReactivitySubscriberDeps {
-	/** Collection this subscription tracks, base64url (matches {@link NotificationV1.collectionId}). */
-	readonly collectionId: string;
-	/** Verifies inbound notifications (owns the single stale-cache refetch). */
-	readonly verifier: NotificationVerifier;
-	/** Surface a verified, contiguous notification to the application. */
-	readonly deliver: (n: NotificationV1) => void;
-	/**
-	 * Request a backfill for the inclusive revision gap `[from, to]`. The `BackfillV1` request/response
-	 * lands in [reactivity-backfill-resume-checkpoints]; the returned entries are fed back through
-	 * {@link ReactivitySubscriber.onNotification} to close the gap. Absent ⇒ the gap is recorded only.
-	 */
-	readonly requestBackfill?: (from: number, to: number) => void;
-	/** Last revision already held; `0` (default) ⇒ fresh subscribe, adopt the first notification as baseline. */
-	readonly lastKnownRev?: number;
-}
-
-/** Drives the subscriber-side verify → contiguity → deliver path for one collection. */
-export interface ReactivitySubscriber {
-	/** Last contiguously-delivered revision (`lastKnownRev` until the first delivery). */
-	readonly lastRevision: number;
-	/** Process one inbound notification; returns the {@link DeliveryOutcome}. */
-	onNotification(n: NotificationV1): Promise<DeliveryOutcome>;
-	/**
-	 * Advance the contiguity head to `revision` because a **verified parent checkpoint** summarized every
-	 * revision up to it (`docs/reactivity.md` §Parent checkpoint summaries). The subscriber then treats
-	 * `revision + 1` as the next contiguous revision, so the checkpoint's `recentEntries` replay without a
-	 * spurious gap/backfill for the digest-covered range. Only advances — never rewinds past delivered
-	 * state. The merged digest itself is applied by the application; this just moves the contiguity head.
-	 */
-	rebaseline(revision: number): void;
-}
-
-class CollectionSubscriber implements ReactivitySubscriber {
-	private last: number;
-	private initialized: boolean;
-
-	constructor(private readonly deps: ReactivitySubscriberDeps) {
-		const lastKnownRev = deps.lastKnownRev ?? 0;
-		this.last = lastKnownRev;
-		// A fresh subscribe (lastKnownRev == 0) has no baseline yet; the first verified notification sets it.
-		this.initialized = lastKnownRev > 0;
-	}
-
-	get lastRevision(): number {
-		return this.last;
-	}
-
-	rebaseline(revision: number): void {
-		// A verified checkpoint summarized everything up to `revision`; jump the head forward (never back).
-		if (!this.initialized || revision > this.last) {
-			this.last = revision;
-			this.initialized = true;
-		}
-	}
-
-	async onNotification(n: NotificationV1): Promise<DeliveryOutcome> {
-		if (n.collectionId !== this.deps.collectionId) {
-			return "foreign";
-		}
-		// Verify first (one fetch-and-retry is internal to the verifier). An untrusted notification is
-		// dropped before any (collectionId, revision) dedupe or lastRevision update.
-		const verdict = await this.deps.verifier.verify(n);
-		if (verdict !== "verified") {
-			return "untrusted";
-		}
-
-		// Fresh subscription: adopt the first verified notification as the contiguity baseline.
-		if (!this.initialized) {
-			this.initialized = true;
-			this.last = n.revision;
-			this.deps.deliver(n);
-			return "delivered";
-		}
-
-		// Dedupe by (collectionId, revision): anything at or below the contiguous head is already delivered.
-		if (n.revision <= this.last) {
-			return "duplicate";
-		}
-
-		// Contiguity check.
-		if (n.revision === this.last + 1) {
-			this.last = n.revision;
-			this.deps.deliver(n);
-			return "delivered";
-		}
-
-		// Gap: request the missing range (inclusive of `revision`); the backfilled entries re-enter here.
-		this.deps.requestBackfill?.(this.last + 1, n.revision);
-		return "gap";
-	}
-}
-
-/** Build a {@link ReactivitySubscriber} for one collection. */
-export function createReactivitySubscriber(deps: ReactivitySubscriberDeps): ReactivitySubscriber {
-	return new CollectionSubscriber(deps);
-}
+/**
+ * Reactivity — subscriber delivery path (`docs/reactivity.md` §Delivery).
+ *
+ * A subscriber receiving a notification:
+ *  1. **verifies** `sig` against the cached tail-cohort `MembershipCertV1` (the {@link NotificationVerifier}
+ *     owns the **one fetch-and-retry** on a stale cache);
+ *  2. checks `revision == lastRevision + 1`. If not, requests a backfill for the gap
+ *     `[lastRevision + 1, revision]` via the {@link requestBackfill} seam (the `BackfillV1` request shape
+ *     lands in [reactivity-backfill-resume-checkpoints]; this ticket only *detects* the gap and calls the
+ *     hook);
+ *  3. updates `lastRevision` once revisions are contiguous;
+ *  4. surfaces the notification to the application layer.
+ *
+ * Subscribers dedupe by `(collectionId, revision)`; duplicates from forwarder retries are discarded.
+ * A fresh subscription (`lastKnownRev == 0`, uninitialized) adopts the first verified notification as its
+ * baseline rather than demanding a backfill from revision 1.
+ */
+
+import type { NotificationV1 } from "./wire.js";
+import type { NotificationVerifier } from "./verify.js";
+
+/** The delivery outcome for one inbound notification. */
+export type DeliveryOutcome =
+	/** Verified and contiguous: surfaced to the application, `lastRevision` advanced. */
+	| "delivered"
+	/** `(collectionId, revision)` already delivered: discarded. */
+	| "duplicate"
+	/** Verified but ahead of `lastRevision + 1`: a backfill was requested; not yet surfaced. */
+	| "gap"
+	/** Signature did not verify (even after the one refetch): dropped. */
+	| "untrusted"
+	/** For a different collection than this subscription: ignored. */
+	| "foreign";
+
+/** Application sink + backfill seam for a {@link ReactivitySubscriber}. */
+export interface ReactivitySubscriberDeps {
+	/** Collection this subscription tracks, base64url (matches {@link NotificationV1.collectionId}). */
+	readonly collectionId: string;
+	/** Verifies inbound notifications (owns the single stale-cache refetch). */
+	readonly verifier: NotificationVerifier;
+	/** Surface a verified, contiguous notification to the application. */
+	readonly deliver: (n: NotificationV1) => void;
+	/**
+	 * Request a backfill for the inclusive revision gap `[from, to]`. The `BackfillV1` request/response
+	 * lands in [reactivity-backfill-resume-checkpoints]; the returned entries are fed back through
+	 * {@link ReactivitySubscriber.onNotification} to close the gap. Absent ⇒ the gap is recorded only.
+	 */
+	readonly requestBackfill?: (from: number, to: number) => void;
+	/** Last revision already held; `0` (default) ⇒ fresh subscribe, adopt the first notification as baseline. */
+	readonly lastKnownRev?: number;
+}
+
+/** Drives the subscriber-side verify → contiguity → deliver path for one collection. */
+export interface ReactivitySubscriber {
+	/** Last contiguously-delivered revision (`lastKnownRev` until the first delivery). */
+	readonly lastRevision: number;
+	/** Process one inbound notification; returns the {@link DeliveryOutcome}. */
+	onNotification(n: NotificationV1): Promise<DeliveryOutcome>;
+	/**
+	 * Advance the contiguity head to `revision` because a **verified parent checkpoint** summarized every
+	 * revision up to it (`docs/reactivity.md` §Parent checkpoint summaries). The subscriber then treats
+	 * `revision + 1` as the next contiguous revision, so the checkpoint's `recentEntries` replay without a
+	 * spurious gap/backfill for the digest-covered range. Only advances — never rewinds past delivered
+	 * state. The merged digest itself is applied by the application; this just moves the contiguity head.
+	 */
+	rebaseline(revision: number): void;
+}
+
+class CollectionSubscriber implements ReactivitySubscriber {
+	private last: number;
+	private initialized: boolean;
+
+	constructor(private readonly deps: ReactivitySubscriberDeps) {
+		const lastKnownRev = deps.lastKnownRev ?? 0;
+		this.last = lastKnownRev;
+		// A fresh subscribe (lastKnownRev == 0) has no baseline yet; the first verified notification sets it.
+		this.initialized = lastKnownRev > 0;
+	}
+
+	get lastRevision(): number {
+		return this.last;
+	}
+
+	rebaseline(revision: number): void {
+		// A verified checkpoint summarized everything up to `revision`; jump the head forward (never back).
+		if (!this.initialized || revision > this.last) {
+			this.last = revision;
+			this.initialized = true;
+		}
+	}
+
+	async onNotification(n: NotificationV1): Promise<DeliveryOutcome> {
+		if (n.collectionId !== this.deps.collectionId) {
+			return "foreign";
+		}
+		// Verify first (one fetch-and-retry is internal to the verifier). An untrusted notification is
+		// dropped before any (collectionId, revision) dedupe or lastRevision update.
+		const verdict = await this.deps.verifier.verify(n);
+		if (verdict !== "verified") {
+			return "untrusted";
+		}
+
+		// Fresh subscription: adopt the first verified notification as the contiguity baseline.
+		if (!this.initialized) {
+			this.initialized = true;
+			this.last = n.revision;
+			this.deps.deliver(n);
+			return "delivered";
+		}
+
+		// Dedupe by (collectionId, revision): anything at or below the contiguous head is already delivered.
+		if (n.revision <= this.last) {
+			return "duplicate";
+		}
+
+		// Contiguity check.
+		if (n.revision === this.last + 1) {
+			this.last = n.revision;
+			this.deps.deliver(n);
+			return "delivered";
+		}
+
+		// Gap: request the missing range (inclusive of `revision`); the backfilled entries re-enter here.
+		this.deps.requestBackfill?.(this.last + 1, n.revision);
+		return "gap";
+	}
+}
+
+/** Build a {@link ReactivitySubscriber} for one collection. */
+export function createReactivitySubscriber(deps: ReactivitySubscriberDeps): ReactivitySubscriber {
+	return new CollectionSubscriber(deps);
+}

package/src/reactivity/subscription.ts

@@ -1,66 +1,66 @@
-/**
- * Reactivity — subscriber-side subscription state (`docs/reactivity.md` §Subscription).
- *
- * Subscribing to a collection is an **ordinary cohort-topic registration** at tier T3 with a reactivity
- * `appPayload`: `topicId = H(currentTailId(C) ‖ "reactivity")`, the configured TTL (Edge 60 s / Core 90 s),
- * and the cohort-topic walk-toward-root / willingness / promotion / TTL-renewal all reused unchanged.
- * This module owns only the subscriber-side bookkeeping struct and the `appPayload` builder; the db-p2p
- * subscription manager drives the cohort-topic `RegisterV1`.
- *
- * `tailIdAtAttach` is the subscriber-side detector for tail rotation (the whole-tree migration the
- * rotation ticket handles); `cohortEpoch` detects membership drift within the topic.
- */
-
-import { encodeSubscribeAppPayload, type SubscribeAppPayloadV1 } from "./wire.js";
-
-/** Subscriber-side live state for one active subscription (`docs/reactivity.md` §Subscriber-side state). */
-export interface ActiveSubscription {
-	/** Stable collection identity. */
-	readonly collectionId: Uint8Array;
-	/** Current tail-anchored topic id. */
-	readonly topicId: Uint8Array;
-	/** Tail block id at registration time — detects tail rotation. */
-	readonly tailIdAtAttach: Uint8Array;
-	/** Serving cohort member. */
-	primary: Uint8Array;
-	/** Warm-failover cohort members. */
-	backups: Uint8Array[];
-	/** Cohort member hint set for fast re-attach. */
-	cohortHint: Uint8Array[];
-	/** Cohort epoch for membership-drift detection. */
-	cohortEpoch: Uint8Array;
-	/** Last contiguously-delivered revision. */
-	lastRevision: number;
-	/** Unix ms of the last delivery. */
-	lastDeliveredAt: number;
-	/** Unix ms the subscription attached. */
-	attachedAt: number;
-}
-
-/** Parameters for building a subscribe `appPayload`. */
-export interface SubscribeParams {
-	/** Collection id, base64url. */
-	readonly collectionId: string;
-	/** Tail block id at attach time, base64url. */
-	readonly tailIdAtAttach: string;
-	/** Last revision already held; `0` for a fresh subscribe. */
-	readonly lastKnownRev?: number;
-	/** Max delta bytes accepted; `0` declines deltas (Edge). */
-	readonly deltaMaxBytes: number;
-}
-
-/** Build the validated {@link SubscribeAppPayloadV1} for a subscription. */
-export function buildSubscribeAppPayload(params: SubscribeParams): SubscribeAppPayloadV1 {
-	return {
-		kind: "reactivity",
-		collectionId: params.collectionId,
-		tailIdAtAttach: params.tailIdAtAttach,
-		lastKnownRev: params.lastKnownRev ?? 0,
-		deltaMaxBytes: params.deltaMaxBytes,
-	};
-}
-
-/** Build the opaque `RegisterV1.appPayload` bytes for a subscription. */
-export function subscribeAppPayloadBytes(params: SubscribeParams): Uint8Array {
-	return encodeSubscribeAppPayload(buildSubscribeAppPayload(params));
-}
+/**
+ * Reactivity — subscriber-side subscription state (`docs/reactivity.md` §Subscription).
+ *
+ * Subscribing to a collection is an **ordinary cohort-topic registration** at tier T3 with a reactivity
+ * `appPayload`: `topicId = H(currentTailId(C) ‖ "reactivity")`, the configured TTL (Edge 60 s / Core 90 s),
+ * and the cohort-topic walk-toward-root / willingness / promotion / TTL-renewal all reused unchanged.
+ * This module owns only the subscriber-side bookkeeping struct and the `appPayload` builder; the db-p2p
+ * subscription manager drives the cohort-topic `RegisterV1`.
+ *
+ * `tailIdAtAttach` is the subscriber-side detector for tail rotation (the whole-tree migration the
+ * rotation ticket handles); `cohortEpoch` detects membership drift within the topic.
+ */
+
+import { encodeSubscribeAppPayload, type SubscribeAppPayloadV1 } from "./wire.js";
+
+/** Subscriber-side live state for one active subscription (`docs/reactivity.md` §Subscriber-side state). */
+export interface ActiveSubscription {
+	/** Stable collection identity. */
+	readonly collectionId: Uint8Array;
+	/** Current tail-anchored topic id. */
+	readonly topicId: Uint8Array;
+	/** Tail block id at registration time — detects tail rotation. */
+	readonly tailIdAtAttach: Uint8Array;
+	/** Serving cohort member. */
+	primary: Uint8Array;
+	/** Warm-failover cohort members. */
+	backups: Uint8Array[];
+	/** Cohort member hint set for fast re-attach. */
+	cohortHint: Uint8Array[];
+	/** Cohort epoch for membership-drift detection. */
+	cohortEpoch: Uint8Array;
+	/** Last contiguously-delivered revision. */
+	lastRevision: number;
+	/** Unix ms of the last delivery. */
+	lastDeliveredAt: number;
+	/** Unix ms the subscription attached. */
+	attachedAt: number;
+}
+
+/** Parameters for building a subscribe `appPayload`. */
+export interface SubscribeParams {
+	/** Collection id, base64url. */
+	readonly collectionId: string;
+	/** Tail block id at attach time, base64url. */
+	readonly tailIdAtAttach: string;
+	/** Last revision already held; `0` for a fresh subscribe. */
+	readonly lastKnownRev?: number;
+	/** Max delta bytes accepted; `0` declines deltas (Edge). */
+	readonly deltaMaxBytes: number;
+}
+
+/** Build the validated {@link SubscribeAppPayloadV1} for a subscription. */
+export function buildSubscribeAppPayload(params: SubscribeParams): SubscribeAppPayloadV1 {
+	return {
+		kind: "reactivity",
+		collectionId: params.collectionId,
+		tailIdAtAttach: params.tailIdAtAttach,
+		lastKnownRev: params.lastKnownRev ?? 0,
+		deltaMaxBytes: params.deltaMaxBytes,
+	};
+}
+
+/** Build the opaque `RegisterV1.appPayload` bytes for a subscription. */
+export function subscribeAppPayloadBytes(params: SubscribeParams): Uint8Array {
+	return encodeSubscribeAppPayload(buildSubscribeAppPayload(params));
+}

package/src/reactivity/topic-anchor.ts

@@ -1,71 +1,71 @@
-/**
- * Reactivity — rotating, tail-anchored topic.
- *
- * Transcribed from `docs/reactivity.md` §Anchor:
- *
- * ```
- * topicId(collection C, tail T) = H(T.blockId ‖ "reactivity")
- * ```
- *
- * Unlike matchmaking (whose anchor is a stable `(kind, label)`), the reactivity anchor **rotates** with
- * the collection's tail block: when the tail fills and a new tail block is born, `topicId` changes and
- * the cohort-topic layer treats it as an entirely new topic. The whole-tree migration that follows is
- * the rotation ticket's concern; this module owns only the pure derivation.
- *
- * The resulting `topicId` is fed verbatim into cohort-topic tier addressing (`coord_d(self, topicId)`),
- * so it is derived with the **same** {@link IRingHash} primitive cohort-topic uses for `coord_d` input —
- * db-core's own SHA-256 truncated to the ring width, **not** a FRET import. The trailing `"reactivity"`
- * literal domain-separates the reactivity tree from any other application anchoring on the same tail id.
- *
- * Concatenation is delimiter-free, exactly as the spec writes it; the constant suffix is unambiguous
- * because no tail-id byte string can alias a `(tailId, "reactivity")` pair of a different length.
- *
- * `reactivityTopicId` is the small pure helper the ticket asks for once and the rotation ticket
- * ([reactivity-rotation-backpressure-policy]) reuses per-emission — define it here, not at the call site.
- */
-
-import { createRingHash } from "../cohort-topic/ring-hash.js";
-import type { IRingHash } from "../cohort-topic/ports.js";
-
-/** Domain-separation suffix mixed into every reactivity anchor. */
-const REACTIVITY_SUFFIX = "reactivity";
-
-const utf8 = new TextEncoder();
-
-/**
- * `H(tailId ‖ "reactivity")` over the injected ring hash — the cohort-topic `topicId` for the
- * reactivity tree anchored on `tailId` (the collection's current tail block id, as raw bytes).
- *
- * The shared helper consumed by subscriber attachment, origination, and (per-emission) the rotation
- * ticket. `hash` defaults to db-core's own 256-bit SHA-256, byte-identical to the cohort-topic host's.
- */
-export function reactivityTopicId(tailId: Uint8Array, hash: IRingHash = createRingHash()): Uint8Array {
-	const suffixBytes = utf8.encode(REACTIVITY_SUFFIX);
-	const input = new Uint8Array(tailId.length + suffixBytes.length);
-	input.set(tailId, 0);
-	input.set(suffixBytes, tailId.length);
-	return hash.H(input);
-}
-
-/** Derives the rotating `topicId` for a collection's current tail. */
-export interface ReactivityTopicAnchor {
-	/** `H(tailId ‖ "reactivity")` for the given tail block id (bytes). */
-	topicId(tailId: Uint8Array): Uint8Array;
-}
-
-class HashReactivityTopicAnchor implements ReactivityTopicAnchor {
-	constructor(private readonly hash: IRingHash) {}
-
-	topicId(tailId: Uint8Array): Uint8Array {
-		return reactivityTopicId(tailId, this.hash);
-	}
-}
-
-/**
- * Build a {@link ReactivityTopicAnchor} over the injected hash. db-p2p passes the same {@link IRingHash}
- * it binds to FRET's `RING_BITS` so the anchor and cohort-topic routing keys line up; the default
- * constructs db-core's own {@link createRingHash} (256-bit SHA-256).
- */
-export function createReactivityTopicAnchor(hash: IRingHash = createRingHash()): ReactivityTopicAnchor {
-	return new HashReactivityTopicAnchor(hash);
-}
+/**
+ * Reactivity — rotating, tail-anchored topic.
+ *
+ * Transcribed from `docs/reactivity.md` §Anchor:
+ *
+ * ```
+ * topicId(collection C, tail T) = H(T.blockId ‖ "reactivity")
+ * ```
+ *
+ * Unlike matchmaking (whose anchor is a stable `(kind, label)`), the reactivity anchor **rotates** with
+ * the collection's tail block: when the tail fills and a new tail block is born, `topicId` changes and
+ * the cohort-topic layer treats it as an entirely new topic. The whole-tree migration that follows is
+ * the rotation ticket's concern; this module owns only the pure derivation.
+ *
+ * The resulting `topicId` is fed verbatim into cohort-topic tier addressing (`coord_d(self, topicId)`),
+ * so it is derived with the **same** {@link IRingHash} primitive cohort-topic uses for `coord_d` input —
+ * db-core's own SHA-256 truncated to the ring width, **not** a FRET import. The trailing `"reactivity"`
+ * literal domain-separates the reactivity tree from any other application anchoring on the same tail id.
+ *
+ * Concatenation is delimiter-free, exactly as the spec writes it; the constant suffix is unambiguous
+ * because no tail-id byte string can alias a `(tailId, "reactivity")` pair of a different length.
+ *
+ * `reactivityTopicId` is the small pure helper the ticket asks for once and the rotation ticket
+ * ([reactivity-rotation-backpressure-policy]) reuses per-emission — define it here, not at the call site.
+ */
+
+import { createRingHash } from "../cohort-topic/ring-hash.js";
+import type { IRingHash } from "../cohort-topic/ports.js";
+
+/** Domain-separation suffix mixed into every reactivity anchor. */
+const REACTIVITY_SUFFIX = "reactivity";
+
+const utf8 = new TextEncoder();
+
+/**
+ * `H(tailId ‖ "reactivity")` over the injected ring hash — the cohort-topic `topicId` for the
+ * reactivity tree anchored on `tailId` (the collection's current tail block id, as raw bytes).
+ *
+ * The shared helper consumed by subscriber attachment, origination, and (per-emission) the rotation
+ * ticket. `hash` defaults to db-core's own 256-bit SHA-256, byte-identical to the cohort-topic host's.
+ */
+export function reactivityTopicId(tailId: Uint8Array, hash: IRingHash = createRingHash()): Uint8Array {
+	const suffixBytes = utf8.encode(REACTIVITY_SUFFIX);
+	const input = new Uint8Array(tailId.length + suffixBytes.length);
+	input.set(tailId, 0);
+	input.set(suffixBytes, tailId.length);
+	return hash.H(input);
+}
+
+/** Derives the rotating `topicId` for a collection's current tail. */
+export interface ReactivityTopicAnchor {
+	/** `H(tailId ‖ "reactivity")` for the given tail block id (bytes). */
+	topicId(tailId: Uint8Array): Uint8Array;
+}
+
+class HashReactivityTopicAnchor implements ReactivityTopicAnchor {
+	constructor(private readonly hash: IRingHash) {}
+
+	topicId(tailId: Uint8Array): Uint8Array {
+		return reactivityTopicId(tailId, this.hash);
+	}
+}
+
+/**
+ * Build a {@link ReactivityTopicAnchor} over the injected hash. db-p2p passes the same {@link IRingHash}
+ * it binds to FRET's `RING_BITS` so the anchor and cohort-topic routing keys line up; the default
+ * constructs db-core's own {@link createRingHash} (256-bit SHA-256).
+ */
+export function createReactivityTopicAnchor(hash: IRingHash = createRingHash()): ReactivityTopicAnchor {
+	return new HashReactivityTopicAnchor(hash);
+}