@earendil-works/chord 1.4.0 → 1.5.0

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

@@ -0,0 +1,65 @@
+import { ChordError, type FailureCause } from "../data/index.ts";
+import type { RegistryValueSource } from "../registries/internal.ts";
+import type { ChordObject } from "./object.ts";
+import { type Failed, type RefState } from "./ref-state.ts";
+import type { Binding } from "./reference.ts";
+/** One declared dependency: a reference (`self.get`) or a registry's value (`self.registry`). */
+export type Dependency = {
+    readonly kind: "reference";
+    readonly binding: Binding;
+} | {
+    readonly kind: "registry";
+    readonly value: RegistryValueSource;
+};
+/** A blocker as `parked_long` names it: a reference's label or `registry <name>`, and whether it loads or failed. */
+export type Blocker = {
+    readonly label: string;
+    readonly state: "loading" | "failed";
+};
+/**
+ * What the dependencies say. `live`: every one is live (hydrated: a reference's members have values). `parked`: what
+ * the attempt shows (`loading`, or `failed { waiting }` naming its first failed blocker), whether its first pass is
+ * over (`firstPass`: no blocker, loading or failed, is an object here still without its first outcome), and its first
+ * blocker in declaration order (`parked_long` names it). `broken`: one failed for a cycle (`invalid/cycle`), for
+ * authority (`forbidden`) or ended: it never comes back by itself.
+ */
+export type Check = {
+    readonly kind: "live";
+} | {
+    readonly kind: "parked";
+    readonly shown: RefState;
+    readonly firstPass: boolean;
+    readonly blocker: Blocker;
+    /** The first blocker in declaration order that is only loading (a reload's report names it). */
+    readonly loadingOn: string | undefined;
+} | {
+    readonly kind: "broken";
+    readonly error: ChordError;
+};
+/** Checks `dependencies` in declaration order (the first failed one is the one the attempt names). */
+export declare function checkDependencies(dependencies: readonly Dependency[]): Check;
+/**
+ * What a reload reports for a parked attempt (slice 7b §4): its failure's cause, or for a blocker that is only
+ * loading a `waiting` cause naming it.
+ */
+export declare function parkedCause(check: Extract<Check, {
+    readonly kind: "parked";
+}>): FailureCause;
+/** A parked attempt's state for a blocker `label` that failed with `error`. */
+export declare function waitingOn(label: string, error: ChordError): Failed;
+/**
+ * The `parked_long` report of one parking episode (dependency model §7, audit A11): once, when the attempt has been
+ * parked longer than `readyTimeout`, whatever its blocker (a ring across hosts started at the same moment stays parked
+ * so, and so does a long wait; nothing fails or retries). The clock and the report's `since` start when the episode
+ * does (its pinned keys' loading included); the report names the blocker of the latest check. Its one timer runs until
+ * the report or the episode's end (`stop`).
+ */
+export declare class ParkedLong {
+    #private;
+    constructor(object: ChordObject);
+    /** What the latest check found blocking. */
+    blockedBy(blocker: Blocker): void;
+    /** The episode ended: no report from now on. */
+    stop(): void;
+}
+//# sourceMappingURL=dependencies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../../../src/next/host/dependencies.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,KAAK,YAAY,EAAgB,MAAM,kBAAkB,CAAC;AAE/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,KAAK,MAAM,EAAW,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,iGAAiG;AACjG,MAAM,MAAM,UAAU,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAEtE,qHAAqH;AACrH,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAE,CAAC;AAEvF;;;;;;GAMG;AACH,MAAM,MAAM,KAAK,GACd;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACA,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,gGAAgG;IAChG,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAI3D,sGAAsG;AACtG,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,SAAS,UAAU,EAAE,GAAG,KAAK,CAuC5E;AAWD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,GAAG,YAAY,CAK5F;AAED,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,qBAAa,UAAU;;IAMtB,YAAY,MAAM,EAAE,WAAW,EAa9B;IAED,4CAA4C;IAC5C,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEhC;IAED,gDAAgD;IAChD,IAAI,IAAI,IAAI,CAEX;CACD"}

package/dist/next/host/dependencies.js

@@ -0,0 +1,115 @@
+// Parked attempts (dependency model §3, §7): the dependency check, what an attempt's declared dependencies (`self.get`
+// references and `self.registry` values) say at one moment: all live, or what the parked attempt shows while one is not
+// (`loading`, `failed { waiting }` naming the nearest blocker and the root cause, or `broken` for a cycle, authority or
+// an ended dependency), whether this host's first pass can count it (no blocker here still without its first outcome,
+// decision (a)), and its first blocker; and the `parked_long` report of a long parking episode.
+import { ChordError, isChordError } from "../data/index.js";
+import { asChordError, waitingFor } from "../data/internal.js";
+import { LOADING } from "./ref-state.js";
+const LIVE = { kind: "live" };
+/** Checks `dependencies` in declaration order (the first failed one is the one the attempt names). */
+export function checkDependencies(dependencies) {
+    let failed;
+    let firstPass = true;
+    let blocker;
+    let loadingOn;
+    for (const dependency of dependencies) {
+        if (dependency.kind === "registry") {
+            const { value } = dependency;
+            const start = value.start();
+            if (start.kind === "value" || start.last !== undefined)
+                continue;
+            const label = `registry ${value.name}`;
+            failed ??= waitingOn(label, asChordError(start.error, label));
+            blocker ??= { label, state: "failed" };
+            continue;
+        }
+        const { binding } = dependency;
+        const state = binding.refState;
+        switch (state.kind) {
+            case "live":
+                continue;
+            case "ended":
+                return { kind: "broken", error: state.error };
+            case "failed": {
+                const { error } = state.cause;
+                if (healsNever(error))
+                    return { kind: "broken", error };
+                failed ??= waitingOn(binding.label, error);
+                blocker ??= { label: binding.label, state: "failed" };
+                // Parked `waiting` on something here still in its first attempt: no first outcome yet (fix round 1).
+                if (binding.target?.blocksFirstPass === true)
+                    firstPass = false;
+                continue;
+            }
+            case "loading":
+                loadingOn ??= binding.label;
+                blocker ??= { label: binding.label, state: "loading" };
+                if (binding.target?.blocksFirstPass === true)
+                    firstPass = false;
+        }
+    }
+    if (blocker === undefined)
+        return LIVE;
+    return { kind: "parked", shown: failed ?? LOADING, firstPass, blocker, loadingOn };
+}
+/**
+ * Whether a dependency failed with `error` never heals by itself, so its dependent breaks too: a cycle
+ * (`invalid/cycle`: it would wait on a ring) or authority (`forbidden`: an `authorize` that refused, M§3.6; only
+ * `retry()` or a reload helps).
+ */
+function healsNever(error) {
+    return (isChordError(error, "invalid") && error.reason === "cycle") || isChordError(error, "forbidden");
+}
+/**
+ * What a reload reports for a parked attempt (slice 7b §4): its failure's cause, or for a blocker that is only
+ * loading a `waiting` cause naming it.
+ */
+export function parkedCause(check) {
+    const { shown } = check;
+    if (shown.kind === "failed")
+        return shown.cause;
+    const label = check.loadingOn ?? "a dependency";
+    return waitingFor(label, new ChordError({ code: "unavailable", message: `${label} is loading` }));
+}
+/** A parked attempt's state for a blocker `label` that failed with `error`. */
+export function waitingOn(label, error) {
+    return { kind: "failed", cause: waitingFor(label, error), retryAt: undefined };
+}
+/**
+ * The `parked_long` report of one parking episode (dependency model §7, audit A11): once, when the attempt has been
+ * parked longer than `readyTimeout`, whatever its blocker (a ring across hosts started at the same moment stays parked
+ * so, and so does a long wait; nothing fails or retries). The clock and the report's `since` start when the episode
+ * does (its pinned keys' loading included); the report names the blocker of the latest check. Its one timer runs until
+ * the report or the episode's end (`stop`).
+ */
+export class ParkedLong {
+    #since = Date.now();
+    #timer;
+    /** The blocker the latest check found. */
+    #blocker;
+    constructor(object) {
+        this.#timer = setTimeout(() => {
+            const blocker = this.#blocker;
+            if (blocker === undefined)
+                return;
+            const { label, state } = blocker;
+            object.host.report({
+                kind: "parked_long",
+                object: object.label,
+                waitingFor: label,
+                state,
+                since: this.#since,
+            });
+        }, object.host.timeouts.ready);
+    }
+    /** What the latest check found blocking. */
+    blockedBy(blocker) {
+        this.#blocker = blocker;
+    }
+    /** The episode ended: no report from now on. */
+    stop() {
+        clearTimeout(this.#timer);
+    }
+}
+//# sourceMappingURL=dependencies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.js","sourceRoot":"","sources":["../../../src/next/host/dependencies.ts"],"names":[],"mappings":"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","sourcesContent":["// Parked attempts (dependency model §3, §7): the dependency check, what an attempt's declared dependencies (`self.get`\n// references and `self.registry` values) say at one moment: all live, or what the parked attempt shows while one is not\n// (`loading`, `failed { waiting }` naming the nearest blocker and the root cause, or `broken` for a cycle, authority or\n// an ended dependency), whether this host's first pass can count it (no blocker here still without its first outcome,\n// decision (a)), and its first blocker; and the `parked_long` report of a long parking episode.\n\nimport { ChordError, type FailureCause, isChordError } from \"../data/index.ts\";\nimport { asChordError, waitingFor } from \"../data/internal.ts\";\nimport type { RegistryValueSource } from \"../registries/internal.ts\";\nimport type { ChordObject } from \"./object.ts\";\nimport { type Failed, LOADING, type RefState } from \"./ref-state.ts\";\nimport type { Binding } from \"./reference.ts\";\n\n/** One declared dependency: a reference (`self.get`) or a registry's value (`self.registry`). */\nexport type Dependency =\n\t| { readonly kind: \"reference\"; readonly binding: Binding }\n\t| { readonly kind: \"registry\"; readonly value: RegistryValueSource };\n\n/** A blocker as `parked_long` names it: a reference's label or `registry <name>`, and whether it loads or failed. */\nexport type Blocker = { readonly label: string; readonly state: \"loading\" | \"failed\" };\n\n/**\n * What the dependencies say. `live`: every one is live (hydrated: a reference's members have values). `parked`: what\n * the attempt shows (`loading`, or `failed { waiting }` naming its first failed blocker), whether its first pass is\n * over (`firstPass`: no blocker, loading or failed, is an object here still without its first outcome), and its first\n * blocker in declaration order (`parked_long` names it). `broken`: one failed for a cycle (`invalid/cycle`), for\n * authority (`forbidden`) or ended: it never comes back by itself.\n */\nexport type Check =\n\t| { readonly kind: \"live\" }\n\t| {\n\t\t\treadonly kind: \"parked\";\n\t\t\treadonly shown: RefState;\n\t\t\treadonly firstPass: boolean;\n\t\t\treadonly blocker: Blocker;\n\t\t\t/** The first blocker in declaration order that is only loading (a reload's report names it). */\n\t\t\treadonly loadingOn: string | undefined;\n\t  }\n\t| { readonly kind: \"broken\"; readonly error: ChordError };\n\nconst LIVE: Check = { kind: \"live\" };\n\n/** Checks `dependencies` in declaration order (the first failed one is the one the attempt names). */\nexport function checkDependencies(dependencies: readonly Dependency[]): Check {\n\tlet failed: Failed | undefined;\n\tlet firstPass = true;\n\tlet blocker: Blocker | undefined;\n\tlet loadingOn: string | undefined;\n\tfor (const dependency of dependencies) {\n\t\tif (dependency.kind === \"registry\") {\n\t\t\tconst { value } = dependency;\n\t\t\tconst start = value.start();\n\t\t\tif (start.kind === \"value\" || start.last !== undefined) continue;\n\t\t\tconst label = `registry ${value.name}`;\n\t\t\tfailed ??= waitingOn(label, asChordError(start.error, label));\n\t\t\tblocker ??= { label, state: \"failed\" };\n\t\t\tcontinue;\n\t\t}\n\t\tconst { binding } = dependency;\n\t\tconst state = binding.refState;\n\t\tswitch (state.kind) {\n\t\t\tcase \"live\":\n\t\t\t\tcontinue;\n\t\t\tcase \"ended\":\n\t\t\t\treturn { kind: \"broken\", error: state.error };\n\t\t\tcase \"failed\": {\n\t\t\t\tconst { error } = state.cause;\n\t\t\t\tif (healsNever(error)) return { kind: \"broken\", error };\n\t\t\t\tfailed ??= waitingOn(binding.label, error);\n\t\t\t\tblocker ??= { label: binding.label, state: \"failed\" };\n\t\t\t\t// Parked `waiting` on something here still in its first attempt: no first outcome yet (fix round 1).\n\t\t\t\tif (binding.target?.blocksFirstPass === true) firstPass = false;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tcase \"loading\":\n\t\t\t\tloadingOn ??= binding.label;\n\t\t\t\tblocker ??= { label: binding.label, state: \"loading\" };\n\t\t\t\tif (binding.target?.blocksFirstPass === true) firstPass = false;\n\t\t}\n\t}\n\tif (blocker === undefined) return LIVE;\n\treturn { kind: \"parked\", shown: failed ?? LOADING, firstPass, blocker, loadingOn };\n}\n\n/**\n * Whether a dependency failed with `error` never heals by itself, so its dependent breaks too: a cycle\n * (`invalid/cycle`: it would wait on a ring) or authority (`forbidden`: an `authorize` that refused, M§3.6; only\n * `retry()` or a reload helps).\n */\nfunction healsNever(error: ChordError): boolean {\n\treturn (isChordError(error, \"invalid\") && error.reason === \"cycle\") || isChordError(error, \"forbidden\");\n}\n\n/**\n * What a reload reports for a parked attempt (slice 7b §4): its failure's cause, or for a blocker that is only\n * loading a `waiting` cause naming it.\n */\nexport function parkedCause(check: Extract<Check, { readonly kind: \"parked\" }>): FailureCause {\n\tconst { shown } = check;\n\tif (shown.kind === \"failed\") return shown.cause;\n\tconst label = check.loadingOn ?? \"a dependency\";\n\treturn waitingFor(label, new ChordError({ code: \"unavailable\", message: `${label} is loading` }));\n}\n\n/** A parked attempt's state for a blocker `label` that failed with `error`. */\nexport function waitingOn(label: string, error: ChordError): Failed {\n\treturn { kind: \"failed\", cause: waitingFor(label, error), retryAt: undefined };\n}\n\n/**\n * The `parked_long` report of one parking episode (dependency model §7, audit A11): once, when the attempt has been\n * parked longer than `readyTimeout`, whatever its blocker (a ring across hosts started at the same moment stays parked\n * so, and so does a long wait; nothing fails or retries). The clock and the report's `since` start when the episode\n * does (its pinned keys' loading included); the report names the blocker of the latest check. Its one timer runs until\n * the report or the episode's end (`stop`).\n */\nexport class ParkedLong {\n\treadonly #since = Date.now();\n\treadonly #timer: ReturnType<typeof setTimeout>;\n\t/** The blocker the latest check found. */\n\t#blocker: Blocker | undefined;\n\n\tconstructor(object: ChordObject) {\n\t\tthis.#timer = setTimeout(() => {\n\t\t\tconst blocker = this.#blocker;\n\t\t\tif (blocker === undefined) return;\n\t\t\tconst { label, state } = blocker;\n\t\t\tobject.host.report({\n\t\t\t\tkind: \"parked_long\",\n\t\t\t\tobject: object.label,\n\t\t\t\twaitingFor: label,\n\t\t\t\tstate,\n\t\t\t\tsince: this.#since,\n\t\t\t});\n\t\t}, object.host.timeouts.ready);\n\t}\n\n\t/** What the latest check found blocking. */\n\tblockedBy(blocker: Blocker): void {\n\t\tthis.#blocker = blocker;\n\t}\n\n\t/** The episode ended: no report from now on. */\n\tstop(): void {\n\t\tclearTimeout(this.#timer);\n\t}\n}\n"]}

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

@@ -0,0 +1,48 @@
+import type { Context } from "../../context/index.ts";
+import type { Address, Contract, ParamsOf } from "../contracts/index.ts";
+import { ChordError, type Principal } from "../data/index.ts";
+import type { WireAddress } from "../link/internal.ts";
+import type { HoldRequest, HostLink, Path } from "../remote/internal.ts";
+import type { Route } from "./route.ts";
+/** Where something is placed: here, or over a path (with the host address it was computed or named with). */
+export type Placed = {
+    readonly kind: "here";
+} | {
+    readonly kind: "path";
+    readonly path: Path;
+    readonly address: WireAddress;
+};
+/** A host's destinations: its address, its routes and its parent path, as the host keeps them. */
+export declare class Destination {
+    #private;
+    constructor(address: Address | undefined, routes: ReadonlyMap<string, Route>, parent: Path);
+    /**
+     * Where a reference to `Type` with `params` made as `principal` goes: here for a local type, and for a remote type
+     * whose host address is this host's, served here or not (the check against what is served is the host's); otherwise
+     * over the route of its host address's kind, or over the parent link (the host address decides where an object
+     * lives: a worker reaches another worker's object of a type it serves too). Throws `invalid/host_address` for a host
+     * address whose params do not fit its kind, `forbidden` when the route refuses, and what a `hostAddress` or
+     * `authorize` throws.
+     */
+    reference(Type: Contract, params: ParamsOf<Contract>, principal: Principal | undefined, context: Context): Placed;
+    /**
+     * Whether a reference to `Type` with `params` goes here: a local type, or a remote one whose host address is this
+     * host's. A `hostAddress` that throws, throws.
+     */
+    placedHere(Type: Contract, params: ParamsOf<Contract>): boolean;
+    /**
+     * Where a hold arriving on `link` acting as `principal` goes, by the address it names: here when it is this host's
+     * (a relay never captures a hold for serving the same name); over the route of its kind; else over the parent link
+     * (waiting for it while it is down), unless it came on the parent link or this host never had one (`unavailable`).
+     * Throws as `reference` does.
+     */
+    hold(request: HoldRequest, link: HostLink, principal: Principal | undefined, context: Context): Placed;
+    /**
+     * The provider's own check of a request placed here for the remote `Type` it serves, with `params` (checked):
+     * `invalid/host_address` when its `hostAddress` puts the object on another host (code skew: the consumer computed
+     * this host), `undefined` when it lives here. A `hostAddress` that throws throws (the provider's own code). The
+     * address a request names only routes it.
+     */
+    misplaced(Type: Contract, params: ParamsOf<Contract>): ChordError | undefined;
+}
+//# sourceMappingURL=destination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"destination.d.ts","sourceRoot":"","sources":["../../../src/next/host/destination.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,6GAA6G;AAC7G,MAAM,MAAM,MAAM,GACf;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAEjF,kGAAkG;AAClG,qBAAa,WAAW;;IAKvB,YAAY,OAAO,EAAE,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,EAIzF;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAKhH;IAED;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,OAAO,CAE9D;IAED;;;;;OAKG;IACH,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CASrG;IAED;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,UAAU,GAAG,SAAS,CAK5E;CAeD"}

package/dist/next/host/destination.js

@@ -0,0 +1,101 @@
+// Destination (§3, section 1's table; dependency model §1): where a reference made on a host, or a hold arriving on one
+// of its links, goes, by address alone: here when the address is this host's (served here or not), else over the
+// route of its host address's kind, or over the parent link; and the check that an object served here lives here.
+import { contractData } from "../contracts/internal.js";
+import { ChordError } from "../data/index.js";
+import { invalid } from "../data/internal.js";
+/** A host's destinations: its address, its routes and its parent path, as the host keeps them. */
+export class Destination {
+    #address;
+    #routes;
+    #parent;
+    constructor(address, routes, parent) {
+        this.#address = address;
+        this.#routes = routes;
+        this.#parent = parent;
+    }
+    /**
+     * Where a reference to `Type` with `params` made as `principal` goes: here for a local type, and for a remote type
+     * whose host address is this host's, served here or not (the check against what is served is the host's); otherwise
+     * over the route of its host address's kind, or over the parent link (the host address decides where an object
+     * lives: a worker reaches another worker's object of a type it serves too). Throws `invalid/host_address` for a host
+     * address whose params do not fit its kind, `forbidden` when the route refuses, and what a `hostAddress` or
+     * `authorize` throws.
+     */
+    reference(Type, params, principal, context) {
+        if (Type.kind === "local")
+            return HERE;
+        const address = hostAddressOf(Type, params);
+        if (this.#isHere(address))
+            return HERE;
+        return { kind: "path", path: this.#pathTo(address, principal, context) ?? this.#parent, address };
+    }
+    /**
+     * Whether a reference to `Type` with `params` goes here: a local type, or a remote one whose host address is this
+     * host's. A `hostAddress` that throws, throws.
+     */
+    placedHere(Type, params) {
+        return Type.kind === "local" || this.#isHere(hostAddressOf(Type, params));
+    }
+    /**
+     * Where a hold arriving on `link` acting as `principal` goes, by the address it names: here when it is this host's
+     * (a relay never captures a hold for serving the same name); over the route of its kind; else over the parent link
+     * (waiting for it while it is down), unless it came on the parent link or this host never had one (`unavailable`).
+     * Throws as `reference` does.
+     */
+    hold(request, link, principal, context) {
+        const { address } = request;
+        if (this.#isHere(address))
+            return HERE;
+        const routed = this.#pathTo(address, principal, context);
+        if (routed !== undefined)
+            return { kind: "path", path: routed, address };
+        if (link.role === "parent" || !this.#parent.linked) {
+            throw new ChordError({ code: "unavailable", message: `${request.type} is not served here` });
+        }
+        return { kind: "path", path: this.#parent, address };
+    }
+    /**
+     * The provider's own check of a request placed here for the remote `Type` it serves, with `params` (checked):
+     * `invalid/host_address` when its `hostAddress` puts the object on another host (code skew: the consumer computed
+     * this host), `undefined` when it lives here. A `hostAddress` that throws throws (the provider's own code). The
+     * address a request names only routes it.
+     */
+    misplaced(Type, params) {
+        const address = hostAddressOf(Type, params);
+        if (this.#isHere(address))
+            return undefined;
+        // A host serving a remote type has an address (`serve` refuses one without).
+        return invalid("host_address", `${Type.name}: placed on ${address.kind}, this host is ${this.#address.key}`);
+    }
+    /**
+     * The path to `address` when this host routes its kind (its params checked, `authorize` run for `principal`);
+     * `undefined` without a route for its kind.
+     */
+    #pathTo(address, principal, context) {
+        return this.#routes.get(address.kind)?.path(address.params, principal, context);
+    }
+    /** Whether an object whose host address is `address` lives here: this host has that address. */
+    #isHere(address) {
+        const own = this.#address;
+        return own !== undefined && sameAddress(own, address);
+    }
+}
+const HERE = { kind: "here" };
+/** The address a remote `Type`'s `hostAddress` computes for `params`. */
+function hostAddressOf(Type, params) {
+    // Every remote contract has one (declaration policy, `remote`).
+    const hostAddress = contractData(Type).hostAddress;
+    // Plugin code: what it returns is checked where it is routed or served.
+    const { kind, params: values } = hostAddress(params);
+    return { kind, params: values };
+}
+/** Whether `address` names the host at `own`: the same kind and the same value for each of its params. */
+function sameAddress(own, address) {
+    if (own.kind !== address.kind || typeof address.params !== "object" || address.params === null)
+        return false;
+    const values = address.params;
+    const fields = Object.keys(own.params);
+    return Object.keys(values).length === fields.length && fields.every((field) => values[field] === own.params[field]);
+}
+//# sourceMappingURL=destination.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"destination.js","sourceRoot":"","sources":["../../../src/next/host/destination.ts"],"names":[],"mappings":"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","sourcesContent":["// Destination (§3, section 1's table; dependency model §1): where a reference made on a host, or a hold arriving on one\n// of its links, goes, by address alone: here when the address is this host's (served here or not), else over the\n// route of its host address's kind, or over the parent link; and the check that an object served here lives here.\n\nimport type { Context } from \"../../context/index.ts\";\nimport type { Address, Contract, ParamsOf } from \"../contracts/index.ts\";\nimport { contractData } from \"../contracts/internal.ts\";\nimport { ChordError, type Principal } from \"../data/index.ts\";\nimport { invalid } from \"../data/internal.ts\";\nimport type { WireAddress } from \"../link/internal.ts\";\nimport type { HoldRequest, HostLink, Path } from \"../remote/internal.ts\";\nimport type { Route } from \"./route.ts\";\n\n/** Where something is placed: here, or over a path (with the host address it was computed or named with). */\nexport type Placed =\n\t| { readonly kind: \"here\" }\n\t| { readonly kind: \"path\"; readonly path: Path; readonly address: WireAddress };\n\n/** A host's destinations: its address, its routes and its parent path, as the host keeps them. */\nexport class Destination {\n\treadonly #address: Address | undefined;\n\treadonly #routes: ReadonlyMap<string, Route>;\n\treadonly #parent: Path;\n\n\tconstructor(address: Address | undefined, routes: ReadonlyMap<string, Route>, parent: Path) {\n\t\tthis.#address = address;\n\t\tthis.#routes = routes;\n\t\tthis.#parent = parent;\n\t}\n\n\t/**\n\t * Where a reference to `Type` with `params` made as `principal` goes: here for a local type, and for a remote type\n\t * whose host address is this host's, served here or not (the check against what is served is the host's); otherwise\n\t * over the route of its host address's kind, or over the parent link (the host address decides where an object\n\t * lives: a worker reaches another worker's object of a type it serves too). Throws `invalid/host_address` for a host\n\t * address whose params do not fit its kind, `forbidden` when the route refuses, and what a `hostAddress` or\n\t * `authorize` throws.\n\t */\n\treference(Type: Contract, params: ParamsOf<Contract>, principal: Principal | undefined, context: Context): Placed {\n\t\tif (Type.kind === \"local\") return HERE;\n\t\tconst address = hostAddressOf(Type, params);\n\t\tif (this.#isHere(address)) return HERE;\n\t\treturn { kind: \"path\", path: this.#pathTo(address, principal, context) ?? this.#parent, address };\n\t}\n\n\t/**\n\t * Whether a reference to `Type` with `params` goes here: a local type, or a remote one whose host address is this\n\t * host's. A `hostAddress` that throws, throws.\n\t */\n\tplacedHere(Type: Contract, params: ParamsOf<Contract>): boolean {\n\t\treturn Type.kind === \"local\" || this.#isHere(hostAddressOf(Type, params));\n\t}\n\n\t/**\n\t * Where a hold arriving on `link` acting as `principal` goes, by the address it names: here when it is this host's\n\t * (a relay never captures a hold for serving the same name); over the route of its kind; else over the parent link\n\t * (waiting for it while it is down), unless it came on the parent link or this host never had one (`unavailable`).\n\t * Throws as `reference` does.\n\t */\n\thold(request: HoldRequest, link: HostLink, principal: Principal | undefined, context: Context): Placed {\n\t\tconst { address } = request;\n\t\tif (this.#isHere(address)) return HERE;\n\t\tconst routed = this.#pathTo(address, principal, context);\n\t\tif (routed !== undefined) return { kind: \"path\", path: routed, address };\n\t\tif (link.role === \"parent\" || !this.#parent.linked) {\n\t\t\tthrow new ChordError({ code: \"unavailable\", message: `${request.type} is not served here` });\n\t\t}\n\t\treturn { kind: \"path\", path: this.#parent, address };\n\t}\n\n\t/**\n\t * The provider's own check of a request placed here for the remote `Type` it serves, with `params` (checked):\n\t * `invalid/host_address` when its `hostAddress` puts the object on another host (code skew: the consumer computed\n\t * this host), `undefined` when it lives here. A `hostAddress` that throws throws (the provider's own code). The\n\t * address a request names only routes it.\n\t */\n\tmisplaced(Type: Contract, params: ParamsOf<Contract>): ChordError | undefined {\n\t\tconst address = hostAddressOf(Type, params);\n\t\tif (this.#isHere(address)) return undefined;\n\t\t// A host serving a remote type has an address (`serve` refuses one without).\n\t\treturn invalid(\"host_address\", `${Type.name}: placed on ${address.kind}, this host is ${this.#address!.key}`);\n\t}\n\n\t/**\n\t * The path to `address` when this host routes its kind (its params checked, `authorize` run for `principal`);\n\t * `undefined` without a route for its kind.\n\t */\n\t#pathTo(address: WireAddress, principal: Principal | undefined, context: Context): Path | undefined {\n\t\treturn this.#routes.get(address.kind)?.path(address.params, principal, context);\n\t}\n\n\t/** Whether an object whose host address is `address` lives here: this host has that address. */\n\t#isHere(address: WireAddress): boolean {\n\t\tconst own = this.#address;\n\t\treturn own !== undefined && sameAddress(own, address);\n\t}\n}\n\nconst HERE: Placed = { kind: \"here\" };\n\n/** The address a remote `Type`'s `hostAddress` computes for `params`. */\nfunction hostAddressOf(Type: Contract, params: ParamsOf<Contract>): WireAddress {\n\t// Every remote contract has one (declaration policy, `remote`).\n\tconst hostAddress = contractData(Type).hostAddress!;\n\t// Plugin code: what it returns is checked where it is routed or served.\n\tconst { kind, params: values } = hostAddress(params) as { readonly kind: string; readonly params: unknown };\n\treturn { kind, params: values };\n}\n\n/** Whether `address` names the host at `own`: the same kind and the same value for each of its params. */\nfunction sameAddress(own: Address, address: WireAddress): boolean {\n\tif (own.kind !== address.kind || typeof address.params !== \"object\" || address.params === null) return false;\n\tconst values = address.params as { readonly [field: string]: unknown };\n\tconst fields = Object.keys(own.params);\n\treturn Object.keys(values).length === fields.length && fields.every((field) => values[field] === own.params[field]);\n}\n"]}

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

@@ -0,0 +1,79 @@
+import type { Watchable } from "../../watch.ts";
+import type { AcceptsTable, Contract } from "../contracts/index.ts";
+import type { Principal } from "../data/index.ts";
+import type { Contribution, Registry, RegistryProvider } from "../registries/index.ts";
+import type { Factory } from "./attempt.ts";
+import type { Presence } from "./presence.ts";
+/** What a setup serves types and registries with (valid only while the setup runs), and the host's presence lists. */
+export interface FacetHost<P extends Principal = Principal> {
+    /**
+     * Serves a type on this host with `factory`; a remote type's factory gets the principal its object is for.
+     * `options.accepts` maps the older versions it still serves (checked here: a declaration error rejects the load or
+     * the reload).
+     */
+    serve<C extends Contract>(Type: C, factory: Factory<C, P>, options?: ServeOptions<C>): void;
+    /**
+     * Serves registry `R` on this host (its defining plugin's facet, the one provider, D1): `compose` builds the value
+     * from the table, `accepts` adapts older versions. A second serve of a registry is refused at `load`.
+     */
+    serve<C, V>(R: Registry<C, V>, provider: RegistryProvider<C, V>): void;
+    /** `host.references(Type)`: the references to objects of `Type` on this host (§19), for factories to derive from. */
+    references<C extends Contract>(Type: C): Watchable<readonly Presence<C, P>[]>;
+}
+/** What `host.serve` takes besides the type and the factory. */
+export type ServeOptions<C extends Contract = Contract> = {
+    /**
+     * The older versions of `C` this provider still binds, with the mappings their edits need (Q10, `checkAccepts`):
+     * an older consumer's state members mapped per binding, its calls' arguments and results mapped.
+     */
+    readonly accepts?: AcceptsTable<C>;
+    /**
+     * How long, in milliseconds, a live object with params stays live after its last reference is released (0 by
+     * default): a reference within that time reuses it, with its documents and dependencies.
+     */
+    readonly linger?: number;
+};
+/** What a facet's setup declares with besides the host: its contributions to registries (R21). */
+export interface FacetSelf {
+    /**
+     * Contributes `value` to registry `R` while this plugin is loaded: a plain value, or a Chord watchable of one
+     * (followed: its change recomposes). At most one per registry.
+     */
+    contribute<C>(R: Registry<C, unknown>, value: Contribution<C>): void;
+}
+/** What a setup served, by kind: a type (its contract, factory and options), or a registry (its provider). */
+export type ServedEntry = {
+    readonly kind: "type";
+    readonly contract: Contract;
+    readonly factory: ServedFactory;
+    readonly options: ServeOptions;
+} | {
+    readonly kind: "registry";
+    readonly registry: Registry<unknown, unknown>;
+    readonly provider: RegistryProvider<unknown, unknown>;
+};
+/** A contribution a setup declared. */
+export type FacetContribution = {
+    readonly registry: Registry<unknown, unknown>;
+    readonly value: unknown;
+};
+/** A factory as a setup served it, of either kind (the host dispatches on its contract's kind). */
+type ServedFactory = (params: never, principalOrSelf: never, self: never) => unknown;
+/** A plugin's facet for hosts of the app's principal type `P` (type only: nothing is checked at runtime). */
+export type Facet<P extends Principal> = {
+    readonly setup: (host: FacetHost<P>, self: FacetSelf) => void;
+    /** Type only: the principal type, invariant, so a host takes only facets typed for exactly its `P`. */
+    readonly "~principal"?: (principal: P) => P;
+};
+/** Defines a facet; base code binds `P` once, next to its principal type. */
+export declare function defineFacet<P extends Principal>(setup: (host: FacetHost<P>, self: FacetSelf) => void): Facet<P>;
+/**
+ * Runs a facet's setup and returns the types and registries it served and its contributions, in order; `references`
+ * is the host's.
+ */
+export declare function setUp<P extends Principal>(name: string, facet: Facet<P>, references: <C extends Contract>(Type: C) => Watchable<readonly Presence<C, P>[]>): {
+    readonly served: readonly ServedEntry[];
+    readonly contributions: readonly FacetContribution[];
+};
+export {};
+//# sourceMappingURL=facet.d.ts.map

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

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

package/dist/next/host/facet.js

@@ -0,0 +1,55 @@
+// Facets (§16): a plugin's setup for one host, typed by the app's principal type. A setup only declares: the types and
+// registries it serves, its contributions to registries (slice 8) and the host's presence lists; it has no documents,
+// routines or natives, so a facet cannot fail after `load`.
+/** Defines a facet; base code binds `P` once, next to its principal type. */
+export function defineFacet(setup) {
+    return { setup };
+}
+/**
+ * Runs a facet's setup and returns the types and registries it served and its contributions, in order; `references`
+ * is the host's.
+ */
+export function setUp(name, facet, references) {
+    const served = [];
+    const contributions = [];
+    let open = true;
+    const assertOpen = (what) => {
+        if (!open)
+            throw new Error(`${name}: ${what} is valid only in the facet's setup`);
+    };
+    const host = {
+        serve: (Type, implementation, options = {}) => {
+            assertOpen("host.serve");
+            // Served types and registries are dispatched by their kind; a factory matches its own contract, a provider
+            // its own registry.
+            if (Type.kind === "registry") {
+                served.push({
+                    kind: "registry",
+                    registry: Type,
+                    provider: implementation,
+                });
+            }
+            else {
+                served.push({ kind: "type", contract: Type, factory: implementation, options });
+            }
+        },
+        references,
+    };
+    const self = {
+        contribute: (registry, value) => {
+            assertOpen("self.contribute");
+            if (contributions.some((each) => each.registry.name === registry.name)) {
+                throw new Error(`${name}: registry ${registry.name} is contributed to twice`);
+            }
+            contributions.push({ registry: registry, value });
+        },
+    };
+    try {
+        facet.setup(host, self);
+    }
+    finally {
+        open = false;
+    }
+    return { served, contributions };
+}
+//# sourceMappingURL=facet.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facet.js","sourceRoot":"","sources":["../../../src/next/host/facet.ts"],"names":[],"mappings":"AAAA,uHAAuH;AACvH,sHAAsH;AACtH,4DAA4D;AA4E5D,6EAA6E;AAC7E,MAAM,UAAU,WAAW,CAAsB,KAAoD;IACpG,OAAO,EAAE,KAAK,EAAE,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,KAAK,CACpB,IAAY,EACZ,KAAe,EACf,UAAiF;IAEjF,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,MAAM,aAAa,GAAwB,EAAE,CAAC;IAC9C,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,MAAM,UAAU,GAAG,CAAC,IAAY,EAAQ,EAAE;QACzC,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,IAAI,qCAAqC,CAAC,CAAC;IACnF,CAAC,CAAC;IACF,MAAM,IAAI,GAAiB;QAC1B,KAAK,EAAE,CAAC,IAA2C,EAAE,cAAuB,EAAE,OAAO,GAAiB,EAAE,EAAE,EAAE;YAC3G,UAAU,CAAC,YAAY,CAAC,CAAC;YACzB,2GAA2G;YAC3G,oBAAoB;YACpB,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC9B,MAAM,CAAC,IAAI,CAAC;oBACX,IAAI,EAAE,UAAU;oBAChB,QAAQ,EAAE,IAAI;oBACd,QAAQ,EAAE,cAAoD;iBAC9D,CAAC,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACP,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,cAA+B,EAAE,OAAO,EAAE,CAAC,CAAC;YAClG,CAAC;QACF,CAAC;QACD,UAAU;KACV,CAAC;IACF,MAAM,IAAI,GAAc;QACvB,UAAU,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE;YAC/B,UAAU,CAAC,iBAAiB,CAAC,CAAC;YAC9B,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,cAAc,QAAQ,CAAC,IAAI,0BAA0B,CAAC,CAAC;YAC/E,CAAC;YACD,aAAa,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAsC,EAAE,KAAK,EAAE,CAAC,CAAC;QACjF,CAAC;KACD,CAAC;IACF,IAAI,CAAC;QACJ,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACzB,CAAC;YAAS,CAAC;QACV,IAAI,GAAG,KAAK,CAAC;IACd,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;AAClC,CAAC","sourcesContent":["// Facets (§16): a plugin's setup for one host, typed by the app's principal type. A setup only declares: the types and\n// registries it serves, its contributions to registries (slice 8) and the host's presence lists; it has no documents,\n// routines or natives, so a facet cannot fail after `load`.\n\nimport type { Watchable } from \"../../watch.ts\";\nimport type { AcceptsTable, Contract } from \"../contracts/index.ts\";\nimport type { Principal } from \"../data/index.ts\";\nimport type { Contribution, Registry, RegistryProvider } from \"../registries/index.ts\";\nimport type { Factory } from \"./attempt.ts\";\nimport type { Presence } from \"./presence.ts\";\n\n/** What a setup serves types and registries with (valid only while the setup runs), and the host's presence lists. */\nexport interface FacetHost<P extends Principal = Principal> {\n\t/**\n\t * Serves a type on this host with `factory`; a remote type's factory gets the principal its object is for.\n\t * `options.accepts` maps the older versions it still serves (checked here: a declaration error rejects the load or\n\t * the reload).\n\t */\n\tserve<C extends Contract>(Type: C, factory: Factory<C, P>, options?: ServeOptions<C>): void;\n\t/**\n\t * Serves registry `R` on this host (its defining plugin's facet, the one provider, D1): `compose` builds the value\n\t * from the table, `accepts` adapts older versions. A second serve of a registry is refused at `load`.\n\t */\n\tserve<C, V>(R: Registry<C, V>, provider: RegistryProvider<C, V>): void;\n\t/** `host.references(Type)`: the references to objects of `Type` on this host (§19), for factories to derive from. */\n\treferences<C extends Contract>(Type: C): Watchable<readonly Presence<C, P>[]>;\n}\n\n/** What `host.serve` takes besides the type and the factory. */\nexport type ServeOptions<C extends Contract = Contract> = {\n\t/**\n\t * The older versions of `C` this provider still binds, with the mappings their edits need (Q10, `checkAccepts`):\n\t * an older consumer's state members mapped per binding, its calls' arguments and results mapped.\n\t */\n\treadonly accepts?: AcceptsTable<C>;\n\t/**\n\t * How long, in milliseconds, a live object with params stays live after its last reference is released (0 by\n\t * default): a reference within that time reuses it, with its documents and dependencies.\n\t */\n\treadonly linger?: number;\n};\n\n/** What a facet's setup declares with besides the host: its contributions to registries (R21). */\nexport interface FacetSelf {\n\t/**\n\t * Contributes `value` to registry `R` while this plugin is loaded: a plain value, or a Chord watchable of one\n\t * (followed: its change recomposes). At most one per registry.\n\t */\n\tcontribute<C>(R: Registry<C, unknown>, value: Contribution<C>): void;\n}\n\n/** What a setup served, by kind: a type (its contract, factory and options), or a registry (its provider). */\nexport type ServedEntry =\n\t| {\n\t\t\treadonly kind: \"type\";\n\t\t\treadonly contract: Contract;\n\t\t\treadonly factory: ServedFactory;\n\t\t\treadonly options: ServeOptions;\n\t  }\n\t| {\n\t\t\treadonly kind: \"registry\";\n\t\t\treadonly registry: Registry<unknown, unknown>;\n\t\t\treadonly provider: RegistryProvider<unknown, unknown>;\n\t  };\n\n/** A contribution a setup declared. */\nexport type FacetContribution = { readonly registry: Registry<unknown, unknown>; readonly value: unknown };\n\n/** A factory as a setup served it, of either kind (the host dispatches on its contract's kind). */\ntype ServedFactory = (params: never, principalOrSelf: never, self: never) => unknown;\n\n/** A plugin's facet for hosts of the app's principal type `P` (type only: nothing is checked at runtime). */\nexport type Facet<P extends Principal> = {\n\treadonly setup: (host: FacetHost<P>, self: FacetSelf) => void;\n\t/** Type only: the principal type, invariant, so a host takes only facets typed for exactly its `P`. */\n\treadonly \"~principal\"?: (principal: P) => P;\n};\n\n/** Defines a facet; base code binds `P` once, next to its principal type. */\nexport function defineFacet<P extends Principal>(setup: (host: FacetHost<P>, self: FacetSelf) => void): Facet<P> {\n\treturn { setup };\n}\n\n/**\n * Runs a facet's setup and returns the types and registries it served and its contributions, in order; `references`\n * is the host's.\n */\nexport function setUp<P extends Principal>(\n\tname: string,\n\tfacet: Facet<P>,\n\treferences: <C extends Contract>(Type: C) => Watchable<readonly Presence<C, P>[]>,\n): { readonly served: readonly ServedEntry[]; readonly contributions: readonly FacetContribution[] } {\n\tconst served: ServedEntry[] = [];\n\tconst contributions: FacetContribution[] = [];\n\tlet open = true;\n\tconst assertOpen = (what: string): void => {\n\t\tif (!open) throw new Error(`${name}: ${what} is valid only in the facet's setup`);\n\t};\n\tconst host: FacetHost<P> = {\n\t\tserve: (Type: Contract | Registry<unknown, unknown>, implementation: unknown, options: ServeOptions = {}) => {\n\t\t\tassertOpen(\"host.serve\");\n\t\t\t// Served types and registries are dispatched by their kind; a factory matches its own contract, a provider\n\t\t\t// its own registry.\n\t\t\tif (Type.kind === \"registry\") {\n\t\t\t\tserved.push({\n\t\t\t\t\tkind: \"registry\",\n\t\t\t\t\tregistry: Type,\n\t\t\t\t\tprovider: implementation as RegistryProvider<unknown, unknown>,\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tserved.push({ kind: \"type\", contract: Type, factory: implementation as ServedFactory, options });\n\t\t\t}\n\t\t},\n\t\treferences,\n\t};\n\tconst self: FacetSelf = {\n\t\tcontribute: (registry, value) => {\n\t\t\tassertOpen(\"self.contribute\");\n\t\t\tif (contributions.some((each) => each.registry.name === registry.name)) {\n\t\t\t\tthrow new Error(`${name}: registry ${registry.name} is contributed to twice`);\n\t\t\t}\n\t\t\tcontributions.push({ registry: registry as Registry<unknown, unknown>, value });\n\t\t},\n\t};\n\ttry {\n\t\tfacet.setup(host, self);\n\t} finally {\n\t\topen = false;\n\t}\n\treturn { served, contributions };\n}\n"]}

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

@@ -0,0 +1,52 @@
+import type { Context } from "../../context/index.ts";
+import type { JsonValue } from "../../json.ts";
+import type { Watch, WatchCall, WatchEnd } from "../../watch.ts";
+import { type Batch, Source, type Subscriber } from "../state/internal.ts";
+/** The observer a followed runtime is given: Chord's watch shapes (Durable's `Observer`). */
+export type FollowObserver<T> = {
+    /** One change, synchronously and quickly: Chord only records it. */
+    advance(call: WatchCall<T>, context: Context): void;
+    /** The followed source ended: `failed` (its runtime failed), or `ended` for good. */
+    end(end: WatchEnd): void;
+};
+/** What attaching gives: the value every later call starts from, and how to detach (Durable's `Observation`). */
+export type FollowAttachment<T> = {
+    readonly value: T;
+    detach(): void;
+};
+/**
+ * What `self.follow` takes: attaches `observer`, resolving with the attachment, `undefined` for an absent address.
+ * The observer takes calls of any value (it only records them), so `T` is inferred from the attachment alone.
+ */
+export type FollowAttach<T> = (observer: FollowObserver<unknown>, context: Context) => Promise<FollowAttachment<T> | undefined>;
+/** Who a followed source belongs to: its attempt (R4) and its context. */
+export type FollowOwner = {
+    readonly label: string;
+    readonly context: Context;
+    /**
+     * The followed runtime ended its observer: `failed` fails the attempt `transient` (live or activating, its retry
+     * attaches again); `ended` while the attempt activates fails it `transient` too (it would go live on a source that
+     * ended); `ended` while live is final for the source only.
+     */
+    ended(end: WatchEnd): void;
+};
+/** A followed source: the runtime's value, its calls applied in order, its frames delivered in the host's batch. */
+export declare class FollowSource extends Source {
+    #private;
+    constructor(attach: FollowAttach<JsonValue>, owner: FollowOwner, batch: Batch);
+    get value(): JsonValue;
+    /**
+     * Attaches (activation, after the natives opened): the calls that came meanwhile apply on the attachment's value,
+     * and an end that came meanwhile takes effect then (the value stays). A rejected attachment, or `undefined` (an
+     * absent address), throws; an attachment arriving after its attempt detached the source is detached at once.
+     */
+    attach(context: Context): Promise<void>;
+    /** Its attempt ended: the observer is detached (also after the runtime ended it) and its watches end `ended`. */
+    detach(): void;
+    /** A watch of an ended source opens at its value and ends `ended` at once. */
+    openWatch(context: Context): Watch<JsonValue>;
+    /** A subscriber of an ended source (a reference's watch through its member) ends `ended` at once. */
+    subscribe(subscriber: Subscriber): void;
+    deliver(context: Context): void;
+}
+//# sourceMappingURL=follow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"follow.d.ts","sourceRoot":"","sources":["../../../src/next/host/follow.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE3E,6FAA6F;AAC7F,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC/B,oEAAoE;IACpE,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACpD,qFAAqF;IACrF,GAAG,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,iHAAiH;AACjH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAAC,MAAM,IAAI,IAAI,CAAA;CAAE,CAAC;AAExE;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAC7B,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,EACjC,OAAO,EAAE,OAAO,KACZ,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAE9C,0EAA0E;AAC1E,MAAM,MAAM,WAAW,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC3B,CAAC;AAgBF,oHAAoH;AACpH,qBAAa,YAAa,SAAQ,MAAM;;IAmBvC,YAAY,MAAM,EAAE,YAAY,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAI5E;IAED,IAAI,KAAK,IAAI,SAAS,CAQrB;IAED;;;;OAIG;IACG,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB5C;IAED,iHAAiH;IACjH,MAAM,IAAI,IAAI,CAMb;IAED,8EAA8E;IACrE,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAIrD;IAED,qGAAqG;IAC5F,SAAS,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAG/C;IAED,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAW9B;CA4FD"}