operon-agents 0.1.0-alpha.0

package/dist/extensions/loader.js

@@ -0,0 +1,285 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+/**
+ * File-extension loader — the shell that turns a extension directory into extension VALUES for
+ * `attachExtension`. The framework core stays file-blind: everything here ends in a plain
+ * `ExtensionDefinition`, handed over the same channel host-authored extensions use.
+ *
+ * Layout: one folder per extension under `directory`, holding a `manifest.json` plus a bundled
+ * entry file (dependencies baked in by the author at publish time — no install step here).
+ *
+ * Trust model — loading is consent, and consent is MANUAL:
+ * - `load()` / `reload()` are explicit host actions; performing one approves the extension at
+ *   its current file mtime, recorded in `.approvals.json` beside the extensions.
+ * - `loadApproved()` (startup) only honors extensions whose entry is byte-for-byte the one
+ *   approved (mtime match). A changed or new extension is reported, never silently loaded —
+ *   an agent with write access must not be able to plant code that runs on next open.
+ *
+ * Reload mechanics: native `import()` with a `?v=<mtime>` suffix — a changed file gets a
+ * fresh module, an unchanged one hits the cache. Old module instances stay resident until
+ * process exit; that is the accepted cost of not restarting.
+ */
+/** This framework's version — what a manifest's `engine` is checked against. */
+export const FRAMEWORK_VERSION = createRequire(import.meta.url)("../../package.json").version;
+const VERSION_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+/** Semver ordering for plain `x.y.z[-pre]` strings (a prerelease sorts below its release). */
+export function compareVersions(a, b) {
+    const pa = VERSION_RE.exec(a), pb = VERSION_RE.exec(b);
+    if (pa === null || pb === null)
+        throw new Error(`not a version: ${JSON.stringify(pa === null ? a : b)}`);
+    for (let i = 1; i <= 3; i++) {
+        const d = Number(pa[i]) - Number(pb[i]);
+        if (d !== 0)
+            return d;
+    }
+    const preA = pa[4], preB = pb[4];
+    if (preA === undefined && preB === undefined)
+        return 0;
+    if (preA === undefined)
+        return 1;
+    if (preB === undefined)
+        return -1;
+    const xs = preA.split("."), ys = preB.split(".");
+    for (let i = 0; i < Math.max(xs.length, ys.length); i++) {
+        const x = xs[i], y = ys[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
+        const d = nx && ny ? Number(x) - Number(y) : nx ? -1 : ny ? 1 : x.localeCompare(y);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+const APPROVALS_FILE = ".approvals.json";
+export class ExtensionLoader {
+    directory;
+    approvalsPath;
+    /** Live definitions by extension id — the values a host hands to `attachExtension`. */
+    loaded = new Map();
+    constructor(options) {
+        this.directory = resolve(options.directory);
+        this.approvalsPath = join(this.directory, APPROVALS_FILE);
+    }
+    /** The parsed manifest of one extension, by id. */
+    async manifest(id) {
+        return (await this.find(id)).manifest;
+    }
+    /** The folder a extension lives in — where an extension keeps its data files. */
+    async manifestDir(id) {
+        return (await this.find(id)).dir;
+    }
+    /** Every extension folder under the directory, with its trust/load state. */
+    async list() {
+        const approvals = await this.readApprovals();
+        const out = [];
+        for (const entry of await this.readExtensionDirs()) {
+            try {
+                const scanned = await this.scan(entry);
+                out.push({
+                    id: scanned.manifest.id,
+                    dir: scanned.dir,
+                    ...(scanned.manifest.version !== undefined ? { version: scanned.manifest.version } : {}),
+                    ...(scanned.manifest.engine !== undefined ? { engine: scanned.manifest.engine } : {}),
+                    ...(scanned.manifest.name !== undefined ? { name: scanned.manifest.name } : {}),
+                    ...(scanned.manifest.description !== undefined ? { description: scanned.manifest.description } : {}),
+                    state: this.stateOf(scanned, approvals),
+                });
+            }
+            catch (error) {
+                out.push({ id: entry, dir: join(this.directory, entry), state: "error", error: messageOf(error) });
+            }
+        }
+        return out;
+    }
+    /**
+     * Import one extension and approve it as it stands. The call itself is the consent — reserve
+     * it for user-initiated actions, never for something an agent triggers on its own.
+     */
+    async load(id) {
+        const scanned = await this.find(id);
+        const definition = await this.importDefinition(scanned);
+        await this.approve(scanned);
+        this.loaded.set(id, definition);
+        return definition;
+    }
+    /** Re-import after an edit and roll the approval forward to the file as it is now. */
+    async reload(id) {
+        return this.load(id);
+    }
+    /** Forget a extension: drop the held definition and revoke its approval. */
+    async unload(id) {
+        this.loaded.delete(id);
+        const approvals = await this.readApprovals();
+        if (id in approvals) {
+            const { [id]: _dropped, ...rest } = approvals;
+            await this.writeApprovals(rest);
+        }
+    }
+    /**
+     * Startup path: import every extension still byte-identical to what was approved. Changed and
+     * new extensions are skipped and reported so the host can surface them for a manual decision.
+     */
+    async loadApproved() {
+        const loaded = [];
+        const skipped = [];
+        for (const status of await this.list()) {
+            if (status.state === "approved" || status.state === "loaded") {
+                try {
+                    const scanned = await this.find(status.id);
+                    const definition = await this.importDefinition(scanned);
+                    this.loaded.set(status.id, definition);
+                    loaded.push(definition);
+                    continue;
+                }
+                catch (error) {
+                    skipped.push({ ...status, state: "error", error: messageOf(error) });
+                    continue;
+                }
+            }
+            skipped.push(status);
+        }
+        return { loaded, skipped };
+    }
+    /** The definitions currently held. On the standalone-loader path these reach sessions through
+     *  `attachExtension`/`reloadInto`; a harness built with `extensionDir` registers them itself
+     *  (`harness.extensions.load`), which is the path that also runs `create` halves. */
+    definitions() {
+        return [...this.loaded.values()];
+    }
+    /** Convenience: reload a extension and swap it on a live session (detach old, attach new). */
+    async reloadInto(session, id) {
+        const definition = await this.reload(id);
+        await session.detachExtension(id).catch(() => undefined);
+        await session.attachExtension(definition);
+        return definition;
+    }
+    // ==========================================================================
+    // Internals
+    // ==========================================================================
+    async readExtensionDirs() {
+        const entries = await readdir(this.directory, { withFileTypes: true }).catch(() => []);
+        // Dot-folders are the loader's own (`.data` holds extensions' data dirs), never extensions.
+        return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort();
+    }
+    async scan(dirName) {
+        const dir = join(this.directory, dirName);
+        const manifestPath = join(dir, "manifest.json");
+        let manifest;
+        try {
+            manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        }
+        catch (error) {
+            throw new Error(`unreadable manifest.json: ${messageOf(error)}`);
+        }
+        if (typeof manifest.id !== "string" || !manifest.id.trim()) {
+            throw new Error("manifest.json must declare a non-empty string \"id\"");
+        }
+        if (manifest.engine !== undefined) {
+            if (typeof manifest.engine !== "string" || !VERSION_RE.test(manifest.engine)) {
+                throw new Error(`manifest "engine" must be a version like "1.2.0", got ${JSON.stringify(manifest.engine)}`);
+            }
+            if (compareVersions(FRAMEWORK_VERSION, manifest.engine) < 0) {
+                throw new Error(`requires operon-agents >= ${manifest.engine}; this host runs ${FRAMEWORK_VERSION}`);
+            }
+        }
+        const entryPath = join(dir, manifest.entry ?? "index.js");
+        const stats = await stat(entryPath).catch(() => {
+            throw new Error(`entry file missing: ${entryPath}`);
+        });
+        return { manifest, dir, entryPath, mtimeMs: stats.mtimeMs };
+    }
+    async find(id) {
+        let failure;
+        for (const dirName of await this.readExtensionDirs()) {
+            try {
+                const scanned = await this.scan(dirName);
+                if (scanned.manifest.id === id)
+                    return scanned;
+            }
+            catch (error) {
+                // A broken sibling folder must not block loading the one asked for — but the folder
+                // named like the id IS the one asked for, and its reason (bad manifest, missing entry,
+                // an `engine` this host is too old for) is the answer, not "not found".
+                if (dirName === id)
+                    failure = error;
+            }
+        }
+        if (failure !== undefined)
+            throw new Error(`extension "${id}": ${messageOf(failure)}`);
+        throw new Error(`no extension with id "${id}" under ${this.directory}`);
+    }
+    stateOf(scanned, approvals) {
+        const approval = approvals[scanned.manifest.id];
+        if (!approval)
+            return "new";
+        if (approval.mtimeMs !== scanned.mtimeMs || approval.entry !== scanned.entryPath)
+            return "changed";
+        return this.loaded.has(scanned.manifest.id) ? "loaded" : "approved";
+    }
+    async importDefinition(scanned) {
+        // The mtime suffix makes an edited file a NEW module while an unchanged one stays cached.
+        const url = `${pathToFileURL(scanned.entryPath).href}?v=${scanned.mtimeMs}`;
+        let moduleExports;
+        try {
+            moduleExports = (await import(__rewriteRelativeImportExtension(url)));
+        }
+        catch (error) {
+            throw new Error(`extension "${scanned.manifest.id}" failed to import: ${messageOf(error)}`);
+        }
+        let candidate = moduleExports.default;
+        // A factory default export lets a extension construct per-load state; called with nothing —
+        // everything a extension may use arrives later through its setup(ctx).
+        if (typeof candidate === "function")
+            candidate = candidate();
+        if (!isExtensionDefinition(candidate)) {
+            throw new Error(`extension "${scanned.manifest.id}" default export is not an extension definition ({ id, setup })`);
+        }
+        if (candidate.id !== scanned.manifest.id) {
+            throw new Error(`extension id mismatch: manifest says "${scanned.manifest.id}", code says "${candidate.id}"`);
+        }
+        return candidate;
+    }
+    async approve(scanned) {
+        const approvals = await this.readApprovals();
+        await this.writeApprovals({
+            ...approvals,
+            [scanned.manifest.id]: { entry: scanned.entryPath, mtimeMs: scanned.mtimeMs, approvedAt: Date.now() },
+        });
+    }
+    async readApprovals() {
+        try {
+            return JSON.parse(await readFile(this.approvalsPath, "utf8"));
+        }
+        catch {
+            return {};
+        }
+    }
+    async writeApprovals(approvals) {
+        await writeFile(this.approvalsPath, `${JSON.stringify(approvals, null, 2)}\n`, "utf8");
+    }
+}
+export function createExtensionLoader(options) {
+    return new ExtensionLoader(options);
+}
+function isExtensionDefinition(value) {
+    return (typeof value === "object" && value !== null
+        && typeof value.id === "string"
+        && typeof value.setup === "function");
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=loader.js.map

package/dist/extensions/manager.d.ts

@@ -0,0 +1,103 @@
+import type { ExtensionDefinition, ExtensionHostContext } from "./types.ts";
+import { type ExtensionFileStatus } from "./loader.ts";
+import { ServiceRegistry, type ServiceOptions } from "./services.ts";
+/** The session surface the barrier hands to a swap function. */
+export interface HeldSession {
+    readonly id: string;
+    attachExtension(definition: ExtensionDefinition): Promise<void>;
+    detachExtension(extensionId: string): Promise<void>;
+    attachedExtensionIds(): readonly string[];
+    attachedExtensions(): readonly {
+        readonly id: string;
+        readonly uses: readonly string[];
+    }[];
+}
+/** The narrow harness face the manager operates through (no import cycle with harness.ts). */
+export interface ExtensionHostBridge {
+    readonly services: ServiceRegistry;
+    createSession(options?: Record<string, unknown>): Promise<{
+        readonly id: string;
+    }>;
+    sessions(): readonly HeldSession[];
+    /** Rendezvous every session holding one of `extensionIds` at its run boundary, run `fn` in
+     *  the quiet moment (held() reads live — sessions born gated during the barrier appear). */
+    withBarrier(extensionIds: readonly string[], timeoutMs: number, fn: (held: () => readonly HeldSession[]) => Promise<void>): Promise<void>;
+    warn(message: string): void;
+}
+/** What staging one `create`-bearing definition produced, before anything is published. */
+export interface StagedDefinition {
+    /** The one service `create` returned, to register under the extension's id; absent when the
+     *  definition has no `create`. */
+    readonly service?: {
+        readonly name: string;
+        readonly instance: unknown;
+        readonly options: ServiceOptions;
+    };
+    /** The definition itself — its `setup` is the per-session half, mounted into every session. */
+    readonly sessionDef: ExtensionDefinition;
+}
+export interface StagingOptions {
+    /** What the registered service's `replaceable` defaults to. File extensions default to true
+     *  (reload is their point); by-value ones to false (a change is a restart). */
+    readonly defaultReplaceable: boolean;
+    readonly dir?: string;
+    /** The extension's data folder, already created. */
+    readonly dataDir?: string;
+    createSession: ExtensionHostContext["createSession"];
+    warn(message: string): void;
+}
+/**
+ * Run a `create`-bearing definition's `create` half against a staging host and collect the one
+ * service it returns — nothing is registered here, so a throwing `create` publishes nothing.
+ * Shared by the file manager and the harness's by-value channel. Stays synchronous when `create`
+ * is, which the by-value channel relies on to have a synchronous extension's service visible the
+ * moment `createHarness` returns.
+ */
+export declare function stageDefinition(definition: ExtensionDefinition, options: StagingOptions): StagedDefinition | Promise<StagedDefinition>;
+export declare class HarnessExtensionManager {
+    private readonly loader;
+    private readonly bridge;
+    /** Root of the extensions' data folders (`<root>/<id>`) — outside every code folder. */
+    private readonly dataRoot;
+    /** Every loaded extension by id, and whether its `create` published a service. */
+    private readonly loaded;
+    /** Definitions newborn sessions receive: every loaded extension's per-session half. */
+    private readonly sessionDefs;
+    constructor(options: {
+        readonly directory: string;
+        readonly dataDir: string;
+        readonly bridge: ExtensionHostBridge;
+    });
+    list(): Promise<ExtensionFileStatus[]>;
+    /** What every new session is born with. Wire into the harness's extension evaluation. */
+    sessionDefinitions(): ExtensionDefinition[];
+    /**
+     * Load (and approve) one extension — a USER action, like `ExtensionLoader.load`. Runs the
+     * definition's `create` (if any) and publishes the result as its service, then hands the
+     * definition to future sessions. Loading an already-loaded extension reloads it: every
+     * session holding it meets at its run boundary, the per-session half is swapped (and the
+     * service replaced), and everyone resumes — the same act whether or not there is a `create`.
+     */
+    load(id: string, options?: {
+        readonly timeoutMs?: number;
+    }): Promise<void>;
+    /** Alias of `load` — the manager's load already swaps a live extension coordinated. */
+    reload(id: string, options?: {
+        readonly timeoutMs?: number;
+    }): Promise<void>;
+    /**
+     * Unload an extension. A `create`-bearing one is refused while any session still runs an
+     * extension that `uses` its service — named, so the caller knows what to detach. Its own
+     * per-session half does not block (it is removed as part of the unload).
+     */
+    unload(id: string): Promise<void>;
+    private register;
+    /** Run `create` with a staging host: the service is COLLECTED, not registered, so a throwing
+     *  `create` publishes nothing. Services default to replaceable — reload is their point. */
+    private stage;
+    /** Sessions still running an extension that `uses` `id`'s service — read off the attached
+     *  definitions themselves, so by-value and file consumers count alike. No graph walk: the
+     *  graph is depth 1. */
+    private consumersOf;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/extensions/manager.js

@@ -0,0 +1,190 @@
+/**
+ * The file-extension manager (design: docs/architecture.md §5.4-5.5). An extension
+ * is a FILE whose default export is an `ExtensionDefinition`; the manager runs its `create` half
+ * once if it has one, registers the result as a service under the extension's `id`, and hands
+ * the SAME definition to every session (its `setup` is the per-session half). One extension,
+ * one approval, one reload — the manager turns a reload into the coordinated act: barrier →
+ * swap the session half → replace the service → release.
+ *
+ * Trust: the code runs at HOST trust and holds `createSession`. The control point is the same
+ * single one as for ordinary extensions — manual load/reload IS the approval (mtime-scoped).
+ * Nothing here auto-loads or watches.
+ *
+ * `stageDefinition` — running `create` against a staging host and collecting the one service, so a
+ * throwing `create` publishes nothing — is shared with the harness's by-value channel
+ * (`createHarness({ extensions })` runs a `create`-bearing definition through it with no loader).
+ */
+import { mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { ExtensionLoader } from "./loader.js";
+import { ServiceRegistry } from "./services.js";
+function isPromiseLike(value) {
+    return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+/**
+ * Run a `create`-bearing definition's `create` half against a staging host and collect the one
+ * service it returns — nothing is registered here, so a throwing `create` publishes nothing.
+ * Shared by the file manager and the harness's by-value channel. Stays synchronous when `create`
+ * is, which the by-value channel relies on to have a synchronous extension's service visible the
+ * moment `createHarness` returns.
+ */
+export function stageDefinition(definition, options) {
+    if (definition.create === undefined)
+        return { sessionDef: definition };
+    const host = {
+        createSession: (sessionOptions) => options.createSession(sessionOptions),
+        ...(options.dir !== undefined ? { dir: options.dir } : {}),
+        ...(options.dataDir !== undefined ? { dataDir: options.dataDir } : {}),
+        warn: (message) => options.warn(`[extension ${definition.id}] ${message}`),
+    };
+    const finish = (instance) => ({
+        service: { name: definition.id, instance, options: { replaceable: options.defaultReplaceable } },
+        sessionDef: definition,
+    });
+    const result = definition.create(host);
+    return isPromiseLike(result) ? Promise.resolve(result).then(finish) : finish(result);
+}
+const DEFAULT_BARRIER_TIMEOUT_MS = 30_000;
+export class HarnessExtensionManager {
+    loader;
+    bridge;
+    /** Root of the extensions' data folders (`<root>/<id>`) — outside every code folder. */
+    dataRoot;
+    /** Every loaded extension by id, and whether its `create` published a service. */
+    loaded = new Map();
+    /** Definitions newborn sessions receive: every loaded extension's per-session half. */
+    sessionDefs = new Map();
+    constructor(options) {
+        this.loader = new ExtensionLoader({ directory: options.directory });
+        this.dataRoot = resolve(options.dataDir);
+        this.bridge = options.bridge;
+    }
+    list() {
+        return this.loader.list();
+    }
+    /** What every new session is born with. Wire into the harness's extension evaluation. */
+    sessionDefinitions() {
+        return [...this.sessionDefs.values()];
+    }
+    /**
+     * Load (and approve) one extension — a USER action, like `ExtensionLoader.load`. Runs the
+     * definition's `create` (if any) and publishes the result as its service, then hands the
+     * definition to future sessions. Loading an already-loaded extension reloads it: every
+     * session holding it meets at its run boundary, the per-session half is swapped (and the
+     * service replaced), and everyone resumes — the same act whether or not there is a `create`.
+     */
+    async load(id, options = {}) {
+        const definition = await this.loader.load(id);
+        // `uses` lives on the definition, so it is readable only after the import; a missing
+        // provider revokes the approval the import just recorded, so a failed load leaves nothing
+        // behind. Same rule for both kinds: load providers first.
+        for (const name of definition.uses ?? []) {
+            if (!this.bridge.services.has(name)) {
+                await this.loader.unload(id);
+                throw new Error(`extension "${id}" uses service "${name}", which is not registered — load the extension that provides it first`);
+            }
+        }
+        await this.register(id, definition, options);
+    }
+    /** Alias of `load` — the manager's load already swaps a live extension coordinated. */
+    reload(id, options = {}) {
+        return this.load(id, options);
+    }
+    /**
+     * Unload an extension. A `create`-bearing one is refused while any session still runs an
+     * extension that `uses` its service — named, so the caller knows what to detach. Its own
+     * per-session half does not block (it is removed as part of the unload).
+     */
+    async unload(id) {
+        const record = this.loaded.get(id);
+        if (record === undefined) {
+            // Never loaded: just revoke whatever approval is on file.
+            await this.loader.unload(id);
+            return;
+        }
+        const consumers = this.consumersOf(id);
+        if (consumers.length > 0) {
+            throw new Error(`cannot unload extension "${id}": service still consumed by ${consumers.join(", ")} — detach those first`);
+        }
+        // Own per-session half: detach everywhere (each session applies it at its own boundary — a
+        // pure removal needs no barrier; there is no two-version coexistence to prevent).
+        for (const session of this.bridge.sessions()) {
+            if (session.attachedExtensionIds().includes(id))
+                await session.detachExtension(id);
+        }
+        this.sessionDefs.delete(id);
+        if (record.hasService)
+            await this.bridge.services.unregister(id);
+        this.loaded.delete(id);
+        await this.loader.unload(id);
+    }
+    // ==========================================================================
+    // Internals
+    // ==========================================================================
+    async register(id, definition, options) {
+        const staged = await this.stage(definition);
+        const previous = this.loaded.get(id);
+        if (previous === undefined) {
+            // First load: register the service, then hand the session half to future sessions.
+            // Already-open sessions are not touched (a reload only re-attaches to sessions that hold
+            // the half) — attach it explicitly where an open session should get it.
+            if (staged.service !== undefined) {
+                this.bridge.services.register(staged.service.name, staged.service.instance, staged.service.options);
+            }
+            this.sessionDefs.set(id, staged.sessionDef);
+            this.loaded.set(id, { hasService: staged.service !== undefined });
+            return;
+        }
+        // Reload: one coordinated act — barrier on the session half, swap half + service in the
+        // quiet moment. Version skew between the two halves is structurally impossible.
+        await this.bridge.withBarrier([id], options.timeoutMs ?? DEFAULT_BARRIER_TIMEOUT_MS, async (held) => {
+            for (const session of held()) {
+                if (session.attachedExtensionIds().includes(id))
+                    await session.detachExtension(id);
+            }
+            if (staged.service !== undefined) {
+                if (this.bridge.services.has(id))
+                    await this.bridge.services.replace(id, staged.service.instance);
+                else
+                    this.bridge.services.register(staged.service.name, staged.service.instance, staged.service.options);
+            }
+            else if (previous.hasService) {
+                await this.bridge.services.unregister(id);
+            }
+            this.sessionDefs.set(id, staged.sessionDef);
+            for (const session of held()) {
+                await session.attachExtension(staged.sessionDef);
+            }
+        });
+        this.loaded.set(id, { hasService: staged.service !== undefined });
+    }
+    /** Run `create` with a staging host: the service is COLLECTED, not registered, so a throwing
+     *  `create` publishes nothing. Services default to replaceable — reload is their point. */
+    async stage(definition) {
+        // The data folder exists before `create` runs, so the extension can use it right away.
+        const dataDir = join(this.dataRoot, definition.id);
+        if (definition.create !== undefined)
+            await mkdir(dataDir, { recursive: true });
+        return stageDefinition(definition, {
+            defaultReplaceable: true,
+            dir: await this.loader.manifestDir(definition.id),
+            dataDir,
+            createSession: (sessionOptions) => this.bridge.createSession(sessionOptions),
+            warn: (message) => this.bridge.warn(message),
+        });
+    }
+    /** Sessions still running an extension that `uses` `id`'s service — read off the attached
+     *  definitions themselves, so by-value and file consumers count alike. No graph walk: the
+     *  graph is depth 1. */
+    consumersOf(id) {
+        const found = [];
+        for (const session of this.bridge.sessions()) {
+            for (const attached of session.attachedExtensions()) {
+                if (attached.uses.includes(id))
+                    found.push(`"${attached.id}" (session ${session.id})`);
+            }
+        }
+        return found;
+    }
+}
+//# sourceMappingURL=manager.js.map