@earendil-works/chord 1.2.0 → 1.3.0

package/dist/{record.js → object.js}

@@ -1,18 +1,39 @@
 import { Value } from "typebox/value";
-import { Cell, Derived, isSource, notReady } from "./cell.js";
-import { bind, LOCAL_VARIANT, } from "./contract.js";
-import { declKind, } from "./declare.js";
+import { Cell, Derived, HYDRATION, hydrationOf, isSource, notReady, unhydrated, } from "./cell.js";
+import { bind, LOCAL_VARIANT, takesNoArgs, } from "./contract.js";
 import { asChordError, ChordError, invalid, runAll } from "./errors.js";
 import { enqueue } from "./publish.js";
-import { assertValid } from "./schema.js";
+import { assertValid, normalize } from "./schema.js";
 const noop = () => { };
-export const makeService = (contract, factory, options, facet) => ({
-    contract,
-    factory: factory,
-    options: options,
-    facet,
-    stateVersion: options.state?.version ?? 1,
-});
+export const makeService = (contract, factory, options, facet) => {
+    checkLifetime(contract, options);
+    return {
+        contract,
+        factory: factory,
+        options: options,
+        facet,
+    };
+};
+/** Whether objects of `service` have `lifetime: "host"`. */
+export const hostLifetime = (service) => service.options.lifetime === "host";
+/** Refuses lifetimes the type cannot have, when it is served. */
+function checkLifetime(contract, options) {
+    const lifetime = options.lifetime ?? "referenced";
+    if (lifetime !== "referenced" && lifetime !== "host")
+        throw new TypeError(`${contract.name}: unknown lifetime ${String(lifetime)}`);
+    if (lifetime !== "host")
+        return;
+    if (contract.scope !== "local")
+        throw new TypeError(`${contract.name}: lifetime "host" needs a local type (remote types are referenced)`);
+    if (options.linger !== undefined)
+        throw new TypeError(`${contract.name}: an object of lifetime "host" does not linger (it lives as long as the host)`);
+    try {
+        normalize(contract.input, {}, `${contract.name} input`);
+    }
+    catch {
+        throw new TypeError(`${contract.name}: lifetime "host" needs an input that accepts {} (the object's one address)`);
+    }
+}
 /** Runtime form of `Exposed<T>`. */
 class ExposedImpl {
     resource;
@@ -22,6 +43,7 @@ class ExposedImpl {
 }
 export class ResourceImpl {
     key;
+    /** The declaration of the factory run whose code is current: a kept resource adopts the new one at commit. */
     spec;
     deps;
     /** `unavailable`: a close/reopen failed during a reload rollback; the value is gone for good. */
@@ -82,6 +104,13 @@ export class ResourceImpl {
         this.state = "unavailable";
         this.#value = undefined;
     }
+    /**
+     * A reload kept this resource (same version, deps and exclusivity): its later `close` is the new declaration's, and
+     * the old declaration (with the old code it closes over) is no longer referenced.
+     */
+    adopt(spec) {
+        this.spec = spec;
+    }
 }
 /**
  * What `self.resources` returns: the resource, except that `.value` throws `not_ready` while any factory runs, even
@@ -110,68 +139,142 @@ const resourceOf = (value) => value instanceof ResourceImpl ? value : value !==
 export class Decls {
     cells = new Map();
     cellSchemas = new Map();
-    holds = new Map();
+    cellVersions = new Map();
+    cellMigrations = new Map();
+    refs = new Map();
     resources = new Map();
+    /** Resources this run kept from the previous one, with this run's declarations (adopted at commit). */
+    adopted = new Map();
     listeners = new Map();
+    /** By position (`#0`, `#1`, …): tasks have no names. */
     tasks = new Map();
+    /** By position: derivations have no names and are new at every run. */
     derives = new Map();
-    deriveFns = new Map();
     registrations = new Map();
 }
+const isStateInit = (value) => value !== null && typeof value === "object" && typeof value.init === "function";
 // ─── Contexts ────────────────────────────────────────────────────────────────
 export class CtxImpl {
     host;
     signal;
     rootId;
-    epoch;
+    codeVersion;
     principal;
     /** Code holders (tasks): every call they make starts a fresh root. */
     holder;
-    #holds = [];
+    #refs = [];
+    #release;
+    /** Aborted when the ctx closes: awaited `get`s give up. */
+    #closing = new AbortController();
     #closed = false;
     /** True after the call or root that received this ctx settled: it may no longer start work. */
     get closed() {
         return this.#closed;
     }
-    /** Throws unless this ctx may start work on `host` now (not expired, not aborted, not from another host). */
+    /** Throws unless this ctx may start work on `host` (the called reference's host) now: not expired, aborted or foreign. */
     check(host) {
         if (this.host !== host)
             throw invalid("foreign_ctx", "ctx belongs to another host");
         if (this.#closed)
             throw new ChordError("aborted", "ctx expired: its call already settled", { reason: "expired" });
-        if (this.signal.aborted)
-            throw new ChordError("aborted", "ctx aborted", { cause: this.signal.reason });
+        if (this.signal.aborted) {
+            const reason = this.signal.reason;
+            // A forced retirement aborted the root: its code version is gone, so the next call is `superseded` (retryable).
+            if (reason instanceof ChordError && reason.code === "superseded")
+                throw new ChordError("superseded", reason.message, { cause: reason });
+            throw new ChordError("aborted", "ctx aborted", { cause: reason });
+        }
     }
+    /** `signals`: the ctx is aborted with the first of them; it stops following them when it closes. */
     constructor(host, fields) {
         this.host = host;
-        this.signal = fields.signal;
+        const linked = linkedSignal(fields.signals);
+        this.signal = linked.signal;
+        this.#release = linked.release;
         this.rootId = fields.rootId;
-        this.epoch = fields.epoch;
+        this.codeVersion = fields.codeVersion;
         this.principal = fields.principal;
         this.holder = fields.holder ?? false;
     }
-    get(type, input, options) {
+    async get(type, input, options) {
         this.check(this.host);
-        const handle = this.host.acquire(type, input, { principal: this.principal, ...options }, "call");
-        this.#holds.push(handle);
-        return handle.proxy;
+        const ref = this.host.acquire(type, input, { principal: this.principal, ...options }, "call");
+        this.#refs.push(ref);
+        await awaitReady(ref, [this.signal, this.#closing.signal], this.host.readyTimeout);
+        return ref.proxy;
     }
     /**
-     * A context for a call into `record`: same root and epoch, its own call-owned holds, aborted on forced disposal.
-     * Code inside an object acts as the host principal.
+     * A context for a call into `object`: same root and code version, its own call-owned references, aborted on forced
+     * disposal. Code inside an object acts as the host principal.
      */
-    child(record) {
+    child(object) {
         return new CtxImpl(this.host, {
-            signal: AbortSignal.any([this.signal, record.callAbort.signal]),
+            signals: [this.signal, object.callAbort.signal],
             rootId: this.rootId,
-            epoch: this.epoch,
+            codeVersion: this.codeVersion,
             principal: this.host.principal,
         });
     }
     close() {
         this.#closed = true;
-        for (const handle of this.#holds.splice(0))
-            handle.release();
+        this.#closing.abort(new ChordError("aborted", "ctx expired: its call already settled", { reason: "expired" }));
+        this.#release();
+        for (const ref of this.#refs.splice(0))
+            ref.release();
+    }
+}
+/**
+ * A signal aborted with the first of `sources` to abort, until `release()`. Not `AbortSignal.any`: Node keeps a
+ * dependant of a long-lived source (an object's or a code version's) reachable while it has abort listeners, so every
+ * call or task context would keep its listeners, and the code they close over, alive as long as the source.
+ */
+export function linkedSignal(sources) {
+    const controller = new AbortController();
+    const detach = [];
+    const release = () => {
+        for (const remove of detach.splice(0))
+            remove();
+    };
+    for (const source of sources) {
+        if (source.aborted) {
+            release();
+            controller.abort(source.reason);
+            break;
+        }
+        const forward = () => {
+            release();
+            controller.abort(source.reason);
+        };
+        source.addEventListener("abort", forward, { once: true });
+        detach.push(() => source.removeEventListener("abort", forward));
+    }
+    return { signal: controller.signal, release };
+}
+/**
+ * Waits until `ref` is ready, at most `ms` and until a signal aborts; on failure the reference is released (only it: a
+ * binding other references share stays) and the error is rethrown: the activation error, `aborted`, or
+ * `unavailable/ready_timeout`.
+ */
+export async function awaitReady(ref, signals, ms) {
+    const timeout = new AbortController();
+    const timer = Number.isFinite(ms)
+        ? setTimeout(() => timeout.abort(new ChordError("unavailable", `${ref.address} was not ready after ${ms} ms`, {
+            reason: "ready_timeout",
+        })), ms)
+        : undefined;
+    timer?.unref?.();
+    const linked = linkedSignal([...signals, timeout.signal]);
+    try {
+        await raceSignal(ref.ready, linked.signal);
+    }
+    catch (error) {
+        ref.release();
+        const reason = linked.signal.reason;
+        throw reason instanceof ChordError && reason.reason === "ready_timeout" ? reason : error;
+    }
+    finally {
+        clearTimeout(timer);
+        linked.release();
     }
 }
 export async function raceSignal(promise, signal) {
@@ -189,11 +292,11 @@ export async function raceSignal(promise, signal) {
         signal.removeEventListener("abort", onAbort);
     }
 }
-export const HANDLE_BASE = new Set([
+export const REF_BASE = new Set([
     "contract",
     "status",
     "ready",
-    "kind",
+    "variant",
     "shape",
     "error",
     "onShape",
@@ -216,43 +319,83 @@ export function notifyStatus(listeners, status, error, report) {
         }
     });
 }
-/** Proxy → hold, for `deps: [handle]` and links. */
-export const holdsByProxy = new WeakMap();
-export const handleOf = (value) => value !== null && typeof value === "object" ? holdsByProxy.get(value) : undefined;
+/** Proxy → reference, for `deps: [ref]` and links. */
+export const refsByProxy = new WeakMap();
+export const refOf = (value) => value !== null && typeof value === "object" ? refsByProxy.get(value) : undefined;
 /**
- * A handle's state member: a stable readable that follows whatever source the current behavior exposes under that
- * name. `undefined` until the handle is live (or while the variant lacks the member). Rebinding (reload, variant)
- * delivers a reset. Upstream is subscribed only while someone listens.
+ * A reference's state member: a stable readable that follows whatever source the current implementation exposes under
+ * that name. Reading throws `not_ready` until the reference is live, `not_in_variant` while the variant lacks the
+ * member. A listener added before the member is readable gets its snapshot then. Rebinding (reload, variant) delivers a
+ * reset. Upstream is subscribed only while someone listens.
  */
 class MemberReadable {
-    #handle;
+    #ref;
     #name;
     #values = new Set();
     #events = new Set();
+    /** Event listeners that have not had their snapshot yet (added while the member was not readable). */
+    #unseen = new Set();
     #source;
     #upstream = noop;
     /** The value listeners last saw; a first upstream snapshot equal to it is not re-announced. */
     #seen;
-    constructor(handle, name) {
-        this.#handle = handle;
+    constructor(ref, name) {
+        this.#ref = ref;
         this.#name = name;
     }
     get value() {
-        return this.#current()?.value;
+        const ref = this.#ref;
+        if (ref.status === "released" || ref.status === "gone")
+            throw ref.terminalError();
+        if (ref.status !== "live")
+            throw notReady(`${ref.address}.${this.#name}`);
+        const view = ref.currentView();
+        if (view === undefined)
+            throw notReady(`${ref.address}.${this.#name}`);
+        const source = this.#current();
+        if (source === undefined) {
+            throw new ChordError("not_in_variant", `${ref.address}: ${this.#name} is not a state member of variant ${variantOf(view) ?? "(local)"}`);
+        }
+        return source.value;
+    }
+    /** Not hydrated while the reference is not live, or while its source (a forwarded remote member) is not. */
+    get [HYDRATION]() {
+        const ref = this.#ref;
+        if (ref.status === "live")
+            return hydrationOf(this.#current());
+        return {
+            hydrated: false,
+            whenHydrated: async () => {
+                await ref.ready;
+                await hydrationOf(this.#current())?.whenHydrated();
+            },
+        };
     }
     subscribe(listener) {
         this.#values.add(listener);
-        this.#seen = this.value;
-        this.#safe(() => listener(this.#seen));
+        const source = this.#readable();
+        if (source !== undefined) {
+            this.#seen = { value: source.value };
+            this.#safe(() => listener(source.value));
+        }
         this.bind();
         return () => this.#remove(this.#values, listener);
     }
     events(listener) {
         this.#events.add(listener);
-        this.#seen = this.value;
-        this.#safe(() => listener({ type: "snap", value: this.#seen }));
+        const source = this.#readable();
+        if (source !== undefined) {
+            const value = source.value;
+            this.#seen = { value };
+            this.#safe(() => listener({ type: "snap", value }));
+        }
+        else
+            this.#unseen.add(listener);
         this.bind();
-        return () => this.#remove(this.#events, listener);
+        return () => {
+            this.#unseen.delete(listener);
+            this.#remove(this.#events, listener);
+        };
     }
     /** (Re)subscribes upstream to the current source; a changed source is announced as a reset. */
     bind() {
@@ -268,17 +411,24 @@ class MemberReadable {
         this.#upstream = source.events((event) => {
             const isFirst = first;
             first = false;
-            if (isFirst && event.value === this.#seen)
+            if (isFirst && this.#unseen.size === 0 && this.#seen !== undefined && event.value === this.#seen.value)
                 return;
-            this.#seen = event.value;
+            this.#seen = { value: event.value };
             const translated = isFirst ? { type: "reset", value: event.value } : event;
             const events = [...this.#events];
             const values = [...this.#values];
+            const unseen = new Set(this.#unseen);
+            this.#unseen.clear();
             // Queued: a rebind during a commit must not run observers before the commit completes.
             enqueue(() => {
-                for (const listener of events)
-                    if (this.#events.has(listener))
-                        this.#safe(() => listener(translated));
+                for (const listener of events) {
+                    if (!this.#events.has(listener))
+                        continue;
+                    const delivered = unseen.has(listener)
+                        ? { type: "snap", value: event.value }
+                        : translated;
+                    this.#safe(() => listener(delivered));
+                }
                 for (const listener of values)
                     if (this.#values.has(listener))
                         this.#safe(() => listener(event.value));
@@ -288,16 +438,22 @@ class MemberReadable {
     stop() {
         this.#values.clear();
         this.#events.clear();
+        this.#unseen.clear();
         this.bind();
     }
     #current() {
-        const view = this.#handle.currentView();
-        if (view === undefined || !this.#handle.inVariant(view, this.#name))
+        const view = this.#ref.currentView();
+        if (view === undefined || !this.#ref.inVariant(view, this.#name))
             return undefined;
         const value = view[this.#name];
         // Cells and derivations, or any readable an `accepts` adapter maps them to.
         return isSource(value) || isReadableLike(value) ? value : undefined;
     }
+    /** The current source if its value can be read now (live, in the variant, hydrated). */
+    #readable() {
+        const source = this.#current();
+        return source === undefined || hydrationOf(source)?.hydrated === false ? undefined : source;
+    }
     #remove(set, listener) {
         set.delete(listener);
         this.bind();
@@ -307,13 +463,13 @@ class MemberReadable {
             fn();
         }
         catch (error) {
-            this.#handle.record.host.report(error);
+            this.#ref.object.host.report(error);
         }
     }
 }
-/** One hold on a record. Exposed through a Proxy so members bind late to the current behavior. */
-export class HandleImpl {
-    record;
+/** One reference on an object. Exposed through a Proxy so members bind late to the current implementation. */
+export class RefImpl {
+    object;
     contract;
     owner;
     address;
@@ -322,28 +478,29 @@ export class HandleImpl {
     status;
     error;
     shapeListeners = new Set();
-    /** Internal: notified when the handle becomes gone (links forward it). */
+    /** Internal: notified when the reference becomes gone (links forward it). */
     goneListeners = new Set();
     readables = new Map();
-    bindings = new Map();
+    /** Weak: a retired code version's service (and the factory code it holds) must not be kept alive by its consumers. */
+    bindings = new WeakMap();
     views = new WeakMap();
     callers = new Map();
-    constructor(record, contract, owner) {
-        this.record = record;
+    constructor(object, contract, owner) {
+        this.object = object;
         this.contract = contract;
         this.owner = owner;
-        this.address = record.address;
-        this.status = record.status === "live" ? "live" : "loading";
-        this.ready = record.ready.then(() => {
+        this.address = object.address;
+        this.status = object.status === "live" ? "live" : "loading";
+        this.ready = object.ready.then(() => {
             if (this.status === "gone")
                 throw this.error;
             if (this.status === "released")
-                throw new ChordError("released", `handle ${this.address} released`);
+                throw new ChordError("released", `reference ${this.address} released`);
         });
         this.ready.catch(noop);
         this.proxy = new Proxy(this, {
             get: (target, property) => {
-                if (HANDLE_BASE.has(property)) {
+                if (REF_BASE.has(property)) {
                     const value = Reflect.get(target, property, target);
                     return typeof value === "function" ? value.bind(target) : value;
                 }
@@ -351,24 +508,23 @@ export class HandleImpl {
                     return undefined;
                 return target.member(property);
             },
-            has: (target, property) => HANDLE_BASE.has(property) || target.member(String(property)) !== undefined,
+            has: (target, property) => REF_BASE.has(property) || target.member(String(property)) !== undefined,
         });
-        holdsByProxy.set(this.proxy, this);
+        refsByProxy.set(this.proxy, this);
     }
-    get kind() {
+    get variant() {
         const view = this.currentView();
-        return view === undefined ? undefined : kindOf(view);
+        return view === undefined ? undefined : variantOf(view);
     }
     get shape() {
-        const installed = this.status === "live" ? this.record.currentInstalled() : undefined;
+        const installed = this.status === "live" ? this.object.currentInstalled() : undefined;
         const view = installed === undefined ? undefined : this.#safeView(installed);
         if (installed === undefined || view === undefined)
             return undefined;
         return {
-            kind: kindOf(view),
-            members: Object.keys(view).filter((key) => key !== "kind"),
+            variant: variantOf(view),
+            members: Object.keys(view).filter((key) => key !== "variant"),
             contract: installed.service.contract.fingerprint,
-            epoch: installed.epoch,
         };
     }
     onShape(listener) {
@@ -381,7 +537,7 @@ export class HandleImpl {
     }
     #statusListeners = new Set();
     #statusChanged() {
-        notifyStatus(this.#statusListeners, this.status, this.error, (error) => this.record.host.report(error));
+        notifyStatus(this.#statusListeners, this.status, this.error, (error) => this.object.host.report(error));
     }
     release() {
         if (this.status === "released" || this.status === "gone")
@@ -389,7 +545,7 @@ export class HandleImpl {
         this.status = "released";
         this.#stopReadables();
         this.#statusChanged();
-        this.record.release(this);
+        this.object.release(this);
     }
     // ─── internal ───
     live() {
@@ -422,15 +578,15 @@ export class HandleImpl {
                     listener(shape);
                 }
                 catch (error) {
-                    this.record.host.report(error);
+                    this.object.host.report(error);
                 }
             }
         });
     }
     terminalError() {
-        return this.status === "gone" ? this.error : new ChordError("released", `handle ${this.address} released`);
+        return this.status === "gone" ? this.error : new ChordError("released", `reference ${this.address} released`);
     }
-    /** The behavior as this consumer sees it (through an accepts adapter when bound to another version). */
+    /** The implementation as this consumer sees it (through an accepts adapter when bound to another version). */
     viewOf(installed) {
         let adapter = this.bindings.get(installed.service);
         if (!this.bindings.has(installed.service)) {
@@ -438,18 +594,18 @@ export class HandleImpl {
             this.bindings.set(installed.service, adapter);
         }
         if (adapter === undefined)
-            return installed.behavior;
-        let view = this.views.get(installed.behavior);
+            return installed.implementation;
+        let view = this.views.get(installed.implementation);
         if (view === undefined) {
-            view = adapter(installed.behavior);
-            this.views.set(installed.behavior, view);
+            view = adapter(installed.implementation);
+            this.views.set(installed.implementation, view);
         }
         return view;
     }
     currentView() {
         if (this.status !== "live")
             return undefined;
-        const installed = this.record.currentInstalled();
+        const installed = this.object.currentInstalled();
         return installed === undefined ? undefined : this.#safeView(installed);
     }
     /** The view, or undefined when this consumer no longer binds (reported; calls reject with the bind error). */
@@ -458,14 +614,14 @@ export class HandleImpl {
             return this.viewOf(installed);
         }
         catch (error) {
-            this.record.host.report(error);
+            this.object.host.report(error);
             return undefined;
         }
     }
-    describe(kind, member) {
+    describe(variant, member) {
         const variants = this.contract.description.variants;
-        if (kind !== undefined)
-            return variants[kind]?.[member];
+        if (variant !== undefined)
+            return variants[variant]?.[member];
         for (const members of Object.values(variants))
             if (members[member] !== undefined)
                 return members[member];
@@ -473,7 +629,7 @@ export class HandleImpl {
     }
     /** Remote consumers see only the members their contract lists for the current variant. */
     inVariant(view, name) {
-        return this.contract.scope !== "remote" || this.describe(kindOf(view), name) !== undefined;
+        return this.contract.scope !== "remote" || this.describe(variantOf(view), name) !== undefined;
     }
     member(name) {
         const declared = this.describe(undefined, name);
@@ -497,8 +653,11 @@ export class HandleImpl {
     caller(name) {
         let caller = this.callers.get(name);
         if (caller === undefined) {
-            caller = (args, ctx) => {
-                if (this.record.host.inFactory > 0) {
+            const noArgs = takesNoArgs(this.contract, name);
+            caller = (...given) => {
+                // A method without arguments is called as `ref.name(ctx)`.
+                const [args, ctx] = (noArgs ? [undefined, given[0]] : given);
+                if (this.object.host.inFactory > 0) {
                     throw new ChordError("not_ready", `${this.address}.${name} called inside a factory`);
                 }
                 if (ctx !== undefined && !(ctx instanceof CtxImpl)) {
@@ -507,16 +666,16 @@ export class HandleImpl {
                 if (ctx === undefined || ctx.holder) {
                     // A code holder (task) starts a fresh root per call, cancelled with the holder.
                     try {
-                        ctx?.check(this.record.host);
+                        ctx?.check(this.object.host);
                     }
                     catch (error) {
                         return Promise.reject(error);
                     }
-                    return this.record.host.root((root) => this.record.call(this, name, args, root), {
+                    return this.object.host.root((root) => this.object.call(this, name, args, root), {
                         signal: ctx?.signal,
                     });
                 }
-                return this.record.call(this, name, args, ctx);
+                return this.object.call(this, name, args, ctx);
             };
             this.callers.set(name, caller);
         }
@@ -527,42 +686,45 @@ export class HandleImpl {
             readable.stop();
     }
 }
-export const kindOf = (behavior) => typeof behavior.kind === "string" ? behavior.kind : undefined;
+export const variantOf = (implementation) => typeof implementation.variant === "string" ? implementation.variant : undefined;
 /**
  * Two `select` functions are the same if they are identical or have the same source text: an inline arrow is a new
- * object on every factory run, but its code is what matters. (A select whose behavior depends on captured values
+ * object on every factory run, but its code is what matters. (A select whose implementation depends on captured values
  * that change between runs is not detected; such a listener keeps its old subscription until its source changes.)
  */
 const sameSelect = (a, b) => a === b || (a !== undefined && b !== undefined && String(a) === String(b));
-export class RecordImpl {
+export class ObjectImpl {
     host;
     address;
     typeName;
     input;
     principal;
-    eager;
+    /** The one object of a `lifetime: "host"` type: only such objects may register. */
+    hostLifetime;
     status = "activating";
     ready = Promise.resolve();
     service;
-    stateVersion = 0;
-    /** Calls carrying an older epoch are rejected upgrade_conflict (state bump or exclusive resource replaced). */
-    minEpoch = 0;
+    /** Calls carrying an older code version are rejected upgrade_conflict (state bump or exclusive resource replaced). */
+    minCodeVersion = 0;
     decls = new Decls();
     /** Declarations of a factory run that has not been installed yet (activation or reload candidate). */
     pending = new Set();
-    behaviors = new Map();
-    holds = new Set();
+    implementations = new Map();
+    refs = new Set();
     leases = new Map();
     openOrder = [];
     callAbort = new AbortController();
     activationAbort = new AbortController();
     gate;
-    /** Served only by a running reload's pending epoch: listeners, tasks and registrations start at its commit. */
+    /** Served only by a running reload's pending code version: listeners, tasks and registrations start at its commit. */
     deferredRuntime = false;
     #subscriptions = new Map();
     #invocations = new Set();
     #tasks = new Map();
-    #stopped = [];
+    /** Aborted task runs that have not finished yet. */
+    #stopped = new Set();
+    /** Bumped by every start and stop of the tasks: a delayed start that is no longer the latest is dropped. */
+    #taskRuns = 0;
     #linger;
     #disposal;
     constructor(host, identity) {
@@ -571,12 +733,12 @@ export class RecordImpl {
         this.typeName = identity.typeName;
         this.input = identity.input;
         this.principal = identity.principal;
-        this.eager = identity.eager;
+        this.hostLifetime = identity.hostLifetime;
     }
     start(after) {
         this.ready = this.#activate(after).then(() => {
-            for (const handle of this.holds)
-                handle.live();
+            for (const ref of this.refs)
+                ref.live();
             this.#maybeIdle();
         }, (cause) => {
             if (this.status === "activating")
@@ -584,15 +746,15 @@ export class RecordImpl {
             this.host.forget(this);
             // A ChordError (forbidden, a dependency's error, ...) keeps its code; anything else is `unavailable`.
             const error = asChordError(cause, `activating ${this.address}`);
-            for (const handle of this.holds)
-                handle.gone(error);
+            for (const ref of this.refs)
+                ref.gone(error);
             throw error;
         });
         this.ready.catch(noop);
     }
     /**
      * Activation as one transaction: factory, opens, then a synchronous finalization (registry check and publication,
-     * behaviors, runtime). Every failure, including one during finalization or a release while listeners start,
+     * implementations, runtime). Every failure, including one during finalization or a release while listeners start,
      * unwinds everything this activation did.
      */
     async #activate(after) {
@@ -605,35 +767,46 @@ export class RecordImpl {
         if (service === undefined)
             throw new ChordError("unavailable", `${this.typeName} is not served`, { reason: "unknown_type" });
         this.service = service;
-        this.stateVersion = service.stateVersion;
         const run = this.run(service, undefined);
         try {
-            await this.open(run.created.resources, run.created.holds, signal);
+            await this.open(run.created.resources, run.created.refs, signal);
+            if (signal.aborted)
+                throw abandoned();
+            await this.waitHydrated(run);
+            if (signal.aborted)
+                throw abandoned();
+            await this.initCells(run, signal);
             if (signal.aborted)
                 throw abandoned();
             this.host.checkRegistrations(this, run.decls);
             this.decls = run.decls;
-            for (const [retained, services] of this.host.retainedEpochs()) {
+            for (const [retained, services] of this.host.retainedCodeVersions()) {
                 if (services.get(this.typeName) === service) {
-                    this.behaviors.set(retained, { epoch: retained, service, behavior: run.behavior, decls: run.decls });
+                    this.implementations.set(retained, {
+                        codeVersion: retained,
+                        service,
+                        implementation: run.implementation,
+                        decls: run.decls,
+                    });
                 }
             }
-            const pending = this.host.pendingEpoch();
-            if (!this.behaviors.has(this.host.currentEpoch()) && (pending === undefined || !this.behaviors.has(pending))) {
+            const pending = this.host.pendingCodeVersion();
+            if (!this.implementations.has(this.host.currentCodeVersion()) &&
+                (pending === undefined || !this.implementations.has(pending))) {
                 throw new ChordError("superseded", `${this.address}: code changed during activation`);
             }
             for (const derived of run.created.derives)
                 derived.attach();
             this.refreshSchemas();
-            // Served only by a running reload's pending epoch: new code must not run (listeners, tasks, registrations)
-            // before that reload commits.
-            this.deferredRuntime = !this.behaviors.has(this.host.currentEpoch());
+            // Served only by a running reload's pending code version: new code must not run (listeners, tasks,
+            // registrations) before that reload commits.
+            this.deferredRuntime = !this.implementations.has(this.host.currentCodeVersion());
             if (!this.deferredRuntime) {
                 if (run.decls.registrations.size > 0)
                     this.host.registriesChanged(this);
                 this.startRuntime();
             }
-            // A listener starting up may have released the last hold synchronously: no resurrection.
+            // A listener starting up may have released the last reference synchronously: no resurrection.
             if (signal.aborted)
                 throw abandoned();
             this.status = "live";
@@ -644,11 +817,11 @@ export class RecordImpl {
             this.stopListeners();
             this.stopTasks();
             const registered = this.decls.registrations.size > 0 && !this.deferredRuntime;
-            this.behaviors.clear();
+            this.implementations.clear();
             this.decls = new Decls();
             if (registered)
                 this.host.registriesChanged();
-            await Promise.allSettled([...this.#invocations, ...this.#stopped.splice(0)]);
+            await Promise.allSettled([...this.#invocations, ...this.#stopped]);
             await this.unwind(run).catch((cleanup) => this.host.report(cleanup));
             throw error;
         }
@@ -668,9 +841,9 @@ export class RecordImpl {
         };
         this.pending.add(self.run(undefined).decls);
         this.host.inFactory++;
-        let behavior;
+        let implementation;
         try {
-            behavior = service.factory(this.input, this.principal, self);
+            implementation = service.factory(this.input, this.principal, self);
         }
         catch (error) {
             this.host.inFactory--;
@@ -678,11 +851,11 @@ export class RecordImpl {
             throw error;
         }
         this.host.inFactory--;
-        const run = self.run(behavior);
+        const run = self.run(implementation);
         try {
-            if (behavior instanceof Promise)
-                throw invalid("behavior", `${this.typeName}: factories must be synchronous`);
-            validateBehavior(service, run.behavior);
+            if (implementation instanceof Promise)
+                throw invalid("implementation", `${this.typeName}: factories must be synchronous`);
+            validateImplementation(service, run.implementation);
         }
         catch (error) {
             discard(run);
@@ -690,8 +863,8 @@ export class RecordImpl {
         }
         return run;
     }
-    /** Opens resources (dependencies first) and waits for holds; settles all before failing. */
-    async open(resources, holds, signal) {
+    /** Opens resources (dependencies first) and waits for references; settles all before failing. */
+    async open(resources, refs, signal) {
         const opening = new Map();
         const openOne = (resource) => {
             let promise = opening.get(resource);
@@ -704,29 +877,85 @@ export class RecordImpl {
             }
             return promise;
         };
-        const results = await Promise.allSettled([...resources.map(openOne), ...holds.map((hold) => hold.ready)]);
+        const ready = this.withinReadyTimeout(Promise.all(refs.map((ref) => ref.ready)), () => refs.filter((ref) => ref.status === "loading").map((ref) => ref.address));
+        const results = await Promise.allSettled([...resources.map(openOne), ready]);
         const failure = results.find((result) => result.status === "rejected");
         if (failure !== undefined)
             throw failure.reason;
     }
-    /** Undoes the objects a run created: closes its resources (reverse order) and releases its holds. */
+    /**
+     * Waits until the state sources a run exposes or derives from have their values: a local object goes live only with
+     * its state, also where it forwards or derives from a remote reference's member.
+     */
+    async waitHydrated(run) {
+        const exposed = Object.entries(run.implementation ?? {});
+        const pending = unhydrated([...run.created.derives, ...exposed.map(([, value]) => value)]);
+        if (pending.length === 0)
+            return;
+        await this.withinReadyTimeout(Promise.all(pending.map((hydration) => hydration.whenHydrated())), () => [
+            ...exposed
+                .filter(([, value]) => hydrationOf(value)?.hydrated === false)
+                .map(([name]) => `${this.address}.${name}`),
+            ...run.created.derives
+                .filter((derived) => hydrationOf(derived) !== undefined)
+                .map((derived) => `derive ${derived.key}`),
+        ]);
+    }
+    /** `work` within the host's `readyTimeout`; a timeout names what is still awaited. */
+    async withinReadyTimeout(work, waiting) {
+        const ms = this.host.readyTimeout;
+        if (!Number.isFinite(ms))
+            return work;
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                const list = waiting();
+                reject(new ChordError("unavailable", `${this.address} was not ready after ${ms} ms${list.length === 0 ? "" : `, waiting on ${list.join(", ")}`} (a reference cycle across hosts?)`, { reason: "ready_timeout" }));
+            }, ms);
+            timer.unref?.();
+        });
+        timeout.catch(noop);
+        try {
+            return await Promise.race([work, timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Fills the cells `run` created with `init`, each in a root of its own, in parallel; settles all before failing. Runs
+     * after the run's resources are open and its references live, before anything reads the cells.
+     */
+    async initCells(run, signal) {
+        if (run.created.inits.length === 0)
+            return;
+        const results = await Promise.allSettled(run.created.inits.map(async ([cell, init]) => {
+            const value = await this.host.root((ctx) => init(ctx), { signal });
+            if (!signal.aborted)
+                cell.initialize(value);
+        }));
+        const failure = results.find((result) => result.status === "rejected");
+        if (failure !== undefined)
+            throw failure.reason;
+    }
+    /** Undoes the objects a run created: closes its resources (reverse order) and releases its references. */
     async unwind(run) {
         for (const derived of run.created.derives)
             derived.detach();
         const resources = [...run.created.resources].sort((a, b) => this.openOrder.indexOf(b) - this.openOrder.indexOf(a));
         await runAll([
             ...resources.map((resource) => () => resource.close(this.openOrder)),
-            ...run.created.holds.map((hold) => () => hold.release()),
+            ...run.created.refs.map((ref) => () => ref.release()),
         ], `${this.address}: cleanup failed`);
     }
     currentInstalled() {
-        return this.behaviors.get(this.host.currentEpoch()) ?? [...this.behaviors.values()].at(-1);
+        return this.implementations.get(this.host.currentCodeVersion()) ?? [...this.implementations.values()].at(-1);
     }
     /** Every state source exposed as a remote state member gets that member's schema (checked per write in dev mode). */
     refreshSchemas() {
         const schemas = new Map();
-        for (const installed of this.behaviors.values()) {
-            for (const [source, list] of memberSchemas(installed.service, installed.behavior)) {
+        for (const installed of this.implementations.values()) {
+            for (const [source, list] of memberSchemas(installed.service, installed.implementation)) {
                 schemas.set(source, [...(schemas.get(source) ?? []), ...list]);
             }
         }
@@ -737,7 +966,7 @@ export class RecordImpl {
     }
     allDecls() {
         const result = new Set([this.decls, ...this.pending]);
-        for (const installed of this.behaviors.values())
+        for (const installed of this.implementations.values())
             result.add(installed.decls);
         return result;
     }
@@ -752,7 +981,7 @@ export class RecordImpl {
         const value = resource === undefined ? decl.source : resource.value;
         const source = (decl.select === undefined ? value : decl.select(value));
         if (typeof source?.subscribe !== "function")
-            throw invalid("behavior", `listener ${key}: source has no subscribe()`);
+            throw invalid("implementation", `listener ${key}: source has no subscribe()`);
         return source;
     }
     /**
@@ -780,6 +1009,15 @@ export class RecordImpl {
                     buffer: [],
                 };
                 fresh.set(key, entry);
+                // State (a readable) is subscribed when the listener activates: it delivers the value current then, not one
+                // of the candidate before the commit (a new derivation computes its value at the commit).
+                if (isSource(source) || isReadableLike(source)) {
+                    entry.buffer = undefined;
+                    entry.subscribe = () => {
+                        entry.unsubscribe = source.subscribe((event) => this.#deliver(key, event));
+                    };
+                    continue;
+                }
                 entry.unsubscribe = source.subscribe((event) => {
                     if (entry.buffer !== undefined)
                         entry.buffer.push(event);
@@ -803,6 +1041,7 @@ export class RecordImpl {
                 }
                 for (const [key, entry] of fresh) {
                     this.#subscriptions.set(key, entry);
+                    entry.subscribe?.();
                     const buffered = entry.buffer ?? [];
                     entry.buffer = undefined;
                     for (const event of buffered)
@@ -819,24 +1058,51 @@ export class RecordImpl {
         this.stageListeners(this.decls).activate();
         this.startTasks();
     }
+    /**
+     * Starts the tasks of the current declarations. Runs aborted by `stopTasks` (a reload, a gate) may still be finishing:
+     * their replacements start once they all finished, or after `taskStopDeadline` (reported), so the old and the new run
+     * of a task never work side by side. A later start or stop, or the object leaving `live`, cancels a delayed start.
+     */
     startTasks() {
-        for (const key of this.decls.tasks.keys())
-            this.startTask(key, this.host.currentEpoch());
+        const run = ++this.#taskRuns;
+        const start = () => {
+            for (const key of this.decls.tasks.keys())
+                this.#startTask(key, this.host.currentCodeVersion());
+        };
+        if (this.#stopped.size === 0) {
+            start();
+            return;
+        }
+        const deadline = this.host.taskStopDeadline;
+        let timer;
+        const late = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(true), deadline);
+        });
+        const stopped = Promise.allSettled([...this.#stopped]).then(() => false);
+        void Promise.race([stopped, late]).then((missed) => {
+            clearTimeout(timer);
+            if (run !== this.#taskRuns || this.status !== "live")
+                return;
+            if (missed) {
+                this.host.report(new ChordError("aborted", `${this.address}: aborted tasks still running after ${deadline} ms; starting their replacements anyway`));
+            }
+            start();
+        });
     }
     stopListeners() {
         for (const subscription of this.#subscriptions.values())
             subscription.unsubscribe();
         this.#subscriptions.clear();
     }
-    startTask(key, epoch) {
+    #startTask(key, codeVersion) {
         const fn = this.decls.tasks.get(key);
         if (fn === undefined)
             return;
         const controller = new AbortController();
         const ctx = new CtxImpl(this.host, {
-            signal: AbortSignal.any([controller.signal, this.callAbort.signal]),
+            signals: [controller.signal, this.callAbort.signal],
             rootId: `task:${this.address}:${key}`,
-            epoch,
+            codeVersion,
             principal: this.host.principal,
             holder: true,
         });
@@ -856,17 +1122,23 @@ export class RecordImpl {
         })();
         this.#tasks.set(key, { controller, done });
     }
-    /** Aborts running tasks; their completion is awaited at disposal. */
+    /**
+     * Aborts running tasks (and cancels a delayed start). Their completion is awaited by the next `startTasks` and at
+     * disposal; each leaves `#stopped` when it finishes.
+     */
     stopTasks() {
+        this.#taskRuns++;
         for (const task of this.#tasks.values()) {
             task.controller.abort(new ChordError("aborted", "task stopped"));
-            this.#stopped.push(task.done);
+            const done = task.done;
+            this.#stopped.add(done);
+            void done.finally(() => this.#stopped.delete(done));
         }
         this.#tasks.clear();
     }
     /**
-     * Delivers one listener event, in publication order. The invocation is a root that holds a lease on this record
-     * (a reload gate waits for it like for any other root that touched the record), counts as an invocation (disposal
+     * Delivers one listener event, in publication order. The invocation is a root that references a lease on this object
+     * (a reload gate waits for it like for any other root that touched the object), counts as an invocation (disposal
      * waits for it) and is cancelled by forced disposal.
      */
     #deliver(key, event) {
@@ -893,7 +1165,7 @@ export class RecordImpl {
             invocation.catch((error) => this.host.report(error));
         });
     }
-    /** Opens the record's gate and replays queued listener events through the current listeners. */
+    /** Opens the object's gate and replays queued listener events through the current listeners. */
     openGate() {
         const gate = this.gate;
         this.gate = undefined;
@@ -906,20 +1178,20 @@ export class RecordImpl {
         if (this.host.failed !== undefined) {
             throw new ChordError("unavailable", `${this.host.name} failed and admits no work`, { reason: "host_failed" });
         }
-        if (!this.host.hasEpoch(ctx.epoch))
-            throw new ChordError("superseded", `epoch ${ctx.epoch} is retired`);
-        if (ctx.epoch < this.minEpoch) {
-            throw new ChordError("upgrade_conflict", `${this.address} was upgraded in epoch ${this.minEpoch}`);
+        if (!this.host.hasCodeVersion(ctx.codeVersion))
+            throw new ChordError("superseded", `code version ${ctx.codeVersion} is retired`);
+        if (ctx.codeVersion < this.minCodeVersion) {
+            throw new ChordError("upgrade_conflict", `${this.address} was upgraded in code version ${this.minCodeVersion}`);
         }
         if (this.gate !== undefined && !this.gate.grandfathered.has(ctx.rootId)) {
             throw new ChordError("upgrade_conflict", `${this.address} is being upgraded`);
         }
     }
-    /** Records that the root of `ctx` touched this record (a reload gate grandfathers it). */
+    /** Records that the root of `ctx` touched this object (a reload gate grandfathers it). */
     lease(ctx) {
         if (this.leases.has(ctx.rootId))
             return;
-        this.leases.set(ctx.rootId, ctx.epoch);
+        this.leases.set(ctx.rootId, ctx.codeVersion);
         this.host.touch(ctx.rootId, this);
     }
     guard = (ctx) => {
@@ -935,52 +1207,65 @@ export class RecordImpl {
             return;
         this.admit(ctx);
     };
-    async call(handle, name, args, ctx) {
+    async call(ref, name, args, ctx) {
         ctx.check(this.host);
-        if (handle.status === "released" || handle.status === "gone")
-            throw handle.terminalError();
-        if (handle.status === "loading")
-            await raceSignal(handle.ready, ctx.signal);
-        if (handle.status !== "live" || this.status !== "live") {
-            throw handle.status === "live"
+        if (ref.status === "released" || ref.status === "gone")
+            throw ref.terminalError();
+        if (ref.status === "loading")
+            await raceSignal(ref.ready, ctx.signal);
+        if (ref.status !== "live" || this.status !== "live") {
+            throw ref.status === "live"
                 ? new ChordError("gone", `${this.address} is ${this.status}`)
-                : handle.terminalError();
+                : ref.terminalError();
         }
         this.admit(ctx);
-        const installed = this.behaviors.get(ctx.epoch);
+        const installed = this.implementations.get(ctx.codeVersion);
         if (installed === undefined)
-            throw new ChordError("superseded", `${this.address} has no behavior for epoch ${ctx.epoch}`);
-        const view = handle.viewOf(installed);
-        const kind = kindOf(view);
-        const wanted = handle.describe(handle.contract.scope === "remote" ? kind : LOCAL_VARIANT, name);
+            throw new ChordError("superseded", `${this.address} has no implementation for code version ${ctx.codeVersion}`);
+        const view = ref.viewOf(installed);
+        const variant = variantOf(view);
+        const wanted = ref.describe(ref.contract.scope === "remote" ? variant : LOCAL_VARIANT, name);
         const fn = view[name];
-        if (typeof fn !== "function" || (handle.contract.scope === "remote" && wanted?.kind !== "method")) {
-            throw new ChordError("not_in_variant", `${this.address}: ${name} is not a method of variant ${kind ?? "(local)"}`);
+        if (typeof fn !== "function" || (ref.contract.scope === "remote" && wanted?.kind !== "method")) {
+            throw new ChordError("not_in_variant", `${this.address}: ${name} is not a method of variant ${variant ?? "(local)"}`);
+        }
+        const direct = view === installed.implementation;
+        const schema = direct
+            ? installed.service.contract.description.variants[variant ?? LOCAL_VARIANT]?.[name]
+            : wanted;
+        const method = schema?.kind === "method" ? schema : undefined;
+        const validated = ref.contract.scope === "remote" ? method : undefined;
+        // No arguments: the handler takes only ctx. No result (void): the caller gets undefined, whatever it returned.
+        const takesArgs = method === undefined || method.args !== undefined;
+        const returns = method === undefined || method.result !== undefined;
+        let input;
+        if (takesArgs) {
+            // The additive rule assumes a consumer sends only what its own schema knows, and a provider sees only what its
+            // schema knows: strip with both before validating.
+            const own = ref.contract.scope === "remote" && wanted?.kind === "method" ? wanted.args : undefined;
+            const sent = own === undefined ? args : Value.Clean(own, Value.Clone(args));
+            input = validated?.args ? Value.Clean(validated.args, Value.Clone(sent)) : sent;
+            if (validated?.args)
+                assertValid("args", `${this.address}.${name} args`, validated.args, input);
         }
-        const direct = view === installed.behavior;
-        const schema = direct ? installed.service.contract.description.variants[kind ?? LOCAL_VARIANT]?.[name] : wanted;
-        const validated = handle.contract.scope === "remote" && schema?.kind === "method" ? schema : undefined;
-        // The additive rule assumes a consumer sends only what its own schema knows, and a provider sees only what its
-        // schema knows: strip with both before validating.
-        const own = handle.contract.scope === "remote" && wanted?.kind === "method" ? wanted.args : undefined;
-        const sent = own === undefined ? args : Value.Clean(own, Value.Clone(args));
-        const input = validated ? Value.Clean(validated.args, Value.Clone(sent)) : sent;
-        if (validated)
-            assertValid("args", `${this.address}.${name} args`, validated.args, input);
         this.lease(ctx);
         const child = ctx.child(this);
         let result;
         try {
-            result = await this.#invoke(() => fn(input, child));
+            result = await this.#invoke(() => takesArgs
+                ? fn(input, child)
+                : fn(child));
         }
         finally {
             child.close();
         }
-        if (validated)
+        if (!returns)
+            return undefined;
+        if (validated?.result)
             assertValid("result", `${this.address}.${name} result`, validated.result, result);
         return result;
     }
-    /** Runs an invocation (method or listener) that keeps the record alive until it settles. */
+    /** Runs an invocation (method or listener) that keeps the object alive until it settles. */
     #invoke(fn) {
         const invocation = (async () => fn())();
         this.#invocations.add(invocation);
@@ -999,19 +1284,19 @@ export class RecordImpl {
             gate.drained();
     }
     // ─── lifetime ───
-    addHold(handle) {
-        this.holds.add(handle);
+    addRef(ref) {
+        this.refs.add(ref);
         if (this.#linger !== undefined)
             clearTimeout(this.#linger);
         this.#linger = undefined;
     }
-    release(handle) {
-        if (this.holds.delete(handle))
+    release(ref) {
+        if (this.refs.delete(ref))
             this.#maybeIdle();
     }
-    /** No holds and no invocations: dispose (after `linger` for a live record). */
+    /** No references and no invocations: dispose (after `linger` for a live object). */
     #maybeIdle() {
-        if (this.holds.size > 0 || this.#invocations.size > 0 || this.#linger !== undefined)
+        if (this.refs.size > 0 || this.#invocations.size > 0 || this.#linger !== undefined)
             return;
         if (this.status === "activating") {
             this.#background(this.dispose(false));
@@ -1026,7 +1311,7 @@ export class RecordImpl {
         }
         this.#linger = setTimeout(() => {
             this.#linger = undefined;
-            if (this.holds.size === 0 && this.#invocations.size === 0 && this.status === "live") {
+            if (this.refs.size === 0 && this.#invocations.size === 0 && this.status === "live") {
                 this.#background(this.dispose(false));
             }
         }, linger);
@@ -1036,7 +1321,7 @@ export class RecordImpl {
         disposal.catch((error) => this.host.report(error));
     }
     /**
-     * Disposes the record. Forced: handles become gone at once (new calls are rejected) and running invocations are
+     * Disposes the object. Forced: references become gone at once (new calls are rejected) and running invocations are
      * cancelled. Either way, resources close only after every invocation settled.
      */
     dispose(forced, reason) {
@@ -1052,40 +1337,41 @@ export class RecordImpl {
         this.#linger = undefined;
         const error = reason ?? new ChordError("gone", `${this.address} was disposed`);
         if (forced) {
-            for (const handle of this.holds)
-                handle.gone(error);
+            for (const ref of this.refs)
+                ref.gone(error);
             this.callAbort.abort(error);
         }
         this.activationAbort.abort(error);
         if (wasActivating)
             await this.ready.catch(noop);
-        for (const handle of this.holds)
-            handle.gone(error);
+        for (const ref of this.refs)
+            ref.gone(error);
         const decls = this.allDecls();
         this.stopTasks();
         this.stopListeners();
         await Promise.allSettled([...this.#invocations]);
         const registered = [...decls].some((set) => set.registrations.size > 0) && !this.deferredRuntime;
-        this.behaviors.clear();
+        this.implementations.clear();
         this.decls = new Decls();
         if (registered)
             this.host.registriesChanged();
-        const holds = new Set();
+        const refs = new Set();
         for (const set of decls) {
             for (const derived of set.derives.values())
                 derived.detach();
-            for (const hold of set.holds.values())
-                holds.add(hold);
+            for (const ref of set.refs.values())
+                refs.add(ref);
         }
         try {
             await runAll([
-                () => Promise.allSettled(this.#stopped.splice(0)),
+                () => Promise.allSettled([...this.#stopped]),
                 ...[...this.openOrder].reverse().map((resource) => () => resource.close(this.openOrder)),
-                ...[...holds].map((hold) => () => hold.release()),
+                ...[...refs].map((ref) => () => ref.release()),
             ], `${this.address}: disposal failed`);
         }
         finally {
             this.status = "disposed";
+            this.host.disposed(this);
         }
     }
 }
@@ -1093,43 +1379,43 @@ const isReadableLike = (value) => value !== null &&
     typeof value === "object" &&
     typeof value.events === "function" &&
     typeof value.subscribe === "function";
-/** The remote state-member schemas a behavior exposes, by source. */
-export function memberSchemas(service, behavior) {
+/** The remote state-member schemas an implementation exposes, by source. */
+export function memberSchemas(service, implementation) {
     const schemas = new Map();
     const contract = service.contract;
     if (contract.scope !== "remote")
         return schemas;
-    const members = contract.description.variants[kindOf(behavior) ?? ""] ?? {};
+    const members = contract.description.variants[variantOf(implementation) ?? ""] ?? {};
     for (const [name, description] of Object.entries(members)) {
-        const source = behavior[name];
+        const source = implementation[name];
         if (description.kind !== "state" || !isSource(source))
             continue;
         schemas.set(source, [...(schemas.get(source) ?? []), description.schema]);
     }
     return schemas;
 }
-function validateBehavior(service, behavior) {
+function validateImplementation(service, implementation) {
     const contract = service.contract;
     const fail = (message) => {
-        throw invalid("behavior", `${contract.name}: ${message}`);
+        throw invalid("implementation", `${contract.name}: ${message}`);
     };
-    if (behavior === null || typeof behavior !== "object")
+    if (implementation === null || typeof implementation !== "object")
         fail("factory must return an object");
     let members;
     if (contract.scope === "remote") {
-        const kind = behavior.kind;
-        if (typeof kind !== "string" || contract.description.variants[kind] === undefined)
-            fail(`unknown variant ${String(kind)}`);
-        members = contract.description.variants[kind];
-        for (const key of Object.keys(behavior))
-            if (key !== "kind" && members[key] === undefined)
-                fail(`${key} is not in variant ${String(kind)}`);
+        const variant = implementation.variant;
+        if (typeof variant !== "string" || contract.description.variants[variant] === undefined)
+            fail(`unknown variant ${String(variant)}`);
+        members = contract.description.variants[variant];
+        for (const key of Object.keys(implementation))
+            if (key !== "variant" && members[key] === undefined)
+                fail(`${key} is not in variant ${String(variant)}`);
     }
     else {
         members = contract.description.variants[LOCAL_VARIANT] ?? {};
     }
     for (const [name, description] of Object.entries(members)) {
-        const value = behavior[name];
+        const value = implementation[name];
         if (description.kind === "method" && typeof value !== "function")
             fail(`${name} must be a method`);
         if (description.kind === "state" && !isSource(value) && !isReadableLike(value)) {
@@ -1141,152 +1427,145 @@ function validateBehavior(service, behavior) {
 }
 // ─── The factory's `self` ────────────────────────────────────────────────────
 class SelfImpl {
-    #record;
+    #object;
     #previous;
     #decls = new Decls();
-    #created = {
-        holds: [],
-        resources: [],
-        derives: [],
-    };
-    constructor(record, previous) {
-        this.#record = record;
+    #created = { refs: [], resources: [], derives: [], inits: [] };
+    constructor(object, previous) {
+        this.#object = object;
         this.#previous = previous;
     }
-    run(behavior) {
-        return { behavior: behavior, decls: this.#decls, created: this.#created };
-    }
-    /** Iterates named declarations of one kind, rejecting repeated names and wrong descriptors. */
-    *#entries(map, kind, entries, descriptor) {
-        if (entries === null || typeof entries !== "object")
-            throw new TypeError(`${kind} takes an object of named declarations`);
-        for (const [name, value] of Object.entries(entries)) {
-            if (map.has(name))
-                throw invalid("duplicate", `${this.#record.typeName}: duplicate ${kind} name ${name}`);
-            if (descriptor !== undefined && declKind(value) !== descriptor) {
-                throw new TypeError(`${kind}.${name} must be declared with ${descriptor}()`);
-            }
-            yield [name, value];
-        }
-    }
-    state(cells) {
-        const result = {};
-        const host = this.#record.host;
-        for (const [name, decl] of this.#entries(this.#decls.cells, "state", cells, "cell")) {
-            const cell = this.#previous?.cells.get(name) ??
-                new Cell(name, decl.schema, decl.initial, this.#record.guard, {
-                    dev: host.dev,
-                    report: (error) => host.report(error),
-                });
-            this.#decls.cells.set(name, cell);
-            this.#decls.cellSchemas.set(name, decl.schema);
-            result[name] = cell;
+    run(implementation) {
+        return { implementation: implementation, decls: this.#decls, created: this.#created };
+    }
+    /** Refuses a second declaration of `name` of one kind in this run (TypeScript cannot see string names). */
+    #unique(map, kind, name) {
+        if (typeof name !== "string" || name === "")
+            throw new TypeError(`${kind} needs a name`);
+        if (map.has(name))
+            throw invalid("duplicate", `${this.#object.typeName}: duplicate ${kind} name ${name}`);
+    }
+    state(name, schema, initial, options = {}) {
+        this.#unique(this.#decls.cells, "state", name);
+        const version = options.version ?? 1;
+        if (!Number.isInteger(version) || version < 1)
+            throw new TypeError(`state ${name}: version must be a positive integer`);
+        const host = this.#object.host;
+        // A JSON value never holds a function: an object with a function `init` is the initializer, not a value.
+        const init = isStateInit(initial) ? initial.init : undefined;
+        let cell = this.#previous?.cells.get(name);
+        if (cell === undefined) {
+            cell = new Cell(name, schema, init === undefined ? { value: initial } : undefined, this.#object.guard, {
+                dev: host.dev,
+                report: (error) => host.report(error),
+            });
+            if (init !== undefined)
+                this.#created.inits.push([cell, init]);
         }
-        return result;
+        this.#decls.cells.set(name, cell);
+        this.#decls.cellSchemas.set(name, schema);
+        this.#decls.cellVersions.set(name, version);
+        if (options.migrate !== undefined)
+            this.#decls.cellMigrations.set(name, options.migrate);
+        return cell;
     }
     get(type, input, options) {
-        const host = this.#record.host;
-        // A prepare rerun (recording mode) binds new holds against the reload's pending contracts: a breaking provider
+        const host = this.#object.host;
+        // A prepare rerun (recording mode) binds new references against the reload's pending contracts: a breaking provider
         // change and its updated consumer reload together.
         const candidate = this.#previous !== undefined;
-        const address = host.addressOf(type, input, options?.principal ?? host.principal, options?.at, candidate);
-        const declared = this.#decls.holds.get(address);
+        const address = host.addressOf(type, input, options?.principal ?? host.principal, candidate);
+        const declared = this.#decls.refs.get(address);
         if (declared !== undefined) {
             if (declared.contract.fingerprint !== type.fingerprint) {
-                throw invalid("duplicate", `${this.#record.typeName}: ${type.name} held twice with different contracts`);
+                throw invalid("duplicate", `${this.#object.typeName}: ${type.name} held twice with different contracts`);
             }
             return declared.proxy;
         }
-        const existing = this.#previous?.holds.get(address);
+        const existing = this.#previous?.refs.get(address);
         if (existing !== undefined &&
             existing.contract.fingerprint === type.fingerprint &&
             existing.status !== "gone" &&
             existing.status !== "released") {
-            this.#decls.holds.set(address, existing);
+            this.#decls.refs.set(address, existing);
             return existing.proxy;
         }
-        const handle = host.acquire(type, input, options, "record", this.#record, candidate);
-        this.#decls.holds.set(address, handle);
-        this.#created.holds.push(handle);
-        return handle.proxy;
-    }
-    resources(resources) {
-        const result = {};
-        for (const [name, { spec }] of this.#entries(this.#decls.resources, "resources", resources, "resource")) {
-            const deps = (spec.deps ?? []).map((dep) => {
-                const resolved = handleOf(dep) ?? resourceOf(dep);
-                if (resolved === undefined) {
-                    throw new TypeError(`resource ${name}: deps must be handles or resources of this record`);
-                }
-                return resolved;
-            });
-            const existing = this.#previous?.resources.get(name);
-            const kept = existing !== undefined &&
-                existing.spec.rev === spec.rev &&
-                existing.exclusive === (spec.exclusive === true) &&
-                existing.deps.length === deps.length &&
-                existing.deps.every((dep, index) => dep === deps[index]);
-            const resource = kept ? existing : new ResourceImpl(name, spec, deps);
-            if (!kept)
-                this.#created.resources.push(resource);
-            this.#decls.resources.set(name, resource);
-            result[name] = new ResourceFacade(resource, this.#record.host);
-        }
-        return result;
-    }
-    listen(listeners) {
-        for (const [name, decl] of this.#entries(this.#decls.listeners, "listen", listeners, "listener")) {
-            this.#decls.listeners.set(name, decl);
-        }
-    }
-    tasks(tasks) {
-        for (const [name, fn] of this.#entries(this.#decls.tasks, "tasks", tasks)) {
-            if (typeof fn !== "function")
-                throw new TypeError(`tasks.${name} must be a function`);
-            this.#decls.tasks.set(name, fn);
-        }
-    }
-    derive(derivations) {
-        const result = {};
-        const host = this.#record.host;
-        for (const [name, { sources, fn }] of this.#entries(this.#decls.derives, "derive", derivations, "derivation")) {
-            const existing = this.#previous?.derives.get(name);
-            let derived;
-            if (existing !== undefined &&
-                existing.sources.length === sources.length &&
-                existing.sources.every((source, index) => source === sources[index])) {
-                derived = existing;
-            }
-            else {
-                derived = new Derived(name, sources, fn, { dev: host.dev, report: (error) => host.report(error) });
-                this.#created.derives.push(derived);
+        const ref = host.acquire(type, input, options, "object", this.#object, candidate);
+        this.#decls.refs.set(address, ref);
+        this.#created.refs.push(ref);
+        return ref.proxy;
+    }
+    resource(name, declaration) {
+        this.#unique(this.#decls.resources, "resource", name);
+        if (!Number.isInteger(declaration.version))
+            throw new TypeError(`resource ${name}: version must be an integer`);
+        const deps = (declaration.deps ?? []).map((dep) => {
+            const resolved = refOf(dep) ?? resourceOf(dep);
+            if (resolved === undefined) {
+                throw new TypeError(`resource ${name}: deps must be references or resources of this object`);
             }
-            this.#decls.derives.set(name, derived);
-            this.#decls.deriveFns.set(name, fn);
-            result[name] = derived;
-        }
-        return result;
+            return resolved;
+        });
+        const existing = this.#previous?.resources.get(name);
+        const kept = existing !== undefined &&
+            existing.spec.version === declaration.version &&
+            existing.exclusive === (declaration.exclusive === true) &&
+            existing.deps.length === deps.length &&
+            existing.deps.every((dep, index) => dep === deps[index]);
+        const resource = kept ? existing : new ResourceImpl(name, declaration, deps);
+        if (kept)
+            this.#decls.adopted.set(existing, declaration);
+        else
+            this.#created.resources.push(resource);
+        this.#decls.resources.set(name, resource);
+        return new ResourceFacade(resource, this.#object.host);
+    }
+    on(name, source, ...rest) {
+        this.#unique(this.#decls.listeners, "listener", name);
+        const [select, fn] = rest.length === 1 ? [undefined, rest[0]] : [rest[0], rest[1]];
+        if (typeof fn !== "function")
+            throw new TypeError(`listener ${name}: the handler must be a function`);
+        if (select !== undefined && typeof select !== "function")
+            throw new TypeError(`listener ${name}: select must be a function`);
+        this.#decls.listeners.set(name, {
+            source,
+            select: select,
+            fn: fn,
+        });
+    }
+    task(fn) {
+        if (typeof fn !== "function")
+            throw new TypeError("a task must be a function");
+        this.#decls.tasks.set(`#${this.#decls.tasks.size}`, fn);
+    }
+    derive(sources, fn) {
+        if (typeof fn !== "function")
+            throw new TypeError("a derivation needs a function");
+        const host = this.#object.host;
+        const key = `#${this.#decls.derives.size}`;
+        const derived = new Derived(key, sources, fn, {
+            dev: host.dev,
+            report: (error) => host.report(error),
+        });
+        this.#created.derives.push(derived);
+        this.#decls.derives.set(key, derived);
+        return derived;
     }
     expose(resource) {
         const resolved = resourceOf(resource);
         if (resolved === undefined || ![...this.#decls.resources.values()].includes(resolved)) {
-            throw new TypeError("expose takes a resource declared by this record");
+            throw new TypeError("expose takes a resource declared by this object");
         }
         return new ExposedImpl(resolved);
     }
     register(registry, entries) {
-        if (!this.#record.eager)
-            throw invalid("not_eager", `${this.#record.typeName}: only eager records may register`);
-        const prefixed = {};
-        for (const [key, value] of Object.entries(entries))
-            prefixed[`${registry.name}\u0000${key}`] = value;
-        for (const [id, value] of this.#entries(this.#decls.registrations, "register", prefixed)) {
-            this.#decls.registrations.set(id, {
-                registry: registry,
-                key: id.slice(registry.name.length + 1),
-                value,
-            });
+        if (!this.#object.hostLifetime)
+            throw invalid("not_host_lifetime", `${this.#object.typeName}: only objects of lifetime "host" may register`);
+        for (const [key, value] of Object.entries(entries)) {
+            const id = `${registry.name}\u0000${key}`;
+            this.#unique(this.#decls.registrations, "register", id);
+            this.#decls.registrations.set(id, { registry: registry, key, value });
         }
     }
 }
-//# sourceMappingURL=record.js.map
+//# sourceMappingURL=object.js.map