@kubun/plugin-p2p 0.11.0 → 0.12.0

package/lib/types.js

@@ -1,2 +1 @@
-// ---- Plugin API ----
 export { };

package/lib/util/handler-error.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Translates a thrown value into a `HandlerError` when it carries a registered
+ * `KubunErrorCode`, so `HandlerError.from` in `@enkaku/server` passes it through
+ * instead of flattening it to `EK01` / "Handler execution failed".
+ *
+ * Anything else is returned unchanged, and that default is the security
+ * property: an error with no registered code is internal, and its message may
+ * carry DIDs, paths, or SQL. Forwarding a refusal is safe only because the
+ * throw site attached a code the registry allows to leave the device.
+ */
+export declare function toHandlerError(cause: unknown): unknown;
+/**
+ * Applies {@link toHandlerError} to every handler in a procedure record, so the
+ * translation lives in one place rather than in each handler.
+ */
+export declare function wrapHandlers(handlers: Record<string, unknown>): Record<string, unknown>;

package/lib/util/handler-error.js

@@ -0,0 +1,64 @@
+import { HandlerError } from '@enkaku/server';
+import { isKubunErrorCode } from '@kubun/protocol';
+import { GraphQLError } from 'graphql';
+function isObject(value) {
+    return typeof value === 'object' && value != null && !Array.isArray(value);
+}
+/**
+ * Translates a thrown value into a `HandlerError` when it carries a registered
+ * `KubunErrorCode`, so `HandlerError.from` in `@enkaku/server` passes it through
+ * instead of flattening it to `EK01` / "Handler execution failed".
+ *
+ * Anything else is returned unchanged, and that default is the security
+ * property: an error with no registered code is internal, and its message may
+ * carry DIDs, paths, or SQL. Forwarding a refusal is safe only because the
+ * throw site attached a code the registry allows to leave the device.
+ */ export function toHandlerError(cause) {
+    if (cause instanceof HandlerError) {
+        return cause;
+    }
+    if (cause instanceof GraphQLError) {
+        const { code, ...data } = cause.extensions;
+        return isKubunErrorCode(code) ? new HandlerError({
+            code,
+            message: cause.message,
+            data,
+            cause
+        }) : cause;
+    }
+    if (isObject(cause) && isKubunErrorCode(cause.code)) {
+        const message = typeof cause.message === 'string' ? cause.message : undefined;
+        const data = isObject(cause.data) ? cause.data : {};
+        return new HandlerError({
+            code: cause.code,
+            message,
+            data,
+            cause
+        });
+    }
+    return cause;
+}
+/**
+ * Applies {@link toHandlerError} to every handler in a procedure record, so the
+ * translation lives in one place rather than in each handler.
+ */ export function wrapHandlers(handlers) {
+    return Object.fromEntries(Object.entries(handlers).map(([name, handler])=>{
+        if (typeof handler !== 'function') {
+            return [
+                name,
+                handler
+            ];
+        }
+        const wrapped = async (...args)=>{
+            try {
+                return await handler(...args);
+            } catch (cause) {
+                throw toHandlerError(cause);
+            }
+        };
+        return [
+            name,
+            wrapped
+        ];
+    }));
+}

package/lib/util/mutex.d.ts

@@ -1,4 +1,17 @@
+export type MutexRunOptions = {
+    /**
+     * Give up WAITING for the lock after this long. Bounds the wait only — the
+     * deadline is cleared when the callback is invoked, so a slow holder is never
+     * rejected out from under work that then completes.
+     *
+     * A backstop, not a policy. A waiter that gives up does NOT run its callback
+     * when its turn comes; it yields the slot so everything behind it proceeds.
+     */
+    acquireTimeoutMs?: number;
+    /** Builds the rejection, so the caller can name what it was waiting for. */
+    acquireTimeoutError?: () => Error;
+};
 export type Mutex = {
-    run<T>(fn: () => Promise<T>): Promise<T>;
+    run<T>(fn: () => Promise<T>, options?: MutexRunOptions): Promise<T>;
 };
 export declare function createMutex(): Mutex;

package/lib/util/mutex.js

@@ -1,10 +1,44 @@
+/** A waiter that gave up before its turn. Read by nothing: its `run` already rejected. */ const EXPIRED = Symbol('mutex.expired');
 export function createMutex() {
     let tail = Promise.resolve();
     return {
-        run (fn) {
-            const next = tail.then(()=>fn());
+        run (fn, options) {
+            const timeoutMs = options?.acquireTimeoutMs;
+            let expired = false;
+            let timer;
+            // The race below is on the RESULT, never on the acquisition: racing the
+            // acquisition inserts microtask hops between a handle operation and
+            // everything ordered against it. `fn` stays one microtask off the
+            // previous holder.
+            const next = tail.then(async ()=>{
+                if (expired) {
+                    return EXPIRED;
+                }
+                // Safe to read a timer the executor below assigns: `new Promise` runs
+                // its executor synchronously, this callback is a microtask away.
+                if (timer != null) {
+                    clearTimeout(timer);
+                    timer = undefined;
+                }
+                return await fn();
+            });
             tail = next.catch(()=>{});
-            return next;
+            if (timeoutMs == null) {
+                return next;
+            }
+            return new Promise((resolve, reject)=>{
+                timer = setTimeout(()=>{
+                    expired = true;
+                    reject(options?.acquireTimeoutError?.() ?? new Error(`lock not acquired in ${timeoutMs}ms`));
+                }, timeoutMs);
+                next.then((value)=>{
+                    clearTimeout(timer);
+                    resolve(value);
+                }, (error)=>{
+                    clearTimeout(timer);
+                    reject(error);
+                });
+            });
         }
     };
 }

package/package.json

@@ -1,78 +1,82 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@sozai/async": "^0.1.0",
-    "@kumiai/broadcast": "^0.1.0",
-    "@kokuin/capability": "^0.1.0",
-    "@enkaku/client": "^0.18.1",
-    "@sozai/codec": "^0.1.0",
-    "@sozai/event": "^0.1.0",
-    "@sozai/generator": "^0.1.0",
-    "@kumiai/mls": "^0.1.0",
-    "@kumiai/rpc": "^0.1.0",
-    "@enkaku/http-fetch": "^0.18.1",
-    "@enkaku/http-serve": "^0.18.1",
-    "@kumiai/hub-protocol": "^0.1.0",
-    "@kumiai/hub-tunnel": "^0.1.0",
-    "@enkaku/protocol": "^0.18.1",
-    "@sozai/runtime": "^0.1.0",
-    "@sozai/schema": "^0.1.0",
-    "@enkaku/server": "^0.18.1",
-    "@sozai/stream": "^0.1.0",
-    "@kokuin/token": "^0.1.1",
-    "@enkaku/transport": "^0.18.1",
+    "@enkaku/client": "^0.20.0",
+    "@enkaku/http-fetch": "^0.20.0",
+    "@enkaku/http-serve": "^0.20.0",
+    "@enkaku/protocol": "^0.20.0",
+    "@enkaku/server": "^0.20.0",
+    "@enkaku/transport": "^0.20.0",
+    "@kokuin/capability": "^0.2.1",
+    "@kokuin/token": "^0.3.0",
+    "@kumiai/broadcast": "^0.5.0",
+    "@kumiai/hub-protocol": "^0.5.0",
+    "@kumiai/hub-server": "^0.5.0",
+    "@kumiai/hub-tunnel": "^0.5.0",
+    "@kumiai/mls": "^0.5.0",
+    "@kumiai/mls-rpc": "^0.5.0",
+    "@kumiai/rpc": "^0.5.0",
+    "@noble/ciphers": "^2.2.0",
     "@noble/hashes": "^2.2.0",
+    "@sozai/async": "^0.2.1",
+    "@sozai/codec": "^0.4.0",
+    "@sozai/event": "^0.1.3",
+    "@sozai/generator": "^0.2.0",
+    "@sozai/runtime": "^0.1.0",
+    "@sozai/schema": "^0.1.1",
+    "@sozai/stream": "^0.2.0",
     "graphql": "^16.14.2",
-    "kysely": "^0.29.2",
+    "kysely": "^0.29.4",
     "ts-mls": "2.0.0-rc.13",
-    "@kubun/db": "^0.11.0",
-    "@kubun/db-adapter": "^0.11.0",
-    "@kubun/graphql": "^0.11.0",
-    "@kubun/hlc": "^0.11.0",
-    "@kubun/engine": "^0.11.0",
-    "@kubun/http-util": "^0.11.0",
-    "@kubun/logger": "^0.11.0",
-    "@kubun/client": "^0.11.0",
-    "@kubun/id": "^0.11.0",
-    "@kubun/mutation": "^0.11.0",
-    "@kubun/store-graph": "^0.11.0",
-    "@kubun/protocol": "^0.11.0",
-    "@kubun/store-delegation": "^0.11.0",
-    "@kubun/store-p2p": "^0.11.0"
+    "@kubun/db": "^0.12.0",
+    "@kubun/db-adapter": "^0.12.0",
+    "@kubun/engine": "^0.12.0",
+    "@kubun/graphql": "^0.12.0",
+    "@kubun/hlc": "^0.12.0",
+    "@kubun/http-util": "^0.12.0",
+    "@kubun/logger": "^0.12.0",
+    "@kubun/mutation": "^0.12.0",
+    "@kubun/plugin-http": "^0.12.0",
+    "@kubun/plugin-rpc": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/store-delegation": "^0.12.0",
+    "@kubun/id": "^0.12.0",
+    "@kubun/store-graph": "^0.12.0",
+    "@kubun/store-p2p": "^0.12.0"
   },
   "devDependencies": {
-    "@kumiai/hub-server": "^0.1.0",
-    "@testcontainers/postgresql": "^12.0.4",
+    "@kumiai/hub-conformance": "^0.5.0",
+    "@kumiai/rpc-conformance": "^0.5.0",
+    "@testcontainers/postgresql": "^12.1.0",
     "get-port": "^7.2.0",
-    "@kubun/db-better-sqlite": "^0.11.0",
-    "@kubun/db-node-sqlite": "^0.11.0",
-    "@kubun/plugin-connector": "^0.11.0",
-    "@kubun/db-postgres": "^0.11.0",
-    "@kubun/plugin-rpc": "^0.11.0",
-    "@kubun/plugin-http": "^0.11.0",
-    "@kubun/hub": "^0.11.0",
-    "@kubun/test-utils": "^0.11.0"
+    "@kubun/db-node-sqlite": "^0.12.0",
+    "@kubun/client": "^0.12.0",
+    "@kubun/plugin-connector": "^0.12.0",
+    "@kubun/test-utils": "^0.12.0",
+    "@kubun/db-postgres": "^0.12.0",
+    "@kubun/hub": "^0.12.0",
+    "@kubun/db-better-sqlite": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
     "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }

package/lib/groups/ledger-entry.d.ts

@@ -1,37 +0,0 @@
-import { type OwnIdentity } from '@kokuin/token';
-/**
- * A control-ledger claim. The payload of a signed ledger token: `type` selects
- * the reducer, `subject` is the entity the claim is about, `value` carries the
- * claim data, and `hlc` orders it. The authenticated author is never part of
- * this shape — it comes from the verified token's `iss`.
- */
-export type LedgerEntry<TValue = unknown> = {
-    type: string;
-    subject: string;
-    value: TValue;
-    hlc: string;
-};
-/** A ledger entry whose token signature has been cryptographically verified. */
-export type VerifiedLedgerEntry<TValue = unknown> = {
-    /** Authenticated author DID (the verified token issuer), normalized. */
-    issuer: string;
-    entry: LedgerEntry<TValue>;
-};
-/**
- * Sign a ledger entry. The signer fills `iss` with its DID, so the signature
- * covers every claim field and binds the author. Returns the stringified token.
- */
-export declare function signLedgerEntry(identity: OwnIdentity, entry: LedgerEntry): Promise<string>;
-/**
- * Verify a signed ledger token and extract its claim. Returns `null` (never
- * throws) when the token is unparseable, unsigned (`alg: 'none'` — `verifyToken`
- * returns those without checking a signature, so an attacker could forge an
- * arbitrary `iss`), or structurally malformed. The claim fields come from the
- * verified payload only; the issuer is the normalized verified `iss`.
- */
-export declare function verifyLedgerEntry<TValue = unknown>(token: string): Promise<VerifiedLedgerEntry<TValue> | null>;
-/**
- * Content-addressed digest of a signed ledger token, used as the append-only
- * store's dedup key. Multibase-encoded SHA-256 multihash over the token bytes.
- */
-export declare function ledgerEntryDigest(signedToken: string): string;

package/lib/groups/ledger-entry.js

@@ -1,56 +0,0 @@
-import { encodeMultibase, isVerifiedToken, multihashSHA256, normalizeDID, stringifyToken, verifyToken } from '@kokuin/token';
-const textEncoder = new TextEncoder();
-/**
- * Sign a ledger entry. The signer fills `iss` with its DID, so the signature
- * covers every claim field and binds the author. Returns the stringified token.
- */ export async function signLedgerEntry(identity, entry) {
-    const signed = await identity.signToken({
-        type: entry.type,
-        subject: entry.subject,
-        value: entry.value,
-        hlc: entry.hlc
-    }, // Embed the long-form DID so each entry is self-verifying offline: the
-    // ledger is the source of truth and receivers fold it long after first
-    // contact, when the author's DID document may no longer be cached. No-op
-    // for did:key (long form === id).
-    {
-        embedLongForm: true
-    });
-    return stringifyToken(signed);
-}
-/**
- * Verify a signed ledger token and extract its claim. Returns `null` (never
- * throws) when the token is unparseable, unsigned (`alg: 'none'` — `verifyToken`
- * returns those without checking a signature, so an attacker could forge an
- * arbitrary `iss`), or structurally malformed. The claim fields come from the
- * verified payload only; the issuer is the normalized verified `iss`.
- */ export async function verifyLedgerEntry(token) {
-    let verified;
-    try {
-        verified = await verifyToken(token);
-    } catch  {
-        return null;
-    }
-    if (!isVerifiedToken(verified)) {
-        return null;
-    }
-    const { iss, type, subject, value, hlc } = verified.payload;
-    if (typeof type !== 'string' || typeof subject !== 'string' || typeof hlc !== 'string') {
-        return null;
-    }
-    return {
-        issuer: normalizeDID(iss),
-        entry: {
-            type,
-            subject,
-            value,
-            hlc
-        }
-    };
-}
-/**
- * Content-addressed digest of a signed ledger token, used as the append-only
- * store's dedup key. Multibase-encoded SHA-256 multihash over the token bytes.
- */ export function ledgerEntryDigest(signedToken) {
-    return encodeMultibase(multihashSHA256(textEncoder.encode(signedToken)));
-}

package/lib/groups/ledger-fold.d.ts

@@ -1,56 +0,0 @@
-import type { GroupAnchor } from './group-anchor.js';
-import type { VerifiedLedgerEntry } from './ledger-entry.js';
-/**
- * A per-type projection over the control ledger. The fold stays free of any
- * admin/circle semantics: a reducer owns its own initial state (derived from
- * the genesis anchor), its authority rule, and its fold step, so a new ledger
- * type plugs in as a parameter with zero edits to {@link foldLedger}.
- */
-export type LedgerReducer<TValue, TState> = {
-    /** Ledger entry `type` this reducer projects; entries of any other type are dropped. */
-    type: string;
-    /**
-     * Initial fold state, derived from the genesis anchor. The anchor is the
-     * authenticated epoch-0 root (e.g. the creator DID is the first admin), so
-     * seeding from it is what makes the very first claims evaluable.
-     */
-    seed(anchor: GroupAnchor): TState;
-    /** Is the verified issuer allowed to make this claim, given the state so far? */
-    verifyAuthority(verified: VerifiedLedgerEntry<TValue>, stateSoFar: TState): boolean;
-    /** Fold step: return the next state after applying an authorized claim. */
-    apply(verified: VerifiedLedgerEntry<TValue>, stateSoFar: TState): TState;
-};
-/**
- * A verified entry paired with its content-addressed id. The id is the
- * total-order tie-breaker when two entries share an `hlc`, and identifies the
- * entry in drop notices.
- */
-export type FoldInput<TValue = unknown> = {
-    verified: VerifiedLedgerEntry<TValue>;
-    entryID: string;
-};
-/** Why an entry was skipped during the fold, for an optional observer. */
-export type FoldDrop = {
-    entryID: string;
-    type: string;
-    reason: string;
-};
-/**
- * Replay the ledger into a single reducer's projection.
- *
- * Signatures are verified at ingest, not here — this fold evaluates AUTHORITY:
- * whether each issuer was allowed to make its claim given the state accumulated
- * from strictly-earlier entries. Evaluating against state-so-far (never the
- * final state) is what makes rotation sound: a key authorized at HLC `t` can be
- * revoked at `t+1` without retroactively invalidating its earlier claims.
- *
- * Deterministic on any arrival order: it seeds from the genesis anchor, sorts a
- * copy of the entries by the total order `(hlc, entryID)`, then folds. Pure — no
- * clock, no randomness, no I/O, and the input array is never mutated. A claim of
- * an unrelated type or one whose authority fails is dropped (never thrown) so a
- * single bad entry can never abort the projection. Drops are silent unless an
- * `onDrop` observer is supplied — the fold runs on every authority check, where
- * authority-failed drops are expected, so the caller decides whether to surface
- * them rather than the fold emitting to the console.
- */
-export declare function foldLedger<TValue, TState>(entries: Array<FoldInput<TValue>>, anchor: GroupAnchor, reducer: LedgerReducer<TValue, TState>, onDrop?: (drop: FoldDrop) => void): TState;

package/lib/groups/ledger-fold.js

@@ -1,53 +0,0 @@
-/** Total order over the ledger: HLC first, then content-addressed id to break ties. */ function compareFoldInputs(a, b) {
-    if (a.verified.entry.hlc !== b.verified.entry.hlc) {
-        return a.verified.entry.hlc < b.verified.entry.hlc ? -1 : 1;
-    }
-    if (a.entryID === b.entryID) {
-        return 0;
-    }
-    return a.entryID < b.entryID ? -1 : 1;
-}
-/**
- * Replay the ledger into a single reducer's projection.
- *
- * Signatures are verified at ingest, not here — this fold evaluates AUTHORITY:
- * whether each issuer was allowed to make its claim given the state accumulated
- * from strictly-earlier entries. Evaluating against state-so-far (never the
- * final state) is what makes rotation sound: a key authorized at HLC `t` can be
- * revoked at `t+1` without retroactively invalidating its earlier claims.
- *
- * Deterministic on any arrival order: it seeds from the genesis anchor, sorts a
- * copy of the entries by the total order `(hlc, entryID)`, then folds. Pure — no
- * clock, no randomness, no I/O, and the input array is never mutated. A claim of
- * an unrelated type or one whose authority fails is dropped (never thrown) so a
- * single bad entry can never abort the projection. Drops are silent unless an
- * `onDrop` observer is supplied — the fold runs on every authority check, where
- * authority-failed drops are expected, so the caller decides whether to surface
- * them rather than the fold emitting to the console.
- */ export function foldLedger(entries, anchor, reducer, onDrop) {
-    const ordered = [
-        ...entries
-    ].sort(compareFoldInputs);
-    let state = reducer.seed(anchor);
-    for (const { verified, entryID } of ordered){
-        const { entry } = verified;
-        if (entry.type !== reducer.type) {
-            onDrop?.({
-                entryID,
-                type: entry.type,
-                reason: `unknown type for reducer '${reducer.type}'`
-            });
-            continue;
-        }
-        if (!reducer.verifyAuthority(verified, state)) {
-            onDrop?.({
-                entryID,
-                type: entry.type,
-                reason: `issuer '${verified.issuer}' not authorized`
-            });
-            continue;
-        }
-        state = reducer.apply(verified, state);
-    }
-    return state;
-}

package/lib/hub/did-observing-transport.d.ts

@@ -1,75 +0,0 @@
-import type { AnyClientMessageOf, AnyServerMessageOf, ClientTransportOf, ProtocolDefinition } from '@enkaku/protocol';
-import type { TransportEvents } from '@enkaku/transport';
-import { Disposer } from '@sozai/async';
-import type { EventEmitter } from '@sozai/event';
-export type ServerDIDObserver = (serverDID: string) => void | Promise<void>;
-export type ServerDIDMismatchObserver = (params: {
-    hubURL: string;
-    expectedServerDID: string;
-    observedServerDID: string;
-}) => void;
-/**
- * Fired once per freshly-spawned hub client when its first signed response
- * arrives. The hub URL is bound into the call site; consumers (hub manager
- * `captureServerDID`) use the URL to look up the local hub row and apply the
- * TOFU conflict matrix. Errors are caught and logged — capture never blocks
- * message forwarding, even on `HubServerDIDConflictError`.
- */
-export type OnServerDIDObserved = (params: {
-    hubURL: string;
-    serverDID: string;
-}) => void | Promise<void>;
-export type DIDObservingTransportParams<Protocol extends ProtocolDefinition> = {
-    inner: ClientTransportOf<Protocol>;
-    /**
-     * Fired on the first message bearing `payload.iss` when no `expectedServerDID`
-     * is set (TOFU capture). When `expectedServerDID` is set and matches, the
-     * callback is NOT fired — the pin is already authoritative.
-     */
-    onServerDID: ServerDIDObserver;
-    /**
-     * Pinned hub server DID. When set, the wrapper enforces it: a non-matching
-     * first observed `iss` triggers a permanent failed state — `read()` rejects
-     * with `HubServerDIDMismatchError`, the offending message is NOT delivered
-     * to the inner Client, and every subsequent `read()` re-raises the same
-     * error. When unset, the wrapper falls back to TOFU capture.
-     */
-    expectedServerDID?: string;
-    /** Hub URL — only used to populate `HubServerDIDMismatchError` for callers. */
-    hubURL?: string;
-    /**
-     * Optional side-channel notification fired on mismatch. Lets the pool log /
-     * evict without having to inspect the rejected `read()` cause. Inner
-     * transport disposal is the pool's job, not the wrapper's.
-     */
-    onMismatch?: ServerDIDMismatchObserver;
-};
-/**
- * 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 declare class DIDObservingTransport<Protocol extends ProtocolDefinition> extends Disposer {
-    #private;
-    constructor(params: DIDObservingTransportParams<Protocol>);
-    get events(): EventEmitter<TransportEvents>;
-    getWritable(): WritableStream<AnyClientMessageOf<Protocol>>;
-    read(): Promise<ReadableStreamReadResult<AnyServerMessageOf<Protocol>>>;
-    write(value: AnyClientMessageOf<Protocol>): Promise<void>;
-    [Symbol.asyncIterator](): AsyncIterator<AnyServerMessageOf<Protocol>, AnyServerMessageOf<Protocol> | null>;
-}