@earendil-works/chord 1.5.0 → 1.5.1

package/dist/host/reference.js

@@ -0,0 +1,797 @@
+// References (§7): what `get` and `hold` return, a plain object built from the contract's members, and its binding to
+// the object: counted as a reference, it follows the object's state, parks calls while loading, keeps the
+// per-reference watches and is released once. A binding whose object a reload removed, or whose version it no longer
+// binds, waits unbound and binds again (slice 7b §6); one of an older version reads adapted members (Q10).
+import { BACKGROUND_CONTEXT } from "../context/index.js";
+import { currentVariants, LOCAL, takesNoArgs, } from "../contracts/internal.js";
+import { ChordError } from "../data/index.js";
+import { Keyed, Singleton } from "../documents/internal.js";
+import { RETRY_HOPS } from "../link/internal.js";
+import { Constant, Source } from "../state/internal.js";
+import { withLinkedAbortSignal } from "./ctx.js";
+import { ParkedCalls } from "./parked.js";
+import { LOADING, ReferenceState } from "./ref-state.js";
+import { ReferenceKeys } from "./reference-keys.js";
+import { ReferenceSource } from "./reference-source.js";
+/** A walk starting here: `ref.retry()`'s, with the first host's budget, or a `retry` message's, with one hop less. */
+export function retryWalk(hops = RETRY_HOPS) {
+    return { visited: new Set(), hops };
+}
+const WAIT = { kind: "wait" };
+const DONE = { kind: "done" };
+/**
+ * A reference's binding to its object: counted by the object as one of its references while bound, and told of each
+ * change of its state. Calls run while live, park while loading (sent in order once live) and reject while failed.
+ * Released, or ended with its object, it ends the watches taken through it and rejects the calls made through it.
+ */
+export class Binding {
+    reference;
+    /** Who calls through this reference: the principal it was got as, and this host's incarnation. */
+    caller;
+    /** The contract's name, for errors. */
+    #name;
+    /** The consumer's contract (its version is the binding's) until the reference is released (it keeps none then). */
+    #contract;
+    /** How long a call made while loading waits: the reference's `readyTimeout`. */
+    #parkTimeout;
+    #state;
+    #watches = new Set();
+    /**
+     * Aborted when the reference ends: its calls' callers are rejected and their handlers' contexts aborted. Made by the
+     * first call and dropped at the end, so a released reference keeps no error (whose stack keeps its frames).
+     */
+    #calls;
+    /** Calls made while loading; made by the first. */
+    #parked;
+    /** Waits for a state (getters, member watches before the first binding); each checks the state at every change. */
+    #waiters = new Set();
+    /** `ref.state`, made on first access. */
+    #refState;
+    /** The keys its object's factory pinned with `ref.member.at(key)`: pinned once bound, released with it. */
+    #ats = [];
+    /** Its state members as consumers follow them (`ReferenceSource`), by name; each made by its first use. */
+    #sources;
+    /** The keys of its object's keyed members it holds (key watches, `at(key)` pins); made by the first. */
+    #heldKeys;
+    /** The instance it attached to last: it takes last values only from that one (never one it never followed). */
+    #attached;
+    /** Whether presence lists show it: every reference but a restart's readiness bindings (`unlist`). */
+    #listed = true;
+    constructor(contract, batch, dependent, caller, parkTimeout) {
+        this.#name = contract.name;
+        this.#contract = contract;
+        this.caller = caller;
+        this.#parkTimeout = parkTimeout;
+        this.#state = { kind: "unbound", batch, dependent };
+        const reference = { release: () => this.release(), retry: () => this.retry() };
+        Object.defineProperty(reference, "state", { get: () => this.#watchableState(), enumerable: true });
+        // Every member of every variant (one kind and signature per name, D11); the bound variant decides which work.
+        const methods = new Map();
+        for (const variant of currentVariants(contract).values()) {
+            for (const member of variant.state.keys())
+                reference[member] = new ReferenceMember(this, member);
+            for (const member of variant.keyed.keys())
+                reference[member] = new ReferenceKeyed(this, member);
+            for (const [member, method] of variant.methods)
+                methods.set(member, method);
+        }
+        for (const [member, method] of methods) {
+            // A method without arguments omits them; `null` is their internal and wire form.
+            reference[member] = takesNoArgs(method)
+                ? async (context) => this.#call(member, null, context)
+                : async (args, context) => this.#call(member, args, context);
+        }
+        if (contract.kind === "remote") {
+            Object.defineProperty(reference, "variant", { get: () => this.#variant(), enumerable: true });
+        }
+        // Built from the contract's own member lists.
+        this.reference = reference;
+    }
+    /** The consumer's contract: its version is the binding's. Only an unreleased binding is asked. */
+    get contract() {
+        return this.#contract;
+    }
+    /** The object whose attempt declared this reference, until it is released. */
+    get dependent() {
+        const state = this.#state;
+        return state.kind === "released" ? undefined : state.dependent;
+    }
+    /** Whom it acts for (the unbound index's revocation). */
+    get principal() {
+        return this.caller.principal;
+    }
+    /** The reference's state. */
+    get refState() {
+        const state = this.#state;
+        if (state.kind === "bound") {
+            // A bound reference keeps its contract until it is released.
+            const { version, fingerprint } = this.#contract;
+            return state.target.stateFor(version, fingerprint);
+        }
+        if (state.kind === "waiting")
+            return state.failure ?? LOADING;
+        if (state.kind === "refused")
+            return state.failure;
+        return state.kind === "unbound" ? LOADING : state.state;
+    }
+    /** The object it is bound to; `undefined` while it is not bound. */
+    get target() {
+        return this.#state.kind === "bound" ? this.#state.target : undefined;
+    }
+    /** The object in errors: its label once bound, else the contract's name. */
+    get label() {
+        return this.#state.kind === "bound" ? this.#state.target.label : this.#name;
+    }
+    /** The error of the object's last failure while none went live since, or of the check that left it unbound. */
+    get lastFailure() {
+        const state = this.#state;
+        if (state.kind === "refused")
+            return state.failure.cause.error;
+        if (state.kind === "waiting")
+            return state.failure?.cause.error;
+        return state.kind === "bound" ? state.target.lastFailure : undefined;
+    }
+    /**
+     * Binds to `target`, which counts this binding as a reference; its members and keys follow what `target` shows now
+     * (one frame from their last values), and the reference takes its state.
+     */
+    bind(target) {
+        const state = this.#state;
+        if (state.kind !== "unbound")
+            return;
+        this.#state = { kind: "bound", batch: state.batch, dependent: state.dependent, target };
+        target.hold(this);
+        // `hold` may release it at once (a presence derive): `retarget` sees that. A batch only when members move.
+        if (this.following)
+            state.batch.within(() => this.retarget(), BACKGROUND_CONTEXT);
+        else
+            this.retarget();
+        this.moved();
+    }
+    /** Whether its members or keys were used: `retarget` moves them (in a batch). */
+    get following() {
+        return this.#sources !== undefined || this.#heldKeys !== undefined;
+    }
+    /**
+     * Inside a batch when `following`: its members and keys follow what its object shows now (`Target.followed`): the live instance's
+     * members (moved there, one frame each), or their last values (one `failed` call for a failure). The first time it
+     * points at nothing, every member of its version gets its last value, read or not.
+     */
+    retarget() {
+        const state = this.#state;
+        if (state.kind !== "bound")
+            return;
+        const { target } = state;
+        const { version } = this.contract;
+        const attachable = target.attachable;
+        if (attachable !== undefined)
+            this.#attached = attachable;
+        // Detaching from an instance it attached to: every member keeps its last value (none before it ever attached).
+        else if (this.#attached !== undefined)
+            this.#keepAll(this.#attached);
+        const attached = this.#attached;
+        for (const [member, source] of this.#sources ?? [])
+            place(source, target.followed(member, version), attached);
+        // Its last values taken: it keeps no node of that instance (GC).
+        if (attachable === undefined)
+            this.#attached = undefined;
+        this.#heldKeys?.follow(BACKGROUND_CONTEXT);
+    }
+    /**
+     * Its object left it (slice 7b §6): its type was removed, or its provider no longer binds its version. The request
+     * waits unbound with `removal.cause` in the host's index, its members and keys keeping their last values (taken from
+     * the instance it leaves; one `failed` call), and binds again, by name, when a publication serves it: its members
+     * move to the next object's instance and its keys pin there again (one frame each); parked calls flush or reject;
+     * presence lists it again.
+     */
+    removed(removal) {
+        const state = this.#state;
+        if (state.kind !== "bound")
+            return;
+        const { error } = removal.cause;
+        state.batch.within(() => {
+            // Its last values from the instance it attached to (one refused at its binding attached to none).
+            if (this.#attached !== undefined)
+                this.#keepAll(this.#attached);
+            for (const source of this.#sources?.values() ?? [])
+                source.fail(error, BACKGROUND_CONTEXT);
+            this.#heldKeys?.fail(error, BACKGROUND_CONTEXT);
+        }, BACKGROUND_CONTEXT);
+        // Its last values taken: it keeps no node of that instance (GC).
+        this.#attached = undefined;
+        this.#state = { kind: "unbound", batch: state.batch, dependent: state.dependent };
+        removal.host.rewait(this, this.contract, removal.params, removal.cause, removal.context);
+    }
+    /**
+     * Every state member of its version, in the variant of the instance it attached to (its object may be live no more),
+     * gets a source, read or not, so each keeps a last value while it points at nothing (no-op for one already made).
+     */
+    #keepAll(attached) {
+        const variant = currentVariants(this.contract).get(attached.variant ?? LOCAL);
+        for (const member of variant?.state.keys() ?? [])
+            this.#memberSource(member);
+    }
+    /**
+     * Leaves the reference unbound in the host's unbound index (`leave` takes it out): `loading` before the publication
+     * (no `cause`), else `failed` with `cause` (`waiting`); `place` checks it again when the index wakes it.
+     */
+    wait(cause, place, leave) {
+        const state = this.#state;
+        if (state.kind !== "unbound")
+            return;
+        // Kept while it waits: its stack made text now, so it keeps none of the frames' objects (an ended instance's).
+        if (cause !== undefined)
+            void cause.error.stack;
+        const failure = cause === undefined ? undefined : { kind: "failed", cause, retryAt: undefined };
+        const { batch, dependent } = state;
+        this.#state = { kind: "waiting", batch, dependent, failure, place, leave };
+        // Unchanged while loading: nothing to tell.
+        if (failure !== undefined)
+            this.moved();
+    }
+    /** Woken by the unbound index (out of it already): checked again where it goes. */
+    wake() {
+        const state = this.#state;
+        if (state.kind !== "waiting")
+            return;
+        const { batch, dependent } = state;
+        this.#state = { kind: "unbound", batch, dependent };
+        state.place();
+    }
+    /**
+     * A reference that cannot be bound (where it goes refused it): failed broken with `cause` until `ref.retry()` runs
+     * `bind` again (a route's `authorize` may admit it later).
+     */
+    refuse(cause, bind) {
+        const state = this.#state;
+        if (state.kind !== "unbound")
+            return;
+        const failure = { kind: "failed", cause, retryAt: undefined };
+        this.#state = { kind: "refused", batch: state.batch, dependent: state.dependent, failure, bind };
+        this.moved();
+    }
+    /**
+     * The state may have changed: `ref.state`'s watches are told; live sends the parked calls in order, failed
+     * rejects them with the cause; waits for a state decide; the object whose attempt declared it re-evaluates.
+     */
+    moved() {
+        this.#refState?.moved();
+        const state = this.refState;
+        if (state.kind === "live") {
+            this.#parked?.flush((method, args, context) => this.#send(method, args, context), () => this.refState.kind === "live");
+        }
+        else if (state.kind === "failed") {
+            this.#parked?.reject(state.cause.error);
+        }
+        for (const waiter of [...this.#waiters])
+            waiter.check();
+        this.dependent?.dependencyMoved();
+    }
+    /** Whether presence lists show it (§19). */
+    get listed() {
+        return this.#listed;
+    }
+    /** Keeps it out of presence lists, before it binds: a restart's readiness binding is no consumer of its own. */
+    unlist() {
+        this.#listed = false;
+    }
+    /** Whether its members have values now: bound to an object that shows it live and has them. */
+    #hydratedNow() {
+        const state = this.#state;
+        return state.kind === "bound" && state.target.hydrated && this.refState.kind === "live";
+    }
+    /** Resolves once `done(state)` holds, checked now and at every change; rejects at its end or `context`'s abort. */
+    until(done, context) {
+        return this.#until((state) => (done(state) ? DONE : WAIT), context);
+    }
+    /** Resolves when the reference is live; rejects with a broken failure's error, or its end. Getters wait for it. */
+    live(context) {
+        return this.#until((state) => {
+            if (state.kind === "live")
+                return DONE;
+            const broken = state.kind === "failed" && state.cause.kind === "broken";
+            return broken ? { kind: "failed", error: state.cause.error } : WAIT;
+        }, context);
+    }
+    /**
+     * The state member behind `member`, as consumers follow it (`ReferenceSource`): the instance's member while its
+     * object is live, its last value while it points at nothing; reads throw `released`, the failure's error, or
+     * `not_ready` when it never had a value.
+     */
+    member(member) {
+        return this.#memberSource(member);
+    }
+    /** The source of state member `member`, made by its first use, following what its target shows now. */
+    #memberSource(member) {
+        this.#sources ??= new Map();
+        let source = this.#sources.get(member);
+        if (source !== undefined)
+            return source;
+        const state = this.#state;
+        // A released reference throws its end (`#target`): it makes no source.
+        if (state.kind === "released")
+            throw state.state.error;
+        source = new ReferenceSource(state.batch, this);
+        this.#sources.set(member, source);
+        // New, nothing follows it yet: placing it needs no batch.
+        if (state.kind === "bound")
+            place(source, state.target.followed(member, this.contract.version), this.#attached);
+        return source;
+    }
+    /** What a read of a member that never had a value throws: `released`, the failure's error, or `not_ready`. */
+    none() {
+        try {
+            this.#target();
+        }
+        catch (error) {
+            return error;
+        }
+        return new ChordError({ code: "not_ready", message: `${this.label}: not live yet` });
+    }
+    /** The keyed member `member`'s slot (slice 6a §12), as `member` resolves a state member. */
+    keyedSlot(member) {
+        return this.#target().keyedMember(member);
+    }
+    /** How this reference reads keyed member `member`'s documents (`Target.keyedMapping`), as `keyedSlot` resolves. */
+    keyedMapping(member) {
+        return this.#target().keyedMapping(member, this.contract.version);
+    }
+    /**
+     * Holds `key` of keyed member `member` (a key watch, a factory's `at(key)`, an object re-exposing this member): its
+     * source, pinned on the live instance and following its object's instances (`ReferenceKeys`); `release` once.
+     */
+    pinKey(member, key, context) {
+        const state = this.#state;
+        if (state.kind === "released")
+            return Promise.reject(state.state.error);
+        this.#heldKeys ??= new ReferenceKeys({
+            batch: state.batch,
+            version: this.contract.version,
+            target: () => this.target,
+            none: () => this.none(),
+        });
+        return this.#heldKeys.hold(member, key, context);
+    }
+    /** The bound object unless it failed: throws `released`, the failure's error, `not_ready` before the binding. */
+    #target() {
+        const state = this.#state;
+        switch (state.kind) {
+            case "bound": {
+                const current = this.refState;
+                if (current.kind === "failed")
+                    throw current.cause.error;
+                return state.target;
+            }
+            case "unbound":
+                throw new ChordError({ code: "not_ready", message: `${this.#name}: not live yet` });
+            case "waiting":
+                if (state.failure === undefined) {
+                    throw new ChordError({ code: "not_ready", message: `${this.#name}: not live yet` });
+                }
+                throw state.failure.cause.error;
+            case "refused":
+                throw state.failure.cause.error;
+            case "released":
+                throw state.state.error;
+        }
+    }
+    /**
+     * A watch of `member` that ends when this reference is released, through its member (`ReferenceSource`): opened at
+     * once once it has a value (its last one while its object is not live, frames again when it is); before its first
+     * value it waits for its object's (`firstValues`: through failures, until the reference ends or `context` aborts).
+     */
+    async watch(member, context) {
+        // Checked here too: a constant's own watch has no batch to check. A released reference throws below.
+        if (this.#state.kind !== "released")
+            this.#state.batch.assertOutside("watch");
+        const source = this.#memberSource(member);
+        // Never had a value: it waits for its object's, as before the first binding.
+        if (source.unbound)
+            await this.firstValues(context);
+        return this.follow(source.openWatch(context));
+    }
+    /**
+     * Resolves once its object's members have values (its first binding, for a watch on a reference that never had any);
+     * rejects only when the reference ends (released, revoked, its host closed) or `context` aborts: a failure is waited
+     * through (Opus G3).
+     */
+    async firstValues(context) {
+        if (this.#hydratedNow())
+            return;
+        await this.#until((state) => (state.kind === "live" ? DONE : WAIT), context);
+    }
+    /** Resolves once the object's members have values; rejects when the reference fails or is released first. */
+    async hydrated(context) {
+        if (this.#hydratedNow())
+            return;
+        await this.#until((state) => {
+            if (state.kind === "live")
+                return DONE;
+            if (state.kind === "failed")
+                return { kind: "failed", error: state.cause.error };
+            return WAIT;
+        }, context);
+    }
+    /**
+     * Ends `watch` when this reference is released; returns it. A watch opened while the reference was released (an
+     * async keyed watch racing `release`) is ended at once, its pin with it, and the caller gets `released`.
+     */
+    follow(watch) {
+        if (this.#state.kind === "released") {
+            watch.end({ kind: "ended" });
+            throw this.#state.state.error;
+        }
+        this.#watches.add(watch);
+        void watch.closed.then(() => this.#watches.delete(watch));
+        return watch;
+    }
+    /**
+     * `ref.member.at(key)`: only while its object's factory runs (the reference not yet bound); pinned once bound
+     * (`pinKeys`), released with the reference.
+     */
+    at(member, key) {
+        if (this.#state.kind !== "unbound" || this.#state.dependent === undefined) {
+            throw new Error(`${this.#name}: ${member}.at(key) is valid only in the factory`);
+        }
+        const at = new KeyedMemberAt(this, member, key);
+        this.#ats.push(at);
+        return at;
+    }
+    /** Whether its object's factory pinned keys on it (`at(key)`). */
+    get pinsKeys() {
+        return this.#ats.length > 0;
+    }
+    /**
+     * Pins the keys of `at(key)` on the live object's keyed members and loads those not in memory, before the
+     * dependent goes live (slice 6a §12); `undefined` when there are none. A failed load rejects.
+     */
+    pinKeys(context) {
+        if (this.#ats.length === 0)
+            return undefined;
+        return (async () => {
+            for (const at of this.#ats)
+                await at.pin(this, context);
+        })();
+    }
+    /**
+     * `ref.retry()`, as a step of `walk` (a new one for `ref.retry()`, passed on through parked objects): the object is
+     * asked for an attempt now (ignored unless failed; a parked one passes it on); a refused reference is placed again;
+     * one waiting in the index is left as it is (an event wakes it).
+     */
+    retry(walk = retryWalk()) {
+        const state = this.#state;
+        if (state.kind === "bound") {
+            state.target.retry(walk);
+            return;
+        }
+        if (state.kind !== "refused")
+            return;
+        this.#state = { kind: "unbound", batch: state.batch, dependent: state.dependent };
+        this.moved();
+        state.bind();
+    }
+    /** Releases the reference (idempotent); the object may end when it was its last. */
+    release() {
+        const state = this.#state;
+        if (state.kind === "released")
+            return;
+        state.batch.assertOutside("release");
+        // First: an object over a link rejects the calls itself and sends no cancel for them.
+        if (state.kind === "bound")
+            state.target.unhold(this);
+        this.end(this.#released());
+    }
+    /**
+     * Ends the reference without releasing it from its object (it ended): watches end, calls (running and parked)
+     * reject with `error`, `ref.state` is `ended` with it; the object whose attempt declared it checks again.
+     */
+    end(error) {
+        // Kept by `ref.state`: its stack is made text now, so the error holds none of the frames' objects.
+        void error.stack;
+        const ended = { kind: "ended", error };
+        const previous = this.#state;
+        this.#state = { kind: "released", state: ended };
+        this.#contract = undefined;
+        if (previous.kind === "waiting")
+            previous.leave();
+        for (const at of this.#ats)
+            at.release();
+        // Its members' and keys' watches end, derives over them are marked; their instance subscriptions go.
+        const sources = this.#sources;
+        const keys = this.#heldKeys;
+        this.#sources = undefined;
+        this.#heldKeys = undefined;
+        this.#attached = undefined;
+        if (previous.kind !== "released" && (sources !== undefined || keys !== undefined)) {
+            const end = () => {
+                for (const source of sources?.values() ?? [])
+                    source.end(error);
+                keys?.end(error);
+            };
+            // A batch only when something still follows them (an ending object's derives detached already).
+            const used = keys !== undefined || [...(sources?.values() ?? [])].some((source) => source.inUse);
+            if (used)
+                previous.batch.within(end, BACKGROUND_CONTEXT);
+            else
+                end();
+        }
+        this.#calls?.abort(error);
+        this.#calls = undefined;
+        this.#parked?.reject(error);
+        this.#parked = undefined;
+        for (const watch of this.#watches)
+            watch.end({ kind: "ended" });
+        this.#refState?.released(ended);
+        // Each removes itself; promise reactions run later.
+        for (const waiter of this.#waiters)
+            waiter.end(error);
+        // An ended dependency breaks a parked dependent (it cannot come back).
+        if (previous.kind !== "released")
+            previous.dependent?.dependencyMoved();
+    }
+    #call(method, args, context) {
+        const state = this.refState;
+        switch (state.kind) {
+            case "live":
+                // Calls queued before it went live are still being sent: a new one never overtakes them.
+                if (this.#parked?.waiting)
+                    return this.#parked.park(method, args, context);
+                return this.#send(method, args, context);
+            case "loading":
+                this.#parked ??= new ParkedCalls(this.#parkTimeout, this.label);
+                return this.#parked.park(method, args, context);
+            case "failed":
+                throw state.cause.error;
+            case "ended":
+                throw state.error;
+        }
+    }
+    /** Calls the live object; the call is aborted when the reference ends. */
+    #send(method, args, context) {
+        // Only a bound reference is live.
+        const { target } = this.#state;
+        this.#calls ??= new AbortController();
+        const linked = withLinkedAbortSignal(this.#calls.signal, context);
+        return target.call(method, args, linked.context, this.caller, this.contract.version).finally(linked.release);
+    }
+    /**
+     * Settles once `decide` does for the reference's state, checked now and at every change; rejects when the reference
+     * ends (with its error, `released` when it is released already) or `context` aborts.
+     */
+    #until(decide, context) {
+        if (this.#state.kind === "released")
+            return Promise.reject(this.#state.state.error);
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const signal = context.abortSignal;
+        const settle = (done) => {
+            this.#waiters.delete(waiter);
+            signal?.removeEventListener("abort", abort);
+            done();
+        };
+        const waiter = {
+            check: () => {
+                const decision = decide(this.refState);
+                if (decision.kind === "done")
+                    settle(resolve);
+                else if (decision.kind === "failed")
+                    settle(() => reject(decision.error));
+            },
+            end: (error) => settle(() => reject(error)),
+        };
+        const abort = () => settle(() => reject(signal?.reason));
+        this.#waiters.add(waiter);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        else
+            waiter.check();
+        return promise;
+    }
+    #watchableState() {
+        if (this.#refState !== undefined)
+            return this.#refState;
+        const state = this.#state;
+        // A released reference's state never changes: it is made ended, keeping no batch.
+        if (state.kind === "released") {
+            const made = new ReferenceState(() => this.refState, undefined);
+            made.released(state.state);
+            this.#refState = made;
+            return made;
+        }
+        this.#refState = new ReferenceState(() => this.refState, state.batch);
+        return this.#refState;
+    }
+    #variant() {
+        const state = this.#state;
+        if (state.kind === "released")
+            throw state.state.error;
+        return state.kind === "bound" ? state.target.variant : undefined;
+    }
+    /** The error of this reference's release by its holder (`released`, no reason). */
+    #released() {
+        return new ChordError({ code: "released", message: `${this.#name}: released` });
+    }
+}
+/** A state member of a reference: the provider's member, followed through this reference. */
+class ReferenceMember {
+    #binding;
+    #member;
+    constructor(binding, member) {
+        this.#binding = binding;
+        this.#member = member;
+    }
+    get value() {
+        return this.source.value;
+    }
+    watch(context) {
+        return this.#binding.watch(this.#member, context);
+    }
+    /** The provider's member: a source or a constant. */
+    get source() {
+        return this.#binding.member(this.#member);
+    }
+}
+/** A keyed member of a reference (slice 6a §12): reads by key behave as calls (they wait while loading). */
+class ReferenceKeyed {
+    #binding;
+    #member;
+    constructor(binding, member) {
+        this.#binding = binding;
+        this.#member = member;
+    }
+    /** The provider's slot: the ultimate provider's, through re-exposures (rule 22). */
+    get slot() {
+        return this.#binding.keyedSlot(this.#member);
+    }
+    /** This member as another object re-exposing it has it: its keys held through this reference. */
+    get keyed() {
+        return { kind: "reexposed", binding: this.#binding, member: this.#member };
+    }
+    async get(key, context) {
+        await this.#binding.hydrated(context);
+        const slot = this.slot;
+        const map = this.#binding.keyedMapping(this.#member);
+        const value = await slot.get(key, ownAccess(slot), context);
+        return map === undefined || value === undefined ? value : map(value);
+    }
+    /**
+     * A watch of the document at `key` across the object's attempts (it holds the key through the object), `undefined`
+     * when absent; it ends with this reference.
+     */
+    async watch(key, context) {
+        await this.#binding.firstValues(context);
+        const slot = this.slot;
+        if ((await slot.get(key, ownAccess(slot), context)) === undefined)
+            return undefined;
+        // Mapped to its version when older (slice 7b §7), across its object's instances (`ReferenceKeys`).
+        const held = await this.#binding.pinKey(this.#member, key, context);
+        // Retired between the read and now: absent.
+        if (slot.current(slot.key(key)) === undefined) {
+            held.release();
+            return undefined;
+        }
+        let watch;
+        try {
+            watch = held.source.openWatch(context);
+        }
+        catch (error) {
+            held.release();
+            throw error;
+        }
+        void watch.closed.then(held.release);
+        return this.#binding.follow(watch);
+    }
+    at(key) {
+        // The pinned key's values are the member's documents.
+        return this.#binding.at(this.#member, key);
+    }
+}
+/** A consumer reads its provider's keyed documents as the provider's own code may: current version, own token. */
+function ownAccess(slot) {
+    return { token: slot.owner.own, version: slot.definition.current.version };
+}
+/**
+ * `ref.member.at(key)`: the key's source across the object's attempts once the reference is bound and the key held
+ * (`pin`), until the reference ends (`release`, exactly once): then it drops the source (a retained reference keeps no
+ * provider).
+ */
+class KeyedMemberAt {
+    #binding;
+    member;
+    key;
+    #state = { kind: "unpinned" };
+    constructor(binding, member, key) {
+        this.#binding = binding;
+        this.member = member;
+        this.key = key;
+    }
+    /** The key's source; `not_ready` before it is held, `released` after. */
+    get source() {
+        const state = this.#state;
+        if (state.kind === "pinned")
+            return state.source;
+        const what = `${this.member}.at(${this.key})`;
+        if (state.kind === "released")
+            throw new ChordError({ code: "released", message: `${what}: released` });
+        throw new ChordError({ code: "not_ready", message: `${what}: not loaded yet` });
+    }
+    get value() {
+        return this.source.value;
+    }
+    async watch(context) {
+        return this.#binding.follow(this.source.openWatch(context));
+    }
+    /**
+     * Holds the key through `binding` (once), loaded, mapped to an older binding's version (slice 7b §7); nothing once
+     * released (a hold that lands then is released).
+     */
+    async pin(binding, context) {
+        if (this.#state.kind !== "unpinned")
+            return;
+        const held = await binding.pinKey(this.member, this.key, context);
+        if (this.#state.kind !== "unpinned") {
+            held.release();
+            return;
+        }
+        this.#state = { kind: "pinned", source: held.source, release: held.release };
+    }
+    /** Releases the pin and drops the source (once). */
+    release() {
+        const state = this.#state;
+        this.#state = { kind: "released" };
+        if (state.kind === "pinned")
+            state.release();
+    }
+}
+/**
+ * What a keyed member's value is (slice 6a §12): a keyed document handle's slot, or a reference's keyed member
+ * (re-exposed); `undefined` for anything else.
+ */
+export function resolveKeyed(value) {
+    if (value instanceof Keyed)
+        return { kind: "own", slot: value.slot };
+    if (value instanceof ReferenceKeyed)
+        return value.keyed;
+    return undefined;
+}
+/**
+ * The watchable Chord follows behind a state member or a derive source (Q14): a source or a constant itself, a
+ * singleton handle's slot, a reference member's provider member, a keyed member's pinned key (a key source itself for
+ * `handle.at(key)`); `undefined` for anything else, a native watchable included.
+ */
+export function resolveWatchable(value) {
+    if (value instanceof Singleton)
+        return value.slot;
+    if (value instanceof ReferenceMember)
+        return value.source;
+    if (value instanceof KeyedMemberAt)
+        return value.source;
+    if (value instanceof Source || value instanceof Constant)
+        return value;
+    return undefined;
+}
+/**
+ * Points `source` at what its reference follows now (`Followed`), inside a batch; a new one takes its last value from
+ * the instance that stopped, only when its reference was attached to that one (`attached`).
+ */
+function place(source, followed, attached) {
+    switch (followed.kind) {
+        case "live":
+            source.bind(followed.source);
+            return;
+        case "lacking":
+            source.vanish(followed.error, BACKGROUND_CONTEXT);
+            return;
+        case "loading":
+            if (source.unbound && followed.last !== undefined && followed.instance === attached)
+                source.bind(followed.last);
+            source.hold();
+            return;
+        case "failed":
+            if (source.unbound && followed.last !== undefined && followed.instance === attached)
+                source.bind(followed.last);
+            source.fail(followed.error, BACKGROUND_CONTEXT);
+            return;
+    }
+}
+//# sourceMappingURL=reference.js.map