@earendil-works/chord 1.4.0 → 1.5.1

package/dist/host/members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.js","sourceRoot":"","sources":["../../src/host/members.ts"],"names":[],"mappings":"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","sourcesContent":["// The member check (Q14): an implementation is one variant with exactly that variant's members, methods being\n// functions and state members JSON watchables; and the resolution of what Chord follows behind every derive's declared\n// sources (JSON and native) and every contribution to a registry (slice 8).\n//\n// The rule for watches across attempts (decision \"References are the only indirection\"): consumers' watches and\n// derives over another object's member follow it through their reference's member (`reference-source.ts`) and keys\n// (`reference-keys.ts`), passed straight through to the instance's own document or derive. While the object points at\n// nothing they keep their last values (one `failed` call for a failure); when a new instance goes live they move by\n// name to its member (a key pinned there again), whether a document or a derive: one frame from the last value, and\n// every derive downstream recovers (decision \"self healing\"). A re-exposed member is the re-exposing object's\n// reference member: it holds with that object, its provider's source goes on. Holds over a link follow the live\n// instance's members and take a snapshot at each binding.\n\nimport type { Context } from \"../context/index.ts\";\nimport type { Contract } from \"../contracts/index.ts\";\nimport { currentVariants, LOCAL, takesNoArgs, type VariantData } from \"../contracts/internal.ts\";\nimport type { KeyedSlot } from \"../documents/internal.ts\";\nimport {\n\ttype ContributionContent,\n\ttype Contributor,\n\tRegistryContribution,\n\ttype RegistryRecord,\n} from \"../registries/internal.ts\";\nimport { type Derive, type DeriveInput, type DeriveSource, NativeSource } from \"../state/internal.ts\";\nimport { type Binding, resolveKeyed, resolveWatchable } from \"./reference.ts\";\n\n/** A checked implementation, as Chord calls and follows it. */\nexport type Members = {\n\t/** The methods, each called with its arguments (`null` for none) and a context. */\n\treadonly methods: ReadonlyMap<string, Method>;\n\t/** The state members, resolved to what Chord follows. */\n\treadonly state: ReadonlyMap<string, DeriveSource>;\n\t/** The keyed members (slice 6a §12): the object's own slot, or the provider's member it re-exposes. */\n\treadonly keyed: ReadonlyMap<string, KeyedBinding>;\n};\n\n/**\n * What a keyed member is: a keyed document handle's slot (`own`), or another object's keyed member re-exposed through\n * a reference (`reexposed`), which reads end at the ultimate provider's slot (rule 22) and pinned keys follow.\n */\nexport type KeyedBinding =\n\t| { readonly kind: \"own\"; readonly slot: KeyedSlot }\n\t| { readonly kind: \"reexposed\"; readonly binding: Binding; readonly member: string };\n\n/** A method as Chord calls it. */\nexport type Method = (args: unknown, context: Context) => Promise<unknown>;\n\n/**\n * Checks what a factory returned (plugin code): a local contract's members, or a remote contract's `{ variant,\n * members }` naming one of its current variants. Errors name the variant or member (the failure cause adds the\n * object).\n */\nexport function checkImplementation(\n\tcontract: Contract,\n\timplementation: unknown,\n): { readonly variant: string | undefined; readonly members: Members } {\n\tconst variants = currentVariants(contract);\n\tif (contract.kind === \"local\") {\n\t\t// The member check establishes the shape.\n\t\treturn { variant: undefined, members: checkMembers(variants.get(LOCAL)!, implementation as Implementation) };\n\t}\n\t// Plugin code: a remote factory returns `{ variant, members }`, which the checks below establish.\n\tconst { variant, members } = implementation as { readonly variant: string; readonly members: Implementation };\n\tconst data = variants.get(variant);\n\tif (data === undefined) throw new Error(`variant ${JSON.stringify(variant)}: not a variant of ${contract.name}`);\n\treturn { variant, members: checkMembers(data, members) };\n}\n\ntype Implementation = { readonly [member: string]: unknown };\n\n/**\n * Checks members against a variant's (exactly its members, methods being functions, state members JSON watchables and\n * keyed members keyed document handles); a method without arguments is called with the context alone.\n */\nfunction checkMembers({ state, methods, keyed }: VariantData, implementation: Implementation): Members {\n\tfor (const member of Object.keys(implementation)) {\n\t\tif (!state.has(member) && !methods.has(member) && !keyed.has(member)) throw new Error(`${member}: not a member`);\n\t}\n\t// Own properties only: an inherited `toString` is no implementation of a member named so.\n\tconst own = (member: string): unknown =>\n\t\tObject.hasOwn(implementation, member) ? implementation[member] : undefined;\n\tconst checked = {\n\t\tmethods: new Map<string, Method>(),\n\t\tstate: new Map<string, DeriveSource>(),\n\t\tkeyed: new Map<string, KeyedBinding>(),\n\t};\n\tfor (const [member, data] of methods) {\n\t\tconst method = own(member);\n\t\tif (typeof method !== \"function\") throw new Error(`${member}: a method is a function`);\n\t\tconst call: Method = takesNoArgs(data)\n\t\t\t? (_args, context) => method(context)\n\t\t\t: (args, context) => method(args, context);\n\t\tchecked.methods.set(member, call);\n\t}\n\tfor (const member of state.keys()) {\n\t\tconst source = resolveWatchable(own(member));\n\t\tif (source === undefined) throw new Error(`${member}: a state member is a JSON watchable`);\n\t\tchecked.state.set(member, source);\n\t}\n\tfor (const member of keyed.keys()) {\n\t\tconst resolved = resolveKeyed(own(member));\n\t\tif (resolved === undefined) throw new Error(`${member}: a keyed member is a keyed document handle`);\n\t\tchecked.keyed.set(member, resolved);\n\t}\n\treturn checked;\n}\n\n/**\n * Resolves every derive's sources; errors name a derive by the member exposing it, else by its position. `report`\n * makes each derive's failure report, with the member exposing it when there is one (`derive_failed`).\n */\nexport function attachDerives(\n\tderives: readonly Derive[],\n\tstate: ReadonlyMap<string, DeriveSource>,\n\treport: (member: string | undefined) => (error: unknown) => void,\n): void {\n\tconst exposed = new Map<DeriveSource, string>([...state].map(([member, source]) => [source, member]));\n\tderives.forEach((derive, position) => {\n\t\tconst member = exposed.get(derive);\n\t\tconst name = member ?? `derive #${position + 1}`;\n\t\tconst resolve = (source: unknown, index: number): DeriveInput => {\n\t\t\tconst resolved = resolveWatchable(source) ?? (source instanceof NativeSource ? source : undefined);\n\t\t\tif (resolved === undefined) throw new Error(`${name}: source ${index} is not a Chord watchable`);\n\t\t\treturn resolved;\n\t\t};\n\t\tderive.attach(resolve, report(member));\n\t});\n}\n\n/**\n * A contribution of `contributor` at `version` to `record`, as Chord follows it: a Chord watchable (a source, a\n * constant, a document handle, a reference member, a native source: another registry's value too) is followed,\n * anything else is a plain value, whatever methods it has (registries carry natives).\n */\nexport function contributionOf(\n\trecord: RegistryRecord,\n\tcontributor: Contributor,\n\tversion: number,\n\tvalue: unknown,\n): RegistryContribution {\n\treturn new RegistryContribution(record, contributor, version, contentOf(value));\n}\n\n/** What Chord follows behind a contribution: its JSON or native source when it is a Chord watchable. */\nfunction contentOf(value: unknown): ContributionContent {\n\tif (value instanceof NativeSource) return { kind: \"native\", source: value };\n\tconst source = resolveWatchable(value);\n\treturn source === undefined ? { kind: \"plain\", value } : { kind: \"json\", source };\n}\n"]}

package/dist/host/native.d.ts

@@ -0,0 +1,64 @@
+import type { TelemetryContext } from "@earendil-works/pi-telemetry";
+import { type Context } from "../context/index.ts";
+import type { HostError } from "./host.ts";
+/** Why a native closes: its object ended or its attempt failed (`end`), the host closes (`close`), a reload (slice 7). */
+export type NativeCloseReason = {
+    readonly kind: "end";
+} | {
+    readonly kind: "close";
+} | {
+    readonly kind: "reload";
+};
+/** A native's handle. */
+export interface Native<T> {
+    /** The opened value: throws `not_ready` until its open resolved and `released` once its close started. */
+    readonly value: T;
+}
+/** What `self.open` takes besides the open and the close. */
+export type NativeOptions = {
+    /** How long its close may take; the host's `closeTimeout` by default. */
+    readonly closeTimeout?: number;
+};
+/** A close that threw, as reported. */
+export type CloseFailed = Extract<HostError, {
+    readonly kind: "close_failed";
+}>;
+/**
+ * Where a native belongs: its object's label, type and its position in declaration order (from 1) for errors, reports
+ * and spans, the object's context (every close runs under it, never under the aborted opener's), the host's telemetry
+ * adapter (a close is a root span), and where it reports.
+ */
+type NativeOwner = {
+    readonly object: string;
+    readonly type: string;
+    readonly position: number;
+    readonly context: Context;
+    readonly telemetry: TelemetryContext;
+    /** Its host's `chord.host`. */
+    readonly host: string;
+    readonly report: (error: HostError) => void;
+};
+/** What an attempt does with each of its natives, whatever their value's type. */
+export interface NativeSlot {
+    open(context: Context): Promise<void>;
+    close(reason: NativeCloseReason): Promise<CloseFailed | undefined>;
+}
+/** One native of one attempt: opened at most once, closed exactly once. */
+export declare class NativeHandle<T> implements Native<T>, NativeSlot {
+    #private;
+    constructor(open: (context: Context) => Promise<T>, close: (value: T, reason: NativeCloseReason, context: Context) => void | Promise<void>, closeTimeout: number, owner: NativeOwner);
+    get value(): T;
+    /**
+     * Opens the value in its `chord.open` span (under `context`'s, its attempt's); one that arrives after its attempt was
+     * abandoned is closed at once, a failure reported.
+     */
+    open(context: Context): Promise<void>;
+    /** Closes the value if it is open (a pending open's value is closed when it arrives); resolves with a throw. */
+    close(reason: NativeCloseReason): Promise<CloseFailed | undefined>;
+}
+/** Whether `promise` settled within `ms` (it rejects when `promise` does first); `promise` itself runs on. */
+export declare function within(promise: Promise<unknown>, ms: number): Promise<"settled" | "timeout">;
+/** Whether the `size` pieces of work in `drain` settled within `ms` (at once when there is none). */
+export declare function drained(drain: Iterable<Promise<unknown>>, size: number, ms: number): Promise<"settled" | "timeout">;
+export {};
+//# sourceMappingURL=native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../src/host/native.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,OAAO,EAAkC,MAAM,qBAAqB,CAAC;AAGnF,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;;;;GAIG;AACH,KAAK,WAAW,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,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;;;OAGG;IACG,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAmB1C;IAED,gHAAgH;IAC1G,KAAK,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAIvE;CAiDD;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/host/native.js

@@ -0,0 +1,126 @@
+// 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, withTelemetry } from "../context/index.js";
+import { ChordError } from "../data/index.js";
+import { chordSpans, ended, spanFailed, untraced } from "../telemetry.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 in its `chord.open` span (under `context`'s, its attempt's); one that arrives after its attempt was
+     * abandoned is closed at once, a failure reported.
+     */
+    async open(context) {
+        this.#state = { kind: "opening" };
+        const parent = context.telemetry;
+        if (untraced(parent)) {
+            await this.#opened(await this.#open(context));
+            return;
+        }
+        const { host, type, position } = this.#owner;
+        await chordSpans(parent)("chord.open", { "chord.host": host, type, native: position }, async (span) => {
+            let value;
+            try {
+                value = await this.#open(withTelemetry(span, context));
+            }
+            catch (error) {
+                // An open its attempt abandoned (a deadline, an end) was cancelled: no error.
+                ended(span, "open_failed", error, context.abortSignal);
+                throw error;
+            }
+            await this.#opened(value);
+        });
+    }
+    /** 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 (in a `chord.close` root span), aborted at the close timeout, and waits
+     * for it up to then; longer is reported.
+     */
+    async #closeValue(value, reason) {
+        const { telemetry, host, type, position } = this.#owner;
+        if (untraced(telemetry))
+            return this.#closeWithin(value, reason, this.#owner.context);
+        const attributes = { "chord.host": host, type, native: position, reason: reason.kind };
+        return chordSpans(telemetry)("chord.close", attributes, async (span) => {
+            const failure = await this.#closeWithin(value, reason, withTelemetry(span, this.#owner.context));
+            if (failure !== undefined)
+                spanFailed(span, "close_failed", failure.error);
+            return failure;
+        });
+    }
+    /** `#closeValue`'s close under `context`. */
+    async #closeWithin(value, reason, context) {
+        const { object, position, 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/host/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../../src/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 { TelemetryContext } from \"@earendil-works/pi-telemetry\";\nimport { type Context, withAbortSignal, withTelemetry } from \"../context/index.ts\";\nimport { ChordError } from \"../data/index.ts\";\nimport { chordSpans, ended, spanFailed, untraced } from \"../telemetry.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, type and its position in declaration order (from 1) for errors, reports\n * and spans, the object's context (every close runs under it, never under the aborted opener's), the host's telemetry\n * adapter (a close is a root span), and where it reports.\n */\ntype NativeOwner = {\n\treadonly object: string;\n\treadonly type: string;\n\treadonly position: number;\n\treadonly context: Context;\n\treadonly telemetry: TelemetryContext;\n\t/** Its host's `chord.host`. */\n\treadonly host: string;\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/**\n\t * Opens the value in its `chord.open` span (under `context`'s, its attempt's); one that arrives after its attempt was\n\t * abandoned is closed at once, a failure reported.\n\t */\n\tasync open(context: Context): Promise<void> {\n\t\tthis.#state = { kind: \"opening\" };\n\t\tconst parent = context.telemetry;\n\t\tif (untraced(parent)) {\n\t\t\tawait this.#opened(await this.#open(context));\n\t\t\treturn;\n\t\t}\n\t\tconst { host, type, position } = this.#owner;\n\t\tawait chordSpans(parent)(\"chord.open\", { \"chord.host\": host, type, native: position }, async (span) => {\n\t\t\tlet value: T;\n\t\t\ttry {\n\t\t\t\tvalue = await this.#open(withTelemetry(span, context));\n\t\t\t} catch (error) {\n\t\t\t\t// An open its attempt abandoned (a deadline, an end) was cancelled: no error.\n\t\t\t\tended(span, \"open_failed\", error, context.abortSignal);\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t\tawait this.#opened(value);\n\t\t});\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 (in a `chord.close` root span), aborted at the close timeout, and waits\n\t * for it up to then; longer is reported.\n\t */\n\tasync #closeValue(value: T, reason: NativeCloseReason): Promise<CloseFailed | undefined> {\n\t\tconst { telemetry, host, type, position } = this.#owner;\n\t\tif (untraced(telemetry)) return this.#closeWithin(value, reason, this.#owner.context);\n\t\tconst attributes = { \"chord.host\": host, type, native: position, reason: reason.kind };\n\t\treturn chordSpans(telemetry)(\"chord.close\", attributes, async (span) => {\n\t\t\tconst failure = await this.#closeWithin(value, reason, withTelemetry(span, this.#owner.context));\n\t\t\tif (failure !== undefined) spanFailed(span, \"close_failed\", failure.error);\n\t\t\treturn failure;\n\t\t});\n\t}\n\n\t/** `#closeValue`'s close under `context`. */\n\tasync #closeWithin(value: T, reason: NativeCloseReason, context: Context): Promise<CloseFailed | undefined> {\n\t\tconst { object, position, 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/host/object.d.ts

@@ -0,0 +1,331 @@
+import type { TelemetryContext } from "@earendil-works/pi-telemetry";
+import { type Context } from "../context/index.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 { JsonValue } from "../json.ts";
+import type { DeriveSource } from "../state/internal.ts";
+import { LiveQueries } from "../store/live-query.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 { Request } 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;
+    /** Whether its calls start method spans (`serve`'s `untraced`: not). */
+    readonly traced: boolean;
+};
+/** 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;
+    };
+    /** Whether presence lists show it (§19): not a restart's readiness binding, which is no consumer of its own. */
+    readonly listed: boolean;
+    /**
+     * 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 an object whose type is still served: a live one restarts, any other is retried. */
+export type ReloadFate = "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;
+    /** An object on this host (a reference's target that is not held over a link). */
+    readonly kind = "local";
+    readonly host: AnyHost;
+    /** Its served type: replaced by a reload that 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, trigger: TelemetryContext, 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), and while a
+     * restart's old attempt is open (its consumers check their version through `stateFor`).
+     */
+    get hydrated(): boolean;
+    /**
+     * The state a same-host consumer of `version` and `fingerprint` sees (rule 5): `live` while a restart's open old
+     * attempt binds that version and its successor is not parked on a failure; otherwise `state`.
+     */
+    stateFor(version: number, fingerprint: string): RefState;
+    /** Whether a restart's open old attempt binds `version` and `fingerprint`: its consumers of that version may use it. */
+    oldServes(version: number, fingerprint: string): boolean;
+    /**
+     * A restart's old attempt while it is open (draining, not sealed yet): old work runs on it, and consumers whose
+     * version it binds see it as the live instance; `undefined` otherwise.
+     */
+    get openOldAttempt(): Attempt | undefined;
+    /** Resolves at its first outcome (the start barrier waits for it); never rejects. */
+    get firstOutcome(): Promise<void>;
+    /**
+     * Whether an activation is under way: waiting for its previous instance's teardown, or activating and showing
+     * `loading` (its factory, its natives' opens, a dependency still loading); a parked wait (`failed { waiting }`) is not.
+     */
+    get activating(): boolean;
+    /** 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;
+    /** The span of the activation under way, when one runs and is recorded (getters waiting for it link to it). */
+    get activationSpan(): TelemetryContext | 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 (a restart's open old attempt's meanwhile); `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), its `chord.method` span under `parent` (the caller's span on this host, a call's carrier over a link). While
+     * an attempt activates (a reload's restart, a retry), new work waits for its outcome (the gate); old work runs on a
+     * restart's open old attempt.
+     */
+    call(method: string, args: unknown, context: Context, caller: Caller, version: number, parent?: TelemetryContext): Promise<unknown>;
+    /** 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
+     * restart keeps it open, 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), or a restart's open old
+     * attempt; `undefined` otherwise.
+     */
+    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;
+    /**
+     * What its activation waits for now (reload cycles, rule 6): the objects its parked attempt's dependencies are bound
+     * to, and those whose gate its opener waits at.
+     */
+    waitEdges(): ChordObject[];
+    /** 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;
+    /** Its live queries by table (`self.query`), across its attempts: what its commits writing a table re-run. */
+    get liveQueries(): LiveQueries;
+    /** 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 does to this object, whose type is still served: a live object restarts, any other is retried. */
+    reloadFate(): ReloadFate;
+    /**
+     * Takes `fate` with its new served type (after the reload's commit) and, for a restart, its new factory's requests as
+     * staging recorded them; returns the new attempt, whose first dependency check the reload's report waits for (a
+     * retry's).
+     */
+    reload(served: Served, fate: ReloadFate, requests: readonly Request[]): Attempt;
+    /** Starts a restart's readiness and its successor, once every fate of the reload started (its served types are new). */
+    startSuccessor(): void;
+    /** What a restart's readiness finds now: a failed request the successor waits for, if any (the report's). */
+    get readinessCause(): FailureCause | undefined;
+    /** 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/host/object.d.ts.map

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