@earendil-works/chord 1.4.0 → 1.5.0

package/dist/next/remote/consumer.js

@@ -0,0 +1,343 @@
+// The consumer side of a link (§7, §22, W1): the holds this host's own remote references sent on it, by this side's
+// ids, the calls through them within the peer's call window, and each `bound` and `state` message applied to their
+// replicas as one batch, then acknowledged. Messages with an origin answer holds this host relays: they go to that
+// origin's provider side. On a host without a compressor, the deflated parts of this host's own holds and calls are
+// inflated asynchronously first, and the message is handled once they are.
+import { takesNoArgs } from "../contracts/internal.js";
+import { ChordError, isChordError } from "../data/index.js";
+import { asChordError } from "../data/internal.js";
+import { errorFromWire, parsePayload, payloadPart, } from "../link/internal.js";
+import { CallWindow } from "./calls.js";
+import { actingFor } from "./hold.js";
+/**
+ * The consumer side of one link. Ids are its own counters, from 0; a reply naming an id this side gave up is ignored
+ * (Q1). When the link closes, every call rejects `unavailable` (never resent) and its path tells every holder.
+ */
+export class ConsumerSide {
+    #link;
+    #entries = new Map();
+    #calls = new Map();
+    #window = new CallWindow();
+    #nextHold = 0;
+    #nextCall = 0;
+    constructor(link) {
+        this.#link = link;
+    }
+    /**
+     * Holds `holder` on this link and returns its new id: its first hold, or a re-hold on a new link; `chain`: the
+     * activation chain it is held for, if any (Q5).
+     */
+    attach(holder, chain) {
+        const id = this.#nextHold++;
+        this.#entries.set(id, holder);
+        const acting = actingFor(this.#link, holder.caller);
+        this.#link.send({
+            kind: "hold",
+            hold: id,
+            ...holder.request,
+            ...acting,
+            ...(chain === undefined ? {} : { chain }),
+        });
+        return id;
+    }
+    /**
+     * Calls method `method` (an index into the bound variant) on hold `hold` with `args`: left out for a method without
+     * arguments, with byte segments when its argument schema has a `bytes()` leaf, deflated above the threshold except on
+     * the parent link. The result is parsed here. The caller's cancellation rejects it at once and sends `abort` when it
+     * is in flight.
+     */
+    call(hold, method, data, args, context) {
+        const signal = context.abortSignal;
+        signal?.throwIfAborted();
+        const payload = takesNoArgs(data) ? undefined : payloadPart(args, data.args.bytes);
+        // Up a parent link they travel uncompressed: the parent may have accepted this host as a child, and child links
+        // refuse compressed parts (§22).
+        const link = this.#link;
+        const part = payload === undefined ? undefined : link.role === "parent" ? payload.json : link.part(payload.json, context);
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const cancel = () => {
+            this.#cancel(call);
+            reject(signal.reason);
+        };
+        const done = () => signal?.removeEventListener("abort", cancel);
+        const call = {
+            hold,
+            method,
+            args: part,
+            segments: payload?.segments,
+            resolve: (value) => {
+                done();
+                resolve(value);
+            },
+            reject: (error) => {
+                done();
+                reject(error);
+            },
+            id: undefined,
+            send: () => this.#send(call),
+        };
+        signal?.addEventListener("abort", cancel, { once: true });
+        this.#window.submit(call);
+        return promise;
+    }
+    /** Hold `hold` was released: the provider is told, its calls fail with `error`. */
+    release(hold, error) {
+        this.#link.send({ kind: "release", hold });
+        this.forget(hold, error);
+    }
+    /** `ref.retry()` on a failed hold, with `hops` left of its budget: the provider is asked for an attempt now. */
+    retry(hold, hops) {
+        this.#link.send({ kind: "retry", hold, hops });
+    }
+    /** Drops hold `hold` from the tables; its calls, in flight and waiting, fail with `error` and free their slots. */
+    forget(hold, error) {
+        this.#entries.delete(hold);
+        this.#failCalls(hold, error);
+    }
+    /** The peer's `hello` arrived: calls go out within its window. */
+    opened(calls) {
+        this.#window.opened(calls);
+    }
+    /**
+     * Handles one message from the provider: this host's own, or (with an origin) one for a relayed hold. A `bound`,
+     * `state` or `result` with deflated parts to inflate asynchronously returns that promise and is handled after it.
+     */
+    message(message) {
+        if (message.origin !== undefined) {
+            this.#link.host.relays.get(message.origin)?.forward(message, this.#link);
+            return;
+        }
+        switch (message.kind) {
+            case "bound":
+            case "state": {
+                const deflated = this.#deflated(message.holds);
+                if (deflated !== undefined)
+                    return this.#link.inflate(deflated, () => this.message(message));
+                if (message.kind === "bound")
+                    this.#bound(message.holds);
+                else
+                    this.#state(message.holds);
+                break;
+            }
+            case "failed":
+                this.#failed(message);
+                break;
+            case "loading":
+                this.#loading(message.hold);
+                break;
+            case "result":
+            case "error":
+                return this.#reply(message);
+            case "gone":
+                this.#gone(message);
+                break;
+        }
+    }
+    /** The link closed: calls in flight and waiting reject `unavailable` (never resent, §7); the tables are dropped. */
+    closed() {
+        const error = new ChordError({ code: "unavailable", message: "the link closed" });
+        const calls = [...this.#calls.values(), ...this.#window.clear()];
+        this.#calls.clear();
+        this.#entries.clear();
+        for (const call of calls)
+            call.reject(error);
+    }
+    /** Sends a call that got its slot, with the next id. */
+    #send(call) {
+        const id = this.#nextCall++;
+        call.id = id;
+        this.#calls.set(id, call);
+        const { hold, method, args, segments } = call;
+        this.#link.send({
+            kind: "call",
+            call: id,
+            hold,
+            method,
+            ...(args === undefined ? {} : { args }),
+            ...(segments === undefined ? {} : { segments }),
+        });
+    }
+    /**
+     * Cancels `call`: a waiting one leaves the window and nothing is sent; one in flight sends `abort` and frees its
+     * slot. Settling the caller is the caller's.
+     */
+    #cancel(call) {
+        if (call.id === undefined) {
+            this.#window.remove(call);
+            return;
+        }
+        if (!this.#calls.delete(call.id))
+            return;
+        this.#link.send({ kind: "abort", call: call.id });
+        this.#window.freed();
+    }
+    /**
+     * The deflated parts of this side's own holds in `entries` that wait for an asynchronous inflate, each with the
+     * link's decoded limit; `undefined` when none does (nothing allocated). Entries of holds this side gave up are not
+     * inflated (Q1).
+     */
+    #deflated(entries) {
+        const { limits } = this.#link;
+        let deflated;
+        for (const entry of entries) {
+            if (!this.#entries.has(entry.hold))
+                continue;
+            for (const member of entry.members) {
+                const part = "value" in member ? member.value : member.ops;
+                if (!this.#link.inflates(part, limits))
+                    continue;
+                deflated ??= [];
+                deflated.push([part, limits.decoded]);
+            }
+        }
+        return deflated;
+    }
+    /**
+     * One `bound` message: every entry prepared first (one that does not fit closes the link before anything changed)
+     * and applied in one batch; then the references go live, and the message is acknowledged. An entry with a part past
+     * the link's limits fails only its hold (`too_large/part`); the others apply.
+     */
+    #bound(holds) {
+        const adoptions = [];
+        const bound = [];
+        let oversized;
+        for (const entry of holds) {
+            const holder = this.#entries.get(entry.hold);
+            if (holder === undefined)
+                continue;
+            try {
+                adoptions.push(holder.prepareBound(entry, this.#link));
+            }
+            catch (error) {
+                if (!isChordError(error, "too_large"))
+                    throw error;
+                oversized ??= [];
+                oversized.push([holder, error]);
+                continue;
+            }
+            bound.push(holder);
+        }
+        this.#adopt(adoptions);
+        // After the batch: the references go live with every replica of the message in place.
+        for (const holder of bound)
+            holder.wentLive();
+        for (const [holder, error] of oversized ?? [])
+            holder.tooLarge(error);
+        this.#link.send({ kind: "ack" });
+    }
+    /** One `state` message, as `#bound` does it. */
+    #state(holds) {
+        const adoptions = [];
+        let oversized;
+        for (const entry of holds) {
+            const holder = this.#entries.get(entry.hold);
+            if (holder === undefined)
+                continue;
+            try {
+                adoptions.push(holder.prepare(entry, this.#link));
+            }
+            catch (error) {
+                if (!isChordError(error, "too_large"))
+                    throw error;
+                oversized ??= [];
+                oversized.push([holder, error]);
+            }
+        }
+        this.#adopt(adoptions);
+        for (const [holder, error] of oversized ?? [])
+            holder.tooLarge(error);
+        this.#link.send({ kind: "ack" });
+    }
+    /** Applies prepared entries in one batch of this host, so no watch or derive sees half a provider commit (W1). */
+    #adopt(adoptions) {
+        if (adoptions.length === 0)
+            return;
+        this.#link.host.batch.commit(() => {
+            for (const adopt of adoptions)
+                adopt();
+        }, this.#link.context);
+    }
+    /**
+     * `loading`: the hold's object, or its relay's upstream, starts over; its calls still waiting for a slot reject
+     * `unavailable` (they may name a method of the old variant).
+     */
+    #loading(hold) {
+        const holder = this.#entries.get(hold);
+        if (holder === undefined)
+            return;
+        const error = new ChordError({ code: "unavailable", message: `hold ${hold}: rebinding` });
+        for (const call of this.#window.removeHold(hold))
+            call.reject(error);
+        holder.loading();
+    }
+    /**
+     * `failed`: its holder fails; its calls still waiting for a slot reject with the cause (a bound hold is unbound by it,
+     * slice 7b; its calls in flight are rejected by the provider).
+     */
+    #failed(message) {
+        const holder = this.#entries.get(message.hold);
+        if (holder === undefined)
+            return;
+        const error = asChordError(errorFromWire(message.cause.error), `hold ${message.hold}`);
+        for (const call of this.#window.removeHold(message.hold))
+            call.reject(error);
+        holder.failed(message);
+    }
+    /**
+     * `gone`: one for a hold this side gave up is ignored (Q1); the holder ends, which forgets its hold here and fails
+     * its calls.
+     */
+    #gone(message) {
+        const holder = this.#entries.get(message.hold);
+        if (holder === undefined)
+            return;
+        holder.lost(asChordError(errorFromWire(message.error), `hold ${message.hold}`));
+    }
+    /**
+     * A reply: its call settles with the parsed result or the error. A result past the link's limits rejects the call
+     * `too_large/part`. A malformed part rejects the call `unavailable` and throws (a protocol error: the link closes).
+     * A result to inflate asynchronously is inflated first (for a call still waiting), then handled again.
+     */
+    #reply(reply) {
+        const call = this.#calls.get(reply.call);
+        if (call === undefined)
+            return;
+        const link = this.#link;
+        if (reply.kind === "result" && link.inflates(reply.value, link.limits)) {
+            return link.inflate([[reply.value, link.limits.decoded]], () => this.#reply(reply));
+        }
+        this.#calls.delete(reply.call);
+        this.#window.freed();
+        try {
+            if (reply.kind === "error")
+                call.reject(errorFromWire(reply.error));
+            else if (reply.value === undefined)
+                call.resolve(null);
+            else
+                call.resolve(parsePayload(link.openPart(reply.value, link.limits, link.context), reply.segments));
+        }
+        catch (error) {
+            if (isChordError(error, "too_large")) {
+                call.reject(error);
+                return;
+            }
+            call.reject(new ChordError({ code: "unavailable", message: `call ${reply.call}: a malformed reply` }));
+            throw error;
+        }
+    }
+    /** Fails `hold`'s calls in flight and waiting with `error`; each in-flight one frees its slot. */
+    #failCalls(hold, error) {
+        // Waiting ones first: a freed slot must not send one of them.
+        const failed = this.#window.removeHold(hold);
+        for (const [id, call] of this.#calls) {
+            if (call.hold !== hold)
+                continue;
+            this.#calls.delete(id);
+            this.#window.freed();
+            failed.push(call);
+        }
+        for (const call of failed)
+            call.reject(error);
+    }
+}
+//# sourceMappingURL=consumer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.js","sourceRoot":"","sources":["../../../src/next/remote/consumer.ts"],"names":[],"mappings":"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","sourcesContent":["// The consumer side of a link (§7, §22, W1): the holds this host's own remote references sent on it, by this side's\n// ids, the calls through them within the peer's call window, and each `bound` and `state` message applied to their\n// replicas as one batch, then acknowledged. Messages with an origin answer holds this host relays: they go to that\n// origin's provider side. On a host without a compressor, the deflated parts of this host's own holds and calls are\n// inflated asynchronously first, and the message is handled once they are.\n\nimport type { Context } from \"../../context/index.ts\";\nimport { type MethodData, takesNoArgs } from \"../contracts/internal.ts\";\nimport { ChordError, isChordError } from \"../data/index.ts\";\nimport { asChordError } from \"../data/internal.ts\";\nimport {\n\ttype BoundEntry,\n\ttype ConsumerMessage,\n\ttype DeflatedPart,\n\terrorFromWire,\n\ttype Message,\n\ttype Part,\n\tparsePayload,\n\tpayloadPart,\n\ttype StateEntry,\n} from \"../link/internal.ts\";\nimport { CallWindow } from \"./calls.ts\";\nimport { actingFor } from \"./hold.ts\";\nimport type { HostLink } from \"./host-link.ts\";\nimport type { RemoteObject } from \"./remote-object.ts\";\n\n/** A reply to a call. */\ntype Reply = Extract<Message, { readonly kind: \"result\" | \"error\" }>;\n\n/**\n * A call through this side: waiting for a slot of the call window (no id yet), then in flight under its id until its\n * reply, its abort, its hold's release or `gone`, or the link's close.\n */\ntype OutgoingCall = {\n\treadonly hold: number;\n\t/** The method's index in the bound variant and its arguments' part. */\n\treadonly method: number;\n\treadonly args: Part | undefined;\n\treadonly segments: readonly Uint8Array[] | undefined;\n\treadonly resolve: (value: unknown) => void;\n\treadonly reject: (error: unknown) => void;\n\tid: number | undefined;\n\tsend(): void;\n};\n\n/**\n * The consumer side of one link. Ids are its own counters, from 0; a reply naming an id this side gave up is ignored\n * (Q1). When the link closes, every call rejects `unavailable` (never resent) and its path tells every holder.\n */\nexport class ConsumerSide {\n\treadonly #link: HostLink;\n\treadonly #entries = new Map<number, RemoteObject>();\n\treadonly #calls = new Map<number, OutgoingCall>();\n\treadonly #window = new CallWindow<OutgoingCall>();\n\t#nextHold = 0;\n\t#nextCall = 0;\n\n\tconstructor(link: HostLink) {\n\t\tthis.#link = link;\n\t}\n\n\t/**\n\t * Holds `holder` on this link and returns its new id: its first hold, or a re-hold on a new link; `chain`: the\n\t * activation chain it is held for, if any (Q5).\n\t */\n\tattach(holder: RemoteObject, chain: string[] | undefined): number {\n\t\tconst id = this.#nextHold++;\n\t\tthis.#entries.set(id, holder);\n\t\tconst acting = actingFor(this.#link, holder.caller);\n\t\tthis.#link.send({\n\t\t\tkind: \"hold\",\n\t\t\thold: id,\n\t\t\t...holder.request,\n\t\t\t...acting,\n\t\t\t...(chain === undefined ? {} : { chain }),\n\t\t});\n\t\treturn id;\n\t}\n\n\t/**\n\t * Calls method `method` (an index into the bound variant) on hold `hold` with `args`: left out for a method without\n\t * arguments, with byte segments when its argument schema has a `bytes()` leaf, deflated above the threshold except on\n\t * the parent link. The result is parsed here. The caller's cancellation rejects it at once and sends `abort` when it\n\t * is in flight.\n\t */\n\tcall(hold: number, method: number, data: MethodData, args: unknown, context: Context): Promise<unknown> {\n\t\tconst signal = context.abortSignal;\n\t\tsignal?.throwIfAborted();\n\t\tconst payload = takesNoArgs(data) ? undefined : payloadPart(args, data.args.bytes);\n\t\t// Up a parent link they travel uncompressed: the parent may have accepted this host as a child, and child links\n\t\t// refuse compressed parts (§22).\n\t\tconst link = this.#link;\n\t\tconst part =\n\t\t\tpayload === undefined ? undefined : link.role === \"parent\" ? payload.json : link.part(payload.json, context);\n\t\tconst { promise, resolve, reject } = Promise.withResolvers<unknown>();\n\t\tconst cancel = (): void => {\n\t\t\tthis.#cancel(call);\n\t\t\treject(signal!.reason);\n\t\t};\n\t\tconst done = (): void => signal?.removeEventListener(\"abort\", cancel);\n\t\tconst call: OutgoingCall = {\n\t\t\thold,\n\t\t\tmethod,\n\t\t\targs: part,\n\t\t\tsegments: payload?.segments,\n\t\t\tresolve: (value) => {\n\t\t\t\tdone();\n\t\t\t\tresolve(value);\n\t\t\t},\n\t\t\treject: (error) => {\n\t\t\t\tdone();\n\t\t\t\treject(error);\n\t\t\t},\n\t\t\tid: undefined,\n\t\t\tsend: () => this.#send(call),\n\t\t};\n\t\tsignal?.addEventListener(\"abort\", cancel, { once: true });\n\t\tthis.#window.submit(call);\n\t\treturn promise;\n\t}\n\n\t/** Hold `hold` was released: the provider is told, its calls fail with `error`. */\n\trelease(hold: number, error: ChordError): void {\n\t\tthis.#link.send({ kind: \"release\", hold });\n\t\tthis.forget(hold, error);\n\t}\n\n\t/** `ref.retry()` on a failed hold, with `hops` left of its budget: the provider is asked for an attempt now. */\n\tretry(hold: number, hops: number): void {\n\t\tthis.#link.send({ kind: \"retry\", hold, hops });\n\t}\n\n\t/** Drops hold `hold` from the tables; its calls, in flight and waiting, fail with `error` and free their slots. */\n\tforget(hold: number, error: ChordError): void {\n\t\tthis.#entries.delete(hold);\n\t\tthis.#failCalls(hold, error);\n\t}\n\n\t/** The peer's `hello` arrived: calls go out within its window. */\n\topened(calls: number): void {\n\t\tthis.#window.opened(calls);\n\t}\n\n\t/**\n\t * Handles one message from the provider: this host's own, or (with an origin) one for a relayed hold. A `bound`,\n\t * `state` or `result` with deflated parts to inflate asynchronously returns that promise and is handled after it.\n\t */\n\tmessage(message: ConsumerMessage): void | Promise<void> {\n\t\tif (message.origin !== undefined) {\n\t\t\tthis.#link.host.relays.get(message.origin)?.forward(message, this.#link);\n\t\t\treturn;\n\t\t}\n\t\tswitch (message.kind) {\n\t\t\tcase \"bound\":\n\t\t\tcase \"state\": {\n\t\t\t\tconst deflated = this.#deflated(message.holds);\n\t\t\t\tif (deflated !== undefined) return this.#link.inflate(deflated, () => this.message(message));\n\t\t\t\tif (message.kind === \"bound\") this.#bound(message.holds);\n\t\t\t\telse this.#state(message.holds);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"failed\":\n\t\t\t\tthis.#failed(message);\n\t\t\t\tbreak;\n\t\t\tcase \"loading\":\n\t\t\t\tthis.#loading(message.hold);\n\t\t\t\tbreak;\n\t\t\tcase \"result\":\n\t\t\tcase \"error\":\n\t\t\t\treturn this.#reply(message);\n\t\t\tcase \"gone\":\n\t\t\t\tthis.#gone(message);\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\t/** The link closed: calls in flight and waiting reject `unavailable` (never resent, §7); the tables are dropped. */\n\tclosed(): void {\n\t\tconst error = new ChordError({ code: \"unavailable\", message: \"the link closed\" });\n\t\tconst calls = [...this.#calls.values(), ...this.#window.clear()];\n\t\tthis.#calls.clear();\n\t\tthis.#entries.clear();\n\t\tfor (const call of calls) call.reject(error);\n\t}\n\n\t/** Sends a call that got its slot, with the next id. */\n\t#send(call: OutgoingCall): void {\n\t\tconst id = this.#nextCall++;\n\t\tcall.id = id;\n\t\tthis.#calls.set(id, call);\n\t\tconst { hold, method, args, segments } = call;\n\t\tthis.#link.send({\n\t\t\tkind: \"call\",\n\t\t\tcall: id,\n\t\t\thold,\n\t\t\tmethod,\n\t\t\t...(args === undefined ? {} : { args }),\n\t\t\t...(segments === undefined ? {} : { segments }),\n\t\t});\n\t}\n\n\t/**\n\t * Cancels `call`: a waiting one leaves the window and nothing is sent; one in flight sends `abort` and frees its\n\t * slot. Settling the caller is the caller's.\n\t */\n\t#cancel(call: OutgoingCall): void {\n\t\tif (call.id === undefined) {\n\t\t\tthis.#window.remove(call);\n\t\t\treturn;\n\t\t}\n\t\tif (!this.#calls.delete(call.id)) return;\n\t\tthis.#link.send({ kind: \"abort\", call: call.id });\n\t\tthis.#window.freed();\n\t}\n\n\t/**\n\t * The deflated parts of this side's own holds in `entries` that wait for an asynchronous inflate, each with the\n\t * link's decoded limit; `undefined` when none does (nothing allocated). Entries of holds this side gave up are not\n\t * inflated (Q1).\n\t */\n\t#deflated(entries: readonly (BoundEntry | StateEntry)[]): [DeflatedPart, number][] | undefined {\n\t\tconst { limits } = this.#link;\n\t\tlet deflated: [DeflatedPart, number][] | undefined;\n\t\tfor (const entry of entries) {\n\t\t\tif (!this.#entries.has(entry.hold)) continue;\n\t\t\tfor (const member of entry.members) {\n\t\t\t\tconst part = \"value\" in member ? member.value : member.ops;\n\t\t\t\tif (!this.#link.inflates(part, limits)) continue;\n\t\t\t\tdeflated ??= [];\n\t\t\t\tdeflated.push([part, limits.decoded]);\n\t\t\t}\n\t\t}\n\t\treturn deflated;\n\t}\n\n\t/**\n\t * One `bound` message: every entry prepared first (one that does not fit closes the link before anything changed)\n\t * and applied in one batch; then the references go live, and the message is acknowledged. An entry with a part past\n\t * the link's limits fails only its hold (`too_large/part`); the others apply.\n\t */\n\t#bound(holds: readonly BoundEntry[]): void {\n\t\tconst adoptions: (() => void)[] = [];\n\t\tconst bound: RemoteObject[] = [];\n\t\tlet oversized: [RemoteObject, ChordError][] | undefined;\n\t\tfor (const entry of holds) {\n\t\t\tconst holder = this.#entries.get(entry.hold);\n\t\t\tif (holder === undefined) continue;\n\t\t\ttry {\n\t\t\t\tadoptions.push(holder.prepareBound(entry, this.#link));\n\t\t\t} catch (error) {\n\t\t\t\tif (!isChordError(error, \"too_large\")) throw error;\n\t\t\t\toversized ??= [];\n\t\t\t\toversized.push([holder, error]);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tbound.push(holder);\n\t\t}\n\t\tthis.#adopt(adoptions);\n\t\t// After the batch: the references go live with every replica of the message in place.\n\t\tfor (const holder of bound) holder.wentLive();\n\t\tfor (const [holder, error] of oversized ?? []) holder.tooLarge(error);\n\t\tthis.#link.send({ kind: \"ack\" });\n\t}\n\n\t/** One `state` message, as `#bound` does it. */\n\t#state(holds: readonly StateEntry[]): void {\n\t\tconst adoptions: (() => void)[] = [];\n\t\tlet oversized: [RemoteObject, ChordError][] | undefined;\n\t\tfor (const entry of holds) {\n\t\t\tconst holder = this.#entries.get(entry.hold);\n\t\t\tif (holder === undefined) continue;\n\t\t\ttry {\n\t\t\t\tadoptions.push(holder.prepare(entry, this.#link));\n\t\t\t} catch (error) {\n\t\t\t\tif (!isChordError(error, \"too_large\")) throw error;\n\t\t\t\toversized ??= [];\n\t\t\t\toversized.push([holder, error]);\n\t\t\t}\n\t\t}\n\t\tthis.#adopt(adoptions);\n\t\tfor (const [holder, error] of oversized ?? []) holder.tooLarge(error);\n\t\tthis.#link.send({ kind: \"ack\" });\n\t}\n\n\t/** Applies prepared entries in one batch of this host, so no watch or derive sees half a provider commit (W1). */\n\t#adopt(adoptions: readonly (() => void)[]): void {\n\t\tif (adoptions.length === 0) return;\n\t\tthis.#link.host.batch.commit(() => {\n\t\t\tfor (const adopt of adoptions) adopt();\n\t\t}, this.#link.context);\n\t}\n\n\t/**\n\t * `loading`: the hold's object, or its relay's upstream, starts over; its calls still waiting for a slot reject\n\t * `unavailable` (they may name a method of the old variant).\n\t */\n\t#loading(hold: number): void {\n\t\tconst holder = this.#entries.get(hold);\n\t\tif (holder === undefined) return;\n\t\tconst error = new ChordError({ code: \"unavailable\", message: `hold ${hold}: rebinding` });\n\t\tfor (const call of this.#window.removeHold(hold)) call.reject(error);\n\t\tholder.loading();\n\t}\n\n\t/**\n\t * `failed`: its holder fails; its calls still waiting for a slot reject with the cause (a bound hold is unbound by it,\n\t * slice 7b; its calls in flight are rejected by the provider).\n\t */\n\t#failed(message: Extract<Message, { readonly kind: \"failed\" }>): void {\n\t\tconst holder = this.#entries.get(message.hold);\n\t\tif (holder === undefined) return;\n\t\tconst error = asChordError(errorFromWire(message.cause.error), `hold ${message.hold}`);\n\t\tfor (const call of this.#window.removeHold(message.hold)) call.reject(error);\n\t\tholder.failed(message);\n\t}\n\n\t/**\n\t * `gone`: one for a hold this side gave up is ignored (Q1); the holder ends, which forgets its hold here and fails\n\t * its calls.\n\t */\n\t#gone(message: Extract<Message, { readonly kind: \"gone\" }>): void {\n\t\tconst holder = this.#entries.get(message.hold);\n\t\tif (holder === undefined) return;\n\t\tholder.lost(asChordError(errorFromWire(message.error), `hold ${message.hold}`));\n\t}\n\n\t/**\n\t * A reply: its call settles with the parsed result or the error. A result past the link's limits rejects the call\n\t * `too_large/part`. A malformed part rejects the call `unavailable` and throws (a protocol error: the link closes).\n\t * A result to inflate asynchronously is inflated first (for a call still waiting), then handled again.\n\t */\n\t#reply(reply: Reply): void | Promise<void> {\n\t\tconst call = this.#calls.get(reply.call);\n\t\tif (call === undefined) return;\n\t\tconst link = this.#link;\n\t\tif (reply.kind === \"result\" && link.inflates(reply.value, link.limits)) {\n\t\t\treturn link.inflate([[reply.value, link.limits.decoded]], () => this.#reply(reply));\n\t\t}\n\t\tthis.#calls.delete(reply.call);\n\t\tthis.#window.freed();\n\t\ttry {\n\t\t\tif (reply.kind === \"error\") call.reject(errorFromWire(reply.error));\n\t\t\telse if (reply.value === undefined) call.resolve(null);\n\t\t\telse call.resolve(parsePayload(link.openPart(reply.value, link.limits, link.context), reply.segments));\n\t\t} catch (error) {\n\t\t\tif (isChordError(error, \"too_large\")) {\n\t\t\t\tcall.reject(error);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcall.reject(new ChordError({ code: \"unavailable\", message: `call ${reply.call}: a malformed reply` }));\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\t/** Fails `hold`'s calls in flight and waiting with `error`; each in-flight one frees its slot. */\n\t#failCalls(hold: number, error: ChordError): void {\n\t\t// Waiting ones first: a freed slot must not send one of them.\n\t\tconst failed = this.#window.removeHold(hold);\n\t\tfor (const [id, call] of this.#calls) {\n\t\t\tif (call.hold !== hold) continue;\n\t\t\tthis.#calls.delete(id);\n\t\t\tthis.#window.freed();\n\t\t\tfailed.push(call);\n\t\t}\n\t\tfor (const call of failed) call.reject(error);\n\t}\n}\n"]}

package/dist/next/remote/hold.d.ts

@@ -0,0 +1,130 @@
+import type { Context } from "../../context/index.ts";
+import { ChordError, type Principal } from "../data/index.ts";
+import { type Caller, type Holder, type Removal, type UnboundRequest } from "../host/internal.ts";
+import { type BoundEntry, type Limits, type Message, type StateEntry } from "../link/internal.ts";
+import type { HostLink } from "./host-link.ts";
+import type { ProviderSide } from "./provider.ts";
+/** A `hold` message. */
+type HoldMessage = Extract<Message, {
+    readonly kind: "hold";
+}>;
+/**
+ * What a `hold` message asks for. Whom it acts for is not part of it: a host takes that from the message once, as its
+ * link allows (`ProviderSide`), and names it again only on a route link (`actingFor`). Its `chain` and `limit` are the
+ * ones this host honours, sent on as they are when it relays the hold.
+ */
+export type HoldRequest = Omit<HoldMessage, "kind" | "origin" | "hold" | "principal" | "incarnation">;
+/**
+ * One hold served here: a reference to its object acting as its caller (the hold's principal). While pending, each
+ * failure of its object is sent as `failed` (with the rest of its backoff window) and the next attempt as `loading`; a
+ * hold that cannot be taken holds nothing: `failed { waiting }` (not served, another version) until a publication
+ * re-runs its start, `failed { broken }` (invalid params, a cycle) until a `retry` does. Once live it binds when its
+ * link's window has a slot, then sends a part per batch that changed its members (or keeps their ops pending while the
+ * window is full), and `gone` when its object ends. It counts as one of the host's references from its arrival to its
+ * end, bound or not.
+ */
+export declare class Hold implements Holder, UnboundRequest {
+    #private;
+    readonly kind = "served";
+    readonly id: number;
+    /** A hold is declared by no object on this host. */
+    readonly dependent: undefined;
+    /** Whom the hold acts for: its calls run as it, with its origin's incarnation. */
+    readonly caller: Caller;
+    /** The limits per part of its params and its calls' arguments: its link's, the decoded one smaller when stamped (Q2). */
+    readonly limits: Limits;
+    constructor(id: number, provider: ProviderSide, caller: Caller, limits: Limits);
+    /** Whether the hold is bound: its members' changes are sent. */
+    get bound(): boolean;
+    /** Whether calls on it reach its object: bound, or binding afresh after a swap in place (its `bound` not sent yet). */
+    get callable(): boolean;
+    /** Whom it acts for (the unbound index's revocation). */
+    get principal(): Principal | undefined;
+    /** Its consumer's contract version and fingerprint (its request's): the provider binds them or it waits. */
+    get contract(): HoldRequest;
+    /** Whether the hold holds no object: before the publication, or refused (revocation ends it, §4). */
+    get unbound(): boolean;
+    /**
+     * Admits the hold: before the host's publication it waits in the unbound index, placed by the publication.
+     * Then its params within the link's part limit (`too_large/part`), then relayed (it is replaced by a relayed hold),
+     * or served here, its params opened and parsed (a malformed part is a protocol error), its object taken and followed
+     * (`moved`) in the turn it arrived. A hold that cannot be served here waits refused (`#refuse`).
+     */
+    start(request: HoldRequest): void;
+    /**
+     * Woken by the unbound index (out of it already): before the publication, placed now; refused `waiting`, its start
+     * runs again, announced with `loading` (then `bound` or `failed`).
+     */
+    wake(): void;
+    /**
+     * The object's state changed, or the hold took it: a pending hold binds once it is live (when a slot is free),
+     * sends each failure, and announces the attempt after a failure with `loading`. A bound hold (or one whose `bound`
+     * waits for a slot) whose object leaves `live` goes back to pending (slice 7b §6), except while a reload's swap runs
+     * in place; a bound one whose object went live with another attempt (a swap) gets a fresh `bound` (audit A9).
+     */
+    moved(): void;
+    /**
+     * A `retry` message with `hops` left of its budget: the object is asked for an attempt now (it ignores this unless
+     * failed; parked, it passes it on, to other hosts with one hop less); a refused hold is started again (a route's
+     * `authorize` may admit it now).
+     */
+    retry({ hops }: Extract<Message, {
+        readonly kind: "retry";
+    }>): void;
+    /** Calls a method of the held object as the hold's caller. */
+    call(method: string, args: unknown, context: Context): Promise<unknown>;
+    /**
+     * The method at `index` of the bound variant and whether its result carries byte segments (its schema has a
+     * `bytes()` leaf). Throws on an index outside the variant (a protocol error); a hold that is not bound has none.
+     */
+    method(index: number): {
+        readonly name: string;
+        readonly resultBytes: boolean;
+    };
+    /**
+     * The hold's binding, sent when a slot is free. The snapshot of every member, as a value or failed, and the
+     * subscription are taken in this synchronous step (race 2), so each member's next ops continue exactly from it.
+     * Names travel as indexes into the bound version (2b). Counts one encode (`chord.link.encodes`).
+     */
+    boundEntry(context: Context): BoundEntry;
+    /**
+     * This batch's entry of the `state` message: the members it changed with their ops, each encoded once with its
+     * member's encoder, and the members that failed; resets both. Counts one encode per hold (`chord.link.encodes`).
+     */
+    entry(context: Context): StateEntry;
+    /** The window is full: this batch's ops join the members' pending queues (raw, never mutated). */
+    queue(): void;
+    /**
+     * The entry of a freed slot's `state` message: each member's pending ops encoded once, or `[["r", value]]` after an
+     * overflow, all reflecting the latest commit; and the members that failed meanwhile. Counts one encode per hold.
+     */
+    pendingEntry(context: Context): StateEntry;
+    /** The consumer released the hold, or its link closed: its waits stop and its object loses this reference. */
+    release(): void;
+    /** Ends the hold without releasing its object (the host closes and ends its objects itself). */
+    drop(): void;
+    /**
+     * The object ended while held (revocation; a reload, slice 7b), or the hold was revoked (or its host closed) while it
+     * held no object: the hold sends `gone` with `error`.
+     */
+    end(error: ChordError): void;
+    /** A hold over a link follows its object's instances in `moved` (a fresh `bound` for a new one). */
+    retarget(): void;
+    /** It moves nothing in `retarget`. */
+    readonly following = false;
+    /**
+     * Its object left it (slice 7b §6): its type was removed (`not_served`) or its provider no longer binds the hold's
+     * version (`version`): no longer subscribed, its calls in flight rejected, it waits refused with `removal.cause` in
+     * the host's index (a publication starts it again) and the consumer is sent `failed`, which unbinds a bound hold.
+     */
+    removed(removal: Removal): void;
+}
+/** A `hold` message's fields naming whom it acts for. */
+type ActingFor = Pick<HoldMessage, "principal" | "incarnation">;
+/**
+ * The fields of a `hold` message naming whom it acts for (`caller`): sent only on a route link, whose child honours
+ * them (§4); none elsewhere.
+ */
+export declare function actingFor(link: HostLink, { principal, incarnation }: Caller): ActingFor;
+export {};
+//# sourceMappingURL=hold.d.ts.map

package/dist/next/remote/hold.d.ts.map

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