instar 1.3.524 → 1.3.526

package/dist/core/ReplicatedStoreReader.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ReplicatedStoreReader — the LOWEST store-access primitive, the single funnel
+ * every replicated-store read routes through so no caller can bypass the
+ * no-clobber union rule (WS2 replicated-store foundation, Component 6 / §7.2).
+ *
+ * Spec: docs/specs/multi-machine-replicated-store-foundation.md §7.1 (namespaced
+ * per-origin storage), §7.2 (the union of local + replicated state computed at the
+ * LOWEST primitive — enforced by a wiring-integrity test, §12 #11), §7.4 (a
+ * dropped origin is excluded from the union LIVE), §11 (machine-local-by-design:
+ * computed from the local own + local replica namespaces, no cross-machine call
+ * on the read path).
+ *
+ * THE BYPASS-PROOF FUNNEL. A store's materialized replicated state is the UNION
+ * over every participating origin namespace: the own stream + each non-dropped
+ * peer replica. This reader is the ONE place that composes that union (via
+ * UnionReader.readUnion) — a consumer store reads THROUGH it, never around it. The
+ * wiring-integrity test asserts the reader's seams are dependency-injected and not
+ * null / not no-ops.
+ *
+ * PURE-ish: all I/O is the injected `loadOriginRecords` seam (the real wiring reads
+ * the CoherenceJournal own stream + the peers/ replica streams for the store's
+ * kind(s)). The reader itself only composes + merges + records conflicts —
+ * bounded, no fs, no Date directly.
+ */
+import type { ReplicatedKindRegistry } from './ReplicatedRecordEnvelope.js';
+import { type ImpactTier, type OriginRecord, type UnionResult } from './UnionReader.js';
+import type { ConflictStore } from './ConflictStore.js';
+import type { DroppedOriginRegistry } from './RollbackUnmerge.js';
+import type { StateSyncStores } from './ReplicatedRecordEnvelope.js';
+/** The seams the reader needs (DI'd so the wiring-integrity test can assert they
+ *  are real, never null/no-op). */
+export interface ReplicatedStoreReaderSeams {
+    /** The replicated-kind registry — the reader serves ONLY registered stores. */
+    registry: ReplicatedKindRegistry;
+    /** The per-store stateSync flags (a store read is a no-op when its store is not
+     *  enabled — the dark-by-default posture). */
+    stores: StateSyncStores | undefined;
+    /** The store's impact tier (high/low) — governs concurrent-edit behavior. A
+     *  store declares its tier at registration; the default is HIGH (the
+     *  conservative side — append-both-and-flag never silently clobbers). */
+    tierOf: (store: string) => ImpactTier;
+    /**
+     * Load EVERY origin's current record for (store, recordKey) — the own stream +
+     * each peer replica namespace, keyed by origin (one record per origin, the
+     * latest by HLC). This is the per-origin materialization the union merges. The
+     * real wiring reads the CoherenceJournal own stream + the peers/ replica files
+     * for the store's kind(s); a single-machine install returns only the own
+     * origin (so the union is a strict no-op = that one record).
+     */
+    loadOriginRecords: (store: string, recordKey: string) => OriginRecord[];
+    /** Enumerate every recordKey the store currently holds across all origins (for
+     *  readAll). The real wiring scans the own + replica streams. */
+    listRecordKeys: (store: string) => string[];
+    /** The durable un-merged (store, origin) set — a dropped origin is excluded
+     *  from the union LIVE (§7.4). */
+    droppedOrigins: DroppedOriginRegistry;
+    /** The conflict ledger — a HIGH-impact concurrent divergence is recorded here
+     *  (idempotent on the stable conflictId). */
+    conflictStore: ConflictStore;
+}
+export declare class ReplicatedStoreReader {
+    private readonly seams;
+    constructor(seams: ReplicatedStoreReaderSeams);
+    /** Is this store registered + enabled (so a read is non-dark)? A read on an
+     *  unregistered or disabled store returns a strict no-op (no record). */
+    private isLive;
+    /**
+     * Read one recordKey through the union (§7.2). Returns the no-clobber union
+     * result: the resolved value, a conflict descriptor (HIGH-impact concurrent),
+     * or a divergence flag (LOW-impact concurrent). A HIGH-impact conflict is
+     * RECORDED in the conflict ledger (idempotent) as a side-effect so it is
+     * surfaced for operator resolution — the read NEVER clobbers a divergent record.
+     *
+     * Live-recompute (§7.4): the dropped-origin set is consulted HERE, so a
+     * rolled-back origin is excluded from the union instantly with no rewrite.
+     */
+    read(store: string, recordKey: string): UnionResult;
+    /** Read every recordKey the store holds, as a recordKey → UnionResult map (§7.2).
+     *  Conflicts are recorded as a side-effect (same as read). Bounded by the live
+     *  key count. */
+    readAll(store: string): Map<string, UnionResult>;
+}
+//# sourceMappingURL=ReplicatedStoreReader.d.ts.map

package/dist/core/ReplicatedStoreReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplicatedStoreReader.d.ts","sourceRoot":"","sources":["../../src/core/ReplicatedStoreReader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;mCACmC;AACnC,MAAM,WAAW,0BAA0B;IACzC,+EAA+E;IAC/E,QAAQ,EAAE,sBAAsB,CAAC;IACjC;kDAC8C;IAC9C,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC;IACpC;;6EAEyE;IACzE,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,UAAU,CAAC;IACtC;;;;;;;OAOG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,YAAY,EAAE,CAAC;IACxE;qEACiE;IACjE,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IAC5C;sCACkC;IAClC,cAAc,EAAE,qBAAqB,CAAC;IACtC;iDAC6C;IAC7C,aAAa,EAAE,aAAa,CAAC;CAC9B;AASD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;gBAEvC,KAAK,EAAE,0BAA0B;IAY7C;6EACyE;IACzE,OAAO,CAAC,MAAM;IAKd;;;;;;;;;OASG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW;IAkBnD;;qBAEiB;IACjB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;CAQjD"}

package/dist/core/ReplicatedStoreReader.js

@@ -0,0 +1,100 @@
+/**
+ * ReplicatedStoreReader — the LOWEST store-access primitive, the single funnel
+ * every replicated-store read routes through so no caller can bypass the
+ * no-clobber union rule (WS2 replicated-store foundation, Component 6 / §7.2).
+ *
+ * Spec: docs/specs/multi-machine-replicated-store-foundation.md §7.1 (namespaced
+ * per-origin storage), §7.2 (the union of local + replicated state computed at the
+ * LOWEST primitive — enforced by a wiring-integrity test, §12 #11), §7.4 (a
+ * dropped origin is excluded from the union LIVE), §11 (machine-local-by-design:
+ * computed from the local own + local replica namespaces, no cross-machine call
+ * on the read path).
+ *
+ * THE BYPASS-PROOF FUNNEL. A store's materialized replicated state is the UNION
+ * over every participating origin namespace: the own stream + each non-dropped
+ * peer replica. This reader is the ONE place that composes that union (via
+ * UnionReader.readUnion) — a consumer store reads THROUGH it, never around it. The
+ * wiring-integrity test asserts the reader's seams are dependency-injected and not
+ * null / not no-ops.
+ *
+ * PURE-ish: all I/O is the injected `loadOriginRecords` seam (the real wiring reads
+ * the CoherenceJournal own stream + the peers/ replica streams for the store's
+ * kind(s)). The reader itself only composes + merges + records conflicts —
+ * bounded, no fs, no Date directly.
+ */
+import { readUnion, } from './UnionReader.js';
+// RULE 3: EXEMPT — this is NOT a state-detector. ReplicatedStoreReader is a
+// pure store-access funnel that composes the no-clobber union over already-loaded
+// per-origin records (via the injected loadOriginRecords seam). It does not parse
+// provider/CLI output, does not detect external/environment state, and has no
+// signature-matching that could drift across providers — it merely merges
+// in-memory records by HLC + the witness rule. The "*Reader" name matches the
+// Rule-3 pattern heuristic but the substance is a deterministic in-memory merge.
+export class ReplicatedStoreReader {
+    seams;
+    constructor(seams) {
+        // Wiring-integrity preconditions (§12 #11): the seams MUST be real, not null.
+        if (!seams)
+            throw new Error('ReplicatedStoreReader: seams are required');
+        if (!seams.registry)
+            throw new Error('ReplicatedStoreReader: registry seam is required (not null)');
+        if (typeof seams.loadOriginRecords !== 'function')
+            throw new Error('ReplicatedStoreReader: loadOriginRecords seam must be a function (not a no-op)');
+        if (typeof seams.listRecordKeys !== 'function')
+            throw new Error('ReplicatedStoreReader: listRecordKeys seam must be a function (not a no-op)');
+        if (!seams.droppedOrigins)
+            throw new Error('ReplicatedStoreReader: droppedOrigins seam is required (not null)');
+        if (!seams.conflictStore)
+            throw new Error('ReplicatedStoreReader: conflictStore seam is required (not null)');
+        if (typeof seams.tierOf !== 'function')
+            throw new Error('ReplicatedStoreReader: tierOf seam must be a function');
+        this.seams = seams;
+    }
+    /** Is this store registered + enabled (so a read is non-dark)? A read on an
+     *  unregistered or disabled store returns a strict no-op (no record). */
+    isLive(store) {
+        if (!this.seams.registry.getByStore(store))
+            return false;
+        return this.seams.stores?.[store]?.enabled === true;
+    }
+    /**
+     * Read one recordKey through the union (§7.2). Returns the no-clobber union
+     * result: the resolved value, a conflict descriptor (HIGH-impact concurrent),
+     * or a divergence flag (LOW-impact concurrent). A HIGH-impact conflict is
+     * RECORDED in the conflict ledger (idempotent) as a side-effect so it is
+     * surfaced for operator resolution — the read NEVER clobbers a divergent record.
+     *
+     * Live-recompute (§7.4): the dropped-origin set is consulted HERE, so a
+     * rolled-back origin is excluded from the union instantly with no rewrite.
+     */
+    read(store, recordKey) {
+        if (!this.isLive(store)) {
+            return { recordKey, value: null, conflict: null, divergenceFlag: false };
+        }
+        const dropped = this.seams.droppedOrigins.droppedOrigins(store);
+        const all = this.seams.loadOriginRecords(store, recordKey);
+        // §7.4 LIVE exclusion: drop any rolled-back origin from the participating set.
+        const participating = dropped.size === 0 ? all : all.filter((r) => !dropped.has(r.origin));
+        const result = readUnion(recordKey, participating, this.seams.tierOf(store));
+        if (result.conflict) {
+            // Record the HIGH-impact conflict (idempotent on its stable id; raises ONE
+            // deduped attention item). The read returns value=null (neither version
+            // clobbers) — the operator resolves it.
+            this.seams.conflictStore.recordConflict(store, result.conflict);
+        }
+        return result;
+    }
+    /** Read every recordKey the store holds, as a recordKey → UnionResult map (§7.2).
+     *  Conflicts are recorded as a side-effect (same as read). Bounded by the live
+     *  key count. */
+    readAll(store) {
+        const out = new Map();
+        if (!this.isLive(store))
+            return out;
+        for (const recordKey of this.seams.listRecordKeys(store)) {
+            out.set(recordKey, this.read(store, recordKey));
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=ReplicatedStoreReader.js.map

package/dist/core/ReplicatedStoreReader.js.map

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

package/dist/core/ReplicationBudget.d.ts

@@ -0,0 +1,183 @@
+/**
+ * ReplicationBudget — Component 7 bounds (WS2 replicated-store foundation, §8 +
+ * §8.1 Phase C).
+ *
+ * Spec: docs/specs/multi-machine-replicated-store-foundation.md §8 (per-store /
+ * per-record-class bounds, replication rate cap with COALESCING, the AGGREGATE
+ * journal budget that caps TOTAL bytes/sec across ALL kinds with proportional
+ * fair-share throttle, the sustained-failure breaker, the dark-peer accumulation
+ * bound + tombstone horizon forced full-snapshot re-join), §8.1 (Phase C: budgets
+ * = per-peer allowance × live online-peer count, hard pool-wide ceiling,
+ * hysteresis on the multiplier — NOT a 2-machine constant).
+ *
+ * PURE-ish: the clock is injected so the token buckets + hysteresis are
+ * unit-testable across simulated windows. No fs, no Date directly, no network.
+ *
+ * The ANTI-STARVATION invariant (§8): a flood on kind A must NOT consume kind B's
+ * replication share. The aggregate budget caps total bytes/sec; when pressured,
+ * per-kind caps throttle PROPORTIONALLY (fair-share) and the throttle is SURFACED
+ * in degradation (never a silent stall). A test enforces the budget ACROSS kinds.
+ */
+import { type HlcTimestamp } from './HybridLogicalClock.js';
+import type { KindRetention, RateCapConfig } from './CoherenceJournal.js';
+/**
+ * The per-replicated-kind bounds a concrete store (WS2.1+) ships when it
+ * registers its kind (§8): a `retention` window (maxFileBytes + rotateKeep) AND a
+ * token-bucket rate cap. The foundation provides the SHAPE + conservative
+ * defaults; a store overrides per kind. These extend the journal's existing
+ * DEFAULT_RETENTION / DEFAULT_RATE_CAP machinery — same types, applied to the
+ * replicated kind's own stream.
+ */
+export interface ReplicatedKindBounds {
+    retention: KindRetention;
+    rateCap: RateCapConfig;
+}
+/** Conservative default bounds for a replicated kind that does not override them.
+ *  A high-write store (preferences) should ship a tighter window; this is the
+ *  bounded fallback so a kind is NEVER unbounded. */
+export declare const DEFAULT_REPLICATED_KIND_BOUNDS: ReplicatedKindBounds;
+/** One coalesced pending replication: the LATEST record for a recordKey within
+ *  the current interval (a burst on one key collapses to one record). */
+export interface CoalescedRecord {
+    recordKey: string;
+    /** The opaque serialized record line (the journal entry to replicate). */
+    line: string;
+    /** Bytes the line would consume (for the budget accounting). */
+    bytes: number;
+    /** The HLC of the latest record (for last-wins coalescing within the interval). */
+    hlc: HlcTimestamp;
+}
+/**
+ * CoalescingReplicator — collapses a burst of edits to one recordKey into ONE
+ * replicated record per interval (§8 coalescing). `stage(recordKey, line, bytes,
+ * hlc)` keeps only the HLC-LATEST per key; `drain()` emits the coalesced set and
+ * clears the buffer for the next interval. Per replicated kind (one instance per
+ * kind), so a chatty kind cannot starve another — the aggregate budget below is
+ * the cross-kind guard.
+ */
+export declare class CoalescingReplicator {
+    private pending;
+    /** Stage a write; keeps only the HLC-latest per recordKey within the interval. */
+    stage(recordKey: string, line: string, bytes: number, hlc: HlcTimestamp): void;
+    /** The number of distinct keys currently coalesced (for observability). */
+    get pendingCount(): number;
+    /** The total bytes the coalesced set would replicate this interval. */
+    pendingBytes(): number;
+    /** Emit + clear the coalesced set (the LATEST per key). */
+    drain(): CoalescedRecord[];
+}
+/** Phase-C budget config (§8.1). */
+export interface PhaseCBudgetConfig {
+    /** Per-peer byte allowance (the unit scaled by online-peer count). */
+    perPeerBytes: number;
+    /** Hard pool-wide ceiling — the scaled budget is clamped here (protects a single
+     *  machine's disk/CPU regardless of pool size). */
+    hardCeilingBytes: number;
+    /** Hysteresis: the effective online-peer MULTIPLIER only RISES after the higher
+     *  peer count has been observed for `hysteresisRiseMs`; it falls immediately
+     *  (shrinking the budget on a real peer loss is the safe direction). A transient
+     *  peer-count SPIKE does not instantly widen the budget. */
+    hysteresisRiseMs: number;
+}
+/**
+ * Compute the Phase-C aggregate budget (§8.1): `min(perPeerBytes ×
+ * effectivePeerCount, hardCeilingBytes)`. NOT a 2-machine constant — a 5-machine
+ * pool gets a proportionally larger budget, bounded by the hard ceiling.
+ *
+ * The `effectivePeerCount` is the HYSTERESIS-damped online count (computed by
+ * PhaseCBudgetController below); this pure helper just applies the formula so it
+ * is independently testable.
+ */
+export declare function phaseCBudget(perPeerBytes: number, effectivePeerCount: number, hardCeilingBytes: number): number;
+/**
+ * PhaseCBudgetController — tracks the live online-peer count with hysteresis on
+ * the multiplier (§8.1). A RISE in peer count only takes effect after it has held
+ * for `hysteresisRiseMs` (a transient spike does not widen the budget); a FALL
+ * takes effect immediately (shrink-on-loss is safe). `currentBudget()` returns the
+ * live aggregate byte budget.
+ */
+export declare class PhaseCBudgetController {
+    private readonly cfg;
+    private readonly now;
+    private effectivePeerCount;
+    /** Seeded on the first observation — there is no prior narrower budget to
+     *  protect at bootstrap, so the first count takes effect immediately; only a
+     *  SUBSEQUENT rise is hysteresis-gated. */
+    private seeded;
+    /** A pending higher count + when it was first observed (for the rise hysteresis). */
+    private pendingRise;
+    constructor(cfg: PhaseCBudgetConfig, now: () => number);
+    /** Feed the live online-peer count (from the capacity heartbeat). Applies the
+     *  rise-hysteresis / immediate-fall policy and returns the effective count. */
+    observePeerCount(online: number): number;
+    /** The current effective (hysteresis-damped) online-peer count. */
+    getEffectivePeerCount(): number;
+    /** The current aggregate byte budget (§8.1). */
+    currentBudget(): number;
+}
+/** A per-kind throttle verdict (§8). When the aggregate budget is pressured, each
+ *  kind's allowance is its FAIR SHARE of the budget; an over-share request is
+ *  throttled (deferred to the next interval) and the throttle is surfaced. */
+export interface AggregateThrottleResult {
+    /** The bytes admitted this interval for the kind. */
+    admittedBytes: number;
+    /** The bytes deferred (throttled) — coalesced to the next interval, never dropped. */
+    throttledBytes: number;
+    /** True iff this kind was throttled (surfaced in degradation; never silent). */
+    throttled: boolean;
+}
+/** Degradation surface for the aggregate budget (§8 — never a silent stall). */
+export interface AggregateBudgetDegradation {
+    /** Intervals in which at least one kind was throttled. */
+    throttledIntervals: number;
+    /** Total bytes deferred across all kinds (cumulative). */
+    totalThrottledBytes: number;
+    /** Per-kind cumulative throttled bytes (so a starving kind is visible). */
+    perKindThrottledBytes: Record<string, number>;
+}
+/**
+ * AggregateJournalBudget — the cross-kind anti-starvation guard (§8). Each
+ * interval, the controller admits each kind's pending bytes up to its FAIR SHARE
+ * of the live aggregate budget; an over-share request is throttled (the surplus
+ * defers to the next interval, never dropped — coalescing already collapsed it to
+ * the latest state). The fair share is `budget / activeKindCount`, with UNUSED
+ * share from quiet kinds redistributed to the others (so a single chatty kind on
+ * an otherwise-idle pool still gets the whole budget — fair, not wasteful), but
+ * NEVER beyond a kind's own pending demand and never letting one kind exceed the
+ * aggregate while another has unserved demand.
+ *
+ * The §12 #9/#15 invariant: a flood on kind A is capped at its fair share when
+ * kind B also has demand — B keeps its share; A's surplus is deferred + surfaced.
+ */
+export declare class AggregateJournalBudget {
+    private readonly degradation;
+    /**
+     * Allocate the live aggregate `budgetBytes` across the kinds' pending demands
+     * for ONE interval. Returns per-kind throttle verdicts. Fair-share with
+     * redistribution of unused share, bounded by each kind's demand and the
+     * aggregate.
+     */
+    allocate(budgetBytes: number, demand: Record<string, number>): Record<string, AggregateThrottleResult>;
+    /** The cumulative degradation surface (§8 — surfaced, never a silent stall). */
+    getDegradation(): AggregateBudgetDegradation;
+}
+/** The re-join verdict for a recovering dark peer (§8). */
+export type RejoinVerdict = {
+    mode: 'tail';
+    fromSeq: number;
+} | {
+    mode: 'full-snapshot';
+    reason: 'beyond-tombstone-horizon' | 'below-oldest-retained';
+};
+/**
+ * Decide how a recovering peer re-joins a kind's stream (§8 dark-peer accumulation
+ * bound + tombstone horizon). If the peer's last-held seq is below the holder's
+ * `oldestRetainedSeq` (the tombstone for a delete may have rotated out), a stale
+ * tail would risk delete-resurrection — so the peer is FORCED to a full
+ * single-origin snapshot re-join (§6.5 delete-resurrection guard). Otherwise a
+ * normal seq tail from `lastHeldSeq` is safe.
+ *
+ * PURE: a function of the seqs — independently testable (§12 #13).
+ */
+export declare function rejoinVerdict(lastHeldSeq: number, oldestRetainedSeq: number): RejoinVerdict;
+//# sourceMappingURL=ReplicationBudget.d.ts.map

package/dist/core/ReplicationBudget.d.ts.map

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

package/dist/core/ReplicationBudget.js

@@ -0,0 +1,253 @@
+/**
+ * ReplicationBudget — Component 7 bounds (WS2 replicated-store foundation, §8 +
+ * §8.1 Phase C).
+ *
+ * Spec: docs/specs/multi-machine-replicated-store-foundation.md §8 (per-store /
+ * per-record-class bounds, replication rate cap with COALESCING, the AGGREGATE
+ * journal budget that caps TOTAL bytes/sec across ALL kinds with proportional
+ * fair-share throttle, the sustained-failure breaker, the dark-peer accumulation
+ * bound + tombstone horizon forced full-snapshot re-join), §8.1 (Phase C: budgets
+ * = per-peer allowance × live online-peer count, hard pool-wide ceiling,
+ * hysteresis on the multiplier — NOT a 2-machine constant).
+ *
+ * PURE-ish: the clock is injected so the token buckets + hysteresis are
+ * unit-testable across simulated windows. No fs, no Date directly, no network.
+ *
+ * The ANTI-STARVATION invariant (§8): a flood on kind A must NOT consume kind B's
+ * replication share. The aggregate budget caps total bytes/sec; when pressured,
+ * per-kind caps throttle PROPORTIONALLY (fair-share) and the throttle is SURFACED
+ * in degradation (never a silent stall). A test enforces the budget ACROSS kinds.
+ */
+import { HybridLogicalClock } from './HybridLogicalClock.js';
+/** Conservative default bounds for a replicated kind that does not override them.
+ *  A high-write store (preferences) should ship a tighter window; this is the
+ *  bounded fallback so a kind is NEVER unbounded. */
+export const DEFAULT_REPLICATED_KIND_BOUNDS = {
+    retention: { maxFileBytes: 8 * 1024 * 1024, rotateKeep: 4 },
+    rateCap: { capacity: 100, refillPerSec: 50 },
+};
+/**
+ * CoalescingReplicator — collapses a burst of edits to one recordKey into ONE
+ * replicated record per interval (§8 coalescing). `stage(recordKey, line, bytes,
+ * hlc)` keeps only the HLC-LATEST per key; `drain()` emits the coalesced set and
+ * clears the buffer for the next interval. Per replicated kind (one instance per
+ * kind), so a chatty kind cannot starve another — the aggregate budget below is
+ * the cross-kind guard.
+ */
+export class CoalescingReplicator {
+    pending = new Map();
+    /** Stage a write; keeps only the HLC-latest per recordKey within the interval. */
+    stage(recordKey, line, bytes, hlc) {
+        const prev = this.pending.get(recordKey);
+        if (prev && HybridLogicalClock.compare(hlc, prev.hlc) <= 0)
+            return; // older or equal — keep the newer.
+        this.pending.set(recordKey, { recordKey, line, bytes, hlc });
+    }
+    /** The number of distinct keys currently coalesced (for observability). */
+    get pendingCount() {
+        return this.pending.size;
+    }
+    /** The total bytes the coalesced set would replicate this interval. */
+    pendingBytes() {
+        let n = 0;
+        for (const r of this.pending.values())
+            n += r.bytes;
+        return n;
+    }
+    /** Emit + clear the coalesced set (the LATEST per key). */
+    drain() {
+        const out = [...this.pending.values()];
+        this.pending.clear();
+        return out;
+    }
+}
+/**
+ * Compute the Phase-C aggregate budget (§8.1): `min(perPeerBytes ×
+ * effectivePeerCount, hardCeilingBytes)`. NOT a 2-machine constant — a 5-machine
+ * pool gets a proportionally larger budget, bounded by the hard ceiling.
+ *
+ * The `effectivePeerCount` is the HYSTERESIS-damped online count (computed by
+ * PhaseCBudgetController below); this pure helper just applies the formula so it
+ * is independently testable.
+ */
+export function phaseCBudget(perPeerBytes, effectivePeerCount, hardCeilingBytes) {
+    const scaled = perPeerBytes * Math.max(0, effectivePeerCount);
+    return Math.min(scaled, hardCeilingBytes);
+}
+/**
+ * PhaseCBudgetController — tracks the live online-peer count with hysteresis on
+ * the multiplier (§8.1). A RISE in peer count only takes effect after it has held
+ * for `hysteresisRiseMs` (a transient spike does not widen the budget); a FALL
+ * takes effect immediately (shrink-on-loss is safe). `currentBudget()` returns the
+ * live aggregate byte budget.
+ */
+export class PhaseCBudgetController {
+    cfg;
+    now;
+    effectivePeerCount = 0;
+    /** Seeded on the first observation — there is no prior narrower budget to
+     *  protect at bootstrap, so the first count takes effect immediately; only a
+     *  SUBSEQUENT rise is hysteresis-gated. */
+    seeded = false;
+    /** A pending higher count + when it was first observed (for the rise hysteresis). */
+    pendingRise = null;
+    constructor(cfg, now) {
+        this.cfg = cfg;
+        this.now = now;
+    }
+    /** Feed the live online-peer count (from the capacity heartbeat). Applies the
+     *  rise-hysteresis / immediate-fall policy and returns the effective count. */
+    observePeerCount(online) {
+        const t = this.now();
+        // First observation seeds the baseline immediately (no prior budget to widen).
+        if (!this.seeded) {
+            this.seeded = true;
+            this.effectivePeerCount = online;
+            return this.effectivePeerCount;
+        }
+        if (online < this.effectivePeerCount) {
+            // Immediate fall — shrinking the budget on a real peer loss is safe.
+            this.effectivePeerCount = online;
+            this.pendingRise = null;
+            return this.effectivePeerCount;
+        }
+        if (online === this.effectivePeerCount) {
+            this.pendingRise = null;
+            return this.effectivePeerCount;
+        }
+        // online > effective — gate the rise behind hysteresis.
+        if (!this.pendingRise || this.pendingRise.count !== online) {
+            this.pendingRise = { count: online, since: t };
+            return this.effectivePeerCount;
+        }
+        if (t - this.pendingRise.since >= this.cfg.hysteresisRiseMs) {
+            this.effectivePeerCount = online;
+            this.pendingRise = null;
+        }
+        return this.effectivePeerCount;
+    }
+    /** The current effective (hysteresis-damped) online-peer count. */
+    getEffectivePeerCount() {
+        return this.effectivePeerCount;
+    }
+    /** The current aggregate byte budget (§8.1). */
+    currentBudget() {
+        return phaseCBudget(this.cfg.perPeerBytes, this.effectivePeerCount, this.cfg.hardCeilingBytes);
+    }
+}
+/**
+ * AggregateJournalBudget — the cross-kind anti-starvation guard (§8). Each
+ * interval, the controller admits each kind's pending bytes up to its FAIR SHARE
+ * of the live aggregate budget; an over-share request is throttled (the surplus
+ * defers to the next interval, never dropped — coalescing already collapsed it to
+ * the latest state). The fair share is `budget / activeKindCount`, with UNUSED
+ * share from quiet kinds redistributed to the others (so a single chatty kind on
+ * an otherwise-idle pool still gets the whole budget — fair, not wasteful), but
+ * NEVER beyond a kind's own pending demand and never letting one kind exceed the
+ * aggregate while another has unserved demand.
+ *
+ * The §12 #9/#15 invariant: a flood on kind A is capped at its fair share when
+ * kind B also has demand — B keeps its share; A's surplus is deferred + surfaced.
+ */
+export class AggregateJournalBudget {
+    degradation = {
+        throttledIntervals: 0,
+        totalThrottledBytes: 0,
+        perKindThrottledBytes: {},
+    };
+    /**
+     * Allocate the live aggregate `budgetBytes` across the kinds' pending demands
+     * for ONE interval. Returns per-kind throttle verdicts. Fair-share with
+     * redistribution of unused share, bounded by each kind's demand and the
+     * aggregate.
+     */
+    allocate(budgetBytes, demand) {
+        const kinds = Object.keys(demand).filter((k) => demand[k] > 0);
+        const out = {};
+        for (const k of Object.keys(demand)) {
+            out[k] = { admittedBytes: 0, throttledBytes: 0, throttled: false };
+        }
+        if (kinds.length === 0 || budgetBytes <= 0) {
+            // Everything is throttled if there is demand but no budget.
+            let anyThrottled = false;
+            for (const k of kinds) {
+                out[k] = { admittedBytes: 0, throttledBytes: demand[k], throttled: true };
+                this.degradation.perKindThrottledBytes[k] = (this.degradation.perKindThrottledBytes[k] ?? 0) + demand[k];
+                this.degradation.totalThrottledBytes += demand[k];
+                anyThrottled = true;
+            }
+            if (anyThrottled)
+                this.degradation.throttledIntervals++;
+            return out;
+        }
+        // Iterative fair-share with redistribution: repeatedly hand each
+        // not-yet-satisfied kind an EQUAL slice of the remaining budget, capping at its
+        // remaining demand; surplus from a kind that fit under its slice spills to the
+        // others. Bounded by kinds.length iterations (each pass satisfies ≥1 kind or
+        // exhausts the budget). This guarantees no kind exceeds the aggregate while
+        // another has unserved demand (the anti-starvation invariant).
+        let remainingBudget = budgetBytes;
+        const remainingDemand = new Map(kinds.map((k) => [k, demand[k]]));
+        let active = [...kinds];
+        let guard = active.length + 1;
+        while (active.length > 0 && remainingBudget > 0 && guard-- > 0) {
+            const share = remainingBudget / active.length;
+            const stillActive = [];
+            for (const k of active) {
+                const want = remainingDemand.get(k);
+                const grant = Math.min(want, share);
+                out[k].admittedBytes += grant;
+                remainingDemand.set(k, want - grant);
+                remainingBudget -= grant;
+                if (want - grant > 0)
+                    stillActive.push(k); // still has demand under its share.
+            }
+            // If no progress was possible (every active kind already at its share), stop.
+            if (stillActive.length === active.length && share <= 0)
+                break;
+            active = stillActive;
+        }
+        let anyThrottled = false;
+        for (const k of kinds) {
+            const left = remainingDemand.get(k) ?? 0;
+            if (left > 0) {
+                out[k].throttledBytes = left;
+                out[k].throttled = true;
+                this.degradation.perKindThrottledBytes[k] = (this.degradation.perKindThrottledBytes[k] ?? 0) + left;
+                this.degradation.totalThrottledBytes += left;
+                anyThrottled = true;
+            }
+        }
+        if (anyThrottled)
+            this.degradation.throttledIntervals++;
+        return out;
+    }
+    /** The cumulative degradation surface (§8 — surfaced, never a silent stall). */
+    getDegradation() {
+        return {
+            throttledIntervals: this.degradation.throttledIntervals,
+            totalThrottledBytes: this.degradation.totalThrottledBytes,
+            perKindThrottledBytes: { ...this.degradation.perKindThrottledBytes },
+        };
+    }
+}
+/**
+ * Decide how a recovering peer re-joins a kind's stream (§8 dark-peer accumulation
+ * bound + tombstone horizon). If the peer's last-held seq is below the holder's
+ * `oldestRetainedSeq` (the tombstone for a delete may have rotated out), a stale
+ * tail would risk delete-resurrection — so the peer is FORCED to a full
+ * single-origin snapshot re-join (§6.5 delete-resurrection guard). Otherwise a
+ * normal seq tail from `lastHeldSeq` is safe.
+ *
+ * PURE: a function of the seqs — independently testable (§12 #13).
+ */
+export function rejoinVerdict(lastHeldSeq, oldestRetainedSeq) {
+    // The peer's next-needed seq has rotated out of the holder's retained window ⇒
+    // a tail would skip the gap (incl. possibly a delete tombstone) ⇒ force a full
+    // snapshot re-join (the delete-resurrection guard).
+    if (lastHeldSeq + 1 < oldestRetainedSeq) {
+        return { mode: 'full-snapshot', reason: 'below-oldest-retained' };
+    }
+    return { mode: 'tail', fromSeq: lastHeldSeq };
+}
+//# sourceMappingURL=ReplicationBudget.js.map

package/dist/core/ReplicationBudget.js.map

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