@earendil-works/chord 1.4.0 → 1.5.0

package/dist/next/remote/relay.js

@@ -0,0 +1,117 @@
+// Relayed holds (§4, §22, R1; decision "Relay flow control per origin"): a hold that arrived on one link (downstream)
+// and that this host neither serves nor parses, held again on its path's link (upstream) with the same id under its
+// downstream origin's number there; messages are forwarded between the two with the origin rewritten and parts
+// untouched.
+import { ChordError } from "../data/index.js";
+import { wireError } from "../link/internal.js";
+import { actingFor } from "./hold.js";
+/**
+ * One relayed hold: `id` on its downstream origin, and the same id upstream on its path's current link (none while
+ * the path has no link). It keeps its `hold` message to hold again on the next link. Calls, `abort`, `retry` and
+ * `release` go upstream at once; what comes back is forwarded by its downstream origin (`ProviderSide.forward`). Two
+ * downstream holds are two upstream holds, each with its own encoders (R1).
+ */
+export class RelayedHold {
+    kind = "relayed";
+    id;
+    #downstream;
+    /**
+     * What the upstream hold asks for, with the chain and decoded limit this host honoured; its params owned, not a view
+     * of the message they came in.
+     */
+    #request;
+    /** Whom the hold acts for, sent on route links. */
+    caller;
+    #path;
+    /** The upstream link while the path has one, and the downstream origin's number on it. */
+    #upstream;
+    constructor(id, downstream, request, caller, path) {
+        this.id = id;
+        this.#downstream = downstream;
+        const { params } = request;
+        // Params are never deflated: the provider side refused deflated ones.
+        const owned = typeof params === "string" ? params : params.slice();
+        this.#request = { ...request, params: owned };
+        this.caller = caller;
+        this.#path = path;
+    }
+    /** Takes the pending hold's place downstream and holds upstream (now, or when the path has a link). */
+    start() {
+        this.#downstream.relayed(this);
+        this.#path.attach(this);
+    }
+    /** Whether it is held on `link` now: only that link answers for it. */
+    heldOn(link) {
+        return this.#upstream?.link === link;
+    }
+    /** Holds on `link`, the path's link now: its kept `hold` message, with whom it acts for on a route link. */
+    attach(link) {
+        const origin = this.#downstream.relayTo(link);
+        this.#upstream = { link, origin };
+        link.send({ kind: "hold", origin, hold: this.id, ...this.#request, ...actingFor(link, this.caller) });
+    }
+    /** The upstream link dropped: downstream its calls fail and the hold goes loading until the path's next link. */
+    dropped(error) {
+        const upstream = this.#upstream;
+        this.#upstream = undefined;
+        if (upstream !== undefined)
+            this.#downstream.upstreamDropped(this, error);
+    }
+    /** Its path's address cannot be reached for now: downstream it fails `waiting` with `error` until the next link. */
+    unreachable(error) {
+        this.#downstream.send({ kind: "failed", hold: this.id, cause: { kind: "waiting", error: wireError(error) } });
+    }
+    /**
+     * Whether it waits for its path's link (a route still resolving, or a dropped link's next): a revocation ends it then,
+     * since the link it is held on next gets no past `revoke` (§4).
+     */
+    get waiting() {
+        return this.#upstream === undefined;
+    }
+    /** Revoked while it waited for its path's link: forgotten, and `gone` with `error` downstream. */
+    revoked(error) {
+        this.drop();
+        this.#downstream.forget(this);
+        this.#downstream.send({ kind: "gone", hold: this.id, error: wireError(error) });
+    }
+    /** `gone` from upstream: the hold is forgotten (the downstream origin forwards the message). */
+    lost() {
+        this.drop();
+        this.#downstream.forget(this);
+    }
+    /**
+     * A call from downstream (registered there under its id), forwarded upstream at once; its reply comes back by the
+     * origin. Without an upstream link it is answered `unavailable` at once (it crossed the `loading` notice).
+     */
+    call(message) {
+        const upstream = this.#upstream;
+        if (upstream !== undefined) {
+            upstream.link.send({ ...message, origin: upstream.origin });
+            return;
+        }
+        const error = new ChordError({ code: "unavailable", message: `hold ${this.id}: its upstream link is down` });
+        this.#downstream.reply(message.call, { kind: "error", call: message.call, error: wireError(error) });
+    }
+    /** A downstream `abort` of call `id`, forwarded. */
+    abort(id) {
+        const upstream = this.#upstream;
+        upstream?.link.send({ kind: "abort", origin: upstream.origin, call: id });
+    }
+    /** A downstream `retry`, forwarded with its hop budget as it is (a relay visits no object). */
+    retry(message) {
+        const upstream = this.#upstream;
+        upstream?.link.send({ ...message, origin: upstream.origin });
+    }
+    /** Released downstream: released upstream (its calls with it) and no later link holds it. */
+    release() {
+        const upstream = this.#upstream;
+        this.drop();
+        upstream?.link.send({ kind: "release", origin: upstream.origin, hold: this.id });
+    }
+    /** No later link holds it (gone, or its downstream origin closed, which `closed` tells the upstream links). */
+    drop() {
+        this.#upstream = undefined;
+        this.#path.detach(this);
+    }
+}
+//# sourceMappingURL=relay.js.map

package/dist/next/remote/relay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.js","sourceRoot":"","sources":["../../../src/next/remote/relay.ts"],"names":[],"mappings":"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","sourcesContent":["// Relayed holds (§4, §22, R1; decision \"Relay flow control per origin\"): a hold that arrived on one link (downstream)\n// and that this host neither serves nor parses, held again on its path's link (upstream) with the same id under its\n// downstream origin's number there; messages are forwarded between the two with the origin rewritten and parts\n// untouched.\n\nimport { ChordError } from \"../data/index.ts\";\nimport type { Caller } from \"../host/internal.ts\";\nimport { type Message, wireError } from \"../link/internal.ts\";\nimport { actingFor, type HoldRequest } from \"./hold.ts\";\nimport type { HostLink } from \"./host-link.ts\";\nimport type { Path } from \"./path.ts\";\nimport type { ProviderSide } from \"./provider.ts\";\n\n/**\n * One relayed hold: `id` on its downstream origin, and the same id upstream on its path's current link (none while\n * the path has no link). It keeps its `hold` message to hold again on the next link. Calls, `abort`, `retry` and\n * `release` go upstream at once; what comes back is forwarded by its downstream origin (`ProviderSide.forward`). Two\n * downstream holds are two upstream holds, each with its own encoders (R1).\n */\nexport class RelayedHold {\n\treadonly kind = \"relayed\";\n\treadonly id: number;\n\treadonly #downstream: ProviderSide;\n\t/**\n\t * What the upstream hold asks for, with the chain and decoded limit this host honoured; its params owned, not a view\n\t * of the message they came in.\n\t */\n\treadonly #request: HoldRequest;\n\t/** Whom the hold acts for, sent on route links. */\n\treadonly caller: Caller;\n\treadonly #path: Path;\n\t/** The upstream link while the path has one, and the downstream origin's number on it. */\n\t#upstream: { readonly link: HostLink; readonly origin: number } | undefined;\n\n\tconstructor(id: number, downstream: ProviderSide, request: HoldRequest, caller: Caller, path: Path) {\n\t\tthis.id = id;\n\t\tthis.#downstream = downstream;\n\t\tconst { params } = request;\n\t\t// Params are never deflated: the provider side refused deflated ones.\n\t\tconst owned = typeof params === \"string\" ? params : (params as Uint8Array).slice();\n\t\tthis.#request = { ...request, params: owned };\n\t\tthis.caller = caller;\n\t\tthis.#path = path;\n\t}\n\n\t/** Takes the pending hold's place downstream and holds upstream (now, or when the path has a link). */\n\tstart(): void {\n\t\tthis.#downstream.relayed(this);\n\t\tthis.#path.attach(this);\n\t}\n\n\t/** Whether it is held on `link` now: only that link answers for it. */\n\theldOn(link: HostLink): boolean {\n\t\treturn this.#upstream?.link === link;\n\t}\n\n\t/** Holds on `link`, the path's link now: its kept `hold` message, with whom it acts for on a route link. */\n\tattach(link: HostLink): void {\n\t\tconst origin = this.#downstream.relayTo(link);\n\t\tthis.#upstream = { link, origin };\n\t\tlink.send({ kind: \"hold\", origin, hold: this.id, ...this.#request, ...actingFor(link, this.caller) });\n\t}\n\n\t/** The upstream link dropped: downstream its calls fail and the hold goes loading until the path's next link. */\n\tdropped(error: ChordError): void {\n\t\tconst upstream = this.#upstream;\n\t\tthis.#upstream = undefined;\n\t\tif (upstream !== undefined) this.#downstream.upstreamDropped(this, error);\n\t}\n\n\t/** Its path's address cannot be reached for now: downstream it fails `waiting` with `error` until the next link. */\n\tunreachable(error: ChordError): void {\n\t\tthis.#downstream.send({ kind: \"failed\", hold: this.id, cause: { kind: \"waiting\", error: wireError(error) } });\n\t}\n\n\t/**\n\t * Whether it waits for its path's link (a route still resolving, or a dropped link's next): a revocation ends it then,\n\t * since the link it is held on next gets no past `revoke` (§4).\n\t */\n\tget waiting(): boolean {\n\t\treturn this.#upstream === undefined;\n\t}\n\n\t/** Revoked while it waited for its path's link: forgotten, and `gone` with `error` downstream. */\n\trevoked(error: ChordError): void {\n\t\tthis.drop();\n\t\tthis.#downstream.forget(this);\n\t\tthis.#downstream.send({ kind: \"gone\", hold: this.id, error: wireError(error) });\n\t}\n\n\t/** `gone` from upstream: the hold is forgotten (the downstream origin forwards the message). */\n\tlost(): void {\n\t\tthis.drop();\n\t\tthis.#downstream.forget(this);\n\t}\n\n\t/**\n\t * A call from downstream (registered there under its id), forwarded upstream at once; its reply comes back by the\n\t * origin. Without an upstream link it is answered `unavailable` at once (it crossed the `loading` notice).\n\t */\n\tcall(message: Extract<Message, { readonly kind: \"call\" }>): void {\n\t\tconst upstream = this.#upstream;\n\t\tif (upstream !== undefined) {\n\t\t\tupstream.link.send({ ...message, origin: upstream.origin });\n\t\t\treturn;\n\t\t}\n\t\tconst error = new ChordError({ code: \"unavailable\", message: `hold ${this.id}: its upstream link is down` });\n\t\tthis.#downstream.reply(message.call, { kind: \"error\", call: message.call, error: wireError(error) });\n\t}\n\n\t/** A downstream `abort` of call `id`, forwarded. */\n\tabort(id: number): void {\n\t\tconst upstream = this.#upstream;\n\t\tupstream?.link.send({ kind: \"abort\", origin: upstream.origin, call: id });\n\t}\n\n\t/** A downstream `retry`, forwarded with its hop budget as it is (a relay visits no object). */\n\tretry(message: Extract<Message, { readonly kind: \"retry\" }>): void {\n\t\tconst upstream = this.#upstream;\n\t\tupstream?.link.send({ ...message, origin: upstream.origin });\n\t}\n\n\t/** Released downstream: released upstream (its calls with it) and no later link holds it. */\n\trelease(): void {\n\t\tconst upstream = this.#upstream;\n\t\tthis.drop();\n\t\tupstream?.link.send({ kind: \"release\", origin: upstream.origin, hold: this.id });\n\t}\n\n\t/** No later link holds it (gone, or its downstream origin closed, which `closed` tells the upstream links). */\n\tdrop(): void {\n\t\tthis.#upstream = undefined;\n\t\tthis.#path.detach(this);\n\t}\n}\n"]}

package/dist/next/remote/remote-object.d.ts

@@ -0,0 +1,133 @@
+import { type Context } from "../../context/index.ts";
+import type { Contract } from "../contracts/index.ts";
+import { ChordError } from "../data/index.ts";
+import { type AnyHost, type Attachable, type Binding, type Caller, type CheckedParams, type ChordObject, type Followed, type PinnedKey, type RefState, type RetryWalk, type Target } from "../host/internal.ts";
+import { type BoundEntry, type Message, type StateEntry, type WireAddress } from "../link/internal.ts";
+import type { DeriveSource } from "../state/internal.ts";
+import type { HoldRequest } from "./hold.ts";
+import type { HostLink } from "./host-link.ts";
+import type { Path } from "./path.ts";
+/**
+ * One remote reference's object, owned by its host across the links of its path. It is `loading` until a link's hold
+ * of it is bound, and again whenever that link drops or its relay's upstream starts over; each link holds it with its
+ * own id. Two references are two holds, each member of each with its own Delta decoder.
+ */
+export declare class RemoteObject implements Target {
+    #private;
+    readonly kind = "remote";
+    /** The object in errors: its type, and its params key when it has params. */
+    readonly label: string;
+    readonly contract: Contract;
+    /** What its holds ask for: the params as a part (checked by L1 when the reference was made), the address. */
+    readonly request: HoldRequest;
+    /** Whom its reference acts for: named on route links (`actingFor`). */
+    readonly caller: Caller;
+    constructor(host: AnyHost, contract: Contract, { params, key }: CheckedParams, address: WireAddress, caller: Caller, path: Path, dependent: ChordObject | undefined);
+    get state(): RefState;
+    /** An object over a link is no blocker of this host's first pass. */
+    get blocksFirstPass(): false;
+    /** The error of the last `failed`, until `bound`. */
+    get lastFailure(): ChordError | undefined;
+    /** The variant last bound; `undefined` before the first binding. */
+    get variant(): string | undefined;
+    /** Whether its state members have values: bound once. */
+    get hydrated(): boolean;
+    /** Its one reference bound to it. */
+    hold(binding: Binding): void;
+    /** The reference was released: the current link's provider is told and the reference's sent calls rejected. */
+    unhold(_binding: Binding): void;
+    /**
+     * Holds on `link`, the path's link now (a first hold, or a re-hold on a new link), with the activation chain of its
+     * dependent while that activates (Q5).
+     */
+    attach(link: HostLink): void;
+    /**
+     * Its path's address cannot be reached for now (a route's `resolve` failed, a suspension): `failed { waiting }` with
+     * `error`, still on the path, bound by its next link.
+     */
+    unreachable(error: ChordError): void;
+    /** The link dropped: loading until a new link's hold is bound (`#startOver`). */
+    dropped(_error: ChordError): void;
+    /**
+     * Calls a method of the bound variant over the link; one outside it fails `invalid/member`. Only a live object is
+     * called: bound on an open link.
+     */
+    call(method: string, args: unknown, context: Context): Promise<unknown>;
+    /**
+     * The replica of `member`; `not_ready` before the first binding, `invalid/member` for a member no binding had (one
+     * a later variant lacks reads its `invalid/member` failure).
+     */
+    member(member: string): DeriveSource;
+    /**
+     * What its reference follows of `member` (a consumer over a link binds at its own version, mapped at the provider):
+     * the replica while live, a member the bound variant lacks (`invalid/member`); while loading or failed nothing, the
+     * replica (kept until the next binding) giving its last value (rule 5).
+     */
+    followed(member: string, _version: number): Followed;
+    /** Its binding while live (its replicas change); `undefined` while loading or failed. */
+    get attachable(): Attachable | undefined;
+    /** Keyed members are only in local contracts: no instance to pin a key on. */
+    get instance(): undefined;
+    /** Keyed members are only in local contracts (`keyedMember`). */
+    keyedMapping(member: string): never;
+    /** Keyed members are only in local contracts (`keyedMember`). */
+    pinKey(member: string): Promise<PinnedKey>;
+    /** Keyed members are only in local contracts, whose objects are never held over a link (slice 6a §12). */
+    keyedMember(member: string): never;
+    /** An object over a link activates on another host: it is in no chain here (Q5). */
+    get activationId(): undefined;
+    /** An object over a link waits for nothing on this host: no chain of waits (its holds carry the chain, Q5). */
+    pathTo(): undefined;
+    /**
+     * `ref.retry()`, as a step of `walk`: a failed object's provider is asked for an attempt with the walk's hop budget,
+     * none left: nothing is sent (a hold it refused is started there again; a parked object there passes it on with one
+     * hop less). One that failed for a part past the link's limits is placed anew and held with a new id, now or on its
+     * path's next link (a `hostAddress` that throws fails it broken again).
+     */
+    retry(walk: RetryWalk): void;
+    /**
+     * A part of its snapshot or of a state change was past the link's limits (`too_large/part`): the hold is released
+     * at the provider, and the reference fails broken with `error`, final: no link holds it again (a reconnect
+     * included) until `retry`.
+     */
+    tooLarge(error: ChordError): void;
+    /**
+     * Prepares one entry of a `bound` message (a first binding, a re-hold; a live hold is bound again): the
+     * variant and every state member once, as a value or as failed. Returns what applies it inside the batch of the
+     * whole message: a member it had gets the snapshot as one frame `[["r", value]]` and a fresh decoder, a member
+     * outside the new variant fails (its replica stays, for a later binding that has it again), a new one gets its first
+     * value. Throws on a snapshot that
+     * does not fit (a protocol error), and `too_large/part` for a value past the link's limits, before anything changed.
+     * `wentLive` follows the batch.
+     */
+    prepareBound(entry: BoundEntry, link: HostLink): () => void;
+    /** After a `bound` message's batch: the reference goes live (its parked calls are sent, a parked dependent goes on). */
+    wentLive(): void;
+    /**
+     * `failed`: the provider's object failed and no attempt runs (`retryIn`: the rest of its backoff window), or the hold
+     * is unbound there or its object parked on a failed dependency (`waiting`), each new cause a new message. On a bound
+     * hold it unbinds it (slice 7b, model §5): the members keep their last values until the next `bound`.
+     */
+    failed(message: Extract<Message, {
+        readonly kind: "failed";
+    }>): void;
+    /**
+     * `loading`: the provider's object started a new attempt after a failure, or its relay's upstream link dropped
+     * (`#startOver`).
+     */
+    loading(): void;
+    /**
+     * Decodes and applies one entry of a state message (its members by index, each with its ops), without changing
+     * anything yet: returns what adopts it into the replicas, run inside the batch that applies the whole message.
+     * Throws on an entry that does not fit (a protocol error), and `too_large/part` for ops past the link's limits.
+     */
+    prepare({ hold: id, members, failed, retired }: StateEntry, link: HostLink): () => void;
+    /**
+     * Its principal was revoked on this host (`host.revoke`): released at its provider if it is held there, then ended
+     * with `error` as `lost` does; no later link holds it.
+     */
+    revoke(error: ChordError): void;
+    /** `gone`, or the host closes: the reference ends, its calls reject with `error`. */
+    lost(error: ChordError): void;
+}
+//# sourceMappingURL=remote-object.d.ts.map

package/dist/next/remote/remote-object.d.ts.map

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