@earendil-works/chord 1.4.0 → 1.5.1

package/dist/remote/provider.d.ts

@@ -0,0 +1,89 @@
+import { type Context } from "../context/index.ts";
+import { ChordError, type Principal } from "../data/index.ts";
+import { type ConsumerMessage, type OriginMessage, type ProviderMessage } from "../link/internal.ts";
+import { Hold } from "./hold.ts";
+import type { HostLink } from "./host-link.ts";
+import { type RelayedHold } from "./relay.ts";
+/**
+ * The provider side of one origin on a link. Ids are the origin's; a message naming an id this side does not know is
+ * ignored (Q1), one reusing a live id is a protocol error, and so are more concurrent calls than this side announced.
+ * This host's own `bound` and `state` messages go through the window: locally served holds wait while it is full
+ * (their ops in their members' pending queues, their bindings for the next slot); a call's answer, its own or a
+ * relayed one, sends the waiting state first. A relay forwards upstream messages at once (each upstream host keeps its
+ * own window for the origin it sees), so a slow consumer stalls only its origin.
+ */
+export declare class ProviderSide {
+    #private;
+    readonly link: HostLink;
+    /** Whose work this side serves: 0 for the peer's own, a relay's number for one of its downstream links. */
+    readonly origin: number;
+    constructor(link: HostLink, origin: number, limit: number);
+    /** Handles one message of this origin; a call whose arguments wait for an asynchronous inflate returns its promise. */
+    message(message: ProviderMessage): void | Promise<void>;
+    /**
+     * The link closed, or the origin did (`closed`): every hold is released (relayed ones by one `closed` to each
+     * upstream link) and every call aborted.
+     */
+    closed(): void;
+    /** Sends `message` on the link with this origin. */
+    send(message: OriginMessage): void;
+    /**
+     * Ends with `error` every hold of this origin that acts for a principal `revoked` names and holds nothing: served
+     * here but unbound (before the publication, refused), or relayed and waiting for its route's link.
+     */
+    revokeUnbound(revoked: (principal: Principal) => boolean, error: ChordError): void;
+    /** A pending hold turned out to be relayed: it takes the hold's place in the table. */
+    relayed(hold: RelayedHold): void;
+    /** This origin's number on upstream links (one per host, never reused), with `link` as one it relays to. */
+    relayTo(link: HostLink): number;
+    /**
+     * A message from upstream link `from` for this origin's relayed holds, forwarded with this origin: `bound` and
+     * `state` join the window's senders (their `ack` goes back to `from`), a reply ends its call (after this host's own
+     * waiting state: `reply`), `gone` forgets its hold. A link answers only for what was relayed over it: an entry, a
+     * notice or a reply naming a hold (or a call) this origin did not relay over `from` is dropped (Q1); a `bound` or
+     * `state` left without entries is acknowledged to `from` at once. Parts travel unchecked and unparsed: the end that
+     * parses a part checks it against its own link's limits.
+     */
+    forward(message: ConsumerMessage, from: HostLink): void;
+    /** An upstream link closed: nothing more is relayed to it, nor accepted from it. */
+    unlinked(link: HostLink): void;
+    /**
+     * The upstream link of relayed hold `hold` dropped with `error`: its calls in flight fail, the hold goes loading
+     * downstream, and its path's next link holds it again.
+     */
+    upstreamDropped(hold: RelayedHold, error: ChordError): void;
+    /**
+     * Forgets a hold (released, refused or gone) and every call on it; local calls are aborted with `error` (its
+     * object's end for a gone hold, `released` otherwise).
+     */
+    forget(hold: Hold | RelayedHold, error?: ChordError): void;
+    /**
+     * A call ended with `reply` (a result or an error, its own or forwarded from upstream): its slot is free; nothing is
+     * sent for one already gone. The state waiting for a slot goes first, past the window if it is full (decision "A
+     * call's answer follows its state"): when the call settles at the consumer, every change this host committed before
+     * answering is applied there.
+     */
+    reply(id: number, reply: Extract<OriginMessage, {
+        readonly kind: "result" | "error";
+    }>): void;
+    /** A hold's object is live: its `bound` goes now when a slot is free, else with the next free slot's bindings. */
+    bind(hold: Hold, context: Context): void;
+    /** A hold stopped waiting for a slot: it was forgotten. */
+    unbind(hold: Hold): void;
+    /**
+     * A served hold left its object's binding with `error` (a failure, a removal or a version no longer bound; slice 7b
+     * §6, model §5): as `unbind`, and its calls in flight rejected with `error` (each slot freed once). A hold unbinding
+     * with `loading` keeps them (`unbind` alone).
+     */
+    unbound(hold: Hold, error: ChordError): void;
+    /** A hold's members changed in the current batch; its flush sends or queues it. */
+    touched(hold: Hold): void;
+    /** The number the next of this host's own `bound` and `state` messages gets (counted from 1). */
+    get nextOwn(): number;
+    /**
+     * Whether its consumer acknowledged this host's own message number `own`, so applied it: a call it sent after that
+     * arrives after the `ack` (one direction keeps its order).
+     */
+    acknowledged(own: number): boolean;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/remote/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/remote/provider.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,OAAO,EAAmB,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,UAAU,EAAgB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE5E,OAAO,EAEN,KAAK,eAAe,EAGpB,KAAK,aAAa,EAElB,KAAK,eAAe,EAKpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,WAAW,EAAc,MAAM,YAAY,CAAC;AAuB1D;;;;;;;GAOG;AACH,qBAAa,YAAY;;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,2GAA2G;IAC3G,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAwBxB,YAAY,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAIxD;IAED,uHAAuH;IACvH,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBtD;IAED;;;OAGG;IACH,MAAM,IAAI,IAAI,CAqBb;IAED,oDAAoD;IACpD,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAEjC;IAED;;;OAGG;IACH,aAAa,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,OAAO,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAOjF;IAED,uFAAuF;IACvF,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAE/B;IAED,4GAA4G;IAC5G,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAQ9B;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAiCtD;IAED,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAE7B;IAED;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAK1D;IAED;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,IAAI,CAWzD;IAED;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,aAAa,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;KAAE,CAAC,GAAG,IAAI,CAU5F;IAUD,kHAAkH;IAClH,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAMvC;IAED,2DAA2D;IAC3D,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAKvB;IAED;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAO3C;IAED,mFAAmF;IACnF,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAGxB;IAwND,iGAAiG;IACjG,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;OAGG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEjC;CAgGD"}