@lapis-notes/api 0.1.4 → 0.2.1

package/dist/plugin-distribution/compatibility.js

@@ -1,15 +1,20 @@
-export const checkCatalogEntryCompatibility = (entry, input) => checkBaseCompatibility(entry.minAppVersion, entry.platforms, false, false, false, input);
-export const checkCatalogReleaseCompatibility = (release, input) => checkBaseCompatibility(release.minAppVersion, release.platforms, false, false, Boolean(release.revoked), input);
-export const checkReleaseManifestCompatibility = (manifest, input) => checkBaseCompatibility(manifest.compatibility.minAppVersion, manifest.compatibility.platforms, Boolean(manifest.compatibility.desktopOnly), Boolean(manifest.compatibility.requiresWorkspaceTrust), Boolean(manifest.revoked), input);
-const checkBaseCompatibility = (minAppVersion, platforms, desktopOnly, requiresWorkspaceTrust, revoked, input) => {
+export const checkCatalogEntryCompatibility = (entry, input) => checkBaseCompatibility(entry.id, entry.minAppVersion, entry.platforms, false, false, false, input);
+export const checkCatalogReleaseCompatibility = (release, input, pluginId = "") => checkBaseCompatibility(pluginId, release.minAppVersion, release.platforms, false, false, Boolean(release.revoked), input);
+export const checkReleaseManifestCompatibility = (manifest, input) => checkBaseCompatibility(manifest.pluginId, manifest.compatibility.minAppVersion, manifest.compatibility.platforms, Boolean(manifest.compatibility.desktopOnly), Boolean(manifest.compatibility.requiresWorkspaceTrust), Boolean(manifest.revoked), input);
+const checkBaseCompatibility = (pluginId, minAppVersion, platforms, desktopOnly, requiresWorkspaceTrust, revoked, input) => {
     const reasons = [];
+    if (Object.hasOwn(input.unavailablePlugins ?? {}, pluginId)) {
+        reasons.push(input.unavailablePlugins[pluginId]);
+    }
     if (compareVersions(input.appVersion, minAppVersion) < 0) {
         reasons.push("app-version-too-old");
     }
     if (!platforms.includes(input.platform)) {
         reasons.push("platform-unsupported");
     }
-    if (desktopOnly && input.platform === "web") {
+    if (desktopOnly &&
+        input.platform === "web" &&
+        !reasons.includes("desktop-only")) {
         reasons.push("desktop-only");
     }
     if (requiresWorkspaceTrust && !input.workspaceTrusted) {

package/dist/plugin-distribution/installed-plugin-state.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "../storage/path";
 import { dirname } from "../storage/path";
 import { installedPluginsStateSchema, parsePluginDistributionMetadata, } from "./schemas";
 export class InstalledPluginStateStore {
@@ -57,7 +58,7 @@ export class InstalledPluginStateStore {
         };
     }
     get path() {
-        return this.options.path ?? ".obsidian/installed-plugins.json";
+        return this.options.path ?? appStatePath("installed-plugins.json");
     }
     now() {
         return (this.options.now?.() ?? new Date()).toISOString();

package/dist/plugin-distribution/installer.d.ts

@@ -19,6 +19,12 @@ export interface PluginInstallerProgressEvent {
     fileCount?: number;
 }
 export interface PluginInstallerManager {
+    unloadPlugin?(pluginId: string): Promise<boolean>;
+    isStaticPlugin?(pluginId: string): boolean;
+    preparePluginReplacement?(pluginId: string): Promise<{
+        reloadRequired: boolean;
+        rollback(): Promise<void>;
+    } | undefined>;
     loadPlugin?(pluginPath: string, options?: {
         provenance?: PluginProvenance;
     }): Promise<unknown>;

package/dist/plugin-distribution/installer.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "../storage/path";
 import { basename, dirname, joinPath } from "../storage/path";
 import { checkReleaseManifestCompatibility } from "./compatibility";
 import { PluginDistributionError } from "./errors";
@@ -64,7 +65,15 @@ export class VerifiedPluginInstaller {
         });
     }
     async uninstall(pluginId, options = {}) {
-        await this.options.pluginManager?.disablePlugin?.(pluginId);
+        const manager = this.options.pluginManager;
+        if (!manager?.isStaticPlugin?.(pluginId)) {
+            if (manager?.unloadPlugin) {
+                if (!(await manager.unloadPlugin(pluginId)))
+                    throw new Error(`Plugin ${pluginId} cleanup failed; uninstall was cancelled.`);
+            }
+            else
+                await manager?.disablePlugin?.(pluginId);
+        }
         const pluginPath = joinPath(this.pluginsPath, pluginId);
         if (options.removeData) {
             await this.removeIfExists(pluginPath);
@@ -140,6 +149,9 @@ export class VerifiedPluginInstaller {
     }
     async installVerifiedBundlePayload(payload, options) {
         const { releaseEnvelope, releaseManifest, releaseManifestSha256, files, nostrProof, } = payload;
+        if (this.options.pluginManager?.isStaticPlugin?.(releaseManifest.pluginId)) {
+            throw new PluginDistributionError("reserved-id", `Plugin ${releaseManifest.pluginId} is registered by the application.`);
+        }
         if (options.compatibility) {
             const compatibility = checkReleaseManifestCompatibility(releaseManifest, options.compatibility);
             if (!compatibility.compatible) {
@@ -170,36 +182,12 @@ export class VerifiedPluginInstaller {
         }
         const stagingPath = joinPath(this.pluginsPath, ".installing", `${releaseManifest.pluginId}-${Date.now()}`);
         const finalPath = joinPath(this.pluginsPath, releaseManifest.pluginId);
-        try {
-            throwIfAborted(options.signal);
-            options.onProgress?.({
-                phase: "staging",
-                message: "Staging plugin files",
-                processedBytes: 0,
-                totalBytes: totalFileBytes(files),
-            });
-            await this.writeStagingFiles(stagingPath, files, {
-                signal: options.signal,
-                onProgress: options.onProgress,
-            });
-            options.onProgress?.({
-                phase: "installing",
-                message: "Installing plugin files",
-            });
-            await this.swapIntoPlace(stagingPath, finalPath);
-        }
-        catch (error) {
-            await this.removeIfExists(stagingPath);
-            if (!(await this.options.adapter.exists(finalPath))) {
-                await this.removeIfExists(finalPath);
-            }
-            throw error;
-        }
+        const previousRecord = await this.stateStore.get(releaseManifest.pluginId);
         const now = this.now();
         const record = {
             pluginId: releaseManifest.pluginId,
             installedVersion: releaseManifest.version,
-            installedAt: now,
+            installedAt: previousRecord?.installedAt ?? now,
             updatedAt: now,
             provenance,
             registryId: options.registryId,
@@ -219,22 +207,70 @@ export class VerifiedPluginInstaller {
             ...(nostrProof ? { nostrProof } : {}),
             restartRequired: Boolean(this.options.pluginManager),
         };
-        await this.stateStore.upsert(record);
+        let replacement;
+        try {
+            throwIfAborted(options.signal);
+            options.onProgress?.({
+                phase: "staging",
+                message: "Staging plugin files",
+                processedBytes: 0,
+                totalBytes: totalFileBytes(files),
+            });
+            await this.writeStagingFiles(stagingPath, files, {
+                signal: options.signal,
+                onProgress: options.onProgress,
+            });
+            if (await this.options.adapter.exists(finalPath)) {
+                replacement =
+                    await this.options.pluginManager?.preparePluginReplacement?.(releaseManifest.pluginId);
+                // Read after teardown so its final save wins over release defaults.
+                const dataPath = joinPath(finalPath, "data.json");
+                if (await this.options.adapter.exists(dataPath)) {
+                    await this.options.adapter.writeBinary(joinPath(stagingPath, "data.json"), await this.options.adapter.readBinary(dataPath));
+                }
+            }
+            options.onProgress?.({
+                phase: "installing",
+                message: "Installing plugin files",
+            });
+            throwIfAborted(options.signal);
+            await this.swapIntoPlace(stagingPath, finalPath, {
+                publish: () => this.stateStore.upsert(record),
+                rollback: async () => {
+                    if (previousRecord)
+                        await this.stateStore.upsert(previousRecord);
+                    else
+                        await this.stateStore.remove(releaseManifest.pluginId);
+                },
+            });
+        }
+        catch (error) {
+            try {
+                await this.removeIfExists(stagingPath);
+            }
+            finally {
+                await replacement?.rollback();
+            }
+            throw error;
+        }
         if (this.options.pluginManager?.loadPlugin) {
             options.onProgress?.({
                 phase: "loading",
                 message: "Loading installed plugin",
             });
         }
-        const loaded = await this.options.pluginManager?.loadPlugin?.(finalPath, {
-            provenance,
-        });
+        const loaded = replacement?.reloadRequired
+            ? null
+            : await this.options.pluginManager?.loadPlugin?.(finalPath, {
+                provenance,
+            });
         const shouldEnable = options.enable ?? true;
         const diagnostics = this.options.pluginManager?.getCommunityPluginDiagnostics?.(releaseManifest.pluginId) ?? null;
         const cleanDormantExtension = diagnostics?.state === "dormant" &&
             (diagnostics.lastFailureMessage ?? null) === null;
         let enabled = false;
         if (shouldEnable &&
+            !replacement?.reloadRequired &&
             (loaded || cleanDormantExtension) &&
             this.options.pluginManager?.enablePlugin) {
             options.onProgress?.({
@@ -243,7 +279,8 @@ export class VerifiedPluginInstaller {
             });
             enabled = await this.options.pluginManager.enablePlugin(releaseManifest.pluginId);
         }
-        record.restartRequired = Boolean(this.options.pluginManager && !loaded && !enabled);
+        record.restartRequired = Boolean(this.options.pluginManager &&
+            (replacement?.reloadRequired || (!loaded && !enabled)));
         await this.stateStore.upsert(record);
         return record;
     }
@@ -332,24 +369,40 @@ export class VerifiedPluginInstaller {
             });
         }
     }
-    async swapIntoPlace(stagingPath, finalPath) {
+    async swapIntoPlace(stagingPath, finalPath, metadata) {
         await ensureFolder(this.options.adapter, this.pluginsPath);
         const backupPath = joinPath(this.pluginsPath, ".installing", `${basename(finalPath)}-backup-${Date.now()}`);
         const hadExisting = await this.options.adapter.exists(finalPath);
         if (hadExisting) {
             await this.options.adapter.rename(finalPath, backupPath);
         }
+        let moved = false;
+        let publishingMetadata = false;
         try {
             await this.options.adapter.rename(stagingPath, finalPath);
-            if (hadExisting)
-                await this.removeIfExists(backupPath);
+            moved = true;
+            publishingMetadata = true;
+            await metadata.publish();
         }
         catch (error) {
+            if (moved)
+                await this.removeIfExists(finalPath);
             if (hadExisting && !(await this.options.adapter.exists(finalPath))) {
                 await this.options.adapter.rename(backupPath, finalPath);
             }
+            if (publishingMetadata)
+                await metadata.rollback();
             throw error;
         }
+        // Code and metadata are committed. Cleanup cannot reactivate the old module.
+        if (hadExisting) {
+            try {
+                await this.removeIfExists(backupPath);
+            }
+            catch (error) {
+                console.warn(`Could not remove plugin backup ${backupPath}`, error);
+            }
+        }
     }
     async removePluginCodeButKeepData(pluginPath) {
         if (!(await this.options.adapter.exists(pluginPath)))
@@ -365,7 +418,7 @@ export class VerifiedPluginInstaller {
         }
     }
     async removeCommunityPluginEnabledState(pluginId) {
-        const enabledPath = ".obsidian/community-plugins.json";
+        const enabledPath = appStatePath("community-plugins.json");
         try {
             const enabled = JSON.parse(await this.options.adapter.read(enabledPath));
             if (!Array.isArray(enabled))
@@ -388,7 +441,7 @@ export class VerifiedPluginInstaller {
         }
     }
     get pluginsPath() {
-        return this.options.pluginsPath ?? ".obsidian/plugins";
+        return this.options.pluginsPath ?? appStatePath("plugins");
     }
     now() {
         return (this.options.now?.() ?? new Date()).toISOString();

package/dist/plugin-distribution/manager.d.ts

@@ -4,7 +4,7 @@ import { type PluginBinaryFetch, type PluginInstallerManager } from "./installer
 import type { PluginBundleVerificationMode } from "./plugin-bundle-worker";
 import { type ParsedNostrPluginBundle } from "./plugin-bundle";
 import type { VerifiedPluginBundlePayload } from "./plugin-bundle-verifier";
-import type { InstalledPluginRecord, PluginCatalogDetail, PluginCatalogEntry, PluginCatalogIndex, PluginCompatibilityResult, PluginDownloadStatsSummary, PluginPlatform, PluginProvenance, PluginRegistryChannel, PluginRevocationIndex, PluginRevocationRecord, PluginRegistrySource, PluginRegistrySourceKind, PluginRegistrySourceState, TrustedSigningKey } from "./types";
+import type { InstalledPluginRecord, PluginCatalogDetail, PluginCatalogEntry, PluginCatalogIndex, PluginCompatibilityInput, PluginCompatibilityResult, PluginDownloadStatsSummary, PluginPlatform, PluginProvenance, PluginRegistryChannel, PluginRevocationIndex, PluginRevocationRecord, PluginRegistrySource, PluginRegistrySourceKind, PluginRegistrySourceState, TrustedSigningKey } from "./types";
 export type PluginInstallPhase = "resolving" | "fetching-catalog" | "fetching-release" | "verifying-signature" | "downloading-bundle" | "verifying-bundle" | "extracting-files" | "verifying-files" | "staging" | "installing" | "loading" | "enabling" | "complete" | "failed";
 export interface PluginInstallProgressEvent {
     pluginId: string;
@@ -73,6 +73,7 @@ export interface PluginDistributionManager {
     setSourceEnabled(sourceId: string, enabled: boolean): Promise<void>;
     search(query?: PluginSearchQuery): PluginCatalogEntry[];
     getCatalogEntry(pluginId: string): PluginCatalogEntry | undefined;
+    getCompatibility?(pluginId: string): PluginCompatibilityResult | null;
     getPluginDetail(pluginId: string, options?: {
         registryId?: string;
     }): Promise<PluginCatalogDetail | null>;
@@ -122,6 +123,7 @@ export interface DefaultPluginDistributionManagerOptions {
     adapter: DataAdapter;
     appVersion: string;
     platform?: PluginPlatform;
+    unavailablePlugins?: PluginCompatibilityInput["unavailablePlugins"];
     workspaceTrusted?: () => Promise<boolean> | boolean;
     registries?: PluginRegistrySource[];
     trustedKeys?: TrustedSigningKey[];
@@ -162,6 +164,7 @@ export declare class DefaultPluginDistributionManager extends EventDispatcher<{
     setSourceEnabled(sourceId: string, enabled: boolean): Promise<void>;
     search(query?: PluginSearchQuery): PluginCatalogEntry[];
     getCatalogEntry(pluginId: string): PluginCatalogEntry | undefined;
+    getCompatibility(pluginId: string): PluginCompatibilityResult | null;
     getPluginDetail(pluginId: string, options?: {
         registryId?: string;
     }): Promise<PluginCatalogDetail | null>;

package/dist/plugin-distribution/manager.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "../storage/path";
 import { EventDispatcher } from "../events";
 import { hasNativeDesktopCapability } from "../storage/desktop-native";
 import { checkCatalogEntryCompatibility, checkCatalogReleaseCompatibility, compareVersions, } from "./compatibility";
@@ -236,8 +237,7 @@ export class DefaultPluginDistributionManager extends EventDispatcher {
                 return false;
             }
             if (query.compatibleOnly) {
-                const compatibility = checkCatalogEntryCompatibility(entry, this.compatibilityInput(false));
-                if (!compatibility.compatible)
+                if (!this.getCompatibility(entry.id)?.compatible)
                     return false;
             }
             return true;
@@ -246,6 +246,12 @@ export class DefaultPluginDistributionManager extends EventDispatcher {
     getCatalogEntry(pluginId) {
         return this.catalog?.plugins.find((entry) => entry.id === pluginId);
     }
+    getCompatibility(pluginId) {
+        const entry = this.getCatalogEntry(pluginId);
+        return entry
+            ? checkCatalogEntryCompatibility(entry, this.compatibilityInput(false))
+            : null;
+    }
     async getPluginDetail(pluginId, options = {}) {
         const entry = this.entryForSource(pluginId, options.registryId);
         if (!entry)
@@ -284,7 +290,7 @@ export class DefaultPluginDistributionManager extends EventDispatcher {
             if (!release) {
                 throw new PluginDistributionError("metadata-invalid", `Plugin ${pluginId} has no requested release.`);
             }
-            const releaseCompatibility = checkCatalogReleaseCompatibility(release, this.compatibilityInput(false));
+            const releaseCompatibility = checkCatalogReleaseCompatibility(release, this.compatibilityInput(false), pluginId);
             if (!releaseCompatibility.compatible) {
                 throw new PluginDistributionError("compatibility-failed", `Plugin ${pluginId} release is not compatible: ${releaseCompatibility.reasons.join(", ")}`, { details: { reasons: releaseCompatibility.reasons } });
             }
@@ -488,7 +494,7 @@ export class DefaultPluginDistributionManager extends EventDispatcher {
             });
             const targetRelease = detail?.versions[targetVersion];
             if (targetRelease) {
-                compatibility = checkCatalogReleaseCompatibility(targetRelease, this.compatibilityInput(false));
+                compatibility = checkCatalogReleaseCompatibility(targetRelease, this.compatibilityInput(false), record.pluginId);
             }
             const canUpdate = hasNewerTarget && compatibility.compatible;
             const update = {
@@ -528,7 +534,7 @@ export class DefaultPluginDistributionManager extends EventDispatcher {
                 fetch: this.options.fetch,
                 cache: new PluginRegistryCache({
                     adapter: this.options.adapter,
-                    cachePath: `.obsidian/plugin-registry-cache/${encodeURIComponent(source.id)}/${encodeURIComponent(source.url)}.json`,
+                    cachePath: appStatePath(`plugin-registry-cache/${encodeURIComponent(source.id)}/${encodeURIComponent(source.url)}.json`),
                 }),
             });
             this.httpClients.set(key, client);
@@ -580,6 +586,7 @@ export class DefaultPluginDistributionManager extends EventDispatcher {
             appVersion: this.options.appVersion,
             platform: this.platform,
             workspaceTrusted,
+            unavailablePlugins: this.options.unavailablePlugins,
         };
     }
     get platform() {

package/dist/plugin-distribution/registry-cache.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "../storage/path";
 import { pluginCatalogDetailSchema, pluginCatalogIndexSchema, pluginRevocationIndexSchema, parsePluginDistributionMetadata, } from "./schemas";
 export class PluginRegistryCache {
     options;
@@ -68,7 +69,7 @@ export class PluginRegistryCache {
         return this.write(existing.sourceUrl, existing.index, existing.details, revocations);
     }
     get cachePath() {
-        return this.options.cachePath ?? ".obsidian/plugin-registry-cache.json";
+        return this.options.cachePath ?? appStatePath("plugin-registry-cache.json");
     }
     get cacheFolder() {
         const parts = this.cachePath.split("/");

package/dist/plugin-distribution/registry-source-state.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "../storage/path";
 import { dirname } from "../storage/path";
 import { ensureFolder } from "./installed-plugin-state";
 import { parsePluginDistributionMetadata, pluginRegistrySourcePreferencesStateSchema, } from "./schemas";
@@ -34,7 +35,7 @@ export class PluginRegistrySourcePreferenceStore {
         };
     }
     get path() {
-        return this.options.path ?? ".obsidian/plugin-registry-sources.json";
+        return this.options.path ?? appStatePath("plugin-registry-sources.json");
     }
     now() {
         return (this.options.now?.() ?? new Date()).toISOString();

package/dist/plugin-distribution/schemas.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v3";
 export declare const registryTrustTierSchema: z.ZodEnum<["official", "community", "local"]>;
 export declare const pluginProvenanceSchema: z.ZodEnum<["bundled", "official", "community", "manual", "development"]>;
 export declare const pluginRegistryChannelSchema: z.ZodEnum<["official", "community"]>;
@@ -28,13 +28,13 @@ export declare const trustedSigningKeySchema: z.ZodObject<{
     publicKey: string;
     keyId: string;
     alg: "ed25519";
-    trustTier: "community" | "official" | "local";
+    trustTier: "local" | "community" | "official";
     expiresAt?: string | undefined;
 }, {
     publicKey: string;
     keyId: string;
     alg: "ed25519";
-    trustTier: "community" | "official" | "local";
+    trustTier: "local" | "community" | "official";
     expiresAt?: string | undefined;
 }>;
 export declare const remoteFileReferenceSchema: z.ZodObject<{
@@ -524,16 +524,19 @@ export declare const pluginContributionSummarySchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>, "many">>;
     editorViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -581,16 +584,19 @@ export declare const pluginContributionSummarySchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>, "many">>;
     editorViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -638,16 +644,19 @@ export declare const pluginContributionSummarySchema: z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>, "many">>;
     editorViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         id: z.ZodString;
+        fileIcon: z.ZodOptional<z.ZodString>;
         filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         extensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         mimeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -687,12 +696,12 @@ export declare const pluginCatalogEntrySchema: z.ZodEffects<z.ZodUnknown, {
     description: string;
     name: string;
     status: "active" | "pending" | "disabled" | "deprecated" | "revoked";
+    id: string;
     owner: {
         name: string;
         verified: boolean;
         url?: string | undefined;
     };
-    id: string;
     author: string;
     badges: string[];
     minAppVersion: string;
@@ -756,14 +765,17 @@ export declare const pluginCatalogEntrySchema: z.ZodEffects<z.ZodUnknown, {
     contributes?: z.objectOutputType<{
         editorViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
+            fileIcon: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
             id: z.ZodString;
+            fileIcon: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
             id: z.ZodString;
+            fileIcon: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, z.ZodTypeAny, "passthrough">>, "many">>;
@@ -782,12 +794,12 @@ export declare const pluginCatalogIndexSchema: z.ZodEffects<z.ZodUnknown, {
         description: string;
         name: string;
         status: "active" | "pending" | "disabled" | "deprecated" | "revoked";
+        id: string;
         owner: {
             name: string;
             verified: boolean;
             url?: string | undefined;
         };
-        id: string;
         author: string;
         badges: string[];
         minAppVersion: string;
@@ -851,14 +863,17 @@ export declare const pluginCatalogIndexSchema: z.ZodEffects<z.ZodUnknown, {
         contributes?: z.objectOutputType<{
             editorViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
+                fileIcon: z.ZodOptional<z.ZodString>;
                 label: z.ZodOptional<z.ZodString>;
                 filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
                 id: z.ZodString;
+                fileIcon: z.ZodOptional<z.ZodString>;
                 label: z.ZodOptional<z.ZodString>;
                 filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
                 id: z.ZodString;
+                fileIcon: z.ZodOptional<z.ZodString>;
                 label: z.ZodOptional<z.ZodString>;
                 filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, z.ZodTypeAny, "passthrough">>, "many">>;
@@ -2617,6 +2632,7 @@ export declare const pluginCatalogDetailSchema: z.ZodEffects<z.ZodUnknown, {
     description: string;
     name: string;
     status: "active" | "pending" | "disabled" | "deprecated" | "revoked";
+    id: string;
     versions: Record<string, {
         version: string;
         bundle: {
@@ -2641,7 +2657,6 @@ export declare const pluginCatalogDetailSchema: z.ZodEffects<z.ZodUnknown, {
         verified: boolean;
         url?: string | undefined;
     };
-    id: string;
     schemaVersion: 2;
     author: string;
     channel: "community" | "official";
@@ -2827,14 +2842,17 @@ export declare const pluginCatalogDetailSchema: z.ZodEffects<z.ZodUnknown, {
     contributes?: z.objectOutputType<{
         editorViews: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
+            fileIcon: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
             id: z.ZodString;
+            fileIcon: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
             id: z.ZodString;
+            fileIcon: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             filenamePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, z.ZodTypeAny, "passthrough">>, "many">>;
@@ -3107,8 +3125,8 @@ export declare const pluginReleaseManifestSchema: z.ZodObject<{
         size: z.ZodNumber;
     }, z.ZodTypeAny, "passthrough">[];
     type: "lapis.plugin.release";
-    schemaVersion: 1;
     version: string;
+    schemaVersion: 1;
     pluginId: string;
     channel: "community" | "official";
     compatibility: {
@@ -3200,8 +3218,8 @@ export declare const pluginReleaseManifestSchema: z.ZodObject<{
         size: z.ZodNumber;
     }, z.ZodTypeAny, "passthrough">[];
     type: "lapis.plugin.release";
-    schemaVersion: 1;
     version: string;
+    schemaVersion: 1;
     pluginId: string;
     channel: "community" | "official";
     compatibility: {

package/dist/plugin-distribution/schemas.js

@@ -1,5 +1,5 @@
 import { normalizeRegistryCatalogEntry, normalizeRegistryCatalogIndex, normalizeRegistryCatalogDetail, } from "../registry-schema/index.js";
-import { z } from "zod";
+import { z } from "zod/v3";
 import { PluginDistributionError } from "./errors";
 const isoDate = z.string().datetime({ offset: true });
 const utcDate = z
@@ -174,6 +174,7 @@ export const pluginContributionSummarySchema = z
         .array(z
         .object({
         id: nonEmpty,
+        fileIcon: z.string().optional(),
         filenamePatterns: z.array(nonEmpty).optional(),
         extensions: z.array(nonEmpty).optional(),
         mimeTypes: z.array(nonEmpty).optional(),

package/dist/plugin-distribution/types.d.ts

@@ -42,6 +42,7 @@ export interface PluginContributionSummary {
     }>;
     editorViews?: Array<{
         id: string;
+        fileIcon?: string;
         filenamePatterns?: string[];
         extensions?: string[];
         mimeTypes?: string[];
@@ -321,7 +322,10 @@ export interface PluginCompatibilityInput {
     appVersion: string;
     platform: PluginPlatform;
     workspaceTrusted?: boolean;
+    unavailablePlugins?: PluginHostRestrictions;
 }
+/** App-owned exclusions override older manifests' compatibility claims. */
+export type PluginHostRestrictions = Readonly<Record<string, "desktop-only" | "platform-unsupported">>;
 export interface PluginCompatibilityResult {
     compatible: boolean;
     reasons: Array<"app-version-too-old" | "platform-unsupported" | "desktop-only" | "workspace-trust-required" | "revoked">;