@optimystic/db-core 0.13.5 → 0.14.0

package/dist/src/matchmaking/seeker-walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeker-walk.js","sourceRoot":"","sources":["../../../src/matchmaking/seeker-walk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AA8BnF,iGAAiG;AACjG,MAAM,UAAU,kBAAkB,CAAC,MAA4B;IAC9D,OAAO,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,iBAAiB,GAAG,CAAC,MAAM,CAAC,mBAAmB,GAAG,MAAM,CAAC,CAAC;AACjG,CAAC;AAED,mGAAmG;AACnG,MAAM,UAAU,gBAAgB,CAAC,MAA4B,EAAE,GAAkB;IAChF,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;IACnG,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAC/C,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,gBAAgB,CAAC,MAA4B,EAAE,GAAkB;IAChF,OAAO,MAAM,CAAC,SAAS,GAAG,gBAAgB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,MAAM,CAAC,MAA4B,EAAE,GAAkB;IACtE,IAAI,MAAM,CAAC,cAAc,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAC3B,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACrE,IAAI,SAAS,IAAI,gBAAgB,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;QAChD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,EAAE,GAAG,CAAC,iBAAiB,EAAE,CAAC;IACxE,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AAC/B,CAAC;AAiBD,iEAAiE;AACjE,MAAM,UAAU,yBAAyB;IACxC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;AACpC,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,YAAY,CAAC,KAA6B,EAAE,OAAe,EAAE,QAAgB;IAC5F,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,EAAE,CAAC;AAClF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAA6B,EAAE,UAAkB,2BAA2B;IAC7G,OAAO,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;AACtE,CAAC;AAED,8FAA8F;AAC9F,MAAM,CAAC,MAAM,uBAAuB,GAAG,uBAAuB,CAAC"}

package/dist/src/matchmaking/seeker.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Matchmaking — seeker registration state (db-core, transport-agnostic).
+ *
+ * A {@link MatchmakingSeeker} owns the short-lived seeker state for one topic and builds the signed
+ * {@link SeekerAppPayloadV1} that the db-p2p `seeker-manager` registers at cohort-topic tier **T2**
+ * with a short TTL (`seeker_ttl`, default 10 s — `docs/matchmaking.md` §Seeker query). The seeker
+ * registers briefly so other seekers can find it (collective assembly) and the cohort sees active
+ * demand.
+ *
+ * This module holds *registration* state only. The `QueryV1` issuance and the hang-out-vs-continue
+ * decision live in the pure {@link import("./seeker-walk.js").decide} engine and the db-p2p
+ * `seeker-walk-client` that drives the walk; the capability filter is {@link import("./capability-filter.js").matchesFilter}.
+ *
+ * Crypto-free: signing is an injected callback, matching {@link MatchmakingProvider}.
+ */
+import { type CapabilityFilter, type SeekerAppPayloadV1 } from "./wire.js";
+/** Construction inputs for a {@link MatchmakingSeeker}. */
+export interface MatchmakingSeekerOptions {
+    /** The matchmaking topic this seeker is querying. */
+    readonly topicId: Uint8Array;
+    /** Number of providers desired (integer `>= 1`). */
+    readonly wantCount: number;
+    /** Multiaddr or PeerId-based callback (collective-assembly use). */
+    readonly contactHint: string;
+    /** Optional capability filter (evaluated cohort-side in the next ticket; carried here). */
+    readonly filter?: CapabilityFilter;
+    /** Opt into arrival pushes; default false (poll path). Consumed by the next ticket. */
+    readonly pushOnArrival?: boolean;
+    /** Sign the canonical registration image; resolves the base64url signature. */
+    readonly sign: (payload: Uint8Array) => Promise<string>;
+    /** 16-byte registration correlation id (not signature-bound); default fresh CSPRNG bytes. */
+    readonly correlationId?: Uint8Array;
+    /** CSPRNG source (injectable for deterministic tests). Default `@noble/hashes` `randomBytes`. */
+    readonly randomBytes?: (n: number) => Uint8Array;
+}
+/** Live seeker state + signed-payload builder for one matchmaking topic (registration only). */
+export declare class MatchmakingSeeker {
+    readonly topicId: Uint8Array;
+    readonly correlationId: Uint8Array;
+    private readonly wantCount;
+    private readonly contactHint;
+    private readonly filter?;
+    private readonly pushOnArrival?;
+    private readonly sign;
+    constructor(options: MatchmakingSeekerOptions);
+    /** Build the signed {@link SeekerAppPayloadV1} for this seeker's registration. */
+    buildAppPayload(): Promise<SeekerAppPayloadV1>;
+    /** Build the opaque bytes for the cohort-topic `RegisterV1.appPayload` slot. */
+    appPayloadBytes(): Promise<Uint8Array>;
+}
+//# sourceMappingURL=seeker.d.ts.map

package/dist/src/matchmaking/seeker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeker.d.ts","sourceRoot":"","sources":["../../../src/matchmaking/seeker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAwB,KAAK,gBAAgB,EAAE,KAAK,kBAAkB,EAA0B,MAAM,WAAW,CAAC;AAEzH,2DAA2D;AAC3D,MAAM,WAAW,wBAAwB;IACxC,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,uFAAuF;IACvF,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACxD,6FAA6F;IAC7F,QAAQ,CAAC,aAAa,CAAC,EAAE,UAAU,CAAC;IACpC,iGAAiG;IACjG,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;CACjD;AAED,gGAAgG;AAChG,qBAAa,iBAAiB;IAC7B,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA2C;gBAEpD,OAAO,EAAE,wBAAwB;IAc7C,kFAAkF;IAC5E,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAiBpD,gFAAgF;IAC1E,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC;CAG5C"}

package/dist/src/matchmaking/seeker.js

@@ -0,0 +1,62 @@
+/**
+ * Matchmaking — seeker registration state (db-core, transport-agnostic).
+ *
+ * A {@link MatchmakingSeeker} owns the short-lived seeker state for one topic and builds the signed
+ * {@link SeekerAppPayloadV1} that the db-p2p `seeker-manager` registers at cohort-topic tier **T2**
+ * with a short TTL (`seeker_ttl`, default 10 s — `docs/matchmaking.md` §Seeker query). The seeker
+ * registers briefly so other seekers can find it (collective assembly) and the cohort sees active
+ * demand.
+ *
+ * This module holds *registration* state only. The `QueryV1` issuance and the hang-out-vs-continue
+ * decision live in the pure {@link import("./seeker-walk.js").decide} engine and the db-p2p
+ * `seeker-walk-client` that drives the walk; the capability filter is {@link import("./capability-filter.js").matchesFilter}.
+ *
+ * Crypto-free: signing is an injected callback, matching {@link MatchmakingProvider}.
+ */
+import { randomBytes } from "@noble/hashes/utils.js";
+import { seekerSigningPayload, encodeSeekerAppPayload } from "./wire.js";
+/** Live seeker state + signed-payload builder for one matchmaking topic (registration only). */
+export class MatchmakingSeeker {
+    topicId;
+    correlationId;
+    wantCount;
+    contactHint;
+    filter;
+    pushOnArrival;
+    sign;
+    constructor(options) {
+        if (!Number.isInteger(options.wantCount) || options.wantCount < 1) {
+            throw new RangeError(`matchmaking seeker: wantCount must be an integer >= 1, got ${options.wantCount}`);
+        }
+        this.topicId = options.topicId;
+        this.wantCount = options.wantCount;
+        this.contactHint = options.contactHint;
+        this.filter = options.filter;
+        this.pushOnArrival = options.pushOnArrival;
+        this.sign = options.sign;
+        const rand = options.randomBytes ?? randomBytes;
+        this.correlationId = options.correlationId ?? rand(16);
+    }
+    /** Build the signed {@link SeekerAppPayloadV1} for this seeker's registration. */
+    async buildAppPayload() {
+        const signature = await this.sign(seekerSigningPayload(this.topicId, this.wantCount));
+        const payload = {
+            kind: "match-seeker",
+            wantCount: this.wantCount,
+            contactHint: this.contactHint,
+            signature,
+        };
+        if (this.filter !== undefined) {
+            payload.filter = this.filter;
+        }
+        if (this.pushOnArrival !== undefined) {
+            payload.pushOnArrival = this.pushOnArrival;
+        }
+        return payload;
+    }
+    /** Build the opaque bytes for the cohort-topic `RegisterV1.appPayload` slot. */
+    async appPayloadBytes() {
+        return encodeSeekerAppPayload(await this.buildAppPayload());
+    }
+}
+//# sourceMappingURL=seeker.js.map

package/dist/src/matchmaking/seeker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeker.js","sourceRoot":"","sources":["../../../src/matchmaking/seeker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAkD,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAsBzH,gGAAgG;AAChG,MAAM,OAAO,iBAAiB;IACpB,OAAO,CAAa;IACpB,aAAa,CAAa;IAClB,SAAS,CAAS;IAClB,WAAW,CAAS;IACpB,MAAM,CAAoB;IAC1B,aAAa,CAAW;IACxB,IAAI,CAA2C;IAEhE,YAAY,OAAiC;QAC5C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,SAAS,GAAG,CAAC,EAAE,CAAC;YACnE,MAAM,IAAI,UAAU,CAAC,8DAA8D,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;QACzG,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,IAAI,WAAW,CAAC;QAChD,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC;IACxD,CAAC;IAED,kFAAkF;IAClF,KAAK,CAAC,eAAe;QACpB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QACtF,MAAM,OAAO,GAAuB;YACnC,IAAI,EAAE,cAAc;YACpB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,SAAS;SACT,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC/B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC9B,CAAC;QACD,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACtC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QAC5C,CAAC;QACD,OAAO,OAAO,CAAC;IAChB,CAAC;IAED,gFAAgF;IAChF,KAAK,CAAC,eAAe;QACpB,OAAO,sBAAsB,CAAC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IAC7D,CAAC;CACD"}

package/dist/src/matchmaking/topic-anchor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Matchmaking — stable topic anchor.
+ *
+ * Transcribed from `docs/matchmaking.md` §Anchor:
+ *
+ * ```
+ * topicId(kind, label) = H(kind ‖ label ‖ "match")
+ * ```
+ *
+ * Unlike reactivity, matchmaking topics do **not** rotate — a task or capability label has a stable
+ * identity over its useful lifetime, so the anchor is a pure function of `(kind, label)`.
+ *
+ * `kind` namespaces the topic so unrelated label spaces never collide; `label` is application-defined
+ * (capability name, proposal hash, task-type id). The resulting `topicId` is fed verbatim into
+ * cohort-topic tier addressing (`coord_d(self, topicId)`), so it is derived with the **same** hash
+ * primitive cohort-topic uses for `coord_d` input — db-core's own {@link IRingHash} (SHA-256 truncated
+ * to the ring width), **not** a FRET import. At the default `ringBits = 256` the anchor is a 32-byte
+ * value, matching the cohort-topic `topicId` width.
+ *
+ * Concatenation is delimiter-free, exactly as the spec writes it. This is unambiguous because `kind`
+ * is drawn from a closed set ({@link MATCH_TOPIC_KINDS}) in which no member is a prefix of another, so
+ * `kind ‖ label` can never alias a different `(kind, label)` pair. The trailing `"match"` literal
+ * domain-separates matchmaking anchors from any other application that might hash the same label.
+ */
+import type { IRingHash } from "../cohort-topic/ports.js";
+/**
+ * The category of a matchmaking topic. Namespaces the `label` space so unrelated topics never
+ * collide on the ring (`docs/matchmaking.md` §Anchor).
+ *
+ * - `task` — a work-task type id; long-lived, matures a deep tree.
+ * - `capability` — a capability name (storage class, region, hardware feature); long-lived.
+ * - `quorum` — a voting-proposal hash; short-lived, forms a shallow tree that demotes once closed.
+ * - `capacity-class` — a capacity bucket for capacity gossip.
+ */
+export type MatchTopicKind = "task" | "capability" | "quorum" | "capacity-class";
+/** Every matchmaking topic kind. Validated against on the seeker/provider build path. */
+export declare const MATCH_TOPIC_KINDS: readonly MatchTopicKind[];
+/** Derives the stable `topicId` for a matchmaking `(kind, label)` pair. */
+export interface MatchTopicAnchor {
+    /** `H(kind ‖ label ‖ "match")` — the cohort-topic `topicId` for this matchmaking topic. */
+    topicId(kind: MatchTopicKind, label: string): Uint8Array;
+}
+/** True iff `kind` is one of the closed {@link MATCH_TOPIC_KINDS}. */
+export declare function isMatchTopicKind(kind: string): kind is MatchTopicKind;
+/**
+ * Build a {@link MatchTopicAnchor} over the injected hash. db-p2p passes the same {@link IRingHash}
+ * instance 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), which is byte-identical
+ * to what the cohort-topic host uses.
+ */
+export declare function createMatchTopicAnchor(hash?: IRingHash): MatchTopicAnchor;
+/** One-shot convenience: `H(kind ‖ label ‖ "match")` over the default db-core ring hash. */
+export declare function matchTopicId(kind: MatchTopicKind, label: string, hash?: IRingHash): Uint8Array;
+//# sourceMappingURL=topic-anchor.d.ts.map

package/dist/src/matchmaking/topic-anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"topic-anchor.d.ts","sourceRoot":"","sources":["../../../src/matchmaking/topic-anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB,CAAC;AAEjF,yFAAyF;AACzF,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAAuD,CAAC;AAO/G,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAChC,2FAA2F;IAC3F,OAAO,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC;CACzD;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,cAAc,CAErE;AAoBD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,GAAE,SAA4B,GAAG,gBAAgB,CAE3F;AAED,4FAA4F;AAC5F,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,SAA4B,GAAG,UAAU,CAEhH"}

package/dist/src/matchmaking/topic-anchor.js

@@ -0,0 +1,67 @@
+/**
+ * Matchmaking — stable topic anchor.
+ *
+ * Transcribed from `docs/matchmaking.md` §Anchor:
+ *
+ * ```
+ * topicId(kind, label) = H(kind ‖ label ‖ "match")
+ * ```
+ *
+ * Unlike reactivity, matchmaking topics do **not** rotate — a task or capability label has a stable
+ * identity over its useful lifetime, so the anchor is a pure function of `(kind, label)`.
+ *
+ * `kind` namespaces the topic so unrelated label spaces never collide; `label` is application-defined
+ * (capability name, proposal hash, task-type id). The resulting `topicId` is fed verbatim into
+ * cohort-topic tier addressing (`coord_d(self, topicId)`), so it is derived with the **same** hash
+ * primitive cohort-topic uses for `coord_d` input — db-core's own {@link IRingHash} (SHA-256 truncated
+ * to the ring width), **not** a FRET import. At the default `ringBits = 256` the anchor is a 32-byte
+ * value, matching the cohort-topic `topicId` width.
+ *
+ * Concatenation is delimiter-free, exactly as the spec writes it. This is unambiguous because `kind`
+ * is drawn from a closed set ({@link MATCH_TOPIC_KINDS}) in which no member is a prefix of another, so
+ * `kind ‖ label` can never alias a different `(kind, label)` pair. The trailing `"match"` literal
+ * domain-separates matchmaking anchors from any other application that might hash the same label.
+ */
+import { createRingHash } from "../cohort-topic/ring-hash.js";
+/** Every matchmaking topic kind. Validated against on the seeker/provider build path. */
+export const MATCH_TOPIC_KINDS = ["task", "capability", "quorum", "capacity-class"];
+/** Domain-separation suffix mixed into every matchmaking anchor. */
+const MATCH_SUFFIX = "match";
+const utf8 = new TextEncoder();
+/** True iff `kind` is one of the closed {@link MATCH_TOPIC_KINDS}. */
+export function isMatchTopicKind(kind) {
+    return MATCH_TOPIC_KINDS.includes(kind);
+}
+class HashMatchTopicAnchor {
+    hash;
+    constructor(hash) {
+        this.hash = hash;
+    }
+    topicId(kind, label) {
+        if (!isMatchTopicKind(kind)) {
+            throw new RangeError(`matchmaking topicId: unknown kind ${JSON.stringify(kind)}`);
+        }
+        const kindBytes = utf8.encode(kind);
+        const labelBytes = utf8.encode(label);
+        const suffixBytes = utf8.encode(MATCH_SUFFIX);
+        const input = new Uint8Array(kindBytes.length + labelBytes.length + suffixBytes.length);
+        input.set(kindBytes, 0);
+        input.set(labelBytes, kindBytes.length);
+        input.set(suffixBytes, kindBytes.length + labelBytes.length);
+        return this.hash.H(input);
+    }
+}
+/**
+ * Build a {@link MatchTopicAnchor} over the injected hash. db-p2p passes the same {@link IRingHash}
+ * instance 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), which is byte-identical
+ * to what the cohort-topic host uses.
+ */
+export function createMatchTopicAnchor(hash = createRingHash()) {
+    return new HashMatchTopicAnchor(hash);
+}
+/** One-shot convenience: `H(kind ‖ label ‖ "match")` over the default db-core ring hash. */
+export function matchTopicId(kind, label, hash = createRingHash()) {
+    return createMatchTopicAnchor(hash).topicId(kind, label);
+}
+//# sourceMappingURL=topic-anchor.js.map

package/dist/src/matchmaking/topic-anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"topic-anchor.js","sourceRoot":"","sources":["../../../src/matchmaking/topic-anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAc9D,yFAAyF;AACzF,MAAM,CAAC,MAAM,iBAAiB,GAA8B,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC;AAE/G,oEAAoE;AACpE,MAAM,YAAY,GAAG,OAAO,CAAC;AAE7B,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;AAQ/B,sEAAsE;AACtE,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC5C,OAAQ,iBAAuC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,oBAAoB;IACI;IAA7B,YAA6B,IAAe;QAAf,SAAI,GAAJ,IAAI,CAAW;IAAG,CAAC;IAEhD,OAAO,CAAC,IAAoB,EAAE,KAAa;QAC1C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,UAAU,CAAC,qCAAqC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACnF,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QACxF,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QACxB,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;QACxC,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;QAC7D,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;CACD;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAkB,cAAc,EAAE;IACxE,OAAO,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,YAAY,CAAC,IAAoB,EAAE,KAAa,EAAE,OAAkB,cAAc,EAAE;IACnG,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAC1D,CAAC"}

package/dist/src/matchmaking/voting-quorum.d.ts

@@ -0,0 +1,233 @@
+/**
+ * Matchmaking — voting-quorum assembler (db-core, discovery-only composition).
+ *
+ * The voting subsystem's **discovery** flow, built as a thin composition over the matchmaking module
+ * (`docs/matchmaking.md` §Voting-quorum assembly). Matchmaking already provides "find the peers": the
+ * stable {@link import("./topic-anchor.js").MatchTopicAnchor}, the signed provider registration
+ * ({@link MatchmakingProvider}), the single-cohort hang-out walk and the hot-topic multi-cohort sweep,
+ * and the reply-side per-entry `registrationSig` re-validation ({@link verifyProviderEntry}). This
+ * module adds the small amount of glue that turns that surface into "assemble a quorum of eligible
+ * voters for proposal `P`".
+ *
+ * **No matchmaking wire-protocol change is introduced.** The genuinely voting-layer pieces are injected
+ * or left out of scope entirely:
+ *
+ * - **Eligibility proof minting** — the caller mints an opaque proof (a signature over the proposal from
+ *   a stake-bearing key, etc.) and supplies the {@link VotingQuorumRequest.verifyEligibility} predicate
+ *   over it. Matchmaking treats the proof as opaque bytes carried in the provider's `capabilities`.
+ * - **The quorum selection rule** (random sample, stake-weighted, geographic) — injected via
+ *   {@link VotingQuorumRequest.select}; the default is first-`targetSize`.
+ * - **Ballots, tally, dispute, ballot privacy** — out of scope; a separate forthcoming voting doc.
+ *
+ * ## Resolved design decisions (`docs/matchmaking.md` §Voting-quorum assembly)
+ *
+ * 1. **Reply-side per-entry verification is the default and required path; a client-side reputation
+ *    pre-filter is optional and additive.** Quorum-assembly *liveness* must never depend on
+ *    reputation-subsystem *availability*, so reputation is an optimization, never a dependency.
+ *    Matchmaking forwards each entry's `registrationSig` plus the eligibility proof in `capabilities`,
+ *    so reply-side verification is effectively free; the cohort returns ineligible entries the
+ *    coordinator discards (bandwidth bounded by `query_limit_max × swept-cohort-count`).
+ * 2. **Flash-vote fairness among competing coordinators is a voting-layer concern; no matchmaking signal
+ *    is added.** Matchmaking returns an advisory *candidate set*, never an allocation — overlapping sets
+ *    are expected and quorum non-collision is decided by the voting protocol.
+ * 3. **No matchmaking protocol additions are needed.** `AggregateCountV1` is threshold-signed (an
+ *    attested *registered*-provider count); an attested *eligible*-voter count, if voting needs one, is a
+ *    voting-layer aggregate computed after discovery+verification, not a matchmaking message.
+ * 4. **Quorum-assembler delegation.** The seeker role may be held by the coordinator itself or by a
+ *    delegated assembler peer; whoever holds it owns `patienceMs` and the reply-side re-validation duty.
+ *    A delegated assembler returns an already-validated {@link ProviderEntryV1}`[]`; because every entry
+ *    carries `registrationSig` + the proof in `capabilities`, the set is independently checkable, so the
+ *    coordinator MAY re-validate (trust-but-verify) on receipt by re-running the verify→select pipeline.
+ *
+ * ## Architecture seam
+ *
+ * db-core is transport-free, so the actual discovery I/O (the register/query/renew walk, the root
+ * `AggregateCountV1` sweep) is **injected** as a {@link QuorumDiscovery} port — exactly as the seeker
+ * walk client and entry verifier are injected elsewhere in this module. db-p2p binds the port to
+ * `MatchmakingSeeker.walk` (single-cohort) and `multi-cohort-seeker` (sweep). The assembler itself never
+ * dials voters, never collects ballots, never tallies.
+ */
+import { type MatchTopicAnchor } from "./topic-anchor.js";
+import { type ProviderEntryV1, type EntrySigVerifier } from "./wire.js";
+/** Default concurrent-vote-collection budget for a registered voter — accepts one vote-collection RPC. */
+export declare const DEFAULT_VOTER_CAPACITY_BUDGET = 1;
+/**
+ * Indicative `patienceMs` range for voting-quorum assembly (`docs/matchmaking.md` §Patience budgeting).
+ * Advisory only — the layer does not dictate; {@link VotingQuorumAssembler.assembleQuorum} requires a
+ * positive budget but does not clamp to this window.
+ */
+export declare const VOTING_PATIENCE_MIN_MS = 30000;
+export declare const VOTING_PATIENCE_MAX_MS = 300000;
+/**
+ * Reserved capability-tag prefix carrying a voter's opaque eligibility proof. The proof is bound into the
+ * provider `capabilities`, which {@link import("./wire.js").providerSigningPayload} covers, so the
+ * provider's `registrationSig` attests the proof verbatim. The caller's `verifyEligibility` predicate
+ * reads it back from the forwarded entry via {@link eligibilityProofOf}.
+ */
+export declare const ELIGIBILITY_TAG_PREFIX = "voter-eligibility:";
+/** Encode an opaque eligibility proof as the reserved capability tag. */
+export declare function eligibilityTag(proof: string): string;
+/** Extract the eligibility proof from a capability set, or `undefined` if no eligibility tag is present. */
+export declare function eligibilityProofFromCapabilities(capabilities: readonly string[]): string | undefined;
+/** Extract the eligibility proof carried by a forwarded {@link ProviderEntryV1} (`undefined` if absent). */
+export declare function eligibilityProofOf(entry: ProviderEntryV1): string | undefined;
+/** One discovery slice: candidate entries plus the hotness signal that drives the single-vs-sweep choice. */
+export interface QuorumDiscoverySlice {
+    /** Candidate provider entries returned by this discovery hop (advisory — the assembler re-verifies). */
+    readonly entries: readonly ProviderEntryV1[];
+    /**
+     * Max `topicTraffic.childCohortCount` observed across the walked tiers. `> 0` means the topic has
+     * promoted (it is hot), so a single-cohort sample is unrepresentative and the assembler escalates to
+     * the multi-cohort sweep. The sweep hop sets this to `0` (the decision is already made).
+     */
+    readonly childCohortCount: number;
+}
+/** Inputs to one discovery hop. */
+export interface QuorumDiscoveryRequest {
+    /** The quorum topic id (`H("quorum" ‖ proposalHash ‖ "match")`). */
+    readonly topicId: Uint8Array;
+    /** Providers desired (drives the hang-out feasibility math / how many shards the sweep unions). */
+    readonly wantCount: number;
+    /** Patience budget remaining for this hop (ms); drains across walk → sweep. */
+    readonly patienceMs: number;
+}
+/**
+ * The discovery surface {@link VotingQuorumAssembler} composes over. db-p2p binds:
+ * - {@link QuorumDiscovery.walk} → `MatchmakingSeeker.walk` (single-cohort hang-out walk), and
+ * - {@link QuorumDiscovery.sweep} → `multi-cohort-seeker` (root `AggregateCountV1` → tier shards union).
+ *
+ * Both surface already-deduped, `registrationSig`-validated entries in production; the assembler treats
+ * them as advisory candidates and re-validates regardless, which keeps the delegated-assembler
+ * (trust-but-verify) path and the mock-tier test fixtures honest.
+ */
+export interface QuorumDiscovery {
+    /** Single-cohort hang-out walk; returns matched candidates plus the observed hotness signal. */
+    walk(req: QuorumDiscoveryRequest): Promise<QuorumDiscoverySlice>;
+    /** Multi-cohort sweep across high-population tier shards; returns the unioned candidate slice. */
+    sweep(req: QuorumDiscoveryRequest): Promise<QuorumDiscoverySlice>;
+}
+/** A request to assemble a voting quorum for one proposal. All voting-layer policy is injected here. */
+export interface VotingQuorumRequest {
+    /** The proposal hash — the quorum topic's label. */
+    readonly proposalHash: string;
+    /** Desired quorum size (integer `>= 1`). */
+    readonly targetSize: number;
+    /** Patience budget (ms); positive. Voting range is 30–300 s (§Patience budgeting), advisory. */
+    readonly patienceMs: number;
+    /** Voting/stake-layer eligibility predicate over the opaque proof in an entry's `capabilities`. */
+    readonly verifyEligibility: (entry: ProviderEntryV1) => boolean;
+    /** Voting-layer quorum selection rule; default = first `targetSize`. Must choose from the input set. */
+    readonly select?: (eligible: ProviderEntryV1[], targetSize: number) => ProviderEntryV1[];
+    /** Optional, additive reputation pre-filter applied *before* verification to trim candidates. */
+    readonly reputationPrefilter?: (candidates: ProviderEntryV1[]) => ProviderEntryV1[];
+    /** Force the multi-cohort sweep even when a single-cohort walk would suffice (representativeness). */
+    readonly preferSweep?: boolean;
+}
+/** The outcome of {@link VotingQuorumAssembler.assembleQuorum}. */
+export interface VotingQuorumResult {
+    /** The selected, eligibility-verified quorum, deduped by `participantId`. */
+    readonly quorum: ProviderEntryV1[];
+    /** Distinct candidates discovery surfaced (after dedup, before eligibility filtering). */
+    readonly candidates: number;
+    /** Candidates that passed `registrationSig` re-validation **and** `verifyEligibility`. */
+    readonly eligible: number;
+    /** Whether the assembled quorum met `targetSize` (`quorum.length >= targetSize`). */
+    readonly metTarget: boolean;
+    /** Whether the multi-cohort sweep was used (hot topic or `preferSweep`). */
+    readonly swept: boolean;
+}
+/** Construction inputs for a {@link VotingQuorumAssembler}; deps are per-role and validated at call time. */
+export interface VotingQuorumAssemblerDeps {
+    /** Stable topic anchor; defaults to db-core's ring-hash anchor ({@link createMatchTopicAnchor}). */
+    readonly anchor?: MatchTopicAnchor;
+    /** Discovery surface (walk + sweep) — required by {@link VotingQuorumAssembler.assembleQuorum}. */
+    readonly discovery?: QuorumDiscovery;
+    /**
+     * Per-entry `registrationSig` verifier (db-p2p binds `verifyPeerSig`) — required by
+     * {@link VotingQuorumAssembler.assembleQuorum}. db-core is crypto-free, so the peer-key check is
+     * injected, matching {@link verifyProviderEntry}'s contract.
+     */
+    readonly verifyEntrySig?: EntrySigVerifier;
+    /** Sign a provider registration image — required by {@link VotingQuorumAssembler.registerEligibleVoter}. */
+    readonly sign?: (payload: Uint8Array) => Promise<string>;
+    /**
+     * Register a signed voter-provider payload at the quorum topic (cohort-topic T2) — required by
+     * {@link VotingQuorumAssembler.registerEligibleVoter}. db-p2p binds this to the provider manager /
+     * `MatchmakingProvider.register` once `matchmaking-sweep-adversarial-module` lands.
+     */
+    readonly registerProvider?: (req: RegisterVoterProviderRequest) => Promise<void>;
+    /** CSPRNG source for the provider correlation id (injectable for deterministic tests). */
+    readonly randomBytes?: (n: number) => Uint8Array;
+    /** Wall clock (unix ms), injectable for tests; default `Date.now`. Splits patience across walk → sweep. */
+    readonly clock?: () => number;
+}
+/** What {@link VotingQuorumAssembler.registerEligibleVoter} hands the injected `registerProvider` port. */
+export interface RegisterVoterProviderRequest {
+    /** The quorum topic id this voter registers at. */
+    readonly topicId: Uint8Array;
+    /** The opaque, signed cohort-topic `RegisterV1.appPayload` bytes for the voter provider. */
+    readonly appPayloadBytes: Uint8Array;
+}
+/** Construction inputs for {@link VotingQuorumAssembler.registerEligibleVoter}. */
+export interface RegisterEligibleVoterRequest {
+    /** The proposal hash — the quorum topic's label. */
+    readonly proposalHash: string;
+    /** base64url, app-defined eligibility proof minted by the voting/stake layer. */
+    readonly eligibilityProof: string;
+    /** Extra application capability tags merged into the registration (the proof tag is always added). */
+    readonly capabilityTags?: readonly string[];
+    /** Concurrent vote-collection budget; default {@link DEFAULT_VOTER_CAPACITY_BUDGET} (1). */
+    readonly capacityBudget?: number;
+    /** Multiaddr or PeerId-based callback for the vote-collection dial. */
+    readonly contactHint: string;
+    /** Optional soft expiry hint (unix ms). */
+    readonly serviceUntil?: number;
+}
+/**
+ * Discovery-only voting-quorum assembler over the matchmaking module. One instance can act in either
+ * role: a voter calls {@link registerEligibleVoter}; a coordinator (or delegated assembler) calls
+ * {@link assembleQuorum}. Deps are role-specific and asserted per method, so a coordinator need not
+ * supply `sign`/`registerProvider` and a voter need not supply `discovery`/`verifyEntrySig`.
+ */
+export declare class VotingQuorumAssembler {
+    private readonly anchor;
+    private readonly deps;
+    private readonly clock;
+    constructor(deps?: VotingQuorumAssemblerDeps);
+    /**
+     * The quorum topic anchor for a proposal: `kind = "quorum"`, `label = proposalHash`, yielding
+     * `topicId = H("quorum" ‖ proposalHash ‖ "match")` via the matchmaking topic anchor.
+     */
+    static quorumTopic(proposalHash: string): {
+        kind: "quorum";
+        label: string;
+    };
+    /** Resolve the cohort-topic `topicId` for a proposal's quorum topic. */
+    topicIdFor(proposalHash: string): Uint8Array;
+    /**
+     * Voter side: bind the caller-minted eligibility proof into `capabilities`, build the signed provider
+     * registration, and register it at the quorum topic (cohort-topic T2). The proof is opaque to
+     * matchmaking; the provider `signature` covers `(topicId, capabilities, capacityBudget)`, so it binds
+     * the proof to the registration.
+     */
+    registerEligibleVoter(req: RegisterEligibleVoterRequest): Promise<void>;
+    /**
+     * Coordinator / delegated-assembler side: discover → verify → select. Drives the single-cohort walk,
+     * escalates to the multi-cohort sweep on a hot topic (`childCohortCount > 0`) or when `preferSweep`,
+     * dedups by `participantId`, applies the optional reputation pre-filter, re-validates each entry's
+     * `registrationSig` **and** `verifyEligibility`, then applies the selection rule. Passes the *draining*
+     * patience budget to each discovery hop (walk, then sweep) — the deadline is fixed at entry and each
+     * hop receives the remaining slice — and on exhaustion returns whatever matched with `metTarget = false`.
+     * (Both legs honour `patienceMs`: the walk enforces a wall-clock deadline across hops and hang-out; the
+     * sweep stops starting new shard queries once the budget drains. The residual is at most one in-flight
+     * shard RPC — assembly never blocks materially past `patienceMs`.)
+     */
+    assembleQuorum(req: VotingQuorumRequest): Promise<VotingQuorumResult>;
+    private requireDiscovery;
+    private requireVerifyEntrySig;
+    private requireSign;
+    private requireRegisterProvider;
+}
+/** The default selection rule: take the first `targetSize` eligible entries (the discovery order). */
+export declare function defaultSelect(eligible: ProviderEntryV1[], targetSize: number): ProviderEntryV1[];
+//# sourceMappingURL=voting-quorum.d.ts.map

package/dist/src/matchmaking/voting-quorum.d.ts.map

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