@serfab/cadre-core 0.13.0 → 1.0.0

package/src/control-authorization.ts

@@ -38,6 +38,7 @@ export const CONTROL_TABLES = [
   'OwnerKey',
   'ValidationKey',
   'Strand',
+  'StrandPartyKey',
   'CadrePeer',
   'DeviceToken',
   'FormationInvite',
@@ -63,7 +64,7 @@ export type ControlTable = typeof CONTROL_TABLES[number];
  * (`control-database.ts`) so the lightweight signers — `peer-authorization.ts`'s
  * `revocationDigest` — can type against it without pulling in the runtime.
  */
-export type RevocableTable = Extract<ControlTable, 'OwnerKey' | 'CadrePeer' | 'ValidationKey' | 'Strand' | 'DeviceToken'>;
+export type RevocableTable = Extract<ControlTable, 'OwnerKey' | 'CadrePeer' | 'ValidationKey' | 'Strand' | 'StrandPartyKey' | 'DeviceToken'>;
 
 /**
  * What a signature authorizes, scoped to one table rule — or, for

package/src/control-cohort.ts

@@ -1,130 +1,122 @@
-/**
- * Control-cohort dial selection: the pure policy behind
- * {@link CadreNode.reconcileControlCohort}. Decides WHICH known cadre siblings a
- * node proactively dials each pass to keep the `CadreControl` collections' cohort
- * connected (and thus replicating), without devolving into an N² mesh.
- *
- * FRET only needs a *connected* graph with the block clusters reachable, not a
- * full mesh. Storage/owner nodes are the stable, publicly-dialable backbone
- * that hold the control blocks, so the policy is **backbone-preferential with a
- * bounded out-degree**:
- *
- * - **Always dial every backbone (owner) member** — the owner set is
- *   small by design, and routing cohort formation through publicly-dialable
- *   owner nodes keeps the cohort ≥2 where owner-signed writes originate.
- * - **Fill the remainder** up to `targetDegree` with non-owner members,
- *   ordered deterministically (peerId sort) so every node makes the same stable
- *   choice across passes and load spreads predictably.
- *
- * For a small party (members ≤ degree) this degenerates to a full mesh, which is
- * correct, cheap, and matches what the convergence tests do by hand; for a large
- * party it bounds out-degree to `backbone + targetDegree`.
- */
-
-import { ed25519PublicKeyB64FromPeerId } from './seed-bootstrap.js';
-import type { CohortPeerRow } from './strand-cohort.js';
-
-/**
- * Default recurring cadence for {@link CadreNode.reconcileControlCohort} (ms).
- * In the same spirit as the 5s strand-watch poll but lighter, since a control
- * cohort changes far less often than strand activity.
- */
-export const DEFAULT_CONTROL_COHORT_RECONCILE_MS = 15_000;
-
-/**
- * Default cap on the number of **non-owner** members a single reconcile pass
- * proactively dials. Backbone (owner) members are always dialed and do NOT
- * count against this cap.
- */
-export const DEFAULT_CONTROL_COHORT_TARGET_DEGREE = 6;
-
-/**
- * Default per-sibling budget for one proactive control-cohort dial, in ms.
- *
- * `libp2p.dial(addrs)` is handed EVERY address a sibling resolved to, and each
- * one carries its own attempt timeout (js-libp2p's default is ~10 s, and
- * `@optimystic/db-p2p` does not override it). Some addresses cost more than one
- * attempt on their own: a `…/p2p-circuit/webrtc/…` address makes
- * `@libp2p/webrtc` dial the signalling leg to the relay hop FIRST and only then
- * the peer, so a two-address WebRTC sibling can block the sequential dial loop
- * for four attempt timeouts. Against unroutable addresses none of those attempts
- * ever answers, so an offline sibling's cost is address fan-out × relay hops ×
- * ~10 s — a number nothing in this package chose or bounds.
- *
- * This budget makes the SIBLING the unit instead of the address: one pass costs
- * at most (dialed siblings) × this, whatever each sibling's addresses look like.
- * Deliberately wider than one attempt timeout so a reachable sibling whose first
- * address is stale still gets a genuine try at its later ones; a sibling that
- * needs longer than this is simply retried next pass (every
- * {@link DEFAULT_CONTROL_COHORT_RECONCILE_MS}), which is what the dial loop's
- * best-effort contract already does with any other dial failure.
- *
- * Override per node with `network.controlCohort.dialTimeoutMs` — tests that
- * drive dead addresses on purpose set it low so a pass's duration is a chosen
- * number rather than a transitive libp2p default stretched by machine load.
- */
-export const DEFAULT_CONTROL_COHORT_DIAL_TIMEOUT_MS = 20_000;
-
-/** Outcome of {@link selectControlCohortDials}: who to dial + what the cap dropped. */
-export interface ControlCohortSelection {
-  /**
-   * Siblings to dial this pass, backbone first then the bounded non-owner
-   * fill. Already self-excluded (the caller must pass self-excluded `siblings`).
-   * Still includes peers that may turn out to be already-connected — the caller
-   * diffs against live connections separately.
-   */
-  dials: CohortPeerRow[];
-  /** Non-owner members dropped by the `targetDegree` cap (0 when none). */
-  cappedNonOwner: number;
-}
-
-/** Stable peerId ordering so the bounded fill is identical across passes/nodes. */
-function byPeerId(a: CohortPeerRow, b: CohortPeerRow): number {
-  if (a.peerId < b.peerId) return -1;
-  if (a.peerId > b.peerId) return 1;
-  return 0;
-}
-
-/**
- * Backbone-preferential, bounded-out-degree selection of control-cohort siblings
- * to dial.
- *
- * A member is **backbone** iff the ed25519 key derived from its peerId
- * (see {@link ed25519PublicKeyB64FromPeerId}) is in `ownerKeys`. All backbone
- * members are selected; non-owner members fill up to `targetDegree` in
- * deterministic peerId order.
- *
- * @param siblings - cadre members EXCLUDING self (the caller filters self out).
- * @param ownerKeys - the converged `OwnerKey` set; may be empty/partial
- *   before owner convergence, in which case no member classifies as backbone
- *   yet and the bounded fill still makes progress (preference sharpens later).
- * @param targetDegree - cap on non-owner dials (negative is treated as 0).
- */
-export function selectControlCohortDials(
-  siblings: CohortPeerRow[],
-  ownerKeys: ReadonlySet<string>,
-  targetDegree: number,
-): ControlCohortSelection {
-  const backbone: CohortPeerRow[] = [];
-  const rest: CohortPeerRow[] = [];
-
-  for (const peer of siblings) {
-    const pubKey = ed25519PublicKeyB64FromPeerId(peer.peerId);
-    if (pubKey !== null && ownerKeys.has(pubKey)) {
-      backbone.push(peer);
-    } else {
-      rest.push(peer);
-    }
-  }
-
-  backbone.sort(byPeerId);
-  rest.sort(byPeerId);
-
-  const cap = Math.max(0, targetDegree);
-  const fill = rest.slice(0, cap);
-
-  return {
-    dials: [...backbone, ...fill],
-    cappedNonOwner: rest.length - fill.length,
-  };
-}
+/**
+ * Control-cohort dial selection: the pure policy behind
+ * {@link CadreNode.reconcileControlCohort}. Decides WHICH known cadre siblings a
+ * node proactively dials each pass to keep the `CadreControl` collections' cohort
+ * connected (and thus replicating), without devolving into an N² mesh.
+ *
+ * FRET only needs a *connected* graph with the block clusters reachable, not a
+ * full mesh. Storage/owner nodes are the stable, publicly-dialable backbone
+ * that hold the control blocks, so the policy is **backbone-preferential with a
+ * bounded out-degree**:
+ *
+ * - **Always dial every backbone (owner) member** — the owner set is
+ *   small by design, and routing cohort formation through publicly-dialable
+ *   owner nodes keeps the cohort ≥2 where owner-signed writes originate.
+ * - **Fill the remainder** up to `targetDegree` with non-owner members,
+ *   ordered deterministically (peerId sort) so every node makes the same stable
+ *   choice across passes and load spreads predictably.
+ *
+ * For a small party (members ≤ degree) this degenerates to a full mesh, which is
+ * correct, cheap, and matches what the convergence tests do by hand; for a large
+ * party it bounds out-degree to `backbone + targetDegree`.
+ */
+
+import { ed25519PublicKeyB64FromPeerId } from './seed-bootstrap.js';
+import type { CohortPeerRow } from './strand-cohort.js';
+
+/**
+ * Default recurring cadence for {@link CadreNode.reconcileControlCohort} (ms).
+ * In the same spirit as the 5s strand-watch poll but lighter, since a control
+ * cohort changes far less often than strand activity.
+ */
+export const DEFAULT_CONTROL_COHORT_RECONCILE_MS = 15_000;
+
+/**
+ * Default cap on the number of **non-owner** members a single reconcile pass
+ * proactively dials. Backbone (owner) members are always dialed and do NOT
+ * count against this cap.
+ */
+export const DEFAULT_CONTROL_COHORT_TARGET_DEGREE = 6;
+
+// The per-sibling and per-address dial time limits live in `peer-dial.ts`
+// (`DEFAULT_CONTROL_COHORT_DIAL_TIMEOUT_MS`,
+// `DEFAULT_CONTROL_COHORT_PER_ADDRESS_DIAL_TIMEOUT_MS`), beside the dial they
+// bound, which `seed-bootstrap.ts` also uses and cannot import from here.
+
+/** Outcome of {@link selectControlCohortDials}: who to dial + what the cap dropped. */
+export interface ControlCohortSelection {
+  /**
+   * Siblings to dial this pass, backbone first then the bounded non-owner
+   * fill. Already self-excluded (the caller must pass self-excluded `siblings`).
+   * Still includes peers that may turn out to be already-connected — the caller
+   * diffs against live connections separately.
+   */
+  dials: CohortPeerRow[];
+  /** Non-owner members dropped by the `targetDegree` cap (0 when none). */
+  cappedNonOwner: number;
+}
+
+/** What one {@link CadreNode.reconcileControlCohort} pass did. */
+export interface ControlCohortReconcileResult {
+  /**
+   * Peer ids this pass dialled and whose dial resolved, in dial order: selected
+   * siblings on the steady-state pass, retained bootstrap peers on the cold-start
+   * pass (the pass takes one branch or the other, never both). A peer already
+   * connected when the pass began is never listed — the pass skips it. A resolved
+   * dial can still be refused moments later by the remote's membership gate, so
+   * an entry means "this pass opened a connection", not "that connection is still
+   * open".
+   */
+  dialed: string[];
+}
+
+/** Stable peerId ordering so the bounded fill is identical across passes/nodes. */
+function byPeerId(a: CohortPeerRow, b: CohortPeerRow): number {
+  if (a.peerId < b.peerId) return -1;
+  if (a.peerId > b.peerId) return 1;
+  return 0;
+}
+
+/**
+ * Backbone-preferential, bounded-out-degree selection of control-cohort siblings
+ * to dial.
+ *
+ * A member is **backbone** iff the ed25519 key derived from its peerId
+ * (see {@link ed25519PublicKeyB64FromPeerId}) is in `ownerKeys`. All backbone
+ * members are selected; non-owner members fill up to `targetDegree` in
+ * deterministic peerId order.
+ *
+ * @param siblings - cadre members EXCLUDING self (the caller filters self out).
+ * @param ownerKeys - the converged `OwnerKey` set; may be empty/partial
+ *   before owner convergence, in which case no member classifies as backbone
+ *   yet and the bounded fill still makes progress (preference sharpens later).
+ * @param targetDegree - cap on non-owner dials (negative is treated as 0).
+ */
+export function selectControlCohortDials(
+  siblings: CohortPeerRow[],
+  ownerKeys: ReadonlySet<string>,
+  targetDegree: number,
+): ControlCohortSelection {
+  const backbone: CohortPeerRow[] = [];
+  const rest: CohortPeerRow[] = [];
+
+  for (const peer of siblings) {
+    const pubKey = ed25519PublicKeyB64FromPeerId(peer.peerId);
+    if (pubKey !== null && ownerKeys.has(pubKey)) {
+      backbone.push(peer);
+    } else {
+      rest.push(peer);
+    }
+  }
+
+  backbone.sort(byPeerId);
+  rest.sort(byPeerId);
+
+  const cap = Math.max(0, targetDegree);
+  const fill = rest.slice(0, cap);
+
+  return {
+    dials: [...backbone, ...fill],
+    cappedNonOwner: rest.length - fill.length,
+  };
+}