@lapis-notes/api 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @lapis-notes/api
 
+## 0.1.1
+
+### Patch Changes
+
+- Own the transport-neutral registry schema and portable Turso build helper,
+  removing the Community dependency from static registry producers and hosts.
+
+- Expose host-owned secure sync capabilities and controlled declarative plugin settings.
+
+- Allow indexed consumers to select metadata fingerprint inputs. Preserve native
+  filesystem error codes and reconcile files removed during startup as deletions
+  while retaining unexpected read failures.
+
+- Support verified static V2 catalogs alongside Nostr sources, retain installation
+  source provenance, and render themed registry images and structured release notes.
+- Updated dependencies []:
+  - @lapis-notes/ui@0.1.1
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -19,6 +19,11 @@ or product routing.
 - Peer dependencies for UI, Svelte, CodeMirror, Mira, and Design Core so hosts
   retain singleton control over their runtime stack.
 
+`@lapis-notes/api/registry/schema` provides catalog schemas, types, normalization,
+media resolution, and structured release-note extraction for registry producers
+and consumers. It imports only Zod and does not boot the application.
+`@lapis-notes/api/build/vite` provides the portable Turso browser-build helper.
+
 ## Usage
 
 ```ts

package/dist/app-database-host.d.ts

@@ -1,4 +1,5 @@
 export * from "./storage/app-database";
+export * from "./storage/remote-app-database";
 export * from "./storage/index-projection";
 export * from "./storage/task-projection";
 export * from "./storage/turso-app-database";

package/dist/app-database-host.js

@@ -1,4 +1,5 @@
 export * from "./storage/app-database";
+export * from "./storage/remote-app-database";
 export * from "./storage/index-projection";
 export * from "./storage/task-projection";
 export * from "./storage/turso-app-database";

package/dist/browser-sync-security.d.ts

@@ -0,0 +1,45 @@
+import type { SyncCryptoStatus } from "./sync-host-security";
+import type { SyncCryptoEnrollmentRequest } from "./sync-host-security";
+import type { SyncHostService } from "./sync-host";
+import type { AppDatabase } from "./storage/app-database";
+export interface BrowserSyncPrfCredential {
+    version: 1;
+    credentialId: string;
+    prfInput: string;
+    hkdfSalt: string;
+}
+export interface BrowserStoragePersistenceStatus {
+    supported: boolean;
+    persisted: boolean;
+}
+export interface BrowserSyncUnlockInteraction {
+    confirmPasskeyEnrollment(pluginId: string): Promise<boolean>;
+    requestPassphrase(pluginId: string, mode: "enroll" | "unlock"): Promise<string | null>;
+}
+export declare function supportsBrowserWebAuthnPrf(): Promise<boolean>;
+export declare function requestBrowserStoragePersistence(storage?: Pick<StorageManager, "persist" | "persisted"> | undefined): Promise<BrowserStoragePersistenceStatus>;
+export declare function createBrowserSyncPrfCredential(options: {
+    rpName: string;
+    rpId?: string;
+    userId: Uint8Array;
+    userName: string;
+    credentials?: CredentialsContainer;
+}): Promise<{
+    credential: BrowserSyncPrfCredential;
+    wrappingKey: Uint8Array;
+}>;
+export declare function unlockBrowserSyncPrfCredential(credential: BrowserSyncPrfCredential, credentials?: CredentialsContainer | undefined): Promise<Uint8Array>;
+/**
+ * Build the host-owned browser unlock callback used by SyncHostService.
+ * The callback returns only status to plugins; wrapping material stays in the
+ * host flow and is zeroed immediately after enrollment or unlock.
+ */
+export declare function createBrowserSyncUnlockHandler(options: {
+    database: AppDatabase;
+    getSyncHost(): SyncHostService;
+    interaction: BrowserSyncUnlockInteraction;
+    rpName: string;
+    rpId?: string;
+    userName?: string;
+    credentials?: CredentialsContainer;
+}): (pluginId: string, status: SyncCryptoStatus, enrollment?: SyncCryptoEnrollmentRequest) => Promise<void>;

package/dist/browser-sync-security.js

@@ -0,0 +1,189 @@
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+const BROWSER_CREDENTIAL_PREFIX = "sync-host:v1:browser-prf:";
+export async function supportsBrowserWebAuthnPrf() {
+    if (typeof PublicKeyCredential === "undefined")
+        return false;
+    const getCapabilities = PublicKeyCredential.getClientCapabilities;
+    if (!getCapabilities)
+        return false;
+    try {
+        const capabilities = await getCapabilities();
+        return capabilities["extension:prf"] === true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function requestBrowserStoragePersistence(storage = typeof navigator === "undefined" ? undefined : navigator.storage) {
+    if (!storage?.persist || !storage.persisted) {
+        return { supported: false, persisted: false };
+    }
+    if (await storage.persisted()) {
+        return { supported: true, persisted: true };
+    }
+    return { supported: true, persisted: await storage.persist() };
+}
+export async function createBrowserSyncPrfCredential(options) {
+    const credentials = options.credentials ??
+        (typeof navigator === "undefined" ? undefined : navigator.credentials);
+    if (!credentials)
+        throw new Error("WebAuthn is unavailable in this host");
+    const prfInput = randomBytes(32);
+    const hkdfSalt = randomBytes(32);
+    const created = await credentials.create({
+        publicKey: {
+            challenge: randomBytes(32),
+            rp: { name: options.rpName, id: options.rpId },
+            user: {
+                id: options.userId,
+                name: options.userName,
+                displayName: options.userName,
+            },
+            pubKeyCredParams: [
+                { type: "public-key", alg: -7 },
+                { type: "public-key", alg: -257 },
+            ],
+            authenticatorSelection: {
+                residentKey: "required",
+                userVerification: "required",
+            },
+            extensions: {
+                prf: { eval: { first: prfInput } },
+            },
+        },
+    });
+    if (!(created instanceof PublicKeyCredential)) {
+        throw new Error("WebAuthn credential creation was cancelled");
+    }
+    const results = created.getClientExtensionResults();
+    if (results.prf?.enabled !== true) {
+        throw new Error("The selected authenticator does not support WebAuthn PRF");
+    }
+    const credential = {
+        version: 1,
+        credentialId: toBase64Url(new Uint8Array(created.rawId)),
+        prfInput: toBase64Url(prfInput),
+        hkdfSalt: toBase64Url(hkdfSalt),
+    };
+    return {
+        credential,
+        wrappingKey: await unlockBrowserSyncPrfCredential(credential, credentials),
+    };
+}
+export async function unlockBrowserSyncPrfCredential(credential, credentials = typeof navigator === "undefined" ? undefined : navigator.credentials) {
+    if (!credentials)
+        throw new Error("WebAuthn is unavailable in this host");
+    if (credential.version !== 1) {
+        throw new Error("Unsupported browser sync credential version");
+    }
+    const assertion = await credentials.get({
+        publicKey: {
+            challenge: randomBytes(32),
+            allowCredentials: [
+                {
+                    id: fromBase64Url(credential.credentialId),
+                    type: "public-key",
+                },
+            ],
+            userVerification: "required",
+            extensions: {
+                prf: { eval: { first: fromBase64Url(credential.prfInput) } },
+            },
+        },
+    });
+    if (!(assertion instanceof PublicKeyCredential)) {
+        throw new Error("WebAuthn unlock was cancelled");
+    }
+    const results = assertion.getClientExtensionResults();
+    const output = results.prf?.results?.first;
+    if (!output || output.byteLength < 32) {
+        throw new Error("WebAuthn PRF did not return wrapping material");
+    }
+    return hkdf(sha256, new Uint8Array(output), fromBase64Url(credential.hkdfSalt), new TextEncoder().encode("lapis-sync-v1:browser-wrapping-key"), 32);
+}
+/**
+ * Build the host-owned browser unlock callback used by SyncHostService.
+ * The callback returns only status to plugins; wrapping material stays in the
+ * host flow and is zeroed immediately after enrollment or unlock.
+ */
+export function createBrowserSyncUnlockHandler(options) {
+    return async (pluginId, status, enrollment) => {
+        if (status.state === "unlocked")
+            return;
+        const recordKey = `${BROWSER_CREDENTIAL_PREFIX}${encodeKeyPart(pluginId)}`;
+        const stored = (await options.database.getMeta(recordKey)) ??
+            null;
+        if (stored) {
+            const wrappingKey = await unlockBrowserSyncPrfCredential(stored, options.credentials);
+            try {
+                if (status.state === "unenrolled") {
+                    await options.getSyncHost().enrollPluginCryptoWithWrappingKey(pluginId, wrappingKey, {
+                        name: "external",
+                        provider: "webauthn-prf",
+                        keyId: stored.credentialId,
+                    }, enrollment);
+                }
+                else {
+                    await options
+                        .getSyncHost()
+                        .unlockPluginCryptoWithWrappingKey(pluginId, wrappingKey);
+                }
+            }
+            finally {
+                wrappingKey.fill(0);
+            }
+            return;
+        }
+        if (status.state === "unenrolled" &&
+            (await supportsBrowserWebAuthnPrf()) &&
+            (await options.interaction.confirmPasskeyEnrollment(pluginId))) {
+            const userId = randomBytes(32);
+            const created = await createBrowserSyncPrfCredential({
+                rpName: options.rpName,
+                rpId: options.rpId,
+                userId,
+                userName: options.userName ?? `sync:${pluginId}`,
+                credentials: options.credentials,
+            });
+            try {
+                await options.getSyncHost().enrollPluginCryptoWithWrappingKey(pluginId, created.wrappingKey, {
+                    name: "external",
+                    provider: "webauthn-prf",
+                    keyId: created.credential.credentialId,
+                }, enrollment);
+                await options.database.setMeta(recordKey, created.credential);
+            }
+            finally {
+                created.wrappingKey.fill(0);
+                userId.fill(0);
+            }
+            return;
+        }
+        const passphrase = await options.interaction.requestPassphrase(pluginId, status.state === "unenrolled" ? "enroll" : "unlock");
+        if (passphrase == null)
+            throw new Error("Sync unlock was cancelled");
+        if (status.state === "unenrolled") {
+            await options
+                .getSyncHost()
+                .enrollPluginCrypto(pluginId, passphrase, enrollment);
+        }
+        else {
+            await options.getSyncHost().unlockPluginCrypto(pluginId, passphrase);
+        }
+    };
+}
+function toBase64Url(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+function encodeKeyPart(value) {
+    return toBase64Url(new TextEncoder().encode(value));
+}
+function fromBase64Url(value) {
+    const padded = value.replaceAll("-", "+").replaceAll("_", "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+    return Uint8Array.from(atob(padded), (character) => character.charCodeAt(0));
+}

package/dist/build-tools/vite.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turso's prebuilt browser bundle already embeds its WASM as a complete data
+ * URL. Removing the redundant URL constructor prevents Vite's worker scanner
+ * from tokenizing the generated 15 MB module recursively during production
+ * builds, without changing the URL passed to fetch at runtime.
+ */
+export declare function unwrapTursoBundleDataUrl(code: string, id: string): string;
+export declare function tursoBundleBuildPlugin(): {
+    name: string;
+    enforce: "pre";
+    transform(this: import("rollup").TransformPluginContext, code: string, id: string): {
+        code: string;
+        map: null;
+    } | null;
+};

package/dist/build-tools/vite.js

@@ -0,0 +1,36 @@
+const TURSO_BUNDLE_SUFFIX = "/node_modules/@tursodatabase/database-wasm/bundle/main.es.js";
+const DATA_URL_PREFIX = 'new URL("data:application/wasm;base64,';
+const URL_WRAPPER_PREFIX = "new URL(";
+const URL_WRAPPER_SUFFIX = ", import.meta.url).href";
+/**
+ * Turso's prebuilt browser bundle already embeds its WASM as a complete data
+ * URL. Removing the redundant URL constructor prevents Vite's worker scanner
+ * from tokenizing the generated 15 MB module recursively during production
+ * builds, without changing the URL passed to fetch at runtime.
+ */
+export function unwrapTursoBundleDataUrl(code, id) {
+    const normalizedId = id.split("?", 1)[0]?.replaceAll("\\", "/") ?? id;
+    if (!normalizedId.endsWith(TURSO_BUNDLE_SUFFIX))
+        return code;
+    const expressionStart = code.indexOf(DATA_URL_PREFIX);
+    if (expressionStart < 0) {
+        return code.replaceAll("new Worker(", "new globalThis.Worker(");
+    }
+    const wrapperEnd = code.indexOf(URL_WRAPPER_SUFFIX, expressionStart);
+    if (wrapperEnd < 0) {
+        return code.replaceAll("new Worker(", "new globalThis.Worker(");
+    }
+    return (code.slice(0, expressionStart) +
+        code.slice(expressionStart + URL_WRAPPER_PREFIX.length, wrapperEnd) +
+        code.slice(wrapperEnd + URL_WRAPPER_SUFFIX.length)).replaceAll("new Worker(", "new globalThis.Worker(");
+}
+export function tursoBundleBuildPlugin() {
+    return {
+        name: "lapis-api-turso-bundle-data-url",
+        enforce: "pre",
+        transform(code, id) {
+            const transformed = unwrapTursoBundleDataUrl(code, id);
+            return transformed === code ? null : { code: transformed, map: null };
+        },
+    };
+}

package/dist/cache.svelte.d.ts

@@ -535,7 +535,7 @@ export declare class MetadataCache extends EventDispatcher<{
     private loadPrimarySnapshot;
     private hydrateDatabaseFromSnapshot;
     private reconcileSnapshotWithVault;
-    getReconciliationFingerprint(): string;
+    getReconciliationFingerprint(acceptsFile?: (file: TFile) => boolean): string;
     getFileCache(file: TFile): CachedMetadata | null;
     getCache(path: string): CachedMetadata | null;
     getFileCacheAsync(file: TFile | string): Promise<CachedMetadata | null>;

package/dist/cache.svelte.js

@@ -586,12 +586,15 @@ export class MetadataCache extends EventDispatcher {
     /**
      * Return the current vault/parser manifest fingerprint used to validate the
      * durable metadata index and disposable indexed-consumer snapshots.
+     * Consumers may restrict the fingerprint to their accepted metadata files.
      */
-    getReconciliationFingerprint() {
+    getReconciliationFingerprint(acceptsFile) {
         const fingerprint = new StreamingManifestFingerprint();
         for (const file of this.app.vault.iterateFiles()) {
             if (!this.processors.has(file.extension.toLowerCase()))
                 continue;
+            if (acceptsFile && !acceptsFile(file))
+                continue;
             fingerprint.add([
                 file.path,
                 file.stat.mtime,

package/dist/components/editor/editor.css

@@ -377,12 +377,14 @@
 
 [data-ui-component="editor"][data-ui-part="lint-rule"] {
   font: inherit;
-  color: var(--ui-editor-lint-accent);
+  color: var(--foreground);
+  text-decoration: underline;
+  text-decoration-color: var(--ui-editor-lint-accent);
   text-underline-offset: 2px;
 }
 
 [data-ui-component="editor"][data-ui-part="lint-rule"]:hover {
-  text-decoration: underline;
+  text-decoration-thickness: 2px;
 }
 
 [data-ui-component="editor"][data-ui-part="lint-copy"] {
@@ -444,6 +446,56 @@
   text-decoration: underline;
 }
 
+.ui-editor-lint-quick-fix-menu {
+  z-index: calc(var(--ui-workspace-overlay-z-index, 50) + 10);
+  min-width: 13rem;
+  max-width: min(24rem, calc(100vw - 1rem));
+  border: 1px solid var(--ui-workspace-border, var(--border));
+  border-radius: var(--ui-workspace-radius-medium, 0.375rem);
+  padding: 0.25rem;
+  color: var(--ui-workspace-popover-foreground, var(--foreground));
+  background: var(--ui-workspace-popover, var(--popover, var(--secondary)));
+  box-shadow: var(
+    --ui-workspace-shadow,
+    0 10px 24px rgb(0 0 0 / 0.18)
+  );
+}
+
+.ui-editor-lint-quick-fix-menu__item {
+  display: flex;
+  min-height: 2rem;
+  width: 100%;
+  align-items: center;
+  gap: 0.5rem;
+  border-radius: var(--ui-workspace-radius-small, 0.25rem);
+  padding: 0.375rem 0.5rem;
+  color: inherit;
+  font-family: var(--ui-editor-font-sans);
+  font-size: 0.875rem;
+  line-height: 1.25rem;
+  outline: none;
+  user-select: none;
+}
+
+.ui-editor-lint-quick-fix-menu__item:focus,
+.ui-editor-lint-quick-fix-menu__item[data-highlighted] {
+  background: var(--ui-workspace-muted, var(--muted));
+}
+
+.ui-editor-lint-quick-fix-menu__item > svg {
+  width: 1rem;
+  height: 1rem;
+  flex: 0 0 1rem;
+}
+
+.ui-editor-lint-quick-fix-menu__label {
+  min-width: 0;
+  flex: 1 1 auto;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 /* Inline diagnostic expansion created by the lint tooltip's View Problem action. */
 [data-ui-component="editor"][data-ui-part="inline-problem"] {
   position: relative;

package/dist/components/editor/extensions/lint/lapis-lint-tooltip.svelte

@@ -1,10 +1,8 @@
 <script lang="ts">
   import { Button } from "@lapismd/design-core/shadcn/button";
   import { WorkspaceIcon } from "@lapismd/design-core/workspace/icon";
-  import { WorkspaceMenuItems } from "@lapismd/design-core/workspace/menu";
   import { DropdownMenu } from "bits-ui";
   import {
-    createLintQuickFixMenu,
     splitLintTooltipActions,
     type LintTooltipAction,
   } from "./lint-tooltip-actions";
@@ -35,7 +33,6 @@
   const { viewProblem, quickFixActions } = $derived(
     splitLintTooltipActions(actions),
   );
-  const quickFixMenu = $derived(createLintQuickFixMenu(quickFixActions));
   const showFooter = $derived(
     Boolean(viewProblem) || quickFixActions.length > 0,
   );
@@ -54,6 +51,10 @@
   function stopRowActivation(event: Event) {
     event.stopPropagation();
   }
+
+  function selectQuickFix(action: LintTooltipAction, event: MouseEvent) {
+    action.onClick(event);
+  }
 </script>
 
 <div
@@ -139,7 +140,7 @@
           </DropdownMenu.Trigger>
           <DropdownMenu.Portal>
             <DropdownMenu.Content
-              class="ui-workspace-menu__content"
+              class="ui-editor-lint-quick-fix-menu"
               data-ui-component="workspace-menu"
               data-ui-part="content"
               data-lint-quick-fix-menu=""
@@ -150,7 +151,19 @@
               collisionBoundary={[]}
               onpointerdown={stopRowActivation}
             >
-              <WorkspaceMenuItems menu={quickFixMenu} />
+              {#each quickFixActions as action, index (`${action.name}-${index}`)}
+                <DropdownMenu.Item
+                  class="ui-editor-lint-quick-fix-menu__item"
+                  data-ui-component="workspace-menu"
+                  data-ui-part="item"
+                  onclick={(event) => selectQuickFix(action, event)}
+                >
+                  <WorkspaceIcon name="lightbulb" />
+                  <span class="ui-editor-lint-quick-fix-menu__label">
+                    {action.name}
+                  </span>
+                </DropdownMenu.Item>
+              {/each}
             </DropdownMenu.Content>
           </DropdownMenu.Portal>
         </DropdownMenu.Root>

package/dist/components/editor/extensions/lint/lint-tooltip-actions.d.ts

@@ -1,4 +1,3 @@
-import { WorkspaceMenu } from "@lapismd/design-core/workspace/core";
 export declare const VIEW_PROBLEM_ACTION = "View Problem";
 export type LintTooltipAction = {
     name: string;
@@ -8,4 +7,3 @@ export declare function splitLintTooltipActions(actions: readonly LintTooltipAct
     viewProblem: LintTooltipAction | undefined;
     quickFixActions: LintTooltipAction[];
 };
-export declare function createLintQuickFixMenu(actions: readonly LintTooltipAction[]): WorkspaceMenu;

package/dist/components/editor/extensions/lint/lint-tooltip-actions.js

@@ -1,4 +1,3 @@
-import { WorkspaceMenu } from "@lapismd/design-core/workspace/core";
 export const VIEW_PROBLEM_ACTION = "View Problem";
 export function splitLintTooltipActions(actions) {
     return {
@@ -6,16 +5,3 @@ export function splitLintTooltipActions(actions) {
         quickFixActions: actions.filter((action) => action.name !== VIEW_PROBLEM_ACTION),
     };
 }
-export function createLintQuickFixMenu(actions) {
-    const menu = new WorkspaceMenu();
-    for (const action of actions) {
-        menu.addItem((item) => item
-            .setTitle(action.name)
-            .setIcon("lightbulb")
-            .setSection("fix")
-            .onClick((event) => {
-            action.onClick(event instanceof MouseEvent ? event : new MouseEvent("click"));
-        }));
-    }
-    return menu;
-}

package/dist/components/editor/language-service/index.js

@@ -1,8 +1,8 @@
-import { Facet } from "@codemirror/state";
+import { Facet, StateEffect, } from "@codemirror/state";
 import { hoverTooltip, ViewPlugin, } from "@codemirror/view";
 import { editorViewField, fromPosition, toPosition, } from "../../../editor.svelte";
 import { lapisCodeMirrorAutocomplete } from "../extensions/autocomplete";
-import { lapisCodeMirrorLint, lintGutter, mapToLapisLintDiagnostic, markdownlintRuleUrl, setDiagnostics, } from "../extensions/lint";
+import { lapisCodeMirrorLint, lintGutter, mapToLapisLintDiagnostic, markdownlintRuleUrl, setDiagnostics, forceLinting, } from "../extensions/lint";
 import { createLanguageServiceHoverDom } from "./dom";
 export const languageServiceDocumentContext = Facet.define({
     combine(values) {
@@ -10,6 +10,7 @@ export const languageServiceDocumentContext = Facet.define({
     },
 });
 const trackedOpenDocuments = new WeakMap();
+const diagnosticsInvalidatedEffect = StateEffect.define();
 export function languageServiceExtensions(options = {}) {
     const extensions = [];
     const wantsDiagnostics = options.diagnostics ?? true;
@@ -18,6 +19,9 @@ export function languageServiceExtensions(options = {}) {
         extensions.push(openDocumentTrackingExtension(options), ...lapisCodeMirrorLint({
             source: async (view) => collectLanguageServiceDiagnostics(view, options),
             gutter: wantsGutter ? undefined : false,
+            lint: {
+                needsRefresh: (update) => update.transactions.some((transaction) => transaction.effects.some((effect) => effect.is(diagnosticsInvalidatedEffect))),
+            },
         }));
     }
     else if (wantsGutter) {
@@ -33,10 +37,26 @@ export function languageServiceExtensions(options = {}) {
 }
 function openDocumentTrackingExtension(options) {
     return ViewPlugin.define((view) => {
+        let subscribedManager;
+        let unsubscribeInvalidation;
         const sync = (nextView) => {
             const resolved = resolveDocumentContext(nextView, options.languageId);
             if (!resolved)
                 return;
+            const manager = resolved.info.app.languageServices;
+            if (subscribedManager !== manager) {
+                unsubscribeInvalidation?.();
+                subscribedManager = manager;
+                unsubscribeInvalidation = manager.onDiagnosticsInvalidated((languages) => {
+                    const current = resolveDocumentContext(view, options.languageId);
+                    if (current && languages.includes(current.document.languageId)) {
+                        view.dispatch({
+                            effects: diagnosticsInvalidatedEffect.of(undefined),
+                        });
+                        forceLinting(view);
+                    }
+                });
+            }
             retainOpenDocument(nextView, resolved.document.uri, resolved.info.app.languageServices);
         };
         sync(view);
@@ -45,6 +65,7 @@ function openDocumentTrackingExtension(options) {
                 sync(update.view);
             },
             destroy() {
+                unsubscribeInvalidation?.();
                 trackedOpenDocuments.get(view)?.release();
                 trackedOpenDocuments.delete(view);
             },

package/dist/components/icon/icon-list.svelte.d.ts

@@ -6,6 +6,6 @@ type $$ComponentProps = ButtonProps & {
     ref?: HTMLButtonElement | null;
     label?: string;
 };
-declare const IconList: import("svelte").Component<$$ComponentProps, {}, "ref" | "value">;
+declare const IconList: import("svelte").Component<$$ComponentProps, {}, "value" | "ref">;
 type IconList = ReturnType<typeof IconList>;
 export default IconList;

package/dist/components/select/select.svelte.d.ts

@@ -20,6 +20,6 @@ export type MultipleSelectProps = SharedSelectProps & {
     onValueChange?: (value: string[]) => void;
 };
 export type SelectProps = SingleSelectProps | MultipleSelectProps;
-declare const Select: import("svelte").Component<SelectProps, {}, "ref" | "value">;
+declare const Select: import("svelte").Component<SelectProps, {}, "value" | "ref">;
 type Select = ReturnType<typeof Select>;
 export default Select;

package/dist/context.svelte.d.ts

@@ -30,6 +30,8 @@ import { DailyDocumentProviderRegistry } from "./daily-document-provider";
 import { AppToolRegistry } from "./agent-tools";
 import { MarkdownExtensionRegistry } from "./markdown-extension-registry";
 import { MarkdownFileSurfaceRegistry } from "./markdown-file-surface-registry";
+import { NostrSignerHost, type NostrSignerBroker } from "./nostr-signer";
+import { SyncHostService, type SyncHostServiceOptions } from "./sync-host";
 export interface AppWorkspaceShellApplicationProperties {
     /** Application name shown by the shell's About surface. */
     name?: string;
@@ -60,9 +62,14 @@ export type AppStateProperties = {
     createCommunityPluginDependencyResolver?: PluginDependencyResolverFactory;
     pluginAssetServer?: PluginAssetServer;
     pluginDistributionOptions?: AppPluginDistributionOptions;
+    /** Host-owned Nostr account, keychain, and remote-signer implementation. */
+    nostrSignerBroker?: NostrSignerBroker;
+    syncHost?: SyncHostServiceOptions;
     workspaceShell?: AppWorkspaceShellProperties;
     markdownRenderer: (markdown: string, el: HTMLElement, sourcePath: string, component: Component) => Promise<void>;
 };
+/** Renderer-safe application properties exposed to plugins and views. */
+export type AppPublicProperties = Pick<AppStateProperties, "version" | "configPath" | "workspaceShell" | "markdownRenderer">;
 export type AppPluginDistributionOptions = Omit<DefaultPluginDistributionManagerOptions, "adapter" | "appVersion" | "platform" | "workspaceTrusted" | "pluginManager">;
 export type ExtType = Extension | ((context: Record<string, any>) => Extension);
 /**
@@ -146,7 +153,7 @@ export declare class SecretStorage {
  * @public
  */
 export declare class App {
-    readonly props: AppStateProperties;
+    readonly props: AppPublicProperties;
     readonly i18n: LocalizationManager;
     readonly workspace: Workspace;
     readonly vault: Vault;
@@ -166,6 +173,7 @@ export declare class App {
     readonly urls: AppUrlService;
     readonly workspaceTrust: WorkspaceTrustService;
     readonly pluginDistribution: DefaultPluginDistributionManager;
+    readonly nostr: NostrSignerHost;
     mardownPostProcessor: Array<MarkdownPostProcessor>;
     mardownCodeBlockPostProcessor: Record<string, Array<MarkdownPostProcessor>>;
     markdownDirectiveRenderers: Record<string, MarkdownDirectiveRenderer>;
@@ -239,6 +247,8 @@ export declare class App {
     setting(id: "options" | "core-plugins" | "community-plugins"): import("./settings.svelte").SettingGroup;
 }
 export type AppState = App;
+/** Transfer the mounting host's sync controller exactly once. */
+export declare function takeHostSyncService(app: App): SyncHostService;
 declare global {
     var app: App;
 }