@earendil-works/chord 1.2.0 → 1.3.0

package/dist/remote.js

@@ -1,145 +1,468 @@
 import { Value } from "typebox/value";
+import { HYDRATION } from "./cell.js";
+import { takesNoArgs } from "./contract.js";
 import { applyImmutable, decoder } from "./delta/index.js";
-import { ChordError } from "./errors.js";
-import { CtxImpl, HANDLE_BASE, holdsByProxy, notifyStatus, raceSignal, } from "./record.js";
+import { ChordError, invalid } from "./errors.js";
+import { CtxImpl, notifyStatus, REF_BASE, raceSignal, refsByProxy, } from "./object.js";
 import { fromWireError } from "./wire.js";
 const noop = () => { };
+function deferred() {
+    let resolve = noop;
+    let reject = noop;
+    const promise = new Promise((done, fail) => {
+        resolve = done;
+        reject = fail;
+    });
+    promise.catch(noop);
+    return { promise, resolve, reject };
+}
+/**
+ * One hold per host and key (type, normalized input, principal key, contract fingerprint), shared by every reference to
+ * it: one hold over the link, one stream per state member, calls over the same hold. References are views onto it.
+ *
+ * A hold implies the state of its variant (unless no view wants state): the provider answers with a unit, the shape
+ * followed by a snapshot of each state member the binding lacks. A shape is applied only once all of its snapshots are
+ * here, so a live binding always has every state member of its variant. After the first hydration the values stay
+ * readable while the binding re-holds (link loss): status `loading`, last values kept.
+ */
+export class RemoteBinding {
+    host;
+    key;
+    contract;
+    at;
+    input;
+    /** Forwarded principal (omitted for the host's own principal). */
+    principal;
+    /** `ended`: gone with `error`, or closed (no views, no linger). */
+    status = "loading";
+    error;
+    /** The applied shape (kept while re-holding). */
+    shape;
+    /** Every state member of the applied shape has a value (stays true while re-holding). */
+    hydrated = false;
+    /** The current hold; undefined while resolving the route or after a link loss. */
+    hold;
+    /** What the provider was told: state for this hold (`state: false` / `sub` / `unsub`). */
+    stateOn = false;
+    views = new Set();
+    members = new Map();
+    /** Lingering since (no views): set by the host. */
+    lingerTimer;
+    #listeners = new Map();
+    /** A shape waiting for its snapshots. */
+    #pending;
+    /** Resolved while a shape is applied for the current hold (calls wait for it). */
+    #live = deferred();
+    /** A shape was applied once (a re-hold says `again`). */
+    #applied = false;
+    /** Waiting for the first hydration (`whenHydrated`). */
+    #hydrationWaiters = new Set();
+    constructor(host, fields) {
+        this.host = host;
+        this.key = fields.key;
+        this.contract = fields.contract;
+        this.at = fields.at;
+        this.input = fields.input;
+        this.principal = fields.principal;
+    }
+    get ended() {
+        return this.status === "ended";
+    }
+    /** Views that want state. */
+    get stateViews() {
+        let count = 0;
+        for (const view of this.views)
+            if (view.wantsState)
+                count++;
+        return count;
+    }
+    /** Whether the next hold should carry state: some view wants it, or nobody is left (lingering keeps it). */
+    get wantsState() {
+        return this.views.size === 0 ? this.stateOn : this.stateViews > 0;
+    }
+    /** Whether a re-hold is `again` (the binding already has a shape). */
+    get applied() {
+        return this.#applied;
+    }
+    // ─── views ───
+    addView(view) {
+        this.views.add(view);
+        if (this.lingerTimer !== undefined) {
+            clearTimeout(this.lingerTimer);
+            this.lingerTimer = undefined;
+        }
+        this.#syncState();
+        view.update();
+    }
+    removeView(view) {
+        if (!this.views.delete(view))
+            return;
+        for (const set of this.#listeners.values())
+            for (const readable of set)
+                if (readable.view === view)
+                    set.delete(readable);
+        if (this.views.size === 0) {
+            this.host.bindingIdle(this);
+            return;
+        }
+        this.#syncState();
+    }
+    /** Tells the provider to start or stop state when the views' wish changed. */
+    #syncState() {
+        if (this.ended || this.views.size === 0)
+            return;
+        const wanted = this.stateViews > 0;
+        if (wanted === this.stateOn)
+            return;
+        this.stateOn = wanted;
+        if (!wanted) {
+            this.hydrated = false;
+            this.members.clear();
+            if (this.#pending !== undefined)
+                this.#pending.missing.clear();
+        }
+        if (this.hold !== undefined)
+            this.hold.channel.wantState(this.hold.id, wanted);
+        for (const view of this.views)
+            view.update();
+    }
+    listen(name, readable) {
+        let set = this.#listeners.get(name);
+        if (set === undefined) {
+            set = new Set();
+            this.#listeners.set(name, set);
+        }
+        set.add(readable);
+    }
+    unlisten(name, readable) {
+        this.#listeners.get(name)?.delete(readable);
+    }
+    /** Whether `name` is a state member of the applied variant (as the consumer's contract describes it). */
+    inVariant(name) {
+        const variant = this.shape?.variant;
+        return variant !== undefined && this.contract.description.variants[variant]?.[name]?.kind === "state";
+    }
+    /** The members' value as views read it: throws `not_ready` before the first hydration, `not_in_variant` outside it. */
+    read(name) {
+        if (this.status === "ended")
+            throw this.terminalError();
+        if (!this.hydrated)
+            throw new ChordError("not_ready", `${this.key}.${name} is not hydrated yet`);
+        if (!this.inVariant(name))
+            throw new ChordError("not_in_variant", `${this.key}: ${name} is not a state member of variant ${this.shape?.variant}`);
+        return this.members.get(name)?.value;
+    }
+    /** Resolves once the binding has its state (rejects if it ends first). */
+    whenHydrated() {
+        if (this.hydrated)
+            return Promise.resolve();
+        if (this.ended)
+            return Promise.reject(this.terminalError());
+        return new Promise((resolve, reject) => this.#hydrationWaiters.add({ resolve, reject }));
+    }
+    #settleHydration(error) {
+        const waiters = [...this.#hydrationWaiters];
+        this.#hydrationWaiters.clear();
+        for (const waiter of waiters) {
+            if (error === undefined)
+                waiter.resolve();
+            else
+                waiter.reject(error);
+        }
+    }
+    readable(name) {
+        return this.status !== "ended" && this.hydrated && this.inVariant(name);
+    }
+    terminalError() {
+        return this.error ?? new ChordError("released", `reference ${this.key} released`);
+    }
+    // ─── driven by the host and the link ───
+    bound(channel, id) {
+        this.hold = { channel, id };
+        this.stateOn = this.wantsState;
+    }
+    /** A unit begins: `listed` are the members whose snapshots follow. */
+    shaped(shape, listed) {
+        if (this.ended)
+            return;
+        const previous = this.#pending;
+        const missing = new Set(listed);
+        // A newer shape before the older one's snapshots (relays may reorder them): wait for both.
+        if (previous !== undefined)
+            for (const name of previous.missing)
+                missing.add(name);
+        const wanted = new Set(this.#stateMembers(shape));
+        for (const name of [...missing])
+            if (!wanted.has(name) || !this.stateOn)
+                missing.delete(name);
+        this.#pending = { shape, missing, values: previous?.values ?? new Map() };
+        if (missing.size === 0)
+            this.#apply();
+    }
+    /** A state frame for member `name` of the current hold. */
+    state(name, frame) {
+        if (this.ended)
+            return;
+        if (frame.as === "error") {
+            const error = fromWireError(frame.error);
+            // Before the first hydration nobody could read anything: the binding fails instead of waiting forever.
+            if (!this.hydrated && this.stateOn) {
+                this.gone(error);
+                this.close();
+            }
+            else
+                this.host.report(error);
+            return;
+        }
+        const pending = this.#pending;
+        if (frame.as === "ops") {
+            const target = pending?.values.get(name) ?? this.members.get(name);
+            if (target === undefined)
+                return;
+            const ops = target.decoder.decode(frame.ops ?? []);
+            target.value = applyImmutable(target.value, ops);
+            if (target === this.members.get(name))
+                this.#deliver(name, { type: "ops", ops, value: target.value });
+            return;
+        }
+        const fresh = { value: frame.value, decoder: decoder() };
+        if (pending !== undefined && (pending.missing.has(name) || pending.values.has(name))) {
+            pending.values.set(name, fresh);
+            pending.missing.delete(name);
+            if (pending.missing.size === 0)
+                this.#apply();
+            return;
+        }
+        if (!this.inVariant(name))
+            return;
+        this.members.set(name, fresh);
+        this.#deliver(name, { type: "reset", value: fresh.value });
+    }
+    /** The provider ended the object (or refused the hold): every view is gone. */
+    gone(error) {
+        if (this.ended)
+            return;
+        this.status = "ended";
+        this.error = error;
+        this.hold = undefined;
+        this.#pending = undefined;
+        this.#live.reject(error);
+        this.#settleHydration(error);
+        for (const view of [...this.views])
+            view.end(error);
+        this.#listeners.clear();
+        this.host.forgetBinding(this);
+    }
+    /** The link went down but may come back (upstream reconnect): keep the values, wait for the re-hold. */
+    detached() {
+        if (this.ended)
+            return;
+        this.hold = undefined;
+        this.#pending = undefined;
+        if (this.status === "live") {
+            this.status = "loading";
+            this.#live = deferred();
+        }
+        for (const view of this.views)
+            view.update();
+    }
+    /** No views and no linger: releases the hold and forgets the binding. */
+    close() {
+        if (this.lingerTimer !== undefined)
+            clearTimeout(this.lingerTimer);
+        this.lingerTimer = undefined;
+        if (this.hold !== undefined)
+            this.hold.channel.release(this.hold.id);
+        this.hold = undefined;
+        if (this.status !== "ended") {
+            this.status = "ended";
+            const error = new ChordError("released", `reference ${this.key} released`);
+            this.#live.reject(error);
+            this.#settleHydration(error);
+            for (const view of [...this.views])
+                view.end(error);
+        }
+        this.#pending = undefined;
+        this.#listeners.clear();
+        this.host.forgetBinding(this);
+    }
+    /** Calls `name` over the current hold, waiting for it while the binding (re)holds. */
+    async call(name, args, ctx) {
+        for (;;) {
+            if (this.ended)
+                throw this.terminalError();
+            if (this.status !== "live" || this.hold === undefined)
+                await raceSignal(this.#live.promise, ctx.signal);
+            const hold = this.hold;
+            if (hold === undefined || this.status !== "live")
+                continue;
+            const variant = this.shape?.variant;
+            const description = variant === undefined ? undefined : this.contract.description.variants[variant]?.[name];
+            if (description?.kind !== "method") {
+                throw new ChordError("not_in_variant", `${this.key}: ${name} is not a method of variant ${variant}`);
+            }
+            // Send only what the consumer's own schema knows (the additive rule's premise; see ObjectImpl.call).
+            const sent = description.args === undefined ? undefined : Value.Clean(description.args, Value.Clone(args));
+            return hold.channel.call(hold.id, name, sent, { rootId: ctx.rootId, codeVersion: ctx.codeVersion }, ctx.signal);
+        }
+    }
+    #stateMembers(shape) {
+        const members = shape.variant === undefined ? undefined : this.contract.description.variants[shape.variant];
+        if (members === undefined)
+            return [];
+        return shape.members.filter((name) => members[name]?.kind === "state");
+    }
+    /** Applies the pending shape with its snapshots: members outside the variant go, new values are announced. */
+    #apply() {
+        const pending = this.#pending;
+        if (pending === undefined)
+            return;
+        this.#pending = undefined;
+        this.shape = pending.shape;
+        const wanted = new Set(this.#stateMembers(pending.shape));
+        for (const name of [...this.members.keys()])
+            if (!wanted.has(name))
+                this.members.delete(name);
+        for (const [name, state] of pending.values)
+            if (wanted.has(name))
+                this.members.set(name, state);
+        this.hydrated = this.stateOn && [...wanted].every((name) => this.members.has(name));
+        if (this.hydrated)
+            this.#settleHydration();
+        this.status = "live";
+        this.#applied = true;
+        this.#live.resolve();
+        for (const view of this.views)
+            view.update();
+        for (const [name, state] of pending.values) {
+            if (wanted.has(name))
+                this.#deliver(name, { type: "reset", value: state.value });
+        }
+        for (const view of [...this.views])
+            view.shapeChanged();
+    }
+    #deliver(name, event) {
+        const readables = this.#listeners.get(name);
+        if (readables === undefined)
+            return;
+        for (const readable of [...readables])
+            readable.deliver(event);
+    }
+}
 /**
- * A state member of a remote handle: hydrated while subscribed (snapshot, then decoded ops); `undefined` before.
- * Re-subscribing after a reconnect delivers the new snapshot as a reset.
+ * A state member of a remote reference: the binding's value. Reading throws `not_ready` before the first hydration and
+ * `not_in_variant` outside the variant. A listener added before the hydration gets its snapshot then.
  */
-class RemoteReadable {
-    #handle;
+class ViewReadable {
+    view;
     #name;
     #values = new Set();
     #events = new Set();
-    #sub;
-    #decoder = decoder();
-    #value;
-    constructor(handle, name) {
-        this.#handle = handle;
+    /** Event listeners that have not had their snapshot yet. */
+    #unseen = new Set();
+    constructor(view, name) {
+        this.view = view;
         this.#name = name;
     }
     get value() {
-        return this.#value;
+        if (this.view.ended)
+            throw this.view.terminalError();
+        return this.view.binding.read(this.#name);
+    }
+    /** Not hydrated before the binding's first snapshots (a local object forwarding this member waits for them). */
+    get [HYDRATION]() {
+        const binding = this.view.binding;
+        if (binding.hydrated)
+            return undefined;
+        return { hydrated: false, whenHydrated: () => binding.whenHydrated() };
     }
     subscribe(listener) {
         this.#values.add(listener);
-        this.#safe(() => listener(this.#value));
-        this.bind();
+        this.#attach();
+        if (this.#readable())
+            this.#safe(() => listener(this.view.binding.members.get(this.#name)?.value));
         return () => this.#remove(this.#values, listener);
     }
     events(listener) {
         this.#events.add(listener);
-        this.#safe(() => listener({ type: "snap", value: this.#value }));
-        this.bind();
-        return () => this.#remove(this.#events, listener);
-    }
-    /** Subscribes upstream while someone listens and the handle is bound; drops a subscription on an old link. */
-    bind() {
-        const listening = this.#values.size + this.#events.size > 0;
-        // Nobody listens: the value would go stale, so forget it. The next subscriber sees `undefined`, then the snapshot.
-        if (!listening)
-            this.#value = undefined;
-        const binding = listening ? this.#handle.binding : undefined;
-        if (binding !== undefined && this.#sub?.channel === binding.channel)
-            return;
-        if (this.#sub !== undefined) {
-            if (this.#sub.channel !== binding?.channel || binding === undefined)
-                this.#sub.channel.unsub(this.#sub.id);
-            this.#sub = undefined;
+        this.#attach();
+        if (this.#readable()) {
+            const value = this.view.binding.members.get(this.#name)?.value;
+            this.#safe(() => listener({ type: "snap", value }));
         }
-        if (binding === undefined)
-            return;
-        const channel = binding.channel;
-        this.#decoder = decoder();
-        const id = channel.sub(binding.id, this.#name, (frame) => this.#receive(frame));
-        this.#sub = { channel, id };
+        else
+            this.#unseen.add(listener);
+        return () => {
+            this.#unseen.delete(listener);
+            this.#remove(this.#events, listener);
+        };
     }
-    /** The link is gone: keep the last value, resubscribe on the next binding. */
-    detach() {
-        this.#sub = undefined;
+    deliver(event) {
+        for (const listener of [...this.#events]) {
+            if (!this.#unseen.delete(listener))
+                this.#safe(() => listener(event));
+            else if (event.type !== "ops")
+                this.#safe(() => listener({ type: "snap", value: event.value }));
+        }
+        for (const listener of [...this.#values])
+            this.#safe(() => listener(event.value));
     }
     stop() {
         this.#values.clear();
         this.#events.clear();
-        this.bind();
+        this.#unseen.clear();
+        this.view.binding.unlisten(this.#name, this);
     }
-    #receive(frame) {
-        if (frame.error !== undefined) {
-            this.#handle.host.report(fromWireError(frame.error));
-            return;
-        }
-        let event;
-        if (frame.ops === undefined && !("snap" in frame) && !("reset" in frame))
-            return;
-        if (frame.ops !== undefined) {
-            const ops = this.#decoder.decode(frame.ops);
-            this.#value = applyImmutable(this.#value, ops);
-            event = { type: "ops", ops, value: this.#value };
-        }
-        else {
-            // Listeners already saw a snapshot (`undefined` or an older value), so every upstream snapshot is a reset.
-            this.#decoder = decoder();
-            this.#value = "snap" in frame ? frame.snap : frame.reset;
-            event = { type: "reset", value: this.#value };
-        }
-        for (const listener of [...this.#events])
-            this.#safe(() => listener(event));
-        for (const listener of [...this.#values])
-            this.#safe(() => listener(this.#value));
+    #readable() {
+        return !this.view.ended && this.view.binding.readable(this.#name);
+    }
+    #attach() {
+        if (!this.view.ended)
+            this.view.binding.listen(this.#name, this);
     }
     #remove(set, listener) {
         set.delete(listener);
-        this.bind();
+        if (this.#values.size + this.#events.size === 0)
+            this.view.binding.unlisten(this.#name, this);
     }
     #safe(fn) {
         try {
             fn();
         }
         catch (error) {
-            this.#handle.host.report(error);
+            this.view.binding.host.report(error);
         }
     }
 }
-/** A hold on an object on another host, bound to a link. Late-bound like a local handle. */
-export class RemoteHandle {
-    record = undefined;
-    host;
-    contract;
-    at;
-    input;
-    /** Forwarded principal (omitted for the host's own principal). */
-    principal;
+/**
+ * A reference to an object on another host: a view onto the host's shared binding for its key. Each view has its own
+ * owner, status, observers and `release`; ending by the provider and re-holding belong to the binding.
+ */
+export class RemoteRef {
+    object = undefined;
+    binding;
     owner;
-    address;
+    /** False: a method-only view (`state: false`), ready once live. */
+    wantsState;
     proxy;
     ready;
     status = "loading";
     error;
-    shape;
-    binding;
     shapeListeners = new Set();
+    #statusListeners = new Set();
     #readables = new Map();
     #callers = new Map();
     #settleReady;
-    #live;
-    constructor(host, fields) {
-        this.host = host;
-        this.contract = fields.contract;
-        this.at = fields.at;
-        this.input = fields.input;
-        this.principal = fields.principal;
-        this.owner = fields.owner;
-        this.address = fields.address;
-        this.ready = new Promise((resolve, reject) => {
-            this.#settleReady = { resolve, reject };
-        });
-        this.ready.catch(noop);
-        this.#live = this.#newLive();
+    constructor(binding, owner, wantsState) {
+        this.binding = binding;
+        this.owner = owner;
+        this.wantsState = wantsState;
+        const ready = deferred();
+        this.ready = ready.promise;
+        this.#settleReady = ready;
         this.proxy = new Proxy(this, {
             get: (target, property) => {
-                if (HANDLE_BASE.has(property)) {
+                if (REF_BASE.has(property)) {
                     const value = Reflect.get(target, property, target);
                     return typeof value === "function" ? value.bind(target) : value;
                 }
@@ -148,10 +471,22 @@ export class RemoteHandle {
                 return target.member(property);
             },
         });
-        holdsByProxy.set(this.proxy, this);
+        refsByProxy.set(this.proxy, this);
+    }
+    get contract() {
+        return this.binding.contract;
+    }
+    get address() {
+        return this.binding.key;
+    }
+    get ended() {
+        return this.status === "released" || this.status === "gone";
     }
-    get kind() {
-        return this.shape?.kind;
+    get variant() {
+        return this.binding.shape?.variant;
+    }
+    get shape() {
+        return this.binding.shape;
     }
     onShape(listener) {
         this.shapeListeners.add(listener);
@@ -161,78 +496,65 @@ export class RemoteHandle {
         this.#statusListeners.add(listener);
         return () => this.#statusListeners.delete(listener);
     }
-    #statusListeners = new Set();
-    #statusChanged() {
-        notifyStatus(this.#statusListeners, this.status, this.error, (error) => this.host.report(error));
+    terminalError() {
+        return this.status === "gone" ? this.error : new ChordError("released", `reference ${this.address} released`);
     }
     release() {
-        if (this.status === "released" || this.status === "gone")
+        if (this.ended)
             return;
         this.status = "released";
-        this.#statusChanged();
-        const error = new ChordError("released", `handle ${this.address} released`);
-        this.#settleReady?.reject(error);
-        this.#live.reject(error);
+        this.#notify();
+        this.#settleReady?.reject(new ChordError("released", `reference ${this.address} released`));
+        this.#settleReady = undefined;
         for (const readable of this.#readables.values())
             readable.stop();
-        if (this.binding !== undefined)
-            this.binding.channel.release(this.binding.id);
-        this.binding = undefined;
-        this.host.forgetRemote(this);
-    }
-    // ─── driven by the link ───
-    bound(channel, id) {
-        this.binding = { channel, id };
+        this.binding.removeView(this);
     }
-    shaped(shape) {
-        if (this.status === "released" || this.status === "gone")
+    // ─── driven by the binding ───
+    /** Follows the binding: live once it has a shape (and, for a state view, its state) over a current hold. */
+    update() {
+        if (this.ended)
             return;
-        this.shape = shape;
-        const wasLoading = this.status === "loading";
-        this.status = "live";
-        if (wasLoading)
-            this.#statusChanged();
-        if (wasLoading) {
+        const binding = this.binding;
+        const live = binding.status === "live" && binding.hold !== undefined && (!this.wantsState || binding.hydrated);
+        const next = live ? "live" : "loading";
+        if (next === this.status)
+            return;
+        this.status = next;
+        this.#notify();
+        if (live) {
             this.#settleReady?.resolve();
             this.#settleReady = undefined;
-            this.#live.resolve();
         }
+    }
+    end(error) {
+        if (this.ended)
+            return;
+        const released = error instanceof ChordError && error.code === "released";
+        this.status = released ? "released" : "gone";
+        if (!released)
+            this.error = error;
+        this.#notify();
+        this.#settleReady?.reject(error);
+        this.#settleReady = undefined;
         for (const readable of this.#readables.values())
-            readable.bind();
+            readable.stop();
+    }
+    shapeChanged() {
+        const shape = this.binding.shape;
+        if (shape === undefined || this.ended)
+            return;
         for (const listener of [...this.shapeListeners]) {
             try {
                 listener(shape);
             }
             catch (error) {
-                this.host.report(error);
+                this.binding.host.report(error);
             }
         }
     }
-    gone(error) {
-        if (this.status === "released" || this.status === "gone")
-            return;
-        this.status = "gone";
-        this.error = error;
-        this.#statusChanged();
-        this.binding = undefined;
-        this.#settleReady?.reject(error);
-        this.#live.reject(error);
-        for (const readable of this.#readables.values())
-            readable.stop();
-        this.host.forgetRemote(this);
-    }
-    /** The link went down but may come back (upstream reconnect): wait, then re-hold. */
-    detached() {
-        if (this.status === "released" || this.status === "gone")
-            return;
-        this.binding = undefined;
-        for (const readable of this.#readables.values())
-            readable.detach();
-        if (this.status === "live") {
-            this.status = "loading";
-            this.#live = this.#newLive();
-            this.#statusChanged();
-        }
+    #notify() {
+        notifyStatus(this.#statusListeners, this.status, this.error, (error) => this.binding.host.report(error));
     }
     // ─── members ───
     member(name) {
@@ -244,7 +566,7 @@ export class RemoteHandle {
         if (description?.kind === "state") {
             let readable = this.#readables.get(name);
             if (readable === undefined) {
-                readable = new RemoteReadable(this, name);
+                readable = new ViewReadable(this, name);
                 this.#readables.set(name, readable);
             }
             return readable;
@@ -254,19 +576,26 @@ export class RemoteHandle {
     #caller(name) {
         let caller = this.#callers.get(name);
         if (caller === undefined) {
-            caller = (args, ctx) => {
-                if (this.host.inFactory > 0)
+            const noArgs = takesNoArgs(this.contract, name);
+            caller = (...given) => {
+                // A method without arguments is called as `ref.name(ctx)`.
+                const [args, ctx] = (noArgs ? [undefined, given[0]] : given);
+                const host = this.binding.host;
+                if (host.inFactory > 0)
                     throw new ChordError("not_ready", `${this.address}.${name} called inside a factory`);
-                if (ctx instanceof CtxImpl) {
-                    try {
-                        ctx.check(ctx.host);
-                    }
-                    catch (error) {
-                        return Promise.reject(error);
-                    }
+                // The same checks as a local reference's caller (RefImpl.caller and ObjectImpl.call): a ctx from another host
+                // or one not made by Chord would carry a root this host does not own over its link.
+                if (ctx !== undefined && !(ctx instanceof CtxImpl)) {
+                    return Promise.reject(invalid("foreign_ctx", "ctx must come from a Chord host"));
+                }
+                try {
+                    ctx?.check(host);
                 }
-                if (ctx === undefined || (ctx instanceof CtxImpl && ctx.holder)) {
-                    return this.host.root((root) => this.#call(name, args, root), { signal: ctx?.signal });
+                catch (error) {
+                    return Promise.reject(error);
+                }
+                if (ctx === undefined || ctx.holder) {
+                    return host.root((root) => this.#call(name, args, root), { signal: ctx?.signal });
                 }
                 return this.#call(name, args, ctx);
             };
@@ -274,35 +603,10 @@ export class RemoteHandle {
         }
         return caller;
     }
-    async #call(name, args, ctx) {
-        for (;;) {
-            if (this.status === "released" || this.status === "gone") {
-                throw this.status === "gone" ? this.error : new ChordError("released", `handle ${this.address} released`);
-            }
-            if (this.status === "loading")
-                await raceSignal(this.#live.promise, ctx.signal);
-            const binding = this.binding;
-            if (binding === undefined)
-                continue;
-            const kind = this.shape?.kind;
-            if (kind === undefined || this.contract.description.variants[kind]?.[name]?.kind !== "method") {
-                throw new ChordError("not_in_variant", `${this.address}: ${name} is not a method of variant ${kind}`);
-            }
-            // Send only what the consumer's own schema knows (the additive rule's premise; see RecordImpl.call).
-            const description = this.contract.description.variants[kind]?.[name];
-            const sent = description?.kind === "method" ? Value.Clean(description.args, Value.Clone(args)) : args;
-            return binding.channel.call(binding.id, name, sent, { rootId: ctx.rootId, epoch: ctx.epoch }, ctx.signal);
-        }
-    }
-    #newLive() {
-        let resolve = noop;
-        let reject = noop;
-        const promise = new Promise((done, fail) => {
-            resolve = done;
-            reject = fail;
-        });
-        promise.catch(noop);
-        return { promise, resolve, reject };
+    #call(name, args, ctx) {
+        if (this.ended)
+            return Promise.reject(this.terminalError());
+        return this.binding.call(name, args, ctx);
     }
 }
 //# sourceMappingURL=remote.js.map