@silverbulletmd/silverbullet 2.6.1 → 2.7.0

package/client/space_lua/query_collection.ts

@@ -26,7 +26,7 @@ import {
   type LuaValue,
   singleResult,
 } from "./runtime.ts";
-import { isSqlNull, LIQ_NULL } from "./liq_null.ts";
+import { isSqlNull, SLIQ_NULL } from "./sliq_null.ts";
 import { evalExpression, luaOp } from "./eval.ts";
 import { asyncMergeSort } from "./util.ts";
 import type { DataStore } from "../data/datastore.ts";
@@ -295,7 +295,7 @@ function containsAggregate(expr: LuaExpression, config?: Config): boolean {
 // Wrap a value for select result tables so that the column key survives
 // in the `LuaTable`
 function selectVal(v: LuaValue): LuaValue {
-  return v === null || v === undefined ? LIQ_NULL : v;
+  return v === null || v === undefined ? SLIQ_NULL : v;
 }
 
 /**
@@ -491,7 +491,7 @@ function normalizeSelectResults(results: any[]): any[] {
     const rebuilt = new LuaTable();
     for (const k of canonicalKeys) {
       const v = item.rawGet(k);
-      void rebuilt.rawSet(k, v === undefined || v === null ? LIQ_NULL : v);
+      void rebuilt.rawSet(k, v === undefined || v === null ? SLIQ_NULL : v);
     }
     for (const k of luaKeys(item)) {
       if (typeof k !== "string") {
@@ -675,7 +675,7 @@ async function evalSelectExpression(
   for (const k of luaKeys(result)) {
     const v = result.rawGet(k);
     if (v === null || v === undefined) {
-      void result.rawSet(k, LIQ_NULL);
+      void result.rawSet(k, SLIQ_NULL);
     }
   }
   return result;

package/client/space_lua/render_lua_markdown.ts

@@ -3,7 +3,7 @@ import {
   escapeRegularPipes,
   jsonToMDTable,
 } from "../markdown_renderer/result_render.ts";
-import { isSqlNull } from "../space_lua/liq_null.ts";
+import { isSqlNull } from "../space_lua/sliq_null.ts";
 import { isTaggedFloat } from "../space_lua/numeric.ts";
 import { LuaTable, luaFormatNumber } from "../space_lua/runtime.ts";
 

package/client/space_lua/runtime.ts

@@ -3,7 +3,7 @@ import { evalStatement } from "./eval.ts";
 import { asyncQuickSort } from "./util.ts";
 import { isPromise, rpAll } from "./rp.ts";
 import { isNegativeZero, isTaggedFloat } from "./numeric.ts";
-import { isSqlNull } from "./liq_null.ts";
+import { isSqlNull } from "./sliq_null.ts";
 import { luaFormat } from "./stdlib/format.ts";
 
 export type LuaType =

package/client/space_lua/{liq_null.ts → sliq_null.ts}

@@ -1,6 +1,6 @@
 // Sentinel value representing SQL NULL in query results.
-export const LIQ_NULL = Symbol.for("silverbullet.sqlNull");
+export const SLIQ_NULL = Symbol.for("silverbullet.sqlNull");
 
 export function isSqlNull(v: any): boolean {
-  return v === LIQ_NULL;
+  return v === SLIQ_NULL;
 }

package/client/space_lua/stdlib/space_lua.ts

@@ -12,7 +12,7 @@ import {
   luaValueToJS,
   singleResult,
 } from "../runtime.ts";
-import { isSqlNull } from "../liq_null.ts";
+import { isSqlNull } from "../sliq_null.ts";
 
 /**
  * These are Space Lua specific functions that are available to all scripts, but are not part of the standard Lua language.

package/client/space_lua/stdlib.ts

@@ -35,7 +35,7 @@ import { cryptoApi } from "./stdlib/crypto.ts";
 import { netApi } from "./stdlib/net.ts";
 import { isTaggedFloat, makeLuaFloat } from "./numeric.ts";
 import { isPromise } from "./rp.ts";
-import { isSqlNull } from "./liq_null.ts";
+import { isSqlNull } from "./sliq_null.ts";
 
 const printFunction = new LuaBuiltinFunction(async (_sf, ...args) => {
   console.log("[Lua]", ...(await Promise.all(args.map((v) => luaToString(v)))));

package/dist/plug-compile.js

@@ -4,14 +4,22 @@
 import { Command } from "commander";
 
 // version.ts
-var version = "2.6.1";
+var version = "2.7.0";
 
 // client/plugos/plug_compile.ts
 import * as path from "node:path";
-import { readFile as readFile2, writeFile, mkdtemp, rm, mkdir } from "node:fs/promises";
+import {
+  copyFile,
+  mkdir,
+  mkdtemp,
+  readFile as readFile2,
+  rm,
+  writeFile
+} from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as YAML from "js-yaml";
 import * as esbuild from "esbuild";
+import * as sass from "sass";
 
 // client/asset_bundle/builder.ts
 import { readFile, readdir } from "node:fs/promises";
@@ -1339,6 +1347,12 @@ async function compileManifest(manifestPath, destPath, options = {}) {
   if (!manifest.name) {
     throw new Error(`Missing 'name' in ${manifestPath}`);
   }
+  if (manifest.build) {
+    await Promise.all(
+      manifest.build.map((step) => runBuildStep(step, rootPath, options))
+    );
+    delete manifest.build;
+  }
   const assetsBundle = await bundleAssets(
     path.resolve(rootPath),
     manifest.assets || []
@@ -1435,6 +1449,34 @@ async function compileManifests(manifestFiles, dist, options = {}) {
   }
   await buildAll();
 }
+async function runBuildStep(step, rootPath, options) {
+  const type = step.type ?? "esbuild";
+  const inFile = path.resolve(rootPath, step.in);
+  const outFile = path.resolve(rootPath, step.out);
+  await mkdir(path.dirname(outFile), { recursive: true });
+  if (type === "esbuild") {
+    await esbuild.build({
+      entryPoints: [inFile],
+      bundle: true,
+      format: "iife",
+      platform: "browser",
+      minify: !options.debug,
+      outfile: outFile,
+      treeShaking: true
+    });
+  } else if (type === "sass") {
+    const scss = await readFile2(inFile, "utf-8");
+    const result = sass.compileString(scss, {
+      loadPaths: [path.dirname(inFile)],
+      style: options.debug ? "expanded" : "compressed"
+    });
+    await writeFile(outFile, result.css, "utf-8");
+  } else if (type === "copy") {
+    await copyFile(inFile, outFile);
+  } else {
+    throw new Error(`Unsupported build step type: ${type}`);
+  }
+}
 function patchBundledJS(code) {
   return code.replaceAll("/(?<=\\n)/", "/()/");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silverbulletmd/silverbullet",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "type": "module",
   "description": "A self-hosted, web-based note taking app",
   "publishConfig": {

package/plug-api/constants.ts

@@ -8,3 +8,23 @@ export const wrongSpacePathError: Error = new Error(
 );
 export const pingTimeout: number = 2000;
 export const pingInterval: number = 5000;
+
+/**
+ * Determines if an error thrown by fetch() is a network-level error
+ * (as opposed to a server-side or application error).
+ *
+ * Browser-specific error messages when there is no internet connection:
+ * - Firefox: "NetworkError when attempting to fetch resource"
+ * - Safari (service worker): "FetchEvent.respondWith received an error: TypeError: Load failed"
+ * - Safari (no service worker): "Load failed"
+ * - Chrome: "Failed to fetch"
+ */
+export function isNetworkError(e: any): boolean {
+  const msg = (e?.message || "").toLowerCase();
+  return (
+    msg.includes("fetch") ||
+    msg.includes("load failed") ||
+    msg.includes("networkerror") ||
+    msg.includes("unavailable")
+  );
+}

package/plug-api/lib/ref.ts

@@ -23,7 +23,8 @@ export type Ref = {
   details?:
     | { type: "position"; pos: number }
     | { type: "linecolumn"; line: number; column: number }
-    | { type: "header"; header: string };
+    | { type: "header"; header: string }
+    | { type: "anchor"; name: string };
 };
 
 /**
@@ -96,7 +97,7 @@ export function isValidPath(path: string): path is Path {
  * TO THE INNER WORKINGS OF SILVERBULLET AND CHANGES COULD INTRODUCE MAJOR BUGS
  */
 const refRegex =
-  /^(?<meta>\^)?(?<path>(?!.*\.[a-zA-Z0-9]+\.md$)(?!\/?(\.|\^))(?!.*(?:\/|^)\.{1,2}(?:\/|$)|.*\/{2})(?!.*(?:\]\]|\[\[))[^@#|<>]*)(@(?<pos>\d+)|@[Ll](?<line>\d+)(?:[Cc](?<col>\d+))?|#\s*(?<header>.*))?$/;
+  /^(?<meta>\^)?(?<path>(?!.*\.[a-zA-Z0-9]+\.md$)(?!\/?(\.|\^))(?!.*(?:\/|^)\.{1,2}(?:\/|$)|.*\/{2})(?!.*(?:\]\]|\[\[))[^@#|<>$]*)(@(?<pos>\d+)|@[Ll](?<line>\d+)(?:[Cc](?<col>\d+))?|#\s*(?<header>.*)|\$(?<anchor>[A-Za-z_][A-Za-z0-9_/:-]*))?$/;
 
 /**
  * Parses a reference string into a ref object.
@@ -132,6 +133,8 @@ export function parseToRef(stringRef: string): Ref | null {
       type: "header",
       header: groups.header,
     };
+  } else if (groups.anchor !== undefined) {
+    ref.details = { type: "anchor", name: groups.anchor };
   }
 
   return ref;
@@ -158,6 +161,8 @@ export function encodeRef(ref: Ref): string {
     stringRef += `@${ref.details.pos}`;
   } else if (ref.details?.type === "header") {
     stringRef += `#${ref.details.header}`;
+  } else if (ref.details?.type === "anchor") {
+    stringRef += `$${ref.details.name}`;
   }
 
   return stringRef;
@@ -191,6 +196,8 @@ export function getOffsetFromRef(
     case "header": {
       return getOffsetFromHeader(parseTree, ref.details.header);
     }
+    case "anchor":
+      return -1;
   }
 }
 

package/plug-api/lib/shortcut.ts

@@ -0,0 +1,16 @@
+export const isMacLike = typeof navigator !== "undefined" &&
+  /(Mac|iPhone|iPod|iPad)/i.test(navigator.platform);
+
+export function prettifyShortcut(shortcut: string): string {
+  if (!isMacLike) return shortcut;
+  const pretty = shortcut
+    .replace(/Mod-/g, "⌘")
+    .replace(/Cmd-/g, "⌘")
+    .replace(/Ctrl-/g, "⌃")
+    .replace(/Alt-/g, "⌥")
+    .replace(/Shift-/g, "⇧");
+  return pretty.replace(
+    /([⌘⌃⌥⇧])([a-z])$/,
+    (_, mod, key) => mod + key.toUpperCase(),
+  );
+}

package/plug-api/lib/tree.ts

@@ -191,13 +191,29 @@ export function traverseTree(
   tree: ParseTree,
   // Return value = should stop traversal into children?
   matchFn: (tree: ParseTree) => boolean,
+  // Just log errors on exceptions, but don't stop traversal
+  catchVisitorErrors = false,
 ): void {
-  if (matchFn(tree)) {
+  let stop = false;
+  if (catchVisitorErrors) {
+    try {
+      stop = matchFn(tree);
+    } catch (e: any) {
+      console.error(
+        `traverseTree visitor failed at node ${tree.type}@${tree.from}:`,
+        e?.stack ?? e,
+      );
+      return;
+    }
+  } else {
+    stop = matchFn(tree);
+  }
+  if (stop) {
     return;
   }
   if (tree.children) {
     for (const child of tree.children) {
-      traverseTree(child, matchFn);
+      traverseTree(child, matchFn, catchVisitorErrors);
     }
   }
 }
@@ -206,13 +222,28 @@ export async function traverseTreeAsync(
   tree: ParseTree,
   // Return value = should stop traversal into children?
   matchFn: (tree: ParseTree) => Promise<boolean>,
+  catchVisitorErrors = false,
 ): Promise<void> {
-  if (await matchFn(tree)) {
+  let stop = false;
+  if (catchVisitorErrors) {
+    try {
+      stop = await matchFn(tree);
+    } catch (e: any) {
+      console.error(
+        `traverseTreeAsync visitor failed at node ${tree.type}@${tree.from}:`,
+        e?.stack ?? e,
+      );
+      return;
+    }
+  } else {
+    stop = await matchFn(tree);
+  }
+  if (stop) {
     return;
   }
   if (tree.children) {
     for (const child of tree.children) {
-      await traverseTreeAsync(child, matchFn);
+      await traverseTreeAsync(child, matchFn, catchVisitorErrors);
     }
   }
 }

package/plug-api/syscalls/config.ts

@@ -53,3 +53,40 @@ export function has(path: string): Promise<boolean> {
 export function define(key: string, schema: any): Promise<void> {
   return syscall("config.define", key, schema);
 }
+
+/**
+ * Defines (or updates) a UI category for the configuration manager. Categories
+ * are referenced by name from a schema field's `ui.category` and are sorted in
+ * ascending `order` (default 0); unknown categories fall to the bottom in
+ * alphabetical order.
+ */
+export function defineCategory(
+  definition: { name: string; description?: string; order?: number },
+): Promise<void> {
+  return syscall("config.defineCategory", definition);
+}
+
+/**
+ * Gets all config values as a single object.
+ * @returns The entire config values object
+ */
+export function getValues(): Promise<Record<string, any>> {
+  return syscall("config.getValues");
+}
+
+/**
+ * Gets all defined config schemas.
+ * @returns The schema definitions object
+ */
+export function getSchemas(): Promise<Record<string, any>> {
+  return syscall("config.getSchemas");
+}
+
+/**
+ * Gets all registered UI categories for the configuration manager.
+ */
+export function getCategories(): Promise<
+  Record<string, { name: string; description?: string; order?: number }>
+> {
+  return syscall("config.getCategories");
+}

package/plug-api/syscalls/editor.ts

@@ -269,6 +269,13 @@ export function hidePanel(id: "lhs" | "rhs" | "bhs" | "modal"): Promise<void> {
   return syscall("editor.hidePanel", id);
 }
 
+/**
+ * Returns focus to the main editor.
+ */
+export function focus(): Promise<void> {
+  return syscall("editor.focus");
+}
+
 export function showProgress(
   progressPercentage?: number,
   progressType?: string,
@@ -466,6 +473,27 @@ export function deleteLine(): Promise<void> {
   return syscall("editor.deleteLine");
 }
 
+/**
+ * Select the entire document
+ */
+export function selectAll(): Promise<void> {
+  return syscall("editor.selectAll");
+}
+
+/**
+ * Increase indentation of the current line or selection
+ */
+export function indentMore(): Promise<void> {
+  return syscall("editor.indentMore");
+}
+
+/**
+ * Decrease indentation of the current line or selection
+ */
+export function indentLess(): Promise<void> {
+  return syscall("editor.indentLess");
+}
+
 /**
  * Comment or uncomment the current line in the editor
  */
@@ -481,6 +509,133 @@ export function moveLineDown(): Promise<void> {
   return syscall("editor.moveLineDown");
 }
 
+// Cursor motion syscalls (wrappers around @codemirror/commands functions)
+export function cursorCharLeft(): Promise<void> {
+  return syscall("editor.cursorCharLeft");
+}
+export function cursorCharRight(): Promise<void> {
+  return syscall("editor.cursorCharRight");
+}
+export function cursorGroupLeft(): Promise<void> {
+  return syscall("editor.cursorGroupLeft");
+}
+export function cursorGroupRight(): Promise<void> {
+  return syscall("editor.cursorGroupRight");
+}
+export function cursorLineBoundaryLeft(): Promise<void> {
+  return syscall("editor.cursorLineBoundaryLeft");
+}
+export function cursorLineBoundaryRight(): Promise<void> {
+  return syscall("editor.cursorLineBoundaryRight");
+}
+export function cursorLineStart(): Promise<void> {
+  return syscall("editor.cursorLineStart");
+}
+export function cursorLineEnd(): Promise<void> {
+  return syscall("editor.cursorLineEnd");
+}
+export function cursorDocStart(): Promise<void> {
+  return syscall("editor.cursorDocStart");
+}
+export function cursorDocEnd(): Promise<void> {
+  return syscall("editor.cursorDocEnd");
+}
+export function cursorLineUp(): Promise<void> {
+  return syscall("editor.cursorLineUp");
+}
+export function cursorLineDown(): Promise<void> {
+  return syscall("editor.cursorLineDown");
+}
+export function cursorPageUp(): Promise<void> {
+  return syscall("editor.cursorPageUp");
+}
+export function cursorPageDown(): Promise<void> {
+  return syscall("editor.cursorPageDown");
+}
+
+// Selection-extending motions
+export function selectCharLeft(): Promise<void> {
+  return syscall("editor.selectCharLeft");
+}
+export function selectCharRight(): Promise<void> {
+  return syscall("editor.selectCharRight");
+}
+export function selectGroupLeft(): Promise<void> {
+  return syscall("editor.selectGroupLeft");
+}
+export function selectGroupRight(): Promise<void> {
+  return syscall("editor.selectGroupRight");
+}
+export function selectLineBoundaryLeft(): Promise<void> {
+  return syscall("editor.selectLineBoundaryLeft");
+}
+export function selectLineBoundaryRight(): Promise<void> {
+  return syscall("editor.selectLineBoundaryRight");
+}
+export function selectLineStart(): Promise<void> {
+  return syscall("editor.selectLineStart");
+}
+export function selectLineEnd(): Promise<void> {
+  return syscall("editor.selectLineEnd");
+}
+export function selectDocStart(): Promise<void> {
+  return syscall("editor.selectDocStart");
+}
+export function selectDocEnd(): Promise<void> {
+  return syscall("editor.selectDocEnd");
+}
+export function selectLineUp(): Promise<void> {
+  return syscall("editor.selectLineUp");
+}
+export function selectLineDown(): Promise<void> {
+  return syscall("editor.selectLineDown");
+}
+export function selectPageUp(): Promise<void> {
+  return syscall("editor.selectPageUp");
+}
+export function selectPageDown(): Promise<void> {
+  return syscall("editor.selectPageDown");
+}
+
+// Delete
+export function deleteCharBackward(): Promise<void> {
+  return syscall("editor.deleteCharBackward");
+}
+export function deleteCharForward(): Promise<void> {
+  return syscall("editor.deleteCharForward");
+}
+export function deleteGroupBackward(): Promise<void> {
+  return syscall("editor.deleteGroupBackward");
+}
+export function deleteGroupForward(): Promise<void> {
+  return syscall("editor.deleteGroupForward");
+}
+export function deleteLineBoundaryBackward(): Promise<void> {
+  return syscall("editor.deleteLineBoundaryBackward");
+}
+export function deleteLineBoundaryForward(): Promise<void> {
+  return syscall("editor.deleteLineBoundaryForward");
+}
+export function transposeChars(): Promise<void> {
+  return syscall("editor.transposeChars");
+}
+
+// Enter: accepts completion if popup open, else inserts newline
+export function insertNewline(): Promise<void> {
+  return syscall("editor.insertNewline");
+}
+
+// Completion popup
+export function acceptCompletion(): Promise<boolean> {
+  return syscall("editor.acceptCompletion");
+}
+export function startCompletion(): Promise<void> {
+  return syscall("editor.startCompletion");
+}
+export function closeCompletion(): Promise<void> {
+  return syscall("editor.closeCompletion");
+}
+
 // Vim-mode specific syscalls
 
 /**

package/plug-api/syscalls/index.ts

@@ -75,3 +75,21 @@ export function deleteObject(
 ): Promise<void> {
   return syscall("index.deleteObject", page, tag, ref);
 }
+
+export type {
+  AnchorHit,
+  ResolveAnchorResult,
+} from "../../plugs/index/types.ts";
+import type { ResolveAnchorResult } from "../../plugs/index/types.ts";
+
+/**
+ * Resolves a `$name` anchor to its host. Returns `ok: true` with page +
+ * hostTag + range on success, or `ok: false` with `missing`/`duplicate`
+ * reason. When `page` is provided, the lookup is filtered to that page.
+ */
+export function resolveAnchor(
+  name: string,
+  page?: string,
+): Promise<ResolveAnchorResult> {
+  return syscall("index.resolveAnchor", name, page);
+}

package/plug-api/syscalls/system.ts

@@ -51,6 +51,21 @@ export function reloadPlugs(): Promise<void> {
   return syscall("system.reloadPlugs");
 }
 
+/**
+ * Load (or reload) a single plug from a space file path.
+ */
+export function loadPlug(path: string): Promise<void> {
+  return syscall("system.loadPlug", path);
+}
+
+/**
+ * Unload a plug previously loaded from the given space file path.
+ * Returns true if a plug was unloaded.
+ */
+export function unloadPlug(path: string): Promise<boolean> {
+  return syscall("system.unloadPlug", path);
+}
+
 /**
  * Returns the current mode of the system, either "ro" (read-only) or "rw" (read-write)
  */

package/plug-api/types/manifest.ts

@@ -6,6 +6,48 @@ export type CodeWidgetT = {
   renderMode?: "iframe";
 };
 
+/**
+ * Predefined native menu items. Ignored in PWA builds; used by the
+ * SilverBullet desktop app to emit OS-native menu items (Cut/Copy/Paste,
+ * Quit, About, etc.) instead of a command-dispatching item.
+ */
+export type PredefinedMenuKind =
+  | "quit" | "about" | "services" | "hide" | "hideOthers" | "showAll"
+  | "closeWindow" | "minimize" | "maximize" | "fullscreen"
+  | "separator"
+  | "undo" | "redo" | "cut" | "copy" | "paste" | "selectAll";
+
+/**
+ * A single native-menu placement for a command or submenu.
+ * Desktop-app only; ignored in PWA builds.
+ *
+ * - `location`: id of the target menu or submenu (e.g. "file",
+ *   "edit.format").
+ * - `group`: sort-prefix convention "1_new", "2_dashboard", "9_close". Items
+ *   are partitioned by group within a location; groups sort alphabetically
+ *   with separators auto-inserted between them.
+ * - `order`: ascending within a group; tiebreak by label.
+ * - `label`: overrides the command's display label in the menu only.
+ * - `predefined`: emit an OS-native predefined item instead of a
+ *   command-dispatching item.
+ * - `icon`: optional icon identifier; platform support varies.
+ */
+export type MenuContribution = {
+  location: string;
+  group?: string;
+  order?: number;
+  label?: string;
+  predefined?: PredefinedMenuKind;
+  icon?: string;
+};
+
+/**
+ * A menu placement value: a single contribution, an array (multiple
+ * placements), or `null` (hide this entry on the matching platform).
+ * Desktop-app only.
+ */
+export type MenuPlacement = MenuContribution | MenuContribution[] | null;
+
 export type CommandDef = {
   name: string;
 
@@ -21,6 +63,27 @@ export type CommandDef = {
   hide?: boolean;
   requireMode?: "rw" | "ro";
   requireEditor?: "any" | "page" | "notpage" | string;
+
+  // When true, this binding is NOT registered while vim mode is active,
+  // so the key falls through to vim.
+  disableInVim?: boolean;
+
+  /**
+   * Desktop-app only. Native menu placement for this command.
+   *
+   * Naming note: the existing `key`/`mac` pair uses a bare platform name
+   * for the override. That pattern doesn't extend cleanly here — bare
+   * `mac` is already taken by the keybinding override, and `windows` /
+   * `linux` as top-level fields would be ambiguous. The `menu` + capital
+   * platform suffix pattern keeps overrides unambiguous.
+   */
+  menu?: MenuPlacement;
+  /** Platform-specific override: replaces `menu` on macOS. */
+  menuMac?: MenuPlacement;
+  /** Platform-specific override: replaces `menu` on Windows. */
+  menuWindows?: MenuPlacement;
+  /** Platform-specific override: replaces `menu` on Linux. */
+  menuLinux?: MenuPlacement;
 };
 export type CommandHookT = {
   command?: CommandDef;

package/plugs/builtin_plugs.ts

@@ -4,9 +4,9 @@ export const builtinPlugNames = [
   "editor",
   "index",
   "sync",
-  "plug-manager",
   "emoji",
   "image-viewer",
+  "configuration-manager",
 ];
 
 export const builtinPlugPaths = builtinPlugNames.map(