@lapis-notes/api 0.1.0

package/dist/plugin-manager.js

@@ -0,0 +1,2848 @@
+import { Platform } from "./platform";
+import { getNativeDesktopBridge, } from "./storage/desktop-native";
+import { activationEventForContribution, buildLapisContributionIndex, classifyLapisPlugin, commandContributionToCommand, isLapisManifest, normalizeManifestCommandId, permissionsToCapabilities, validateLapisManifest, } from "./lapis-extension";
+import { selectPluginRuntimeEntry, } from "./plugin-runtime-entry";
+import { Plugin, resolvePluginDataPath, } from "./plugin";
+import { HOSTED_PLUGIN_CAPABILITIES, } from "./plugin-capability-facade";
+import { isPluginDependencyResolver, LegacyObjectDependencyResolver, } from "./plugin-dependency-resolver";
+import { ELECTRON_PLUGIN_ASSET_SCHEME, WEB_PLUGIN_ASSET_ROUTE_PREFIX, } from "./plugin-asset-server";
+import { scanBarePluginDependencySpecifiers } from "./plugin-dependency-scanner";
+import pluginHostModuleRegistry from "./generated/plugin-host-modules.schema.generated";
+import { InstalledPluginStateStore } from "./plugin-distribution/installed-plugin-state";
+import { dirname, getAdapterVaultId, joinPath, normalizePath } from "./storage";
+import { debounce } from "lodash-es";
+import { EventDispatcher } from "./events";
+function formatPluginError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function resolvePluginModuleExport(moduleExports) {
+    const exportRecord = isRecord(moduleExports) ? moduleExports : {};
+    for (const [, value] of Object.entries(exportRecord)) {
+        if (value === Plugin) {
+            return value;
+        }
+    }
+    return (moduleExports?.default ||
+        Object.values(exportRecord)[0] ||
+        moduleExports);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingPathError(error) {
+    const err = error;
+    return err?.name === "NotFoundError" || err?.code === "ENOENT";
+}
+function pluginSourceForProvenance(provenance) {
+    return provenance === "official" ? "official" : "community";
+}
+function provenanceForPluginSource(source) {
+    switch (source) {
+        case "core":
+        case "system":
+            return "bundled";
+        case "official":
+            return "official";
+        default:
+            return "community";
+    }
+}
+function isExternalPluginSource(source) {
+    return source === "community" || source === "official";
+}
+function requiresWorkspaceTrust(manifest) {
+    const hostRequiresBrokeredCapabilities = normalizeStringArray(manifest.requiredCapabilities).length > 0;
+    return Boolean(hostRequiresBrokeredCapabilities || manifest.lapis?.runtime?.trustedDesktop);
+}
+function trustFailureMessage(manifest) {
+    if (manifest.lapis?.runtime?.trustedDesktop) {
+        return `Plugin ${manifest.id} requires a trusted workspace before loading trusted desktop runtime code`;
+    }
+    return `Plugin ${manifest.id} requires a trusted workspace before using brokered plugin capabilities`;
+}
+function hasDeclaredLapisRuntimeCode(manifest) {
+    const runtime = manifest.lapis?.runtime;
+    if (!isRecord(runtime)) {
+        return false;
+    }
+    if (typeof runtime.workspace === "string" ||
+        typeof runtime.desktop === "string" ||
+        typeof runtime.trustedDesktop === "string") {
+        return true;
+    }
+    if (!isRecord(runtime.entries)) {
+        return false;
+    }
+    return Object.values(runtime.entries).some((entry) => isRecord(entry) && typeof entry.path === "string");
+}
+export class RendererCommunityPluginExecutionHost {
+    adapter;
+    id = "renderer";
+    resolver;
+    constructor(adapter, dependenciesOrResolver) {
+        this.adapter = adapter;
+        this.resolver = isPluginDependencyResolver(dependenciesOrResolver)
+            ? dependenciesOrResolver
+            : new LegacyObjectDependencyResolver(dependenciesOrResolver);
+    }
+    async evaluate(request) {
+        try {
+            const dependencyContext = {
+                pluginId: request.pluginId,
+                pluginPath: request.pluginPath,
+                manifest: request.manifest,
+                host: request.selectedRuntime?.host ?? "workspace",
+                format: "commonjs",
+            };
+            const moduleSources = await this.readPluginModuleSources(request.pluginPath);
+            await this.resolver.prepare(getBareDependencySpecifiersFromSources(moduleSources), dependencyContext);
+            const moduleCache = new Map();
+            const loadModule = (modulePath) => {
+                const normalizedModulePath = normalizePath(modulePath);
+                const cached = moduleCache.get(normalizedModulePath);
+                if (cached) {
+                    return cached.exports;
+                }
+                const code = moduleSources.get(normalizedModulePath);
+                if (code === undefined) {
+                    throw new Error(`Cannot find local module ${normalizedModulePath} in plugin ${request.pluginId}`);
+                }
+                const exports = {};
+                const module = { exports };
+                moduleCache.set(normalizedModulePath, module);
+                const executeModule = new Function("exports", "module", "require", code);
+                executeModule(exports, module, (dep) => this.requireDependency(normalizedModulePath, dep, moduleSources, loadModule, dependencyContext));
+                return module.exports;
+            };
+            const moduleExports = loadModule(request.modulePath);
+            return resolvePluginModuleExport(moduleExports);
+        }
+        catch (error) {
+            throw new Error(`Error evaluating plugin module for ${request.pluginId}: ${formatPluginError(error)}`);
+        }
+    }
+    requireDependency(importerPath, dep, moduleSources, loadModule, dependencyContext) {
+        if (dep.startsWith("./") || dep.startsWith("../")) {
+            return loadModule(this.resolveLocalModulePath(importerPath, dep, moduleSources));
+        }
+        return this.wrapDependencyForRequire(dep, this.resolver.require(dep, dependencyContext));
+    }
+    wrapDependencyForRequire(dep, dependency) {
+        if (!isRecord(dependency)) {
+            return dependency;
+        }
+        return new Proxy(dependency, {
+            get(target, prop, receiver) {
+                const value = Reflect.get(target, prop, receiver);
+                if (value === undefined) {
+                    console.log(`error: Unable to find: ${prop.toString()} in ${dep}`);
+                }
+                return value;
+            },
+        });
+    }
+    resolveLocalModulePath(importerPath, dep, moduleSources) {
+        const basePath = normalizePath(joinPath(dirname(importerPath), dep));
+        const candidates = [
+            basePath,
+            `${basePath}.js`,
+            `${basePath}.cjs`,
+            `${basePath}.mjs`,
+            joinPath(basePath, "index.js"),
+            joinPath(basePath, "index.cjs"),
+            joinPath(basePath, "index.mjs"),
+        ];
+        return candidates.find((path) => moduleSources.has(path)) ?? basePath;
+    }
+    async readPluginModuleSources(pluginPath) {
+        const sources = new Map();
+        const visit = async (folderPath) => {
+            const listing = await this.adapter.list(folderPath);
+            await Promise.all(listing.files
+                .filter((file) => /\.(?:cjs|mjs|js)$/i.test(file))
+                .map(async (file) => {
+                const filePath = normalizePath(joinPath(folderPath, file));
+                sources.set(filePath, await this.adapter.read(filePath));
+            }));
+            for (const folder of listing.folders) {
+                await visit(joinPath(folderPath, folder));
+            }
+        };
+        await visit(pluginPath);
+        return sources;
+    }
+}
+export class RendererEsmPluginExecutionHost {
+    adapter;
+    pluginAssetServer;
+    diagnostics;
+    id = "renderer";
+    resolver;
+    constructor(adapter, pluginAssetServer, dependenciesOrResolver, diagnostics = {}) {
+        this.adapter = adapter;
+        this.pluginAssetServer = pluginAssetServer;
+        this.diagnostics = diagnostics;
+        this.resolver = isPluginDependencyResolver(dependenciesOrResolver)
+            ? dependenciesOrResolver
+            : new LegacyObjectDependencyResolver(dependenciesOrResolver);
+    }
+    async evaluate(request) {
+        const selectedRuntime = request.selectedRuntime;
+        if (selectedRuntime?.format !== "esm") {
+            throw new Error(`Plugin ${request.pluginId} was routed to the renderer ESM host without an ESM runtime entry`);
+        }
+        const dependencyContext = {
+            pluginId: request.pluginId,
+            pluginPath: request.pluginPath,
+            manifest: request.manifest,
+            host: selectedRuntime.host,
+            format: "esm",
+        };
+        await this.prepareDependencies(request.modulePath, dependencyContext);
+        const moduleUrl = await this.pluginAssetServer.getPluginAssetUrl({
+            pluginId: request.pluginId,
+            pluginPath: request.pluginPath,
+            relativePath: selectedRuntime.path,
+            version: request.manifest.version,
+        });
+        this.diagnostics.onPluginAssetUrl?.(request.pluginId, moduleUrl);
+        try {
+            const moduleExports = await import(/* @vite-ignore */ moduleUrl);
+            return resolvePluginModuleExport(moduleExports);
+        }
+        catch (error) {
+            throw new Error(`Error importing ESM plugin module for ${request.pluginId} from ${moduleUrl}: ${formatPluginError(error)}`);
+        }
+    }
+    registerDependencies(_deps) { }
+    async prepareDependencies(modulePath, dependencyContext) {
+        let source = "";
+        try {
+            source = await this.adapter.read(modulePath);
+        }
+        catch {
+            // Preflight already checks the selected entry path. Preserve import failure
+            // as the actionable error if the file disappears between preflight/import.
+        }
+        await this.resolver.prepare(source ? scanBarePluginDependencySpecifiers(source) : [], dependencyContext);
+    }
+}
+export class HybridCommunityPluginExecutionHost {
+    commonJsHost;
+    esmHost;
+    diagnostics;
+    id;
+    constructor(commonJsHost, esmHost, diagnostics = {}) {
+        this.commonJsHost = commonJsHost;
+        this.esmHost = esmHost;
+        this.diagnostics = diagnostics;
+        this.id = commonJsHost.id;
+    }
+    hostIdForManifest(manifest) {
+        return (this.commonJsHost.hostIdForManifest?.(manifest) ?? this.commonJsHost.id);
+    }
+    registerDependencies(deps) {
+        this.commonJsHost.registerDependencies?.(deps);
+        this.esmHost.registerDependencies?.(deps);
+    }
+    async evaluate(request) {
+        if (request.selectedRuntime?.format !== "esm" ||
+            request.selectedRuntime.host === "electron-sidecar") {
+            return this.commonJsHost.evaluate(request);
+        }
+        try {
+            return await this.esmHost.evaluate(request);
+        }
+        catch (error) {
+            const fallbackPath = request.selectedRuntime.fallbackPath;
+            if (!fallbackPath) {
+                throw error;
+            }
+            this.diagnostics.onFallbackUsed?.(request.pluginId, fallbackPath);
+            return this.commonJsHost.evaluate({
+                ...request,
+                modulePath: normalizePath(joinPath(request.pluginPath, fallbackPath)),
+                selectedRuntime: {
+                    ...request.selectedRuntime,
+                    path: fallbackPath,
+                    format: "commonjs",
+                },
+            });
+        }
+    }
+}
+export class NativeDesktopCommunityPluginExecutionHost {
+    adapter;
+    bridge;
+    id = "electron-plugin-sidecar";
+    prepared = false;
+    contextId;
+    rootPath;
+    dependencies = {};
+    rendererHost;
+    constructor(adapter, bridge = requireNativeDesktopBridge(), createRendererDependencyResolver) {
+        this.adapter = adapter;
+        this.bridge = bridge;
+        const rendererDependenciesOrResolver = createRendererDependencyResolver?.(this.dependencies) ??
+            this.dependencies;
+        this.rendererHost = new RendererCommunityPluginExecutionHost(adapter, rendererDependenciesOrResolver);
+        this.contextId = getAdapterVaultId(adapter);
+        this.rootPath =
+            typeof adapter.rootPath === "string"
+                ? adapter.rootPath
+                : undefined;
+    }
+    async evaluate(request) {
+        if (!this.shouldUseSidecar(request.manifest)) {
+            return this.rendererHost.evaluate(request);
+        }
+        await this.prepare();
+        try {
+            await this.bridge.invoke("desktop_plugin_host_evaluate", {
+                contextId: this.contextId,
+                pluginId: request.pluginId,
+                pluginPath: request.pluginPath,
+                modulePath: request.modulePath,
+                manifest: request.manifest,
+                selectedRuntime: request.selectedRuntime,
+            });
+        }
+        catch (error) {
+            const runtime = request.selectedRuntime;
+            throw new Error(`Plugin ${request.pluginId} failed in ${this.id} while evaluating ${runtime?.format ?? "commonjs"} entry ${runtime?.path ?? request.modulePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+        const host = this;
+        return class NativeDesktopHostedCommunityPlugin extends Plugin {
+            async onload() {
+                await host.activate({
+                    pluginId: this.manifest.id,
+                    manifest: this.manifest,
+                });
+            }
+            async onunload() {
+                await host.deactivate({
+                    pluginId: this.manifest.id,
+                });
+            }
+        };
+    }
+    hostIdForManifest(manifest) {
+        return this.shouldUseSidecar(manifest) ? this.id : "renderer";
+    }
+    registerDependencies(deps) {
+        for (const [key, value] of Object.entries(deps)) {
+            if (isRecord(this.dependencies[key]) && isRecord(value)) {
+                this.dependencies[key] = { ...this.dependencies[key], ...value };
+                continue;
+            }
+            this.dependencies[key] = value;
+        }
+    }
+    shouldUseSidecar(manifest) {
+        if (normalizeStringArray(manifest.requiredCapabilities).length) {
+            return true;
+        }
+        const supportedRuntimes = normalizeStringArray(manifest.supportedRuntimes).map((runtime) => runtime.toLowerCase());
+        if (supportedRuntimes.some((runtime) => [
+            "desktop",
+            "electron",
+            "electron-sidecar",
+            "electron-plugin-sidecar",
+            "plugin-sidecar",
+        ].includes(runtime))) {
+            return true;
+        }
+        return Boolean(manifest.lapis?.runtime?.desktop ||
+            manifest.lapis?.runtime?.trustedDesktop);
+    }
+    async prepare() {
+        if (this.prepared) {
+            return;
+        }
+        await this.bridge.invoke("desktop_plugin_host_prepare", {
+            contextId: this.contextId,
+            rootPath: this.rootPath,
+        });
+        this.prepared = true;
+    }
+    async activate(payload) {
+        await this.prepare();
+        await this.bridge.invoke("desktop_plugin_host_activate", {
+            ...payload,
+            contextId: this.contextId,
+        });
+    }
+    async deactivate(payload) {
+        await this.bridge.invoke("desktop_plugin_host_deactivate", {
+            ...payload,
+            contextId: this.contextId,
+        });
+    }
+}
+function requireNativeDesktopBridge() {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        throw new Error("Native desktop bridge is unavailable");
+    }
+    return bridge;
+}
+export class PluginManager extends EventDispatcher {
+    app;
+    pluginsPath;
+    adapter;
+    plugins = new Map();
+    dependencies = {};
+    #loaded = false;
+    #configuredCommunityPlugins = new Set();
+    #disabledCorePlugins = new Set();
+    #enabledCorePlugins = new Set();
+    #defaultDisabledCorePlugins = new Set();
+    #corePluginStyles = new Map();
+    #corePluginDistribution = new Map();
+    #installedPluginProvenance = new Map();
+    #installedPluginStateStore;
+    #basesViewRegistrations = new Map();
+    #communityPluginDiagnostics = new Map();
+    #communityPluginDependencyDiagnostics = new Map();
+    #communityPluginRuntimeExecutionDiagnostics = new Map();
+    #lapisExtensionIndex = new Map();
+    #manifestContributionDisposers = new Map();
+    #manifestContributionDiagnostics = new Map();
+    #systemExtensionManifests = new Map();
+    #systemExtensionPlugins = new Map();
+    #systemExtensionServiceProviders = new Map();
+    #indexedActivationRegistry = new Map();
+    #deferredIndexedExtensions = new Map();
+    #communityPluginHost;
+    #pluginAssetServer;
+    constructor(app, pluginsPath, adapter, options = {}) {
+        super();
+        this.app = app;
+        this.pluginsPath = pluginsPath;
+        this.adapter = adapter;
+        this.#installedPluginStateStore = new InstalledPluginStateStore(adapter);
+        const dependencyResolver = options.createCommunityPluginDependencyResolver?.(this.dependencies) ??
+            this.dependencies;
+        this.#pluginAssetServer = options.pluginAssetServer;
+        const commonJsHost = options.communityPluginHost ??
+            new RendererCommunityPluginExecutionHost(adapter, dependencyResolver);
+        this.#communityPluginHost = options.pluginAssetServer
+            ? new HybridCommunityPluginExecutionHost(commonJsHost, new RendererEsmPluginExecutionHost(adapter, options.pluginAssetServer, dependencyResolver, {
+                onPluginAssetUrl: (pluginId, url) => this.recordPluginAssetUrlDiagnostics(pluginId, url),
+            }), {
+                onFallbackUsed: (pluginId) => this.recordPluginFallbackDiagnostics(pluginId),
+            })
+            : commonJsHost;
+        this.app.configuration.on("plugin-data-updated", (event) => {
+            if (event.origin === "plugin-save") {
+                return;
+            }
+            void this.syncLegacyPluginData(event.pluginId);
+        });
+    }
+    getPluginFolder() {
+        return this.pluginsPath;
+    }
+    get corePlugins() {
+        return [...this.plugins.values()].filter((plugin) => plugin.source === "core" || plugin.source === "official");
+    }
+    get communityPlugins() {
+        return [...this.plugins.values()].filter((plugin) => plugin.source === "community");
+    }
+    isPluginEnabled(pluginId) {
+        return Boolean(this.plugins.get(pluginId)?.enabled);
+    }
+    get corePluginEntries() {
+        const runtimePlugins = this.corePlugins.map((plugin) => ({
+            manifest: plugin.manifest,
+            enabled: plugin.enabled,
+            required: plugin.required,
+            source: plugin.source,
+            provenance: plugin.provenance,
+            distribution: this.#corePluginDistribution.get(plugin.manifest.id) ??
+                (plugin.source === "official"
+                    ? "first-party-external"
+                    : "bundled"),
+            errorMessage: plugin.errorMessage,
+        }));
+        const runtimeSystemPlugins = [...this.plugins.values()].filter((plugin) => plugin.source === "system");
+        const runtimePluginIds = new Set([...runtimePlugins, ...runtimeSystemPlugins].map((plugin) => plugin.manifest.id));
+        const systemExtensions = [
+            ...runtimeSystemPlugins.map((plugin) => ({
+                manifest: plugin.manifest,
+                enabled: plugin.enabled,
+                required: plugin.required,
+                source: plugin.source,
+                provenance: plugin.provenance,
+                distribution: "bundled",
+                errorMessage: plugin.errorMessage,
+            })),
+            ...this.systemExtensions
+                .filter((extension) => !runtimePluginIds.has(extension.pluginId))
+                .map((extension) => {
+                const diagnostics = this.#communityPluginDiagnostics.get(extension.pluginId);
+                return {
+                    manifest: this.#systemExtensionManifests.get(extension.pluginId) ?? {
+                        id: extension.pluginId,
+                        name: extension.name ?? extension.pluginId,
+                        author: "Lapis Notes",
+                        version: "0.0.0",
+                        minAppVersion: "0.0.0",
+                        description: "",
+                    },
+                    enabled: extension.enabled,
+                    required: extension.locked,
+                    source: "system",
+                    provenance: "bundled",
+                    distribution: "bundled",
+                    errorMessage: diagnostics?.state === "failed"
+                        ? diagnostics.lastFailureMessage
+                        : null,
+                };
+            }),
+        ];
+        return [...runtimePlugins, ...systemExtensions];
+    }
+    get communityPluginHostId() {
+        return this.#communityPluginHost.id;
+    }
+    get pluginAssetServer() {
+        return this.#pluginAssetServer;
+    }
+    get communityPluginDiagnostics() {
+        return [...this.#communityPluginDiagnostics.values()];
+    }
+    get lapisExtensions() {
+        return [...this.#lapisExtensionIndex.values()];
+    }
+    get systemExtensions() {
+        return this.lapisExtensions.filter((extension) => extension.source === "system");
+    }
+    getLapisExtension(pluginId) {
+        return this.#lapisExtensionIndex.get(pluginId) ?? null;
+    }
+    getLapisContributionDiagnostics(pluginId) {
+        return [...(this.#manifestContributionDiagnostics.get(pluginId) ?? [])];
+    }
+    getCommunityPluginDiagnostics(pluginId) {
+        return this.#communityPluginDiagnostics.get(pluginId) ?? null;
+    }
+    registerDependencies(deps) {
+        for (const [key, value] of Object.entries(deps)) {
+            if (isRecord(this.dependencies[key]) && isRecord(value)) {
+                this.dependencies[key] = { ...this.dependencies[key], ...value };
+                continue;
+            }
+            this.dependencies[key] = value;
+        }
+        this.#communityPluginHost.registerDependencies?.(deps);
+    }
+    async migratePluginDataAliases(migrations) {
+        const migrated = [];
+        for (const migration of migrations) {
+            if (!this.app.configuration.hasPluginData(migration.fromPluginId) ||
+                this.app.configuration.hasPluginData(migration.toPluginId)) {
+                continue;
+            }
+            await this.app.configuration.updatePluginData(migration.toPluginId, this.app.configuration.getPluginData(migration.fromPluginId), { origin: "configuration-update" });
+            if (migration.removeSource) {
+                await this.app.configuration.removePluginData(migration.fromPluginId, {
+                    origin: "configuration-update",
+                });
+            }
+            migrated.push(`${migration.fromPluginId}:${migration.toPluginId}`);
+        }
+        return migrated;
+    }
+    registerStaticPlugins(profile) {
+        for (const registration of profile) {
+            const { plugin: PluginType, required = false, enabledByDefault = true, distribution = "bundled", styles, } = typeof registration === "function"
+                ? {
+                    plugin: registration,
+                    required: false,
+                    enabledByDefault: true,
+                    distribution: "bundled",
+                    styles: undefined,
+                }
+                : registration;
+            try {
+                const plugin = new PluginType(this.app);
+                const pluginPath = normalizePath(joinPath(this.pluginsPath, plugin.manifest.id));
+                plugin.manifest.dir ??= pluginPath;
+                if (!required && !enabledByDefault) {
+                    this.#defaultDisabledCorePlugins.add(plugin.manifest.id);
+                }
+                const registeredPlugin = this.registerPlugin(plugin, {
+                    source: "core",
+                    provenance: distribution === "first-party-external"
+                        ? "official"
+                        : "bundled",
+                    required,
+                    basePath: pluginPath,
+                });
+                this.#corePluginDistribution.set(registeredPlugin.manifest.id, distribution);
+                this.registerCorePluginManifestContributions(registeredPlugin, pluginPath, { required, enabledByDefault });
+                if (styles !== undefined) {
+                    this.#corePluginStyles.set(registeredPlugin.manifest.id, styles);
+                }
+            }
+            catch (error) {
+                this.reportPluginError("core", `Failed to register core plugin: ${formatPluginError(error)}`, error);
+            }
+        }
+    }
+    /** @deprecated Use {@link registerStaticPlugins}. */
+    registerCorePlugins(profile) {
+        this.registerStaticPlugins(profile);
+    }
+    registerCorePluginManifestContributions(plugin, pluginPath, options) {
+        if (plugin.manifest.lapis === undefined) {
+            return;
+        }
+        const diagnostics = validateLapisManifest(plugin.manifest.id, plugin.manifest.lapis);
+        if (diagnostics.length) {
+            throw new Error(diagnostics.join("; "));
+        }
+        if (!isLapisManifest(plugin.manifest.lapis)) {
+            throw new Error(`Plugin ${plugin.manifest.id} has invalid lapis metadata`);
+        }
+        const indexedExtension = buildLapisContributionIndex({
+            pluginId: plugin.manifest.id,
+            name: plugin.manifest.name,
+            source: "system",
+            manifestPath: joinPath(pluginPath, "manifest.json"),
+            classification: classifyLapisPlugin(plugin.manifest, { hasMainJs: true }),
+            lapis: {
+                ...plugin.manifest.lapis,
+                source: "system",
+                locked: plugin.manifest.lapis.locked ?? options.required,
+                enabledByDefault: plugin.manifest.lapis.enabledByDefault ?? options.enabledByDefault,
+            },
+            requestedCapabilities: this.getRequestedCapabilities(plugin.manifest),
+            grantedCapabilities: this.getGrantedCapabilities(plugin.manifest),
+        });
+        this.#lapisExtensionIndex.set(plugin.manifest.id, indexedExtension);
+        this.#manifestContributionDiagnostics.set(plugin.manifest.id, indexedExtension.contributions.flatMap((entry) => entry.diagnostics));
+        this.syncIndexedExtensionActivation(indexedExtension);
+        this.recordCommunityPluginDiagnostics(plugin.manifest, "disabled");
+        const configurationDisposers = [];
+        for (const entry of indexedExtension.contributions) {
+            if (entry.kind !== "configuration" || entry.state === "invalid") {
+                continue;
+            }
+            configurationDisposers.push({
+                kind: entry.kind,
+                id: entry.id,
+                dispose: this.installManifestConfiguration(entry),
+            });
+        }
+        if (configurationDisposers.length > 0) {
+            this.#manifestContributionDisposers.set(plugin.manifest.id, configurationDisposers);
+        }
+    }
+    registerSystemExtensions(registrations) {
+        for (const registration of registrations) {
+            const manifest = this.createSystemExtensionManifest(registration);
+            if (this.plugins.has(manifest.id) ||
+                this.#lapisExtensionIndex.has(manifest.id)) {
+                throw new Error(`Plugin id ${manifest.id} is already registered`);
+            }
+            const diagnostics = validateLapisManifest(manifest.id, manifest.lapis);
+            if (diagnostics.length) {
+                throw new Error(diagnostics.join("; "));
+            }
+            if (!isLapisManifest(manifest.lapis)) {
+                throw new Error(`Plugin ${manifest.id} has invalid lapis metadata`);
+            }
+            const requestedCapabilities = permissionsToCapabilities(manifest.lapis.permissions);
+            const indexedExtension = buildLapisContributionIndex({
+                pluginId: manifest.id,
+                name: manifest.name,
+                source: "system",
+                manifestPath: this.getSystemExtensionManifestPath(registration.basePath, manifest.id),
+                classification: classifyLapisPlugin(manifest, { hasMainJs: false }),
+                lapis: manifest.lapis,
+                requestedCapabilities,
+                grantedCapabilities: [...requestedCapabilities],
+                privileges: registration.privileges,
+            });
+            this.#manifestContributionDiagnostics.set(manifest.id, indexedExtension.contributions.flatMap((entry) => entry.diagnostics));
+            if (!indexedExtension.locked && !indexedExtension.enabledByDefault) {
+                this.#defaultDisabledCorePlugins.add(manifest.id);
+            }
+            this.#lapisExtensionIndex.set(manifest.id, indexedExtension);
+            this.#systemExtensionManifests.set(manifest.id, manifest);
+            if (registration.plugin) {
+                this.#systemExtensionPlugins.set(manifest.id, registration.plugin);
+            }
+            this.storeSystemExtensionServiceProviders(manifest.id, registration.serviceProviders ?? []);
+            this.syncIndexedExtensionActivation(indexedExtension);
+            this.recordIndexedExtensionDiagnostics(manifest.id, "disabled");
+        }
+    }
+    async loadPlugins(options = {}) {
+        return this.app.telemetry.measureAsync("plugins.load_all", async (span) => {
+            span.setAttribute("plugins.path", this.pluginsPath);
+            await this.app.workspaceTrust.ready();
+            this.#loaded = false;
+            const communityPluginsEnabled = options.communityPlugins !== "disabled";
+            const optionalCorePluginsEnabled = options.optionalCorePlugins !== "disabled";
+            span.setAttribute("plugins.community_plugins_enabled", communityPluginsEnabled);
+            span.setAttribute("plugins.optional_core_plugins_enabled", optionalCorePluginsEnabled);
+            try {
+                await this.app.vault.mkpath(this.pluginsPath);
+            }
+            catch (error) {
+                this.reportPluginError(this.pluginsPath, `Failed to initialize plugin folder ${this.pluginsPath}: ${formatPluginError(error)}`, error);
+            }
+            await this.refreshInstalledPluginProvenance();
+            try {
+                const pluginFolders = await this.adapter.list(this.pluginsPath);
+                span.setAttribute("plugins.discovered_folder_count", pluginFolders.folders.length);
+                for (const folder of pluginFolders.folders) {
+                    const registeredPlugin = this.plugins.get(folder);
+                    if (registeredPlugin) {
+                        continue;
+                    }
+                    await this.loadPlugin(joinPath(this.pluginsPath, folder));
+                }
+            }
+            catch (error) {
+                this.reportPluginError(this.pluginsPath, `Failed to discover plugins in ${this.pluginsPath}: ${formatPluginError(error)}`, error);
+            }
+            const corePluginState = await this.readCorePluginStateConfig();
+            this.#disabledCorePlugins = new Set(corePluginState.disabled);
+            this.#enabledCorePlugins = new Set(corePluginState.enabled);
+            this.#configuredCommunityPlugins = new Set(await this.readPluginListConfig("community-plugins.json", {
+                createIfMissing: true,
+            }));
+            const prunedCommunityPlugins = await this.pruneMissingConfiguredCommunityPlugins();
+            span.setAttribute("plugins.pruned_community_config_count", prunedCommunityPlugins.length);
+            const activationOrder = [
+                ...new Set([
+                    ...this.corePlugins
+                        .filter((plugin) => plugin.source === "core" &&
+                        (plugin.required ||
+                            (optionalCorePluginsEnabled &&
+                                this.isCorePluginEnabled(plugin.manifest.id))))
+                        .map((plugin) => plugin.manifest.id),
+                    ...[...this.#configuredCommunityPlugins].filter((pluginId) => {
+                        const plugin = this.plugins.get(pluginId);
+                        if (!plugin) {
+                            return false;
+                        }
+                        if (plugin.source === "official") {
+                            return optionalCorePluginsEnabled;
+                        }
+                        return plugin.source === "community" && communityPluginsEnabled;
+                    }),
+                ]),
+            ];
+            span.setAttribute("plugins.activation_count", activationOrder.length);
+            for (const [index, pluginId] of activationOrder.entries()) {
+                const plugin = this.plugins.get(pluginId);
+                options.onProgress?.({
+                    id: pluginId,
+                    name: plugin?.manifest.name ?? pluginId,
+                    index,
+                    total: activationOrder.length,
+                });
+                await this.enablePlugin(pluginId);
+            }
+            await this.enableConfiguredIndexedExtensions({
+                communityPluginsEnabled,
+                optionalCorePluginsEnabled,
+            });
+            await this.activateIndexedExtensionsForWorkspace();
+            this.#loaded = true;
+            this.emit("plugins-loaded");
+            await this.activateByEvent("onStartupFinished");
+        }, {
+            attributes: { "plugins.path": this.pluginsPath },
+            slowThresholdMs: 500,
+        });
+    }
+    get enabledPlugins() {
+        return [...this.#configuredCommunityPlugins];
+    }
+    getBasesViewRegistrations() {
+        return new Map([...this.#basesViewRegistrations.entries()].map(([viewId, entry]) => [viewId, entry.registration]));
+    }
+    registerBasesView(pluginId, viewId, registration) {
+        const existing = this.#basesViewRegistrations.get(viewId);
+        if (existing && existing.pluginId !== pluginId) {
+            throw new Error(`Bases view ${viewId} is already registered`);
+        }
+        this.#basesViewRegistrations.set(viewId, { pluginId, registration });
+        return true;
+    }
+    unregisterBasesView(pluginId, viewId) {
+        const existing = this.#basesViewRegistrations.get(viewId);
+        if (!existing) {
+            return false;
+        }
+        if (existing.pluginId !== pluginId) {
+            throw new Error(`Bases view ${viewId} is owned by plugin ${existing.pluginId}`);
+        }
+        this.#basesViewRegistrations.delete(viewId);
+        return true;
+    }
+    registerLapisServiceProvider(registration) {
+        if (!isLanguageServiceId(registration.service)) {
+            throw new Error(`Unsupported Lapis service provider: ${registration.service}`);
+        }
+        const declaration = this.getLapisServiceContribution(registration.pluginId, registration.id, registration.service);
+        const metadata = this.createLanguageServiceProviderMetadata(registration, declaration);
+        const provider = {
+            ...registration.provider,
+            metadata,
+        };
+        const disposeProvider = this.app.languageServices.registerProvider(provider);
+        return () => {
+            disposeProvider();
+            void registration.dispose?.();
+        };
+    }
+    getLapisServiceContribution(pluginId, providerId, service) {
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        const contribution = indexedExtension?.contributions.find((entry) => entry.kind === "services" &&
+            entry.id === providerId &&
+            isLanguageServiceId(entry.contribution.service) &&
+            isLanguageServiceId(service));
+        return contribution?.contribution ?? null;
+    }
+    createLanguageServiceProviderMetadata(registration, declaration) {
+        const explicitMetadata = isRecord(registration.metadata)
+            ? registration.metadata
+            : {};
+        const providerId = scopeLapisProviderId(registration.pluginId, explicitMetadata.id ?? registration.id);
+        const capabilities = normalizeLanguageServiceCapabilities(explicitMetadata.capabilities ?? declaration?.capabilities);
+        const languages = normalizeStringArray(explicitMetadata.languages ?? declaration?.languages);
+        if (!languages.length) {
+            throw new Error(`Lapis language-service provider ${registration.id} must declare languages`);
+        }
+        return {
+            ...explicitMetadata,
+            id: providerId,
+            languages,
+            runtime: explicitMetadata.runtime ??
+                languageServiceRuntimeFromDeclaration(declaration?.runtime),
+            priority: explicitMetadata.priority ?? declaration?.priority,
+            capabilities,
+        };
+    }
+    getEnabledInternalPluginById(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (!plugin?.enabled) {
+            const systemExtension = this.#lapisExtensionIndex.get(pluginId);
+            if (systemExtension?.source === "system" && systemExtension.enabled) {
+                return {
+                    manifest: this.#systemExtensionManifests.get(pluginId) ?? {
+                        id: pluginId,
+                        name: systemExtension.name ?? pluginId,
+                        author: "Lapis Notes",
+                        version: "0.0.0",
+                        minAppVersion: "0.0.0",
+                        description: "",
+                    },
+                };
+            }
+            return null;
+        }
+        if (pluginId === "bases") {
+            return {
+                manifest: plugin.manifest,
+                registrations: Object.fromEntries(this.getBasesViewRegistrations()),
+            };
+        }
+        return { manifest: plugin.manifest };
+    }
+    get internalPlugins() {
+        const plugins = Object.fromEntries(this.corePluginEntries.map((plugin) => [plugin.manifest.id, plugin]));
+        return {
+            plugins,
+            getEnabledPluginById: (pluginId) => this.getEnabledInternalPluginById(pluginId),
+        };
+    }
+    getPluginStatePath(filename) {
+        return normalizePath(joinPath(`${this.pluginsPath}/../`, filename));
+    }
+    async refreshInstalledPluginProvenance() {
+        try {
+            const installed = await this.#installedPluginStateStore.list();
+            this.#installedPluginProvenance = new Map(installed.map((record) => [record.pluginId, record.provenance]));
+        }
+        catch (error) {
+            this.#installedPluginProvenance = new Map();
+            this.reportPluginError("installed-plugins", `Failed to load installed plugin provenance: ${formatPluginError(error)}`, error);
+        }
+    }
+    resolveExternalPluginSource(pluginId, provenanceOverride) {
+        const provenance = provenanceOverride ??
+            this.#installedPluginProvenance.get(pluginId) ??
+            "community";
+        return {
+            source: pluginSourceForProvenance(provenance),
+            provenance,
+        };
+    }
+    async readPluginListConfig(filename, options = {}) {
+        const configPath = this.getPluginStatePath(filename);
+        try {
+            const exists = await this.adapter.exists(configPath);
+            if (!exists) {
+                if (options.createIfMissing) {
+                    await this.adapter.write(configPath, "[]");
+                }
+                return [];
+            }
+            const data = await this.adapter.read(configPath);
+            const plugins = JSON.parse(data);
+            if (Array.isArray(plugins)) {
+                return plugins.map((it) => it.toString());
+            }
+        }
+        catch (error) {
+            this.reportPluginError(configPath, `Failed to load plugin config ${configPath}: ${formatPluginError(error)}`, error);
+        }
+        return [];
+    }
+    async readCorePluginStateConfig() {
+        const configPath = this.getPluginStatePath("core-plugins.json");
+        try {
+            const exists = await this.adapter.exists(configPath);
+            if (!exists) {
+                return { disabled: [], enabled: [] };
+            }
+            const data = await this.adapter.read(configPath);
+            const config = JSON.parse(data);
+            if (Array.isArray(config)) {
+                return {
+                    disabled: config.map((it) => it.toString()),
+                    enabled: [],
+                };
+            }
+            if (isRecord(config)) {
+                return {
+                    disabled: Array.isArray(config.disabled)
+                        ? config.disabled.map((it) => it.toString())
+                        : [],
+                    enabled: Array.isArray(config.enabled)
+                        ? config.enabled.map((it) => it.toString())
+                        : [],
+                };
+            }
+        }
+        catch (error) {
+            this.reportPluginError(configPath, `Failed to load plugin config ${configPath}: ${formatPluginError(error)}`, error);
+        }
+        return { disabled: [], enabled: [] };
+    }
+    async savePluginListConfig(filename, pluginIds) {
+        const configPath = this.getPluginStatePath(filename);
+        try {
+            const file = this.app.vault.getFileByPath(configPath);
+            const payload = JSON.stringify([...pluginIds], null, 2);
+            if (file) {
+                await this.app.vault.modify(file, payload);
+                return;
+            }
+            await this.app.vault.create(configPath, payload);
+        }
+        catch (error) {
+            this.reportPluginError(configPath, `Failed to save plugin config ${configPath}: ${formatPluginError(error)}`, error);
+        }
+    }
+    async saveCorePluginStateConfig() {
+        const configPath = this.getPluginStatePath("core-plugins.json");
+        try {
+            const file = this.app.vault.getFileByPath(configPath);
+            const payload = this.#enabledCorePlugins.size === 0
+                ? JSON.stringify([...this.#disabledCorePlugins], null, 2)
+                : JSON.stringify({
+                    disabled: [...this.#disabledCorePlugins],
+                    enabled: [...this.#enabledCorePlugins],
+                }, null, 2);
+            if (file) {
+                await this.app.vault.modify(file, payload);
+                return;
+            }
+            await this.app.vault.create(configPath, payload);
+        }
+        catch (error) {
+            this.reportPluginError(configPath, `Failed to save plugin config ${configPath}: ${formatPluginError(error)}`, error);
+        }
+    }
+    saveCommunityPluginState = debounce(() => {
+        return void this.savePluginListConfig("community-plugins.json", this.#configuredCommunityPlugins);
+    }, 500);
+    saveCorePluginState = debounce(() => {
+        return void this.saveCorePluginStateConfig();
+    }, 500);
+    flushPendingConfigWrites() {
+        this.saveCommunityPluginState.flush();
+        this.saveCorePluginState.flush();
+    }
+    isCorePluginEnabled(pluginId) {
+        if (this.#disabledCorePlugins.has(pluginId)) {
+            return false;
+        }
+        if (this.#enabledCorePlugins.has(pluginId)) {
+            return true;
+        }
+        return !this.#defaultDisabledCorePlugins.has(pluginId);
+    }
+    async pruneMissingConfiguredCommunityPlugins() {
+        const missingPluginIds = [];
+        for (const pluginId of this.#configuredCommunityPlugins) {
+            const manifestPath = joinPath(this.pluginsPath, pluginId, "manifest.json");
+            let exists = false;
+            try {
+                exists = await this.adapter.exists(manifestPath);
+            }
+            catch (error) {
+                if (!isMissingPathError(error)) {
+                    throw error;
+                }
+            }
+            if (!exists) {
+                missingPluginIds.push(pluginId);
+            }
+        }
+        if (!missingPluginIds.length) {
+            return [];
+        }
+        for (const pluginId of missingPluginIds) {
+            this.#configuredCommunityPlugins.delete(pluginId);
+        }
+        await this.savePluginListConfig("community-plugins.json", this.#configuredCommunityPlugins);
+        this.emit("community-plugin-config-pruned", missingPluginIds);
+        return missingPluginIds;
+    }
+    async enableConfiguredIndexedExtensions(options) {
+        for (const indexedExtension of this.#lapisExtensionIndex.values()) {
+            if (this.plugins.has(indexedExtension.pluginId)) {
+                continue;
+            }
+            if (indexedExtension.source === "community") {
+                if (!options.communityPluginsEnabled ||
+                    !this.#configuredCommunityPlugins.has(indexedExtension.pluginId)) {
+                    continue;
+                }
+            }
+            else if (indexedExtension.source === "official") {
+                if (!options.optionalCorePluginsEnabled ||
+                    !this.#configuredCommunityPlugins.has(indexedExtension.pluginId)) {
+                    continue;
+                }
+            }
+            else if (!indexedExtension.locked &&
+                !this.isCorePluginEnabled(indexedExtension.pluginId)) {
+                continue;
+            }
+            if (this.shouldDeferIndexedExtensionActivation(indexedExtension)) {
+                this.enableDeferredIndexedExtension(indexedExtension.pluginId);
+                continue;
+            }
+            if (indexedExtension.source === "system" &&
+                this.#systemExtensionPlugins.has(indexedExtension.pluginId)) {
+                const plugin = this.instantiateSystemExtensionPlugin(indexedExtension.pluginId);
+                if (plugin) {
+                    await this.enablePlugin(plugin.manifest.id);
+                }
+                continue;
+            }
+            if (this.hasIndexedExtensionCodeEntry(indexedExtension)) {
+                continue;
+            }
+            this.enableManifestOnlyExtension(indexedExtension.pluginId);
+        }
+    }
+    async loadPlugin(pluginPath, options = {}) {
+        return this.app.telemetry.measureAsync("plugin.load", async (span) => {
+            span.setAttribute("plugin.path", pluginPath.split("/").at(-1) ?? pluginPath);
+            let manifest = null;
+            let pluginId = pluginPath.split("/").at(-1) ?? pluginPath;
+            try {
+                const manifestPath = joinPath(pluginPath, "manifest.json");
+                if (!(await this.adapter.exists(manifestPath))) {
+                    return null;
+                }
+                const manifestContent = await this.adapter.read(manifestPath);
+                manifest = JSON.parse(manifestContent);
+                pluginId = manifest.id || pluginId;
+                span.setAttribute("plugin.id", manifest.id);
+                manifest.dir ??= pluginPath;
+                const runtimeSource = options.source !== undefined
+                    ? {
+                        source: options.source,
+                        provenance: options.provenance ??
+                            provenanceForPluginSource(options.source),
+                    }
+                    : this.resolveExternalPluginSource(manifest.id, options.provenance);
+                span.setAttribute("plugin.source", runtimeSource.source);
+                span.setAttribute("plugin.provenance", runtimeSource.provenance);
+                const mainModulePath = joinPath(pluginPath, "main.js");
+                const hasMainJs = await this.pathExists(mainModulePath);
+                const classification = this.indexCommunityManifest(manifest, manifestPath, hasMainJs, runtimeSource.source, runtimeSource.provenance);
+                span.setAttribute("plugin.host", this.getHostIdForManifest(manifest));
+                span.setAttribute("plugin.classification", classification);
+                await this.preflightManifest(manifest, pluginPath, runtimeSource.source, {
+                    classification,
+                    hasMainJs,
+                });
+                if (this.isManifestOnlyLapisExtension(manifest, classification, hasMainJs)) {
+                    this.recordCommunityPluginDiagnostics(manifest, "indexed");
+                    return null;
+                }
+                if (!options.loadDeferredRuntime &&
+                    this.shouldDeferManifestActivation(manifest.id)) {
+                    this.recordCommunityPluginDiagnostics(manifest, "dormant");
+                    return null;
+                }
+                const modulePath = this.getSelectedCommunityModulePath(manifest, pluginPath, classification, hasMainJs);
+                if (!modulePath) {
+                    throw new Error(`Plugin ${manifest.id} does not have a code entry`);
+                }
+                await this.updateCommunityPluginDependencyDiagnostics(manifest, pluginPath, classification, hasMainJs);
+                const PluginClass = await this.#communityPluginHost.evaluate({
+                    pluginId: manifest.id,
+                    pluginPath,
+                    modulePath,
+                    manifest,
+                    selectedRuntime: this.selectRuntimeEntryForManifest(manifest, {
+                        classification,
+                        hasMainJs,
+                    }),
+                });
+                if (!PluginClass || typeof PluginClass !== "function") {
+                    throw new Error(`Plugin ${manifest.id} does not export a valid plugin class`);
+                }
+                const PluginType = PluginClass;
+                const plugin = new PluginType(this.app, manifest);
+                if (!(plugin instanceof Plugin)) {
+                    throw new Error(`Plugin ${manifest.id} does not extend the Plugin base class`);
+                }
+                return this.registerPlugin(plugin, {
+                    source: runtimeSource.source,
+                    provenance: runtimeSource.provenance,
+                    basePath: pluginPath,
+                });
+            }
+            catch (error) {
+                const message = `Failed to load plugin from ${pluginPath}: ${formatPluginError(error)}`;
+                this.recordCommunityPluginFailure(pluginId, manifest, message);
+                this.reportPluginError(pluginPath, message, error);
+                return null;
+            }
+        }, { slowThresholdMs: 200 });
+    }
+    registerPlugin(plugin, options) {
+        if (!plugin.manifest.id?.trim()) {
+            throw new Error("Plugin manifest is missing an id");
+        }
+        if (this.plugins.has(plugin.manifest.id)) {
+            throw new Error(`Plugin id ${plugin.manifest.id} is already registered`);
+        }
+        plugin.configureRuntime({
+            source: options.source,
+            provenance: options.provenance,
+            basePath: options.basePath,
+            required: options.required,
+            hostMode: isExternalPluginSource(options.source)
+                ? this.getHostIdForManifest(plugin.manifest)
+                : options.source === "system"
+                    ? this.getHostIdForIndexedExtension(this.#lapisExtensionIndex.get(plugin.manifest.id) ?? {
+                        pluginId: plugin.manifest.id,
+                        source: "system",
+                        classification: "lapis-extension",
+                        manifestPath: plugin.manifest.dir ?? "",
+                        activationEvents: [],
+                        runtime: plugin.manifest.lapis?.runtime,
+                        permissions: [],
+                        requestedCapabilities: [],
+                        grantedCapabilities: [],
+                        enabled: false,
+                        locked: plugin.required,
+                        enabledByDefault: true,
+                        activationErrors: [],
+                        privileges: [],
+                        contributions: [],
+                    })
+                    : "renderer",
+            requestedCapabilities: isExternalPluginSource(options.source)
+                ? this.getRequestedCapabilities(plugin.manifest)
+                : options.source === "system"
+                    ? (this.#lapisExtensionIndex.get(plugin.manifest.id)
+                        ?.requestedCapabilities ?? [])
+                    : [],
+            grantedCapabilities: isExternalPluginSource(options.source)
+                ? this.getGrantedCapabilities(plugin.manifest)
+                : options.source === "system"
+                    ? (this.#lapisExtensionIndex.get(plugin.manifest.id)
+                        ?.grantedCapabilities ?? [])
+                    : [],
+        });
+        this.plugins.set(plugin.manifest.id, plugin);
+        if (isExternalPluginSource(options.source) ||
+            this.#lapisExtensionIndex.get(plugin.manifest.id)?.source === "system") {
+            this.updatePluginDiagnosticsFromPlugin(plugin);
+        }
+        this.emit("plugin-loaded", plugin);
+        void this.syncLegacyPluginData(plugin.manifest.id);
+        return plugin;
+    }
+    async syncLegacyPluginData(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (!plugin) {
+            return;
+        }
+        const path = resolvePluginDataPath(plugin.manifest.id, plugin.source, plugin.basePath);
+        if (!path) {
+            return;
+        }
+        try {
+            if (!this.app.configuration.hasPluginData(pluginId)) {
+                const file = this.app.vault.getFileByPath(path);
+                if (file) {
+                    await this.app.vault.delete(file, true);
+                }
+                return;
+            }
+            const payload = JSON.stringify(this.app.configuration.getPluginData(pluginId), null, 2);
+            const file = this.app.vault.getFileByPath(path);
+            if (file) {
+                await this.app.vault.modify(file, payload);
+                return;
+            }
+            await this.app.vault.mkpath(dirname(path));
+            await this.app.vault.create(path, payload);
+        }
+        catch (error) {
+            this.reportPluginError(pluginId, `Failed to sync legacy plugin data for ${pluginId}: ${formatPluginError(error)}`, error);
+        }
+    }
+    async enablePlugin(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (!plugin) {
+            const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+            if (indexedExtension) {
+                if (this.shouldDeferIndexedExtensionActivation(indexedExtension)) {
+                    const enabled = this.enableDeferredIndexedExtension(pluginId);
+                    if (enabled && this.#loaded) {
+                        if (indexedExtension.source === "community" ||
+                            indexedExtension.source === "official") {
+                            this.#configuredCommunityPlugins.add(pluginId);
+                            this.saveCommunityPluginState();
+                        }
+                        else if (!indexedExtension.locked) {
+                            this.#disabledCorePlugins.delete(pluginId);
+                            if (this.#defaultDisabledCorePlugins.has(pluginId)) {
+                                this.#enabledCorePlugins.add(pluginId);
+                            }
+                            else {
+                                this.#enabledCorePlugins.delete(pluginId);
+                            }
+                            this.saveCorePluginState();
+                        }
+                    }
+                    return enabled;
+                }
+                if (indexedExtension.source === "system" &&
+                    this.#systemExtensionPlugins.has(pluginId)) {
+                    const runtimePlugin = this.instantiateSystemExtensionPlugin(pluginId);
+                    if (runtimePlugin) {
+                        return this.enablePlugin(pluginId);
+                    }
+                }
+                if ((indexedExtension.source === "community" ||
+                    indexedExtension.source === "official") &&
+                    this.hasIndexedExtensionCodeEntry(indexedExtension)) {
+                    const loadedPlugin = await this.loadPlugin(dirname(indexedExtension.manifestPath));
+                    if (loadedPlugin) {
+                        return this.enablePlugin(pluginId);
+                    }
+                    return false;
+                }
+                const enabled = this.enableManifestOnlyExtension(pluginId);
+                if (enabled && this.#loaded) {
+                    if (indexedExtension.source === "community" ||
+                        indexedExtension.source === "official") {
+                        this.#configuredCommunityPlugins.add(pluginId);
+                        this.saveCommunityPluginState();
+                    }
+                    else if (!indexedExtension.locked) {
+                        this.#disabledCorePlugins.delete(pluginId);
+                        if (this.#defaultDisabledCorePlugins.has(pluginId)) {
+                            this.#enabledCorePlugins.add(pluginId);
+                        }
+                        else {
+                            this.#enabledCorePlugins.delete(pluginId);
+                        }
+                        this.saveCorePluginState();
+                    }
+                }
+                return enabled;
+            }
+            const communityPluginPath = joinPath(this.pluginsPath, pluginId);
+            const communityManifestPath = joinPath(communityPluginPath, "manifest.json");
+            if (await this.pathExists(communityManifestPath)) {
+                const loadedPlugin = await this.loadPlugin(communityPluginPath);
+                if (loadedPlugin) {
+                    return this.enablePlugin(pluginId);
+                }
+                return false;
+            }
+            this.reportPluginError(pluginId, `Unknown plugin: ${pluginId}`);
+            return false;
+        }
+        return this.app.telemetry.measureAsync("plugin.enable", async (span) => {
+            span.setAttribute("plugin.id", pluginId);
+            span.setAttribute("plugin.source", plugin.source);
+            span.setAttribute("plugin.required", plugin.required);
+            try {
+                await plugin.enable();
+                await this.restorePluginOwnedLeaves(plugin);
+                const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+                if (indexedExtension?.classification === "hybrid" &&
+                    !this.#manifestContributionDisposers.has(pluginId)) {
+                    this.enableManifestOnlyExtension(pluginId);
+                }
+                await this.loadPluginStyles(plugin);
+                this.updatePluginDiagnosticsFromPlugin(plugin);
+                this.emit("plugin-enabled", plugin);
+                if (this.#loaded) {
+                    if (plugin.source === "community" || plugin.source === "official") {
+                        this.#configuredCommunityPlugins.add(pluginId);
+                        this.saveCommunityPluginState();
+                    }
+                    else if ((plugin.source === "core" || plugin.source === "system") &&
+                        !plugin.required) {
+                        this.#disabledCorePlugins.delete(pluginId);
+                        if (this.#defaultDisabledCorePlugins.has(pluginId)) {
+                            this.#enabledCorePlugins.add(pluginId);
+                        }
+                        else {
+                            this.#enabledCorePlugins.delete(pluginId);
+                        }
+                        this.saveCorePluginState();
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                this.updatePluginDiagnosticsFromPlugin(plugin);
+                this.reportPluginError(pluginId, `Failed to enable plugin ${pluginId}: ${formatPluginError(error)}`, error);
+                return false;
+            }
+        }, {
+            attributes: {
+                "plugin.id": pluginId,
+                "plugin.source": plugin.source,
+            },
+            slowThresholdMs: 300,
+        });
+    }
+    async disablePlugin(pluginId) {
+        const plugin = this.plugins.get(pluginId);
+        if (!plugin) {
+            const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+            if (indexedExtension) {
+                if (indexedExtension.source === "system" && indexedExtension.locked) {
+                    this.reportPluginError(pluginId, `Plugin ${pluginId} is required and cannot be disabled`);
+                    return false;
+                }
+                this.disableManifestOnlyExtension(pluginId);
+                if (this.#loaded) {
+                    if (indexedExtension.source === "community" ||
+                        indexedExtension.source === "official") {
+                        this.#configuredCommunityPlugins.delete(pluginId);
+                        this.saveCommunityPluginState();
+                    }
+                    else {
+                        this.#enabledCorePlugins.delete(pluginId);
+                        if (this.#defaultDisabledCorePlugins.has(pluginId)) {
+                            this.#disabledCorePlugins.delete(pluginId);
+                        }
+                        else {
+                            this.#disabledCorePlugins.add(pluginId);
+                        }
+                        this.saveCorePluginState();
+                    }
+                }
+                return true;
+            }
+            if (this.#configuredCommunityPlugins.delete(pluginId)) {
+                this.disableManifestOnlyExtension(pluginId);
+                this.saveCommunityPluginState();
+                const diagnostics = this.#communityPluginDiagnostics.get(pluginId);
+                if (diagnostics) {
+                    this.#communityPluginDiagnostics.set(pluginId, {
+                        ...diagnostics,
+                        state: "disabled",
+                    });
+                }
+                return true;
+            }
+            this.reportPluginError(pluginId, `Unknown plugin: ${pluginId}`);
+            return false;
+        }
+        if (plugin.required) {
+            this.reportPluginError(pluginId, `Plugin ${pluginId} is required and cannot be disabled`);
+            return false;
+        }
+        return this.app.telemetry.measureAsync("plugin.disable", async (span) => {
+            span.setAttribute("plugin.id", pluginId);
+            span.setAttribute("plugin.source", plugin.source);
+            try {
+                const ownedLeaves = this.capturePluginOwnedLeaves(plugin);
+                await plugin.disable();
+                await this.replacePluginOwnedLeaves(ownedLeaves);
+                if (this.#manifestContributionDisposers.has(pluginId)) {
+                    this.disposeInstalledManifestContributions(pluginId);
+                }
+                this.unloadPluginCSS(pluginId);
+                this.updatePluginDiagnosticsFromPlugin(plugin);
+                this.emit("plugin-disabled", plugin);
+                if (this.#loaded) {
+                    if (plugin.source === "community" || plugin.source === "official") {
+                        this.#configuredCommunityPlugins.delete(pluginId);
+                        this.saveCommunityPluginState();
+                    }
+                    else if (plugin.source === "core" || plugin.source === "system") {
+                        this.#enabledCorePlugins.delete(pluginId);
+                        if (this.#defaultDisabledCorePlugins.has(pluginId)) {
+                            this.#disabledCorePlugins.delete(pluginId);
+                        }
+                        else {
+                            this.#disabledCorePlugins.add(pluginId);
+                        }
+                        this.saveCorePluginState();
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                this.updatePluginDiagnosticsFromPlugin(plugin);
+                this.reportPluginError(pluginId, `Failed to disable plugin ${pluginId}: ${formatPluginError(error)}`, error);
+                return false;
+            }
+        }, {
+            attributes: {
+                "plugin.id": pluginId,
+                "plugin.source": plugin.source,
+            },
+            slowThresholdMs: 300,
+        });
+    }
+    async restartPlugin(pluginId) {
+        let plugin = this.plugins.get(pluginId);
+        if (!plugin) {
+            plugin =
+                (await this.loadPlugin(joinPath(this.pluginsPath, pluginId))) ??
+                    undefined;
+        }
+        if (!plugin && this.#lapisExtensionIndex.has(pluginId)) {
+            this.disableManifestOnlyExtension(pluginId);
+            return this.enablePlugin(pluginId);
+        }
+        if (!plugin) {
+            this.reportPluginError(pluginId, `Unknown plugin: ${pluginId}`);
+            return false;
+        }
+        try {
+            if (plugin.loaded || plugin.enabled || plugin.state === "failed") {
+                await plugin.disable();
+                this.unloadPluginCSS(pluginId);
+                this.updatePluginDiagnosticsFromPlugin(plugin);
+            }
+        }
+        catch (error) {
+            this.updatePluginDiagnosticsFromPlugin(plugin);
+            this.reportPluginError(pluginId, `Failed to restart plugin ${pluginId}: ${formatPluginError(error)}`, error);
+            return false;
+        }
+        return this.enablePlugin(pluginId);
+    }
+    capturePluginOwnedLeaves(plugin) {
+        const leaves = new Set();
+        for (const viewType of plugin.registeredViewTypes) {
+            for (const leaf of this.app.workspace.getLeavesOfType(viewType)) {
+                leaves.add(leaf);
+            }
+        }
+        return [...leaves].map((leaf) => ({
+            leaf,
+            state: leaf.captureCurrentViewState(),
+        }));
+    }
+    async replacePluginOwnedLeaves(entries) {
+        await Promise.all(entries.map(({ leaf, state }) => leaf.setViewState({
+            ...state,
+            type: "empty",
+            state: {
+                ...(state.state ?? {}),
+                __missingViewType: state.type,
+            },
+        }, { history: false, activatePlugins: false })));
+    }
+    async restorePluginOwnedLeaves(plugin) {
+        const leaves = [];
+        this.app.workspace.iterateAllLeaves((leaf) => {
+            const state = leaf.getViewState();
+            const missingViewType = state.state?.["__missingViewType"];
+            if (state.type === "empty" &&
+                typeof missingViewType === "string" &&
+                plugin.registeredViewTypes.has(missingViewType)) {
+                leaves.push(leaf);
+            }
+        });
+        await Promise.all(leaves.map((leaf) => leaf.setViewState(leaf.getViewState(), { history: false })));
+    }
+    isVersionCompatible(minVersion) {
+        const appVersion = this.app.version;
+        const appParts = appVersion.split(".").map(Number);
+        const minParts = minVersion.split(".").map(Number);
+        for (let i = 0; i < Math.max(appParts.length, minParts.length); i++) {
+            const appPart = appParts[i] || 0;
+            const minPart = minParts[i] || 0;
+            if (appPart > minPart)
+                return true;
+            if (appPart < minPart)
+                return false;
+        }
+        return true;
+    }
+    async enableAllPlugins(...pluginIds) {
+        const ids = pluginIds.flat().filter((it) => it);
+        const targetIds = pluginIds.length > 0 ? ids : [...this.plugins.keys()];
+        for (const id of targetIds) {
+            await this.enablePlugin(id);
+        }
+    }
+    async loadPluginStyles(plugin) {
+        if (plugin.source === "core") {
+            const handled = await this.loadCorePluginStyles(plugin);
+            if (handled) {
+                return;
+            }
+        }
+        if (!plugin.basePath) {
+            return;
+        }
+        const cssPath = joinPath(plugin.basePath, "styles.css");
+        let exists = false;
+        try {
+            exists = await this.adapter.exists(cssPath);
+        }
+        catch (error) {
+            if (isMissingPathError(error)) {
+                return;
+            }
+            throw error;
+        }
+        if (!exists) {
+            return;
+        }
+        try {
+            await this.loadPluginCSS(plugin.manifest.id, cssPath);
+        }
+        catch (error) {
+            this.reportPluginError(plugin.manifest.id, `Failed to load plugin styles for ${plugin.manifest.id}: ${formatPluginError(error)}`, error);
+        }
+    }
+    async loadCorePluginStyles(plugin) {
+        const styleSource = this.#corePluginStyles.get(plugin.manifest.id);
+        if (styleSource === undefined) {
+            return false;
+        }
+        try {
+            const cssContent = typeof styleSource === "function" ? await styleSource() : styleSource;
+            if (cssContent.trim()) {
+                this.loadPluginCSSContent(plugin.manifest.id, cssContent);
+            }
+            else {
+                this.unloadPluginCSS(plugin.manifest.id);
+            }
+        }
+        catch (error) {
+            this.reportPluginError(plugin.manifest.id, `Failed to load bundled plugin styles for ${plugin.manifest.id}: ${formatPluginError(error)}`, error);
+        }
+        return true;
+    }
+    unloadPluginCSS(pluginId) {
+        const el = document.querySelector(`#plugin-css-${pluginId}`);
+        if (el) {
+            el.detach();
+            this.emit("css-change");
+        }
+    }
+    async loadPluginCSS(pluginId, cssPath) {
+        const cssContent = await this.adapter.read(cssPath);
+        this.loadPluginCSSContent(pluginId, cssContent);
+    }
+    loadPluginCSSContent(pluginId, cssContent) {
+        const id = `plugin-css-${pluginId}`;
+        const el = document.querySelector(`#${id}`) ||
+            document.createElement("style");
+        el.id = id;
+        el.textContent = cssContent;
+        document.head.appendChild(el);
+        this.emit("css-change");
+    }
+    async preflightManifest(manifest, pluginPath, source, options = {}) {
+        if (!manifest.id?.trim()) {
+            throw new Error(`Plugin at ${pluginPath} is missing a manifest id`);
+        }
+        if (this.plugins.has(manifest.id)) {
+            throw new Error(`Plugin id ${manifest.id} is already registered`);
+        }
+        if (manifest.minAppVersion &&
+            !this.isVersionCompatible(manifest.minAppVersion)) {
+            throw new Error(`Plugin ${manifest.id} requires app version ${manifest.minAppVersion} or newer`);
+        }
+        if (manifest.isDesktopOnly && !Platform.isDesktopApp) {
+            throw new Error(`Plugin ${manifest.id} can only run in the desktop app`);
+        }
+        if (isExternalPluginSource(source)) {
+            if (requiresWorkspaceTrust(manifest) &&
+                !this.app.workspaceTrust.trusted) {
+                throw new Error(trustFailureMessage(manifest));
+            }
+            if (!this.isRuntimeSupported(manifest)) {
+                throw new Error(`Plugin ${manifest.id} does not support host ${this.getHostIdForManifest(manifest)}`);
+            }
+            const invalidCapabilities = this.getInvalidRequiredCapabilities(manifest);
+            if (invalidCapabilities.length) {
+                throw new Error(`Plugin ${manifest.id} declares unknown required capabilities: ${invalidCapabilities.join(", ")}`);
+            }
+            const grantedCapabilities = new Set(this.getGrantedCapabilities(manifest));
+            const missingCapabilities = this.getRequestedCapabilities(manifest).filter((capability) => !grantedCapabilities.has(capability));
+            if (missingCapabilities.length) {
+                throw new Error(`Plugin ${manifest.id} requires unavailable capabilities: ${missingCapabilities.join(", ")}`);
+            }
+            const mainPath = joinPath(pluginPath, "main.js");
+            const hasMainJs = options.hasMainJs ?? (await this.pathExists(mainPath));
+            const classification = options.classification ??
+                classifyLapisPlugin(manifest, {
+                    hasMainJs,
+                });
+            const selectedEntry = this.getSelectedCodeEntry(manifest, classification, hasMainJs);
+            if (!selectedEntry) {
+                if (classification === "obsidian-compatible" && !hasMainJs) {
+                    throw new Error(`Plugin ${manifest.id} is missing main.js`);
+                }
+                if (hasDeclaredLapisRuntimeCode(manifest)) {
+                    throw new Error(`Plugin ${manifest.id} does not have a supported Lapis runtime entry for host ${this.getHostIdForManifest(manifest)}`);
+                }
+                return;
+            }
+            const modulePath = this.getSelectedCommunityModulePath(manifest, pluginPath, classification, hasMainJs);
+            if (!modulePath || !(await this.pathExists(modulePath))) {
+                if (selectedEntry === "main.js") {
+                    throw new Error(`Plugin ${manifest.id} is missing main.js`);
+                }
+                throw new Error(`Plugin ${manifest.id} is missing Lapis runtime entry ${selectedEntry}`);
+            }
+        }
+    }
+    reportPluginError(id, message, error) {
+        console.error(message, error);
+        this.app.telemetry.recordEvent("plugin.error", {
+            "plugin.id": id,
+            "plugin.message": message,
+        });
+        this.emit("plugin-error", id, message, error);
+    }
+    isRuntimeSupported(manifest) {
+        const runtimes = normalizeStringArray(manifest.supportedRuntimes);
+        if (!runtimes.length) {
+            return true;
+        }
+        const hostId = this.getHostIdForManifest(manifest);
+        return runtimes.some((runtime) => runtimeMatchesHost(runtime.toLowerCase(), hostId));
+    }
+    getRequestedCapabilities(manifest) {
+        const validCapabilities = new Set(HOSTED_PLUGIN_CAPABILITIES);
+        return [
+            ...new Set([
+                ...normalizeStringArray(manifest.requiredCapabilities).filter((capability) => validCapabilities.has(capability)),
+                ...permissionsToCapabilities(manifest.lapis?.permissions),
+            ]),
+        ];
+    }
+    getInvalidRequiredCapabilities(manifest) {
+        const validCapabilities = new Set(HOSTED_PLUGIN_CAPABILITIES);
+        return normalizeStringArray(manifest.requiredCapabilities).filter((capability) => !validCapabilities.has(capability));
+    }
+    getGrantedCapabilities(manifest) {
+        if (!this.getRequestedCapabilities(manifest).length) {
+            return [];
+        }
+        if (!this.app.workspaceTrust.trusted) {
+            return [];
+        }
+        if (isSidecarHost(this.getHostIdForManifest(manifest))) {
+            return [...HOSTED_PLUGIN_CAPABILITIES];
+        }
+        return permissionsToCapabilities(manifest.lapis?.permissions);
+    }
+    recordCommunityPluginDiagnostics(manifest, state, runtime = {}) {
+        this.syncPluginContextKeys(manifest.id, state);
+        const previous = this.#communityPluginDiagnostics.get(manifest.id);
+        const indexedExtension = this.#lapisExtensionIndex.get(manifest.id);
+        const source = runtime.source ??
+            this.plugins.get(manifest.id)?.source ??
+            indexedExtension?.source ??
+            previous?.source ??
+            "community";
+        const provenance = runtime.provenance ??
+            this.plugins.get(manifest.id)?.provenance ??
+            previous?.provenance ??
+            provenanceForPluginSource(source);
+        const classification = indexedExtension?.classification ??
+            previous?.classification ??
+            "obsidian-compatible";
+        const selectedRuntime = this.selectRuntimeEntryForManifest(manifest, {
+            classification,
+        });
+        const dependencyDiagnostics = this.getCommunityPluginDependencyDiagnosticsForRecord(manifest.id, previous);
+        const runtimeDiagnostics = this.getCommunityPluginRuntimeExecutionDiagnosticsForRecord(manifest.id, previous);
+        this.#communityPluginDiagnostics.set(manifest.id, {
+            pluginId: manifest.id,
+            name: manifest.name,
+            version: manifest.version,
+            author: manifest.author,
+            description: manifest.description,
+            source,
+            provenance,
+            classification,
+            hostMode: this.getHostIdForManifest(manifest),
+            activationMode: "not-activated",
+            activationTrigger: previous?.activationTrigger ?? null,
+            selectedRuntimeHost: selectedRuntime?.host ?? null,
+            selectedRuntimeEntry: selectedRuntime?.path ?? null,
+            moduleFormat: selectedRuntime?.format ?? null,
+            fallbackRuntimeEntry: selectedRuntime?.fallbackPath ?? null,
+            fallbackUsed: runtimeDiagnostics.fallbackUsed,
+            requiresReloadOnUpdate: selectedRuntime?.requiresReloadOnUpdate ?? false,
+            sharedDependencies: selectedRuntime?.sharedDependencies ?? [],
+            usedSharedDependencies: dependencyDiagnostics.usedSharedDependencies,
+            undeclaredSharedDependencies: dependencyDiagnostics.undeclaredSharedDependencies,
+            missingSharedDependencies: dependencyDiagnostics.missingSharedDependencies,
+            deprecatedSharedDependencies: dependencyDiagnostics.deprecatedSharedDependencies,
+            privateSharedDependencies: dependencyDiagnostics.privateSharedDependencies,
+            assetUrlMode: runtimeDiagnostics.assetUrlMode,
+            pluginAssetUrl: runtimeDiagnostics.pluginAssetUrl,
+            requestedCapabilities: this.getRequestedCapabilities(manifest),
+            grantedCapabilities: this.getGrantedCapabilities(manifest),
+            privileges: indexedExtension?.privileges ?? previous?.privileges ?? [],
+            indexedContributionCount: indexedExtension?.contributions.length ??
+                previous?.indexedContributionCount ??
+                0,
+            contributionDiagnostics: [
+                ...(this.#manifestContributionDiagnostics.get(manifest.id) ??
+                    previous?.contributionDiagnostics ??
+                    []),
+            ],
+            lastFailureMessage: previous?.lastFailureMessage ?? null,
+            state,
+        });
+    }
+    recordCommunityPluginFailure(pluginId, manifest, message) {
+        this.syncPluginContextKeys(pluginId, "failed");
+        const previous = this.#communityPluginDiagnostics.get(pluginId);
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        const source = this.plugins.get(pluginId)?.source ??
+            indexedExtension?.source ??
+            previous?.source ??
+            (manifest
+                ? this.resolveExternalPluginSource(manifest.id).source
+                : "community");
+        const provenance = this.plugins.get(pluginId)?.provenance ??
+            previous?.provenance ??
+            provenanceForPluginSource(source);
+        const classification = indexedExtension?.classification ??
+            previous?.classification ??
+            "obsidian-compatible";
+        const selectedRuntime = manifest
+            ? this.selectRuntimeEntryForManifest(manifest, { classification })
+            : null;
+        const dependencyDiagnostics = this.getCommunityPluginDependencyDiagnosticsForRecord(pluginId, previous);
+        const runtimeDiagnostics = this.getCommunityPluginRuntimeExecutionDiagnosticsForRecord(pluginId, previous);
+        this.#communityPluginDiagnostics.set(pluginId, {
+            pluginId,
+            name: manifest?.name ?? previous?.name,
+            version: manifest?.version ?? previous?.version,
+            author: manifest?.author ?? previous?.author,
+            description: manifest?.description ?? previous?.description,
+            source,
+            provenance,
+            classification,
+            hostMode: manifest
+                ? this.getHostIdForManifest(manifest)
+                : (previous?.hostMode ?? this.#communityPluginHost.id),
+            activationMode: manifest
+                ? "not-activated"
+                : (previous?.activationMode ?? "not-activated"),
+            activationTrigger: previous?.activationTrigger ?? null,
+            selectedRuntimeHost: selectedRuntime?.host ?? previous?.selectedRuntimeHost ?? null,
+            selectedRuntimeEntry: selectedRuntime?.path ?? previous?.selectedRuntimeEntry ?? null,
+            moduleFormat: selectedRuntime?.format ?? previous?.moduleFormat ?? null,
+            fallbackRuntimeEntry: selectedRuntime?.fallbackPath ?? previous?.fallbackRuntimeEntry ?? null,
+            fallbackUsed: runtimeDiagnostics.fallbackUsed,
+            requiresReloadOnUpdate: selectedRuntime?.requiresReloadOnUpdate ??
+                previous?.requiresReloadOnUpdate ??
+                false,
+            sharedDependencies: selectedRuntime?.sharedDependencies ??
+                previous?.sharedDependencies ??
+                [],
+            usedSharedDependencies: dependencyDiagnostics.usedSharedDependencies,
+            undeclaredSharedDependencies: dependencyDiagnostics.undeclaredSharedDependencies,
+            missingSharedDependencies: dependencyDiagnostics.missingSharedDependencies,
+            deprecatedSharedDependencies: dependencyDiagnostics.deprecatedSharedDependencies,
+            privateSharedDependencies: dependencyDiagnostics.privateSharedDependencies,
+            assetUrlMode: runtimeDiagnostics.assetUrlMode,
+            pluginAssetUrl: runtimeDiagnostics.pluginAssetUrl,
+            requestedCapabilities: manifest
+                ? this.getRequestedCapabilities(manifest)
+                : (previous?.requestedCapabilities ?? []),
+            grantedCapabilities: manifest
+                ? this.getGrantedCapabilities(manifest)
+                : (previous?.grantedCapabilities ?? []),
+            privileges: indexedExtension?.privileges ?? previous?.privileges ?? [],
+            indexedContributionCount: indexedExtension?.contributions.length ??
+                previous?.indexedContributionCount ??
+                0,
+            contributionDiagnostics: [
+                ...(this.#manifestContributionDiagnostics.get(pluginId) ??
+                    previous?.contributionDiagnostics ??
+                    []),
+            ],
+            lastFailureMessage: message,
+            state: "failed",
+        });
+    }
+    updatePluginDiagnosticsFromPlugin(plugin) {
+        this.syncPluginContextKeys(plugin.manifest.id, plugin.state);
+        if (!isExternalPluginSource(plugin.source) &&
+            this.#lapisExtensionIndex.get(plugin.manifest.id)?.source !== "system") {
+            return;
+        }
+        const previous = this.#communityPluginDiagnostics.get(plugin.manifest.id);
+        const indexedExtension = this.#lapisExtensionIndex.get(plugin.manifest.id);
+        const classification = indexedExtension?.classification ??
+            previous?.classification ??
+            "obsidian-compatible";
+        const selectedRuntime = this.selectRuntimeEntryForManifest(plugin.manifest, {
+            classification,
+        });
+        const dependencyDiagnostics = this.getCommunityPluginDependencyDiagnosticsForRecord(plugin.manifest.id, previous);
+        const runtimeDiagnostics = this.getCommunityPluginRuntimeExecutionDiagnosticsForRecord(plugin.manifest.id, previous);
+        this.#communityPluginDiagnostics.set(plugin.manifest.id, {
+            pluginId: plugin.manifest.id,
+            name: plugin.manifest.name,
+            version: plugin.manifest.version,
+            author: plugin.manifest.author,
+            description: plugin.manifest.description,
+            source: plugin.source,
+            provenance: plugin.provenance,
+            classification,
+            hostMode: plugin.hostMode,
+            activationMode: "code",
+            activationTrigger: previous?.activationTrigger ?? null,
+            selectedRuntimeHost: selectedRuntime?.host ?? null,
+            selectedRuntimeEntry: selectedRuntime?.path ?? null,
+            moduleFormat: selectedRuntime?.format ?? null,
+            fallbackRuntimeEntry: selectedRuntime?.fallbackPath ?? null,
+            fallbackUsed: runtimeDiagnostics.fallbackUsed,
+            requiresReloadOnUpdate: selectedRuntime?.requiresReloadOnUpdate ?? false,
+            sharedDependencies: selectedRuntime?.sharedDependencies ?? [],
+            usedSharedDependencies: dependencyDiagnostics.usedSharedDependencies,
+            undeclaredSharedDependencies: dependencyDiagnostics.undeclaredSharedDependencies,
+            missingSharedDependencies: dependencyDiagnostics.missingSharedDependencies,
+            deprecatedSharedDependencies: dependencyDiagnostics.deprecatedSharedDependencies,
+            privateSharedDependencies: dependencyDiagnostics.privateSharedDependencies,
+            assetUrlMode: runtimeDiagnostics.assetUrlMode,
+            pluginAssetUrl: runtimeDiagnostics.pluginAssetUrl,
+            requestedCapabilities: plugin.requestedCapabilities,
+            grantedCapabilities: plugin.grantedCapabilities,
+            privileges: indexedExtension?.privileges ?? previous?.privileges ?? [],
+            indexedContributionCount: indexedExtension?.contributions.length ??
+                previous?.indexedContributionCount ??
+                0,
+            contributionDiagnostics: [
+                ...(this.#manifestContributionDiagnostics.get(plugin.manifest.id) ??
+                    previous?.contributionDiagnostics ??
+                    []),
+            ],
+            lastFailureMessage: plugin.lastFailureMessage ?? previous?.lastFailureMessage ?? null,
+            state: plugin.state,
+        });
+    }
+    async updateCommunityPluginDependencyDiagnostics(manifest, pluginPath, classification, hasMainJs) {
+        const selectedRuntime = this.selectRuntimeEntryForManifest(manifest, {
+            classification,
+            hasMainJs,
+        });
+        const moduleSources = await this.readCommunityPluginModuleSources(pluginPath);
+        const usedSharedDependencies = getBareDependencySpecifiersFromSources(moduleSources);
+        const declaredSharedDependencies = selectedRuntime?.sharedDependencies ?? [];
+        const declarationsAreExplicit = selectedRuntime?.source === "lapis-runtime-entry" ||
+            declaredSharedDependencies.length > 0;
+        const declared = new Set(declaredSharedDependencies);
+        const undeclaredSharedDependencies = declarationsAreExplicit
+            ? usedSharedDependencies.filter((specifier) => this.isKnownHostDependency(specifier, selectedRuntime?.host) &&
+                !declared.has(specifier))
+            : [];
+        const missingSharedDependencies = declaredSharedDependencies.filter((specifier) => !this.isKnownHostDependency(specifier, selectedRuntime?.host));
+        const declaredOrUsedSharedDependencies = [
+            ...new Set([...declaredSharedDependencies, ...usedSharedDependencies]),
+        ].sort();
+        const deprecatedSharedDependencies = declaredOrUsedSharedDependencies.filter((specifier) => {
+            const metadata = this.getHostDependencyMetadata(specifier);
+            return Boolean(metadata && "deprecated" in metadata && metadata.deprecated === true);
+        });
+        const privateSharedDependencies = declaredOrUsedSharedDependencies.filter((specifier) => this.getHostDependencyMetadata(specifier)?.public === false);
+        this.#communityPluginDependencyDiagnostics.set(manifest.id, {
+            usedSharedDependencies,
+            undeclaredSharedDependencies,
+            missingSharedDependencies,
+            deprecatedSharedDependencies,
+            privateSharedDependencies,
+        });
+    }
+    getCommunityPluginDependencyDiagnosticsForRecord(pluginId, previous) {
+        return (this.#communityPluginDependencyDiagnostics.get(pluginId) ?? {
+            usedSharedDependencies: previous?.usedSharedDependencies ?? [],
+            undeclaredSharedDependencies: previous?.undeclaredSharedDependencies ?? [],
+            missingSharedDependencies: previous?.missingSharedDependencies ?? [],
+            deprecatedSharedDependencies: previous?.deprecatedSharedDependencies ?? [],
+            privateSharedDependencies: previous?.privateSharedDependencies ?? [],
+        });
+    }
+    getCommunityPluginRuntimeExecutionDiagnosticsForRecord(pluginId, previous) {
+        return (this.#communityPluginRuntimeExecutionDiagnostics.get(pluginId) ?? {
+            fallbackUsed: previous?.fallbackUsed ?? false,
+            assetUrlMode: previous?.assetUrlMode ?? null,
+            pluginAssetUrl: previous?.pluginAssetUrl ?? null,
+        });
+    }
+    recordPluginAssetUrlDiagnostics(pluginId, url) {
+        const previous = this.#communityPluginRuntimeExecutionDiagnostics.get(pluginId);
+        this.#communityPluginRuntimeExecutionDiagnostics.set(pluginId, {
+            ...previous,
+            fallbackUsed: false,
+            assetUrlMode: getPluginAssetUrlMode(url),
+            pluginAssetUrl: url,
+        });
+    }
+    recordPluginFallbackDiagnostics(pluginId) {
+        const previous = this.#communityPluginRuntimeExecutionDiagnostics.get(pluginId);
+        this.#communityPluginRuntimeExecutionDiagnostics.set(pluginId, {
+            fallbackUsed: true,
+            assetUrlMode: previous?.assetUrlMode ?? null,
+            pluginAssetUrl: previous?.pluginAssetUrl ?? null,
+        });
+    }
+    isKnownHostDependency(specifier, host) {
+        const metadata = this.getHostDependencyMetadata(specifier);
+        if (!metadata) {
+            return false;
+        }
+        if (!host) {
+            return true;
+        }
+        return metadata.platforms.some((platform) => hostPlatformMatchesDependencyPlatform(host, platform));
+    }
+    getHostDependencyMetadata(specifier) {
+        return (pluginHostModuleRegistry[specifier] ?? undefined);
+    }
+    async readCommunityPluginModuleSources(pluginPath) {
+        const sources = new Map();
+        const visit = async (folderPath) => {
+            const listing = await this.adapter.list(folderPath);
+            await Promise.all(listing.files
+                .filter((file) => /\.(?:cjs|mjs|js)$/i.test(file))
+                .map(async (file) => {
+                const filePath = normalizePath(joinPath(folderPath, file));
+                sources.set(filePath, await this.adapter.read(filePath));
+            }));
+            for (const folder of listing.folders) {
+                await visit(joinPath(folderPath, folder));
+            }
+        };
+        await visit(pluginPath);
+        return sources;
+    }
+    indexCommunityManifest(manifest, manifestPath, hasMainJs, source = "community", provenance = provenanceForPluginSource(source)) {
+        const classification = classifyLapisPlugin(manifest, { hasMainJs });
+        if (manifest.lapis === undefined) {
+            this.#lapisExtensionIndex.delete(manifest.id);
+            this.recordCommunityPluginDiagnostics(manifest, "disabled", {
+                source,
+                provenance,
+            });
+            return classification;
+        }
+        const diagnostics = validateLapisManifest(manifest.id, manifest.lapis);
+        if (diagnostics.length) {
+            throw new Error(diagnostics.join("; "));
+        }
+        if (!isLapisManifest(manifest.lapis)) {
+            throw new Error(`Plugin ${manifest.id} has invalid lapis metadata`);
+        }
+        const indexedExtension = buildLapisContributionIndex({
+            pluginId: manifest.id,
+            name: manifest.name,
+            source: isExternalPluginSource(source) ? source : "community",
+            manifestPath,
+            classification,
+            lapis: manifest.lapis,
+            requestedCapabilities: this.getRequestedCapabilities(manifest),
+            grantedCapabilities: this.getGrantedCapabilities(manifest),
+        });
+        this.#lapisExtensionIndex.set(manifest.id, indexedExtension);
+        this.#manifestContributionDiagnostics.set(manifest.id, indexedExtension.contributions.flatMap((entry) => entry.diagnostics));
+        this.syncIndexedExtensionActivation(indexedExtension);
+        this.recordCommunityPluginDiagnostics(manifest, "disabled", {
+            source,
+            provenance,
+        });
+        return classification;
+    }
+    enableManifestOnlyExtension(pluginId) {
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        if (!indexedExtension) {
+            return false;
+        }
+        this.disableManifestOnlyExtension(pluginId);
+        this.#deferredIndexedExtensions.delete(pluginId);
+        const disposers = [];
+        const diagnostics = indexedExtension.contributions.flatMap((entry) => entry.diagnostics);
+        const contributions = indexedExtension.contributions.map((entry) => ({
+            ...entry,
+            diagnostics: [...entry.diagnostics],
+            state: entry.state,
+        }));
+        for (const entry of contributions) {
+            if (entry.state === "invalid") {
+                continue;
+            }
+            try {
+                switch (entry.kind) {
+                    case "commands":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestCommand(entry),
+                        });
+                        break;
+                    case "configuration":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestConfiguration(entry),
+                        });
+                        break;
+                    case "statusBarItems":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestStatusBarItem(entry),
+                        });
+                        break;
+                    case "editorViews":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestEditorView(entry),
+                        });
+                        break;
+                    case "services":
+                        if (indexedExtension.source === "system") {
+                            disposers.push({
+                                kind: entry.kind,
+                                id: entry.id,
+                                dispose: this.installManifestService(entry),
+                            });
+                            break;
+                        }
+                        {
+                            const message = `Contribution ${entry.kind}:${entry.id} is indexed but not installed in this phase`;
+                            entry.diagnostics.push(message);
+                            diagnostics.push(message);
+                            break;
+                        }
+                    default: {
+                        const message = `Contribution ${entry.kind}:${entry.id} is indexed but not installed in this phase`;
+                        entry.diagnostics.push(message);
+                        diagnostics.push(message);
+                    }
+                }
+            }
+            catch (error) {
+                entry.state = "invalid";
+                const message = `Failed to install contribution ${entry.kind}:${entry.id}: ${formatPluginError(error)}`;
+                entry.diagnostics.push(message);
+                diagnostics.push(message);
+            }
+        }
+        this.#manifestContributionDisposers.set(pluginId, disposers);
+        this.#manifestContributionDiagnostics.set(pluginId, diagnostics);
+        this.#lapisExtensionIndex.set(pluginId, {
+            ...indexedExtension,
+            contributions,
+        });
+        this.recordIndexedExtensionDiagnostics(pluginId, "enabled");
+        return true;
+    }
+    enableDeferredIndexedExtension(pluginId) {
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        if (!indexedExtension) {
+            return false;
+        }
+        this.disableManifestOnlyExtension(pluginId);
+        const disposers = [];
+        const diagnostics = indexedExtension.contributions.flatMap((entry) => entry.diagnostics);
+        const contributions = indexedExtension.contributions.map((entry) => ({
+            ...entry,
+            diagnostics: [...entry.diagnostics],
+            state: entry.state,
+        }));
+        for (const entry of contributions) {
+            if (entry.state === "invalid") {
+                continue;
+            }
+            try {
+                switch (entry.kind) {
+                    case "commands":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestCommand(entry, {
+                                activateEvent: activationEventForContribution(pluginId, entry) ??
+                                    `onCommand:${entry.id}`,
+                            }),
+                        });
+                        break;
+                    case "configuration":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestConfiguration(entry),
+                        });
+                        break;
+                    case "statusBarItems":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestStatusBarItem(entry),
+                        });
+                        break;
+                    case "editorViews":
+                        disposers.push({
+                            kind: entry.kind,
+                            id: entry.id,
+                            dispose: this.installManifestEditorView(entry),
+                        });
+                        break;
+                    default:
+                        break;
+                }
+            }
+            catch (error) {
+                entry.state = "invalid";
+                const message = `Failed to install deferred contribution ${entry.kind}:${entry.id}: ${formatPluginError(error)}`;
+                entry.diagnostics.push(message);
+                diagnostics.push(message);
+            }
+        }
+        this.#manifestContributionDisposers.set(pluginId, disposers);
+        this.#manifestContributionDiagnostics.set(pluginId, diagnostics);
+        this.#lapisExtensionIndex.set(pluginId, {
+            ...indexedExtension,
+            contributions,
+            enabled: true,
+        });
+        this.#deferredIndexedExtensions.set(pluginId, {
+            pluginId,
+            source: indexedExtension.source,
+            mode: "lazy-code",
+        });
+        this.recordIndexedExtensionDiagnostics(pluginId, "dormant");
+        return true;
+    }
+    disableManifestOnlyExtension(pluginId) {
+        this.disposeInstalledManifestContributions(pluginId);
+        this.#deferredIndexedExtensions.delete(pluginId);
+        this.recordIndexedExtensionDiagnostics(pluginId, "disabled");
+    }
+    disposeInstalledManifestContributions(pluginId) {
+        const disposers = this.#manifestContributionDisposers.get(pluginId) ?? [];
+        for (const entry of [...disposers].reverse()) {
+            try {
+                entry.dispose();
+            }
+            catch (error) {
+                this.reportPluginError(pluginId, `Failed to dispose manifest contribution for ${pluginId}: ${formatPluginError(error)}`, error);
+            }
+        }
+        this.#manifestContributionDisposers.delete(pluginId);
+        this.#manifestContributionDiagnostics.delete(pluginId);
+    }
+    installManifestCommand(entry, options = {}) {
+        const command = commandContributionToCommand(entry.contribution);
+        const idPrefix = `${entry.pluginId}:`;
+        if (!command.id.startsWith(idPrefix)) {
+            command.id = `${idPrefix}${command.id}`;
+        }
+        if (!command.name.startsWith(idPrefix)) {
+            command.name = `${idPrefix} ${command.name}`;
+        }
+        const commandId = command.id;
+        const activateEvent = options.activateEvent ?? null;
+        command.sourcePlugin = entry.pluginId;
+        command.activationEvent = activateEvent ?? undefined;
+        command.callback = async (...args) => {
+            if (!activateEvent) {
+                this.reportPluginError(entry.pluginId, `Manifest command ${entry.id} is declarative; runtime activation is not implemented yet`);
+                return;
+            }
+            this.app.commands.unregisterCommand(commandId);
+            const activated = await this.activateByEvent(activateEvent, `command:${commandId}`);
+            if (activated && this.app.commands.getCommand(commandId)) {
+                return this.app.commands.executeCommand(commandId, ...args);
+            }
+            this.app.commands.registerCommand(command);
+            this.reportPluginError(entry.pluginId, `Deferred command ${commandId} did not activate a runtime command`);
+        };
+        this.app.commands.registerCommand(command);
+        return () => {
+            this.app.commands.unregisterCommand(command.id);
+        };
+    }
+    installManifestConfiguration(entry) {
+        const contribution = entry.contribution;
+        const schema = {
+            id: contribution.id ?? entry.pluginId,
+            title: contribution.title ?? entry.id,
+            type: "object",
+            properties: contribution.properties ?? {},
+        };
+        this.app.configuration.schema.register(schema);
+        void this.app.configuration.materializeSchemaDefaults();
+        return () => {
+            this.app.configuration.schema.unregister(schema);
+        };
+    }
+    installManifestStatusBarItem(entry) {
+        const contribution = entry.contribution;
+        return this.app.statusBar.registerItem({
+            id: `${entry.pluginId}:${contribution.id}`,
+            text: contribution.text,
+            icon: contribution.icon,
+            tooltip: contribution.tooltip,
+            when: contribution.when,
+            alignment: contribution.alignment,
+            priority: contribution.priority,
+            command: contribution.command
+                ? normalizeManifestCommandId(entry.pluginId, contribution.command)
+                : undefined,
+            sourcePlugin: entry.pluginId,
+        });
+    }
+    installManifestEditorView(entry) {
+        const contribution = entry.contribution;
+        return this.app.workspace.registerEditorView({
+            ...contribution,
+            pluginId: entry.pluginId,
+            source: "manifest",
+        });
+    }
+    installManifestService(entry) {
+        const contribution = entry.contribution;
+        const registration = this.getSystemExtensionServiceProviderRegistration(entry.pluginId, contribution.service, entry.id);
+        if (!registration) {
+            throw new Error(`System extension ${entry.pluginId} is missing a provider binding for ${contribution.service}:${entry.id}`);
+        }
+        const provider = registration.createProvider
+            ? registration.createProvider(this.app)
+            : registration.provider;
+        if (provider === undefined) {
+            throw new Error(`System extension ${entry.pluginId} did not return a provider for ${contribution.service}:${entry.id}`);
+        }
+        return this.registerLapisServiceProvider({
+            pluginId: entry.pluginId,
+            service: contribution.service,
+            id: entry.id,
+            metadata: registration.metadata,
+            provider,
+            dispose: registration.dispose,
+        });
+    }
+    recordIndexedExtensionDiagnostics(pluginId, state) {
+        this.syncPluginContextKeys(pluginId, state);
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        if (!indexedExtension) {
+            return;
+        }
+        const updatedExtension = {
+            ...indexedExtension,
+            enabled: state === "enabled",
+        };
+        this.#lapisExtensionIndex.set(pluginId, updatedExtension);
+        const previous = this.#communityPluginDiagnostics.get(pluginId);
+        const selectedRuntime = this.selectRuntimeEntryForIndexedExtension(updatedExtension);
+        const dependencyDiagnostics = this.getCommunityPluginDependencyDiagnosticsForRecord(pluginId, previous);
+        const runtimeDiagnostics = this.getCommunityPluginRuntimeExecutionDiagnosticsForRecord(pluginId, previous);
+        this.#communityPluginDiagnostics.set(pluginId, {
+            pluginId,
+            name: updatedExtension.name ?? previous?.name,
+            version: previous?.version,
+            author: previous?.author,
+            description: previous?.description,
+            source: updatedExtension.source === "system"
+                ? "system"
+                : updatedExtension.source,
+            provenance: updatedExtension.source === "official"
+                ? "official"
+                : updatedExtension.source === "system"
+                    ? "bundled"
+                    : (previous?.provenance ?? "community"),
+            classification: updatedExtension.classification,
+            hostMode: this.getHostIdForIndexedExtension(updatedExtension),
+            activationMode: state === "enabled"
+                ? this.#deferredIndexedExtensions.get(pluginId)?.mode === "lazy-code"
+                    ? "not-activated"
+                    : "manifest-only"
+                : "not-activated",
+            activationTrigger: previous?.activationTrigger ?? null,
+            selectedRuntimeHost: selectedRuntime?.host ?? null,
+            selectedRuntimeEntry: selectedRuntime?.path ?? null,
+            moduleFormat: selectedRuntime?.format ?? null,
+            fallbackRuntimeEntry: selectedRuntime?.fallbackPath ?? null,
+            fallbackUsed: runtimeDiagnostics.fallbackUsed,
+            requiresReloadOnUpdate: selectedRuntime?.requiresReloadOnUpdate ?? false,
+            sharedDependencies: selectedRuntime?.sharedDependencies ?? [],
+            usedSharedDependencies: dependencyDiagnostics.usedSharedDependencies,
+            undeclaredSharedDependencies: dependencyDiagnostics.undeclaredSharedDependencies,
+            missingSharedDependencies: dependencyDiagnostics.missingSharedDependencies,
+            deprecatedSharedDependencies: dependencyDiagnostics.deprecatedSharedDependencies,
+            privateSharedDependencies: dependencyDiagnostics.privateSharedDependencies,
+            assetUrlMode: runtimeDiagnostics.assetUrlMode,
+            pluginAssetUrl: runtimeDiagnostics.pluginAssetUrl,
+            requestedCapabilities: updatedExtension.requestedCapabilities,
+            grantedCapabilities: updatedExtension.grantedCapabilities,
+            privileges: updatedExtension.privileges,
+            indexedContributionCount: updatedExtension.contributions.length,
+            contributionDiagnostics: this.getLapisContributionDiagnostics(pluginId),
+            lastFailureMessage: previous?.lastFailureMessage ?? null,
+            state,
+        });
+    }
+    syncPluginContextKeys(pluginId, state) {
+        this.app.contextKeys.set(`plugin.state.${pluginId}`, state);
+        this.app.contextKeys.set(`plugin.enabled.${pluginId}`, state === "enabled" || state === "enabling" || state === "dormant");
+    }
+    async activateByEvent(event, trigger = event) {
+        const pluginIds = [...(this.#indexedActivationRegistry.get(event) ?? [])];
+        if (!pluginIds.length) {
+            return false;
+        }
+        let activated = false;
+        for (const pluginId of pluginIds) {
+            activated =
+                (await this.activateDeferredIndexedExtension(pluginId, trigger)) ||
+                    activated;
+        }
+        return activated;
+    }
+    async activateForViewType(viewType) {
+        return this.activateByEvent(`onView:${viewType}`, `view:${viewType}`);
+    }
+    async activateForService(serviceId) {
+        return this.activateByEvent(`onService:${serviceId}`, `service:${serviceId}`);
+    }
+    async activateForLanguage(languageId) {
+        return this.activateByEvent(`onLanguage:${languageId}`, `language:${languageId}`);
+    }
+    async activateForPath(path) {
+        const events = this.matchingPathActivationEvents(path);
+        let activated = false;
+        for (const event of events) {
+            activated =
+                (await this.activateByEvent(event, `path:${path}`)) || activated;
+        }
+        return activated;
+    }
+    async activateIndexedExtensionsForWorkspace() {
+        const files = this.app.vault.getFiles().map((file) => file.path);
+        for (const filePath of files) {
+            await this.activateForPath(filePath);
+            const languageIds = this.findLanguageIdsForPath(filePath);
+            for (const languageId of languageIds) {
+                await this.activateForLanguage(languageId);
+            }
+        }
+    }
+    async activateDeferredIndexedExtension(pluginId, trigger) {
+        const deferred = this.#deferredIndexedExtensions.get(pluginId);
+        if (!deferred) {
+            return false;
+        }
+        if (this.plugins.get(pluginId)?.enabled) {
+            return false;
+        }
+        const diagnostics = this.#communityPluginDiagnostics.get(pluginId);
+        if (diagnostics) {
+            this.#communityPluginDiagnostics.set(pluginId, {
+                ...diagnostics,
+                activationTrigger: trigger,
+                state: "enabling",
+            });
+        }
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        const commandShims = this.#manifestContributionDisposers
+            .get(pluginId)
+            ?.filter((entry) => entry.kind === "commands") ?? [];
+        for (const entry of commandShims) {
+            entry.dispose();
+        }
+        if (commandShims.length) {
+            const remaining = this.#manifestContributionDisposers
+                .get(pluginId)
+                ?.filter((entry) => entry.kind !== "commands") ?? [];
+            this.#manifestContributionDisposers.set(pluginId, remaining);
+        }
+        let enabled = false;
+        try {
+            if (indexedExtension?.source === "system" &&
+                this.#systemExtensionPlugins.has(pluginId)) {
+                const runtimePlugin = this.instantiateSystemExtensionPlugin(pluginId);
+                if (!runtimePlugin) {
+                    return false;
+                }
+                enabled = await this.enablePlugin(pluginId);
+            }
+            else {
+                const pluginPath = joinPath(this.pluginsPath, pluginId);
+                const runtimePlugin = (await this.loadPlugin(pluginPath, {
+                    loadDeferredRuntime: true,
+                })) ?? null;
+                if (!runtimePlugin) {
+                    return false;
+                }
+                enabled = await this.enablePlugin(pluginId);
+            }
+        }
+        catch (error) {
+            const message = `Failed to activate deferred extension ${pluginId}: ${formatPluginError(error)}`;
+            this.recordCommunityPluginFailure(pluginId, this.plugins.get(pluginId)?.manifest ??
+                this.#systemExtensionManifests.get(pluginId) ??
+                null, message);
+            this.enableDeferredIndexedExtension(pluginId);
+            return false;
+        }
+        if (!enabled) {
+            this.enableDeferredIndexedExtension(pluginId);
+            return false;
+        }
+        this.#deferredIndexedExtensions.delete(pluginId);
+        const updatedDiagnostics = this.#communityPluginDiagnostics.get(pluginId);
+        if (updatedDiagnostics) {
+            this.#communityPluginDiagnostics.set(pluginId, {
+                ...updatedDiagnostics,
+                activationTrigger: trigger,
+            });
+        }
+        return true;
+    }
+    shouldDeferManifestActivation(pluginId) {
+        const indexedExtension = this.#lapisExtensionIndex.get(pluginId);
+        return indexedExtension
+            ? this.shouldDeferIndexedExtensionActivation(indexedExtension)
+            : false;
+    }
+    shouldDeferIndexedExtensionActivation(indexedExtension) {
+        if (indexedExtension.classification !== "lapis-extension") {
+            return false;
+        }
+        if (indexedExtension.source === "system") {
+            return this.#systemExtensionPlugins.has(indexedExtension.pluginId);
+        }
+        if (!this.getSelectedRuntimeEntryForIndexedExtension(indexedExtension)) {
+            return false;
+        }
+        const allEvents = this.collectIndexedExtensionActivationEvents(indexedExtension);
+        if (!allEvents.length) {
+            return false;
+        }
+        return indexedExtension.contributions.every((entry) => {
+            if (entry.kind === "configuration") {
+                return true;
+            }
+            return Boolean(activationEventForContribution(indexedExtension.pluginId, entry));
+        });
+    }
+    collectIndexedExtensionActivationEvents(indexedExtension) {
+        const events = new Set(indexedExtension.activationEvents);
+        for (const entry of indexedExtension.contributions) {
+            const event = activationEventForContribution(indexedExtension.pluginId, entry);
+            if (event) {
+                events.add(event);
+            }
+            if (entry.kind === "services") {
+                const contribution = entry.contribution;
+                events.add(`onService:${contribution.service}`);
+            }
+        }
+        return [...events];
+    }
+    syncIndexedExtensionActivation(indexedExtension) {
+        for (const pluginIds of this.#indexedActivationRegistry.values()) {
+            pluginIds.delete(indexedExtension.pluginId);
+        }
+        if (!this.shouldDeferIndexedExtensionActivation(indexedExtension)) {
+            return;
+        }
+        for (const event of this.collectIndexedExtensionActivationEvents(indexedExtension)) {
+            const pluginIds = this.#indexedActivationRegistry.get(event) ?? new Set();
+            pluginIds.add(indexedExtension.pluginId);
+            this.#indexedActivationRegistry.set(event, pluginIds);
+        }
+    }
+    matchingPathActivationEvents(path) {
+        const matches = [];
+        for (const event of this.#indexedActivationRegistry.keys()) {
+            if (!event.startsWith("workspaceContains:")) {
+                if (event.startsWith("onFileSystem:")) {
+                    const pattern = event.slice("onFileSystem:".length);
+                    if (matchesGlob(path, pattern)) {
+                        matches.push(event);
+                    }
+                }
+                continue;
+            }
+            const pattern = event.slice("workspaceContains:".length);
+            if (matchesGlob(path, pattern)) {
+                matches.push(event);
+            }
+        }
+        return matches;
+    }
+    findLanguageIdsForPath(path) {
+        const languageIds = new Set();
+        const fileName = path.split("/").at(-1) ?? path;
+        for (const extension of this.#lapisExtensionIndex.values()) {
+            for (const entry of extension.contributions) {
+                if (entry.kind !== "languages") {
+                    continue;
+                }
+                const contribution = entry.contribution;
+                const normalizedExtensions = (contribution.extensions ?? []).map((it) => (it.startsWith(".") ? it : `.${it}`));
+                if (normalizedExtensions.some((suffix) => path.toLowerCase().endsWith(suffix.toLowerCase())) ||
+                    (contribution.filenames ?? []).includes(fileName)) {
+                    if (typeof contribution.id === "string" && contribution.id) {
+                        languageIds.add(contribution.id);
+                    }
+                }
+            }
+        }
+        return [...languageIds];
+    }
+    instantiateSystemExtensionPlugin(pluginId) {
+        const PluginType = this.#systemExtensionPlugins.get(pluginId);
+        const manifest = this.#systemExtensionManifests.get(pluginId);
+        if (!PluginType || !manifest || this.plugins.has(pluginId)) {
+            return this.plugins.get(pluginId) ?? null;
+        }
+        const plugin = new PluginType(this.app);
+        if (!(plugin instanceof Plugin)) {
+            throw new Error(`System extension ${pluginId} does not extend the Plugin base class`);
+        }
+        plugin.manifest.dir ??= dirname(this.getSystemExtensionManifestPath(undefined, pluginId));
+        this.registerPlugin(plugin, {
+            source: "system",
+            basePath: plugin.manifest.dir,
+            required: this.#lapisExtensionIndex.get(pluginId)?.locked ?? false,
+        });
+        return plugin;
+    }
+    createSystemExtensionManifest(registration) {
+        return {
+            id: registration.manifest.id,
+            name: registration.manifest.name,
+            author: registration.manifest.author ?? "Lapis Notes",
+            version: registration.manifest.version,
+            minAppVersion: registration.manifest.minAppVersion ?? "0.0.0",
+            description: registration.manifest.description ?? "",
+            lapis: {
+                ...registration.manifest.lapis,
+                source: "system",
+                enabledByDefault: registration.enabledByDefault ??
+                    registration.manifest.lapis.enabledByDefault,
+                locked: registration.locked ?? registration.manifest.lapis.locked,
+            },
+        };
+    }
+    getSystemExtensionManifestPath(basePath, pluginId) {
+        if (basePath) {
+            return normalizePath(joinPath(basePath, "manifest.json"));
+        }
+        return `/.lapis/system-extensions/${pluginId}/manifest.json`;
+    }
+    storeSystemExtensionServiceProviders(pluginId, registrations) {
+        const providers = new Map();
+        for (const registration of registrations) {
+            providers.set(createSystemExtensionServiceProviderKey(registration.service, registration.id), registration);
+        }
+        this.#systemExtensionServiceProviders.set(pluginId, providers);
+    }
+    getSystemExtensionServiceProviderRegistration(pluginId, service, providerId) {
+        return (this.#systemExtensionServiceProviders
+            .get(pluginId)
+            ?.get(createSystemExtensionServiceProviderKey(service, providerId)) ??
+            null);
+    }
+    isManifestOnlyLapisExtension(manifest, classification, hasMainJs) {
+        return (classification === "lapis-extension" &&
+            !hasMainJs &&
+            !hasDeclaredLapisRuntimeCode(manifest));
+    }
+    hasIndexedExtensionCodeEntry(indexedExtension) {
+        return (this.getSelectedRuntimeEntryForIndexedExtension(indexedExtension) !== null);
+    }
+    getSelectedCodeEntry(manifest, classification, hasMainJs) {
+        return (this.selectRuntimeEntryForManifest(manifest, {
+            classification,
+            hasMainJs,
+        })?.path ?? null);
+    }
+    getSelectedCommunityModulePath(manifest, pluginPath, classification, hasMainJs) {
+        const entry = this.getSelectedCodeEntry(manifest, classification, hasMainJs);
+        if (!entry) {
+            return null;
+        }
+        if (entry === "main.js") {
+            return joinPath(pluginPath, entry);
+        }
+        return this.resolveValidatedRuntimeEntryPath(manifest.id, pluginPath, entry);
+    }
+    getSelectedLapisRuntimeEntry(manifest) {
+        const selected = this.selectRuntimeEntryForManifest(manifest, {
+            hasMainJs: false,
+            classification: "lapis-extension",
+        });
+        if (selected?.source === "obsidian-main") {
+            return null;
+        }
+        return selected?.path ?? null;
+    }
+    getHostIdForManifest(manifest) {
+        return (this.#communityPluginHost.hostIdForManifest?.(manifest) ??
+            this.#communityPluginHost.id);
+    }
+    getHostIdForIndexedExtension(indexedExtension) {
+        return isSidecarHost(this.#communityPluginHost.id) &&
+            (indexedExtension.runtime?.desktop ||
+                indexedExtension.runtime?.trustedDesktop ||
+                indexedExtension.requestedCapabilities.length)
+            ? this.#communityPluginHost.id
+            : "renderer";
+    }
+    getSelectedRuntimeEntryForManifest(manifest, classification) {
+        return (this.selectRuntimeEntryForManifest(manifest, {
+            classification,
+        })?.path ?? null);
+    }
+    getSelectedRuntimeEntryForIndexedExtension(indexedExtension) {
+        return (this.selectRuntimeEntryForIndexedExtension(indexedExtension)?.path ?? null);
+    }
+    selectRuntimeEntryForManifest(manifest, options = {}) {
+        const classification = options.classification;
+        const requestedHost = this.getRequestedPluginExecutionHost(manifest);
+        return selectPluginRuntimeEntry({
+            manifest,
+            requestedHost,
+            supportsEsm: this.supportsRendererEsm(requestedHost),
+            supportsNodeEsm: false,
+            hasMainJs: options.hasMainJs ?? classification !== "lapis-extension",
+        });
+    }
+    selectRuntimeEntryForIndexedExtension(indexedExtension) {
+        return selectPluginRuntimeEntry({
+            manifest: {
+                id: indexedExtension.pluginId,
+                name: indexedExtension.name ?? indexedExtension.pluginId,
+                author: "",
+                version: "0.0.0",
+                minAppVersion: "0.0.0",
+                description: "",
+                lapis: {
+                    manifestVersion: 1,
+                    runtime: indexedExtension.runtime,
+                },
+            },
+            requestedHost: this.getRequestedPluginExecutionHostForHostId(this.getHostIdForIndexedExtension(indexedExtension)),
+            supportsEsm: this.supportsRendererEsm(this.getRequestedPluginExecutionHostForHostId(this.getHostIdForIndexedExtension(indexedExtension))),
+            supportsNodeEsm: false,
+            hasMainJs: indexedExtension.classification !== "lapis-extension",
+        });
+    }
+    supportsRendererEsm(host) {
+        return Boolean(this.#pluginAssetServer) && host !== "electron-sidecar";
+    }
+    getRequestedPluginExecutionHost(manifest) {
+        return this.getRequestedPluginExecutionHostForHostId(this.getHostIdForManifest(manifest));
+    }
+    getRequestedPluginExecutionHostForHostId(hostId) {
+        if (isSidecarHost(hostId)) {
+            return "electron-sidecar";
+        }
+        return getNativeDesktopBridge()?.capabilities?.["plugin-assets"]?.status ===
+            "available"
+            ? "electron-renderer"
+            : "workspace";
+    }
+    resolveValidatedRuntimeEntryPath(pluginId, pluginPath, runtimeEntry) {
+        const normalizedPluginPath = normalizePath(pluginPath);
+        const normalizedEntry = runtimeEntry.trim();
+        if (!normalizedEntry) {
+            throw new Error(`Plugin ${pluginId} is missing a Lapis runtime entry path`);
+        }
+        if (normalizedEntry.startsWith("/")) {
+            throw new Error(`Plugin ${pluginId} declares absolute Lapis runtime entry ${runtimeEntry}`);
+        }
+        if (!/\.(?:[cm]?js)$/u.test(normalizedEntry)) {
+            throw new Error(`Plugin ${pluginId} declares unsupported Lapis runtime entry ${runtimeEntry}`);
+        }
+        const modulePath = normalizePath(joinPath(normalizedPluginPath, normalizedEntry));
+        if (modulePath === normalizedPluginPath ||
+            !modulePath.startsWith(`${normalizedPluginPath}/`)) {
+            throw new Error(`Plugin ${pluginId} declares Lapis runtime entry ${runtimeEntry} outside the plugin root`);
+        }
+        return modulePath;
+    }
+    async pathExists(path) {
+        try {
+            return await this.adapter.exists(path);
+        }
+        catch (error) {
+            if (isMissingPathError(error)) {
+                return false;
+            }
+            throw error;
+        }
+    }
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return [
+        ...new Set(value.filter((it) => typeof it === "string")),
+    ];
+}
+function matchesGlob(path, pattern) {
+    const normalizedPattern = pattern.trim();
+    if (!normalizedPattern) {
+        return false;
+    }
+    const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const withDoubleStar = escaped.replace(/\*\*/g, "__DOUBLE_STAR__");
+    const regex = new RegExp(`^${withDoubleStar
+        .replace(/\*/g, "[^/]*")
+        .replace(/__DOUBLE_STAR__/g, ".*")
+        .replace(/\?/g, ".")}$`, "u");
+    return regex.test(path);
+}
+function isLanguageServiceId(service) {
+    return ["language-service", "lapis.languageService"].includes(service);
+}
+function scopeLapisProviderId(pluginId, providerId) {
+    const prefix = `${pluginId}:`;
+    return providerId.startsWith(prefix) ? providerId : `${prefix}${providerId}`;
+}
+function createSystemExtensionServiceProviderKey(service, providerId) {
+    return `${service}:${providerId}`;
+}
+function normalizeLanguageServiceCapabilities(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return {
+        diagnostics: value.diagnostics === true,
+        completion: value.completion === true,
+        hover: value.hover === true,
+        definition: value.definition === true,
+        codeActions: value.codeActions === true,
+    };
+}
+function languageServiceRuntimeFromDeclaration(runtime) {
+    switch (runtime) {
+        case "desktop":
+            return "native";
+        case "browserWorker":
+            return "worker";
+        case "workspace":
+        default:
+            return "in-process";
+    }
+}
+function runtimeMatchesHost(runtime, hostId) {
+    if (runtime === hostId) {
+        return true;
+    }
+    if (hostId === "renderer") {
+        return ["renderer", "browser", "pwa", "web"].includes(runtime);
+    }
+    if (isSidecarHost(hostId)) {
+        return [
+            "desktop",
+            "electron",
+            "electron-sidecar",
+            "electron-plugin-sidecar",
+            "plugin-sidecar",
+        ].includes(runtime);
+    }
+    return false;
+}
+function isSidecarHost(hostId) {
+    return [
+        "electron-plugin-sidecar",
+        "plugin-sidecar",
+        "electron-sidecar",
+    ].includes(hostId);
+}
+function hostPlatformMatchesDependencyPlatform(host, platform) {
+    switch (host) {
+        case "electron-sidecar":
+            return platform === "electron-sidecar";
+        case "electron-renderer":
+            return platform === "electron-renderer" || platform === "web";
+        case "workspace":
+        default:
+            return platform === "web" || platform === "electron-renderer";
+    }
+}
+function getPluginAssetUrlMode(url) {
+    if (url.startsWith(`${ELECTRON_PLUGIN_ASSET_SCHEME}://`)) {
+        return "electron";
+    }
+    try {
+        const parsed = new URL(url, "http://lapis.local");
+        if (parsed.pathname.startsWith(`${WEB_PLUGIN_ASSET_ROUTE_PREFIX}/`)) {
+            return "web";
+        }
+    }
+    catch {
+        // Fall through to custom for opaque or host-specific URL shapes.
+    }
+    return "custom";
+}
+function getBareDependencySpecifiersFromSources(moduleSources) {
+    return [
+        ...new Set([...moduleSources.values()].flatMap((source) => scanBarePluginDependencySpecifiers(source))),
+    ].sort();
+}