@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/core/src/module/diagnostics.js

@@ -0,0 +1,99 @@
+// ============================================================================
+// DOWNDRAFT_STRICT — dev-mode diagnostics for the plugin system
+//
+// When STRICT is active (default in dev, off in prod), the plugin hosts
+// validate the dependency graph at activation time and catch common footguns:
+//   - duplicate `provide` of the same ResourceToken
+//   - missing `requires` provider (a plugin needs a token nobody provides)
+//   - brand mismatch (token type safety)
+//   - leak detection (plugin provided resources / allocated SAB channels but
+//     registered no dispose fns)
+//
+// Set `DOWNDRAFT_STRICT=0` to force-disable, `DOWNDRAFT_STRICT=1` to force-enable.
+// ============================================================================
+import { isDev } from "../platform/runtime.js";
+import { createLogger } from "../util/logger.js";
+const log = createLogger();
+/** Error thrown when STRICT validation catches a footgun. */
+export class DiagnosticError extends Error {
+    moduleName;
+    tokenKey;
+    constructor(moduleName, tokenKey, message) {
+        super(message);
+        this.name = "DiagnosticError";
+        this.moduleName = moduleName;
+        this.tokenKey = tokenKey;
+    }
+}
+function readEnv() {
+    // Explicit override always wins.
+    const env = globalThis.process?.env?.DOWNDRAFT_STRICT;
+    if (env === "1")
+        return true;
+    if (env === "0")
+        return false;
+    // Default: on in dev, off in prod. `isDev` (platform/runtime.ts) probes
+    // Vite's import.meta.env.DEV under the dev shell, then DOWNDRAFT_DEV /
+    // NODE_ENV on native runtimes — the previous globalThis.importMetaEnv
+    // lookup never observed anything (nothing sets that global), so STRICT
+    // was effectively DOWNDRAFT_STRICT=1-only even in dev.
+    return isDev;
+}
+let _strict = null;
+/**
+ * Whether STRICT diagnostics are active. Resolved lazily on first call
+ * from the DOWNDRAFT_STRICT env var or Vite's import.meta.env.DEV.
+ * Override for tests via `setStrict()`.
+ */
+export function isStrict() {
+    if (_strict === null)
+        _strict = readEnv();
+    return _strict;
+}
+/** Override the STRICT flag (for tests). Pass `null` to reset to env-based. */
+export function setStrict(value) {
+    _strict = value;
+}
+// ── Validation helpers ──
+/**
+ * Assert that a token is not already provided.
+ * @param providers  Map of tokenKey → provider plugin name
+ * @param token      The token being provided
+ * @param moduleName The plugin attempting to provide it
+ */
+export function assertNoDuplicate(providers, token, moduleName) {
+    const existing = providers.get(token.key);
+    if (existing !== undefined) {
+        throw new DiagnosticError(moduleName, token.key, `Module "${moduleName}" provides "${token.key}" but it is already provided by "${existing}". ` +
+            `Duplicate provides are not allowed — remove one, or use injectOptional to read without providing.`);
+    }
+}
+/**
+ * Assert that a required token has a provider.
+ * @param providers  Map of tokenKey → provider plugin name
+ * @param token      The required token
+ * @param moduleName The plugin that requires it
+ */
+export function assertRequired(providers, token, moduleName) {
+    if (!providers.has(token.key)) {
+        throw new DiagnosticError(moduleName, token.key, `Module "${moduleName}" requires "${token.key}" which is not provided. ` +
+            `Add a plugin that provides it, or declare it in the plugin's provides[] array.`);
+    }
+}
+/**
+ * Warn about a potential resource leak: the plugin provided resources or
+ * allocated SAB channels but registered no dispose fns.
+ */
+export function warnLeak(moduleName, details) {
+    if (details.disposeFnCount > 0)
+        return;
+    const parts = [];
+    if (details.providedCount > 0)
+        parts.push(`${details.providedCount} resource(s)`);
+    if (details.sabCount > 0)
+        parts.push(`${details.sabCount} SAB channel(s)`);
+    if (parts.length === 0)
+        return;
+    log.warn("downdraft:diagnostics", `Module "${moduleName}" provided ${parts.join(" and ")} but registered no onDispose() cleanup. ` +
+        `This may leak resources on unload.`);
+}

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

@@ -0,0 +1,449 @@
+import { getComponentId } from "../ecs/component.js";
+import { createLogger } from "../util/logger.js";
+import { assertNoDuplicate, assertRequired, isStrict, warnLeak } from "./diagnostics.js";
+import { ModuleRegistry } from "./registry.js";
+import { TsModuleLoader } from "./ts-loader.js";
+const log = createLogger();
+export class ModuleHost {
+    world;
+    registry;
+    tsLoader;
+    active = new Map();
+    pending = new Map();
+    migrations = new Map();
+    _devtools = null;
+    /** Typed resource store: tokenKey → { token, value } */
+    resources = new Map();
+    /** Reverse map: tokenKey → provider plugin name */
+    providers = new Map();
+    constructor(world, registry) {
+        this.world = world;
+        this.registry = registry ?? new ModuleRegistry();
+        this.tsLoader = new TsModuleLoader(this.registry);
+    }
+    /**
+     * Inject the DevTools API. Called by the game bootstrap after
+     * `initDevTools()` so plugins can self-register debug panels via
+     * `ctx.devtools.registerPanel(...)` during their `register()` lifecycle.
+     */
+    setDevToolsAPI(api) {
+        this._devtools = api;
+    }
+    get devtools() {
+        // Return the injected API, or a no-op stub if not set (so plugins that
+        // call ctx.devtools.registerPanel() don't crash if devtools isn't wired).
+        return this._devtools ?? NoopDevToolsAPI;
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    async loadModule(pluginPath) {
+        const plugin = await this.tsLoader.load(pluginPath);
+        this.activateModule(plugin);
+        return plugin;
+    }
+    /**
+     * Register and immediately activate a plugin.
+     * For batch registration with dependency-ordered activation,
+     * use `registerModuleDeferred()` + `activateAll()` instead.
+     */
+    registerModule(plugin) {
+        this.registry.register(plugin);
+        this.validateModule(plugin);
+        this.activateModule(plugin);
+    }
+    /**
+     * Register a plugin without activating it.
+     * Call `activateAll()` after all plugins are registered
+     * to activate them in dependency-resolved order (topological sort).
+     */
+    registerModuleDeferred(plugin) {
+        this.registry.register(plugin);
+        this.pending.set(plugin.name, plugin);
+    }
+    /**
+     * Activate all plugins registered via `registerModuleDeferred()`
+     * in dependency-resolved order (topological sort).
+     * Plugins with no dependencies are activated first.
+     *
+     * In DOWNDRAFT_STRICT mode, validates the full dependency graph
+     * (provides/requires) before activating any plugin.
+     */
+    activateAll() {
+        this.validateGraph();
+        const order = this.registry.resolveOrder();
+        for (let i = 0; i < order.length; i++) {
+            const name = order[i];
+            if (this.pending.has(name) && !this.active.has(name)) {
+                const plugin = this.pending.get(name);
+                this.pending.delete(name);
+                this.activateModule(plugin);
+            }
+        }
+    }
+    /**
+     * Register and activate multiple plugins in dependency-resolved order.
+     * This is the standard batch registration pattern — equivalent to
+     * calling `registerModuleDeferred()` for each plugin followed by
+     * `activateAll()`. Use this when multiple plugins have interdependencies
+     * (via `provides`/`requires` typed tokens).
+     */
+    useModules(plugins) {
+        for (let i = 0; i < plugins.length; i++) {
+            this.registerModuleDeferred(plugins[i]);
+        }
+        this.activateAll();
+    }
+    /**
+     * Validate a single plugin's requires against already-active providers.
+     * Used for immediate-activation (registerModule) path.
+     */
+    validateModule(plugin) {
+        if (!isStrict())
+            return;
+        if (!plugin.requires)
+            return;
+        const selfProvides = new Set(plugin.provides?.map((t) => t.key) ?? []);
+        plugin.requires.forEach((token) => {
+            if (!this.providers.has(token.key) && !selfProvides.has(token.key)) {
+                assertRequired(this.providers, token, plugin.name);
+            }
+        });
+    }
+    /**
+     * Validate the full dependency graph across all pending + active plugins.
+     * Called before batch activation in activateAll().
+     */
+    validateGraph() {
+        if (!isStrict())
+            return;
+        // Build a complete providers map from all pending + active plugins
+        const allProviders = new Map();
+        for (const [name, active] of this.active.entries()) {
+            (active.plugin.provides ?? []).forEach((token) => {
+                allProviders.set(token.key, name);
+            });
+        }
+        for (const [name, plugin] of this.pending.entries()) {
+            (plugin.provides ?? []).forEach((token) => {
+                if (allProviders.has(token.key)) {
+                    throw new Error(`Module "${name}" provides "${token.key}" but it is already provided by "${allProviders.get(token.key)}". ` +
+                        `Duplicate provides are not allowed.`);
+                }
+                allProviders.set(token.key, name);
+            });
+        }
+        // Check all requires
+        for (const [name, plugin] of this.pending.entries()) {
+            if (!plugin.requires)
+                continue;
+            plugin.requires.forEach((token) => {
+                if (!allProviders.has(token.key)) {
+                    assertRequired(allProviders, token, name);
+                }
+            });
+        }
+    }
+    activateModule(plugin) {
+        const active = {
+            plugin,
+            disposeFns: [],
+            sabChannels: new Map(),
+            providedKeys: new Set(),
+            systemNames: [],
+        };
+        this.active.set(plugin.name, active);
+        this.currentModuleName = plugin.name;
+        try {
+            plugin.register(this.makeContext(plugin.name, active));
+        }
+        catch (err) {
+            // Roll back partial activation: the module must not stay "active"
+            // with half-wired resources. Clean up anything it provided or
+            // registered for disposal, then re-throw so the caller sees it.
+            for (const key of active.providedKeys.values()) {
+                this.resources.delete(key);
+                this.providers.delete(key);
+            }
+            for (let i = active.disposeFns.length - 1; i >= 0; i--) {
+                try {
+                    active.disposeFns[i]();
+                }
+                catch (disposeErr) {
+                    log.error("module-host", `Dispose error rolling back plugin "${plugin.name}": ${disposeErr}`);
+                }
+            }
+            // Remove systems the module registered before throwing.
+            active.systemNames.forEach((sysName) => {
+                this.world.schedule.removeSystem(sysName);
+            });
+            this.active.delete(plugin.name);
+            throw err;
+        }
+        finally {
+            // Clear the attribution context — any provide/onDispose/registerSystem
+            // call made outside a register() lifecycle (async callbacks, game code)
+            // must not be silently attributed to this module.
+            this.currentModuleName = "";
+        }
+    }
+    unloadModule(name) {
+        const active = this.active.get(name);
+        if (!active)
+            return;
+        // Leak detection: warn if plugin provided resources / SAB channels
+        // but registered no dispose fns.
+        if (isStrict()) {
+            warnLeak(name, {
+                providedCount: active.providedKeys.size,
+                sabCount: active.sabChannels.size,
+                disposeFnCount: active.disposeFns.length,
+            });
+        }
+        // Clean up provided resources
+        for (const key of active.providedKeys.values()) {
+            this.resources.delete(key);
+            this.providers.delete(key);
+        }
+        for (let i = active.disposeFns.length - 1; i >= 0; i--) {
+            try {
+                active.disposeFns[i]();
+            }
+            catch (err) {
+                log.error("module-host", `Dispose error in plugin "${name}": ${err}`);
+            }
+        }
+        // Remove the module's systems from the world schedule — otherwise they
+        // keep running after unload (e.g. duplicated per hot-reload swap).
+        active.systemNames.forEach((sysName) => {
+            this.world.schedule.removeSystem(sysName);
+        });
+        this.active.delete(name);
+        this.pending.delete(name);
+        this.registry.unregister(name);
+    }
+    getModule(name) {
+        return this.registry.get(name);
+    }
+    listModules() {
+        return this.registry.getAll().map((p) => p.name);
+    }
+    /**
+     * Produce a thread-tagged snapshot of all active modules for the
+     * cross-thread report + doctor panel. `thread` identifies which side
+     * this host lives on ("sim" | "renderer").
+     *
+     * Tokens created via `crossThreadToken()` carry a `__thread` tag; the
+     * snapshot records it in `tokenThreads` so `buildCrossThreadReport()`
+     * can flag tokens provided on the wrong thread.
+     */
+    snapshot(thread) {
+        const out = [];
+        for (const [name, active] of this.active.entries()) {
+            const plugin = active.plugin;
+            const tokenThreads = {};
+            const collectTags = (tokens) => {
+                (tokens ?? []).forEach((t) => {
+                    const tag = t.__thread;
+                    if (tag)
+                        tokenThreads[t.key] = tag;
+                });
+            };
+            collectTags(plugin.provides);
+            collectTags(plugin.requires);
+            out.push({
+                name,
+                version: plugin.version,
+                thread,
+                provides: (plugin.provides ?? []).map((t) => t.key),
+                requires: (plugin.requires ?? []).map((t) => t.key),
+                active: true,
+                tokenThreads: Object.keys(tokenThreads).length > 0 ? tokenThreads : undefined,
+            });
+        }
+        return out;
+    }
+    disposeAll() {
+        const order = this.registry.resolveOrder();
+        for (let i = order.length - 1; i >= 0; i--) {
+            this.unloadModule(order[i]);
+        }
+        // Clean up unattributed registrations (made outside a register()
+        // lifecycle — they were tracked globally so they don't leak).
+        this.unattributedSystemNames.forEach((sysName) => {
+            this.world.schedule.removeSystem(sysName);
+        });
+        this.unattributedSystemNames.length = 0;
+        for (let i = this.unattributedDisposeFns.length - 1; i >= 0; i--) {
+            try {
+                this.unattributedDisposeFns[i]();
+            }
+            catch (err) {
+                log.error("module-host", `Unattributed dispose error: ${err}`);
+            }
+        }
+        this.unattributedDisposeFns.length = 0;
+    }
+    registerComponent(name, _schema) {
+        return getComponentId(name);
+    }
+    registerSystem(stage, system) {
+        if (!this.currentModuleName) {
+            log.warn("module-host", "registerSystem called outside a module register() lifecycle — the system will not be attributed to any module");
+        }
+        this.registerSystemFor(this.currentModuleName || "unattributed", stage, system);
+    }
+    registerSystemFor(owner, stage, system) {
+        this.systemCounter++;
+        const name = `module:${owner}:${this.systemCounter}`;
+        this.world.schedule.add({
+            name,
+            stage,
+            fn: system,
+            queries: [],
+        });
+        const active = this.active.get(owner);
+        if (active) {
+            active.systemNames.push(name);
+        }
+        else {
+            this.unattributedSystemNames.push(name);
+        }
+    }
+    registerSystemObject(system) {
+        if (!this.currentModuleName) {
+            log.warn("module-host", `registerSystemObject("${system.name}") called outside a module register() lifecycle — the system will not be attributed to any module`);
+        }
+        this.registerSystemObjectFor(this.currentModuleName, system);
+    }
+    registerSystemObjectFor(owner, system) {
+        this.world.schedule.add(system);
+        const active = this.active.get(owner);
+        if (active) {
+            active.systemNames.push(system.name);
+        }
+        else {
+            this.unattributedSystemNames.push(system.name);
+        }
+    }
+    allocateSABChannel(name, size) {
+        if (!this.currentModuleName) {
+            log.warn("module-host", `allocateSABChannel("${name}") called outside a module register() lifecycle — the channel is untracked and won't be cleaned up on unload`);
+        }
+        return this.allocateSABChannelFor(this.currentModuleName, name, size);
+    }
+    allocateSABChannelFor(owner, name, size) {
+        const buffer = new SharedArrayBuffer(size);
+        const active = this.active.get(owner);
+        if (active) {
+            active.sabChannels.set(name, buffer);
+        }
+        return { name, buffer };
+    }
+    provide(token, value) {
+        if (!this.currentModuleName) {
+            log.warn("module-host", `provide("${token.key}") called outside a module register() lifecycle — the resource won't be cleaned up on unload`);
+        }
+        this.provideFor(this.currentModuleName, token, value);
+    }
+    provideFor(owner, token, value) {
+        if (isStrict()) {
+            assertNoDuplicate(this.providers, token, owner);
+        }
+        this.resources.set(token.key, { token: token, value });
+        this.providers.set(token.key, owner);
+        const active = this.active.get(owner);
+        if (active) {
+            active.providedKeys.add(token.key);
+        }
+    }
+    /**
+     * Provide a typed resource from an external provider (e.g. the LibraryHost).
+     * Unlike `provide()`, this does not require a current plugin context.
+     * The `providerName` is used for diagnostics.
+     */
+    provideExternal(providerName, token, value) {
+        if (isStrict()) {
+            assertNoDuplicate(this.providers, token, providerName);
+        }
+        this.resources.set(token.key, { token: token, value });
+        this.providers.set(token.key, providerName);
+    }
+    inject(token) {
+        return this.injectFor(this.currentModuleName, token);
+    }
+    injectFor(owner, token) {
+        const entry = this.resources.get(token.key);
+        if (!entry) {
+            throw new Error(`Module "${owner}" injects "${token.key}" which is not provided. ` +
+                `Add a module that provides it, or use injectOptional() for safe reads.`);
+        }
+        return entry.value;
+    }
+    injectOptional(token) {
+        const entry = this.resources.get(token.key);
+        return entry?.value;
+    }
+    registerMigration(fromVersion, fn) {
+        this.migrations.set(fromVersion, fn);
+    }
+    getMigration(fromVersion) {
+        return this.migrations.get(fromVersion);
+    }
+    onDispose(fn) {
+        const active = this.active.get(this.currentModuleName);
+        if (active) {
+            active.disposeFns.push(fn);
+        }
+        else {
+            // Don't drop the callback silently — run it at disposeAll() so
+            // resources registered outside a lifecycle still get cleaned up.
+            log.warn("module-host", "onDispose called outside a module register() lifecycle — the callback will run at disposeAll() instead of being attributed to a module");
+            this.unattributedDisposeFns.push(fn);
+        }
+    }
+    currentModuleName = "";
+    systemCounter = 0;
+    /** Systems registered outside a register() lifecycle — removed at disposeAll(). */
+    unattributedSystemNames = [];
+    /** Dispose callbacks registered outside a register() lifecycle — run at disposeAll(). */
+    unattributedDisposeFns = [];
+    setCurrentPlugin(name) {
+        this.currentModuleName = name;
+    }
+    /**
+     * Per-module context facade handed to `register()`. Lifecycle calls are
+     * bound to the owning module at creation time — a module that retains its
+     * ctx and calls it later (async callback, or during another module's
+     * register()) stays correctly attributed instead of leaking onto whatever
+     * module happens to be activating. Mirrors RendererModuleHost.makeContext.
+     */
+    makeContext(name, active) {
+        const devtoolsApi = () => this.devtools;
+        return {
+            // Lazy — the DevTools API may be injected after register() runs;
+            // resolving per-access keeps late wiring (setDevToolsAPI) working.
+            get devtools() { return devtoolsApi(); },
+            registerComponent: (n, s) => this.registerComponent(n, s),
+            registerSystem: (stage, system) => this.registerSystemFor(name, stage, system),
+            registerSystemObject: (system) => this.registerSystemObjectFor(name, system),
+            allocateSABChannel: (n, size) => this.allocateSABChannelFor(name, n, size),
+            provide: (token, value) => this.provideFor(name, token, value),
+            inject: (token) => this.injectFor(name, token),
+            injectOptional: (token) => this.injectOptional(token),
+            registerMigration: (fromVersion, fn) => this.registerMigration(fromVersion, fn),
+            onDispose: (fn) => {
+                active.disposeFns.push(fn);
+            },
+        };
+    }
+}
+// No-op DevTools API stub — used when setDevToolsAPI() hasn't been called.
+// Plugins that call ctx.devtools.registerPanel() will silently no-op.
+const NoopDevToolsAPI = {
+    registerPanel: () => { },
+    registerOverlayToggle: () => { },
+    registerDataFeed: () => { },
+    registerCommand: () => { },
+    registerSABStat: () => { },
+};

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

@@ -0,0 +1,6 @@
+// Module sub-barrel — re-exports all module-related items.
+export { buildCrossThreadReport, crossThreadToken } from "./cross-thread.js";
+export { DiagnosticError, isStrict, setStrict } from "./diagnostics.js";
+export { ModuleHost } from "./host.js";
+export { ModuleRegistry } from "./registry.js";
+export { TsModuleLoader } from "./ts-loader.js";

package/dist/core/src/module/module.js

@@ -0,0 +1 @@
+export {};

package/dist/core/src/module/registry.js

@@ -0,0 +1,83 @@
+export class ModuleRegistry {
+    plugins = new Map();
+    loadOrder = [];
+    register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            throw new Error(`Module "${plugin.name}" is already registered`);
+        }
+        if (plugin.dependencies) {
+            for (let i = 0; i < plugin.dependencies.length; i++) {
+                if (!this.plugins.has(plugin.dependencies[i])) {
+                    throw new Error(`Module "${plugin.name}" requires "${plugin.dependencies[i]}" which is not registered`);
+                }
+            }
+        }
+        this.plugins.set(plugin.name, plugin);
+        this.loadOrder.push(plugin.name);
+    }
+    unregister(name) {
+        this.plugins.delete(name);
+        const idx = this.loadOrder.indexOf(name);
+        if (idx >= 0)
+            this.loadOrder.splice(idx, 1);
+    }
+    get(name) {
+        return this.plugins.get(name);
+    }
+    getAll() {
+        return this.loadOrder.map((name) => this.plugins.get(name)).filter(Boolean);
+    }
+    has(name) {
+        return this.plugins.has(name);
+    }
+    /**
+     * Resolve activation order via topological sort over `dependencies`
+     * (module names) AND `requires` (typed tokens → provider module). A module
+     * that `requires` a token must activate after whichever module `provides`
+     * it — otherwise its `register()` would fail at `inject()`.
+     *
+     * Throws on a dependency cycle. A `requires` token with no registered
+     * provider adds no edge (the strict-mode graph validation reports it).
+     */
+    resolveOrder() {
+        // Provider map: token key → module name that provides it.
+        const providers = new Map();
+        for (const m of this.getAll()) {
+            (m.provides ?? []).forEach((token) => {
+                providers.set(token.key, m.name);
+            });
+        }
+        const visited = new Set();
+        const result = [];
+        const visiting = new Set();
+        const visit = (name) => {
+            if (visited.has(name))
+                return;
+            if (visiting.has(name)) {
+                throw new Error(`Module dependency cycle detected at "${name}"`);
+            }
+            visiting.add(name);
+            const plugin = this.plugins.get(name);
+            if (plugin?.dependencies) {
+                for (let i = 0; i < plugin.dependencies.length; i++) {
+                    visit(plugin.dependencies[i]);
+                }
+            }
+            // requires (typed tokens → provider module)
+            if (plugin?.requires) {
+                plugin.requires.forEach((token) => {
+                    const providerName = providers.get(token.key);
+                    if (providerName && providerName !== name)
+                        visit(providerName);
+                });
+            }
+            visiting.delete(name);
+            visited.add(name);
+            result.push(name);
+        };
+        for (let i = 0; i < this.loadOrder.length; i++) {
+            visit(this.loadOrder[i]);
+        }
+        return result;
+    }
+}

package/dist/core/src/module/renderer-module.js

@@ -0,0 +1,13 @@
+// ============================================================================
+// Renderer Module System — first-class renderer-thread plugin surface
+//
+// Distinct from the sim-thread `Module` (which registers ECS systems/resources
+// against a World). Renderer plugins run on the renderer thread and own
+// DOM/GPU/input/frame-hook concerns: camera controllers, gizmos, XR frame
+// loops, offscreen render targets, etc.
+//
+// A plugin that spans both threads (e.g. XR) ships two objects: a sim `Module`
+// for sim-side resources and a `RendererModule` for the renderer-side frame
+// loop. See docs/site/src/content/docs/guides/plugins.md.
+// ============================================================================
+export {};

package/dist/core/src/module/ts-loader.js

@@ -0,0 +1,20 @@
+export class TsModuleLoader {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async load(pluginPath) {
+        const mod = await import(/* @vite-ignore */ pluginPath);
+        const plugin = mod.default ?? mod;
+        this.registry.register(plugin);
+        return plugin;
+    }
+    async loadAll(paths) {
+        const plugins = [];
+        for (let i = 0; i < paths.length; i++) {
+            const plugin = await this.load(paths[i]);
+            plugins.push(plugin);
+        }
+        return plugins;
+    }
+}