@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-C7AQTPCE.js

@@ -0,0 +1,694 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  extensionInvocation,
+  resolveExtensionCommands
+} from "./chunk-RFCKPS2V.js";
+import {
+  isLoadableExtension
+} from "./chunk-OH3YYA3B.js";
+import {
+  RUNTIME_LIMITS,
+  extensionPlainText,
+  listInstalledExtensions,
+  parseExtensionManifest,
+  parseExtensionOutput,
+  resolveExtensionEntrypoint
+} from "./chunk-VESL6DQY.js";
+import {
+  extensionContentDigestWithCapture
+} from "./chunk-BJH6WFIB.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  buildSafeToolEnv
+} from "./chunk-M2IPMWCN.js";
+import {
+  resolvePackageRoot
+} from "./chunk-ZPST2KQO.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/extensions/operator-runtime.ts
+init_esm_shims();
+import { realpathSync } from "node:fs";
+
+// src/domains/extensions/runtime-process.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { fork } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { cpSync, mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var ExtensionRuntimeProcess = class {
+  constructor(extension, snapshot, onState = () => {
+  }) {
+    this.extension = extension;
+    this.snapshot = snapshot;
+    if (!extension.runtime) throw new Error("extension has no operator runtime");
+    this.declaration = extension.runtime;
+    this.onState = onState;
+    const temporary = mkdtempSync(path.join(os.tmpdir(), "clio-coder-extension-"));
+    this.copyRoot = temporary;
+    const copy = path.join(temporary, "package");
+    try {
+      cpSync(extension.provenance.canonicalRoot, copy, { recursive: true, dereference: false, verbatimSymlinks: true });
+      const manifestName = path.basename(extension.manifestPath);
+      const verified = extensionContentDigestWithCapture(copy, { capture: [manifestName] });
+      if (verified.digest !== extension.provenance.contentDigest)
+        throw new Error("runtime copy does not match installed package digest");
+      const manifestBytes = verified.captured.get(manifestName);
+      if (!manifestBytes) throw new Error("verified runtime manifest bytes are absent");
+      const parsed = parseExtensionManifest(
+        manifestName.endsWith(".json") ? JSON.parse(manifestBytes.toString("utf8")) : (0, import_yaml.parse)(manifestBytes.toString("utf8")),
+        path.join(copy, manifestName)
+      );
+      if (!parsed.manifest || parsed.diagnostics.some((diagnostic2) => diagnostic2.type === "error") || parsed.manifest.id !== extension.id || JSON.stringify(parsed.manifest.runtime) !== JSON.stringify(this.declaration))
+        throw new Error("runtime declarations differ from verified manifest bytes");
+      resolveExtensionEntrypoint(copy, this.declaration.entrypoint);
+    } catch (error) {
+      rmSync(temporary, { recursive: true, force: true });
+      throw error;
+    }
+    this.staged = new Promise((resolve, reject) => {
+      this.stageResolve = resolve;
+      this.stageReject = reject;
+    });
+    this.child = fork(path.join(resolvePackageRoot(), "src/domains/extensions/runtime-child.mjs"), [], {
+      cwd: snapshot.workspace,
+      execArgv: [],
+      env: buildSafeToolEnv(),
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      serialization: "json"
+    });
+    this.exited = new Promise((resolve) => {
+      this.child.once("exit", () => {
+        this.kill("SIGKILL");
+        if (this.state !== "disposed") this.fail("runtime process exited");
+        this.cleanCopy();
+        resolve();
+      });
+      this.child.once("error", (error) => {
+        this.fail(`runtime process error: ${error.message}`);
+        if (!this.child.pid) {
+          this.cleanCopy();
+          resolve();
+        }
+      });
+    });
+    this.startupTimer = setTimeout(() => this.fail("runtime startup timed out"), RUNTIME_LIMITS.startupMs);
+    this.child.on("message", (message) => this.receive(message));
+    const diagnostic = (chunk) => {
+      this.diagnosticBytes += chunk.byteLength;
+      if (this.diagnosticBytes > RUNTIME_LIMITS.diagnosticsBytes) this.fail("runtime diagnostic output exceeded 64 KiB");
+    };
+    this.child.stdout?.on("data", diagnostic);
+    this.child.stderr?.on("data", diagnostic);
+    this.send({
+      kind: "init",
+      entrypoint: path.join(copy, this.declaration.entrypoint),
+      declaration: this.declaration,
+      snapshot
+    });
+  }
+  extension;
+  snapshot;
+  instance = randomUUID();
+  declaration;
+  copyRoot;
+  startedAt = performance.now();
+  state = "staging";
+  failure;
+  readyMs = 0;
+  rss = 0;
+  child;
+  pending;
+  stageResolve;
+  stageReject;
+  activeResolve;
+  activeReject;
+  startupTimer;
+  stopPromise;
+  exited;
+  diagnosticBytes = 0;
+  messageWindow = Date.now();
+  messages = 0;
+  onState;
+  staged;
+  get pid() {
+    return this.child.pid;
+  }
+  get busy() {
+    return this.pending !== void 0;
+  }
+  cleanCopy() {
+    try {
+      rmSync(this.copyRoot, { recursive: true, force: true });
+    } catch (error) {
+      this.failure = `runtime private-copy cleanup failed: ${extensionPlainText(String(error)).slice(0, 400)}`;
+      this.notifyState();
+    }
+  }
+  notifyState() {
+    try {
+      this.onState();
+    } catch {
+    }
+  }
+  send(value) {
+    if (!this.child.connected) return;
+    this.child.send({ protocol: 1, instance: this.instance, ...value }, (error) => {
+      if (error) this.fail(`runtime IPC failed: ${error.message}`);
+    });
+  }
+  kill(signal) {
+    if (this.child.pid && process.platform !== "win32") {
+      try {
+        process.kill(-this.child.pid, signal);
+        return;
+      } catch {
+      }
+    }
+    this.child.kill(signal);
+  }
+  fail(reason) {
+    if (this.state === "disposed" || this.state === "failed") return;
+    this.failure = extensionPlainText(reason).slice(0, 512);
+    this.state = "failed";
+    clearTimeout(this.startupTimer);
+    const error = new Error(this.failure);
+    this.stageReject(error);
+    this.activeReject?.(error);
+    this.rejectPending(error);
+    this.notifyState();
+    this.kill("SIGKILL");
+  }
+  rejectPending(error) {
+    const pending = this.pending;
+    this.pending = void 0;
+    pending?.cleanup();
+    pending?.reject(error);
+  }
+  receive(value) {
+    if (this.state === "disposed" || this.state === "failed") return;
+    try {
+      if (Date.now() - this.messageWindow > 1e3) {
+        this.messageWindow = Date.now();
+        this.messages = 0;
+      }
+      if (++this.messages > 128) throw new Error("runtime IPC rate exceeded");
+      if (Buffer.byteLength(JSON.stringify(value)) > RUNTIME_LIMITS.messageBytes)
+        throw new Error("runtime IPC message too large");
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid runtime IPC message");
+      const m = value;
+      const fields = {
+        ready: ["commands", "events", "rss"],
+        active: [],
+        result: ["id", "output"],
+        error: ["id", "error"],
+        fatal: ["error"]
+      };
+      if (typeof m.kind !== "string" || !Object.hasOwn(fields, m.kind) || Object.keys(m).some((key) => !["protocol", "instance", "kind", ...fields[m.kind] ?? []].includes(key)))
+        throw new Error("invalid runtime protocol fields");
+      if (m.protocol !== 1 || m.instance !== this.instance) throw new Error("runtime protocol or instance mismatch");
+      if (m.kind === "fatal") throw new Error(typeof m.error === "string" ? m.error : "runtime fatal error");
+      if (m.kind === "ready" && this.state === "staging") {
+        if (JSON.stringify(Array.isArray(m.commands) ? [...m.commands].sort() : null) !== JSON.stringify(this.declaration.commands.map((command) => command.name).sort()) || JSON.stringify(Array.isArray(m.events) ? [...m.events].sort() : null) !== JSON.stringify([...this.declaration.events].sort()))
+          throw new Error("runtime registration inventory mismatch");
+        if (typeof m.rss !== "number" || !Number.isFinite(m.rss) || m.rss < 0)
+          throw new Error("invalid runtime memory observation");
+        this.rss = m.rss;
+        this.readyMs = performance.now() - this.startedAt;
+        this.state = "starting";
+        clearTimeout(this.startupTimer);
+        this.stageResolve();
+        return;
+      }
+      if (m.kind === "active" && this.state === "starting" && this.activeResolve) {
+        this.state = "ready";
+        clearTimeout(this.startupTimer);
+        this.activeResolve();
+        this.activeResolve = void 0;
+        this.activeReject = void 0;
+        this.notifyState();
+        return;
+      }
+      if (m.kind !== "result" && m.kind !== "error") throw new Error("unexpected runtime IPC message");
+      if (!this.pending || m.id !== this.pending.id || this.state !== "ready") return;
+      if (m.kind === "error") throw new Error(typeof m.error === "string" ? m.error : "runtime handler failed");
+      const output = parseExtensionOutput(m.output, this.declaration);
+      const pending = this.pending;
+      this.pending = void 0;
+      pending.cleanup();
+      pending.resolve(output);
+    } catch (error) {
+      this.fail(error instanceof Error ? error.message : String(error));
+    }
+  }
+  async activate() {
+    await this.staged;
+    if (this.state !== "starting") throw new Error(this.failure ?? "runtime is not staged");
+    return new Promise((resolve, reject) => {
+      this.activeResolve = resolve;
+      this.activeReject = reject;
+      this.startupTimer = setTimeout(() => this.fail("runtime activation timed out"), RUNTIME_LIMITS.startupMs);
+      this.send({ kind: "activate" });
+    });
+  }
+  request(message, timeoutMs, signal) {
+    if (this.state !== "ready" || this.pending)
+      return Promise.reject(new Error(this.failure ?? "runtime not ready or busy"));
+    if (signal?.aborted) return Promise.reject(new Error("extension command cancelled"));
+    return new Promise((resolve, reject) => {
+      const id = randomUUID();
+      const cancel = () => {
+        this.send({ kind: "cancel", id });
+        this.rejectPending(new Error("extension command cancelled"));
+        void this.dispose("cancelled");
+      };
+      const timer = setTimeout(() => this.fail("runtime request timed out"), timeoutMs);
+      this.pending = {
+        id,
+        resolve,
+        reject,
+        cleanup: () => {
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", cancel);
+        }
+      };
+      signal?.addEventListener("abort", cancel, { once: true });
+      this.send({ ...message, id });
+    });
+  }
+  dispose(reason = "disposed") {
+    if (this.stopPromise) return this.stopPromise;
+    this.state = "disposed";
+    clearTimeout(this.startupTimer);
+    const error = new Error(`runtime disposed: ${reason}`);
+    this.stageReject(error);
+    this.activeReject?.(error);
+    this.rejectPending(error);
+    this.notifyState();
+    this.send({ kind: "dispose", reason });
+    this.stopPromise = (async () => {
+      const timer = setTimeout(() => this.kill("SIGKILL"), RUNTIME_LIMITS.disposeMs);
+      await this.exited;
+      clearTimeout(timer);
+    })();
+    return this.stopPromise;
+  }
+};
+
+// src/domains/extensions/operator-runtime.ts
+function identity(entry) {
+  return `${entry.id}:${entry.scope}:${entry.provenance?.canonicalRoot}:${entry.provenance?.contentDigest}`;
+}
+function contextIdentity(context) {
+  return JSON.stringify(context);
+}
+var OperatorExtensionRuntime = class {
+  constructor(options) {
+    this.options = options;
+    if (options.frozenTools)
+      this.initialTools = new Map(
+        options.frozenTools.map((provenance) => [
+          provenance.id,
+          `${provenance.id}:${provenance.scope}:${provenance.canonicalRoot}:${provenance.contentDigest}`
+        ])
+      );
+  }
+  options;
+  processes = /* @__PURE__ */ new Map();
+  inventory = [];
+  failures = /* @__PURE__ */ new Map();
+  statuses = /* @__PURE__ */ new Map();
+  initialTools;
+  lastScanMs = 0;
+  observationIssue;
+  generation = 0;
+  lifetime = 0;
+  closed = false;
+  reloading = false;
+  queued = false;
+  activeContext;
+  pendingObservation;
+  observationTask;
+  reloadTask;
+  retired = /* @__PURE__ */ new Set();
+  /** No timer or filesystem work is needed without active runtimes or queued reload. */
+  get maintenanceDelayMs() {
+    if (this.closed || this.reloading) return null;
+    if (this.queued) return 250;
+    return [...this.processes.values()].some((process2) => process2.state === "ready") ? Math.max(3e4, Math.ceil(this.lastScanMs * 100)) : null;
+  }
+  maintenance() {
+    if (this.closed || this.reloading) return;
+    if (this.queued) {
+      if (!this.busy && this.options.isIdle()) void this.reload("session-change");
+      return;
+    }
+    if (this.maintenanceDelayMs !== null) this.reconcile();
+  }
+  reportObservationFailure(error) {
+    const message = `extension observation unavailable: ${error instanceof Error ? error.message : String(error)}`.slice(
+      0,
+      512
+    );
+    if (message === this.observationIssue) return;
+    this.observationIssue = message;
+    try {
+      this.options.onDiagnostic?.(message);
+    } catch {
+    }
+  }
+  context() {
+    const context = this.options.context();
+    return { ...context, workspace: realpathSync(context.workspace) };
+  }
+  list() {
+    const start = performance.now();
+    try {
+      return (this.options.list ?? ((cwd) => listInstalledExtensions(cwd, { all: true })))(this.context().workspace);
+    } finally {
+      this.lastScanMs = performance.now() - start;
+    }
+  }
+  changed() {
+    try {
+      this.options.onChange?.();
+    } catch {
+    }
+  }
+  retire(process2, reason) {
+    this.statuses.delete(process2.extension.id);
+    const task = process2.dispose(reason);
+    this.retired.add(task);
+    void task.finally(() => this.retired.delete(task));
+  }
+  get busy() {
+    return this.reloading || [...this.processes.values()].some((process2) => process2.busy);
+  }
+  /** Synchronous fence for resume/fork/branch switch, including same-session leaf changes. */
+  invalidateContext() {
+    if (this.closed || !this.processes.size && !this.reloading && !this.queued) return;
+    this.lifetime++;
+    for (const process2 of this.processes.values()) this.retire(process2, "session-change");
+    this.processes.clear();
+    this.queued = true;
+    this.changed();
+  }
+  get activeGeneration() {
+    return this.generation;
+  }
+  eligible(process2, list) {
+    return list.some((entry) => isLoadableExtension(entry) && identity(entry) === identity(process2.extension));
+  }
+  /** Reverify at command boundaries and on the host's slow lifecycle tick, never during paint. */
+  reconcile() {
+    if (this.closed || !this.queued && !this.reloading && ![...this.processes.values()].some((process2) => process2.state === "ready"))
+      return;
+    let context;
+    let list;
+    try {
+      context = contextIdentity(this.context());
+      list = this.list();
+    } catch {
+      context = "unavailable";
+      list = [];
+    }
+    this.inventory = list;
+    if (this.activeContext !== void 0 && context !== this.activeContext) {
+      this.lifetime++;
+      for (const process2 of this.processes.values()) this.retire(process2, "session-change");
+      this.processes.clear();
+      this.activeContext = context;
+      this.queued = true;
+      this.changed();
+    }
+    for (const [id, process2] of this.processes) {
+      if (this.eligible(process2, list)) continue;
+      this.processes.delete(id);
+      this.failures.set(id, "installation disabled, removed, replaced, or changed; reload after reviewed installation");
+      this.retire(process2, "installation-revoked");
+      this.changed();
+    }
+    if (this.queued && !this.busy && this.options.isIdle()) void this.reload("session-change");
+  }
+  reload(reason = "reload") {
+    if (this.closed)
+      return Promise.resolve({ status: "rejected", generation: this.generation, message: "operator runtime is disposed" });
+    if (this.busy || !this.options.isIdle()) {
+      this.queued = true;
+      this.changed();
+      return Promise.resolve({
+        status: "deferred",
+        generation: this.generation,
+        message: "extension reload queued until the session and extension commands are idle"
+      });
+    }
+    this.queued = false;
+    this.reloading = true;
+    this.reloadTask = this.performReload(reason).finally(() => {
+      this.reloading = false;
+      this.changed();
+    });
+    return this.reloadTask;
+  }
+  async performReload(reason) {
+    const staged = /* @__PURE__ */ new Map();
+    const failures = /* @__PURE__ */ new Map();
+    const lifetime = this.lifetime;
+    const next = this.generation + 1;
+    let result;
+    try {
+      const context = this.context();
+      const capturedContext = contextIdentity(context);
+      const list = this.list();
+      this.inventory = list;
+      this.initialTools ??= new Map(
+        list.filter((entry) => entry.loadable && entry.capabilities?.tools.length).map((entry) => [entry.id, identity(entry)])
+      );
+      for (const process2 of this.processes.values()) this.retire(process2, reason);
+      this.processes.clear();
+      this.statuses.clear();
+      await Promise.all(this.retired);
+      const eligible = list.filter(
+        (entry) => isLoadableExtension(entry) && entry.runtime !== void 0 && (!this.options.onlyId || entry.id === this.options.onlyId)
+      );
+      for (const entry of eligible.slice(RUNTIME_LIMITS.processes))
+        failures.set(entry.id, `operator runtime limit is ${RUNTIME_LIMITS.processes}; disable another runtime and reload`);
+      await Promise.all(
+        eligible.slice(0, RUNTIME_LIMITS.processes).map(async (entry) => {
+          try {
+            const process2 = new ExtensionRuntimeProcess(entry, { ...context, generation: next }, () => {
+              if (this.processes.get(entry.id)?.state !== "ready") this.statuses.delete(entry.id);
+              this.changed();
+            });
+            staged.set(entry.id, process2);
+            await process2.staged;
+          } catch (error) {
+            failures.set(entry.id, error instanceof Error ? error.message : String(error));
+          }
+        })
+      );
+      if (this.closed || lifetime !== this.lifetime || capturedContext !== contextIdentity(this.context()))
+        throw new Error("session or workspace changed while staging runtimes");
+      const current = this.list();
+      if (JSON.stringify(list.map(identity)) !== JSON.stringify(current.map(identity)) || list.some((entry, index) => entry.loadable !== current[index]?.loadable))
+        throw new Error("extension installations changed while staging; reload again");
+      if (!this.options.isIdle()) {
+        this.queued = true;
+        throw new Error("session became busy while staging; reload queued until idle");
+      }
+      const hooks = this.options.commitHooks?.();
+      if (hooks && hooks.status !== "committed")
+        throw new Error(`hook generation rejected: ${hooks.reason ?? hooks.status}`);
+      this.generation = next;
+      this.activeContext = capturedContext;
+      this.processes = staged;
+      this.failures = failures;
+      await Promise.all(
+        [...staged].map(async ([id, process2]) => {
+          if (failures.has(id)) return;
+          try {
+            await process2.activate();
+          } catch (error) {
+            failures.set(id, error instanceof Error ? error.message : String(error));
+          }
+        })
+      );
+      if (this.closed || lifetime !== this.lifetime || capturedContext !== contextIdentity(this.context()))
+        throw new Error("session or workspace changed during runtime activation");
+      if (context.mode === "interactive") await this.deliverObservation({ event: "session_open", reason });
+      const ready = [...staged.values()].filter((process2) => process2.state === "ready").length;
+      const degraded = eligible.length - ready;
+      result = {
+        status: "committed",
+        generation: next,
+        degraded,
+        message: degraded > 0 ? `Extensions: ${degraded} failed to start; ${ready} ready. Open /extensions to inspect.` : ready > 0 ? `Extensions reloaded: ${ready} ready.` : "Extensions reloaded. No runtime extensions enabled."
+      };
+    } catch (error) {
+      for (const process2 of /* @__PURE__ */ new Set([...this.processes.values(), ...staged.values()])) {
+        this.retire(process2, "reload-rejected");
+      }
+      this.processes.clear();
+      result = {
+        status: this.generation === next ? "committed" : "rejected",
+        generation: this.generation,
+        message: `${this.generation === next ? "Extensions reloaded with errors: " : "Extension reload failed: "}${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    this.changed();
+    try {
+      this.options.onReload?.(result, reason);
+    } catch {
+    }
+    return result;
+  }
+  commands(promptNames = []) {
+    const rows = this.inventory.filter((entry) => entry.effective && entry.runtime).flatMap(
+      (entry) => (entry.runtime?.commands ?? []).map((command) => {
+        const process2 = this.processes.get(entry.id);
+        const available = process2?.state === "ready" && entry.loadable && !this.reloading;
+        const reason = available ? void 0 : this.failures.get(entry.id) ?? process2?.failure ?? (!entry.loadable ? "installation is not enabled and eligible" : this.reloading ? "runtime reload in progress" : "runtime not ready; reload extensions");
+        return {
+          origin: "extension",
+          invocation: extensionInvocation(entry.id, command.name),
+          extensionId: entry.id,
+          scope: entry.scope,
+          description: command.description,
+          generation: this.generation,
+          available,
+          ...reason ? { reason } : {}
+        };
+      })
+    );
+    return resolveExtensionCommands(rows, promptNames);
+  }
+  entries() {
+    return this.inventory.map((entry) => {
+      const process2 = this.processes.get(entry.id);
+      const current = process2 && identity(process2.extension) === identity(entry) ? process2 : void 0;
+      const reason = this.failures.get(entry.id) ?? current?.failure;
+      const status = current?.state === "ready" ? this.statuses.get(entry.id) : void 0;
+      const initial = this.initialTools?.get(entry.id);
+      const newSessionReasons = (entry.capabilities?.tools.length || initial) && initial !== identity(entry) ? [
+        this.options.frozenTools ? "installed package differs from the frozen tool registry (or was not admitted there); a new session is required for tool admission" : "package differs from the runtime-startup observation; actual frozen tool binding is unknown here, inspect the registry or start a new session"
+      ] : [];
+      return {
+        id: entry.id,
+        scope: entry.scope,
+        generation: this.generation,
+        state: current?.state ?? "inactive",
+        ...current ? { provenance: current.extension.provenance } : {},
+        ...reason ? { reason } : {},
+        ...status ? { status } : {},
+        newSessionReasons,
+        toolEvidence: this.options.frozenTools ? "frozen-registry" : "runtime-startup-observation"
+      };
+    });
+  }
+  async invoke(invocation, args, promptNames = [], signal) {
+    this.reconcile();
+    if (this.closed || !this.options.isIdle() || this.reloading)
+      throw new Error("extension command requires an idle session");
+    if (Buffer.byteLength(args) > RUNTIME_LIMITS.argumentBytes) throw new Error("extension arguments exceed 16 KiB");
+    const row = this.commands(promptNames).find((row2) => row2.invocation === invocation);
+    if (!row?.available) throw new Error(row?.reason ?? `/${invocation} is not an available extension command`);
+    const process2 = this.processes.get(row.extensionId);
+    const name = invocation.slice(invocation.lastIndexOf(":") + 1);
+    const command = process2?.declaration.commands.find((command2) => command2.name === name);
+    if (!process2 || !command) throw new Error("extension command unavailable");
+    const context = contextIdentity(this.context());
+    const output = await process2.request({ kind: "command", name, args }, command.timeoutMs, signal);
+    this.reconcile();
+    if (this.closed || signal?.aborted || context !== contextIdentity(this.context()) || this.processes.get(row.extensionId) !== process2 || process2.state !== "ready")
+      throw new Error("extension result belongs to a revoked runtime or session");
+    this.applyOutput(process2, output);
+    return output;
+  }
+  applyOutput(process2, output) {
+    if (this.processes.get(process2.extension.id) !== process2 || process2.state !== "ready") return;
+    if (output.status === null) this.statuses.delete(process2.extension.id);
+    else if (output.status) this.statuses.set(process2.extension.id, output.status);
+    this.changed();
+  }
+  observe(observation) {
+    if (this.closed || ![...this.processes.values()].some(
+      (process2) => process2.state === "ready" && process2.declaration.events.includes(observation.event)
+    ))
+      return;
+    this.pendingObservation = observation;
+    if (this.observationTask) return;
+    this.observationTask = (async () => {
+      while (this.pendingObservation && !this.closed) {
+        const next = this.pendingObservation;
+        this.pendingObservation = void 0;
+        await this.deliverObservation(next);
+      }
+    })().catch((error) => this.reportObservationFailure(error)).finally(() => {
+      this.observationTask = void 0;
+    });
+  }
+  async deliverObservation(observation) {
+    try {
+      const context = contextIdentity(this.context());
+      const candidates = [...this.processes.values()].filter(
+        (process2) => process2.state === "ready" && !process2.busy && process2.declaration.events.includes(observation.event)
+      );
+      if (candidates.length === 0) return;
+      const admitted = this.list();
+      const responses = await Promise.all(
+        candidates.map(async (process2) => {
+          const { generation: _generation, ...processContext } = process2.snapshot;
+          if (contextIdentity(processContext) !== context || !this.eligible(process2, admitted)) return null;
+          try {
+            return { process: process2, output: await process2.request({ kind: "observe", observation }, RUNTIME_LIMITS.observationMs) };
+          } catch (error) {
+            this.reportObservationFailure(error);
+            if (this.processes.get(process2.extension.id) === process2) this.statuses.delete(process2.extension.id);
+            this.changed();
+            return null;
+          }
+        })
+      );
+      if (this.closed) return;
+      if (context !== contextIdentity(this.context())) {
+        this.reconcile();
+        return;
+      }
+      const current = this.list();
+      for (const response of responses) {
+        if (!response) continue;
+        if (this.eligible(response.process, current)) this.applyOutput(response.process, response.output);
+        else this.reconcile();
+      }
+    } catch (error) {
+      this.reportObservationFailure(error);
+      this.reconcile();
+    }
+  }
+  cancel() {
+    for (const process2 of this.processes.values()) if (process2.busy) this.retire(process2, "operator-cancelled");
+  }
+  async dispose() {
+    this.closed = true;
+    this.lifetime++;
+    this.pendingObservation = void 0;
+    for (const process2 of this.processes.values()) this.retire(process2, "session-closed");
+    this.processes.clear();
+    await this.reloadTask;
+    await this.observationTask;
+    await Promise.all(this.retired);
+  }
+};
+
+export {
+  OperatorExtensionRuntime
+};
+//# sourceMappingURL=chunk-C7AQTPCE.js.map