@inhuman.tools/plexus-expectations 0.0.0-stage → 0.2.0

package/dist/executor/kernel-intern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-intern.js","sourceRoot":"","sources":["../../src/executor/kernel-intern.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Process-local connection intern table keyed by the kernel root object.\n *\n * Session wrap is Yjs load. Park drops an owner ref and must not dispose the\n * instance — {@link disposeKernelConnections} is kernel teardown only.\n * Rejected: last-ref dispose. Switching seats reminted every driver.\n */\nimport { DefaultedWeakMap } from \"@here.build/collections\";\nimport { comparer, reaction, type IReactionDisposer } from \"mobx\";\n\nimport { ConnectionMiss } from \"../driver/connection-miss.js\";\nimport { extraLiveFromState, type PEWDriver } from \"../driver/PEWDriver.js\";\nimport type { ConnectionSpec } from \"../shared/models/ConnectionSpec.js\";\nimport { asReadyState } from \"../shared/types.js\";\n\ntype InternOwner = { forgetConnection(id: string): void };\n\nfunction internOwnerOf(owner: object): InternOwner | undefined {\n  return typeof (owner as InternOwner).forgetConnection === \"function\" ? (owner as InternOwner) : undefined;\n}\n\ntype KernelRoot = { readonly connections: Record<string, ConnectionSpec | undefined> };\ntype ConnectionHold = {\n  readonly refs: Set<object>;\n  readonly pending: Promise<PEWDriver>;\n  mirror: IReactionDisposer | undefined;\n};\ntype KernelIntern = { readonly connections: Map<string, ConnectionHold> };\n\nconst internByKernel = new DefaultedWeakMap<object, KernelIntern>(() => ({ connections: new Map() }));\n\nexport function acquireConnection(\n  kernel: KernelRoot,\n  owner: object,\n  connectionId: string,\n  construct: () => PEWDriver | Promise<PEWDriver>,\n): Promise<PEWDriver> {\n  const bag = internByKernel.get(kernel);\n  const existing = bag.connections.get(connectionId);\n  if (existing !== undefined) {\n    existing.refs.add(owner);\n    return existing.pending;\n  }\n  const lease: ConnectionHold = {\n    refs: new Set([owner]),\n    pending: Promise.resolve().then(construct).then((instance) => {\n      lease.mirror = reaction(\n        () => {\n          const spec = kernel.connections[connectionId];\n          if (spec === undefined) return null;\n          const ready = asReadyState(instance.readyState);\n          // Bootstrapping remint must not wipe a ready catalog.\n          if (ready !== \"ready\" && ready !== \"failed\" && spec.readyState === \"ready\") return null;\n          return { ready, error: instance.error, live: extraLiveFromState(instance.state) };\n        },\n        (snap) => {\n          if (snap == null) return;\n          kernel.connections[connectionId]?.stampProcess({\n            readyState: snap.ready,\n            error: snap.error,\n            live: snap.live,\n          });\n        },\n        { fireImmediately: true, equals: comparer.structural },\n      );\n      return instance;\n    }),\n    mirror: undefined,\n  };\n  bag.connections.set(connectionId, lease);\n  void lease.pending.then(undefined, () => {\n    if (lease.refs.size === 0) bag.connections.delete(connectionId);\n  });\n  return lease.pending;\n}\n\nexport function releaseConnection(kernel: object, owner: object, connectionId: string): void {\n  if (!internByKernel.has(kernel)) return;\n  internByKernel.get(kernel).connections.get(connectionId)?.refs.delete(owner);\n}\n\n/**\n * Remint door. Logout/drop — not park, not last-ref.\n * Pending lease still `asyncDispose`s when it fulfills. Next `ensure` remints.\n */\nexport async function dropConnection(kernel: KernelRoot, connectionId: string): Promise<void> {\n  if (!internByKernel.has(kernel)) return;\n  const bag = internByKernel.get(kernel);\n  const lease = bag.connections.get(connectionId);\n  if (lease === undefined) return;\n  bag.connections.delete(connectionId);\n  lease.mirror?.();\n  const owners = [...lease.refs];\n  lease.refs.clear();\n  const miss = new ConnectionMiss(\"connection-dropped\", `connection ${connectionId} dropped`);\n  const disposing = lease.pending.then(\n    (instance) => {\n      instance.abortOnDrop(miss);\n      return instance[Symbol.asyncDispose]();\n    },\n    () => {},\n  );\n  for (const owner of owners) internOwnerOf(owner)?.forgetConnection(connectionId);\n  await disposing;\n}\n\n/** Kernel teardown only. Session park is a document wrap, not a connection lifetime. */\nexport function disposeKernelConnections(kernel: object): void {\n  if (!internByKernel.has(kernel)) return;\n  const bag = internByKernel.get(kernel);\n  internByKernel.delete(kernel);\n  for (const lease of bag.connections.values()) {\n    lease.refs.clear();\n    lease.mirror?.();\n    void lease.pending.then(\n      (instance) => instance[Symbol.asyncDispose](),\n      () => {},\n    );\n  }\n  bag.connections.clear();\n}\n"]}

package/dist/executor/orchestrator.d.ts

@@ -0,0 +1,97 @@
+import { ExpectationActor } from "../driver/ExpectationActor.js";
+import { type ConnectionSecretsView, type DriverConnectionClass, type PEWDriver } from "../driver/PEWDriver.js";
+import { DriverSpec } from "../shared/models/DriverSpec.js";
+import { Job } from "../shared/models/Job.js";
+import { type AnyWorkExpectation, WorkExpectation } from "../shared/models/WorkExpectation.js";
+import { type KernelPlexus, type SessionPlexus } from "../shared/types.js";
+/** Class identity for `instanceof`. `registerExecutor` never constructs. */
+export type JobConstructor<T extends Job = Job> = abstract new (...args: any[]) => T;
+/**
+ * Seam: session work graph → honor (PEW) and claim (Job).
+ *
+ * Honor is reachable PEW → handle. Unstarted cancel writes the durable
+ * ending here and must not poke `ensure` — MCP: an unstarted tool must not
+ * spin the server. Do not call `Actor.complete` — unstarted Work has no
+ * Actor. `handle` is not the sealer. License is phase 1 on an Approvable
+ * leaf. A sealed parent is not honored (the
+ * child is already ending in the agentic runtime, or must not start).
+ *
+ * INTERN TABLE IS NOT AN ATOM. `#connections` is a plain Map of kernel-interned
+ * instances (one live driver per kernel connection id). Honor re-enters by
+ * reading catalog `spec.readyState` and, once minted, `instance.readyState`.
+ * `handle` only when `ready`.
+ *
+ * A rejected ensure/load memo IS the sticky failure (no hot loop).
+ *
+ * Honor and Job claim do not start in the constructor. PEW autorun used to
+ * run during `super()`, so a readiness Promise after construct was not a
+ * gate. Call {@link activate} after replicas are pinned and recovery ran.
+ *
+ * Import discipline: this module does not import harness or the session document.
+ */
+export declare abstract class Orchestrator<K extends KernelPlexus = KernelPlexus, S extends SessionPlexus = SessionPlexus> implements Disposable {
+    #private;
+    readonly kernel: K;
+    readonly session: S;
+    /**
+     * Origin-dispatched PEW skip. Lives here, not on the session subclass:
+     * honor used to run during `super()`, and subclass fields are unassigned
+     * then (JS). A child WeakSet made `shouldHonor` throw `undefined.has`.
+     */
+    protected readonly originCompletions: WeakSet<WorkExpectation<unknown, unknown>>;
+    constructor(kernel: K, session: S);
+    protected get reachableJobs(): Job[];
+    /**
+     * Two functions. License (phase 1) returns `true` | `false` and writes
+     * `orchestrationResult` (`orchestrated` follows). `true` → await execute
+     * (phase 2). `false` → skip execute, `completed = true`. Bootstrap
+     * `orchestrated && !completed` skips the license and runs execute.
+     * `signal` aborts when the job leaves the graph or the orchestrator disposes.
+     */
+    registerExecutor<T extends Job>(Class: JobConstructor<T>, license: (job: T, orchestrator: this) => boolean | Promise<boolean>, execute: (job: T, signal: AbortSignal, orchestrator: this) => void | Promise<void>, options?: {
+        readonly seal?: boolean;
+    }): void;
+    /**
+     * Host hook: a guard or body threw. `job.crash` is set; write the receipt
+     * the job's joiners read (a tool outcome, a call failure). The orchestrator
+     * completes the job right after.
+     */
+    protected stampCrash(_job: Job, _phase: "license" | "body", _detail: string): void;
+    /** In-flight claimed Jobs (handler has not `finally`'d). */
+    protected inFlightJobs(): Iterable<Job>;
+    /** Abort an in-flight executor. No-op if the job is not claimed here. */
+    abortJob(job: Job, reason?: unknown): void;
+    abstract loadDriverModule(driver: DriverSpec): Promise<DriverConnectionClass>;
+    /**
+     * Honor still `handle`s leftover attach PEW. Origin-dispatched completions
+     * return false (PR4). Default true unless the node is in {@link originCompletions}.
+     */
+    protected shouldHonor(node: WorkExpectation): boolean;
+    /** Process-local. Secrets are never a Plexus field. */
+    protected connectionSecrets(_connectionId: string): ConnectionSecretsView;
+    /** After bootstrap, before ensure settles. The session host binds the settings writer here. */
+    protected attachConnection(_connectionId: string, _instance: PEWDriver): void;
+    connectionOf(expectation: WorkExpectation): PEWDriver | undefined;
+    actorOf<T extends AnyWorkExpectation>(expectation: T): ExpectationActor<T> | undefined;
+    ensure(connectionId: string): Promise<PEWDriver>;
+    /** True once the connection memo has been poked — without poking it. */
+    protected isEnsured(connectionId: string): boolean;
+    /** Intern-owner remint. Deletes the sticky `#ensured` memo. */
+    forgetConnection(id: string): void;
+    /** True after {@link activate}; constructor and registerExecutor do not honor. */
+    get activated(): boolean;
+    /**
+     * Start honor, Job claim, and driver discovery. Idempotent. No-op after
+     * park/dispose — those already stopped admission.
+     */
+    activate(): void;
+    /**
+     * Stop honor and new claim. In-flight BODY and live connections stay —
+     * park waits dispatched MCP before {@link Symbol.dispose} releases them.
+     */
+    protected stopAdmission(): void;
+    [Symbol.dispose](): void;
+    get drivers(): Record<string, DriverSpec>;
+    get connections(): Record<string, import("../index.js").ConnectionSpec>;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/executor/orchestrator.d.ts.map

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

package/dist/executor/orchestrator.js

@@ -0,0 +1,465 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { DefaultedMap } from "@here.build/collections";
+import { action, autorun, comparer, computed, observable, reaction, toJS } from "mobx";
+import invariant from "tiny-invariant";
+import { acquireConnection, releaseConnection, } from "./kernel-intern.js";
+import { extraLiveFromState, isDriverConnectionClass, } from "../driver/PEWDriver.js";
+import { Job } from "../shared/models/Job.js";
+import { WorkContainer, walkWork } from "../shared/models/WorkContainer.js";
+import { WorkExpectation, isTreeOrphan } from "../shared/models/WorkExpectation.js";
+/**
+ * Seam: session work graph → honor (PEW) and claim (Job).
+ *
+ * Honor is reachable PEW → handle. Unstarted cancel writes the durable
+ * ending here and must not poke `ensure` — MCP: an unstarted tool must not
+ * spin the server. Do not call `Actor.complete` — unstarted Work has no
+ * Actor. `handle` is not the sealer. License is phase 1 on an Approvable
+ * leaf. A sealed parent is not honored (the
+ * child is already ending in the agentic runtime, or must not start).
+ *
+ * INTERN TABLE IS NOT AN ATOM. `#connections` is a plain Map of kernel-interned
+ * instances (one live driver per kernel connection id). Honor re-enters by
+ * reading catalog `spec.readyState` and, once minted, `instance.readyState`.
+ * `handle` only when `ready`.
+ *
+ * A rejected ensure/load memo IS the sticky failure (no hot loop).
+ *
+ * Honor and Job claim do not start in the constructor. PEW autorun used to
+ * run during `super()`, so a readiness Promise after construct was not a
+ * gate. Call {@link activate} after replicas are pinned and recovery ran.
+ *
+ * Import discipline: this module does not import harness or the session document.
+ */
+let Orchestrator = (() => {
+    let _instanceExtraInitializers = [];
+    let _get_reachableJobs_decorators;
+    return class Orchestrator {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(this, null, _get_reachableJobs_decorators, { kind: "getter", name: "reachableJobs", static: false, private: false, access: { has: obj => "reachableJobs" in obj, get: obj => obj.reachableJobs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        kernel = __runInitializers(this, _instanceExtraInitializers);
+        session;
+        #disposed = false;
+        #admissionStopped = false;
+        #activated = observable.box(false);
+        #disposeWork;
+        /** Disposed with the orchestrator — a dead session must not keep writing the live kernel catalog. */
+        #mirrorDisposers = [];
+        #processes = new Map();
+        /** Execute (phase 2) — started BODY. */
+        #jobAbort = new Map();
+        /** In-flight license (phase 1). */
+        #guardAbort = new Map();
+        /**
+         * Process-local: execute already claimed this job. Survives seal:false
+         * so the starter does not re-run BODY. A new Orchestrator is empty —
+         * bootstrap `orchestrated && !completed` runs execute once more.
+         */
+        #bodyStarted = new WeakSet();
+        /**
+         * Origin-dispatched PEW skip. Lives here, not on the session subclass:
+         * honor used to run during `super()`, and subclass fields are unassigned
+         * then (JS). A child WeakSet made `shouldHonor` throw `undefined.has`.
+         */
+        originCompletions = new WeakSet();
+        #disposeAborts;
+        constructor(kernel, session) {
+            this.kernel = kernel;
+            this.session = session;
+            this.#mirrorDisposers.push(autorun(() => {
+                if (this.#disposed || !this.#activated.get())
+                    return;
+                for (const name of Object.keys(this.drivers)) {
+                    // Driver discovery is intentionally eager so the kernel catalog can
+                    // expose class-side offers and live facts before a connection is
+                    // ensured. A session may not be able to load every driver in a
+                    // shared kernel, so consume a rejected discovery promise here; the
+                    // driver spec already carries the failure for interested readers.
+                    void this.#classes.get(name).catch(() => { });
+                }
+            }));
+            this.#disposeWork = autorun(() => {
+                if (this.#disposed || !this.#activated.get())
+                    return;
+                for (const node of collectReachable(this.session.root)) {
+                    if (node.isDone || isTreeOrphan(node))
+                        continue;
+                    if (!this.shouldHonor(node))
+                        continue;
+                    const spec = this.connections[node.connectionId];
+                    if (spec === undefined)
+                        continue;
+                    void spec.readyState;
+                    const instance = this.#connections.get(node.connectionId);
+                    if (instance !== undefined) {
+                        if (instance.readyState === "ready")
+                            instance.handle(node);
+                        continue;
+                    }
+                    invariant(Object.hasOwn(this.connections, node.connectionId), `unknown connection ${node.connectionId}`);
+                    void this.ensure(node.connectionId);
+                }
+            });
+            this.#disposeAborts = autorun(() => {
+                if (this.#disposed || !this.#activated.get())
+                    return;
+                const live = new Set(this.reachableJobs);
+                for (const [job, ac] of this.#jobAbort) {
+                    if (live.has(job) || ac.signal.aborted)
+                        continue;
+                    ac.abort();
+                }
+                for (const [job, ac] of this.#guardAbort) {
+                    if (live.has(job) || ac.signal.aborted)
+                        continue;
+                    ac.abort();
+                }
+            });
+        }
+        get reachableJobs() {
+            const root = this.session.root;
+            const jobs = new Set();
+            if (root instanceof Job)
+                jobs.add(root);
+            if (root instanceof WorkContainer) {
+                for (const job of Iterator.from(walkWork(root)).filter((node) => node instanceof Job)) {
+                    jobs.add(job);
+                }
+            }
+            return [...jobs];
+        }
+        /**
+         * Two functions. License (phase 1) returns `true` | `false` and writes
+         * `orchestrationResult` (`orchestrated` follows). `true` → await execute
+         * (phase 2). `false` → skip execute, `completed = true`. Bootstrap
+         * `orchestrated && !completed` skips the license and runs execute.
+         * `signal` aborts when the job leaves the graph or the orchestrator disposes.
+         */
+        registerExecutor(Class, license, execute, options) {
+            invariant(!this.#processes.has(Class), `Orchestrator: executor already registered for ${Class.name}`);
+            const seal = options?.seal !== false;
+            this.#processes.set(Class, autorun(() => {
+                if (this.#disposed || !this.#activated.get())
+                    return;
+                for (const node of this.reachableJobs) {
+                    if (!(node instanceof Class))
+                        continue;
+                    const job = node;
+                    if (job.completed || job.cancelled)
+                        continue;
+                    if (job.orchestrationResult === false) {
+                        job.markComplete();
+                        continue;
+                    }
+                    if (job.orchestrationResult === true) {
+                        this.#startExecute(job, execute, seal);
+                        continue;
+                    }
+                    if (this.#guardAbort.has(job) || this.#jobAbort.has(job))
+                        continue;
+                    // Ordering is data on the job: wait here until every predecessor is released.
+                    if (!job.afterReleased)
+                        continue;
+                    this.#startGuard(job, license, execute, seal);
+                }
+            }));
+        }
+        #startGuard(job, license, execute, seal) {
+            const settle = action((ok) => {
+                if (job.orchestrationResult !== null || job.completed || job.cancelled)
+                    return;
+                job.orchestrationResult = ok;
+                if (ok) {
+                    this.#startExecute(job, execute, seal);
+                }
+                else {
+                    job.markComplete();
+                }
+            });
+            // A guard that threw never licensed the job: deny it with a crash receipt.
+            const crashed = action((error) => {
+                if (job.orchestrationResult !== null || job.completed || job.cancelled)
+                    return;
+                this.#recordCrash(job, "license", error);
+                job.orchestrationResult = false;
+                job.markComplete();
+            });
+            try {
+                const result = license(job, this);
+                if (typeof result === "boolean") {
+                    settle(result);
+                    return;
+                }
+                const ac = new AbortController();
+                this.#guardAbort.set(job, ac);
+                void result.then((ok) => {
+                    if (ac.signal.aborted)
+                        return;
+                    settle(ok);
+                    return ok;
+                }, (error) => {
+                    if (ac.signal.aborted)
+                        return;
+                    crashed(error);
+                }).finally(action(() => {
+                    this.#guardAbort.delete(job);
+                }));
+            }
+            catch (error) {
+                crashed(error);
+            }
+        }
+        #startExecute(job, execute, seal) {
+            if (this.#bodyStarted.has(job) || job.completed || job.cancelled)
+                return;
+            if (job.orchestrationResult !== true)
+                return;
+            this.#bodyStarted.add(job);
+            action(() => {
+                job.markStarted();
+            })();
+            const ac = new AbortController();
+            this.#jobAbort.set(job, ac);
+            void Promise.resolve()
+                .then(() => execute(job, ac.signal, this))
+                .then(() => false, (error) => {
+                // An abort (cancel, park, leaving the graph) is not a crash: the aborter owns the ending.
+                if (ac.signal.aborted || job.completed || job.cancelled)
+                    return false;
+                action(() => this.#recordCrash(job, "body", error))();
+                return true;
+            })
+                .then(action((crashed) => {
+                if (seal || crashed)
+                    job.markComplete();
+                this.#jobAbort.delete(job);
+            }))
+                .catch(() => { });
+        }
+        #recordCrash(job, phase, error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            job.crash = `${phase}: ${detail === "" ? "unknown error" : detail}`;
+            try {
+                this.stampCrash(job, phase, detail);
+            }
+            catch {
+                /* the crash fact is already on the job; the receipt is best effort */
+            }
+        }
+        /**
+         * Host hook: a guard or body threw. `job.crash` is set; write the receipt
+         * the job's joiners read (a tool outcome, a call failure). The orchestrator
+         * completes the job right after.
+         */
+        stampCrash(_job, _phase, _detail) { }
+        /** In-flight claimed Jobs (handler has not `finally`'d). */
+        inFlightJobs() {
+            return this.#jobAbort.keys();
+        }
+        /** Abort an in-flight executor. No-op if the job is not claimed here. */
+        abortJob(job, reason) {
+            this.#jobAbort.get(job)?.abort(reason);
+        }
+        #connections = new Map();
+        #classes = new DefaultedMap(this.#loadDriverClass.bind(this));
+        #ensured = new DefaultedMap(this.#ensureConnection.bind(this));
+        /**
+         * Honor still `handle`s leftover attach PEW. Origin-dispatched completions
+         * return false (PR4). Default true unless the node is in {@link originCompletions}.
+         */
+        shouldHonor(node) {
+            return !this.originCompletions.has(node);
+        }
+        /** Process-local. Secrets are never a Plexus field. */
+        connectionSecrets(_connectionId) {
+            return { get: () => undefined };
+        }
+        /** After bootstrap, before ensure settles. The session host binds the settings writer here. */
+        attachConnection(_connectionId, _instance) { }
+        connectionOf(expectation) {
+            return this.#connections.get(expectation.connectionId);
+        }
+        actorOf(expectation) {
+            const connection = this.connectionOf(expectation);
+            if (!connection?.has(expectation))
+                return undefined;
+            return connection.resolveExpectation(expectation);
+        }
+        #loadDriverClass(driverName) {
+            return (async () => {
+                // JS: subclass fields (SessionOrchestrator.sessionDaemon) are unassigned during super().
+                await Promise.resolve();
+                const driver = this.drivers[driverName];
+                invariant(driver !== undefined, `unknown driver ${driverName}`);
+                try {
+                    const cls = await this.loadDriverModule(driver);
+                    invariant(isDriverConnectionClass(cls), "loadDriverModule: result is not a PEWDriver class");
+                    // Occupancy is kernel-plane: interned connections outlive a session wrap.
+                    cls.awareness = this.kernel.awareness;
+                    cls.driverName = driverName;
+                    const spec = this.drivers[driverName];
+                    if (spec !== undefined) {
+                        spec.stampLoad({
+                            readyState: "ready",
+                            error: "",
+                            offersJson: JSON.stringify(cls.offers),
+                            live: extraLiveFromState(cls.state),
+                        });
+                        // Offers are class state a driver may keep fresh (local detection). The
+                        // reaction also holds the observation that wakes a lazy `cls.offers`.
+                        this.#mirrorDisposers.push(reaction(() => toJS(cls.offers), (offers) => {
+                            if (!this.#disposed)
+                                spec.offers = offers;
+                        }, { equals: comparer.structural }));
+                    }
+                    return cls;
+                }
+                catch (error) {
+                    const spec = this.drivers[driverName];
+                    if (spec !== undefined)
+                        spec.stampLoad({ readyState: "failed", error: String(error) });
+                    throw error;
+                }
+            })();
+        }
+        #ensureConnection(connectionId) {
+            const pending = (async () => {
+                const driver = this.kernel.root.connections[connectionId]?.driver;
+                invariant(driver !== undefined, `unknown driver for connection ${connectionId}`);
+                const instance = await acquireConnection(this.kernel.root, this, connectionId, async () => {
+                    const cls = await this.#classes.get(driver.name);
+                    const minted = new cls(connectionId, 
+                    // YAML: settings stamped onto the connection before ensure.
+                    this.kernel.root.connections[connectionId]?.configuration ?? {}, this.connectionSecrets(connectionId));
+                    action(() => {
+                        minted.awareness = this.kernel.awareness; // kernel occupancy, not session
+                    })();
+                    return minted;
+                });
+                action(() => {
+                    instance.awareness = this.kernel.awareness;
+                })();
+                this.#connections.set(connectionId, instance);
+                await instance.ensureBootstrapStarted();
+                this.attachConnection(connectionId, instance);
+                return instance;
+            })();
+            void pending.then(undefined, () => { });
+            return pending;
+        }
+        ensure(connectionId) {
+            return this.#ensured.get(connectionId);
+        }
+        /** True once the connection memo has been poked — without poking it. */
+        isEnsured(connectionId) {
+            return this.#ensured.has(connectionId);
+        }
+        /** Intern-owner remint. Deletes the sticky `#ensured` memo. */
+        forgetConnection(id) {
+            this.#ensured.delete(id);
+            this.#connections.delete(id);
+            releaseConnection(this.kernel.root, this, id);
+        }
+        /** True after {@link activate}; constructor and registerExecutor do not honor. */
+        get activated() {
+            return this.#activated.get();
+        }
+        /**
+         * Start honor, Job claim, and driver discovery. Idempotent. No-op after
+         * park/dispose — those already stopped admission.
+         */
+        activate() {
+            if (this.#disposed || this.#admissionStopped)
+                return;
+            action(() => {
+                this.#activated.set(true);
+            })();
+        }
+        /**
+         * Stop honor and new claim. In-flight BODY and live connections stay —
+         * park waits dispatched MCP before {@link Symbol.dispose} releases them.
+         */
+        stopAdmission() {
+            if (this.#admissionStopped)
+                return;
+            this.#admissionStopped = true;
+            this.#disposeWork();
+            for (const dispose of this.#processes.values())
+                dispose();
+            this.#processes.clear();
+            for (const ac of this.#guardAbort.values())
+                ac.abort("park");
+        }
+        [(_get_reachableJobs_decorators = [computed], Symbol.dispose)]() {
+            if (this.#disposed)
+                return;
+            this.#disposed = true;
+            this.stopAdmission();
+            for (const ac of this.#jobAbort.values())
+                ac.abort();
+            for (const ac of this.#guardAbort.values())
+                ac.abort();
+            this.#disposeAborts();
+            this.#jobAbort.clear();
+            this.#guardAbort.clear();
+            for (const id of this.#connections.keys())
+                releaseConnection(this.kernel.root, this, id);
+            this.#connections.clear();
+            for (const dispose of this.#mirrorDisposers.splice(0))
+                dispose();
+        }
+        get drivers() {
+            return this.kernel.root.drivers;
+        }
+        get connections() {
+            return this.kernel.root.connections;
+        }
+    };
+})();
+export { Orchestrator };
+function collectReachable(root) {
+    if (!(root instanceof WorkContainer))
+        return new Set();
+    const found = new Set();
+    for (const node of walkWork(root)) {
+        if (node instanceof WorkExpectation)
+            found.add(node);
+    }
+    return found;
+}
+//# sourceMappingURL=orchestrator.js.map