@earendil-works/chord 1.4.0 → 1.5.0

package/dist/next/host/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../src/next/host/native.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAmB,MAAM,wBAAwB,CAAC;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,0HAA0H;AAC1H,MAAM,MAAM,iBAAiB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEpH,yBAAyB;AACzB,MAAM,WAAW,MAAM,CAAC,CAAC;IACxB,0GAA0G;IAC1G,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CAClB;AAED,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GAAG;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,uCAAuC;AACvC,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC,CAAC;AAEhF;;;GAGG;AACH,KAAK,WAAW,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CAC5C,CAAC;AAEF,kFAAkF;AAClF,MAAM,WAAW,UAAU;IAC1B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,KAAK,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;CACnE;AAUD,2EAA2E;AAC3E,qBAAa,YAAY,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU;;IAO5D,YACC,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,EACtC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACtF,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,WAAW,EAMlB;IAED,IAAI,KAAK,IAAI,CAAC,CAQb;IAED,+GAA+G;IACzG,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1C;IAED,gHAAgH;IAC1G,KAAK,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAIvE;CAqCD;AAED,8GAA8G;AAC9G,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAUlG;AAED,qGAAqG;AACrG,wBAAsB,OAAO,CAC5B,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EACjC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACR,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAEhC"}

package/dist/next/host/native.js

@@ -0,0 +1,92 @@
+// Natives (§13): the handle `self.open` returns, a value opened during activation and closed with a reason when its
+// attempt ends; `within`, which bounds a close or a drain by a timeout; and the drain's admission of running work.
+import { withAbortSignal } from "../../context/index.js";
+import { ChordError } from "../data/index.js";
+/** One native of one attempt: opened at most once, closed exactly once. */
+export class NativeHandle {
+    #open;
+    #close;
+    #closeTimeout;
+    #owner;
+    #state = { kind: "unopened" };
+    constructor(open, close, closeTimeout, owner) {
+        this.#open = open;
+        this.#close = close;
+        this.#closeTimeout = closeTimeout;
+        this.#owner = owner;
+    }
+    get value() {
+        const state = this.#state;
+        if (state.kind === "open")
+            return state.value;
+        const name = this.#name();
+        if (state.kind === "unopened" || state.kind === "opening") {
+            throw new ChordError({ code: "not_ready", message: `${name}: not open yet` });
+        }
+        throw new ChordError({ code: "released", reason: "closed", message: `${name}: closed` });
+    }
+    /** Opens the value; one that arrives after its attempt was abandoned is closed at once, a failure reported. */
+    async open(context) {
+        this.#state = { kind: "opening" };
+        await this.#opened(await this.#open(context));
+    }
+    /** Closes the value if it is open (a pending open's value is closed when it arrives); resolves with a throw. */
+    async close(reason) {
+        const state = this.#state;
+        this.#state = state.kind === "opening" ? { kind: "abandoned", reason } : { kind: "closed" };
+        return state.kind === "open" ? this.#closeValue(state.value, reason) : undefined;
+    }
+    /** Keeps the value an open resolved with, or closes it at once when the native was closed meanwhile. */
+    async #opened(value) {
+        const state = this.#state;
+        if (state.kind !== "abandoned") {
+            this.#state = { kind: "open", value };
+            return;
+        }
+        this.#state = { kind: "closed" };
+        const failure = await this.#closeValue(value, state.reason);
+        if (failure !== undefined)
+            this.#owner.report(failure);
+    }
+    /**
+     * Runs the close under the object's context, aborted at the close timeout, and waits for it up to then; longer is
+     * reported.
+     */
+    async #closeValue(value, reason) {
+        const { object, position, context, report } = this.#owner;
+        const at = { object, native: { kind: "native", position } };
+        const timeout = new AbortController();
+        const closing = (async () => this.#close(value, reason, withAbortSignal(timeout.signal, context)))();
+        try {
+            if ((await within(closing, this.#closeTimeout)) === "timeout") {
+                timeout.abort(new ChordError({ code: "aborted", message: `${this.#name()}: close timed out` }));
+                report({ kind: "close_timeout", ...at });
+            }
+            return undefined;
+        }
+        catch (error) {
+            return { kind: "close_failed", ...at, error };
+        }
+    }
+    #name() {
+        return `${this.#owner.object} native #${this.#owner.position}`;
+    }
+}
+/** Whether `promise` settled within `ms` (it rejects when `promise` does first); `promise` itself runs on. */
+export async function within(promise, ms) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(resolve, ms, "timeout");
+    });
+    try {
+        return await Promise.race([promise.then(() => "settled"), timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Whether the `size` pieces of work in `drain` settled within `ms` (at once when there is none). */
+export async function drained(drain, size, ms) {
+    return size === 0 ? "settled" : within(Promise.allSettled(drain), ms);
+}
+//# sourceMappingURL=native.js.map

package/dist/next/host/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../../../src/next/host/native.ts"],"names":[],"mappings":"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","sourcesContent":["// Natives (§13): the handle `self.open` returns, a value opened during activation and closed with a reason when its\n// attempt ends; `within`, which bounds a close or a drain by a timeout; and the drain's admission of running work.\n\nimport { type Context, withAbortSignal } from \"../../context/index.ts\";\nimport { ChordError } from \"../data/index.ts\";\nimport type { HostError } from \"./host.ts\";\n\n/** Why a native closes: its object ended or its attempt failed (`end`), the host closes (`close`), a reload (slice 7). */\nexport type NativeCloseReason = { readonly kind: \"end\" } | { readonly kind: \"close\" } | { readonly kind: \"reload\" };\n\n/** A native's handle. */\nexport interface Native<T> {\n\t/** The opened value: throws `not_ready` until its open resolved and `released` once its close started. */\n\treadonly value: T;\n}\n\n/** What `self.open` takes besides the open and the close. */\nexport type NativeOptions = {\n\t/** How long its close may take; the host's `closeTimeout` by default. */\n\treadonly closeTimeout?: number;\n};\n\n/** A close that threw, as reported. */\nexport type CloseFailed = Extract<HostError, { readonly kind: \"close_failed\" }>;\n\n/**\n * Where a native belongs: its object's label and its position in declaration order (from 1) for errors and reports,\n * the object's context (every close runs under it, never under the aborted opener's), and where it reports.\n */\ntype NativeOwner = {\n\treadonly object: string;\n\treadonly position: number;\n\treadonly context: Context;\n\treadonly report: (error: HostError) => void;\n};\n\n/** What an attempt does with each of its natives, whatever their value's type. */\nexport interface NativeSlot {\n\topen(context: Context): Promise<void>;\n\tclose(reason: NativeCloseReason): Promise<CloseFailed | undefined>;\n}\n\n/** Where a native stands. `abandoned`: closed while its open was pending, so the late value is closed at once. */\ntype NativeState<T> =\n\t| { readonly kind: \"unopened\" }\n\t| { readonly kind: \"opening\" }\n\t| { readonly kind: \"open\"; readonly value: T }\n\t| { readonly kind: \"abandoned\"; readonly reason: NativeCloseReason }\n\t| { readonly kind: \"closed\" };\n\n/** One native of one attempt: opened at most once, closed exactly once. */\nexport class NativeHandle<T> implements Native<T>, NativeSlot {\n\treadonly #open: (context: Context) => Promise<T>;\n\treadonly #close: (value: T, reason: NativeCloseReason, context: Context) => void | Promise<void>;\n\treadonly #closeTimeout: number;\n\treadonly #owner: NativeOwner;\n\t#state: NativeState<T> = { kind: \"unopened\" };\n\n\tconstructor(\n\t\topen: (context: Context) => Promise<T>,\n\t\tclose: (value: T, reason: NativeCloseReason, context: Context) => void | Promise<void>,\n\t\tcloseTimeout: number,\n\t\towner: NativeOwner,\n\t) {\n\t\tthis.#open = open;\n\t\tthis.#close = close;\n\t\tthis.#closeTimeout = closeTimeout;\n\t\tthis.#owner = owner;\n\t}\n\n\tget value(): T {\n\t\tconst state = this.#state;\n\t\tif (state.kind === \"open\") return state.value;\n\t\tconst name = this.#name();\n\t\tif (state.kind === \"unopened\" || state.kind === \"opening\") {\n\t\t\tthrow new ChordError({ code: \"not_ready\", message: `${name}: not open yet` });\n\t\t}\n\t\tthrow new ChordError({ code: \"released\", reason: \"closed\", message: `${name}: closed` });\n\t}\n\n\t/** Opens the value; one that arrives after its attempt was abandoned is closed at once, a failure reported. */\n\tasync open(context: Context): Promise<void> {\n\t\tthis.#state = { kind: \"opening\" };\n\t\tawait this.#opened(await this.#open(context));\n\t}\n\n\t/** Closes the value if it is open (a pending open's value is closed when it arrives); resolves with a throw. */\n\tasync close(reason: NativeCloseReason): Promise<CloseFailed | undefined> {\n\t\tconst state = this.#state;\n\t\tthis.#state = state.kind === \"opening\" ? { kind: \"abandoned\", reason } : { kind: \"closed\" };\n\t\treturn state.kind === \"open\" ? this.#closeValue(state.value, reason) : undefined;\n\t}\n\n\t/** Keeps the value an open resolved with, or closes it at once when the native was closed meanwhile. */\n\tasync #opened(value: T): Promise<void> {\n\t\tconst state = this.#state;\n\t\tif (state.kind !== \"abandoned\") {\n\t\t\tthis.#state = { kind: \"open\", value };\n\t\t\treturn;\n\t\t}\n\t\tthis.#state = { kind: \"closed\" };\n\t\tconst failure = await this.#closeValue(value, state.reason);\n\t\tif (failure !== undefined) this.#owner.report(failure);\n\t}\n\n\t/**\n\t * Runs the close under the object's context, aborted at the close timeout, and waits for it up to then; longer is\n\t * reported.\n\t */\n\tasync #closeValue(value: T, reason: NativeCloseReason): Promise<CloseFailed | undefined> {\n\t\tconst { object, position, context, report } = this.#owner;\n\t\tconst at = { object, native: { kind: \"native\", position } } as const;\n\t\tconst timeout = new AbortController();\n\t\tconst closing = (async () => this.#close(value, reason, withAbortSignal(timeout.signal, context)))();\n\t\ttry {\n\t\t\tif ((await within(closing, this.#closeTimeout)) === \"timeout\") {\n\t\t\t\ttimeout.abort(new ChordError({ code: \"aborted\", message: `${this.#name()}: close timed out` }));\n\t\t\t\treport({ kind: \"close_timeout\", ...at });\n\t\t\t}\n\t\t\treturn undefined;\n\t\t} catch (error) {\n\t\t\treturn { kind: \"close_failed\", ...at, error };\n\t\t}\n\t}\n\n\t#name(): string {\n\t\treturn `${this.#owner.object} native #${this.#owner.position}`;\n\t}\n}\n\n/** Whether `promise` settled within `ms` (it rejects when `promise` does first); `promise` itself runs on. */\nexport async function within(promise: Promise<unknown>, ms: number): Promise<\"settled\" | \"timeout\"> {\n\tlet timer: ReturnType<typeof setTimeout> | undefined;\n\tconst timeout = new Promise<\"timeout\">((resolve) => {\n\t\ttimer = setTimeout(resolve, ms, \"timeout\");\n\t});\n\ttry {\n\t\treturn await Promise.race([promise.then(() => \"settled\" as const), timeout]);\n\t} finally {\n\t\tclearTimeout(timer);\n\t}\n}\n\n/** Whether the `size` pieces of work in `drain` settled within `ms` (at once when there is none). */\nexport async function drained(\n\tdrain: Iterable<Promise<unknown>>,\n\tsize: number,\n\tms: number,\n): Promise<\"settled\" | \"timeout\"> {\n\treturn size === 0 ? \"settled\" : within(Promise.allSettled(drain), ms);\n}\n"]}

package/dist/next/host/object.d.ts

@@ -0,0 +1,290 @@
+import { type Context } from "../../context/index.ts";
+import type { JsonValue } from "../../json.ts";
+import type { Contract, ParamsOf } from "../contracts/index.ts";
+import type { ContractShape } from "../contracts/internal.ts";
+import { ChordError, type FailureCause, type Principal } from "../data/index.ts";
+import { type Provider } from "../data/internal.ts";
+import { Documents, type KeyedSlot } from "../documents/internal.ts";
+import type { JobDefinition } from "../jobs/index.ts";
+import { JobRecords } from "../jobs/internal.ts";
+import type { DeriveSource } from "../state/internal.ts";
+import { Attempt, type PinnedKey, type Self } from "./attempt.ts";
+import type { Caller } from "./ctx.ts";
+import type { Dependency } from "./dependencies.ts";
+import type { AnyHost } from "./host.ts";
+import type { CloseFailed } from "./native.ts";
+import { type RefState } from "./ref-state.ts";
+import { type CheckedParams, type Followed, type RetryWalk, type Target } from "./reference.ts";
+import { type RetrySource } from "./retry-on.ts";
+import { type Recorded } from "./staging.ts";
+/** A `local` contract, as a served type has it. */
+export type LocalContract = Contract<ContractShape & {
+    readonly kind: "local";
+}>;
+/** A `remote` contract, as a served type has it. */
+export type RemoteContract = Contract<ContractShape & {
+    readonly kind: "remote";
+}>;
+/**
+ * A type served on a host, by kind: its contract, factory (a remote one gets the object's principal) and argument
+ * checks. Factories are plugin code: what they return is checked at activation.
+ */
+export type Served = (ServedType<LocalContract> & {
+    readonly kind: "local";
+    readonly factory: (params: ParamsOf<Contract>, self: Self) => unknown;
+    /** A type with empty params: its object lives as long as the host (Q-A). */
+    readonly hostLifetime: boolean;
+}) | (ServedType<RemoteContract> & {
+    readonly kind: "remote";
+    readonly factory: (params: ParamsOf<Contract>, principal: Principal, self: Self) => unknown;
+});
+type ServedType<C extends Contract> = {
+    /** The plugin whose facet served it: its objects contribute to registries by it. */
+    readonly plugin: string;
+    readonly contract: C;
+    readonly provider: Provider<Contract>;
+    /** How long a live object stays live after its last reference, in milliseconds (`serve`'s `linger`, 0 by default). */
+    readonly linger: number;
+};
+/** What holds an object: a reference's binding, or a hold arriving over a link. */
+export interface Holder {
+    /** The object whose attempt declared the reference: it checks its dependencies again when this object changes. */
+    readonly dependent: ChordObject | undefined;
+    /** Whom the reference acts for, with its origin's incarnation (`host.references`). */
+    readonly caller: Caller;
+    /** The consumer's contract version and fingerprint (its request's): the provider binds it or it waits unbound. */
+    readonly contract: {
+        readonly version: number;
+        readonly fingerprint: string;
+    };
+    /**
+     * Inside a batch, before `moved`: what it follows of the object changed (`ChordObject.followed`): a reference moves its
+     * members' subscriptions to the new instance, or keeps their last values; a hold over a link has nothing to do here.
+     */
+    retarget(): void;
+    /** Whether `retarget` moves anything (a reference whose members or keys were used): it then runs in a batch. */
+    readonly following: boolean;
+    /** The object's state (`state`) changed: an attempt started after a failure, it went live, or it failed. */
+    moved(): void;
+    /** The object ended with `error`. */
+    end(error: ChordError): void;
+    /**
+     * The object ended because a reload removed its type (slice 7b §6): the holder's request is not ended; it waits
+     * unbound with `removal.cause` (`not_served`) until a publication serves the name again.
+     */
+    removed(removal: Removal): void;
+}
+/**
+ * What an object tells holders it leaves: why they wait (`not_served` after a removal, `contract_mismatch` after a
+ * version refusal), its params (they place their requests again) and its context. A reference keeps its last values
+ * meanwhile and moves its subscriptions to the next object of the identity that serves its version (one frame).
+ */
+export type Removal = {
+    readonly cause: FailureCause;
+    readonly host: AnyHost;
+    readonly params: CheckedParams;
+    readonly context: Context;
+};
+/** What a reload does to a live, activating, parked or failed object whose type is still served (slice 7b §4). */
+export type ReloadFate = "swap" | "restart" | "retry";
+/**
+ * One object. Each attempt is a fresh `Attempt`; the documents, the line, the job runs and the holders outlive it. An
+ * attempt parked on its dependencies waits for them without a timer; a transient failure (its own) is retried after its
+ * backoff window, or at once when a reference asks (`retry`); a broken one stays failed until a reference asks.
+ * The object ends with its last reference, a live one after its type's `linger` (never, for a host-lifetime object),
+ * or when the host closes.
+ */
+export declare class ChordObject implements Target {
+    #private;
+    readonly host: AnyHost;
+    /** Its served type: replaced by a reload that swaps, restarts or retries it. */
+    served: Served;
+    readonly params: ParamsOf<Contract>;
+    /** Its params' identity key (empty for empty params). */
+    readonly key: string;
+    /** The principal in a remote object's identity, which its factory gets; `undefined` for a local object. */
+    readonly principal: Principal | undefined;
+    readonly identity: string;
+    /** The object in errors, reports and cycles: its type, and its params key when it has params. */
+    readonly label: string;
+    /**
+     * The activation chain it was created for (Q5): the instance ids of the activations waiting for it, from the hold
+     * that created it (a trusted link's) or the activation here that declared it; empty otherwise.
+     */
+    readonly chain: readonly string[];
+    /** Its documents and line, across its attempts. */
+    readonly documents: Documents;
+    constructor(host: AnyHost, served: Served, params: ParamsOf<Contract>, principal: Principal | undefined, key: string, identity: string, context: Context, chain: readonly string[]);
+    /** The object's state as its references show it. */
+    get state(): RefState;
+    /** Whether its state members have values: once live (a local object stays live until it ends). */
+    get hydrated(): boolean;
+    /** Resolves at its first outcome (the start barrier waits for it); never rejects. */
+    get firstOutcome(): Promise<void>;
+    /** Whether it holds up the start barrier: it has no first outcome yet. */
+    get blocksFirstPass(): boolean;
+    /**
+     * The error of its last failure while none went live since: a failed attempt's, or the cause its parked attempt
+     * showed last (kept when the dependency falls back to `loading`, so a getter's deadline names it).
+     */
+    get lastFailure(): ChordError | undefined;
+    /** Its instance id while an attempt activates; `undefined` otherwise (a hold's chain names only activations). */
+    get activationId(): string | undefined;
+    /**
+     * The chain a hold this object's activation makes over a link carries (Q5): its own chain and its instance id, the
+     * last 32; `undefined` when it is not activating.
+     */
+    activationChain(): string[] | undefined;
+    /** Its holders, for a presence list made after they took it. */
+    get holders(): ReadonlySet<Holder>;
+    /** The variant a live remote object's factory chose; `undefined` for a local object and before it is live. */
+    get variant(): string | undefined;
+    /** The live object's state members, as Chord follows them. */
+    get stateMembers(): ReadonlyMap<string, DeriveSource>;
+    /**
+     * Starts an attempt when waiting or failed and returns it; a trigger while an attempt runs (or once live) is ignored.
+     * After a failure the holders are told: their references are loading again.
+     */
+    attempt(): Attempt | undefined;
+    /**
+     * `ref.retry()` and a `retry` message, as a step of `walk` (handled once per walk: a diamond reaches it twice): an
+     * attempt now when failed (a broken one too) or waiting, its backoff window skipped; passed on to the failed
+     * dependencies while parked `failed { waiting }`; ignored otherwise (an attempt runs, or it is live).
+     */
+    retry(walk?: RetryWalk): void;
+    /**
+     * Follows `sources` as its wake signals instead of the last attempt's (`self.retryOn`, right after a factory
+     * returned): a new value retries it while failed, as `ref.retry()` does; one while it activates retries it at once
+     * if that attempt fails; one while live does nothing.
+     */
+    retryOn(sources: readonly RetrySource[]): void;
+    /**
+     * Calls a method of the live object for `caller`, bound at `version` (an older one maps its arguments and result,
+     * Q10). While a reload's pure swap runs, the call waits for its new attempt (the gate), bounded by `readyTimeout`.
+     */
+    call(method: string, args: unknown, context: Context, caller: Caller, version: number): Promise<unknown>;
+    /**
+     * Whether a reload's pure swap runs in place: the new attempt neither parked nor failed yet. Holds stay bound
+     * meanwhile (their calls wait at the gate) and get a fresh `bound` once it is live.
+     */
+    get swapsInPlace(): boolean;
+    /** Whether a consumer of `contract`'s version and fingerprint binds to this object's provider now (R6, Q10). */
+    binds(contract: Contract): boolean;
+    /** Its params as checked, with their identity key. */
+    get checkedParams(): CheckedParams;
+    /**
+     * What a reference of `version` follows for state member `member` now (decision "References are the only
+     * indirection"): the shown instance's member (its mapping at an older version) while that instance is live, while a
+     * swap brings its successor in place, and after a live failure until its admitted commits published; else nothing:
+     * `failed` with the cause's error, or `loading`, with that member to take a last value from.
+     */
+    followed(member: string, version: number): Followed;
+    /**
+     * The instance its references follow now (they attach to it; they take last values only from an instance they
+     * attached to); `undefined` once it stopped changing.
+     */
+    get attachable(): Attempt | undefined;
+    /** The live instance, which references pin their keys on (a new one: they pin again); `undefined` when not live. */
+    get instance(): Attempt | undefined;
+    /** The live instance's state member `member` as a consumer of `version` follows it (a hold over a link). */
+    liveMember(member: string, version: number): DeriveSource;
+    /** How a consumer of `version` reads keyed member `member`'s documents: mapped back when older (`undefined`: as they are). */
+    keyedMapping(member: string, version: number): ((current: JsonValue) => JsonValue) | undefined;
+    /** The keyed member `member` of the live object: its ultimate slot (slice 6a §12). */
+    keyedMember(member: string): KeyedSlot;
+    /** Pins `key` of keyed member `member` on the live instance, as a consumer of `version` reads it (`Attempt.pinKey`). */
+    pinKey(member: string, key: string, version: number, context: Context): Promise<PinnedKey>;
+    /**
+     * Counts `holder` as a reference to this object (the holder reads `state` itself), listed in its type's presence; a
+     * lingering object stays.
+     */
+    hold(holder: Holder): void;
+    /** `holder` was released: the object may end (`#idle`). */
+    unhold(holder: Holder): void;
+    /**
+     * The records of job `definition`'s runs, made by its first declaration. A later declaration (a new attempt's, after a
+     * reload) at another version takes the records over (each run keeps its version, slice 7b §8); one at the same
+     * version with another fingerprint is refused (`checkJob`).
+     */
+    jobRecords(definition: JobDefinition<unknown, unknown, unknown>): JobRecords;
+    /** Refuses a declaration of a job its records cannot take (`JobRecords.check`); a reload's staging checks it too. */
+    checkJob(definition: JobDefinition<unknown, unknown, unknown>): void;
+    /**
+     * Claims table `table` (its SQL name) in the host's store for this object, until its end (slice 6b claims); held by
+     * another owner: `invalid/args`, which fails the declaring factory.
+     */
+    claimTable(table: string): void;
+    /** Claims this object's documents in `namespace` of the host's store, as `claimTable`. */
+    claimDocuments(namespace: string): void;
+    /**
+     * A runtime failure of the live attempt `attempt`: `broken` (a `migrate` failing on access, a stored version newer
+     * than the code, a refused commit) or `transient` (a followed runtime failed, R4): the attempt is sealed and the
+     * object `failed` with `cause`; calls reject with it, holders are told, its references keep their last values once the
+     * admitted commits adopted (`followed`), the natives close in the background (then its references are released),
+     * `onError` gets `object_failed` once. Documents and job runs stay. Recovery: a broken failure by `ref.retry()`, a
+     * transient one after its identity's backoff too (a new attempt, whose members its references follow once live). A
+     * failure of a sealed attempt is ignored, so several at once fail it once.
+     */
+    failLive(attempt: Attempt, cause: FailureCause): void;
+    /**
+     * Adds `delta` to its running and finishing job runs (and `host.activity.jobs`). A new run keeps a lingering object;
+     * the last one settling on an object without references ends it as its last release would (`#idle`).
+     */
+    countRuns(delta: number): void;
+    /**
+     * Throws `invalid/cycle` when waiting for `dependency` closes a chain of waits back to this object (Q5). Every other
+     * object on the chain fails broken with the same error, so no part of a cycle waits for a retry. Counts the objects
+     * it visits (`chord.cycle.visits`). Otherwise, a dependency whose activation is in this object's chain closes a
+     * cycle through other hosts (they fail through their dependency on this one).
+     */
+    assertNoCycle(dependency: Target, context: Context): void;
+    /** Its parked attempt waits for `dependencies` (none once it leaves parking): the waits a cycle check follows. */
+    waitsFor(dependencies: readonly Dependency[]): void;
+    /**
+     * A dependency of its current attempt changed (its state, or its first outcome): a parked attempt checks again; an
+     * attempt past its dependency check ignores it (R18 after live), and so does any other state.
+     */
+    dependencyMoved(): void;
+    /**
+     * Its attempt `attempt` is parked showing `shown` (`loading` or `failed { waiting }`): holders are told when that
+     * changed (a cause compared by value). `firstPass`: no blocker here is still without its first outcome, so this
+     * object has its first outcome now.
+     */
+    parked(attempt: Attempt, shown: RefState, firstPass: boolean): void;
+    /** Its attempt `attempt` left parking for its own steps: it shows `loading` until its outcome. */
+    unparked(attempt: Attempt): void;
+    /**
+     * Ends the object (once): sealed now, its holders and running calls told `error` (`released` by default), torn down
+     * in the background with reason `end`, close failures reported.
+     */
+    end(error?: ChordError): void;
+    /**
+     * Ends the object for `host.close`: sealed now; returns its teardown (reason `close`), which the host runs once every
+     * object is sealed, so no reference it releases starts an ending in the background.
+     */
+    stop(): () => Promise<CloseFailed[]>;
+    /**
+     * Ends the object because a reload removed its type (slice 7b §4): as `end` (natives close with reason `end`,
+     * running calls' callers rejected `released`, handlers drained), but its holders' requests are not ended: they wait
+     * unbound with `cause` (`not_served`), references with their last values, until the next object of its identity
+     * binds them (`Removal`).
+     */
+    remove(cause: FailureCause): void;
+    /**
+     * What a reload with `recorded` (the new factory's declarations) does to this object, whose type is still served:
+     * a live object swaps in place when neither its live attempt nor the new factory opens natives and no table of the
+     * new factory is newer than the store's, else it restarts; any other is retried.
+     */
+    reloadFate(recorded: Recorded): ReloadFate;
+    /**
+     * Takes `fate` with its new served type (after the reload's commit); returns the new attempt, whose first
+     * dependency check the reload's report waits for.
+     */
+    reload(served: Served, fate: ReloadFate): Attempt;
+    /** The `released` error of this object. */
+    ended(): ChordError;
+    /** The chain of waits from this activation to `target` (see `Target`), through its parked attempt's dependencies. */
+    pathTo(target: ChordObject, visited: Set<Target>): ChordObject[] | undefined;
+}
+export {};
+//# sourceMappingURL=object.d.ts.map

package/dist/next/host/object.d.ts.map

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