@silverbulletmd/silverbullet 2.4.2 → 2.5.3

package/client/space_lua/stdlib.ts

@@ -1,4 +1,5 @@
 import {
+  getMetatable,
   type ILuaFunction,
   isILuaFunction,
   isLuaTable,
@@ -17,6 +18,7 @@ import {
   luaToString,
   luaTypeOf,
   type LuaValue,
+  singleResult,
 } from "./runtime.ts";
 import { stringApi } from "./stdlib/string.ts";
 import { tableApi } from "./stdlib/table.ts";
@@ -32,6 +34,7 @@ import { luaLoad } from "./stdlib/load.ts";
 import { cryptoApi } from "./stdlib/crypto.ts";
 import { netApi } from "./stdlib/net.ts";
 import { isTaggedFloat, makeLuaFloat } from "./numeric.ts";
+import { isPromise } from "./rp.ts";
 
 const printFunction = new LuaBuiltinFunction(async (_sf, ...args) => {
   console.log(
@@ -121,23 +124,41 @@ export const eachFunction = new LuaBuiltinFunction(
   },
 );
 
-const unpackFunction = new LuaBuiltinFunction(async (sf, t: LuaTable) => {
-  const values: LuaValue[] = [];
-  for (let i = 1; i <= (t as any).length; i++) {
-    values.push(await luaGet(t, i, sf.astCtx ?? null, sf));
-  }
-  return new LuaMultiRes(values);
-});
-
 const typeFunction = new LuaBuiltinFunction(
   (_sf, value: LuaValue): string | Promise<string> => {
     return luaTypeOf(value);
   },
 );
 
-const tostringFunction = new LuaBuiltinFunction((_sf, value: any) => {
-  return luaToString(value);
-});
+// tostring() checks `__tostring` metamethod first (with live SF), then
+// falls back to the default `luaToString` representation.
+const tostringFunction = new LuaBuiltinFunction(
+  (sf, value: any): string | Promise<string> => {
+    const mt = getMetatable(value, sf);
+    if (mt) {
+      const mm = mt.rawGet("__tostring");
+      if (mm !== undefined && mm !== null) {
+        const ctx = sf.astCtx ?? {};
+        const r = luaCall(mm, [value], ctx as any, sf);
+        const unwrap = (v: any): string => {
+          const s = singleResult(v);
+          if (typeof s !== "string") {
+            throw new LuaRuntimeError(
+              "'__tostring' must return a string",
+              sf,
+            );
+          }
+          return s;
+        };
+        if (isPromise(r)) {
+          return (r as Promise<any>).then(unwrap);
+        }
+        return unwrap(r);
+      }
+    }
+    return luaToString(value);
+  },
+);
 
 const tonumberFunction = new LuaBuiltinFunction(
   (sf, value: LuaValue, base?: number) => {
@@ -255,7 +276,7 @@ const setmetatableFunction = new LuaBuiltinFunction(
 
 const rawlenFunction = new LuaBuiltinFunction(
   (_sf, value: LuaValue) => {
-    return luaLen(value, _sf);
+    return luaLen(value, _sf, true);
   },
 );
 
@@ -429,7 +450,7 @@ const nextFunction = new LuaBuiltinFunction(
 const someFunction = new LuaBuiltinFunction(async (_sf, value: any) => {
   switch (await luaTypeOf(value)) {
     case "number":
-      if (!isFinite(value)) return null;
+      if (!Number.isFinite(value)) return null;
       break;
     case "string":
       if (value.trim() === "") return null;
@@ -446,13 +467,16 @@ export function luaBuildStandardEnv() {
   const env = new LuaEnv();
   // _G global
   env.set("_G", env);
+  // Lua version string - for now it signals Lua 5.4 compatibility with
+  // selective 5.5 features; kept non-standard so callers can distinguish
+  // Space Lua from a plain Lua runtime.
+  env.set("_VERSION", "Lua 5.4+");
   // Top-level builtins
   env.set("print", printFunction);
   env.set("assert", assertFunction);
   env.set("type", typeFunction);
   env.set("tostring", tostringFunction);
   env.set("tonumber", tonumberFunction);
-  env.set("unpack", unpackFunction);
   env.set("select", selectFunction);
   env.set("next", nextFunction);
   // Iterators

package/client/space_lua/tonumber.ts

@@ -283,7 +283,7 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
     return { ok: false, value: 0 };
   }
 
-  const result = sign * (hasExp ? val * Math.pow(10, exp) : val);
+  const result = sign * (hasExp ? val * 10 ** exp : val);
   return { ok: true, value: result };
 }
 
@@ -434,7 +434,7 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
   }
 
   const frac = fracVal === 0 ? 0 : (fracVal / fracScale);
-  const result = sign * (intVal + frac) * Math.pow(2, expSign * exp);
+  const result = sign * (intVal + frac) * 2 ** (expSign * exp);
   return { ok: true, value: result };
 }
 
@@ -460,6 +460,7 @@ export function luaToNumberDetailed(
   }
 
   {
+    // biome-ignore lint/correctness/useParseIntRadix: local parseInt function, not global
     const parsed = parseInt(s);
     if (parsed.ok) {
       const v = parsed.value;

package/client/space_lua/util.ts

@@ -14,9 +14,8 @@ export function evalPromiseValues(vals: any[]): Promise<any[]> | any[] {
   }
   if (promises.length === 0) {
     return promiseResults;
-  } else {
-    return Promise.all(promises).then(() => promiseResults);
   }
+  return Promise.all(promises).then(() => promiseResults);
 }
 
 /**
@@ -36,18 +35,19 @@ async function getPivot(
   if (await compare(x, y) < 0) {
     if (await compare(y, z) < 0) {
       return y;
-    } else if (await compare(z, x) < 0) {
+    }
+    if (await compare(z, x) < 0) {
       return x;
-    } else {
-      return z;
     }
-  } else if (await compare(y, z) > 0) {
+    return z;
+  }
+  if (await compare(y, z) > 0) {
     return y;
-  } else if (await compare(z, x) > 0) {
+  }
+  if (await compare(z, x) > 0) {
     return x;
-  } else {
-    return z;
   }
+  return z;
 }
 
 /**
@@ -94,3 +94,37 @@ export async function asyncQuickSort(
   }
   return arr;
 }
+
+/**
+ * iterative async merge sort
+ * @param arr tagged array of { val, idx } elements
+ * @param compare async comparator returning <0, 0, or >0
+ */
+export async function asyncMergeSort(
+  arr: { val: any; idx: number }[],
+  compare: (
+    a: { val: any; idx: number },
+    b: { val: any; idx: number },
+  ) => Promise<number>,
+): Promise<void> {
+  const n = arr.length;
+  if (n <= 1) return;
+  const work = new Array(n);
+
+  for (let size = 1; size < n; size *= 2) {
+    for (let left = 0; left < n; left += 2 * size) {
+      const mid = Math.min(left + size, n);
+      const right = Math.min(left + 2 * size, n);
+
+      let i = left, j = mid, k = left;
+      while (i < mid && j < right) {
+        const cmp = await compare(arr[i], arr[j]);
+        if (cmp <= 0) work[k++] = arr[i++];
+        else work[k++] = arr[j++];
+      }
+      while (i < mid) work[k++] = arr[i++];
+      while (j < right) work[k++] = arr[j++];
+      for (let m = left; m < right; m++) arr[m] = work[m];
+    }
+  }
+}

package/dist/plug-compile.js

@@ -4,64 +4,14 @@
 import { Command } from "commander";
 
 // version.ts
-var version = "2.4.1";
+var version = "2.5.3";
 
 // client/plugos/plug_compile.ts
 import * as path from "node:path";
 import { readFile as readFile2, writeFile, mkdtemp, rm, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as YAML from "js-yaml";
-
-// build_deps.ts
 import * as esbuild from "esbuild";
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-function denoPlugin(options) {
-  const configPath = options?.configPath || resolve(__dirname, "deno.json");
-  const denoConfig = JSON.parse(readFileSync(configPath, "utf-8"));
-  const imports = denoConfig.imports || {};
-  return {
-    name: "deno-resolver",
-    setup(build) {
-      build.onResolve({ filter: /^file:\/\// }, (args) => {
-        const filePath = args.path.replace(/^file:\/\//, "");
-        return { path: filePath };
-      });
-      build.onResolve({ filter: /^@silverbulletmd\/silverbullet\// }, (args) => {
-        const importPath = args.path;
-        if (imports[importPath]) {
-          const resolvedPath = resolve(__dirname, imports[importPath]);
-          return { path: resolvedPath };
-        }
-        return null;
-      });
-      build.onResolve({ filter: /.*/ }, (args) => {
-        if (args.path.startsWith(".") || args.path.startsWith("/")) {
-          return null;
-        }
-        const importPath = args.path;
-        if (imports[importPath]) {
-          let mapped = imports[importPath];
-          if (mapped.startsWith("npm:")) {
-            return { path: mapped.replace(/^npm:/, ""), external: true };
-          }
-          if (mapped.startsWith("jsr:")) {
-            return { path: args.path, external: true };
-          }
-          if (mapped.startsWith("http://") || mapped.startsWith("https://")) {
-            return { path: args.path, external: true };
-          }
-          const resolvedPath = resolve(__dirname, mapped);
-          return { path: resolvedPath };
-        }
-        return null;
-      });
-    }
-  };
-}
 
 // client/asset_bundle/builder.ts
 import picomatch from "picomatch";
@@ -1365,7 +1315,19 @@ async function bundleAssets(rootPath, patterns) {
 }
 
 // client/plugos/plug_compile.ts
-var workerRuntimeUrl = `https://deno.land/x/silverbullet@${version}/client/plugos/worker_runtime.ts`;
+import { existsSync } from "node:fs";
+var currentDir = import.meta.dirname;
+var bundledPath = path.join(currentDir, "worker_runtime_bundle.js");
+var sourcePath = path.join(currentDir, "../../dist/worker_runtime_bundle.js");
+var workerRuntimeBundlePath = existsSync(bundledPath) ? bundledPath : sourcePath;
+var workerRuntimePlugin = {
+  name: "worker-runtime",
+  setup(build2) {
+    build2.onResolve({ filter: /^worker-runtime$/ }, () => ({
+      path: workerRuntimeBundlePath
+    }));
+  }
+};
 async function compileManifest(manifestPath, destPath, options = {}) {
   const rootPath = path.dirname(manifestPath);
   const manifestContent = await readFile2(manifestPath, "utf-8");
@@ -1382,7 +1344,7 @@ async function compileManifest(manifestPath, destPath, options = {}) {
     manifest.functions = {};
   }
   const jsFile = `
-import { setupMessageListener } from "${options.runtimeUrl || workerRuntimeUrl}";
+import { setupMessageListener } from "worker-runtime";
 
 // Imports
 ${Object.entries(manifest.functions).map(([funcName, def]) => {
@@ -1391,7 +1353,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 "file://${// Replacing \ with / for Windows
+    return `import {${jsFunctionName} as ${funcName}} from "${// Replacing \ with / for Windows
     path.resolve(filePath).replaceAll(
       "\\",
       "\\\\"
@@ -1432,18 +1394,14 @@ setupMessageListener(functionMapping, manifest, self.postMessage);
     outfile: outFile,
     metafile: options.info,
     treeShaking: true,
-    plugins: [
-      denoPlugin({
-        configPath: options.configPath && path.resolve(process.cwd(), options.configPath)
-      })
-    ]
+    plugins: [workerRuntimePlugin]
   });
   if (options.info) {
     const text = await esbuild.analyzeMetafile(result.metafile);
     console.log("Bundle info for", manifestPath, text);
   }
   let jsCode = await readFile2(outFile, "utf-8");
-  jsCode = patchDenoLibJS(jsCode);
+  jsCode = patchBundledJS(jsCode);
   await writeFile(outFile, jsCode, "utf-8");
   await rm(tempDir, { recursive: true, force: true });
   console.log(`Plug ${manifest.name} written to ${outFile}.`);
@@ -1478,18 +1436,16 @@ async function compileManifests(manifestFiles, dist, options = {}) {
   }
   await buildAll();
 }
-function patchDenoLibJS(code) {
+function patchBundledJS(code) {
   return code.replaceAll("/(?<=\\n)/", "/()/");
 }
-async function plugCompileCommand({ dist, debug, info, config, runtimeUrl }, ...manifestPaths) {
+async function plugCompileCommand({ dist, debug, info }, ...manifestPaths) {
   await compileManifests(
     manifestPaths,
     dist,
     {
       debug,
-      info,
-      runtimeUrl,
-      configPath: config
+      info
     }
   );
   esbuild.stop();
@@ -1498,14 +1454,12 @@ async function plugCompileCommand({ dist, debug, info, config, runtimeUrl }, ...
 
 // bin/plug-compile.ts
 var program = new Command();
-program.name("plug-compile").description("Bundle (compile) one or more plug manifests").version(version).usage("<options> <manifest paths>").argument("<manifestPaths...>", "One or more .plug.yaml manifest files").option("--debug", "Do not minify code", false).option("--info", "Print out size info per function", false).option("-w, --watch", "Watch for changes and rebuild", false).option("--dist <path>", "Folder to put the resulting .plug.json file into", ".").option("-c, --config <path>", "Path to deno.json file to use").option("--runtimeUrl <url>", "URL to worker_runtime.ts to use").action(async (manifestPaths, options) => {
+program.name("plug-compile").description("Bundle (compile) one or more plug manifests").version(version).usage("<options> <manifest paths>").argument("<manifestPaths...>", "One or more .plug.yaml manifest files").option("--debug", "Do not minify code", false).option("--info", "Print out size info per function", false).option("-w, --watch", "Watch for changes and rebuild", false).option("--dist <path>", "Folder to put the resulting .plug.json file into", ".").action(async (manifestPaths, options) => {
   await plugCompileCommand(
     {
       dist: options.dist,
       debug: options.debug,
-      info: options.info,
-      config: options.config,
-      runtimeUrl: options.runtimeUrl
+      info: options.info
     },
     ...manifestPaths
   );

package/dist/worker_runtime_bundle.js

@@ -0,0 +1,233 @@
+// plug-api/lib/crypto.ts
+function base64Decode(s) {
+  const binString = atob(s);
+  const len = binString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binString.charCodeAt(i);
+  }
+  return bytes;
+}
+function base64Encode(buffer) {
+  if (typeof buffer === "string") {
+    buffer = new TextEncoder().encode(buffer);
+  }
+  let binary = "";
+  const len = buffer.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(buffer[i]);
+  }
+  return btoa(binary);
+}
+var fixedCounter = new Uint8Array(16);
+
+// client/lib/logger.ts
+var Logger = class {
+  constructor(prefix = "", maxCaptureSize = 1e3) {
+    this.prefix = prefix;
+    this.maxCaptureSize = maxCaptureSize;
+    this.prefix = prefix;
+    this.originalConsole = {
+      log: console.log.bind(console),
+      info: console.info.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console),
+      debug: console.debug.bind(console)
+    };
+    this.patchConsole();
+  }
+  originalConsole;
+  logBuffer = [];
+  patchConsole() {
+    const createPatchedMethod = (level) => {
+      return (...args) => {
+        const prefixedArgs = this.prefix ? [this.prefix, ...args] : args;
+        this.originalConsole[level](...prefixedArgs);
+        this.captureLog(level, args);
+      };
+    };
+    console.log = createPatchedMethod("log");
+    console.info = createPatchedMethod("info");
+    console.warn = createPatchedMethod("warn");
+    console.error = createPatchedMethod("error");
+    console.debug = createPatchedMethod("debug");
+  }
+  captureLog(level, args) {
+    const entry = {
+      level,
+      timestamp: Date.now(),
+      message: args.map((arg) => {
+        if (typeof arg === "string") {
+          return arg;
+        }
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      }).join(" ")
+    };
+    this.logBuffer.push(entry);
+    if (this.logBuffer.length > this.maxCaptureSize) {
+      this.logBuffer.shift();
+    }
+  }
+  /**
+   * Posts all buffered logs to a server endpoint
+   */
+  async postToServer(logEndpoint, source) {
+    const logs = this.logBuffer;
+    if (logs.length > 0) {
+      const logCopy = [...this.logBuffer];
+      this.logBuffer = [];
+      try {
+        const resp = await fetch(logEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(logCopy.map((entry) => ({ ...entry, source })))
+        });
+        if (!resp.ok) {
+          throw new Error("Failed to post logs to server");
+        }
+      } catch (e) {
+        console.warn("Could not post logs to server", e.message);
+        this.logBuffer.unshift(...logCopy);
+      }
+    }
+  }
+};
+var globalLogger;
+function initLogger(prefix = "") {
+  globalLogger = new Logger(prefix);
+  return globalLogger;
+}
+
+// client/plugos/worker_runtime.ts
+var workerPostMessage = (_msg) => {
+  throw new Error("Not initialized yet");
+};
+var runningAsWebWorker = typeof window === "undefined" && // @ts-expect-error: globalThis
+typeof globalThis.WebSocketPair === "undefined";
+var pendingRequests = /* @__PURE__ */ new Map();
+var syscallReqId = 0;
+if (runningAsWebWorker) {
+  globalThis.syscall = async (name, ...args) => {
+    return await new Promise((resolve, reject) => {
+      syscallReqId++;
+      pendingRequests.set(syscallReqId, { resolve, reject });
+      workerPostMessage({
+        type: "sys",
+        id: syscallReqId,
+        name,
+        args
+      });
+    });
+  };
+}
+function setupMessageListener(functionMapping, manifest, postMessageFn) {
+  if (!runningAsWebWorker) {
+    return;
+  }
+  workerPostMessage = postMessageFn;
+  self.addEventListener("message", (event) => {
+    (async () => {
+      const data = event.data;
+      switch (data.type) {
+        case "inv":
+          {
+            const fn = functionMapping[data.name];
+            if (!fn) {
+              throw new Error(`Function not loaded: ${data.name}`);
+            }
+            try {
+              const result = await Promise.resolve(fn(...data.args || []));
+              workerPostMessage({
+                type: "invr",
+                id: data.id,
+                result
+              });
+            } catch (e) {
+              console.error(
+                "An exception was thrown as a result of invoking function",
+                data.name,
+                "error:",
+                e.message
+              );
+              workerPostMessage({
+                type: "invr",
+                id: data.id,
+                error: e.message
+              });
+            }
+          }
+          break;
+        case "sysr":
+          {
+            const syscallId = data.id;
+            const lookup = pendingRequests.get(syscallId);
+            if (!lookup) {
+              throw Error("Invalid request id");
+            }
+            pendingRequests.delete(syscallId);
+            if (data.error) {
+              lookup.reject(new Error(data.error));
+            } else {
+              lookup.resolve(data.result);
+            }
+          }
+          break;
+      }
+    })().catch(console.error);
+  });
+  workerPostMessage({
+    type: "manifest",
+    manifest
+  });
+  initLogger(`[${manifest.name} plug]`);
+}
+async function sandboxFetch(reqInfo, options) {
+  if (typeof reqInfo !== "string") {
+    const body = new Uint8Array(await reqInfo.arrayBuffer());
+    const encodedBody = body.length > 0 ? base64Encode(body) : void 0;
+    options = {
+      method: reqInfo.method,
+      headers: Object.fromEntries(reqInfo.headers.entries()),
+      base64Body: encodedBody
+    };
+    reqInfo = reqInfo.url;
+  }
+  return syscall("sandboxFetch.fetch", reqInfo, options);
+}
+globalThis.nativeFetch = globalThis.fetch;
+function monkeyPatchFetch() {
+  globalThis.fetch = async (reqInfo, init) => {
+    const encodedBody = init?.body ? base64Encode(
+      new Uint8Array(await new Response(init.body).arrayBuffer())
+    ) : void 0;
+    const r = await sandboxFetch(
+      reqInfo,
+      init && {
+        method: init.method,
+        headers: init.headers,
+        base64Body: encodedBody
+      }
+    );
+    return new Response(
+      r.base64Body ? base64Decode(r.base64Body) : null,
+      {
+        status: r.status,
+        headers: r.headers
+      }
+    );
+  };
+}
+if (runningAsWebWorker) {
+  monkeyPatchFetch();
+}
+export {
+  monkeyPatchFetch,
+  sandboxFetch,
+  setupMessageListener
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silverbulletmd/silverbullet",
-  "version": "2.4.2",
+  "version": "2.5.3",
   "type": "module",
   "description": "A self-hosted, web-based note taking app",
   "publishConfig": {
@@ -21,6 +21,7 @@
     "./lib/tags": "./plug-api/lib/tags.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",
     "./type/client": "./plug-api/types/client.ts",
     "./type/config": "./plug-api/types/config.ts",
     "./type/manifest": "./plug-api/types/manifest.ts",
@@ -46,16 +47,18 @@
     "!client/space_lua/**/*.bench.ts",
     "client/markdown_parser/constants.ts",
     "plugs/builtin_plugs.ts",
-    "dist/plug-compile.js"
+    "dist/plug-compile.js",
+    "dist/worker_runtime_bundle.js"
   ],
   "scripts": {
-    "build": "npm run build:plugs && npm run build:client",
+    "build": "tsx build_worker_runtime.ts && npm run build:plugs && npm run build:client",
     "build:plugs": "tsx build_plugs_libraries.ts",
     "build:client": "tsx build_client.ts",
-    "build:plug-compile": "tsx build_plug_compile.ts",
+    "build:plug-compile": "tsx build_worker_runtime.ts && tsx build_plug_compile.ts",
     "prepublishOnly": "npm run build:plug-compile",
     "test": "vitest run",
     "check": "tsc --noEmit",
+    "lint": "biome lint .",
     "bench": "vitest bench"
   },
   "dependencies": {
@@ -102,6 +105,7 @@
     "turndown": "7.2.2"
   },
   "devDependencies": {
+    "@biomejs/biome": "2.4.6",
     "@preact/preset-vite": "^2.10.3",
     "@types/gitignore-parser": "^0.0.3",
     "@types/js-yaml": "^4.0.9",
@@ -115,6 +119,7 @@
     "vitest": "^4.0.18"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.13.0",
+    "npm": ">=10.0.0"
   }
 }