@appsoftwareltd/etherpk-extension-api 0.12.0 → 0.14.0

package/dist/context.d.ts

@@ -3,18 +3,23 @@
  *
  * Everything an extension adds through it sits under the extension's id and is removed when the
  * graph closes or the extension is switched off, so an extension never has to undo its own
- * registrations. It holds no document store, no keys and no sync: an extension reads documents
- * only through the index's answers and its own fences, and changes them only through its fences,
- * the blocks it puts at the caret and the Client's Commands.
+ * registrations. It holds no document store, no keys and no sync. An extension reads documents
+ * through the index's answers, `documents` (which leaves out every Protected Document) and its own
+ * fences, and changes them only through its fences, the blocks it puts at the caret, the images it
+ * keeps as assets and the Commands it may run.
  */
+import type { ExtensionAssets } from './assets';
 import type { ExtensionAuth } from './auth';
 import type { ExtensionDialogs } from './dialogs';
+import type { ExtensionDocuments } from './documents';
 import type { ExtensionEditor } from './editor';
 import type { ExtensionEmbeds } from './embeds';
 import type { ExtensionEvents } from './events';
 import type { ExtensionIndex } from './graph-index';
 import type { ExtensionJournalPanels } from './journal';
-import type { CommandMenuItem, ContextMenuItem, GraphSidebarButton } from './menus';
+import type { CommandBarButton, CommandMenuItem, ContextMenuItem, GraphSidebarButton } from './menus';
+import type { ExtensionGraphRecords } from './records';
+import type { SettingsSection } from './settings-sections';
 import type { ViewContribution, ViewRef } from './views';
 /**
  * A Command's handler. What it returns, or resolves to, is what `execute` resolves to.
@@ -31,16 +36,12 @@ export interface ExtensionCommands {
     /** Add a Command, its id under the extension's id. Throws if the id is taken or outside it. */
     register(id: string, handler: CommandHandler): () => void;
     /**
-     * Run any Command, the Client's or an extension's. Rejects if no Command has the id.
-     *
-     * @beta
+     * Run a Command: the extension's own, another running extension's, or one of the Client's that
+     * {@link CLIENT_COMMANDS} names. Rejects if no Command has the id, or if it is one of the
+     * Client's that the list does not name. An extension that comes with EtherPK may run any.
      */
     execute(id: string, arg?: unknown): Promise<unknown>;
-    /**
-     * Whether any Command has the id.
-     *
-     * @beta
-     */
+    /** Whether a Command the extension may run has the id. */
     has(id: string): boolean;
 }
 /**
@@ -58,7 +59,7 @@ export interface ExtensionViews {
 /**
  * Adding Context Menu rows.
  *
- * @beta
+ * @public
  */
 export interface ExtensionContextMenu {
     /** Add a row, its id under the extension's id. */
@@ -73,6 +74,16 @@ export interface ExtensionCommandMenu {
     /** Add a row, its id under the extension's id. */
     register(item: CommandMenuItem): () => void;
 }
+/**
+ * Adding buttons to the Command Bar, the row of buttons across the bottom of a phone's screen:
+ * after the editing buttons that scroll, or in the pinned group at its right end.
+ *
+ * @public
+ */
+export interface ExtensionCommandBar {
+    /** Add a button, its id under the extension's id. */
+    register(button: CommandBarButton): () => void;
+}
 /**
  * Adding buttons to the Graph Sidebar's group of action buttons, after Search and today's date.
  *
@@ -85,7 +96,7 @@ export interface ExtensionGraphSidebar {
 /**
  * A key chord that runs a Command.
  *
- * @beta
+ * @public
  */
 export interface Keybinding {
     /** `Alt+M`, `Mod+Shift+K`: `Mod` is Cmd on Apple devices and Ctrl elsewhere. */
@@ -100,10 +111,15 @@ export interface Keybinding {
 /**
  * Adding key chords.
  *
- * @beta
+ * @public
  */
 export interface ExtensionKeybindings {
-    /** Add a chord. Throws if the Client or another extension already binds it. */
+    /**
+     * Add a chord for one of the extension's own Commands. Throws for another's Command. When the
+     * Client or another extension binds the chord already, the chord is left to them and this one
+     * does nothing: the call still succeeds, and the Client says so in the browser's console. So a
+     * shortcut the Client adds in a later release never stops an extension from starting.
+     */
     register(binding: Keybinding): () => void;
 }
 /**
@@ -122,9 +138,8 @@ export interface ExtensionLayout {
         beside?: string;
     }): void;
     /**
-     * Bring a Sidebar resident to the front of its expanded Sidebar.
-     *
-     * @beta
+     * Bring one of the extension's own Sidebar residents (a View kind its manifest declares with a
+     * `resident` side) to the front of its expanded Sidebar. Does nothing for any other kind.
      */
     reveal(kind: string): void;
     /**
@@ -139,21 +154,42 @@ export interface ExtensionLayout {
         beside?: string;
     }): void;
     /**
-     * The document the user is working in, or null.
-     *
-     * @beta
+     * The name of the document the person is working in, as its tab names it (a page's title, or a
+     * journal entry's day, `YYYY-MM-DD`), or null when no document's tab is in front.
      */
     activeDocument(): string | null;
     /** True while the desktop presenter is showing, 1024 pixels wide and more. */
     isDesktop(): boolean;
+    /**
+     * Draw something over the whole EtherPK window, with a heading and a close button the Client
+     * draws, as a fence's widget opens over the window. One at a time: opening another closes the
+     * one before. The close button, Escape and `close` all close it, and `onClose` is told once.
+     */
+    openWindow(options: {
+        /** The heading the Client draws beside the close button. */
+        title: string;
+        /** Draw into `host`, which fills the window under the heading. */
+        mount(host: HTMLElement, window: {
+            close(): void;
+        }): {
+            destroy(): void;
+        };
+        onClose?(): void;
+    }): {
+        close(): void;
+    };
 }
 /**
  * The rules for naming a concept, which every index answer follows.
  *
- * @beta
+ * @public
  */
 export interface ExtensionConcepts {
-    /** The case-insensitive key of a name. */
+    /**
+     * The key the Client tells two names apart by: two names with the same key are one concept.
+     * How it is made may change in a later release, so compare keys from this, and never make
+     * one another way.
+     */
     key(name: string): string;
     /** The name a concept resolves to: an alias's page, a page's own title, or the name itself. */
     canonicalName(name: string): string;
@@ -203,15 +239,15 @@ export interface ExtensionSettings {
 }
 /**
  * The extension's own records, kept with the person (ADR 0140): on this device, and where the
- * person's account syncs a graph, in that account's vault too, encrypted on the device so only the
- * person's own devices can read them. So a record follows the person to their other devices, as
+ * person's account syncs a graph, in that account's Settings Vault too, encrypted on the device so
+ * only the person's own devices can read them. So a record follows the person to their other devices, as
  * Extension Settings do, such as what signing in to another service gave the extension. The person
  * never sees these records, and uninstalling the extension clears them on every device.
  *
  * Each record is kept as JSON, at most 64 KB of it. Between two devices the later change to a
  * record wins, record by record. A record is readable on the device by any code in the page, as
- * localStorage is, and by a Headless Client given an agent token for the same account, which opens
- * the account's vault.
+ * localStorage is. A Headless Client signed in to the same account cannot read it: the Sync Server
+ * never gives an agent token the Settings Vault (ADR 0148).
  *
  * @public
  */
@@ -247,7 +283,7 @@ export interface ExtensionTheme {
  * it goes into the page as it is. A string built from it is a plain string again, which the
  * Client's default policy sanitizes.
  *
- * @beta
+ * @public
  */
 export interface IconMarkup {
     /** Never present at run time. It marks the type, so a plain string is not one. */
@@ -256,7 +292,7 @@ export interface IconMarkup {
 /**
  * Drawing the Client's icons and the extension's own.
  *
- * @beta
+ * @public
  */
 export interface ExtensionIcons {
     /**
@@ -299,26 +335,18 @@ export interface ExtensionContributions {
 export interface ExtensionContext {
     /**
      * The extension's id, from its manifest.
-     *
-     * @beta
      */
     readonly extensionId: string;
     /**
      * The open graph.
-     *
-     * @beta
      */
     readonly graphId: string;
     /**
      * The Client's version, `x.y.z`.
-     *
-     * @beta
      */
     readonly clientVersion: string;
     /**
      * True in a development build of the Client, where tests may reach in.
-     *
-     * @beta
      */
     readonly dev: boolean;
     /** Supplying the Views the manifest declares. */
@@ -327,20 +355,20 @@ export interface ExtensionContext {
     readonly commands: ExtensionCommands;
     /**
      * Adding Context Menu rows.
-     *
-     * @beta
      */
     readonly contextMenu: ExtensionContextMenu;
     /** Adding Command Menu rows. */
     readonly commandMenu: ExtensionCommandMenu;
     /** Adding buttons to the Graph Sidebar. */
     readonly graphSidebar: ExtensionGraphSidebar;
+    /**
+     * Adding buttons to the phone's Command Bar.
+     */
+    readonly commandBar: ExtensionCommandBar;
     /** Adding panels beneath each Journal Entry. */
     readonly journalPanels: ExtensionJournalPanels;
     /**
      * Adding key chords.
-     *
-     * @beta
      */
     readonly keybindings: ExtensionKeybindings;
     /**
@@ -353,16 +381,24 @@ export interface ExtensionContext {
     readonly events: ExtensionEvents;
     /**
      * Questions to the open graph's index.
-     *
-     * @beta
      */
     readonly index: ExtensionIndex;
+    /**
+     * Reading the open graph's documents, with every Protected Document left out, name and all.
+     */
+    readonly documents: ExtensionDocuments;
+    /**
+     * The extension's records for the open graph, kept on this device only.
+     */
+    readonly records: ExtensionGraphRecords;
+    /**
+     * Images kept as the open graph's assets.
+     */
+    readonly assets: ExtensionAssets;
     /** Opening Views and documents. */
     readonly layout: ExtensionLayout;
     /**
      * The rules for naming a concept.
-     *
-     * @beta
      */
     readonly concepts: ExtensionConcepts;
     /** The extension's own storage on this device. */
@@ -377,8 +413,6 @@ export interface ExtensionContext {
     readonly theme: ExtensionTheme;
     /**
      * The Client's icons and the extension's own.
-     *
-     * @beta
      */
     readonly icons: ExtensionIcons;
     /** Widgets over the extension's own fences, and blocks put at the caret. */
@@ -402,4 +436,10 @@ export interface ExtensionModule {
      * called after that, for anything else the extension holds.
      */
     activate(context: ExtensionContext): void | (() => void);
+    /**
+     * Sections the extension adds to the Client's settings, which the Client mounts while the
+     * extension is switched on: in a graph's Settings and Extensions, and, for an extension that
+     * comes with EtherPK, on the Graphs page with no graph open (see {@link SettingsSection}).
+     */
+    settingsSections?: readonly SettingsSection[];
 }

package/dist/documents.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Reading the open graph's documents, as a language model may read them for a person (ADR 0147).
+ *
+ * Every answer leaves out a [[Protected Document]] entirely: not its content, and not its name
+ * either, even while the person holds the Protection Key. That is stricter than the index's
+ * answers (`context.index`), which list a Protected Document by name, because what an extension
+ * reads here may be sent to a model provider. A document whose text holds an encrypted fence
+ * anywhere counts as protected here too.
+ *
+ * Every answer is bounded: a list is paged, and a document's text is cut at a cap and says so. A
+ * page of a listing holds at most 200 documents or tasks, and a page of a search 50 results. A
+ * document's text is cut after 200,000 characters. The format guide's wording changes as the format
+ * does, so an extension passes it on and never reads meaning into its words.
+ */
+/**
+ * A document as a listing names it.
+ *
+ * @public
+ */
+export interface DocumentSummary {
+    /** The document's name: a page's title, or a journal entry's day, `YYYY-MM-DD`. */
+    name: string;
+    /** A page or a journal entry. */
+    kind: 'page' | 'journal';
+    /** The page's other names. */
+    aliases: string[];
+}
+/**
+ * A document's text, as {@link ExtensionDocuments.read} answers.
+ *
+ * @public
+ */
+export interface DocumentText extends DocumentSummary {
+    /** The body: the text after the frontmatter block, cut at the cap. */
+    text: string;
+    /** True when the text was cut at the cap. */
+    truncated: boolean;
+}
+/**
+ * One document a search matched, with the lines that matched.
+ *
+ * @public
+ */
+export interface DocumentSearchResult extends Omit<DocumentSummary, 'aliases'> {
+    /** How many lines matched. */
+    matches: number;
+    /** The matching lines, best first. */
+    hits: {
+        /** The line's number in the document's text, from 0. */
+        line: number;
+        /** The labels of the blocks the line sits under, outermost first. */
+        breadcrumb: string[];
+        /** The line's text around the match. */
+        snippet: string;
+    }[];
+}
+/**
+ * One document whose text links to the concept asked about, with each place it does.
+ *
+ * @public
+ */
+export interface DocumentBacklink extends Omit<DocumentSummary, 'aliases'> {
+    references: {
+        /** The line's number in the source's text, from 0. */
+        line: number;
+        /** The labels of the blocks the reference sits under, outermost first. */
+        breadcrumb: string[];
+        /** The block holding the link with its children, or the prose around it. */
+        text: string;
+    }[];
+}
+/**
+ * One task, as the Tasks View lists it.
+ *
+ * @public
+ */
+export interface DocumentTask extends Omit<DocumentSummary, 'aliases'> {
+    /** The task's line in the document's text, from 0. */
+    line: number;
+    /** The task's words, without the checkbox. */
+    text: string;
+    status: 'open' | 'doing' | 'waiting' | 'done' | 'cancelled';
+    /** 1 is the highest; null when the task has none. */
+    priority: 1 | 2 | 3 | null;
+    /** `YYYY-MM-DD`, or null. */
+    due: string | null;
+    /** `YYYY-MM-DD`, or null. */
+    scheduled: string | null;
+    /** The labels of the blocks the task sits under, outermost first. */
+    breadcrumb: string[];
+}
+/**
+ * Reading the open graph's documents.
+ *
+ * @public
+ */
+export interface ExtensionDocuments {
+    /** Pages and journal entries, journals newest first and then pages by name, a page at a time. */
+    list(options?: {
+        kind?: 'page' | 'journal';
+        offset?: number;
+        limit?: number;
+    }): Promise<{
+        documents: DocumentSummary[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * A document's text by its name or an alias, or null when there is no such document or it is
+     * protected. The text is the document as it is now, edits not yet saved included.
+     */
+    read(name: string): Promise<DocumentText | null>;
+    /**
+     * The names of the documents a document's wikilinks name directly, in the order they first
+     * appear, each once. Names with no document, and protected documents, are left out. Null when
+     * the document cannot be read.
+     */
+    links(name: string): Promise<string[] | null>;
+    /** The documents whose text matches the words, best first, a page at a time. */
+    search(query: string, options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<{
+        results: DocumentSearchResult[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    /** The documents that link to a concept, or null when the concept is a protected document. */
+    backlinks(name: string): Promise<DocumentBacklink[] | null>;
+    /**
+     * How the graph's documents are written, as the Client describes it to agents: names and
+     * wikilinks, the outline, tasks and the rest of the syntax, in markdown. The same words the
+     * `AGENTS.md` of a graph folder carries, less what is about files on a disk, so a model reading
+     * the graph's text understands it and names documents as `[[Name]]`.
+     */
+    formatGuide(): string;
+    /** Tasks, open ones unless asked otherwise, of one concept or of the whole graph, a page at a time. */
+    tasks(options?: {
+        /** Only the tasks that answer to this concept. */
+        concept?: string;
+        statuses?: DocumentTask['status'][];
+        offset?: number;
+        limit?: number;
+    }): Promise<{
+        tasks: DocumentTask[];
+        total: number;
+        hasMore: boolean;
+    }>;
+}

package/dist/documents.js

@@ -0,0 +1,15 @@
+/**
+ * Reading the open graph's documents, as a language model may read them for a person (ADR 0147).
+ *
+ * Every answer leaves out a [[Protected Document]] entirely: not its content, and not its name
+ * either, even while the person holds the Protection Key. That is stricter than the index's
+ * answers (`context.index`), which list a Protected Document by name, because what an extension
+ * reads here may be sent to a model provider. A document whose text holds an encrypted fence
+ * anywhere counts as protected here too.
+ *
+ * Every answer is bounded: a list is paged, and a document's text is cut at a cap and says so. A
+ * page of a listing holds at most 200 documents or tasks, and a page of a search 50 results. A
+ * document's text is cut after 200,000 characters. The format guide's wording changes as the format
+ * does, so an extension passes it on and never reads meaning into its words.
+ */
+export {};

package/dist/editor.d.ts

@@ -236,6 +236,72 @@ export interface FenceOptions {
      */
     keepsHistory?: boolean;
 }
+/**
+ * A panel an extension draws in a document, beneath one of its lines, which is not part of the
+ * document's text: nothing of it is saved, synced or seen on another device (ADR 0147).
+ *
+ * The panel follows its line as the document changes, here or on another device, and moves with
+ * the editor when the editor is rebuilt (a Draft becoming a document, say). It closes when the
+ * person closes it, or when the document's editor closes for good: the panel lasts for the visit.
+ *
+ * @public
+ */
+export interface InlinePanel {
+    /** The document the panel is in, by its concept. */
+    readonly document: string | null;
+    /** False once the panel has closed. */
+    readonly isOpen: boolean;
+    /**
+     * Put a block at the panel's line, by the rule {@link ExtensionEditor.insertBlock} follows at the
+     * caret: an empty line is replaced, an empty bullet takes an outline's place at its own
+     * indentation (or any other block as its content), and after any other line the block goes on new
+     * lines beneath at the line's content column. The panel then sits beneath the block, and the next
+     * block goes after it at the indentation of its first line. One undoable change. False where
+     * nothing was put in: the panel is closed, its editor has closed, or its line is now in the
+     * frontmatter, a fenced block or a table.
+     */
+    insertBlock(text: string): boolean;
+    /** Bring the panel into view. */
+    focus(): void;
+    /**
+     * Give the panel a new height in CSS pixels, which its content scrolls inside: the lines below
+     * it move once. Grow it when there is more to show, rather than on every change.
+     */
+    resize(height: number): void;
+    /**
+     * The outline around the panel's line, as the document writes it: the line's ancestors, each its
+     * own lines without its other children, and its siblings with their branches, the line's own
+     * branch among them while the line has text. A block the panel put in is left out. Null when
+     * the line is not a bullet, or the panel is closed or under the document's last line.
+     */
+    outline(): string | null;
+    /** Close the panel. Its `onClose` is told. */
+    close(): void;
+}
+/**
+ * What an inline panel is drawn with.
+ *
+ * @public
+ */
+export interface InlinePanelOptions {
+    /**
+     * The panel's height in CSS pixels, which its content scrolls inside, so the lines below never
+     * move as its content grows. {@link InlinePanel.resize} changes it.
+     */
+    height?: number;
+    /**
+     * Draw the panel into `host`, which the Client owns and places. Called once, when the panel is
+     * first drawn: the host keeps its content while the panel is scrolled out of view and when the
+     * editor is rebuilt, and `destroy` is called when the panel closes. Events inside the host are
+     * the panel's own: the editor neither types nor moves its caret for them, but Mod+Z and Mod+Y
+     * outside a text field undo and redo in the document.
+     */
+    mount(host: HTMLElement, panel: InlinePanel): {
+        destroy(): void;
+    };
+    /** Told once, when the panel closes for any reason. */
+    onClose?(): void;
+}
 /**
  * The document editor, as far as an extension may reach it.
  *
@@ -263,4 +329,16 @@ export interface ExtensionEditor {
     insertBlock(text: string, options?: {
         focus?: boolean;
     }): boolean;
+    /**
+     * Draw a panel beneath the caret's line in the editor the person is working in, from where the
+     * line's text starts, or beside the dot of an empty bullet, as a code block opened there is. With
+     * `at` `end`, it is drawn beneath the document's last line, at the editor's left edge, a line's
+     * height clear of it. With `caret-or-end`, at the caret while the person is typing in the
+     * document (the editor has the keyboard, as a Command Bar button leaves it), else at the end: for
+     * a button pressed from outside the text. Null where no panel can go: no editor, a Protected
+     * Document, or a caret in the frontmatter, a fenced block or a table.
+     */
+    openPanel(options: InlinePanelOptions & {
+        at?: 'caret' | 'end' | 'caret-or-end';
+    }): InlinePanel | null;
 }

package/dist/graph-index.d.ts

@@ -6,14 +6,14 @@
 /**
  * What kind of name a concept is.
  *
- * @beta
+ * @public
  */
 export type ConceptKind = 'page' | 'journal' | 'alias' | 'pageless';
 /**
  * One name the index knows: a page, a journal entry, an alias, or a Pageless Concept (a name
  * wikilinks use that has no page).
  *
- * @beta
+ * @public
  */
 export interface ConceptCandidate {
     /** The name as written. */
@@ -32,7 +32,7 @@ export interface ConceptCandidate {
 /**
  * One concept in the link graph.
  *
- * @beta
+ * @public
  */
 export interface LinkGraphConcept {
     /** The case-insensitive key every other answer uses. */
@@ -50,7 +50,7 @@ export interface LinkGraphConcept {
  * One line, from the document whose text holds the wikilinks to the concept they name. Both ends
  * are positions in {@link LinkGraph.concepts}.
  *
- * @beta
+ * @public
  */
 export interface LinkGraphLink {
     /** The document whose text holds the wikilinks, by its position in `concepts`. */
@@ -65,7 +65,7 @@ export interface LinkGraphLink {
 /**
  * Every concept and every line a wikilink draws between two of them.
  *
- * @beta
+ * @public
  */
 export interface LinkGraph {
     /** Sorted by key, so two answers over the same index are identical. */
@@ -76,7 +76,7 @@ export interface LinkGraph {
 /**
  * What changed in one update the index committed.
  *
- * @beta
+ * @public
  */
 export interface IndexUpdate {
     /** The whole index was read again, so anything may have changed. */
@@ -91,7 +91,7 @@ export interface IndexUpdate {
 /**
  * The questions an extension may ask the open graph's index.
  *
- * @beta
+ * @public
  */
 export interface ExtensionIndex {
     /** Every name the index knows, aliases and Pageless Concepts included. */

package/dist/index.d.ts

@@ -9,20 +9,26 @@
  *
  * A declaration, or a member of one, is Stable (`@public`) or Proposed (`@beta`). A Stable one never
  * breaks: it is deprecated and kept. A Proposed one may change in any release, and only the
- * extensions that come with EtherPK may use it. An extension from the Extension Directory uses the
+ * extensions that come with EtherPK may use it. Since 0.14.0 everything is Stable but
+ * `contributions`, the Client's own registries. An extension from the Extension Directory uses the
  * Stable part alone, which `etc/etherpk-extension-api.public.api.md` lists.
  *
  * @packageDocumentation
  */
-export type { CommandHandler, ExtensionCommandMenu, ExtensionCommands, ExtensionConcepts, ExtensionContext, ExtensionContextMenu, ExtensionContributions, ExtensionGraphSidebar, ExtensionIcons, ExtensionKeybindings, ExtensionLayout, ExtensionModule, ExtensionPersonStorage, ExtensionSettings, ExtensionStorage, ExtensionTheme, ExtensionViews, IconMarkup, Keybinding, } from './context';
+export type { CommandHandler, ExtensionCommandBar, ExtensionCommandMenu, ExtensionCommands, ExtensionConcepts, ExtensionContext, ExtensionContextMenu, ExtensionContributions, ExtensionGraphSidebar, ExtensionIcons, ExtensionKeybindings, ExtensionLayout, ExtensionModule, ExtensionPersonStorage, ExtensionSettings, ExtensionStorage, ExtensionTheme, ExtensionViews, IconMarkup, Keybinding, } from './context';
+export type { ExtensionAssets } from './assets';
 export type { AuthorizeOptions, ExtensionAuth } from './auth';
 export type { ExtensionDialogs, PromptOptions } from './dialogs';
-export type { ExtensionEditor, FenceContext, FenceEdit, FenceInfo, FenceOptions, FencePresentation, FenceWidget, MountedFence, PublishedFence, PublishFenceRequest, QuoteFenceRequest, } from './editor';
+export type { DocumentBacklink, DocumentSearchResult, DocumentSummary, DocumentTask, DocumentText, ExtensionDocuments } from './documents';
+export type { ExtensionEditor, FenceContext, FenceEdit, FenceInfo, FenceOptions, FencePresentation, FenceWidget, InlinePanel, InlinePanelOptions, MountedFence, PublishedFence, PublishFenceRequest, QuoteFenceRequest, } from './editor';
 export type { ExtensionEmbeds, FrameOptions } from './embeds';
 export type { ExtensionEventName, ExtensionEventPayloads, ExtensionEvents } from './events';
 export type { ConceptCandidate, ConceptKind, ExtensionIndex, IndexUpdate, LinkGraph, LinkGraphConcept, LinkGraphLink } from './graph-index';
 export type { ExtensionJournalPanels, JournalPanel, JournalPanelProps, MountedJournalPanel } from './journal';
 export type { ExtensionIsolation, ExtensionManifest, ExtensionPackage, ReadExtensionPackageResult, SettingDeclaration, ViewDeclaration, ViewRegion, } from './manifest';
 export { readExtensionPackage } from './manifest';
-export type { CommandMenuContext, CommandMenuItem, ContextMenuItem, DocumentMenuTarget, ExtensionMenuTarget, GraphSidebarButton, MenuTarget, TabMenuTarget, WikilinkMenuTarget, } from './menus';
+export { CLIENT_COMMANDS } from './client-commands';
+export type { CommandBarButton, CommandMenuContext, CommandMenuItem, ContextMenuItem, DocumentMenuTarget, ExtensionMenuTarget, GraphSidebarButton, MenuTarget, TabMenuTarget, WikilinkMenuTarget, } from './menus';
+export type { ExtensionGraphRecords } from './records';
+export type { MountedSettingsSection, SettingsSection, SettingsSectionContext, SettingsSectionTab } from './settings-sections';
 export type { MountedView, ViewContribution, ViewMountProps, ViewRef, ViewVisibility } from './views';

package/dist/index.js

@@ -9,9 +9,11 @@
  *
  * A declaration, or a member of one, is Stable (`@public`) or Proposed (`@beta`). A Stable one never
  * breaks: it is deprecated and kept. A Proposed one may change in any release, and only the
- * extensions that come with EtherPK may use it. An extension from the Extension Directory uses the
+ * extensions that come with EtherPK may use it. Since 0.14.0 everything is Stable but
+ * `contributions`, the Client's own registries. An extension from the Extension Directory uses the
  * Stable part alone, which `etc/etherpk-extension-api.public.api.md` lists.
  *
  * @packageDocumentation
  */
 export { readExtensionPackage } from './manifest';
+export { CLIENT_COMMANDS } from './client-commands';