@lapis-notes/api 0.1.0 → 0.1.2

package/dist/plugin-distribution/schemas.js

@@ -1,6 +1,15 @@
+import { normalizeRegistryCatalogEntry, normalizeRegistryCatalogIndex, normalizeRegistryCatalogDetail, } from "../registry-schema/index.js";
 import { z } from "zod";
 import { PluginDistributionError } from "./errors";
 const isoDate = z.string().datetime({ offset: true });
+const utcDate = z
+    .string()
+    .regex(/^\d{4}-\d{2}-\d{2}$/)
+    .refine((value) => {
+    const parsed = new Date(`${value}T00:00:00.000Z`);
+    return (!Number.isNaN(parsed.valueOf()) &&
+        parsed.toISOString().slice(0, 10) === value);
+});
 const sha256 = z.string().regex(/^[a-fA-F0-9]{64}$/);
 const nonEmpty = z.string().min(1);
 const urlOrRelative = z.string().min(1);
@@ -18,6 +27,11 @@ export const pluginProvenanceSchema = z.enum([
     "development",
 ]);
 export const pluginRegistryChannelSchema = z.enum(["official", "community"]);
+export const pluginCatalogStatusSchema = z.enum([
+    "active",
+    "pending",
+    "revoked",
+]);
 export const pluginPlatformSchema = z.enum(["web", "electron", "desktop"]);
 export const pluginBadgeSchema = z.enum([
     "official",
@@ -43,10 +57,38 @@ export const trustedSigningKeySchema = z.object({
 export const remoteFileReferenceSchema = z
     .object({
     url: urlOrRelative,
+    downloadUrl: urlOrRelative.optional(),
     sha256,
     size: z.number().int().nonnegative().optional(),
 })
     .passthrough();
+export const pluginMarkdownReferenceSchema = z
+    .object({
+    url: httpsUrl,
+    sourceUrl: httpsUrl,
+    sha256,
+    size: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(256 * 1024),
+    mediaType: z.literal("text/markdown"),
+})
+    .passthrough();
+export const pluginCatalogContentSchema = z
+    .object({
+    overview: pluginMarkdownReferenceSchema.optional(),
+    changelog: pluginMarkdownReferenceSchema.optional(),
+})
+    .passthrough();
+export const pluginCatalogLinksSchema = z
+    .object({
+    homepage: httpsUrl.optional(),
+    repository: httpsUrl.optional(),
+    documentation: httpsUrl.optional(),
+    issues: httpsUrl.optional(),
+})
+    .passthrough();
 export const pluginReleaseFileSchema = z
     .object({
     path: nonEmpty,
@@ -149,35 +191,43 @@ export const pluginContributionSummarySchema = z
         .optional(),
 })
     .passthrough();
-export const pluginCatalogEntrySchema = z
+export const pluginCatalogEntrySchema = sharedCatalogSchema(normalizeRegistryCatalogEntry);
+export const pluginCatalogIndexSchema = sharedCatalogSchema(normalizeRegistryCatalogIndex);
+const nonnegativeSafeInteger = z.number().int().nonnegative().safe();
+const pluginDownloadCountsSchema = z.record(nonnegativeSafeInteger);
+const pluginDownloadStatsPluginSchema = z
     .object({
-    id: nonEmpty,
-    name: nonEmpty,
-    description: z.string(),
-    readmeUrl: httpsUrl.optional(),
-    author: nonEmpty,
-    channel: pluginRegistryChannelSchema,
-    latestVersion: nonEmpty,
-    minAppVersion: nonEmpty,
-    platforms: z.array(pluginPlatformSchema).min(1),
-    categories: z.array(nonEmpty),
-    badges: z.array(pluginBadgeSchema).optional(),
-    detail: urlOrRelative,
-    contributes: pluginContributionSummarySchema.optional(),
+    total: nonnegativeSafeInteger,
+    versions: pluginDownloadCountsSchema,
 })
     .passthrough();
-export const pluginCatalogIndexSchema = z
+const pluginDownloadStatsPeriodSchema = z
+    .object({
+    from: utcDate.nullable(),
+    through: utcDate.nullable(),
+    total: nonnegativeSafeInteger,
+    plugins: z.record(pluginDownloadStatsPluginSchema),
+    versions: pluginDownloadCountsSchema,
+    actions: pluginDownloadCountsSchema,
+    platforms: pluginDownloadCountsSchema,
+    os: pluginDownloadCountsSchema,
+})
+    .passthrough();
+export const pluginDownloadStatsSummarySchema = z
     .object({
     schemaVersion: z.literal(1),
     generatedAt: isoDate,
-    registries: z
-        .record(z.object({
-        name: nonEmpty,
-        trustTier: registryTrustTierSchema,
-    }))
-        .optional(),
-    plugins: z.array(pluginCatalogEntrySchema),
-    signatures: z.array(signatureRecordSchema).optional(),
+    dataset: z.literal("lapis_plugin_downloads_v1"),
+    metric: z.literal("approximate_redirect_requests"),
+    trackedSince: utcDate,
+    through: utcDate.nullable(),
+    periods: z
+        .object({
+        lifetime: pluginDownloadStatsPeriodSchema,
+        "7d": pluginDownloadStatsPeriodSchema,
+        "30d": pluginDownloadStatsPeriodSchema,
+    })
+        .passthrough(),
 })
     .passthrough();
 export const pluginRevocationRecordSchema = z.object({
@@ -206,25 +256,7 @@ export const pluginCatalogReleaseSchema = z
     revoked: pluginRevocationRecordSchema.optional(),
 })
     .passthrough();
-export const pluginCatalogDetailSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    id: nonEmpty,
-    name: nonEmpty,
-    description: z.string(),
-    readmeUrl: httpsUrl.optional(),
-    channel: pluginRegistryChannelSchema,
-    owner: z.object({
-        name: nonEmpty,
-        verified: z.boolean().optional(),
-        url: z.string().url().optional(),
-    }),
-    latestVersion: nonEmpty,
-    readme: remoteFileReferenceSchema.optional(),
-    versions: z.record(pluginCatalogReleaseSchema),
-    signatures: z.array(signatureRecordSchema).optional(),
-})
-    .passthrough();
+export const pluginCatalogDetailSchema = sharedCatalogSchema(normalizeRegistryCatalogDetail);
 export const pluginReleaseManifestSchema = z.object({
     schemaVersion: z.literal(1),
     type: z.literal("lapis.plugin.release"),
@@ -269,6 +301,17 @@ export const installedPluginRecordSchema = z
     })),
     runtimeWarnings: z.array(pluginReleaseRuntimeDiagnosticSchema).optional(),
     signature: signatureRecordSchema.optional(),
+    nostrProof: z
+        .object({
+        authorizationEventId: nonEmpty,
+        releaseEventId: nonEmpty,
+        decisionEventId: nonEmpty,
+        manifestSha256: sha256,
+        artifactSha256: sha256,
+        artifactSize: z.number().int().nonnegative(),
+        requiresRelayRefresh: z.boolean(),
+    })
+        .optional(),
     revoked: pluginRevocationRecordSchema.optional(),
     restartRequired: z.boolean().optional(),
 })
@@ -288,6 +331,18 @@ export const installedPluginsStateSchema = z
         .optional(),
 })
     .passthrough();
+export const pluginRegistrySourcePreferenceSchema = z
+    .object({
+    enabled: z.boolean(),
+})
+    .passthrough();
+export const pluginRegistrySourcePreferencesStateSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    updatedAt: isoDate,
+    sources: z.record(pluginRegistrySourcePreferenceSchema),
+})
+    .passthrough();
 export const parsePluginDistributionMetadata = (schema, value) => {
     const result = schema.safeParse(value);
     if (!result.success) {
@@ -297,3 +352,17 @@ export const parsePluginDistributionMetadata = (schema, value) => {
     }
     return result.data;
 };
+function sharedCatalogSchema(normalize) {
+    return z.unknown().transform((value, context) => {
+        try {
+            return normalize(value);
+        }
+        catch (error) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            return z.NEVER;
+        }
+    });
+}

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

@@ -1,14 +1,38 @@
+import type { RegistryCatalogV2Entry, RegistryCatalogV2Detail, RegistryReleaseChangelog } from "../registry-schema/index.js";
 export type PluginProvenance = "bundled" | "official" | "community" | "manual" | "development";
 export type RegistryTrustTier = "official" | "community" | "local";
+export type PluginRegistrySourceKind = "http" | "nostr";
 export interface PluginRegistrySource {
     id: string;
     name: string;
+    /** Omitted by legacy sources and treated as `http`. */
+    kind?: PluginRegistrySourceKind;
     url: string;
+    downloadStatsUrl?: string;
+    relays?: string[];
+    curatorPubkeys?: string[];
+    installQuorum?: number;
     trustTier: RegistryTrustTier;
     enabled: boolean;
     builtin?: boolean;
 }
+export type PluginRegistrySourcePhase = "idle" | "ready" | "degraded" | "error";
+export interface PluginRegistrySourceState {
+    source: PluginRegistrySource;
+    phase: PluginRegistrySourcePhase;
+    installReady: boolean;
+    message?: string;
+}
+export interface PluginRegistrySourcePreference {
+    enabled: boolean;
+}
+export interface PluginRegistrySourcePreferencesState {
+    schemaVersion: 1;
+    updatedAt: string;
+    sources: Record<string, PluginRegistrySourcePreference>;
+}
 export type PluginRegistryChannel = "official" | "community";
+export type PluginCatalogStatus = RegistryCatalogV2Entry["status"];
 export type PluginPlatform = "web" | "electron" | "desktop";
 export type PluginBadge = "official" | "verified" | "community" | "desktop-only" | "requires-trust" | "update-available" | "revoked";
 export interface PluginContributionSummary {
@@ -36,7 +60,7 @@ export interface PluginContributionSummary {
     }>;
 }
 export interface PluginCatalogIndex {
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     generatedAt: string;
     registries?: Record<string, {
         name: string;
@@ -46,47 +70,120 @@ export interface PluginCatalogIndex {
     signatures?: SignatureRecord[];
 }
 export interface PluginCatalogEntry {
+    owner?: RegistryCatalogV2Entry["owner"];
+    appearance?: RegistryCatalogV2Entry["appearance"];
+    authorAvatarUrl?: string;
     id: string;
     name: string;
     description: string;
     readmeUrl?: string;
     author: string;
+    authorUrl?: string;
     channel: PluginRegistryChannel;
+    status?: PluginCatalogStatus;
     latestVersion: string;
     minAppVersion: string;
-    platforms: PluginPlatform[];
+    platforms: string[];
     categories: string[];
-    badges?: PluginBadge[];
+    badges?: string[];
+    latestRelease?: PluginCatalogLatestRelease;
     detail: string;
     contributes?: PluginContributionSummary;
 }
-export interface PluginCatalogDetail {
+export interface PluginCatalogLatestRelease {
+    releasedAt: string;
+    bundleSize: number;
+}
+export interface PluginDownloadStatsPlugin {
+    total: number;
+    versions: Record<string, number>;
+}
+export interface PluginDownloadStatsPeriod {
+    from: string | null;
+    through: string | null;
+    total: number;
+    plugins: Record<string, PluginDownloadStatsPlugin>;
+    versions: Record<string, number>;
+    actions: Record<string, number>;
+    platforms: Record<string, number>;
+    os: Record<string, number>;
+}
+export interface PluginDownloadStatsSummary {
     schemaVersion: 1;
+    generatedAt: string;
+    dataset: "lapis_plugin_downloads_v1";
+    metric: "approximate_redirect_requests";
+    trackedSince: string;
+    through: string | null;
+    periods: {
+        lifetime: PluginDownloadStatsPeriod;
+        "7d": PluginDownloadStatsPeriod;
+        "30d": PluginDownloadStatsPeriod;
+    };
+}
+export interface PluginDownloadCounts {
+    lifetime: number;
+    recent: number;
+}
+export interface PluginCatalogDetail {
+    schemaVersion: 1 | 2;
+    author?: string;
+    authorUrl?: string;
+    authorAvatarUrl?: string;
+    appearance?: RegistryCatalogV2Detail["appearance"];
+    media?: RegistryCatalogV2Detail["media"];
+    gallery?: RegistryCatalogV2Detail["gallery"];
     id: string;
     name: string;
     description: string;
     readmeUrl?: string;
     channel: PluginRegistryChannel;
+    status?: PluginCatalogStatus;
     owner: {
         name: string;
         verified?: boolean;
         url?: string;
     };
     latestVersion: string;
+    license?: string;
+    links?: PluginCatalogLinks;
+    highlights?: string[];
+    content?: PluginCatalogContent;
     readme?: RemoteFileReference;
+    contributes?: PluginContributionSummary;
     versions: Record<string, PluginCatalogRelease>;
     signatures?: SignatureRecord[];
 }
+export interface PluginCatalogLinks {
+    homepage?: string;
+    repository?: string;
+    documentation?: string;
+    issues?: string;
+}
+export interface PluginMarkdownReference {
+    url: string;
+    sourceUrl: string;
+    sha256: string;
+    size: number;
+    mediaType: "text/markdown";
+}
+export interface PluginCatalogContent {
+    overview?: PluginMarkdownReference;
+    changelog?: PluginMarkdownReference;
+}
 export interface PluginCatalogRelease {
+    changelog?: RegistryReleaseChangelog;
+    releasePost?: string;
     version: string;
     minAppVersion: string;
     releasedAt: string;
-    platforms: PluginPlatform[];
+    platforms: string[];
     bundle: RemoteFileReference;
     revoked?: PluginRevocationRecord;
 }
 export interface RemoteFileReference {
     url: string;
+    downloadUrl?: string;
     sha256: string;
     size?: number;
 }
@@ -196,6 +293,20 @@ export interface InstalledPluginRecord {
     }>;
     runtimeWarnings?: PluginReleaseRuntimeDiagnostic[];
     signature?: SignatureRecord;
+    nostrProof?: {
+        authorizationEventId: string;
+        releaseEventId: string;
+        decisionEventId: string;
+        manifestSha256: string;
+        /** Digest and size of the exact inner payload authenticated at installation. */
+        artifactSha256: string;
+        artifactSize: number;
+        /**
+         * Portable proof is valid, but a relay quorum has not checked later
+         * revocations.
+         */
+        requiresRelayRefresh: boolean;
+    };
     revoked?: PluginRevocationRecord;
     restartRequired?: boolean;
     [key: string]: unknown;

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

@@ -0,0 +1,4 @@
+export { createNostrPluginRegistryAdapter } from "./plugin-distribution/nostr-registry-adapter";
+export { DEFAULT_OFFICIAL_PLUGIN_REGISTRY_SOURCE } from "./plugin-distribution/manager";
+export type { PluginRegistrySource } from "./plugin-distribution/types";
+export type { PluginDistributionManager } from "./plugin-distribution/manager";

package/dist/plugin-distribution-host.js

@@ -0,0 +1,2 @@
+export { createNostrPluginRegistryAdapter } from "./plugin-distribution/nostr-registry-adapter";
+export { DEFAULT_OFFICIAL_PLUGIN_REGISTRY_SOURCE } from "./plugin-distribution/manager";

package/dist/plugin-install-progress.js

@@ -67,7 +67,7 @@ export async function withPluginInstallProgress(app, options, action) {
         source: options.source ?? "Plugin registry",
         location: options.location ?? "status",
         cancellable: true,
-        persistOnError: options.persistOnError ?? false,
+        persistOnError: options.persistOnError ?? true,
     }, async (progressHandle, token) => {
         const removeProgressListener = app.pluginDistribution.addProgressListener((event) => {
             if (event.pluginId !== options.pluginId) {

package/dist/plugin-manager.d.ts

@@ -9,6 +9,7 @@ import { type PluginDependencyResolver, type PluginDependencyResolverFactory } f
 import { type PluginAssetServer } from "./plugin-asset-server";
 import type { PluginProvenance } from "./plugin-distribution/types";
 import { EventDispatcher } from "./events";
+import type { SyncHostCapabilities } from "./sync-host";
 export interface PluginLoader {
     pluginsPath: string;
 }
@@ -41,6 +42,8 @@ export interface PluginManagerOptions {
     communityPluginHost?: CommunityPluginExecutionHost;
     createCommunityPluginDependencyResolver?: PluginDependencyResolverFactory;
     pluginAssetServer?: PluginAssetServer;
+    createSyncHostCapabilities?: (pluginId: string, grants: readonly HostedPluginCapability[]) => SyncHostCapabilities;
+    revokeSyncHostCapabilities?: (pluginId: string) => void;
 }
 export interface PluginDataAliasMigration {
     fromPluginId: string;

package/dist/plugin-manager.js

@@ -17,14 +17,11 @@ function formatPluginError(error) {
 }
 function resolvePluginModuleExport(moduleExports) {
     const exportRecord = isRecord(moduleExports) ? moduleExports : {};
-    for (const [, value] of Object.entries(exportRecord)) {
-        if (value === Plugin) {
-            return value;
-        }
+    if (exportRecord.default !== undefined) {
+        return exportRecord.default;
     }
-    return (moduleExports?.default ||
-        Object.values(exportRecord)[0] ||
-        moduleExports);
+    const namedPluginClass = Object.values(exportRecord).find((value) => typeof value === "function" && value.prototype instanceof Plugin);
+    return namedPluginClass ?? Object.values(exportRecord)[0] ?? moduleExports;
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -415,6 +412,8 @@ export class PluginManager extends EventDispatcher {
     #deferredIndexedExtensions = new Map();
     #communityPluginHost;
     #pluginAssetServer;
+    #createSyncHostCapabilities;
+    #revokeSyncHostCapabilities;
     constructor(app, pluginsPath, adapter, options = {}) {
         super();
         this.app = app;
@@ -424,6 +423,8 @@ export class PluginManager extends EventDispatcher {
         const dependencyResolver = options.createCommunityPluginDependencyResolver?.(this.dependencies) ??
             this.dependencies;
         this.#pluginAssetServer = options.pluginAssetServer;
+        this.#createSyncHostCapabilities = options.createSyncHostCapabilities;
+        this.#revokeSyncHostCapabilities = options.revokeSyncHostCapabilities;
         const commonJsHost = options.communityPluginHost ??
             new RendererCommunityPluginExecutionHost(adapter, dependencyResolver);
         this.#communityPluginHost = options.pluginAssetServer
@@ -1144,6 +1145,12 @@ export class PluginManager extends EventDispatcher {
         if (this.plugins.has(plugin.manifest.id)) {
             throw new Error(`Plugin id ${plugin.manifest.id} is already registered`);
         }
+        const grantedCapabilities = isExternalPluginSource(options.source)
+            ? this.getGrantedCapabilities(plugin.manifest)
+            : options.source === "system"
+                ? (this.#lapisExtensionIndex.get(plugin.manifest.id)
+                    ?.grantedCapabilities ?? [])
+                : (plugin.manifest.requiredCapabilities ?? []).filter((capability) => typeof capability === "string");
         plugin.configureRuntime({
             source: options.source,
             provenance: options.provenance,
@@ -1176,12 +1183,13 @@ export class PluginManager extends EventDispatcher {
                     ? (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 ?? [])
-                    : [],
+            grantedCapabilities,
+            createSyncHostCapabilities: this.#createSyncHostCapabilities
+                ? () => this.#createSyncHostCapabilities(plugin.manifest.id, grantedCapabilities)
+                : undefined,
+            revokeSyncHostCapabilities: this.#revokeSyncHostCapabilities
+                ? () => this.#revokeSyncHostCapabilities(plugin.manifest.id)
+                : undefined,
         });
         this.plugins.set(plugin.manifest.id, plugin);
         if (isExternalPluginSource(options.source) ||

package/dist/plugin-settings.d.ts

@@ -0,0 +1,21 @@
+import { type WorkspaceActionResult, type WorkspaceActionSetting, type WorkspaceCustomFieldAdapter, type WorkspaceCustomSetting, type WorkspaceCustomSettingProps, type WorkspaceObjectCollectionSetting, type WorkspaceObjectProperty, type WorkspaceObjectRowAction, type WorkspaceOutputSetting, type WorkspaceSettingField, type WorkspaceSettingsDefinition, type WorkspaceSettingsSection, type WorkspaceSettingsSource } from "@lapismd/design-core/workspace/settings";
+import type { App } from "./context.svelte";
+import type { Plugin } from "./plugin";
+import { PluginSettingTab } from "./settings.svelte";
+export type PluginSettingsDefinition = WorkspaceSettingsDefinition;
+export interface PluginSettingsRegistration {
+    readonly definition: PluginSettingsDefinition;
+    open(fieldId?: string): boolean;
+    dispose(): void;
+}
+export type { WorkspaceActionResult, WorkspaceActionSetting, WorkspaceCustomFieldAdapter, WorkspaceCustomSetting, WorkspaceCustomSettingProps, WorkspaceObjectCollectionSetting, WorkspaceObjectProperty, WorkspaceObjectRowAction, WorkspaceOutputSetting, WorkspaceSettingField, WorkspaceSettingsSection, WorkspaceSettingsSource, };
+/**
+ * Compatibility settings tab backed by the same controlled definition as the
+ * Workspace Settings surface.
+ */
+export declare class DeclarativePluginSettingTab extends PluginSettingTab {
+    #private;
+    constructor(app: App, plugin: Plugin, definition: PluginSettingsDefinition);
+    display(): void;
+    hide(): void;
+}

package/dist/plugin-settings.js

@@ -0,0 +1,41 @@
+import { DeclarativeSettingsSection, WorkspaceSettingsController, } from "@lapismd/design-core/workspace/settings";
+import { mount, unmount } from "svelte";
+import { PluginSettingTab } from "./settings.svelte";
+/**
+ * Compatibility settings tab backed by the same controlled definition as the
+ * Workspace Settings surface.
+ */
+export class DeclarativePluginSettingTab extends PluginSettingTab {
+    #definition;
+    #component = null;
+    #controller = null;
+    constructor(app, plugin, definition) {
+        super(app, plugin);
+        this.#definition = definition;
+    }
+    display() {
+        this.#disposeRenderer();
+        this.containerEl.empty();
+        const controller = new WorkspaceSettingsController();
+        controller.registerDefinition(this.#definition);
+        this.#controller = controller;
+        this.#component = mount(DeclarativeSettingsSection, {
+            target: this.containerEl,
+            props: {
+                controller,
+                section: this.#definition.section,
+                class: "ui-workspace-settings--legacy-tab",
+            },
+        });
+    }
+    hide() {
+        this.#disposeRenderer();
+    }
+    #disposeRenderer() {
+        if (this.#component)
+            void unmount(this.#component);
+        this.#component = null;
+        this.#controller?.destroy();
+        this.#controller = null;
+    }
+}

package/dist/plugin.d.ts

@@ -8,11 +8,13 @@ import type { LapisExtensionContributions, LapisExtensionKind, LapisExtensionMan
 import type { EditorViewContribution } from "./editor-view-registry";
 import type { ConfigurationOptionSourceProvider, ConfigurationOptionSourceRegistration } from "./configuration-option-source-registry";
 import type { HostedPluginCapability } from "./plugin-capability-facade";
+import type { SyncHostCapabilities } from "./sync-host";
 import type { MarkdownDirectiveRenderer, MarkdownPostProcessor, MarkdownPostProcessorContext, MarkdownViewMenuItemProvider } from "./markdown";
 import type { MarkdownExtensionContribution } from "./markdown-extension-registry";
 import type { MarkdownFileSurfaceProvider } from "./markdown-file-surface-registry";
 import type { TypeWidget } from "./metadata.svelte";
 import type { PluginSettingTab } from "./settings.svelte";
+import type { PluginSettingsDefinition, PluginSettingsRegistration } from "./plugin-settings";
 import type { EditorSuggest } from "./suggest";
 import type { TelemetryAttributes, TelemetryMeasurementOptions, TelemetrySpan, TelemetrySpanOptions } from "./telemetry";
 import type { PluginProvenance } from "./plugin-distribution/types";
@@ -168,6 +170,8 @@ export interface PluginRuntimeOptions {
     hostMode?: string;
     requestedCapabilities?: HostedPluginCapability[];
     grantedCapabilities?: HostedPluginCapability[];
+    createSyncHostCapabilities?: () => SyncHostCapabilities;
+    revokeSyncHostCapabilities?: () => void;
 }
 /**
  * Base class for Lapis plugins.
@@ -224,6 +228,8 @@ export declare abstract class Plugin extends Component {
     get requestedCapabilities(): HostedPluginCapability[];
     get grantedCapabilities(): HostedPluginCapability[];
     get id(): string;
+    /** Host-authenticated durable capabilities for sync and similar plugins. */
+    get syncHost(): SyncHostCapabilities;
     private getDataPath;
     private readLegacyData;
     private writeLegacyData;
@@ -347,4 +353,11 @@ export declare abstract class Plugin extends Component {
      * @see {@link https://docs.obsidian.md/Plugins/User+interface/Settings#Register+a+settings+tab}
      */
     addSettingTab(settingTab: PluginSettingTab): void;
+    /**
+     * Register one controlled declarative settings definition with Workspace
+     * Settings. Source-backed values remain owned by the plugin.
+     *
+     * @public
+     */
+    registerSettingsSection(definition: PluginSettingsDefinition): PluginSettingsRegistration;
 }