@kubun/plugin-p2p 0.11.0 → 0.12.1

package/lib/hub/did-observing-transport.js

@@ -1,126 +0,0 @@
-import { Disposer } from '@sozai/async';
-import { HubServerDIDMismatchError } from './errors.js';
-/**
- * Wraps a `ClientTransportOf<Protocol>` to enforce hub-server-DID
- * TOFU + pinned-mismatch semantics on the receive side.
- *
- * - `expectedServerDID == null`: TOFU mode. First message bearing
- *   `payload.iss` fires `onServerDID(iss)` exactly once; subsequent messages
- *   never re-fire, even with a differing `iss`. Every message is forwarded
- *   to the inner Client untouched.
- * - `expectedServerDID != null` and the first observed `iss` matches: the
- *   pin is already authoritative; `onServerDID` is NOT fired and forwarding
- *   continues normally.
- * - `expectedServerDID != null` and the first observed `iss` differs: the
- *   wrapper enters a permanent failed state (`HubServerDIDMismatchError`).
- *   The current `read()` call AND every subsequent `read()` reject with the
- *   error; the offending message is NOT delivered. Inner-transport lifecycle
- *   stays the pool's responsibility — the wrapper does not dispose its inner.
- *
- * Extends `Disposer` and matches the `ClientTransportOf<Protocol>` shape
- * structurally so it can be passed straight to `Client<Protocol>`.
- */ export class DIDObservingTransport extends Disposer {
-    #inner;
-    #onServerDID;
-    #expectedServerDID;
-    #hubURL;
-    #onMismatch;
-    #fired = false;
-    #failure = null;
-    constructor(params){
-        super({
-            signal: params.inner.signal,
-            dispose: async (reason)=>{
-                await params.inner.dispose(reason);
-            }
-        });
-        this.#inner = params.inner;
-        this.#onServerDID = params.onServerDID;
-        this.#expectedServerDID = params.expectedServerDID;
-        this.#hubURL = params.hubURL;
-        this.#onMismatch = params.onMismatch;
-    }
-    get events() {
-        return this.#inner.events;
-    }
-    getWritable() {
-        return this.#inner.getWritable();
-    }
-    async read() {
-        if (this.#failure != null) {
-            throw this.#failure;
-        }
-        const result = await this.#inner.read();
-        const failure = this.#observe(result);
-        if (failure != null) {
-            throw failure;
-        }
-        return result;
-    }
-    async write(value) {
-        await this.#inner.write(value);
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: async ()=>{
-                const result = await this.read();
-                if (result.done) {
-                    return {
-                        done: true,
-                        value: result.value ?? null
-                    };
-                }
-                return {
-                    done: false,
-                    value: result.value
-                };
-            }
-        };
-    }
-    /**
-   * Inspect a freshly-read result for `payload.iss`. Returns a
-   * `HubServerDIDMismatchError` to be thrown by the caller when in pinned
-   * mode and the observed DID does not match — in that case the wrapper
-   * also enters a permanent failed state and the offending message must NOT
-   * be returned to the caller. Returns `null` otherwise.
-   */ #observe(result) {
-        if (this.#fired || result.done || result.value == null) {
-            return null;
-        }
-        const payload = result.value.payload;
-        const iss = payload?.iss;
-        if (typeof iss !== 'string' || iss.length === 0) {
-            return null;
-        }
-        this.#fired = true;
-        if (this.#expectedServerDID != null) {
-            if (iss === this.#expectedServerDID) {
-                return null;
-            }
-            const error = new HubServerDIDMismatchError({
-                hubURL: this.#hubURL ?? '',
-                expectedServerDID: this.#expectedServerDID,
-                observedServerDID: iss
-            });
-            this.#failure = error;
-            if (this.#onMismatch != null) {
-                try {
-                    this.#onMismatch({
-                        hubURL: this.#hubURL ?? '',
-                        expectedServerDID: this.#expectedServerDID,
-                        observedServerDID: iss
-                    });
-                } catch  {
-                // observer errors must not mask the typed mismatch path
-                }
-            }
-            return error;
-        }
-        // TOFU mode — fire-and-forget: forwarding must not wait on the observer.
-        // Errors are swallowed at the wrapper; the pool-side handler logs them.
-        void Promise.resolve().then(()=>this.#onServerDID(iss)).catch(()=>{
-        // intentional: capture failures don't break the read loop in TOFU mode
-        });
-        return null;
-    }
-}

package/lib/hub/errors.d.ts

@@ -1,24 +0,0 @@
-/**
- * Thrown by `DIDObservingTransport.read()` when the first observed `payload.iss`
- * does not match the pinned `expectedServerDID`. The transport enters a
- * permanent failed state: no message bearing the offending `iss` is delivered
- * to the inner Client, and every subsequent `read()` rejects with the same
- * error. In-flight Enkaku RPCs see this error as the `cause` of the Client's
- * "Transport read failed" abort.
- *
- * Distinct from `HubServerDIDConflictError` (raised by manager-level
- * `captureServerDID` when the pin row already differs from the observed DID
- * on the TOFU capture path); this class is raised client-side, before any
- * message is delivered, when a row was already pinned at connect time.
- */
-export declare class HubServerDIDMismatchError extends Error {
-    #private;
-    constructor(params: {
-        hubURL: string;
-        expectedServerDID: string;
-        observedServerDID: string;
-    });
-    get hubURL(): string;
-    get expectedServerDID(): string;
-    get observedServerDID(): string;
-}

package/lib/hub/errors.js

@@ -1,33 +0,0 @@
-/**
- * Thrown by `DIDObservingTransport.read()` when the first observed `payload.iss`
- * does not match the pinned `expectedServerDID`. The transport enters a
- * permanent failed state: no message bearing the offending `iss` is delivered
- * to the inner Client, and every subsequent `read()` rejects with the same
- * error. In-flight Enkaku RPCs see this error as the `cause` of the Client's
- * "Transport read failed" abort.
- *
- * Distinct from `HubServerDIDConflictError` (raised by manager-level
- * `captureServerDID` when the pin row already differs from the observed DID
- * on the TOFU capture path); this class is raised client-side, before any
- * message is delivered, when a row was already pinned at connect time.
- */ export class HubServerDIDMismatchError extends Error {
-    #hubURL;
-    #expectedServerDID;
-    #observedServerDID;
-    constructor(params){
-        super(`hub at ${params.hubURL} signed responses with ${params.observedServerDID}; pinned to ${params.expectedServerDID}`);
-        this.name = 'HubServerDIDMismatchError';
-        this.#hubURL = params.hubURL;
-        this.#expectedServerDID = params.expectedServerDID;
-        this.#observedServerDID = params.observedServerDID;
-    }
-    get hubURL() {
-        return this.#hubURL;
-    }
-    get expectedServerDID() {
-        return this.#expectedServerDID;
-    }
-    get observedServerDID() {
-        return this.#observedServerDID;
-    }
-}