@earendil-works/chord 1.4.0 → 1.5.1

package/dist/host/reference.d.ts

@@ -0,0 +1,321 @@
+import { type Context } from "../context/index.ts";
+import type { Contract, Implementation, ParamsOf } from "../contracts/index.ts";
+import { type CurrentVariants, type ShapeOf, type VariantImplementation } from "../contracts/internal.ts";
+import { ChordError, type FailureCause, type Principal } from "../data/index.ts";
+import { type KeyedSlot } from "../documents/internal.ts";
+import type { JsonValue } from "../json.ts";
+import { type Batch, type DeriveSource } from "../state/internal.ts";
+import type { NativeWatchable, Watch } from "../watch.ts";
+import type { PinnedKey } from "./attempt.ts";
+import { type Caller } from "./ctx.ts";
+import type { KeyedBinding } from "./members.ts";
+import type { ChordObject, Holder, Removal } from "./object.ts";
+import { type RefState } from "./ref-state.ts";
+import type { UnboundRequest } from "./unbound.ts";
+/**
+ * A reference: a local contract's members, or for a remote contract the members of the variant its object chose,
+ * narrowed by `variant`; and its state, `retry()` and `release()`. Every use after release throws.
+ */
+export type Reference<C extends Contract> = ShapeOf<C>["kind"] extends "local" ? Implementation<C> & Lifecycle : InVariants<C, never>;
+/** What `host.hold` returns: a reference whose `variant` is `undefined` until its first binding. */
+export type Held<C extends Contract> = ShapeOf<C>["kind"] extends "local" ? Implementation<C> & Lifecycle : InVariants<C, undefined>;
+/** A remote reference narrowed to some of its variants. */
+export type RefIn<C extends Contract, V extends string> = Extract<Reference<C>, {
+    readonly variant: V;
+}>;
+/** One member of a remote reference's union per variant; `Unbound` is what `variant` may also be. */
+type InVariants<C extends Contract, Unbound> = {
+    [V in keyof CurrentVariants<C>]: {
+        readonly variant: V | Unbound;
+    } & VariantImplementation<CurrentVariants<C>[V]> & Lifecycle;
+}[keyof CurrentVariants<C>];
+/** What every reference has besides its members. */
+type Lifecycle = {
+    /** The reference's state: loading, live, failed or released; watches get every change. */
+    readonly state: NativeWatchable<RefState>;
+    /**
+     * Asks a failed object for an attempt now (the backoff skipped, a broken one renewed); an object parked on failed
+     * dependencies passes it on to them, once; otherwise nothing.
+     */
+    retry(): void;
+    release(): void;
+};
+/**
+ * What a binding is bound to: an object on this host (`ChordObject`), or an object held over a path, the parent link
+ * or a route address (`RemoteObject`). It tells its holders of each change of `state`.
+ */
+export interface Target {
+    /** Where it is: an object on this host, or one held over a link (another host decides what it serves). */
+    readonly kind: "local" | "remote";
+    /** The object in errors: its type, and its params key when it has params. */
+    readonly label: string;
+    /** Its state as its references show it. */
+    readonly state: RefState;
+    /**
+     * Its state as a reference of `version` and `fingerprint` sees it: on this host `live` also while a restart's open
+     * old attempt binds that version (decision "Reload restarts every affected object", rule 5); `state` over a link.
+     */
+    stateFor(version: number, fingerprint: string): RefState;
+    /** Whether its state members have values: live once, for a remote object bound once. */
+    readonly hydrated: boolean;
+    /** The variant bound last; `undefined` for a local object and before the first binding. */
+    readonly variant: string | undefined;
+    /** The error of its last failure (an attempt's, or the dependencies it is parked on) while none went live since. */
+    readonly lastFailure: ChordError | undefined;
+    /** Its instance id while it activates on this host (Q5); `undefined` otherwise and over a link. */
+    readonly activationId: string | undefined;
+    /**
+     * Whether it holds up this host's start barrier: an object here without its first outcome (decision (a)); a remote
+     * object never does.
+     */
+    readonly blocksFirstPass: boolean;
+    /** Counts `binding` as a reference; the binding reads `state` itself. */
+    hold(binding: Binding): void;
+    /** `binding` was released. */
+    unhold(binding: Binding): void;
+    /** Calls a method of the live object for `caller`, bound at `version` (an older one is mapped, Q10). */
+    call(method: string, args: unknown, context: Context, caller: Caller, version: number): Promise<unknown>;
+    /**
+     * What a reference of `version` follows for state member `member` now (decision "References are the only
+     * indirection"): the live instance's member (a replica over a link), or nothing (`loading`, or `failed` with the
+     * cause's error), with the member a reference takes its last value from.
+     */
+    followed(member: string, version: number): Followed;
+    /** The instance its references follow now (they attach to it); `undefined` once it stopped changing. */
+    readonly attachable: Attachable | undefined;
+    /** Its live instance (a reference's keys pin there; a new one, they pin again); `undefined` when not live. */
+    readonly instance: unknown;
+    /** The keyed member `member` of the live object: its ultimate slot (slice 6a §12; only local objects have any). */
+    keyedMember(member: string): KeyedSlot;
+    /**
+     * How a consumer of `version` reads keyed member `member`'s documents: mapped back to its version when older
+     * (slice 7b §7), `undefined` when as they are; `contract_mismatch` when the provider refuses it.
+     */
+    keyedMapping(member: string, version: number): ((current: JsonValue) => JsonValue) | undefined;
+    /**
+     * Pins `key` of keyed member `member` on the live instance, loaded, as a consumer of `version` reads it (mapped when
+     * older); only a live local object has keyed members.
+     */
+    pinKey(member: string, key: string, version: number, context: Context): Promise<PinnedKey>;
+    /**
+     * `ref.retry()`, as one step of `walk`: an attempt now if failed; an object parked on failed dependencies passes it
+     * on; ignored otherwise.
+     */
+    retry(walk: RetryWalk): void;
+    /**
+     * The chain of activation waits from this object to `target`, both included (Q5); `undefined` when there is none.
+     * `visited` keeps a search over shared dependencies linear in the waits.
+     */
+    pathTo(target: ChordObject, visited: Set<Target>): ChordObject[] | undefined;
+}
+/** An instance a reference attaches to (`Target.attachable`): it keeps last values in that instance's variant. */
+export type Attachable = {
+    readonly variant: string | undefined;
+};
+/**
+ * What a reference follows of its target for one state member (`Target.followed`): the member of the instance it
+ * follows (`instance`, still changing), a member its live variant lacks (`invalid/member`), or nothing: its target loads
+ * (no call) or failed (one `failed` call with the cause's error); `last` is the member of `instance`, which stopped
+ * changing, that a reference attached to it takes a last value from (never one it never attached to).
+ */
+export type Followed = {
+    readonly kind: "live";
+    readonly source: DeriveSource;
+    readonly instance: unknown;
+} | {
+    readonly kind: "lacking";
+    readonly error: ChordError;
+} | {
+    readonly kind: "loading";
+    readonly last: DeriveSource | undefined;
+    readonly instance: unknown;
+} | {
+    readonly kind: "failed";
+    readonly error: ChordError;
+    readonly last: DeriveSource | undefined;
+    readonly instance: unknown;
+};
+/**
+ * One retry's walk through parked objects on this host (dependency model §3.7, audit A5): the objects it reached (one
+ * reached again, through a diamond, ignores it) and the hop budget a `retry` message to another host carries (none is
+ * sent at 0, so a waiting ring of hosts stops).
+ */
+export type RetryWalk = {
+    readonly visited: Set<ChordObject>;
+    readonly hops: number;
+};
+/** A walk starting here: `ref.retry()`'s, with the first host's budget, or a `retry` message's, with one hop less. */
+export declare function retryWalk(hops?: number): RetryWalk;
+/** A reference's params as L1 checked them, with their identity key. */
+export type CheckedParams = {
+    readonly params: ParamsOf<Contract>;
+    readonly key: string;
+};
+/**
+ * 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 declare class Binding implements Holder, UnboundRequest {
+    #private;
+    readonly reference: Reference<Contract>;
+    /** Who calls through this reference: the principal it was got as, and this host's incarnation. */
+    readonly caller: Caller;
+    constructor(contract: Contract, batch: Batch, dependent: ChordObject | undefined, caller: Caller, parkTimeout: number);
+    /** The consumer's contract: its version is the binding's. Only an unreleased binding is asked. */
+    get contract(): Contract;
+    /** The object whose attempt declared this reference, until it is released. */
+    get dependent(): ChordObject | undefined;
+    /** Whom it acts for (the unbound index's revocation). */
+    get principal(): Principal | undefined;
+    /** The reference's state. */
+    get refState(): RefState;
+    /** The object it is bound to; `undefined` while it is not bound. */
+    get target(): Target | undefined;
+    /** The object in errors: its label once bound, else the contract's name. */
+    get label(): string;
+    /** The error of the object's last failure while none went live since, or of the check that left it unbound. */
+    get lastFailure(): ChordError | 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: Target): void;
+    /** Whether its members or keys were used: `retarget` moves them (in a batch). */
+    get following(): boolean;
+    /**
+     * 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(): void;
+    /**
+     * 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: Removal): void;
+    /**
+     * 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: FailureCause | undefined, place: () => void, leave: () => void): void;
+    /** Woken by the unbound index (out of it already): checked again where it goes. */
+    wake(): void;
+    /**
+     * 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: FailureCause, bind: () => void): void;
+    /**
+     * 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(): void;
+    /** Whether presence lists show it (§19). */
+    get listed(): boolean;
+    /** Keeps it out of presence lists, before it binds: a restart's readiness binding is no consumer of its own. */
+    unlist(): void;
+    /** Resolves once `done(state)` holds, checked now and at every change; rejects at its end or `context`'s abort. */
+    until(done: (state: RefState) => boolean, context: Context): Promise<void>;
+    /** Resolves when the reference is live; rejects with a broken failure's error, or its end. Getters wait for it. */
+    live(context: Context): Promise<void>;
+    /**
+     * 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: string): DeriveSource;
+    /** What a read of a member that never had a value throws: `released`, the failure's error, or `not_ready`. */
+    none(): ChordError;
+    /** The keyed member `member`'s slot (slice 6a §12), as `member` resolves a state member. */
+    keyedSlot(member: string): KeyedSlot;
+    /** How this reference reads keyed member `member`'s documents (`Target.keyedMapping`), as `keyedSlot` resolves. */
+    keyedMapping(member: string): ((current: JsonValue) => JsonValue) | undefined;
+    /**
+     * 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: string, key: string, context: Context): Promise<PinnedKey>;
+    /**
+     * 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).
+     */
+    watch(member: string, context: Context): Promise<Watch<JsonValue>>;
+    /**
+     * 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).
+     */
+    firstValues(context: Context): Promise<void>;
+    /** Resolves once the object's members have values; rejects when the reference fails or is released first. */
+    hydrated(context: Context): Promise<void>;
+    /**
+     * 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<W extends Watch<JsonValue>>(watch: W): W;
+    /**
+     * `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: string, key: string): KeyedMemberAt;
+    /** Whether its object's factory pinned keys on it (`at(key)`). */
+    get pinsKeys(): boolean;
+    /**
+     * 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: Context): Promise<void> | undefined;
+    /**
+     * `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): void;
+    /** Releases the reference (idempotent); the object may end when it was its last. */
+    release(): void;
+    /**
+     * 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: ChordError): void;
+}
+/**
+ * `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).
+ */
+declare class KeyedMemberAt {
+    #private;
+    readonly member: string;
+    readonly key: string;
+    constructor(binding: Binding, member: string, key: string);
+    /** The key's source; `not_ready` before it is held, `released` after. */
+    get source(): DeriveSource;
+    get value(): JsonValue;
+    watch(context: Context): Promise<Watch<JsonValue>>;
+    /**
+     * 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).
+     */
+    pin(binding: Binding, context: Context): Promise<void>;
+    /** Releases the pin and drops the source (once). */
+    release(): void;
+}
+/**
+ * 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 declare function resolveKeyed(value: unknown): KeyedBinding | 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 declare function resolveWatchable(value: unknown): DeriveSource | undefined;
+export {};
+//# sourceMappingURL=reference.d.ts.map

package/dist/host/reference.d.ts.map

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