@downdraft/engine 0.1.1 → 0.1.2-alpha.5

package/dist/core/src/plugin/host.js

@@ -0,0 +1,542 @@
+// ============================================================================
+// PluginHost — discovers, validates, sandboxes, loads, and disposes plugins.
+//
+// Thread-agnostic: a renderer-side host and a sim-side host each manage the
+// plugins targeted at their thread. The host:
+//   1. Discovers plugin manifests from configured sources (local dir, workshop).
+//   2. Validates each manifest (validatePluginManifest) + engine/game compat.
+//   3. Resolves permissions (requested ∩ tier ∩ game allowlist).
+//   4. Resolves load order (PluginRegistry topological sort).
+//   5. For each plugin in order, asks the format-specific loader to load it,
+//      passing a tiered PluginContext facade. Native-tier context bridges
+//      into the provided ModuleHost's typed-DI graph.
+//   6. Tracks active plugins, dispose fns, and snapshot for diagnostics.
+//
+// Loaders are pluggable (one per format). Phase 1 wires WorkerPluginLoader;
+// asset/wasm/quickjs loaders are added in later phases.
+// ============================================================================
+import { createLogger } from "../util/logger.js";
+import { makeNativeContext, makeScriptContext } from "./context.js";
+import { pluginInfoFromManifest, } from "./diagnostics.js";
+import { flattenExtensions, validatePluginManifest } from "./manifest.js";
+import { resolvePermissions, } from "./permissions.js";
+import { PluginRegistry } from "./registry.js";
+const log = createLogger("info");
+// ── Host ──
+export class PluginHost {
+    registry = new PluginRegistry();
+    active = new Map();
+    loaders = new Map();
+    extensionLoaders = new Map();
+    opts;
+    /** Manifests discovered but not yet loaded (id → manifest + source). */
+    discovered = new Map();
+    /** Shared event bus — all plugins on this host publish/subscribe through
+     *  the same bus so mods can actually communicate with each other and with
+     *  the game (previously each plugin got a private bus, so publish/subscribe
+     *  could never cross plugin boundaries). */
+    eventBus = makeEventBus();
+    /** Per-plugin in-process tick drains (plugin id → drain fn). */
+    tickDrains = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Register a format-specific loader for the `logic` extension. */
+    registerLoader(loader) {
+        this.loaders.set(loader.format, loader);
+        // Let loaders reach back into the host (event bus fan-out, grant checks).
+        loader.bindHost?.(this);
+    }
+    /**
+     * Inject the ModuleHost after construction. Needed when the renderer's
+     * ModuleHost only exists after renderer init (startGame constructs the
+     * PluginHost early but must wire the ModuleHost before loadAll()).
+     */
+    setModuleHost(moduleHost) {
+        this.opts.moduleHost = moduleHost;
+    }
+    /**
+     * Publish an event to every plugin on this host (and, for worker plugins,
+     * to their sandbox via the loader's fan-out). Games call this to push
+     * game-defined events into the mod ecosystem.
+     */
+    publishEvent(event, data) {
+        if (this.opts.eventCatalog && !(event in this.opts.eventCatalog)) {
+            log.warn("plugin-host", `publishEvent("${event}") — not in the game's event catalog; delivering anyway`);
+        }
+        this.eventBus.publish(event, data);
+    }
+    /**
+     * Drive plugin tick callbacks. Games call this once per frame/tick from
+     * their render loop. In-process plugins' onTick callbacks are drained here;
+     * worker plugins receive a `__tick` message via their loader.
+     */
+    tick(dt, elapsedTime) {
+        for (const drain of this.tickDrains.values()) {
+            try {
+                drain(dt, elapsedTime);
+            }
+            catch (e) {
+                log.error("plugin-host", `Plugin tick error: ${e.message}`);
+            }
+        }
+        for (const loader of this.loaders.values()) {
+            loader.tick?.(dt, elapsedTime);
+        }
+    }
+    /** Register an extra dispose fn on an active plugin (used by bridge wiring
+     *  to clean up host-side event subscriptions when a worker plugin unloads). */
+    trackDispose(pluginId, fn) {
+        const a = this.active.get(pluginId);
+        if (a)
+            a.disposeFns.push(fn);
+    }
+    /** The shared event bus (for loader fan-out to worker plugins). */
+    get sharedEventBus() {
+        return this.eventBus;
+    }
+    /** Register a bucket-specific loader for a declarative extension kind. */
+    registerExtensionLoader(loader) {
+        this.extensionLoaders.set(loader.bucket, loader);
+    }
+    // ── Discovery ──
+    /**
+     * Register a discovered manifest (from a local dir scan or workshop fetch).
+     * Validates the manifest + engine/game compatibility. Does NOT load yet.
+     */
+    discover(manifest, source) {
+        const v = validatePluginManifest(manifest);
+        if (!v.valid)
+            return { ok: false, errors: v.errors };
+        const m = v.normalized;
+        if (m.game !== this.opts.gameId) {
+            return { ok: false, errors: [`game "${m.game}" does not match host game "${this.opts.gameId}"`] };
+        }
+        if (!satisfiesEngine(this.opts.engineVersion, m.engineVersion)) {
+            return {
+                ok: false,
+                errors: [`engineVersion "${m.engineVersion}" not satisfied by engine "${this.opts.engineVersion}"`],
+            };
+        }
+        this.discovered.set(m.id, { manifest: m, source });
+        return { ok: true, errors: [] };
+    }
+    /**
+     * Load all discovered plugins in dependency-resolved order.
+     * Plugins that fail validation/loading are marked `error` and skipped;
+     * dependents of an errored plugin are also skipped.
+     */
+    async loadAll() {
+        // Register all discovered manifests with the registry for topo sort.
+        for (const [id, d] of this.discovered.entries()) {
+            if (!this.registry.has(id))
+                this.registry.register(d.manifest);
+        }
+        let order;
+        try {
+            order = this.registry.resolveOrder();
+        }
+        catch (e) {
+            log.error("plugin-host", `Dependency resolution failed: ${e.message}`);
+            // Mark all discovered as errored.
+            for (const [id, d] of this.discovered.entries()) {
+                this.active.set(id, {
+                    manifest: d.manifest,
+                    status: "error",
+                    disposeFns: [],
+                    granted: { granted: new Set(), denied: [] },
+                    error: e.message,
+                    source: d.source,
+                });
+            }
+            return;
+        }
+        for (let _i = 0, _it = order, _n = _it.length; _i < _n; _i++) {
+            const id = _it[_i];
+            const d = this.discovered.get(id);
+            if (!d)
+                continue;
+            if (this.active.has(id))
+                continue; // already loaded (reload path)
+            // Skip if any dependency errored.
+            const m = d.manifest;
+            const depFailed = (m.dependencies ?? []).some((dep) => {
+                const depId = dep.split("@")[0];
+                const a = this.active.get(depId);
+                return a?.status === "error";
+            });
+            if (depFailed) {
+                this.active.set(id, {
+                    manifest: m,
+                    status: "error",
+                    disposeFns: [],
+                    granted: { granted: new Set(), denied: [] },
+                    error: "a dependency failed to load",
+                    source: d.source,
+                });
+                log.warn("plugin-host", `Skipping "${id}" — dependency failed`);
+                continue;
+            }
+            await this.loadOne(id);
+        }
+    }
+    async loadOne(id) {
+        const d = this.discovered.get(id);
+        const m = d.manifest;
+        // Resolve the logic loader. For a mod.json the loader is keyed by
+        // `logic.format`; for a legacy plugin.json it's keyed by `format`. A
+        // pure-data mod (no logic) has no logic loader and skips straight to
+        // extension dispatch.
+        const logicFormat = m.logic?.format ?? m.format;
+        const hasLogic = !!m.logic || (m.format && m.format !== "asset");
+        const loader = hasLogic ? this.loaders.get(logicFormat) : undefined;
+        if (hasLogic && !loader) {
+            this.active.set(id, {
+                manifest: m,
+                status: "error",
+                disposeFns: [],
+                granted: { granted: new Set(), denied: [] },
+                error: `no loader registered for format "${logicFormat}"`,
+                source: d.source,
+            });
+            log.error("plugin-host", `No loader for "${id}" (format ${logicFormat})`);
+            return;
+        }
+        const granted = resolvePermissions(m.logic?.permissions ?? m.permissions ?? [], m.tier, this.opts.gameAllow);
+        this.active.set(id, {
+            manifest: m,
+            status: "loading",
+            disposeFns: [],
+            granted,
+            source: d.source,
+        });
+        try {
+            const ctx = this.buildContext(m, granted);
+            // 1. Load the logic extension (code entry) if present.
+            if (loader) {
+                const dispose = await loader.load(m, ctx, granted);
+                if (dispose) {
+                    const a = this.active.get(id);
+                    a.disposeFns.push(dispose);
+                }
+            }
+            // 2. Dispatch declarative extensions (assets, maps, physics, shaders).
+            //    Each is loaded by its bucket-specific ExtensionLoader. Failures are
+            //    recorded on the plugin snapshot but do not abort the whole mod —
+            //    a bad shader shouldn't prevent the mod's assets from loading.
+            const exts = flattenExtensions(m);
+            for (let _i = 0, _it = exts, _n = _it.length; _i < _n; _i++) {
+                const ext = _it[_i];
+                const extLoader = this.extensionLoaders.get(ext.bucket);
+                if (!extLoader) {
+                    log.warn("plugin-host", `No extension loader for bucket "${ext.bucket}" (mod "${id}") — skipping`);
+                    continue;
+                }
+                try {
+                    const dispose = await extLoader.load(m, ext.extension, ctx);
+                    if (dispose) {
+                        const a = this.active.get(id);
+                        a.disposeFns.push(dispose);
+                    }
+                }
+                catch (e) {
+                    log.error("plugin-host", `Extension load error in "${id}" (${ext.bucket}): ${e.message}`);
+                }
+            }
+            const a = this.active.get(id);
+            a.status = "active";
+            log.info("plugin-host", `Loaded mod "${id}" (${logicFormat ?? "data"}/${m.tier})`);
+        }
+        catch (e) {
+            const a = this.active.get(id);
+            a.status = "error";
+            a.error = e.message;
+            log.error("plugin-host", `Failed to load mod "${id}": ${e.message}`);
+        }
+    }
+    /** Build the tiered context facade for a plugin. */
+    buildContext(m, granted) {
+        const host = this;
+        // Shared bus, wrapped per-plugin so subscriptions/publishes are
+        // validated against the game's event catalog (when one is configured).
+        const events = this.wrapEventBus(m.id);
+        const state = makeStateStore(m.id);
+        const tick = makeTickApi(m.id);
+        // Track the in-process drain so tick() can drive this plugin's callbacks;
+        // removed on unload.
+        this.tickDrains.set(m.id, tick._drain ?? (() => { }));
+        const pluginLog = makeLogger(m.id);
+        const onDispose = (fn) => {
+            const a = host.active.get(m.id);
+            if (a)
+                a.disposeFns.push(fn);
+        };
+        const backing = {
+            id: m.id,
+            events,
+            state,
+            tick,
+            log: pluginLog,
+            onDispose,
+        };
+        if (m.tier === "native") {
+            const mh = this.opts.moduleHost;
+            if (!mh) {
+                throw new Error(`Plugin "${m.id}" is native-tier but no ModuleHost is configured on this thread.`);
+            }
+            // Bridge into the real ModuleHost. setCurrentPlugin so provide/inject
+            // attribute resources to this plugin.
+            backing.registerComponent = (name, schema) => mh.registerComponent(name, schema);
+            backing.registerSystem = (stage, system) => {
+                mh.setCurrentPlugin(`plugin:${m.id}`);
+                mh.registerSystem(stage, system);
+            };
+            backing.allocateSABChannel = (name, size) => {
+                mh.setCurrentPlugin(`plugin:${m.id}`);
+                return mh.allocateSABChannel(name, size);
+            };
+            backing.provide = (token, value) => {
+                mh.setCurrentPlugin(`plugin:${m.id}`);
+                mh.provide(token, value);
+            };
+            backing.inject = (token) => mh.inject(token);
+            backing.injectOptional = (token) => mh.injectOptional(token);
+            backing.devtools = this.opts.devtools ?? mh.devtools;
+            backing.hostCalls = this.opts.hostCalls;
+            return makeNativeContext(backing, granted.granted);
+        }
+        return makeScriptContext(backing, granted.granted);
+    }
+    /**
+     * Wrap the shared bus for a plugin: validates event names against the
+     * game's event catalog (if configured) — unknown events warn but still
+     * deliver, so a partial catalog doesn't break cross-plugin traffic.
+     */
+    wrapEventBus(pluginId) {
+        const bus = this.eventBus;
+        const catalog = this.opts.eventCatalog;
+        const check = (event, op) => {
+            if (catalog && !(event in catalog)) {
+                log.warn("plugin-host", `plugin "${pluginId}" ${op} unknown event "${event}" (not in catalog)`);
+            }
+        };
+        return {
+            subscribe(event, handler) {
+                check(event, "subscribed to");
+                return bus.subscribe(event, handler);
+            },
+            publish(event, data) {
+                check(event, "published");
+                bus.publish(event, data);
+            },
+        };
+    }
+    // ── Unload / dispose ──
+    unload(id) {
+        const a = this.active.get(id);
+        if (!a)
+            return;
+        for (let i = a.disposeFns.length - 1; i >= 0; i--) {
+            try {
+                a.disposeFns[i]();
+            }
+            catch (e) {
+                log.error("plugin-host", `Dispose error in plugin "${id}": ${e.message}`);
+            }
+        }
+        this.active.delete(id);
+        this.tickDrains.delete(id);
+        this.registry.unregister(id);
+    }
+    disposeAll() {
+        let order = [];
+        try {
+            order = this.registry.resolveOrder();
+        }
+        catch {
+            order = [...this.active.keys()];
+        }
+        for (let i = order.length - 1; i >= 0; i--)
+            this.unload(order[i]);
+    }
+    /** Reload a single plugin (dispose + reload). */
+    async reload(id) {
+        const d = this.discovered.get(id);
+        if (!d) {
+            log.warn("plugin-host", `reload: "${id}" not discovered`);
+            return;
+        }
+        this.unload(id);
+        if (!this.registry.has(id))
+            this.registry.register(d.manifest);
+        await this.loadOne(id);
+    }
+    // ── Snapshot ──
+    snapshot() {
+        const out = [];
+        for (const [, a] of this.active.entries()) {
+            out.push(pluginInfoFromManifest(a.manifest, a.status, {
+                error: a.error,
+                deniedPermissions: a.granted.denied,
+                source: a.source,
+            }));
+        }
+        // Include discovered-but-not-loaded (pending) for diagnostics.
+        for (const [id, d] of this.discovered.entries()) {
+            if (!this.active.has(id)) {
+                out.push(pluginInfoFromManifest(d.manifest, "pending", { source: d.source }));
+            }
+        }
+        return out;
+    }
+    getActiveIds() {
+        return [...this.active.entries()].filter(([, a]) => a.status === "active").map(([id]) => id);
+    }
+}
+// ── Engine version range check (minimal) ──
+function satisfiesEngine(engine, range) {
+    if (range === "*")
+        return true;
+    const eParts = engine.split(".").map((n) => parseInt(n, 10));
+    // Strip comparator prefix
+    const r = range.replace(/^[<>=~^]+/, "").split(".");
+    const rParts = r.map((n) => (n === "x" || n === "X" ? NaN : parseInt(n, 10)));
+    if (range.startsWith("^")) {
+        // ^1.2.3 → >=1.2.3 <2.0.0
+        if (eParts[0] !== rParts[0])
+            return false;
+        if (eParts[1] < rParts[1])
+            return false;
+        if (eParts[1] === rParts[1] && eParts[2] < (rParts[2] || 0))
+            return false;
+        return true;
+    }
+    if (range.startsWith("~")) {
+        if (eParts[0] !== rParts[0])
+            return false;
+        if (eParts[1] !== rParts[1])
+            return false;
+        if (eParts[2] < (rParts[2] || 0))
+            return false;
+        return true;
+    }
+    if (range.startsWith(">=")) {
+        for (let i = 0; i < 3; i++) {
+            if (eParts[i] > rParts[i])
+                return true;
+            if (eParts[i] < rParts[i])
+                return false;
+        }
+        return true;
+    }
+    if (range.startsWith("<=")) {
+        for (let i = 0; i < 3; i++) {
+            if (eParts[i] < rParts[i])
+                return true;
+            if (eParts[i] > rParts[i])
+                return false;
+        }
+        return true;
+    }
+    if (range.startsWith(">")) {
+        for (let i = 0; i < 3; i++) {
+            if (eParts[i] > rParts[i])
+                return true;
+            if (eParts[i] < rParts[i])
+                return false;
+        }
+        return false;
+    }
+    if (range.startsWith("<")) {
+        for (let i = 0; i < 3; i++) {
+            if (eParts[i] < rParts[i])
+                return true;
+            if (eParts[i] > rParts[i])
+                return false;
+        }
+        return false;
+    }
+    // plain / = / exact-ish (ignore missing minor/patch → treat as x)
+    for (let i = 0; i < 3; i++) {
+        if (Number.isNaN(rParts[i]))
+            continue;
+        if (eParts[i] !== rParts[i])
+            return false;
+    }
+    return true;
+}
+// ── Context backing factories ──
+//
+// These are simple in-process implementations. For worker-js/wasm/quickjs
+// plugins that run off-thread / in a VM, the loader replaces these with
+// MessageChannel-/marshal-backed proxies that forward to the host. The
+// in-process versions are used for renderer-thread (quickjs/asset) plugins
+// and for tests.
+function makeEventBus() {
+    const handlers = new Map();
+    return {
+        subscribe(event, handler) {
+            let set = handlers.get(event);
+            if (!set) {
+                set = new Set();
+                handlers.set(event, set);
+            }
+            set.add(handler);
+            return () => set.delete(handler);
+        },
+        publish(event, data) {
+            const set = handlers.get(event);
+            if (set)
+                for (const h of set.values())
+                    h(data);
+        },
+    };
+}
+function makeStateStore(_pluginId) {
+    const store = new Map();
+    return {
+        get: (key) => store.get(key),
+        set: (key, value) => {
+            store.set(key, value);
+        },
+        delete: (key) => {
+            store.delete(key);
+        },
+        keys: () => [...store.keys()],
+        save: async () => {
+            /* OPFS persistence wired in Phase 2 (storage permission) */
+        },
+        load: async () => {
+            /* OPFS load wired in Phase 2 */
+        },
+    };
+}
+function makeTickApi(_pluginId) {
+    const callbacks = new Set();
+    // The host's render/sim loop calls `runTicks(dt, t)` each frame; we expose
+    // registration here and the host drains the set. Stored on the api object
+    // so the host can access it.
+    const api = {
+        onTick(fn) {
+            callbacks.add(fn);
+            return () => callbacks.delete(fn);
+        },
+        _drain(dt, t) {
+            for (const cb of callbacks.values())
+                cb(dt, t);
+        },
+    };
+    return api;
+}
+function fmt(msg, args) {
+    return args.length > 0 ? `${msg} ${args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ")}` : msg;
+}
+function makeLogger(_pluginId) {
+    const prefix = `plugin:${_pluginId}`;
+    return {
+        info: (msg, ...args) => log.info(prefix, fmt(msg, args)),
+        warn: (msg, ...args) => log.warn(prefix, fmt(msg, args)),
+        error: (msg, ...args) => log.error(prefix, fmt(msg, args)),
+        debug: (msg, ...args) => log.debug(prefix, fmt(msg, args)),
+    };
+}

package/dist/core/src/plugin/index.js

@@ -0,0 +1,19 @@
+// Plugin sub-barrel — re-exports all plugin-related items.
+export { makeNativeContext, makeScriptContext } from "./context.js";
+export { pluginInfoFromManifest } from "./diagnostics.js";
+export { collectPluginManifests, createAssetRegistryBridge, createNoopMapRegistry, createNoopPhysicsRegistry, deriveAssetName, discoverPlugins, pluginBaseUrlLookup, resolvePluginAssetUrl } from "./discovery.js";
+export { createAssetLoader, createMapLoader, createMaterialShaderLoader, createPhysicsLoader, createPostfxShaderLoader, registerAllExtensionLoaders } from "./extension-loaders.js";
+export { PluginHost } from "./host.js";
+export { AssetPluginLoader } from "./loader-asset.js";
+export { QuickjsPluginLoader } from "./loader-quickjs.js";
+export { InlineWasmPluginLoader, WasmPluginLoader } from "./loader-wasm.js";
+export { InlinePluginLoader, WorkerPluginLoader } from "./loader-worker.js";
+export { flattenExtensions, validatePluginManifest } from "./manifest.js";
+export { MaterialRegistry } from "./material-registry.js";
+export { createPluginMcpTools } from "./mcp-tools.js";
+export { BASELINE_GLOBALS, computeGlobalAllowlist, PERMISSION_GLOBALS, resolvePermissions, TIER_ALLOWED } from "./permissions.js";
+export { createQuickjsBridge, getQuickJS } from "./quickjs-bridge.js";
+export { PluginRegistry } from "./registry.js";
+export { restrictGlobals } from "./sandbox-shim.js";
+export { readBytesFromMemory, readStringFromMemory, WASM_PLUGIN_ABI_VERSION, writeBytesToMemory, writeStringToMemory } from "./wasm-abi.js";
+export { WorkshopFetcher } from "./workshop.js";

package/dist/core/src/plugin/loader-asset.js

@@ -0,0 +1,105 @@
+// ============================================================================
+// AssetPluginLoader — loads `asset` format (data-tier) plugins.
+//
+// An asset plugin has no code entry. Its manifest declares an `assets`
+// section listing files (textures, audio, meshes, data) that the loader
+// registers into the game's `AssetManager`:
+//   - adds the plugin directory as a search path (so `load("bronze.png")`
+//     resolves to the plugin's file),
+//   - registers per-extension loaders if not already registered,
+//   - eagerly loads the declared textures/audio/meshes so they're available
+//     when the game queries them,
+//   - exposes data files via `AssetManager.get(uri)`.
+//
+// On dispose, the loader removes the search path and unloads the assets.
+// ============================================================================
+import { createLogger } from "../util/logger.js";
+const log = createLogger("info");
+export class AssetPluginLoader {
+    format = "asset";
+    opts;
+    /** pluginId → list of URIs loaded (for unload). */
+    loadedUris = new Map();
+    /** pluginId → search-path name registered (for unload). */
+    searchPathNames = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async load(manifest, _ctx, _granted) {
+        const am = this.opts.assetManager;
+        const base = this.opts.resolveBase(manifest.id, manifest.__source ?? "local");
+        const spName = `plugin:${manifest.id}`;
+        am.addSearchPath(spName, base);
+        this.searchPathNames.set(manifest.id, spName);
+        const assets = manifest.assets;
+        if (!assets)
+            return;
+        const loaded = [];
+        // Eagerly load declared asset categories. Each entry is a path relative
+        // to the plugin dir; the search path makes them resolvable.
+        for (let _i = 0, _it = assets.textures ?? [], _n = _it.length; _i < _n; _i++) {
+            const path = _it[_i];
+            try {
+                await am.load(path);
+                loaded.push(path);
+            }
+            catch (e) {
+                log.error("asset-plugin-loader", `Failed to load texture "${path}" for plugin "${manifest.id}": ${e.message}`);
+            }
+        }
+        for (let _i = 0, _it = assets.audio ?? [], _n = _it.length; _i < _n; _i++) {
+            const path = _it[_i];
+            try {
+                await am.load(path);
+                loaded.push(path);
+            }
+            catch (e) {
+                log.error("asset-plugin-loader", `Failed to load audio "${path}" for plugin "${manifest.id}": ${e.message}`);
+            }
+        }
+        for (let _i = 0, _it = assets.meshes ?? [], _n = _it.length; _i < _n; _i++) {
+            const path = _it[_i];
+            try {
+                await am.load(path);
+                loaded.push(path);
+            }
+            catch (e) {
+                log.error("asset-plugin-loader", `Failed to load mesh "${path}" for plugin "${manifest.id}": ${e.message}`);
+            }
+        }
+        // Data files (JSON etc.) — loaded as raw text via the generic loader.
+        for (let _i = 0, _it = assets.data ?? [], _n = _it.length; _i < _n; _i++) {
+            const path = _it[_i];
+            try {
+                await am.load(path);
+                loaded.push(path);
+            }
+            catch (e) {
+                log.error("asset-plugin-loader", `Failed to load data "${path}" for plugin "${manifest.id}": ${e.message}`);
+            }
+        }
+        this.loadedUris.set(manifest.id, loaded);
+        log.info("asset-plugin-loader", `Loaded ${loaded.length} asset(s) for plugin "${manifest.id}" from ${base}`);
+        return () => this.dispose(manifest.id);
+    }
+    dispose(pluginId) {
+        const am = this.opts.assetManager;
+        const uris = this.loadedUris.get(pluginId);
+        if (uris) {
+            uris.forEach((uri) => {
+                try {
+                    am.releaseSync(uri);
+                }
+                catch {
+                    /* best-effort */
+                }
+            });
+            this.loadedUris.delete(pluginId);
+        }
+        const spName = this.searchPathNames.get(pluginId);
+        if (spName) {
+            am.removeSearchPath(spName);
+            this.searchPathNames.delete(pluginId);
+        }
+    }
+}