@earendil-works/chord 1.3.0 → 1.5.0

package/dist/next/remote/hold.js

@@ -0,0 +1,537 @@
+// A hold arriving on a link and served here (§7, §22, W1): where it goes once the host published (waiting in the
+// unbound index until then), why it is unbound (refused: kept in the index while it waits for a name, dependency
+// model §1), the object it keeps, the notices of its object's failures and new attempts, the snapshot and subscription
+// taken in one synchronous step when a slot of the window is free, and the ops of its members per batch (sent at
+// once, or pending while the window is full), each member with its own Delta encoder. Across a reload (slice 7b §6) a
+// bound hold is kept: a swap in place sends it a fresh `bound` once the new instance is live (it answers calls
+// meanwhile), an object leaving `live` unbinds it (`loading` or `failed`, then a fresh `bound`), a version no longer
+// bound or a removed type leaves it waiting unbound. A hold of an older version follows its object's adapted members
+// (Q10).
+import { encoder, PendingOps } from "../../delta/index.js";
+import { variantNames, variantOrder, variantsAt } from "../contracts/internal.js";
+import { ChordError, isChordError } from "../data/index.js";
+import { asChordError } from "../data/internal.js";
+import { retryWalk, } from "../host/internal.js";
+import { jsonPart, NO_RETIRED, oversized, parsePart, wireError, } from "../link/internal.js";
+import { Source } from "../state/internal.js";
+import { RelayedHold } from "./relay.js";
+const PENDING = { kind: "pending", toldFailed: false };
+const BINDING = { kind: "binding" };
+/**
+ * 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 class Hold {
+    kind = "served";
+    id;
+    /** A hold is declared by no object on this host. */
+    dependent = undefined;
+    /** Whom the hold acts for: its calls run as it, with its origin's incarnation. */
+    caller;
+    /** The limits per part of its params and its calls' arguments: its link's, the decoded one smaller when stamped (Q2). */
+    limits;
+    #provider;
+    #state = PENDING;
+    /** What it asks for (its params owned), once it started: it is placed again after a reload left it unbound. */
+    #request;
+    /** The held object, from its binding until the hold is released. */
+    #object;
+    /** The members the current batch changed, with their ops, in order. */
+    #changes = [];
+    /** The members that failed since the last message that carried this hold. */
+    #failed = [];
+    /** The members whose document was retired since the last message that carried this hold (ORed while it waits). */
+    #retired = NO_RETIRED;
+    #touched = false;
+    /** Whether the hold counts as one of the host's references (`host.activity`): from its arrival until it ends. */
+    #counted = true;
+    constructor(id, provider, caller, limits) {
+        this.id = id;
+        this.#provider = provider;
+        this.caller = caller;
+        this.limits = limits;
+        provider.link.host.count("references", 1);
+    }
+    /** Whether the hold is bound: its members' changes are sent. */
+    get bound() {
+        return this.#state.kind === "bound";
+    }
+    /** Whether calls on it reach its object: bound, or binding afresh after a swap in place (its `bound` not sent yet). */
+    get callable() {
+        const state = this.#state;
+        return state.kind === "bound" || (state.kind === "binding" && state.previous !== undefined);
+    }
+    /** Whom it acts for (the unbound index's revocation). */
+    get principal() {
+        return this.caller.principal;
+    }
+    /** Its consumer's contract version and fingerprint (its request's): the provider binds them or it waits. */
+    get contract() {
+        return this.#request;
+    }
+    /** Whether the hold holds no object: before the publication, or refused (revocation ends it, §4). */
+    get unbound() {
+        return this.#object === undefined && this.#state.kind !== "released";
+    }
+    /**
+     * 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) {
+        const { link } = this.#provider;
+        if (!link.host.published) {
+            this.#state = { kind: "unplaced", request: owned(request) };
+            link.host.index(request.type, this);
+            return;
+        }
+        let served;
+        try {
+            const oversize = oversized(request.params, link.limits.part);
+            if (oversize !== undefined)
+                throw oversize;
+            const placed = link.host.place(request, link, this.caller, link.context);
+            if (placed.kind === "path") {
+                // Counted where it is served: a relayed hold is not this host's reference.
+                this.drop();
+                new RelayedHold(this.id, this.#provider, request, this.caller, placed.path).start();
+                return;
+            }
+            let params;
+            try {
+                params = parsePart(link.openPart(request.params, this.limits, link.context));
+            }
+            catch (error) {
+                // Past its limits: the hold's \`too_large/part\`. No JSON: a protocol error, reported, and the link closes.
+                if (isChordError(error, "too_large"))
+                    throw error;
+                link.host.report({ kind: "protocol_error", error });
+                link.close();
+                return;
+            }
+            served = link.host.serving(request, params, this.caller.principal, link.context);
+        }
+        catch (error) {
+            this.#refuse(request, { kind: "broken", error: asChordError(error, request.type) });
+            return;
+        }
+        if (served.kind === "waiting") {
+            this.#refuse(request, served.cause);
+            return;
+        }
+        this.#request = owned(request);
+        const { object } = served;
+        this.#object = object;
+        object.hold(this);
+        this.moved();
+    }
+    /**
+     * 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() {
+        const state = this.#state;
+        if (state.kind === "unplaced") {
+            this.#state = PENDING;
+            this.start(state.request);
+        }
+        else if (state.kind === "refused") {
+            this.#restart(state.request);
+        }
+    }
+    /**
+     * 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() {
+        const current = this.#state;
+        const object = this.#object;
+        if (object === undefined)
+            return;
+        if (current.kind === "bound" || current.kind === "binding") {
+            const { kind } = object.state;
+            if (kind === "live") {
+                if (current.kind === "bound" && object.instance !== current.instance)
+                    this.#rebind(current);
+                return;
+            }
+            // Its instance still changes (a swap's old one, a restart's drain, a live failure's admitted commits): it follows
+            // it on until it stopped (slice 7b, decision "References are the only indirection").
+            if (current.kind === "bound" && object.attachable === current.instance)
+                return;
+            if (current.kind === "binding" && kind === "loading" && object.swapsInPlace)
+                return;
+            this.#unbind(object.state.kind === "failed" ? object.state.cause.error : undefined);
+        }
+        this.#pending(object);
+    }
+    /** Member `followed` failed with `error`: its failure waits to be sent, replacing one still waiting. */
+    #memberFailed(followed, error) {
+        followed.pending.take();
+        const failure = { member: followed.index, error: wireError(error) };
+        const at = this.#failed.findIndex(({ member }) => member === followed.index);
+        // A new list when one is replaced (rare): a list handed to an entry is never written to.
+        if (at === -1)
+            this.#failed.push(failure);
+        else
+            this.#failed = this.#failed.map((pending, i) => (i === at ? failure : pending));
+    }
+    /** Member `index` has a value again: a failure of it still waiting to be sent (rare) is not sent. */
+    #memberHealed(index) {
+        if (this.#failed.length > 0)
+            this.#failed = this.#failed.filter(({ member }) => member !== index);
+    }
+    /**
+     * Its object left `live` (a restart, a parked swap, a live failure): no longer subscribed or waiting for a slot, its
+     * calls in flight rejected (`error`, or `unavailable`), pending again; a `loading` tells the consumer it rebinds
+     * (a failure is sent by `#pending`, which a consumer applies to a bound hold as a rebinding too, model §5).
+     */
+    #unbind(error) {
+        const state = this.#state;
+        if (state.kind === "bound")
+            unfollow(state);
+        this.#changes = [];
+        this.#failed = [];
+        this.#retired = NO_RETIRED;
+        this.#touched = false;
+        const reason = error ?? new ChordError({ code: "unavailable", message: `hold ${this.id}: its object rebinds` });
+        this.#provider.unbound(this, reason);
+        this.#state = PENDING;
+        if (error === undefined)
+            this.#provider.send({ kind: "loading", hold: this.id });
+    }
+    /**
+     * A swap of its object went live in place (slice 7b §5, audit A9): no longer subscribed to the old instance, it gets
+     * a fresh `bound` of the new one's members (as a restart, a variant or a version change does), answering calls by
+     * its old names until that is sent.
+     */
+    #rebind(state) {
+        unfollow(state);
+        // Its ops still waiting for a slot are the old instance's: the `bound` replaces them.
+        this.#provider.unbind(this);
+        this.#state = { kind: "binding", previous: { variant: state.variant, names: state.names } };
+        this.#provider.bind(this, this.#provider.link.context);
+    }
+    /**
+     * 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 }) {
+        const state = this.#state;
+        if (state.kind !== "refused") {
+            this.#object?.retry(retryWalk(hops - 1));
+            return;
+        }
+        if (state.cause.kind === "waiting")
+            this.#provider.link.host.unindex(state.request.type, this);
+        this.#restart(state.request);
+    }
+    /** The pending hold's part of `moved`: binds once live, sends each failure, announces the next attempt. */
+    #pending(object) {
+        const current = this.#state;
+        if (current.kind !== "pending")
+            return;
+        const state = object.state;
+        if (state.kind === "live") {
+            this.#state = BINDING;
+            this.#provider.bind(this, this.#provider.link.context);
+        }
+        else if (state.kind === "failed") {
+            // Each failure and each new cause (a parked object's blocker changed) is a message of its own.
+            const { cause, retryAt } = state;
+            const retryIn = retryAt === undefined ? {} : { retryIn: Math.max(0, retryAt - Date.now()) };
+            const failed = { kind: cause.kind, error: wireError(cause.error) };
+            this.#provider.send({ kind: "failed", hold: this.id, cause: failed, ...retryIn });
+            this.#state = { kind: "pending", toldFailed: true };
+        }
+        else if (state.kind === "loading" && current.toldFailed) {
+            this.#provider.send({ kind: "loading", hold: this.id });
+            this.#state = PENDING;
+        }
+    }
+    /** Starts a refused hold again, announced with `loading`. */
+    #restart(request) {
+        this.#state = PENDING;
+        this.#provider.send({ kind: "loading", hold: this.id });
+        this.start(request);
+    }
+    /** Calls a method of the held object as the hold's caller. */
+    call(method, args, context) {
+        return this.#object.call(method, args, context, this.caller, this.contract.version);
+    }
+    /**
+     * 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) {
+        const state = this.#state;
+        // Binding afresh after a swap: by the names the consumer still has (the new instance answers by name).
+        const bound = state.kind === "bound" ? state : state.kind === "binding" ? state.previous : undefined;
+        const name = bound?.names.methods[index];
+        if (name === undefined)
+            throw new Error(`hold ${this.id}: no method ${index}`);
+        return { name, resultBytes: bound.variant.methods.get(name).result.bytes };
+    }
+    /**
+     * 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) {
+        const object = this.#object;
+        const { contract } = object.served;
+        // A live remote object has its variant.
+        const variant = object.variant;
+        const state = this.#bindTo(object);
+        const members = [];
+        const failed = [];
+        const { version } = this.contract;
+        const current = version === contract.version;
+        for (const [index, member] of state.names.state.entries()) {
+            // An older version's members are its instance's mapping (its refusals unbound it before: `ChordObject`).
+            const source = current ? object.stateMembers.get(member) : object.liveMember(member, version);
+            let value;
+            try {
+                value = source.value;
+            }
+            catch (error) {
+                // A failed member (a derive whose compute throws) is followed: it recovers with a root replacement.
+                failed.push({ member: index, error: wireError(error) });
+                if (source instanceof Source)
+                    this.#follow(state, index, source);
+                continue;
+            }
+            try {
+                members.push({ member: index, value: this.#provider.link.part(jsonPart(value), context) });
+            }
+            catch (error) {
+                // A value past the link's limits: failed for this hold, which takes no more of it.
+                failed.push({ member: index, error: wireError(error) });
+                continue;
+            }
+            // A constant never changes: nothing to follow.
+            if (source instanceof Source)
+                this.#follow(state, index, source);
+        }
+        this.#changes = [];
+        this.#failed = [];
+        this.#retired = NO_RETIRED;
+        context.telemetry.metrics?.counter("chord.link.encodes").add(1);
+        return { hold: this.id, variant: variantOrder(contract).indexOf(variant), members, failed };
+    }
+    /**
+     * 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) {
+        const { link } = this.#provider;
+        const members = this.#take().map(([{ index, encoder }, ops]) => ({
+            member: index,
+            ops: link.part(jsonPart(encoder.encode(ops)), context),
+        }));
+        return this.#entry(members, context);
+    }
+    /** The window is full: this batch's ops join the members' pending queues (raw, never mutated). */
+    queue() {
+        for (const [{ pending }, ops] of this.#take())
+            pending.push(ops);
+    }
+    /**
+     * 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) {
+        const { link } = this.#provider;
+        const members = [];
+        // Only a bound hold has pending ops.
+        for (const { index, source, encoder, pending } of this.#state.followed) {
+            if (pending.size === 0)
+                continue;
+            const taken = pending.take();
+            const ops = taken.kind === "replace" ? [["r", source.value]] : taken.ops;
+            if (ops.length > 0)
+                members.push({ member: index, ops: link.part(jsonPart(encoder.encode(ops)), context) });
+        }
+        return this.#entry(members, context);
+    }
+    /** The consumer released the hold, or its link closed: its waits stop and its object loses this reference. */
+    release() {
+        this.drop();
+        this.#object?.unhold(this);
+        this.#object = undefined;
+    }
+    /** Ends the hold without releasing its object (the host closes and ends its objects itself). */
+    drop() {
+        const state = this.#state;
+        const { host } = this.#provider.link;
+        if (state.kind === "bound") {
+            unfollow(state);
+        }
+        else if (state.kind === "unplaced" || (state.kind === "refused" && state.cause.kind === "waiting")) {
+            host.unindex(state.request.type, this);
+        }
+        this.#state = { kind: "released" };
+        if (this.#counted)
+            host.count("references", -1);
+        this.#counted = false;
+    }
+    /**
+     * 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) {
+        if (this.#state.kind === "released")
+            return;
+        this.#provider.forget(this, error);
+        this.drop();
+        this.#object = undefined;
+        this.#provider.send({ kind: "gone", hold: this.id, error: wireError(error) });
+    }
+    /** The binding: its variant and names at the hold's version, with no member followed yet. */
+    #bindTo(object) {
+        const variant = variantsAt(object.served.contract, this.contract.version).get(object.variant);
+        const state = {
+            kind: "bound",
+            variant,
+            names: variantNames(variant),
+            followed: [],
+            instance: object.instance,
+        };
+        this.#state = state;
+        return state;
+    }
+    /** A hold over a link follows its object's instances in `moved` (a fresh `bound` for a new one). */
+    retarget() { }
+    /** It moves nothing in `retarget`. */
+    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) {
+        const state = this.#state;
+        if (state.kind === "released" || this.#object === undefined)
+            return;
+        if (state.kind === "bound")
+            unfollow(state);
+        this.#changes = [];
+        this.#failed = [];
+        this.#retired = NO_RETIRED;
+        this.#touched = false;
+        this.#provider.unbound(this, removal.cause.error);
+        this.#object = undefined;
+        this.#refuse(this.contract, removal.cause);
+    }
+    /**
+     * Follows member `index` from its snapshot on (a failed one too: it may recover in this hold): its own encoder and
+     * pending queue, and a subscription feeding its calls into this hold's batch. Failures fold per member: a failure
+     * drops what was pending for it and replaces a failure not sent yet (one at most per member, however long the
+     * consumer stalls); the value after it (a root replacement) replaces the failure. A retirement waits for a value.
+     */
+    #follow(state, index, source) {
+        const followed = {
+            index,
+            source,
+            subscriber: {
+                advance: (call) => {
+                    this.#touch();
+                    if (call.kind === "failed") {
+                        this.#memberFailed(followed, call.error);
+                        return;
+                    }
+                    this.#memberHealed(index);
+                    const { ops, retired } = call;
+                    // A retired derive's frame may carry no ops (rule 21): only the flag travels.
+                    if (ops.length > 0)
+                        this.#changes.push([followed, ops]);
+                    // A new list per retirement (rare): the shared empty one is never written to.
+                    if (retired && !this.#retired.includes(index))
+                        this.#retired = [...this.#retired, index];
+                },
+                // The member's source ended with its object, which ends this hold.
+                end: () => { },
+                endAfterDelivery: () => { },
+            },
+            encoder: encoder(),
+            pending: new PendingOps(),
+        };
+        // A constant never changes: nothing to subscribe to.
+        if (source instanceof Source)
+            source.subscribe(followed.subscriber);
+        state.followed.push(followed);
+    }
+    /** Takes the current batch's changes; the hold is untouched again. */
+    #take() {
+        const changes = this.#changes;
+        this.#changes = [];
+        this.#touched = false;
+        return changes;
+    }
+    /** A state entry with `members` and the failures and retirements since the last one; counts one encode. */
+    #entry(members, context) {
+        const failed = this.#failed;
+        let retired = this.#retired;
+        this.#failed = [];
+        this.#retired = NO_RETIRED;
+        if (retired.length > 0 && failed.length > 0) {
+            // A failed member's retirement travels with its next value, never with its failure.
+            const kept = retired.filter((index) => failed.some(({ member }) => member === index));
+            if (kept.length > 0) {
+                this.#retired = kept;
+                retired = retired.filter((index) => !kept.includes(index));
+            }
+        }
+        context.telemetry.metrics?.counter("chord.link.encodes").add(1);
+        return { hold: this.id, members, failed, retired };
+    }
+    #touch() {
+        if (this.#touched)
+            return;
+        this.#touched = true;
+        this.#provider.touched(this);
+    }
+    /**
+     * Refuses the hold with `cause`, holding nothing: it keeps `request`, indexed under its type while `waiting` (a
+     * publication starts it again), for a `retry` otherwise.
+     */
+    #refuse(request, cause) {
+        this.#state = { kind: "refused", request: owned(request), cause };
+        if (cause.kind === "waiting")
+            this.#provider.link.host.index(request.type, this);
+        this.#provider.send({
+            kind: "failed",
+            hold: this.id,
+            cause: { kind: cause.kind, error: wireError(cause.error) },
+        });
+    }
+}
+/** Stops following every member of a bound hold. */
+function unfollow(state) {
+    for (const { source, subscriber } of state.followed)
+        if (source instanceof Source)
+            source.unsubscribe(subscriber);
+}
+/** `request` with its params owned, not a view of the message they came in (which the link's buffers may hold). */
+function owned(request) {
+    const { params } = request;
+    return typeof params === "string" ? request : { ...request, params: params.slice() };
+}
+const NOBODY = {};
+/**
+ * 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 function actingFor(link, { principal, incarnation }) {
+    return link.role === "route" && principal !== undefined ? { principal, incarnation } : NOBODY;
+}
+//# sourceMappingURL=hold.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hold.js","sourceRoot":"","sources":["../../../src/next/remote/hold.ts"],"names":[],"mappings":"AAAA,iHAAiH;AACjH,iHAAiH;AACjH,uHAAuH;AACvH,iHAAiH;AACjH,sHAAsH;AACtH,+GAA+G;AAC/G,qHAAqH;AACrH,qHAAqH;AACrH,SAAS;AAGT,OAAO,EAAgB,OAAO,EAAW,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElF,OAAO,EAAuC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACvH,OAAO,EAAE,UAAU,EAAqB,YAAY,EAAkB,MAAM,kBAAkB,CAAC;AAC/F,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAKN,SAAS,GAGT,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGN,QAAQ,EAGR,UAAU,EACV,SAAS,EACT,SAAS,EAET,SAAS,GACT,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAqB,MAAM,EAAmB,MAAM,sBAAsB,CAAC;AAGlF,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA8DzC,MAAM,OAAO,GAAc,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;AAElE,MAAM,OAAO,GAAc,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;AAE/C;;;;;;;;GAQG;AACH,MAAM,OAAO,IAAI;IACP,IAAI,GAAG,QAAQ,CAAC;IAChB,EAAE,CAAS;IACpB,oDAAoD;IAC3C,SAAS,GAAG,SAAS,CAAC;IAC/B,kFAAkF;IACzE,MAAM,CAAS;IACxB,yHAAyH;IAChH,MAAM,CAAS;IACf,SAAS,CAAe;IACjC,MAAM,GAAc,OAAO,CAAC;IAC5B,+GAA+G;IAC/G,QAAQ,CAA0B;IAClC,oEAAoE;IACpE,OAAO,CAA0B;IACjC,uEAAuE;IACvE,QAAQ,GAA2C,EAAE,CAAC;IACtD,6EAA6E;IAC7E,OAAO,GAAmB,EAAE,CAAC;IAC7B,kHAAkH;IAClH,QAAQ,GAAsB,UAAU,CAAC;IACzC,QAAQ,GAAG,KAAK,CAAC;IACjB,iHAAiH;IACjH,QAAQ,GAAG,IAAI,CAAC;IAEhB,YAAY,EAAU,EAAE,QAAsB,EAAE,MAAc,EAAE,MAAc;QAC7E,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED,gEAAgE;IAChE,IAAI,KAAK;QACR,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC;IACrC,CAAC;IAED,uHAAuH;IACvH,IAAI,QAAQ;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,OAAO,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC;IAC7F,CAAC;IAED,yDAAyD;IACzD,IAAI,SAAS;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;IAC9B,CAAC;IAED,4GAA4G;IAC5G,IAAI,QAAQ;QACX,OAAO,IAAI,CAAC,QAAS,CAAC;IACvB,CAAC;IAED,qGAAqG;IACrG,IAAI,OAAO;QACV,OAAO,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,UAAU,CAAC;IACtE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAoB;QACzB,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5D,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACpC,OAAO;QACR,CAAC;QACD,IAAI,MAAe,CAAC;QACpB,IAAI,CAAC;YACJ,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC7D,IAAI,QAAQ,KAAK,SAAS;gBAAE,MAAM,QAAQ,CAAC;YAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACzE,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBAC5B,2EAA2E;gBAC3E,IAAI,CAAC,IAAI,EAAE,CAAC;gBACZ,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;gBACpF,OAAO;YACR,CAAC;YACD,IAAI,MAAe,CAAC;YACpB,IAAI,CAAC;gBACJ,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAC9E,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,4GAA4G;gBAC5G,IAAI,YAAY,CAAC,KAAK,EAAE,WAAW,CAAC;oBAAE,MAAM,KAAK,CAAC;gBAClD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,CAAC;gBACpD,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,OAAO;YACR,CAAC;YACD,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,SAAU,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACnF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACpF,OAAO;QACR,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACpC,OAAO;QACR,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;QAC/B,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClB,IAAI,CAAC,KAAK,EAAE,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,IAAI;QACH,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YACtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;IACF,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACJ,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO;QACjC,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5D,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC;YAC9B,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBACrB,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ;oBAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;gBAC5F,OAAO;YACR,CAAC;YACD,kHAAkH;YAClH,qFAAqF;YACrF,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC,QAAQ;gBAAE,OAAO;YAC/E,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,YAAY;gBAAE,OAAO;YACpF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACrF,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACvB,CAAC;IAED,wGAAwG;IACxG,aAAa,CAAC,QAAkB,EAAE,KAAc;QAC/C,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACxB,MAAM,OAAO,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACpE,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC7E,yFAAyF;QACzF,IAAI,EAAE,KAAK,CAAC,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;;YACrC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IACtF,CAAC;IAED,qGAAqG;IACrG,aAAa,CAAC,KAAa;QAC1B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;IACnG,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,KAA6B;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;YAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,MAAM,MAAM,GAAG,KAAK,IAAI,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,QAAQ,IAAI,CAAC,EAAE,sBAAsB,EAAE,CAAC,CAAC;QAChH,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;QACtB,IAAI,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAClF,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAY;QACnB,QAAQ,CAAC,KAAK,CAAC,CAAC;QAChB,sFAAsF;QACtF,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QAC5F,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,EAAE,IAAI,EAAgD;QAC3D,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;YACzC,OAAO;QACR,CAAC;QACD,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/F,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED,2GAA2G;IAC3G,QAAQ,CAAC,MAAmB;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC;QAC5B,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO;QACvC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YACtB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACxD,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACpC,+FAA+F;YAC/F,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;YACjC,MAAM,OAAO,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC;YAC5F,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACnE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;YAClF,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;QACrD,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YAC3D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;YACxD,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;QACvB,CAAC;IACF,CAAC;IAED,6DAA6D;IAC7D,QAAQ,CAAC,OAAoB;QAC5B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrB,CAAC;IAED,8DAA8D;IAC9D,IAAI,CAAC,MAAc,EAAE,IAAa,EAAE,OAAgB;QACnD,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACtF,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAa;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,uGAAuG;QACvG,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;QACrG,MAAM,IAAI,GAAG,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,IAAI,KAAK,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,EAAE,eAAe,KAAK,EAAE,CAAC,CAAC;QAC/E,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,KAAM,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC9E,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,OAAgB;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAQ,CAAC;QAC7B,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC;QACnC,wCAAwC;QACxC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAQ,CAAC;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACnC,MAAM,OAAO,GAAoC,EAAE,CAAC;QACpD,MAAM,MAAM,GAAmB,EAAE,CAAC;QAClC,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QAClC,MAAM,OAAO,GAAG,OAAO,KAAK,QAAQ,CAAC,OAAO,CAAC;QAC7C,KAAK,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;YAC3D,yGAAyG;YACzG,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAE,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC/F,IAAI,KAAgB,CAAC;YACrB,IAAI,CAAC;gBACJ,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YACtB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,oGAAoG;gBACpG,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACxD,IAAI,MAAM,YAAY,MAAM;oBAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;gBACjE,SAAS;YACV,CAAC;YACD,IAAI,CAAC;gBACJ,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;YAC5F,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,mFAAmF;gBACnF,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACxD,SAAS;YACV,CAAC;YACD,+CAA+C;YAC/C,IAAI,MAAM,YAAY,MAAM;gBAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAChE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAC7F,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAgB;QACrB,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;YAChE,MAAM,EAAE,KAAK;YACb,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC;SACtD,CAAC,CAAC,CAAC;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACtC,CAAC;IAED,kGAAkG;IAClG,KAAK;QACJ,KAAK,MAAM,CAAC,EAAE,OAAO,EAAE,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE;YAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClE,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,OAAgB;QAC5B,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,MAAM,OAAO,GAAoC,EAAE,CAAC;QACpD,qCAAqC;QACrC,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAK,IAAI,CAAC,MAAgB,CAAC,QAAQ,EAAE,CAAC;YACnF,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC;gBAAE,SAAS;YACjC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;YAC7B,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;YAClF,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;gBAAE,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAC7G,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACtC,CAAC;IAED,8GAA8G;IAC9G,OAAO;QACN,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;IAC1B,CAAC;IAED,gGAAgG;IAChG,IAAI;QACH,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;QACrC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC5B,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjB,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,EAAE,CAAC;YACtG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;QACnC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,KAAiB;QACpB,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,UAAU;YAAE,OAAO;QAC5C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC/E,CAAC;IAED,6FAA6F;IAC7F,OAAO,CAAC,MAAmB;QAC1B,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,OAAQ,CAAE,CAAC;QAChG,MAAM,KAAK,GAAU;YACpB,IAAI,EAAE,OAAO;YACb,OAAO;YACP,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC;YAC5B,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,MAAM,CAAC,QAAQ;SACzB,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,KAAK,CAAC;IACd,CAAC;IAED,oGAAoG;IACpG,QAAQ,KAAU,CAAC;IAEnB,sCAAsC;IAC7B,SAAS,GAAG,KAAK,CAAC;IAE3B;;;;OAIG;IACH,OAAO,CAAC,OAAgB;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;YAAE,OAAO;QACpE,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;YAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClD,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,KAAY,EAAE,KAAa,EAAE,MAAoB;QACxD,MAAM,QAAQ,GAAa;YAC1B,KAAK;YACL,MAAM;YACN,UAAU,EAAE;gBACX,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;oBACjB,IAAI,CAAC,MAAM,EAAE,CAAC;oBACd,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;wBAC5B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;wBACzC,OAAO;oBACR,CAAC;oBACD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;oBAC1B,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;oBAC9B,8EAA8E;oBAC9E,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;wBAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;oBACxD,8EAA8E;oBAC9E,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;wBAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBAC1F,CAAC;gBACD,mEAAmE;gBACnE,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC;gBACb,gBAAgB,EAAE,GAAG,EAAE,GAAE,CAAC;aAC1B;YACD,OAAO,EAAE,OAAO,EAAE;YAClB,OAAO,EAAE,IAAI,UAAU,EAAE;SACzB,CAAC;QACF,qDAAqD;QACrD,IAAI,MAAM,YAAY,MAAM;YAAE,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QACpE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAED,sEAAsE;IACtE,KAAK;QACJ,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,OAAO,OAAO,CAAC;IAChB,CAAC;IAED,2GAA2G;IAC3G,MAAM,CAAC,OAA8B,EAAE,OAAgB;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7C,oFAAoF;YACpF,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC;YACtF,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACrB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5D,CAAC;QACF,CAAC;QACD,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAChE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IACpD,CAAC;IAED,MAAM;QACL,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,OAAoB,EAAE,KAAmB;QAChD,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC;QAClE,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACjF,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;YACnB,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,IAAI,CAAC,EAAE;YACb,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;SAC1D,CAAC,CAAC;IACJ,CAAC;CACD;AAED,oDAAoD;AACpD,SAAS,QAAQ,CAAC,KAAY;IAC7B,KAAK,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,KAAK,CAAC,QAAQ;QAAE,IAAI,MAAM,YAAY,MAAM;YAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;AACnH,CAAC;AAED,mHAAmH;AACnH,SAAS,KAAK,CAAC,OAAoB;IAClC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC3B,OAAO,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAG,MAAqB,CAAC,KAAK,EAAE,EAAE,CAAC;AACtG,CAAC;AAKD,MAAM,MAAM,GAAc,EAAE,CAAC;AAE7B;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,IAAc,EAAE,EAAE,SAAS,EAAE,WAAW,EAAU;IAC3E,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;AAC/F,CAAC","sourcesContent":["// A hold arriving on a link and served here (§7, §22, W1): where it goes once the host published (waiting in the\n// unbound index until then), why it is unbound (refused: kept in the index while it waits for a name, dependency\n// model §1), the object it keeps, the notices of its object's failures and new attempts, the snapshot and subscription\n// taken in one synchronous step when a slot of the window is free, and the ops of its members per batch (sent at\n// once, or pending while the window is full), each member with its own Delta encoder. Across a reload (slice 7b §6) a\n// bound hold is kept: a swap in place sends it a fresh `bound` once the new instance is live (it answers calls\n// meanwhile), an object leaving `live` unbinds it (`loading` or `failed`, then a fresh `bound`), a version no longer\n// bound or a removed type leaves it waiting unbound. A hold of an older version follows its object's adapted members\n// (Q10).\n\nimport type { Context } from \"../../context/index.ts\";\nimport { type Encoder, encoder, type Op, PendingOps } from \"../../delta/index.ts\";\nimport type { JsonValue } from \"../../json.ts\";\nimport { type VariantData, type VariantNames, variantNames, variantOrder, variantsAt } from \"../contracts/internal.ts\";\nimport { ChordError, type FailureCause, isChordError, type Principal } from \"../data/index.ts\";\nimport { asChordError } from \"../data/internal.ts\";\nimport {\n\ttype Caller,\n\ttype ChordObject,\n\ttype Holder,\n\ttype Removal,\n\tretryWalk,\n\ttype Serving,\n\ttype UnboundRequest,\n} from \"../host/internal.ts\";\nimport {\n\ttype BoundEntry,\n\ttype FailedMember,\n\tjsonPart,\n\ttype Limits,\n\ttype Message,\n\tNO_RETIRED,\n\toversized,\n\tparsePart,\n\ttype StateEntry,\n\twireError,\n} from \"../link/internal.ts\";\nimport { type DeriveSource, Source, type Subscriber } from \"../state/internal.ts\";\nimport type { HostLink } from \"./host-link.ts\";\nimport type { ProviderSide } from \"./provider.ts\";\nimport { RelayedHold } from \"./relay.ts\";\n\n/** A `hold` message. */\ntype HoldMessage = Extract<Message, { readonly kind: \"hold\" }>;\n\n/**\n * 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\n * link allows (`ProviderSide`), and names it again only on a route link (`actingFor`). Its `chain` and `limit` are the\n * ones this host honours, sent on as they are when it relays the hold.\n */\nexport type HoldRequest = Omit<HoldMessage, \"kind\" | \"origin\" | \"hold\" | \"principal\" | \"incarnation\">;\n\n/**\n * A state member a bound hold follows: its index in the bound version, its source and subscription (which feeds this\n * record), its own encoder (R1, path interning) and the ops waiting for a slot of the window.\n */\ntype Followed = {\n\treadonly index: number;\n\t/** Its source (subscribed when it changes, a constant's never). */\n\treadonly source: DeriveSource;\n\treadonly subscriber: Subscriber;\n\treadonly encoder: Encoder;\n\treadonly pending: PendingOps;\n};\n\n/**\n * Where a hold stands: `unplaced` in the unbound index until the host's publication places it; `pending` until its\n * object is live (the activation, parking and retries; `toldFailed` once the consumer was told of a failure, so the\n * next attempt is announced with `loading`); `binding` while its object is live and its `bound` waits for a slot\n * (after a swap in place with the names it was bound with, `previous`: the consumer still holds it bound, so its calls\n * are answered by those names, design §22; only contract data, so the old instance and its sources go meanwhile);\n * `bound` with the object's variant and the members it follows.\n */\ntype HoldState =\n\t| { readonly kind: \"unplaced\"; readonly request: HoldRequest }\n\t| { readonly kind: \"pending\"; readonly toldFailed: boolean }\n\t| { readonly kind: \"binding\"; readonly previous?: BoundNames }\n\t| {\n\t\t\treadonly kind: \"bound\";\n\t\t\t/** The bound variant's data at the hold's version. */\n\t\t\treadonly variant: VariantData;\n\t\t\t/** The bound version's names of the variant, which the wire's indexes point into. */\n\t\t\treadonly names: VariantNames;\n\t\t\t/** The members it follows, in the order they were subscribed. */\n\t\t\treadonly followed: Followed[];\n\t\t\t/** The instance it was bound to: a swap brings another, which it binds to afresh. */\n\t\t\treadonly instance: unknown;\n\t  }\n\t/**\n\t * Refused where it arrived, with `cause`: `waiting` (not served here, another version, placed elsewhere by the\n\t * provider's code) in the unbound index until a publication wakes it; `broken` (invalid params, a cycle, a route that\n\t * refused, a part past the limits) until a `retry` restarts it.\n\t */\n\t| { readonly kind: \"refused\"; readonly request: HoldRequest; readonly cause: FailureCause }\n\t| { readonly kind: \"released\" };\n\n/** A bound hold's state. */\ntype Bound = Extract<HoldState, { readonly kind: \"bound\" }>;\n\n/** What calls need of a binding: its variant's data at the hold's version and the names the wire's indexes point into. */\ntype BoundNames = { readonly variant: VariantData; readonly names: VariantNames };\n\nconst PENDING: HoldState = { kind: \"pending\", toldFailed: false };\n\nconst BINDING: HoldState = { kind: \"binding\" };\n\n/**\n * One hold served here: a reference to its object acting as its caller (the hold's principal). While pending, each\n * failure of its object is sent as `failed` (with the rest of its backoff window) and the next attempt as `loading`; a\n * hold that cannot be taken holds nothing: `failed { waiting }` (not served, another version) until a publication\n * re-runs its start, `failed { broken }` (invalid params, a cycle) until a `retry` does. Once live it binds when its\n * link's window has a slot, then sends a part per batch that changed its members (or keeps their ops pending while the\n * window is full), and `gone` when its object ends. It counts as one of the host's references from its arrival to its\n * end, bound or not.\n */\nexport class Hold implements Holder, UnboundRequest {\n\treadonly kind = \"served\";\n\treadonly id: number;\n\t/** A hold is declared by no object on this host. */\n\treadonly dependent = undefined;\n\t/** Whom the hold acts for: its calls run as it, with its origin's incarnation. */\n\treadonly caller: Caller;\n\t/** The limits per part of its params and its calls' arguments: its link's, the decoded one smaller when stamped (Q2). */\n\treadonly limits: Limits;\n\treadonly #provider: ProviderSide;\n\t#state: HoldState = PENDING;\n\t/** What it asks for (its params owned), once it started: it is placed again after a reload left it unbound. */\n\t#request: HoldRequest | undefined;\n\t/** The held object, from its binding until the hold is released. */\n\t#object: ChordObject | undefined;\n\t/** The members the current batch changed, with their ops, in order. */\n\t#changes: (readonly [Followed, readonly Op[]])[] = [];\n\t/** The members that failed since the last message that carried this hold. */\n\t#failed: FailedMember[] = [];\n\t/** The members whose document was retired since the last message that carried this hold (ORed while it waits). */\n\t#retired: readonly number[] = NO_RETIRED;\n\t#touched = false;\n\t/** Whether the hold counts as one of the host's references (`host.activity`): from its arrival until it ends. */\n\t#counted = true;\n\n\tconstructor(id: number, provider: ProviderSide, caller: Caller, limits: Limits) {\n\t\tthis.id = id;\n\t\tthis.#provider = provider;\n\t\tthis.caller = caller;\n\t\tthis.limits = limits;\n\t\tprovider.link.host.count(\"references\", 1);\n\t}\n\n\t/** Whether the hold is bound: its members' changes are sent. */\n\tget bound(): boolean {\n\t\treturn this.#state.kind === \"bound\";\n\t}\n\n\t/** Whether calls on it reach its object: bound, or binding afresh after a swap in place (its `bound` not sent yet). */\n\tget callable(): boolean {\n\t\tconst state = this.#state;\n\t\treturn state.kind === \"bound\" || (state.kind === \"binding\" && state.previous !== undefined);\n\t}\n\n\t/** Whom it acts for (the unbound index's revocation). */\n\tget principal(): Principal | undefined {\n\t\treturn this.caller.principal;\n\t}\n\n\t/** Its consumer's contract version and fingerprint (its request's): the provider binds them or it waits. */\n\tget contract(): HoldRequest {\n\t\treturn this.#request!;\n\t}\n\n\t/** Whether the hold holds no object: before the publication, or refused (revocation ends it, §4). */\n\tget unbound(): boolean {\n\t\treturn this.#object === undefined && this.#state.kind !== \"released\";\n\t}\n\n\t/**\n\t * Admits the hold: before the host's publication it waits in the unbound index, placed by the publication.\n\t * Then its params within the link's part limit (`too_large/part`), then relayed (it is replaced by a relayed hold),\n\t * or served here, its params opened and parsed (a malformed part is a protocol error), its object taken and followed\n\t * (`moved`) in the turn it arrived. A hold that cannot be served here waits refused (`#refuse`).\n\t */\n\tstart(request: HoldRequest): void {\n\t\tconst { link } = this.#provider;\n\t\tif (!link.host.published) {\n\t\t\tthis.#state = { kind: \"unplaced\", request: owned(request) };\n\t\t\tlink.host.index(request.type, this);\n\t\t\treturn;\n\t\t}\n\t\tlet served: Serving;\n\t\ttry {\n\t\t\tconst oversize = oversized(request.params, link.limits.part);\n\t\t\tif (oversize !== undefined) throw oversize;\n\t\t\tconst placed = link.host.place(request, link, this.caller, link.context);\n\t\t\tif (placed.kind === \"path\") {\n\t\t\t\t// Counted where it is served: a relayed hold is not this host's reference.\n\t\t\t\tthis.drop();\n\t\t\t\tnew RelayedHold(this.id, this.#provider, request, this.caller, placed.path).start();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tlet params: unknown;\n\t\t\ttry {\n\t\t\t\tparams = parsePart(link.openPart(request.params, this.limits, link.context));\n\t\t\t} catch (error) {\n\t\t\t\t// Past its limits: the hold's \\`too_large/part\\`. No JSON: a protocol error, reported, and the link closes.\n\t\t\t\tif (isChordError(error, \"too_large\")) throw error;\n\t\t\t\tlink.host.report({ kind: \"protocol_error\", error });\n\t\t\t\tlink.close();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tserved = link.host.serving(request, params, this.caller.principal!, link.context);\n\t\t} catch (error) {\n\t\t\tthis.#refuse(request, { kind: \"broken\", error: asChordError(error, request.type) });\n\t\t\treturn;\n\t\t}\n\t\tif (served.kind === \"waiting\") {\n\t\t\tthis.#refuse(request, served.cause);\n\t\t\treturn;\n\t\t}\n\t\tthis.#request = owned(request);\n\t\tconst { object } = served;\n\t\tthis.#object = object;\n\t\tobject.hold(this);\n\t\tthis.moved();\n\t}\n\n\t/**\n\t * Woken by the unbound index (out of it already): before the publication, placed now; refused `waiting`, its start\n\t * runs again, announced with `loading` (then `bound` or `failed`).\n\t */\n\twake(): void {\n\t\tconst state = this.#state;\n\t\tif (state.kind === \"unplaced\") {\n\t\t\tthis.#state = PENDING;\n\t\t\tthis.start(state.request);\n\t\t} else if (state.kind === \"refused\") {\n\t\t\tthis.#restart(state.request);\n\t\t}\n\t}\n\n\t/**\n\t * The object's state changed, or the hold took it: a pending hold binds once it is live (when a slot is free),\n\t * sends each failure, and announces the attempt after a failure with `loading`. A bound hold (or one whose `bound`\n\t * waits for a slot) whose object leaves `live` goes back to pending (slice 7b §6), except while a reload's swap runs\n\t * in place; a bound one whose object went live with another attempt (a swap) gets a fresh `bound` (audit A9).\n\t */\n\tmoved(): void {\n\t\tconst current = this.#state;\n\t\tconst object = this.#object;\n\t\tif (object === undefined) return;\n\t\tif (current.kind === \"bound\" || current.kind === \"binding\") {\n\t\t\tconst { kind } = object.state;\n\t\t\tif (kind === \"live\") {\n\t\t\t\tif (current.kind === \"bound\" && object.instance !== current.instance) this.#rebind(current);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// Its instance still changes (a swap's old one, a restart's drain, a live failure's admitted commits): it follows\n\t\t\t// it on until it stopped (slice 7b, decision \"References are the only indirection\").\n\t\t\tif (current.kind === \"bound\" && object.attachable === current.instance) return;\n\t\t\tif (current.kind === \"binding\" && kind === \"loading\" && object.swapsInPlace) return;\n\t\t\tthis.#unbind(object.state.kind === \"failed\" ? object.state.cause.error : undefined);\n\t\t}\n\t\tthis.#pending(object);\n\t}\n\n\t/** Member `followed` failed with `error`: its failure waits to be sent, replacing one still waiting. */\n\t#memberFailed(followed: Followed, error: unknown): void {\n\t\tfollowed.pending.take();\n\t\tconst failure = { member: followed.index, error: wireError(error) };\n\t\tconst at = this.#failed.findIndex(({ member }) => member === followed.index);\n\t\t// A new list when one is replaced (rare): a list handed to an entry is never written to.\n\t\tif (at === -1) this.#failed.push(failure);\n\t\telse this.#failed = this.#failed.map((pending, i) => (i === at ? failure : pending));\n\t}\n\n\t/** Member `index` has a value again: a failure of it still waiting to be sent (rare) is not sent. */\n\t#memberHealed(index: number): void {\n\t\tif (this.#failed.length > 0) this.#failed = this.#failed.filter(({ member }) => member !== index);\n\t}\n\n\t/**\n\t * Its object left `live` (a restart, a parked swap, a live failure): no longer subscribed or waiting for a slot, its\n\t * calls in flight rejected (`error`, or `unavailable`), pending again; a `loading` tells the consumer it rebinds\n\t * (a failure is sent by `#pending`, which a consumer applies to a bound hold as a rebinding too, model §5).\n\t */\n\t#unbind(error: ChordError | undefined): void {\n\t\tconst state = this.#state;\n\t\tif (state.kind === \"bound\") unfollow(state);\n\t\tthis.#changes = [];\n\t\tthis.#failed = [];\n\t\tthis.#retired = NO_RETIRED;\n\t\tthis.#touched = false;\n\t\tconst reason = error ?? new ChordError({ code: \"unavailable\", message: `hold ${this.id}: its object rebinds` });\n\t\tthis.#provider.unbound(this, reason);\n\t\tthis.#state = PENDING;\n\t\tif (error === undefined) this.#provider.send({ kind: \"loading\", hold: this.id });\n\t}\n\n\t/**\n\t * A swap of its object went live in place (slice 7b §5, audit A9): no longer subscribed to the old instance, it gets\n\t * a fresh `bound` of the new one's members (as a restart, a variant or a version change does), answering calls by\n\t * its old names until that is sent.\n\t */\n\t#rebind(state: Bound): void {\n\t\tunfollow(state);\n\t\t// Its ops still waiting for a slot are the old instance's: the `bound` replaces them.\n\t\tthis.#provider.unbind(this);\n\t\tthis.#state = { kind: \"binding\", previous: { variant: state.variant, names: state.names } };\n\t\tthis.#provider.bind(this, this.#provider.link.context);\n\t}\n\n\t/**\n\t * A `retry` message with `hops` left of its budget: the object is asked for an attempt now (it ignores this unless\n\t * failed; parked, it passes it on, to other hosts with one hop less); a refused hold is started again (a route's\n\t * `authorize` may admit it now).\n\t */\n\tretry({ hops }: Extract<Message, { readonly kind: \"retry\" }>): void {\n\t\tconst state = this.#state;\n\t\tif (state.kind !== \"refused\") {\n\t\t\tthis.#object?.retry(retryWalk(hops - 1));\n\t\t\treturn;\n\t\t}\n\t\tif (state.cause.kind === \"waiting\") this.#provider.link.host.unindex(state.request.type, this);\n\t\tthis.#restart(state.request);\n\t}\n\n\t/** The pending hold's part of `moved`: binds once live, sends each failure, announces the next attempt. */\n\t#pending(object: ChordObject): void {\n\t\tconst current = this.#state;\n\t\tif (current.kind !== \"pending\") return;\n\t\tconst state = object.state;\n\t\tif (state.kind === \"live\") {\n\t\t\tthis.#state = BINDING;\n\t\t\tthis.#provider.bind(this, this.#provider.link.context);\n\t\t} else if (state.kind === \"failed\") {\n\t\t\t// Each failure and each new cause (a parked object's blocker changed) is a message of its own.\n\t\t\tconst { cause, retryAt } = state;\n\t\t\tconst retryIn = retryAt === undefined ? {} : { retryIn: Math.max(0, retryAt - Date.now()) };\n\t\t\tconst failed = { kind: cause.kind, error: wireError(cause.error) };\n\t\t\tthis.#provider.send({ kind: \"failed\", hold: this.id, cause: failed, ...retryIn });\n\t\t\tthis.#state = { kind: \"pending\", toldFailed: true };\n\t\t} else if (state.kind === \"loading\" && current.toldFailed) {\n\t\t\tthis.#provider.send({ kind: \"loading\", hold: this.id });\n\t\t\tthis.#state = PENDING;\n\t\t}\n\t}\n\n\t/** Starts a refused hold again, announced with `loading`. */\n\t#restart(request: HoldRequest): void {\n\t\tthis.#state = PENDING;\n\t\tthis.#provider.send({ kind: \"loading\", hold: this.id });\n\t\tthis.start(request);\n\t}\n\n\t/** Calls a method of the held object as the hold's caller. */\n\tcall(method: string, args: unknown, context: Context): Promise<unknown> {\n\t\treturn this.#object!.call(method, args, context, this.caller, this.contract.version);\n\t}\n\n\t/**\n\t * The method at `index` of the bound variant and whether its result carries byte segments (its schema has a\n\t * `bytes()` leaf). Throws on an index outside the variant (a protocol error); a hold that is not bound has none.\n\t */\n\tmethod(index: number): { readonly name: string; readonly resultBytes: boolean } {\n\t\tconst state = this.#state;\n\t\t// Binding afresh after a swap: by the names the consumer still has (the new instance answers by name).\n\t\tconst bound = state.kind === \"bound\" ? state : state.kind === \"binding\" ? state.previous : undefined;\n\t\tconst name = bound?.names.methods[index];\n\t\tif (name === undefined) throw new Error(`hold ${this.id}: no method ${index}`);\n\t\treturn { name, resultBytes: bound!.variant.methods.get(name)!.result.bytes };\n\t}\n\n\t/**\n\t * The hold's binding, sent when a slot is free. The snapshot of every member, as a value or failed, and the\n\t * subscription are taken in this synchronous step (race 2), so each member's next ops continue exactly from it.\n\t * Names travel as indexes into the bound version (2b). Counts one encode (`chord.link.encodes`).\n\t */\n\tboundEntry(context: Context): BoundEntry {\n\t\tconst object = this.#object!;\n\t\tconst { contract } = object.served;\n\t\t// A live remote object has its variant.\n\t\tconst variant = object.variant!;\n\t\tconst state = this.#bindTo(object);\n\t\tconst members: BoundEntry[\"members\"][number][] = [];\n\t\tconst failed: FailedMember[] = [];\n\t\tconst { version } = this.contract;\n\t\tconst current = version === contract.version;\n\t\tfor (const [index, member] of state.names.state.entries()) {\n\t\t\t// An older version's members are its instance's mapping (its refusals unbound it before: `ChordObject`).\n\t\t\tconst source = current ? object.stateMembers.get(member)! : object.liveMember(member, version);\n\t\t\tlet value: JsonValue;\n\t\t\ttry {\n\t\t\t\tvalue = source.value;\n\t\t\t} catch (error) {\n\t\t\t\t// A failed member (a derive whose compute throws) is followed: it recovers with a root replacement.\n\t\t\t\tfailed.push({ member: index, error: wireError(error) });\n\t\t\t\tif (source instanceof Source) this.#follow(state, index, source);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tmembers.push({ member: index, value: this.#provider.link.part(jsonPart(value), context) });\n\t\t\t} catch (error) {\n\t\t\t\t// A value past the link's limits: failed for this hold, which takes no more of it.\n\t\t\t\tfailed.push({ member: index, error: wireError(error) });\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// A constant never changes: nothing to follow.\n\t\t\tif (source instanceof Source) this.#follow(state, index, source);\n\t\t}\n\t\tthis.#changes = [];\n\t\tthis.#failed = [];\n\t\tthis.#retired = NO_RETIRED;\n\t\tcontext.telemetry.metrics?.counter(\"chord.link.encodes\").add(1);\n\t\treturn { hold: this.id, variant: variantOrder(contract).indexOf(variant), members, failed };\n\t}\n\n\t/**\n\t * This batch's entry of the `state` message: the members it changed with their ops, each encoded once with its\n\t * member's encoder, and the members that failed; resets both. Counts one encode per hold (`chord.link.encodes`).\n\t */\n\tentry(context: Context): StateEntry {\n\t\tconst { link } = this.#provider;\n\t\tconst members = this.#take().map(([{ index, encoder }, ops]) => ({\n\t\t\tmember: index,\n\t\t\tops: link.part(jsonPart(encoder.encode(ops)), context),\n\t\t}));\n\t\treturn this.#entry(members, context);\n\t}\n\n\t/** The window is full: this batch's ops join the members' pending queues (raw, never mutated). */\n\tqueue(): void {\n\t\tfor (const [{ pending }, ops] of this.#take()) pending.push(ops);\n\t}\n\n\t/**\n\t * The entry of a freed slot's `state` message: each member's pending ops encoded once, or `[[\"r\", value]]` after an\n\t * overflow, all reflecting the latest commit; and the members that failed meanwhile. Counts one encode per hold.\n\t */\n\tpendingEntry(context: Context): StateEntry {\n\t\tconst { link } = this.#provider;\n\t\tconst members: StateEntry[\"members\"][number][] = [];\n\t\t// Only a bound hold has pending ops.\n\t\tfor (const { index, source, encoder, pending } of (this.#state as Bound).followed) {\n\t\t\tif (pending.size === 0) continue;\n\t\t\tconst taken = pending.take();\n\t\t\tconst ops = taken.kind === \"replace\" ? [[\"r\", source.value] as const] : taken.ops;\n\t\t\tif (ops.length > 0) members.push({ member: index, ops: link.part(jsonPart(encoder.encode(ops)), context) });\n\t\t}\n\t\treturn this.#entry(members, context);\n\t}\n\n\t/** The consumer released the hold, or its link closed: its waits stop and its object loses this reference. */\n\trelease(): void {\n\t\tthis.drop();\n\t\tthis.#object?.unhold(this);\n\t\tthis.#object = undefined;\n\t}\n\n\t/** Ends the hold without releasing its object (the host closes and ends its objects itself). */\n\tdrop(): void {\n\t\tconst state = this.#state;\n\t\tconst { host } = this.#provider.link;\n\t\tif (state.kind === \"bound\") {\n\t\t\tunfollow(state);\n\t\t} else if (state.kind === \"unplaced\" || (state.kind === \"refused\" && state.cause.kind === \"waiting\")) {\n\t\t\thost.unindex(state.request.type, this);\n\t\t}\n\t\tthis.#state = { kind: \"released\" };\n\t\tif (this.#counted) host.count(\"references\", -1);\n\t\tthis.#counted = false;\n\t}\n\n\t/**\n\t * The object ended while held (revocation; a reload, slice 7b), or the hold was revoked (or its host closed) while it\n\t * held no object: the hold sends `gone` with `error`.\n\t */\n\tend(error: ChordError): void {\n\t\tif (this.#state.kind === \"released\") return;\n\t\tthis.#provider.forget(this, error);\n\t\tthis.drop();\n\t\tthis.#object = undefined;\n\t\tthis.#provider.send({ kind: \"gone\", hold: this.id, error: wireError(error) });\n\t}\n\n\t/** The binding: its variant and names at the hold's version, with no member followed yet. */\n\t#bindTo(object: ChordObject): Bound {\n\t\tconst variant = variantsAt(object.served.contract, this.contract.version).get(object.variant!)!;\n\t\tconst state: Bound = {\n\t\t\tkind: \"bound\",\n\t\t\tvariant,\n\t\t\tnames: variantNames(variant),\n\t\t\tfollowed: [],\n\t\t\tinstance: object.instance,\n\t\t};\n\t\tthis.#state = state;\n\t\treturn state;\n\t}\n\n\t/** A hold over a link follows its object's instances in `moved` (a fresh `bound` for a new one). */\n\tretarget(): void {}\n\n\t/** It moves nothing in `retarget`. */\n\treadonly following = false;\n\n\t/**\n\t * Its object left it (slice 7b §6): its type was removed (`not_served`) or its provider no longer binds the hold's\n\t * version (`version`): no longer subscribed, its calls in flight rejected, it waits refused with `removal.cause` in\n\t * the host's index (a publication starts it again) and the consumer is sent `failed`, which unbinds a bound hold.\n\t */\n\tremoved(removal: Removal): void {\n\t\tconst state = this.#state;\n\t\tif (state.kind === \"released\" || this.#object === undefined) return;\n\t\tif (state.kind === \"bound\") unfollow(state);\n\t\tthis.#changes = [];\n\t\tthis.#failed = [];\n\t\tthis.#retired = NO_RETIRED;\n\t\tthis.#touched = false;\n\t\tthis.#provider.unbound(this, removal.cause.error);\n\t\tthis.#object = undefined;\n\t\tthis.#refuse(this.contract, removal.cause);\n\t}\n\n\t/**\n\t * Follows member `index` from its snapshot on (a failed one too: it may recover in this hold): its own encoder and\n\t * pending queue, and a subscription feeding its calls into this hold's batch. Failures fold per member: a failure\n\t * drops what was pending for it and replaces a failure not sent yet (one at most per member, however long the\n\t * consumer stalls); the value after it (a root replacement) replaces the failure. A retirement waits for a value.\n\t */\n\t#follow(state: Bound, index: number, source: DeriveSource): void {\n\t\tconst followed: Followed = {\n\t\t\tindex,\n\t\t\tsource,\n\t\t\tsubscriber: {\n\t\t\t\tadvance: (call) => {\n\t\t\t\t\tthis.#touch();\n\t\t\t\t\tif (call.kind === \"failed\") {\n\t\t\t\t\t\tthis.#memberFailed(followed, call.error);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tthis.#memberHealed(index);\n\t\t\t\t\tconst { ops, retired } = call;\n\t\t\t\t\t// A retired derive's frame may carry no ops (rule 21): only the flag travels.\n\t\t\t\t\tif (ops.length > 0) this.#changes.push([followed, ops]);\n\t\t\t\t\t// A new list per retirement (rare): the shared empty one is never written to.\n\t\t\t\t\tif (retired && !this.#retired.includes(index)) this.#retired = [...this.#retired, index];\n\t\t\t\t},\n\t\t\t\t// The member's source ended with its object, which ends this hold.\n\t\t\t\tend: () => {},\n\t\t\t\tendAfterDelivery: () => {},\n\t\t\t},\n\t\t\tencoder: encoder(),\n\t\t\tpending: new PendingOps(),\n\t\t};\n\t\t// A constant never changes: nothing to subscribe to.\n\t\tif (source instanceof Source) source.subscribe(followed.subscriber);\n\t\tstate.followed.push(followed);\n\t}\n\n\t/** Takes the current batch's changes; the hold is untouched again. */\n\t#take(): (readonly [Followed, readonly Op[]])[] {\n\t\tconst changes = this.#changes;\n\t\tthis.#changes = [];\n\t\tthis.#touched = false;\n\t\treturn changes;\n\t}\n\n\t/** A state entry with `members` and the failures and retirements since the last one; counts one encode. */\n\t#entry(members: StateEntry[\"members\"], context: Context): StateEntry {\n\t\tconst failed = this.#failed;\n\t\tlet retired = this.#retired;\n\t\tthis.#failed = [];\n\t\tthis.#retired = NO_RETIRED;\n\t\tif (retired.length > 0 && failed.length > 0) {\n\t\t\t// A failed member's retirement travels with its next value, never with its failure.\n\t\t\tconst kept = retired.filter((index) => failed.some(({ member }) => member === index));\n\t\t\tif (kept.length > 0) {\n\t\t\t\tthis.#retired = kept;\n\t\t\t\tretired = retired.filter((index) => !kept.includes(index));\n\t\t\t}\n\t\t}\n\t\tcontext.telemetry.metrics?.counter(\"chord.link.encodes\").add(1);\n\t\treturn { hold: this.id, members, failed, retired };\n\t}\n\n\t#touch(): void {\n\t\tif (this.#touched) return;\n\t\tthis.#touched = true;\n\t\tthis.#provider.touched(this);\n\t}\n\n\t/**\n\t * Refuses the hold with `cause`, holding nothing: it keeps `request`, indexed under its type while `waiting` (a\n\t * publication starts it again), for a `retry` otherwise.\n\t */\n\t#refuse(request: HoldRequest, cause: FailureCause): void {\n\t\tthis.#state = { kind: \"refused\", request: owned(request), cause };\n\t\tif (cause.kind === \"waiting\") this.#provider.link.host.index(request.type, this);\n\t\tthis.#provider.send({\n\t\t\tkind: \"failed\",\n\t\t\thold: this.id,\n\t\t\tcause: { kind: cause.kind, error: wireError(cause.error) },\n\t\t});\n\t}\n}\n\n/** Stops following every member of a bound hold. */\nfunction unfollow(state: Bound): void {\n\tfor (const { source, subscriber } of state.followed) if (source instanceof Source) source.unsubscribe(subscriber);\n}\n\n/** `request` with its params owned, not a view of the message they came in (which the link's buffers may hold). */\nfunction owned(request: HoldRequest): HoldRequest {\n\tconst { params } = request;\n\treturn typeof params === \"string\" ? request : { ...request, params: (params as Uint8Array).slice() };\n}\n\n/** A `hold` message's fields naming whom it acts for. */\ntype ActingFor = Pick<HoldMessage, \"principal\" | \"incarnation\">;\n\nconst NOBODY: ActingFor = {};\n\n/**\n * The fields of a `hold` message naming whom it acts for (`caller`): sent only on a route link, whose child honours\n * them (§4); none elsewhere.\n */\nexport function actingFor(link: HostLink, { principal, incarnation }: Caller): ActingFor {\n\treturn link.role === \"route\" && principal !== undefined ? { principal, incarnation } : NOBODY;\n}\n"]}