@silverbulletmd/silverbullet 2.9.0 → 2.11.0

package/client/space_lua/syscalls.ts

@@ -0,0 +1,270 @@
+import type { ASTCtx, LuaBlock, LuaExpression } from "./ast.ts";
+import { evalExpression } from "./eval.ts";
+import { parseBlock, parseExpressionString } from "./parse.ts";
+import {
+  type PrintOptions,
+  prettyPrintBlock,
+  prettyPrintExpression,
+} from "./pretty_print.ts";
+import {
+  isILuaFunction,
+  LuaEnv,
+  LuaStackFrame,
+  LuaTable,
+  luaGet,
+  luaKeys,
+  luaToString,
+  luaTypeOf,
+  luaValueToJS,
+} from "./runtime.ts";
+import { buildThreadLocalEnv } from "../space_lua_api.ts";
+import type { SysCallMapping, System } from "../plugos/system.ts";
+import { isSendable } from "../plugos/util.ts";
+import type {
+  LuaFunctionInfo,
+  LuaPropertyInspection,
+  LuaValueInspection,
+} from "../../plug-api/types/index.ts";
+import { encodeRef } from "../../plug-api/lib/ref.ts";
+import { resolveASTReference } from "../space_lua.ts";
+
+async function inspectValue(
+  value: unknown,
+  path: string[],
+): Promise<Omit<LuaValueInspection, "properties">> {
+  const type = value instanceof LuaEnv ? "table" : await luaTypeOf(value);
+  if (!isILuaFunction(value)) {
+    return { type };
+  }
+  const functionInfo: LuaFunctionInfo = {
+    ...(value.info ?? { kind: "builtin" }),
+    name: value.info?.name ?? path.join("."),
+  };
+  const definitionRef =
+    functionInfo.kind === "lua" && functionInfo.source
+      ? resolveASTReference(functionInfo.source as ASTCtx)
+      : null;
+  return {
+    type,
+    functionInfo,
+    definition: definitionRef ? encodeRef(definitionRef) : undefined,
+  };
+}
+
+async function inspectLuaPath(
+  env: LuaEnv,
+  path: string[],
+): Promise<LuaValueInspection | null> {
+  const sf = LuaStackFrame.createWithGlobalEnv(env);
+  let value: unknown = env;
+  for (const key of path) {
+    value = await luaGet(value, key, null, sf);
+    if (value === null || value === undefined) {
+      return null;
+    }
+  }
+
+  const properties: LuaPropertyInspection[] = [];
+  const keys =
+    value instanceof LuaEnv
+      ? value.keys()
+      : value instanceof LuaTable ||
+          Array.isArray(value) ||
+          (typeof value === "object" && value !== null)
+        ? luaKeys(value)
+        : [];
+  for (const key of [...new Set(keys)]
+    .filter((candidate): candidate is string => typeof candidate === "string")
+    .sort()) {
+    const child = await luaGet(value, key, null, sf);
+    if (child === null || child === undefined) continue;
+    properties.push({
+      key,
+      ...(await inspectValue(child, [...path, key])),
+    });
+  }
+
+  return {
+    ...(await inspectValue(value, path)),
+    properties,
+  };
+}
+
+export function luaSyscalls(
+  system: System<any>,
+  getEnvironment: () => LuaEnv,
+): SysCallMapping {
+  return {
+    "lua.parseBlock": {
+      callback: (_ctx, code: string): LuaBlock => parseBlock(code),
+      description:
+        "Parses a Space Lua chunk and returns its AST. Blocks retain comments in source order with their exact text, kind, and source range.",
+      parameters: [
+        { name: "code", type: "string", description: "Lua code to parse." },
+      ],
+      returns: [{ type: "table", description: "Parsed Lua block AST." }],
+      examples: [
+        {
+          code: 'local ast = lua.parseBlock("print(\\"Hello\\")")',
+        },
+      ],
+      see: "API/lua",
+    },
+    // Deprecated alias for `lua.parseBlock`, kept for backwards compatibility.
+    "lua.parse": {
+      callback: (_ctx, code: string): LuaBlock => parseBlock(code),
+      description: "Deprecated alias for lua.parseBlock.",
+      parameters: [
+        { name: "code", type: "string", description: "Lua code to parse." },
+      ],
+      returns: [{ type: "table", description: "Parsed Lua block AST." }],
+      deprecated: "Use lua.parseBlock instead.",
+      see: "API/lua",
+    },
+    "lua.parseExpression": {
+      callback: (_ctx, expression: string): LuaExpression =>
+        parseExpressionString(expression),
+      description: "Parses a Space Lua expression and returns its AST.",
+      parameters: [
+        {
+          name: "expression",
+          type: "string",
+          description: "Lua expression to parse.",
+        },
+      ],
+      returns: [{ type: "table", description: "Parsed expression AST." }],
+      examples: [
+        {
+          code: 'local expression = lua.parseExpression("1 + 2 * 3")',
+        },
+      ],
+      see: "API/lua",
+    },
+    "lua.prettyPrintBlock": {
+      callback: (_ctx, block: LuaBlock, opts?: PrintOptions): string =>
+        prettyPrintBlock(block, opts),
+      description:
+        "Pretty-prints a parsed Space Lua block. Comments are preserved while their placement and indentation are normalized.",
+      parameters: [
+        { name: "block", type: "table", description: "Parsed block AST." },
+        {
+          name: "options",
+          type: "table",
+          description:
+            "Formatting options: `indentWidth`, `quote`, and `trailingComma`.",
+          optional: true,
+        },
+      ],
+      returns: [{ type: "string", description: "Formatted Lua source." }],
+      examples: [
+        {
+          code: 'local formatted = lua.prettyPrintBlock(lua.parseBlock("if a then return 1 end"))',
+        },
+      ],
+      see: "API/lua",
+    },
+    "lua.prettyPrintExpression": {
+      callback: (
+        _ctx,
+        expression: LuaExpression,
+        opts?: PrintOptions,
+      ): string => prettyPrintExpression(expression, opts),
+      description: "Pretty-prints a parsed Space Lua expression.",
+      parameters: [
+        {
+          name: "expression",
+          type: "table",
+          description: "Parsed expression AST.",
+        },
+        {
+          name: "options",
+          type: "table",
+          description:
+            "Formatting options: `indentWidth`, `quote`, and `trailingComma`.",
+          optional: true,
+        },
+      ],
+      returns: [{ type: "string", description: "Formatted Lua source." }],
+      examples: [
+        {
+          code: 'local formatted = lua.prettyPrintExpression(lua.parseExpression("{a=1,b=2}"))',
+        },
+      ],
+      see: "API/lua",
+    },
+    /**
+     * Evaluates a Lua expression and returns the result as a JavaScript value
+     * @param _ctx
+     * @param expression
+     * @returns
+     */
+    "lua.evalExpression": {
+      callback: async (_ctx, expression: string) => {
+        try {
+          const ast = parseExpressionString(expression);
+          const globalEnv = getEnvironment();
+          const env = await buildThreadLocalEnv(system, globalEnv);
+          const sf = new LuaStackFrame(env, null);
+          const luaResult = await evalExpression(ast, globalEnv, sf);
+          const jsResult = luaValueToJS(luaResult, sf);
+          if (isSendable(jsResult)) {
+            return jsResult;
+          } else {
+            // This may evaluate to e.g. a function, which is not sendable, in this case we'll console.warn and return a stringified version of the result
+            console.warn(
+              "Lua eval result is not sendable, returning stringified version",
+              jsResult,
+            );
+            return luaToString(luaResult);
+          }
+        } catch (e: any) {
+          console.error("Lua eval error: ", e.message, e.sf?.astCtx);
+          throw e;
+        }
+      },
+      description: "Evaluates a Space Lua expression.",
+      parameters: [
+        {
+          name: "expression",
+          type: "string",
+          description: "Lua expression to evaluate.",
+        },
+      ],
+      returns: [{ description: "Evaluated result." }],
+      examples: [
+        {
+          code: 'local result = lua.evalExpression("1 + 2 * 3")\nprint(result)',
+        },
+      ],
+      see: "API/lua",
+    },
+    "lua.inspect": {
+      callback: (_ctx, path: string[] = []) =>
+        inspectLuaPath(getEnvironment(), path),
+      description:
+        "Inspects a value in the live Space Lua environment and returns serializable type, function, definition, and property metadata.",
+      parameters: [
+        {
+          name: "path",
+          type: "table",
+          description:
+            "Sequence of property names from the global environment; omit to inspect globals.",
+          optional: true,
+        },
+      ],
+      returns: [
+        {
+          type: "table|nil",
+          description:
+            "Inspection metadata, or nil when the requested path does not exist.",
+        },
+      ],
+      examples: [
+        {
+          code: 'local info = lua.inspect({"editor", "getText"})',
+        },
+      ],
+      see: "API/lua",
+    },
+  };
+}

package/client/space_lua/tonumber.ts

@@ -142,7 +142,6 @@ function parseInt(s: string): { ok: boolean; value: number } {
   let acc = 0;
   let any = false;
 
-  // hex?
   if (s.charCodeAt(i) === 48 && i + 1 < n) {
     // '0'
     const x = s.charCodeAt(i + 1);
@@ -179,7 +178,6 @@ function parseInt(s: string): { ok: boolean; value: number } {
     }
   }
 
-  // decimal integer
   while (i < n) {
     const c = s.charCodeAt(i);
     if (c < 48 || c > 57) {
@@ -221,7 +219,6 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
   let fracAny = false;
   let val = 0;
 
-  // integer part
   while (i < n) {
     const c = s.charCodeAt(i);
     if (c < 48 || c > 57) {
@@ -233,7 +230,6 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
     i++;
   }
 
-  // fractional part
   if (i < n) {
     if (s.charCodeAt(i) === 46) {
       // '.'
@@ -253,7 +249,6 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
     }
   }
 
-  // exponent
   let exp = 0;
   let hasExp = false;
   if (i < n) {
@@ -347,7 +342,6 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
   let anyHex = false;
   let sawDot = false;
 
-  // integer hex digits
   while (i < n) {
     const c = s.charCodeAt(i);
     let d = -1;
@@ -371,7 +365,6 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
     i++;
   }
 
-  // optional fractional part
   if (i < n) {
     if (s.charCodeAt(i) === 46) {
       // '.'
@@ -444,7 +437,6 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
         return { ok: false, value: 0 };
       }
     } else {
-      // no exponent marker
       if (!sawDot) {
         // without dot we must reject so parseInt can claim it as integer
         return { ok: false, value: 0 };
@@ -456,7 +448,6 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
       exp = 0; // implicit p0
     }
   } else {
-    // end of string
     if (!sawDot) {
       return { ok: false, value: 0 };
     }

package/dist/plug-compile.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // version.ts
-var version = "2.9.0";
+var version = "2.11.0";
 
 // client/plugos/plug_compile.ts
 import * as path from "node:path";
@@ -1371,8 +1371,7 @@ ${Object.entries(manifest.functions).map(([funcName, def]) => {
     }
     let [filePath, jsFunctionName] = def.path.split(":");
     filePath = path.join(rootPath, filePath);
-    return `import {${jsFunctionName} as ${funcName}} from "${// Replacing \ with / for Windows
-    path.resolve(filePath).replaceAll("\\", "\\\\")}";
+    return `import {${jsFunctionName} as ${funcName}} from "${path.resolve(filePath).replaceAll("\\", "\\\\")}";
 `;
   }).join("")}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silverbulletmd/silverbullet",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "type": "module",
   "description": "A self-hosted, web-based note taking app",
   "publishConfig": {
@@ -15,20 +15,26 @@
     "./lib/tree": "./plug-api/lib/tree.ts",
     "./lib/ref": "./plug-api/lib/ref.ts",
     "./lib/resolve": "./plug-api/lib/resolve.ts",
+    "./lib/resolve_path": "./plug-api/lib/resolve_path.ts",
+    "./lib/link_write": "./plug-api/lib/link_write.ts",
     "./lib/dates": "./plug-api/lib/dates.ts",
+    "./lib/fuzzy": "./plug-api/lib/fuzzy.ts",
     "./lib/async": "./plug-api/lib/async.ts",
     "./lib/crypto": "./plug-api/lib/crypto.ts",
     "./lib/limited_map": "./plug-api/lib/limited_map.ts",
     "./lib/tags": "./plug-api/lib/tags.ts",
+    "./lib/collation": "./plug-api/lib/collation.ts",
     "./lib/transclusion": "./plug-api/lib/transclusion.ts",
     "./lib/native_fetch": "./plug-api/lib/native_fetch.ts",
     "./lib/query_expression": "./plug-api/lib/query_expression.ts",
+    "./lib/panel_styles": "./plug-api/lib/panel_styles.ts",
     "./type/client": "./plug-api/types/client.ts",
     "./type/config": "./plug-api/types/config.ts",
     "./type/manifest": "./plug-api/types/manifest.ts",
     "./type/namespace": "./plug-api/types/namespace.ts",
     "./type/datastore": "./plug-api/types/datastore.ts",
     "./type/event": "./plug-api/types/event.ts",
+    "./type/revisions": "./plug-api/types/revisions.ts",
     "./type/index": "./plug-api/types/index.ts"
   },
   "bin": {
@@ -41,6 +47,7 @@
     "client/plugos/**/*.ts",
     "!client/plugos/**/*.test.ts",
     "client/asset_bundle/bundle.ts",
+    "client/config.ts",
     "client/data/kv_primitives.ts",
     "client/data/datastore.ts",
     "client/space_lua/**/*.ts",
@@ -48,6 +55,7 @@
     "!client/space_lua/**/*.bench.ts",
     "client/markdown_parser/constants.ts",
     "plugs/builtin_plugs.ts",
+    "plugs/index/types.ts",
     "dist/plug-compile.js"
   ],
   "scripts": {
@@ -55,16 +63,17 @@
     "build:plugs": "tsx build/build_plugs.ts",
     "build:client": "tsx build/build_client.ts",
     "build:plug-compile": "tsx build/build_plug_compile.ts",
+    "prebuild:client": "node build/patch_codemirror_view.mjs",
     "prepublishOnly": "npm run build:plug-compile",
     "test": "vitest run",
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && tsc -p tsconfig.e2e.json",
     "lint": "biome lint .",
     "fmt": "biome format --write .",
     "fmt:check": "biome format .",
     "bench": "vitest bench",
     "index-stats": "tsx plugs/index/index_stats.ts",
-    "test:e2e": "npx playwright test",
-    "test:e2e:headed": "npx playwright test --headed"
+    "test:e2e": "npx playwright test --project=chromium",
+    "test:e2e:headed": "npx playwright test --project=chromium --headed"
   },
   "peerDependencies": {
     "preact": "^10.25.0"
@@ -92,8 +101,10 @@
     "@lezer/lr": "1.4.8",
     "@lezer/markdown": "1.6.3",
     "@msgpack/msgpack": "3.1.3",
+    "@noble/hashes": "2.0.1",
     "@replit/codemirror-lang-nix": "6.0.1",
     "@replit/codemirror-vim": "6.3.0",
+    "@types/js-yaml": "^4.0.9",
     "commander": "^14.0.3",
     "crelt": "1.0.6",
     "d3-force": "^3.0.0",
@@ -118,7 +129,6 @@
     "@preact/preset-vite": "^2.10.3",
     "@types/d3-force": "^3.0.10",
     "@types/gitignore-parser": "^0.0.3",
-    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "@types/turndown": "^5.0.6",
     "fake-indexeddb": "6.0.1",

package/plug-api/lib/async.ts

@@ -11,7 +11,6 @@ export function throttle(
       }, limit);
     }
   };
-  // Immediately execute any pending call and cancel the timer
   throttled.flush = () => {
     if (timer) {
       clearTimeout(timer);
@@ -91,7 +90,7 @@ export class PromiseQueue {
       reject(error);
     }
 
-    void this.process(); // Continue processing the next promise in the queue
+    void this.process();
   }
 }
 
@@ -108,17 +107,13 @@ export async function batchRequests<I, O>(
   batchSize: number,
 ): Promise<O[]> {
   const results: O[] = [];
-  // Split values into batches of batchSize
   const batches: I[][] = [];
   for (let i = 0; i < values.length; i += batchSize) {
     batches.push(values.slice(i, i + batchSize));
   }
-  // Run fn on them in parallel
   const batchResults = await Promise.all(batches.map(fn));
-  // Flatten the results
   for (const batchResult of batchResults) {
     if (Array.isArray(batchResult)) {
-      // If fn returns an array, collect them
       results.push(...batchResult);
     }
   }

package/plug-api/lib/collation.ts

@@ -0,0 +1,22 @@
+import type { QueryCollationConfig } from "../types/config.ts";
+
+/**
+ * Compares two values the same way the query engine's `order by` does:
+ * codepoint order by default, or `Intl.Collator` order when the space's
+ * `queryCollation` config turns it on and both sides are strings.
+ */
+export function compareCollated(
+  // deno-lint-ignore no-explicit-any
+  a: any,
+  // deno-lint-ignore no-explicit-any
+  b: any,
+  collation: QueryCollationConfig | undefined,
+  collator: Intl.Collator,
+): number {
+  if (collation?.enabled && typeof a === "string" && typeof b === "string") {
+    return collator.compare(a, b);
+  }
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}

package/plug-api/lib/crypto.ts

@@ -1,3 +1,5 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+
 export function base64Decode(s: string): Uint8Array {
   const binString = atob(s);
   const len = binString.length;
@@ -32,31 +34,33 @@ export function base64DecodeDataUrl(dataUrl: string): Uint8Array {
   return base64Decode(b64Encoded);
 }
 
-/**
- * Perform sha256 hash using the browser's crypto APIs
- * Note: this will only work over HTTPS
- * @param message
- */
 export async function hashSHA256(
   message: string | Uint8Array,
 ): Promise<string> {
-  // Transform the string into an ArrayBuffer
   const encoder = new TextEncoder();
   const data: Uint8Array =
     typeof message === "string" ? encoder.encode(message) : message;
 
-  // Generate the hash
-  const hashBuffer = await globalThis.crypto.subtle.digest(
-    "SHA-256",
-    data as BufferSource,
-  );
+  const hashBuffer = globalThis.crypto.subtle
+    ? await globalThis.crypto.subtle.digest("SHA-256", data as BufferSource)
+    : sha256(data);
 
-  // Transform the hash into a hex string
   return Array.from(new Uint8Array(hashBuffer))
     .map((b) => b.toString(16).padStart(2, "0"))
     .join("");
 }
 
+export function randomUUID(): string {
+  if (globalThis.crypto.randomUUID) return globalThis.crypto.randomUUID();
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = (bytes[6] & 0x0f) | 0x40;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = Array.from(bytes, (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 /**
  * To avoid database clashes based on space folder path name, base URLs and encryption keys we derive
  * a database name from a hash of all these combined together
@@ -117,7 +121,6 @@ export async function encryptAesGcm(
   );
   const encrypted = new Uint8Array(encryptedBuffer);
 
-  // Prepend IV to ciphertext
   const result = new Uint8Array(iv.length + encrypted.length);
   result.set(iv, 0);
   result.set(encrypted, iv.length);
@@ -143,10 +146,8 @@ export async function deriveCTRKeyFromPassword(
   password: string,
   salt: Uint8Array,
 ): Promise<CryptoKey> {
-  // Encode password to ArrayBuffer
   const passwordBytes = new TextEncoder().encode(password);
 
-  // Import password as a CryptoKey
   const baseKey = await globalThis.crypto.subtle.importKey(
     "raw",
     passwordBytes,

package/plug-api/lib/dates.ts

@@ -2,6 +2,39 @@ export function niceDate(d: Date): string {
   return localDateString(d).split("T")[0];
 }
 
+/** Largest-unit-first, so the cascade below divides down to the right one. */
+const RELATIVE_DIVISIONS: {
+  amount: number;
+  unit: Intl.RelativeTimeFormatUnit;
+}[] = [
+  { amount: 60, unit: "second" },
+  { amount: 60, unit: "minute" },
+  { amount: 24, unit: "hour" },
+  { amount: 7, unit: "day" },
+  { amount: 4.34524, unit: "week" },
+  { amount: 12, unit: "month" },
+];
+
+/**
+ * "10 minutes ago", "yesterday", "3 months ago". `numeric: "auto"` is what
+ * turns the -1 cases into words rather than "1 day ago".
+ */
+export function relativeTime(
+  timestamp: number,
+  locale?: string,
+  now: number = Date.now(),
+): string {
+  const formatter = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  let duration = (timestamp - now) / 1000;
+  for (const { amount, unit } of RELATIVE_DIVISIONS) {
+    if (Math.abs(duration) < amount) {
+      return formatter.format(Math.round(duration), unit);
+    }
+    duration /= amount;
+  }
+  return formatter.format(Math.round(duration), "year");
+}
+
 export function localDateString(d: Date): string {
   return (
     d.getFullYear() +