@lapis-notes/api 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,122 @@
 # @lapis-notes/api
 
+## 0.1.4
+
+### Patch Changes
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Keep editor saves and
+  failures bound to their original document and App across file switches and
+  close. Register retained writers with the App-owned session registry, expose
+  protection and awaitable disposal, and support a captured asynchronous
+  external persistence writer. Block typing/rebinding during guarded admission
+  while allowing controlled clean refresh.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Expose the headless
+  opaque Sync repository contract and add purpose-separated local-state
+  encryption for durable encrypted checkpoints and publication queues. Existing
+  encrypted object tags and wire formats remain compatible.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Expose an App-owned file
+  editing-session registry for independent file writers. Serialize guarded
+  mutation, protect and flush every matching session before admission, retain
+  detached dirty writers for retry, and drain cleanup before another mutation or
+  shutdown. Production Sync guard selection still requires complete writer
+  integration.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Register and protect
+  asynchronous editor document loads before reading, drain original drafts and
+  publish the target file and contents together. Superseded, unloaded and failed
+  loads preserve the previous document and release their provisional session.
+  Managed file and folder renames now protect and flush all registered writers
+  before moving files or rewriting links.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Expose protocol-neutral
+  guarded file generations, immutable mutation identifiers, durable receipts and
+  an opaque local-state crypto boundary for host-owned native Sync vault
+  transactions. Existing protocol and encryption formats stay unchanged.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Add explicit
+  host-delivered pairing without relay addresses while preserving default relay
+  invitations and the signed/encrypted Nostr message format. Expose copied
+  installed content-key epoch numbers only while unlocked so history policy can
+  use the actual keyring instead of assuming an epoch.
+
+  Expose the same implementation through the headless `sync-security-host`
+  export for trusted Node/Deno hosts, with no plugin runtime platforms
+  advertised.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Allow trusted hosts to
+  retain wrapped Sync keys and network grants in a dedicated security store
+  independent of disposable application indexes. Keep legacy storage compatible
+  and reject invalid or unavailable dedicated stores without fallback.
+
+  Expose the shared metadata-store types through a headless host-only
+  entrypoint, retaining the existing AppDatabase metadata exports.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Add an optional opaque
+  immutable record repository extension for independently encrypted local
+  receipts. Native mutation recovery can compact completed work without growing
+  its active journal or exposing receipt contents in an index.
+
+- [#28](https://github.com/lapismd/lapis-notes/pull/28)
+  [`967a92f`](https://github.com/lapismd/lapis-notes/commit/967a92fb123c9cb66fca976c689fafdd00aa65b6)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Allow trusted hosts to
+  delegate scoped Sync security to native custody while preserving legacy plugin
+  credentials. Check permissions before and after asynchronous operations,
+  reject local enrollment for delegated plugins, and await security revocation
+  when a plugin is disabled, including unload failures. Add host disposal that
+  invalidates runtimes and drains delegated cleanup.
+
+## 0.1.3
+
+### Patch Changes
+
+- [#19](https://github.com/lapismd/lapis-notes/pull/19)
+  [`a85055b`](https://github.com/lapismd/lapis-notes/commit/a85055b6570244d5dde2ea1145be3609260d91ca)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Restore the omitted API
+  0.1.2 release notes and keep changelog generation independent of optional code
+  formatter plugins. Verify current-version notes before and after preparing a
+  release so incomplete changelogs stop publication.
+
+- [#17](https://github.com/lapismd/lapis-notes/pull/17)
+  [`0c8cbd0`](https://github.com/lapismd/lapis-notes/commit/0c8cbd0811663a9c63590d4d730445c80df91e6c)
+  Thanks [@stevejuma](https://github.com/stevejuma)! - Download selected plugin
+  releases through the catalog's signed delivery endpoint so browser hosts can
+  install archives from the registry. Retain verified archive integrity and
+  signatures, allow origin fallback for transport failures, and stop fallback
+  after cancellation or revocation.
+
+## 0.1.2
+
+### Patch Changes
+
+- Use published Bits UI 2.19.5 so destroyed text-selection layers stop document
+  pointer listeners before reading component-owned reactive state. Retain the
+  existing approved Link Preview selection-probe and listener cleanup when
+  refreshing the runtime.
+- Require published Design Core 0.3.2 for native window-controls spacing, bold
+  settings headings, selected-tab indicators and mobile shell teardown. Consume
+  the npm release through portable semver ranges and lockfile integrity.
+- Expose the existing optional App argument in the Notice declaration so
+  app-owned callers can use the public constructor without falling back to
+  compatibility state.
+
 ## 0.1.1
 
 ### Patch Changes
@@ -7,14 +124,16 @@
 - 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.
+- 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.
+- 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
 

package/dist/components/editor/editor.svelte

@@ -86,6 +86,7 @@
   });
 
   function renameFile(name: string | null) {
+    if (editor.editingProtected) return;
     if (name && editor.file && name !== editor.file.name) {
       const path = `${dirname(editor.file.path)}/${name}.${editor.file.extension}`;
       app.fileManager.renameFile(editor.file, path);
@@ -125,7 +126,7 @@
               onfocusout={(evt) =>
                 renameFile((evt.target as HTMLDivElement).getText())}
               class="inline-title cm-editor-inline-title"
-              contenteditable="true"
+              contenteditable={!editor.editingProtected}
               {spellcheck}
               autocapitalize="on"
               tabindex="-1"
@@ -144,7 +145,7 @@
               data-mobile-inline-title="true"
               data-mobile-inline-title-input="true"
               aria-label="Active note title"
-              contenteditable="true"
+              contenteditable={!editor.editingProtected}
               {spellcheck}
               autocapitalize="on"
               tabindex="-1"

package/dist/context.svelte.d.ts

@@ -30,6 +30,7 @@ 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 { FileEditingSessionRegistry } from "./file-editing-sessions";
 import { NostrSignerHost, type NostrSignerBroker } from "./nostr-signer";
 import { SyncHostService, type SyncHostServiceOptions } from "./sync-host";
 export interface AppWorkspaceShellApplicationProperties {
@@ -190,6 +191,7 @@ export declare class App {
     readonly agentTools: AppToolRegistry;
     readonly markdownExtensions: MarkdownExtensionRegistry;
     readonly markdownFileSurfaces: MarkdownFileSurfaceRegistry;
+    readonly fileEditingSessions: FileEditingSessionRegistry;
     readonly agentSkills: import("./agent-skills").AppSkillRegistry;
     readonly agentSlashCommands: import("./agent-skills").AppSlashCommandRegistry;
     readonly agentResultViews: import("./agent-result-views").AppResultViewRegistry;

package/dist/context.svelte.js

@@ -26,14 +26,16 @@ import { WorkspaceTrustService } from "./workspace-trust";
 import { DefaultPluginDistributionManager, } from "./plugin-distribution";
 import { ConfigurationOptionSourceRegistry } from "./configuration-option-source-registry";
 import { resolveMetadataFieldValuesAsync } from "./configuration-option-source-providers";
+import { flushWorkspaceEditors } from "./sync-editor-flush";
+import { FileEditingSessionRegistry } from "./file-editing-sessions";
 import { SearchDocumentProviderRegistry } from "./search-document-provider";
 import { DailyDocumentProviderRegistry } from "./daily-document-provider";
 import { AppToolRegistry } from "./agent-tools";
-import { AppSkillRegistry, AppSlashCommandRegistry, } from "./agent-skills";
+import { AppSkillRegistry, AppSlashCommandRegistry } from "./agent-skills";
 import { AppResultViewRegistry } from "./agent-result-views";
 import { MarkdownExtensionRegistry } from "./markdown-extension-registry";
 import { MarkdownFileSurfaceRegistry } from "./markdown-file-surface-registry";
-import { SyncHostService, } from "./sync-host";
+import { SyncHostService } from "./sync-host";
 import { installApplicationCompatibility, resolveApplication, } from "./application-compatibility";
 import { provideApplicationState, useApplicationState, } from "./application-state.svelte";
 const hostSyncServices = new WeakMap();
@@ -167,6 +169,7 @@ export class App {
     agentResultViews = new AppResultViewRegistry();
     markdownExtensions = new MarkdownExtensionRegistry();
     markdownFileSurfaces = new MarkdownFileSurfaceRegistry();
+    fileEditingSessions = new FileEditingSessionRegistry();
     lastEvent = $state(null);
     renderContext = new RenderContext();
     secretStorage = new SecretStorage();
@@ -231,15 +234,7 @@ export class App {
         this.vault = new Vault(adapter);
         this.#syncHost = new SyncHostService(this.appDatabase, this.vault, Date.now, {
             ...props.syncHost,
-            flushOpenEditor: async (path) => {
-                const active = this.workspace.activeEditor;
-                if (!active?.editor || !active.file)
-                    return { flushed: false, path };
-                if (path && active.file.path !== path)
-                    return { flushed: false, path };
-                await active.editor.flushChanges();
-                return { flushed: true, path: active.file.path };
-            },
+            flushOpenEditor: (path) => flushWorkspaceEditors(this.workspace, path),
         });
         hostSyncServices.set(this, this.#syncHost);
         this.workspaceTrust = new WorkspaceTrustService(adapter);

package/dist/editor-save-context.d.ts

@@ -0,0 +1,24 @@
+export interface EditorSaveSnapshot {
+    content: string;
+    sequence: number;
+    documentGeneration: number;
+}
+/** One document's queued saves and failures; the editor supplies shared serialization. */
+export declare class EditorSaveContext {
+    #private;
+    private readonly options;
+    constructor(options: {
+        serialize(run: () => Promise<void>): Promise<void>;
+        persist(snapshot: EditorSaveSnapshot): Promise<void>;
+        saved(snapshot: EditorSaveSnapshot): void;
+        unownedExternal: boolean;
+        released(): void;
+    });
+    get dirty(): boolean;
+    queue(snapshot: EditorSaveSnapshot, explicit?: boolean): Promise<void> | undefined;
+    flushSave(): Promise<void> | undefined;
+    cancelSave(): void;
+    cancelChange(): void;
+    flush(retryFailed?: boolean): Promise<void>;
+    retire(): void;
+}

package/dist/editor-save-context.js

@@ -0,0 +1,101 @@
+import debounce from "lodash-es/debounce";
+/** One document's queued saves and failures; the editor supplies shared serialization. */
+export class EditorSaveContext {
+    options;
+    #latest;
+    #completed = 0;
+    #failure;
+    #waitingChange;
+    #waitingSave;
+    #pending = new Set();
+    #retired = false;
+    #unverified = false;
+    #change = debounce((snapshot) => {
+        this.#waitingChange = undefined;
+        return this.#enqueue(snapshot);
+    }, 500);
+    #save = debounce((snapshot) => {
+        this.#waitingSave = undefined;
+        return this.#enqueue(snapshot);
+    }, 500);
+    constructor(options) {
+        this.options = options;
+    }
+    get dirty() {
+        return (!!this.#waitingChange ||
+            !!this.#waitingSave ||
+            this.#pending.size > 0 ||
+            !!this.#failure ||
+            this.#unverified);
+    }
+    queue(snapshot, explicit = false) {
+        this.#latest = snapshot;
+        if (this.options.unownedExternal)
+            this.#unverified = true;
+        if (explicit) {
+            this.#waitingSave = snapshot;
+            return this.#save(snapshot);
+        }
+        this.#waitingChange = snapshot;
+        return this.#change(snapshot);
+    }
+    flushSave() {
+        return this.#save.flush();
+    }
+    cancelSave() {
+        this.#save.cancel();
+        this.#waitingSave = undefined;
+    }
+    cancelChange() {
+        this.#change.cancel();
+        this.#waitingChange = undefined;
+    }
+    #flushPending() {
+        this.#change.flush();
+        this.#save.flush();
+    }
+    #enqueue(snapshot) {
+        const flight = this.options.serialize(async () => {
+            if (snapshot.sequence <= this.#completed)
+                return;
+            await this.options.persist(snapshot);
+            this.options.saved(snapshot);
+            this.#completed = snapshot.sequence;
+            if (this.#failure && this.#failure.snapshot.sequence <= snapshot.sequence)
+                this.#failure = undefined;
+        });
+        this.#pending.add(flight);
+        // Observe failures even when a debounce caller does not await its result.
+        void flight.then(() => {
+            this.#pending.delete(flight);
+            this.#releaseIfClean();
+        }, (error) => {
+            this.#failure = { snapshot, error };
+            this.#pending.delete(flight);
+        });
+        return flight;
+    }
+    async flush(retryFailed = true) {
+        const retry = this.#failure;
+        this.#flushPending();
+        if (retryFailed && retry && this.#latest === retry.snapshot)
+            this.#enqueue(retry.snapshot);
+        do {
+            await Promise.allSettled([...this.#pending]);
+            this.#flushPending();
+        } while (this.#pending.size > 0);
+        if (this.#failure)
+            throw this.#failure.error;
+        this.#releaseIfClean();
+    }
+    retire() {
+        this.#retired = true;
+        // Retiring a context never replaces another context's debounce payload.
+        this.#flushPending();
+        this.#releaseIfClean();
+    }
+    #releaseIfClean() {
+        if (this.#retired && !this.dirty)
+            this.options.released();
+    }
+}

package/dist/editor.svelte.d.ts

@@ -43,6 +43,12 @@ export interface EditorTransaction {
 }
 /** Controls whether an editor persists its own debounced document changes. */
 export type EditorPersistence = "vault" | "external";
+export interface EditorPersistenceRequest {
+    readonly content: string;
+    readonly file: TFile | null;
+    readonly application: App;
+}
+export type EditorPersistenceWriter = (request: EditorPersistenceRequest) => Promise<void>;
 export interface MarkdownFileInfo {
     /** @public */
     app: App;
@@ -70,10 +76,20 @@ export declare class Editor extends EventDispatcher<{
     readonly id: `${string}-${string}-${string}-${string}-${string}`;
     private destroyed;
     private application;
-    private readonly pendingChange;
     constructor(data?: string, extensions?: Extension[], application?: App);
     /** Bind this editor to the application that owns its view. */
     bindApplication(application: App): this;
+    /** Capture an explicit asynchronous owner for external-mode persistence. */
+    setExternalPersistenceWriter(writer?: EditorPersistenceWriter): this;
+    get hasUnsavedChanges(): boolean;
+    get editingProtected(): boolean;
+    get refreshError(): unknown;
+    /** Protect the current document and drain its captured persistence. */
+    protect(): Promise<() => void>;
+    /** Register and protect a target, then publish its file and contents atomically. */
+    loadDocument(file: TFile, read: () => Promise<string>, publish?: (contents: string) => void): Promise<boolean>;
+    /** Cancel a pending publication while observing any late read result. */
+    cancelDocumentLoad(): void;
     /** The owning application, with the global alias retained as fallback. */
     get app(): App;
     readonly save: import("lodash-es").DebouncedFunc<() => Promise<void>>;
@@ -88,6 +104,8 @@ export declare class Editor extends EventDispatcher<{
     getValue(): string;
     refresh(): void;
     destroy(): void;
+    /** Stop editing immediately and await all retained document persistence. */
+    dispose(): Promise<void>;
     trackChanges(callback?: (data: string, editor: Editor) => void): () => void;
     updateExtensions(extensions: Extension[], context?: Record<string, any>): this;
     setValue(content: string): void;