@earendil-works/chord 1.5.0 → 1.5.1

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":"AAAA,oHAAoH;AACpH,mHAAmH;AAGnH,OAAO,EAAgB,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAmD1E,2EAA2E;AAC3E,MAAM,OAAO,YAAY;IACf,KAAK,CAAmC;IACxC,MAAM,CAAkF;IACxF,aAAa,CAAS;IACtB,MAAM,CAAc;IAC7B,MAAM,GAAmB,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IAE9C,YACC,IAAsC,EACtC,KAAsF,EACtF,YAAoB,EACpB,KAAkB;QAElB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,IAAI,KAAK;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,KAAK,CAAC,KAAK,CAAC;QAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC3D,MAAM,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,IAAI,gBAAgB,EAAE,CAAC,CAAC;QAC/E,CAAC;QACD,MAAM,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,UAAU,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI,CAAC,OAAgB;QAC1B,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;QACjC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YAC9C,OAAO;QACR,CAAC;QACD,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QAC7C,MAAM,UAAU,CAAC,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;YACrG,IAAI,KAAQ,CAAC;YACb,IAAI,CAAC;gBACJ,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;YACxD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,8EAA8E;gBAC9E,KAAK,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;gBACvD,MAAM,KAAK,CAAC;YACb,CAAC;YACD,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,gHAAgH;IAChH,KAAK,CAAC,KAAK,CAAC,MAAyB;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC5F,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAClF,CAAC;IAED,wGAAwG;IACxG,KAAK,CAAC,OAAO,CAAC,KAAQ;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAChC,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;YACtC,OAAO;QACR,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC5D,IAAI,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,KAAQ,EAAE,MAAyB;QACpD,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACxD,IAAI,QAAQ,CAAC,SAAS,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACtF,MAAM,UAAU,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;QACvF,OAAO,UAAU,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;YACtE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;YACjG,IAAI,OAAO,KAAK,SAAS;gBAAE,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3E,OAAO,OAAO,CAAC;QAChB,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,6CAA6C;IAC7C,KAAK,CAAC,YAAY,CAAC,KAAQ,EAAE,MAAyB,EAAE,OAAgB;QACvE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACjD,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAW,CAAC;QACrE,MAAM,OAAO,GAAG,IAAI,eAAe,EAAE,CAAC;QACtC,MAAM,OAAO,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACrG,IAAI,CAAC;YACJ,IAAI,CAAC,MAAM,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;gBAC/D,OAAO,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,mBAAmB,EAAE,CAAC,CAAC,CAAC;gBAChG,MAAM,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;YAC1C,CAAC;YACD,OAAO,SAAS,CAAC;QAClB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC;QAC/C,CAAC;IACF,CAAC;IAED,KAAK;QACJ,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,YAAY,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;IAChE,CAAC;CACD;AAED,8GAA8G;AAC9G,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,OAAyB,EAAE,EAAU;IACjE,IAAI,KAAgD,CAAC;IACrD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAY,CAAC,OAAO,EAAE,EAAE;QAClD,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IACH,IAAI,CAAC;QACJ,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAkB,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9E,CAAC;YAAS,CAAC;QACV,YAAY,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;AACF,CAAC;AAED,qGAAqG;AACrG,MAAM,CAAC,KAAK,UAAU,OAAO,CAC5B,KAAiC,EACjC,IAAY,EACZ,EAAU;IAEV,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;AACvE,CAAC","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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"}