@earendil-works/chord 1.4.0 → 1.5.1

package/dist/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/host/destination.js.map

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

@@ -0,0 +1,84 @@
+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 { Watchable } from "../watch.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;
+    /**
+     * Its calls start no `chord.method` span (`true`): Chord's telemetry ingest, whose every call would otherwise record
+     * a span about the telemetry it writes. Traced by default.
+     */
+    readonly untraced?: true;
+};
+/** 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/host/facet.d.ts.map

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

package/dist/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/host/facet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facet.js","sourceRoot":"","sources":["../../src/host/facet.ts"],"names":[],"mappings":"AAAA,uHAAuH;AACvH,sHAAsH;AACtH,4DAA4D;AAiF5D,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 { AcceptsTable, Contract } from \"../contracts/index.ts\";\nimport type { Principal } from \"../data/index.ts\";\nimport type { Contribution, Registry, RegistryProvider } from \"../registries/index.ts\";\nimport type { Watchable } from \"../watch.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\t/**\n\t * Its calls start no `chord.method` span (`true`): Chord's telemetry ingest, whose every call would otherwise record\n\t * a span about the telemetry it writes. Traced by default.\n\t */\n\treadonly untraced?: true;\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/host/follow.d.ts

@@ -0,0 +1,52 @@
+import type { Context } from "../context/index.ts";
+import type { JsonValue } from "../json.ts";
+import { type Batch, Source, type Subscriber } from "../state/internal.ts";
+import type { Watch, WatchCall, WatchEnd } from "../watch.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/host/follow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"follow.d.ts","sourceRoot":"","sources":["../../src/host/follow.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE9D,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"}

package/dist/host/follow.js

@@ -0,0 +1,207 @@
+// Followed sources (slice 6b D9, R4, §3): `self.follow(attach)`, a Chord source over a synchronous observer of another
+// runtime (Durable's `observeConversation`, `observeTaskGraph`, `observeDoc`). Attached during its attempt's
+// activation, detached at the attempt's end. Calls inside a running batch (Durable adopting in the store's commit step)
+// are marked in that batch, calls outside one are grouped into one batch on the next microtask, so a derive over two
+// views of one commit computes once with both changes.
+import { ChordError } from "../data/index.js";
+import { Source } from "../state/internal.js";
+const NO_OPS = [];
+const ENDED = { kind: "ended" };
+/** A followed source: the runtime's value, its calls applied in order, its frames delivered in the host's batch. */
+export class FollowSource extends Source {
+    #attach;
+    #owner;
+    #state = { kind: "attaching", end: undefined };
+    #value;
+    /** Calls not applied yet: before the attachment resolved, and outside a batch until the next microtask. */
+    #queued = [];
+    /** Whether a microtask is queued to apply `#queued` in a batch of its own. */
+    #scheduled = false;
+    /**
+     * The runtime's end, still to reach the watches: `queued` after the queued calls' batch, `frame` after the current
+     * batch's frame (a retirement and an end in one batch: the retirement first).
+     */
+    #ending = "none";
+    /** The ops of the current batch's frame (kept only while watched), and whether a retirement came in it. */
+    #ops = [];
+    #retired = false;
+    #listed = false;
+    constructor(attach, owner, batch) {
+        super(batch);
+        this.#attach = attach;
+        this.#owner = owner;
+    }
+    get value() {
+        if (this.#value === undefined) {
+            throw new ChordError({
+                code: "not_ready",
+                message: `${this.#owner.label}: a followed source read before it attached`,
+            });
+        }
+        return this.#value;
+    }
+    /**
+     * 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.
+     */
+    async attach(context) {
+        const observer = {
+            advance: (call) => this.#advance(call),
+            end: (end) => this.#end(end),
+        };
+        const attached = await this.#attach(observer, context);
+        if (attached === undefined) {
+            throw new ChordError({ code: "unavailable", message: `${this.#owner.label}: the followed address is absent` });
+        }
+        const state = this.#state;
+        const detach = () => attached.detach();
+        if (state.kind !== "attaching") {
+            detach();
+            return;
+        }
+        this.#value = attached.value;
+        // Nothing watches it yet (members are checked after this): the queued calls only move the value on.
+        for (const call of this.#queued)
+            if (call.kind === "value")
+                this.#value = call.value;
+        this.#queued = [];
+        this.#state = state.end?.kind === "ended" ? { kind: "ended", detach } : { kind: "attached", detach };
+    }
+    /** Its attempt ended: the observer is detached (also after the runtime ended it) and its watches end `ended`. */
+    detach() {
+        const state = this.#state;
+        this.#state = { kind: "detached" };
+        this.#queued = [];
+        if (state.kind === "attached" || state.kind === "ended")
+            state.detach();
+        this.endWatches();
+    }
+    /** A watch of an ended source opens at its value and ends `ended` at once. */
+    openWatch(context) {
+        const watch = super.openWatch(context);
+        if (this.#over)
+            watch.end(ENDED);
+        return watch;
+    }
+    /** A subscriber of an ended source (a reference's watch through its member) ends `ended` at once. */
+    subscribe(subscriber) {
+        if (this.#over)
+            subscriber.end(ENDED);
+        else
+            super.subscribe(subscriber);
+    }
+    deliver(context) {
+        const ops = this.#ops;
+        const retired = this.#retired;
+        this.#ops = [];
+        this.#retired = false;
+        this.#listed = false;
+        this.publish(this.#value, ops.length === 0 ? NO_OPS : ops, retired, context);
+        if (this.#ending === "frame") {
+            this.#ending = "none";
+            this.endWatchesAfterDelivery();
+        }
+    }
+    /** Whether nothing reaches its watches any more: ended by the runtime (what it gave delivered) or detached. */
+    get #over() {
+        const { kind } = this.#state;
+        return (kind === "ended" && this.#ending === "none") || kind === "detached";
+    }
+    /**
+     * A call of the runtime: before the attachment, queued; inside a running batch, applied there (after what was
+     * queued); outside one, queued for one batch on the next microtask.
+     */
+    #advance(call) {
+        const { kind } = this.#state;
+        if (kind === "ended" || kind === "detached")
+            return;
+        if (kind === "attaching" || !this.batch.running) {
+            this.#queued.push(call);
+            if (kind === "attached")
+                this.#schedule();
+            return;
+        }
+        this.#applyQueued();
+        this.#apply(call);
+    }
+    /**
+     * The runtime ended its observer (R4); its attempt is told. `ended` is final: what came before reaches the watches
+     * first (the queued calls in their batch, a call of the running batch in its frame), then they end, the value
+     * staying. A `failed` attempt detaches the source.
+     */
+    #end(end) {
+        const state = this.#state;
+        if (state.kind === "ended" || state.kind === "detached")
+            return;
+        if (state.kind === "attaching") {
+            if (state.end === undefined)
+                this.#state = { kind: "attaching", end };
+            this.#owner.ended(end);
+            return;
+        }
+        if (end.kind === "ended") {
+            this.#state = { kind: "ended", detach: state.detach };
+            if (this.#queued.length > 0 && !this.batch.running)
+                this.#ending = "queued";
+            else {
+                // Inside a running batch the queued calls join it (none is queued outside one: they wait for their batch).
+                this.#applyQueued();
+                this.#endAfterFrame();
+            }
+        }
+        this.#owner.ended(end);
+    }
+    /** The watches end once this batch's frame reached them, at once when the source is in none. */
+    #endAfterFrame() {
+        // No frame to wait for (nothing watches it): the end is over now, and a later watch ends at once.
+        this.#ending = this.#listed ? "frame" : "none";
+        if (!this.#listed)
+            this.endWatchesAfterDelivery();
+    }
+    #schedule() {
+        if (this.#scheduled)
+            return;
+        this.#scheduled = true;
+        this.batch.soon(() => {
+            this.#scheduled = false;
+            const { kind } = this.#state;
+            if (kind === "attached" || kind === "ended")
+                this.#applyQueued();
+            if (this.#ending === "queued")
+                this.#endAfterFrame();
+        }, this.#owner.context);
+    }
+    #applyQueued() {
+        const queued = this.#queued;
+        if (queued.length === 0)
+            return;
+        this.#queued = [];
+        for (const call of queued)
+            this.#apply(call);
+    }
+    /** Applies one value call inside the running batch: the new value, its ops for the frame, the source marked once. */
+    #apply(call) {
+        // The runtime's failures are final: it ends its observer instead of sending one.
+        if (call.kind !== "value")
+            return;
+        this.#value = call.value;
+        if (call.retired)
+            this.#retired = true;
+        if (!this.watched) {
+            this.changed();
+            if (call.retired)
+                this.retiredInBatch();
+            return;
+        }
+        for (const op of call.ops)
+            this.#ops.push(op);
+        if (!this.#listed) {
+            this.#listed = true;
+            this.changed();
+        }
+        if (call.retired)
+            this.retiredInBatch();
+    }
+}
+//# sourceMappingURL=follow.js.map

package/dist/host/follow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"follow.js","sourceRoot":"","sources":["../../src/host/follow.ts"],"names":[],"mappings":"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","sourcesContent":["// Followed sources (slice 6b D9, R4, §3): `self.follow(attach)`, a Chord source over a synchronous observer of another\n// runtime (Durable's `observeConversation`, `observeTaskGraph`, `observeDoc`). Attached during its attempt's\n// activation, detached at the attempt's end. Calls inside a running batch (Durable adopting in the store's commit step)\n// are marked in that batch, calls outside one are grouped into one batch on the next microtask, so a derive over two\n// views of one commit computes once with both changes.\n\nimport type { Context } from \"../context/index.ts\";\nimport { ChordError } from \"../data/index.ts\";\nimport type { Op } from \"../delta/index.ts\";\nimport type { JsonValue } from \"../json.ts\";\nimport { type Batch, Source, type Subscriber } from \"../state/internal.ts\";\nimport type { Watch, WatchCall, WatchEnd } from \"../watch.ts\";\n\n/** The observer a followed runtime is given: Chord's watch shapes (Durable's `Observer`). */\nexport type FollowObserver<T> = {\n\t/** One change, synchronously and quickly: Chord only records it. */\n\tadvance(call: WatchCall<T>, context: Context): void;\n\t/** The followed source ended: `failed` (its runtime failed), or `ended` for good. */\n\tend(end: WatchEnd): void;\n};\n\n/** What attaching gives: the value every later call starts from, and how to detach (Durable's `Observation`). */\nexport type FollowAttachment<T> = { readonly value: T; detach(): void };\n\n/**\n * What `self.follow` takes: attaches `observer`, resolving with the attachment, `undefined` for an absent address.\n * The observer takes calls of any value (it only records them), so `T` is inferred from the attachment alone.\n */\nexport type FollowAttach<T> = (\n\tobserver: FollowObserver<unknown>,\n\tcontext: Context,\n) => Promise<FollowAttachment<T> | undefined>;\n\n/** Who a followed source belongs to: its attempt (R4) and its context. */\nexport type FollowOwner = {\n\treadonly label: string;\n\treadonly context: Context;\n\t/**\n\t * The followed runtime ended its observer: `failed` fails the attempt `transient` (live or activating, its retry\n\t * attaches again); `ended` while the attempt activates fails it `transient` too (it would go live on a source that\n\t * ended); `ended` while live is final for the source only.\n\t */\n\tended(end: WatchEnd): void;\n};\n\n/**\n * Where a followed source stands: waiting for its attachment (with the runtime's end when it came first), attached,\n * ended by the runtime (its value stays; detached at its attempt's end), or detached by its attempt.\n */\ntype FollowState =\n\t| { readonly kind: \"attaching\"; readonly end: WatchEnd | undefined }\n\t| { readonly kind: \"attached\"; readonly detach: () => void }\n\t| { readonly kind: \"ended\"; readonly detach: () => void }\n\t| { readonly kind: \"detached\" };\n\nconst NO_OPS: readonly Op[] = [];\n\nconst ENDED: WatchEnd = { kind: \"ended\" };\n\n/** A followed source: the runtime's value, its calls applied in order, its frames delivered in the host's batch. */\nexport class FollowSource extends Source {\n\treadonly #attach: FollowAttach<JsonValue>;\n\treadonly #owner: FollowOwner;\n\t#state: FollowState = { kind: \"attaching\", end: undefined };\n\t#value: JsonValue | undefined;\n\t/** Calls not applied yet: before the attachment resolved, and outside a batch until the next microtask. */\n\t#queued: WatchCall<JsonValue>[] = [];\n\t/** Whether a microtask is queued to apply `#queued` in a batch of its own. */\n\t#scheduled = false;\n\t/**\n\t * The runtime's end, still to reach the watches: `queued` after the queued calls' batch, `frame` after the current\n\t * batch's frame (a retirement and an end in one batch: the retirement first).\n\t */\n\t#ending: \"none\" | \"queued\" | \"frame\" = \"none\";\n\t/** The ops of the current batch's frame (kept only while watched), and whether a retirement came in it. */\n\t#ops: Op[] = [];\n\t#retired = false;\n\t#listed = false;\n\n\tconstructor(attach: FollowAttach<JsonValue>, owner: FollowOwner, batch: Batch) {\n\t\tsuper(batch);\n\t\tthis.#attach = attach;\n\t\tthis.#owner = owner;\n\t}\n\n\tget value(): JsonValue {\n\t\tif (this.#value === undefined) {\n\t\t\tthrow new ChordError({\n\t\t\t\tcode: \"not_ready\",\n\t\t\t\tmessage: `${this.#owner.label}: a followed source read before it attached`,\n\t\t\t});\n\t\t}\n\t\treturn this.#value;\n\t}\n\n\t/**\n\t * Attaches (activation, after the natives opened): the calls that came meanwhile apply on the attachment's value,\n\t * and an end that came meanwhile takes effect then (the value stays). A rejected attachment, or `undefined` (an\n\t * absent address), throws; an attachment arriving after its attempt detached the source is detached at once.\n\t */\n\tasync attach(context: Context): Promise<void> {\n\t\tconst observer: FollowObserver<JsonValue> = {\n\t\t\tadvance: (call) => this.#advance(call),\n\t\t\tend: (end) => this.#end(end),\n\t\t};\n\t\tconst attached = await this.#attach(observer, context);\n\t\tif (attached === undefined) {\n\t\t\tthrow new ChordError({ code: \"unavailable\", message: `${this.#owner.label}: the followed address is absent` });\n\t\t}\n\t\tconst state = this.#state;\n\t\tconst detach = () => attached.detach();\n\t\tif (state.kind !== \"attaching\") {\n\t\t\tdetach();\n\t\t\treturn;\n\t\t}\n\t\tthis.#value = attached.value;\n\t\t// Nothing watches it yet (members are checked after this): the queued calls only move the value on.\n\t\tfor (const call of this.#queued) if (call.kind === \"value\") this.#value = call.value;\n\t\tthis.#queued = [];\n\t\tthis.#state = state.end?.kind === \"ended\" ? { kind: \"ended\", detach } : { kind: \"attached\", detach };\n\t}\n\n\t/** Its attempt ended: the observer is detached (also after the runtime ended it) and its watches end `ended`. */\n\tdetach(): void {\n\t\tconst state = this.#state;\n\t\tthis.#state = { kind: \"detached\" };\n\t\tthis.#queued = [];\n\t\tif (state.kind === \"attached\" || state.kind === \"ended\") state.detach();\n\t\tthis.endWatches();\n\t}\n\n\t/** A watch of an ended source opens at its value and ends `ended` at once. */\n\toverride openWatch(context: Context): Watch<JsonValue> {\n\t\tconst watch = super.openWatch(context);\n\t\tif (this.#over) watch.end(ENDED);\n\t\treturn watch;\n\t}\n\n\t/** A subscriber of an ended source (a reference's watch through its member) ends `ended` at once. */\n\toverride subscribe(subscriber: Subscriber): void {\n\t\tif (this.#over) subscriber.end(ENDED);\n\t\telse super.subscribe(subscriber);\n\t}\n\n\tdeliver(context: Context): void {\n\t\tconst ops = this.#ops;\n\t\tconst retired = this.#retired;\n\t\tthis.#ops = [];\n\t\tthis.#retired = false;\n\t\tthis.#listed = false;\n\t\tthis.publish(this.#value!, ops.length === 0 ? NO_OPS : ops, retired, context);\n\t\tif (this.#ending === \"frame\") {\n\t\t\tthis.#ending = \"none\";\n\t\t\tthis.endWatchesAfterDelivery();\n\t\t}\n\t}\n\n\t/** Whether nothing reaches its watches any more: ended by the runtime (what it gave delivered) or detached. */\n\tget #over(): boolean {\n\t\tconst { kind } = this.#state;\n\t\treturn (kind === \"ended\" && this.#ending === \"none\") || kind === \"detached\";\n\t}\n\n\t/**\n\t * A call of the runtime: before the attachment, queued; inside a running batch, applied there (after what was\n\t * queued); outside one, queued for one batch on the next microtask.\n\t */\n\t#advance(call: WatchCall<JsonValue>): void {\n\t\tconst { kind } = this.#state;\n\t\tif (kind === \"ended\" || kind === \"detached\") return;\n\t\tif (kind === \"attaching\" || !this.batch.running) {\n\t\t\tthis.#queued.push(call);\n\t\t\tif (kind === \"attached\") this.#schedule();\n\t\t\treturn;\n\t\t}\n\t\tthis.#applyQueued();\n\t\tthis.#apply(call);\n\t}\n\n\t/**\n\t * The runtime ended its observer (R4); its attempt is told. `ended` is final: what came before reaches the watches\n\t * first (the queued calls in their batch, a call of the running batch in its frame), then they end, the value\n\t * staying. A `failed` attempt detaches the source.\n\t */\n\t#end(end: WatchEnd): void {\n\t\tconst state = this.#state;\n\t\tif (state.kind === \"ended\" || state.kind === \"detached\") return;\n\t\tif (state.kind === \"attaching\") {\n\t\t\tif (state.end === undefined) this.#state = { kind: \"attaching\", end };\n\t\t\tthis.#owner.ended(end);\n\t\t\treturn;\n\t\t}\n\t\tif (end.kind === \"ended\") {\n\t\t\tthis.#state = { kind: \"ended\", detach: state.detach };\n\t\t\tif (this.#queued.length > 0 && !this.batch.running) this.#ending = \"queued\";\n\t\t\telse {\n\t\t\t\t// Inside a running batch the queued calls join it (none is queued outside one: they wait for their batch).\n\t\t\t\tthis.#applyQueued();\n\t\t\t\tthis.#endAfterFrame();\n\t\t\t}\n\t\t}\n\t\tthis.#owner.ended(end);\n\t}\n\n\t/** The watches end once this batch's frame reached them, at once when the source is in none. */\n\t#endAfterFrame(): void {\n\t\t// No frame to wait for (nothing watches it): the end is over now, and a later watch ends at once.\n\t\tthis.#ending = this.#listed ? \"frame\" : \"none\";\n\t\tif (!this.#listed) this.endWatchesAfterDelivery();\n\t}\n\n\t#schedule(): void {\n\t\tif (this.#scheduled) return;\n\t\tthis.#scheduled = true;\n\t\tthis.batch.soon(() => {\n\t\t\tthis.#scheduled = false;\n\t\t\tconst { kind } = this.#state;\n\t\t\tif (kind === \"attached\" || kind === \"ended\") this.#applyQueued();\n\t\t\tif (this.#ending === \"queued\") this.#endAfterFrame();\n\t\t}, this.#owner.context);\n\t}\n\n\t#applyQueued(): void {\n\t\tconst queued = this.#queued;\n\t\tif (queued.length === 0) return;\n\t\tthis.#queued = [];\n\t\tfor (const call of queued) this.#apply(call);\n\t}\n\n\t/** Applies one value call inside the running batch: the new value, its ops for the frame, the source marked once. */\n\t#apply(call: WatchCall<JsonValue>): void {\n\t\t// The runtime's failures are final: it ends its observer instead of sending one.\n\t\tif (call.kind !== \"value\") return;\n\t\tthis.#value = call.value;\n\t\tif (call.retired) this.#retired = true;\n\t\tif (!this.watched) {\n\t\t\tthis.changed();\n\t\t\tif (call.retired) this.retiredInBatch();\n\t\t\treturn;\n\t\t}\n\t\tfor (const op of call.ops) this.#ops.push(op);\n\t\tif (!this.#listed) {\n\t\t\tthis.#listed = true;\n\t\t\tthis.changed();\n\t\t}\n\t\tif (call.retired) this.retiredInBatch();\n\t}\n}\n"]}