@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/space_lua/stdlib/format.ts

@@ -58,7 +58,8 @@ function parseSpec(
 
   // Parse width
   let width = 0;
-  if (i < len && fmt.charCodeAt(i) === 42) { // '*'
+  if (i < len && fmt.charCodeAt(i) === 42) {
+    // '*'
     width = -1;
     i++;
   } else {
@@ -71,10 +72,12 @@ function parseSpec(
   // Parse precision
   let hasPrec = false;
   let prec = 0;
-  if (i < len && fmt.charCodeAt(i) === 46) { // '.'
+  if (i < len && fmt.charCodeAt(i) === 46) {
+    // '.'
     hasPrec = true;
     i++;
-    if (i < len && fmt.charCodeAt(i) === 42) { // '*'
+    if (i < len && fmt.charCodeAt(i) === 42) {
+      // '*'
       prec = -1;
       i++;
     } else {
@@ -109,9 +112,10 @@ function parseSpec(
 function pad(s: string, width: number, flags: number, numPad: boolean): string {
   if (width <= 0 || s.length >= width) return s;
   const n = width - s.length;
-  if (numPad && (flags & FLAG_ZERO) && !(flags & FLAG_MINUS)) {
+  if (numPad && flags & FLAG_ZERO && !(flags & FLAG_MINUS)) {
     let signLen = 0;
-    if (s.charCodeAt(0) === 45 || s.charCodeAt(0) === 43) { // '-' or '+'
+    if (s.charCodeAt(0) === 45 || s.charCodeAt(0) === 43) {
+      // '-' or '+'
       signLen = 1;
     } else if (
       s.charCodeAt(0) === 48 &&
@@ -128,8 +132,8 @@ function pad(s: string, width: number, flags: number, numPad: boolean): string {
 }
 
 function addSign(s: string, flags: number): string {
-  if (flags & FLAG_PLUS) return "+" + s;
-  if (flags & FLAG_SPACE) return " " + s;
+  if (flags & FLAG_PLUS) return `+${s}`;
+  if (flags & FLAG_SPACE) return ` ${s}`;
   return s;
 }
 
@@ -200,7 +204,7 @@ function formatInt(n: number, spec: FormatSpec): string {
 
   let result: string;
   if (neg) {
-    result = "-" + prefix + digits;
+    result = `-${prefix}${digits}`;
   } else {
     result = addSign(prefix + digits, spec.flags);
   }
@@ -216,7 +220,7 @@ function formatFloat(n: number, spec: FormatSpec): string {
   const lower = code | 32; // to lowercase
 
   // Lua convention
-  if (!isFinite(n)) {
+  if (!Number.isFinite(n)) {
     let s: string;
     if (n !== n) {
       s = upper ? "-NAN" : "-nan";
@@ -235,14 +239,17 @@ function formatFloat(n: number, spec: FormatSpec): string {
 
   let body: string;
 
-  if (lower === 102) { // 'f'
+  if (lower === 102) {
+    // 'f'
     body = abs.toFixed(prec);
-  } else if (lower === 101) { // 'e'
+  } else if (lower === 101) {
+    // 'e'
     body = abs.toExponential(prec);
     // Ensure exponent has at least 2 digits
     body = ensureExpTwoDigits(body);
-  } else { // 'g'
-    const gPrec = (prec === 0) ? 1 : prec;
+  } else {
+    // 'g'
+    const gPrec = prec === 0 ? 1 : prec;
     if (abs === 0) {
       body = "0";
     } else {
@@ -268,35 +275,35 @@ function formatFloat(n: number, spec: FormatSpec): string {
   }
 
   // Alt flag for 'f'/'e': ensure decimal point exists
-  if ((spec.flags & FLAG_HASH) && lower !== 103) {
+  if (spec.flags & FLAG_HASH && lower !== 103) {
     if (body.indexOf(".") === -1) {
       // Insert dot before 'e' if present, else append
       const eIdx = body.indexOf("e");
       const EIdx = body.indexOf("E");
       const expIdx = eIdx !== -1 ? eIdx : EIdx;
       if (expIdx !== -1) {
-        body = body.slice(0, expIdx) + "." + body.slice(expIdx);
+        body = `${body.slice(0, expIdx)}.${body.slice(expIdx)}`;
       } else {
-        body = body + ".";
+        body = `${body}.`;
       }
     }
   }
 
   // Alt flag for 'g': keep trailing zeros but ensure decimal point
-  if ((spec.flags & FLAG_HASH) && lower === 103) {
+  if (spec.flags & FLAG_HASH && lower === 103) {
     if (body.indexOf(".") === -1) {
       const expIdx = findExpIndex(body);
       if (expIdx !== -1) {
-        body = body.slice(0, expIdx) + "." + body.slice(expIdx);
+        body = `${body.slice(0, expIdx)}.${body.slice(expIdx)}`;
       } else {
-        body = body + ".";
+        body = `${body}.`;
       }
     }
   }
 
   let result: string;
   if (neg) {
-    result = "-" + body;
+    result = `-${body}`;
   } else {
     result = addSign(body, spec.flags);
   }
@@ -322,7 +329,7 @@ function ensureExpTwoDigits(s: string): string {
   const digitStart = signIdx + 1;
   const expLen = s.length - digitStart;
   if (expLen < 2) {
-    return s.slice(0, digitStart) + "0" + s.slice(digitStart);
+    return `${s.slice(0, digitStart)}0${s.slice(digitStart)}`;
   }
   return s;
 }
@@ -337,7 +344,8 @@ function stripTrailingZerosG(s: string): string {
   if (dotIdx === -1) return s; // nothing to strip
 
   let end = mantissa.length;
-  while (end > dotIdx + 1 && mantissa.charCodeAt(end - 1) === 48) { // '0'
+  while (end > dotIdx + 1 && mantissa.charCodeAt(end - 1) === 48) {
+    // '0'
     end--;
   }
   // Remove dot if nothing after it
@@ -353,7 +361,7 @@ function formatHexFloat(n: number, spec: FormatSpec): string {
   const code = spec.spec;
   const upper = code === 65; // 'A'
 
-  if (!isFinite(n)) {
+  if (!Number.isFinite(n)) {
     let s: string;
     if (n !== n) {
       s = upper ? "-NAN" : "-nan";
@@ -373,7 +381,7 @@ function formatHexFloat(n: number, spec: FormatSpec): string {
   if (abs === 0) {
     const prec = spec.hasPrec ? spec.prec : 0;
     if (prec > 0) {
-      body = "0x0." + "0".repeat(prec) + "p+0";
+      body = `0x0.${"0".repeat(prec)}p+0`;
     } else {
       body = "0x0p+0";
     }
@@ -389,20 +397,21 @@ function formatHexFloat(n: number, spec: FormatSpec): string {
     if (pIdx !== -1) {
       let hasDot = false;
       for (let k = 0; k < pIdx; k++) {
-        if (body.charCodeAt(k) === 46) { // '.'
+        if (body.charCodeAt(k) === 46) {
+          // '.'
           hasDot = true;
           break;
         }
       }
       if (!hasDot) {
-        body = body.slice(0, pIdx) + "." + body.slice(pIdx);
+        body = `${body.slice(0, pIdx)}.${body.slice(pIdx)}`;
       }
     }
   }
 
   let result: string;
   if (neg) {
-    result = "-" + body;
+    result = `-${body}`;
   } else {
     result = addSign(body, spec.flags);
   }
@@ -436,8 +445,8 @@ function hexFloatBody(abs: number, spec: FormatSpec): string {
   const view = new DataView(buf.buffer);
   view.setFloat64(0, abs);
   const bits = view.getBigUint64(0);
-  const biasedExp = Number((bits >> 52n) & 0x7FFn);
-  const frac = bits & 0xFFFFFFFFFFFFFn;
+  const biasedExp = Number((bits >> 52n) & 0x7ffn);
+  const frac = bits & 0xfffffffffffffn;
 
   let exponent: number;
   let mantBits: bigint;
@@ -474,9 +483,9 @@ function hexFloatBody(abs: number, spec: FormatSpec): string {
 
   const expSign = exponent >= 0 ? "+" : "";
   if (fracHex.length > 0) {
-    return "0x" + firstDigit + "." + fracHex + "p" + expSign + exponent;
+    return `0x${firstDigit}.${fracHex}p${expSign}${exponent}`;
   }
-  return "0x" + firstDigit + "p" + expSign + exponent;
+  return `0x${firstDigit}p${expSign}${exponent}`;
 }
 
 // Convert 52-bit value to 13 hex digits, zero-padded
@@ -557,7 +566,8 @@ function padHexRight(s: string, len: number): string {
 
 function stripHexTrailingZeros(s: string): string {
   let end = s.length;
-  while (end > 0 && s.charCodeAt(end - 1) === 48) { // '0'
+  while (end > 0 && s.charCodeAt(end - 1) === 48) {
+    // '0'
     end--;
   }
   if (end === s.length) return s;
@@ -581,7 +591,7 @@ function quoteString(s: string): string {
         if (ds.length < 3) out += "0".repeat(3 - ds.length);
         out += ds;
       } else {
-        out += "\\" + c.toString();
+        out += `\\${c.toString()}`;
       }
     } else {
       out += String.fromCharCode(c);
@@ -643,7 +653,7 @@ function toPointer(v: unknown): string {
       id = nextId++;
       stringIds.set(key, id);
     }
-    return "0x" + id.toString(16).padStart(14, "0");
+    return `0x${id.toString(16).padStart(14, "0")}`;
   }
 
   const obj = v as object;
@@ -652,7 +662,7 @@ function toPointer(v: unknown): string {
     id = nextId++;
     objectIds.set(obj, id);
   }
-  return "0x" + id.toString(16).padStart(14, "0");
+  return `0x${id.toString(16).padStart(14, "0")}`;
 }
 
 function formatPointer(v: unknown, spec: FormatSpec): string {
@@ -669,7 +679,8 @@ export function luaFormat(fmt: string, ...args: any[]): string {
 
   while (i < len) {
     const c = fmt.charCodeAt(i);
-    if (c !== 37) { // not '%'
+    if (c !== 37) {
+      // not '%'
       // Fast path: scan for next '%' or end
       let j = i + 1;
       while (j < len && fmt.charCodeAt(j) !== 37) j++;
@@ -743,15 +754,18 @@ export function luaFormat(fmt: string, ...args: any[]): string {
           false,
         );
         break;
-      case 112: { // 'p'
+      case 112: {
+        // 'p'
         out += formatPointer(args[ai++], spec);
         break;
       }
-      case 113: { // 'q'
+      case 113: {
+        // 'q'
         out += formatQ(args[ai++]);
         break;
       }
-      case 115: { // 's'
+      case 115: {
+        // 's'
         let s = String(args[ai++]);
         if (spec.hasPrec && s.length > spec.prec) {
           s = s.slice(0, spec.prec);

package/client/space_lua/stdlib/js.ts

@@ -12,13 +12,9 @@ export const jsApi = new LuaTable({
    * @param args - The arguments to pass to the constructor.
    * @returns The new instance.
    */
-  new: new LuaBuiltinFunction(
-    (sf, constructorFn: any, ...args) => {
-      return new constructorFn(
-        ...args.map((v) => luaValueToJS(v, sf)),
-      );
-    },
-  ),
+  new: new LuaBuiltinFunction((sf, constructorFn: any, ...args) => {
+    return new constructorFn(...args.map((v) => luaValueToJS(v, sf)));
+  }),
   /**
    * Imports a JavaScript module.
    * @param url - The URL of the module to import.

package/client/space_lua/stdlib/load.ts

@@ -18,9 +18,7 @@ export function luaLoad(code: LuaValue, sf: LuaStackFrame): LuaValue {
 
     // Be vocal when no _GLOBAL is set
     if (!globalEnvMaybe) {
-      console.warn(
-        "load() called without _GLOBAL in thread-local environment",
-      );
+      console.warn("load() called without _GLOBAL in thread-local environment");
       return new LuaMultiRes([null, "Global environment not set"]);
     }
 

package/client/space_lua/stdlib/math.ts

@@ -4,7 +4,11 @@ import {
   LuaRuntimeError,
   LuaTable,
 } from "../runtime.ts";
-import { isNegativeZero, isTaggedFloat } from "../numeric.ts";
+import { isNegativeZero, isTaggedFloat, makeLuaFloat } from "../numeric.ts";
+import { LuaPRNG } from "./prng.ts";
+
+// One PRNG per module load, auto-seeded at startup
+const prng = new LuaPRNG();
 
 // Fast unwrap: avoids function call overhead for the common plain-number case
 function untagNumber(x: any): number {
@@ -40,6 +44,29 @@ export const mathApi = new LuaTable({
     }
     return null;
   }),
+
+  /**
+   * If the value x is representable as a Lua integer, returns an integer
+   * with that value. Otherwise returns nil.
+   * Strings are NOT accepted — only Lua number values.
+   */
+  tointeger: new LuaBuiltinFunction((_sf, x?: any) => {
+    if (typeof x === "number") {
+      return Number.isInteger(x) && Number.isFinite(x) ? x : null;
+    }
+    if (isTaggedFloat(x)) {
+      const n = x.value;
+      return Number.isInteger(n) && Number.isFinite(n) ? n : null;
+    }
+    if (typeof x === "string") {
+      const n = untagNumber(x); // Number(x) coerces the string
+      if (Number.isNaN(n) || !Number.isFinite(n) || !Number.isInteger(n))
+        return null;
+      return n;
+    }
+    return null;
+  }),
+
   /**
    * When called without arguments, returns a pseudo-random float with
    * uniform distribution in the range [0,1). When called with two
@@ -52,51 +79,21 @@ export const mathApi = new LuaTable({
   random: new LuaBuiltinFunction((_sf, m?: number, n?: number) => {
     if (m !== undefined) m = untagNumber(m);
     if (n !== undefined) n = untagNumber(n);
-
-    if (m === undefined && n === undefined) {
-      return Math.random();
-    }
-
-    if (!Number.isInteger(m)) {
-      throw new LuaRuntimeError(
-        "bad argument #1 to 'math.random' (integer expected)",
-        _sf,
-      );
-    }
-
-    if (n === undefined) {
-      if (m! == 0) {
-        const high = Math.floor(Math.random() * 0x100000000);
-        const low = Math.floor(Math.random() * 0x100000000);
-        let result = (BigInt(high) << 32n) | BigInt(low);
-        if (result & (1n << 63n)) {
-          result -= 1n << 64n;
-        }
-        return result;
-      }
-      if (m! < 1) {
-        throw new LuaRuntimeError(
-          "bad argument #1 to 'math.random' (interval is empty)",
-          _sf,
-        );
-      }
-      return Math.floor(Math.random() * m!) + 1;
+    try {
+      return prng.random(m, n);
+    } catch (e: any) {
+      throw new LuaRuntimeError(e.message, _sf);
     }
-
-    if (!Number.isInteger(n!)) {
-      throw new LuaRuntimeError(
-        "bad argument #2 to 'math.random' (integer expected)",
-        _sf,
-      );
-    }
-
-    if (n! < m!) {
-      throw new LuaRuntimeError(
-        "bad argument #1 to 'math.random' (interval is empty)",
-        _sf,
-      );
-    }
-    return Math.floor(Math.random() * (n! - m! + 1)) + m!;
+  }),
+  /**
+   * Seeds the pseudo-random generator. With no arguments, uses a
+   * time-based seed. Returns the two seed integers used (Lua 5.4 contract).
+   */
+  randomseed: new LuaBuiltinFunction((_sf, x?: number, y?: number) => {
+    if (x !== undefined) x = untagNumber(x);
+    if (y !== undefined) y = untagNumber(y);
+    const [s1, s2] = prng.randomseed(x, y);
+    return new LuaMultiRes([s1, s2]);
   }),
 
   // Basic functions
@@ -104,23 +101,51 @@ export const mathApi = new LuaTable({
   ceil: new LuaBuiltinFunction((_sf, x: number) => Math.ceil(untagNumber(x))),
   floor: new LuaBuiltinFunction((_sf, x: number) => Math.floor(untagNumber(x))),
   max: new LuaBuiltinFunction((_sf, ...args: number[]) =>
-    Math.max(...args.map(untagNumber))
+    Math.max(...args.map(untagNumber)),
   ),
   min: new LuaBuiltinFunction((_sf, ...args: number[]) =>
-    Math.min(...args.map(untagNumber))
+    Math.min(...args.map(untagNumber)),
   ),
 
   // Rounding and remainder
-  fmod: new LuaBuiltinFunction((_sf, x: number, y: number) =>
-    untagNumber(x) % untagNumber(y)
+  fmod: new LuaBuiltinFunction(
+    (_sf, x: number, y: number) => untagNumber(x) % untagNumber(y),
   ),
   modf: new LuaBuiltinFunction((_sf, x: number) => {
     const xn = untagNumber(x);
     const int = Math.trunc(xn);
-    const frac = xn - int;
+    // Guarantee that the `frac` part is always Lua float
+    const frac = makeLuaFloat(xn - int);
     return new LuaMultiRes([int, frac]);
   }),
 
+  // Returns m and e such that x = m * 2^e, 0.5 <= |m| < 1 (or m=0 when x=0).
+  // e is an integer. Mirrors C99/Lua.
+  // Special cases: frexp(0) = (0, 0); frexp(+-inf/nan) = (x, 0).
+  frexp: new LuaBuiltinFunction((_sf, x: number) => {
+    const xn = untagNumber(x);
+    if (xn === 0 || !Number.isFinite(xn) || Number.isNaN(xn)) {
+      return new LuaMultiRes([xn, 0]);
+    }
+    const abs = Math.abs(xn);
+    let e = Math.floor(Math.log2(abs)) + 1;
+    let m = xn / 2 ** e;
+    if (Math.abs(m) >= 1.0) {
+      e += 1;
+      m /= 2;
+    }
+    if (Math.abs(m) < 0.5) {
+      e -= 1;
+      m *= 2;
+    }
+    return new LuaMultiRes([m, e]);
+  }),
+
+  // Returns m * 2^e (the inverse of frexp).  Mirrors C99/Lua.
+  ldexp: new LuaBuiltinFunction(
+    (_sf, m: number, e: number) => untagNumber(m) * 2 ** untagNumber(e),
+  ),
+
   // Power and logarithms
   exp: new LuaBuiltinFunction((_sf, x: number) => Math.exp(untagNumber(x))),
   log: new LuaBuiltinFunction((_sf, x: number, base?: number) => {
@@ -129,8 +154,9 @@ export const mathApi = new LuaTable({
     }
     return Math.log(untagNumber(x)) / Math.log(untagNumber(base));
   }),
-  pow: new LuaBuiltinFunction((_sf, x: number, y: number) =>
-    Math.pow(untagNumber(x), untagNumber(y))
+  // Power function (deprecated in Lua 5.4 but retained for compatibility)
+  pow: new LuaBuiltinFunction(
+    (_sf, x: number, y: number) => untagNumber(x) ** untagNumber(y),
   ),
   sqrt: new LuaBuiltinFunction((_sf, x: number) => Math.sqrt(untagNumber(x))),
 
@@ -147,20 +173,20 @@ export const mathApi = new LuaTable({
     return Math.atan2(untagNumber(y), untagNumber(x));
   }),
 
-  // Hyperbolic functions
+  // Hyperbolic functions (deprecated in Lua 5.4 but retained for compatibility)
   cosh: new LuaBuiltinFunction((_sf, x: number) => Math.cosh(untagNumber(x))),
   sinh: new LuaBuiltinFunction((_sf, x: number) => Math.sinh(untagNumber(x))),
   tanh: new LuaBuiltinFunction((_sf, x: number) => Math.tanh(untagNumber(x))),
 
   // Additional utility
-  deg: new LuaBuiltinFunction((_sf, x: number) =>
-    untagNumber(x) * 180 / Math.PI
+  deg: new LuaBuiltinFunction(
+    (_sf, x: number) => (untagNumber(x) * 180) / Math.PI,
   ),
-  rad: new LuaBuiltinFunction((_sf, x: number) =>
-    untagNumber(x) * Math.PI / 180
+  rad: new LuaBuiltinFunction(
+    (_sf, x: number) => (untagNumber(x) * Math.PI) / 180,
   ),
   ult: new LuaBuiltinFunction((_sf, m: number, n: number) => {
-    return (untagNumber(m) >>> 0) < (untagNumber(n) >>> 0);
+    return untagNumber(m) >>> 0 < untagNumber(n) >>> 0;
   }),
 
   // Keep the cosineSimilarity utility function

package/client/space_lua/stdlib/net.ts

@@ -14,17 +14,18 @@ export const netApi = new LuaTable({
     ): Promise<ProxyFetchResponse> => {
       // JSONify any non-serializable body
       if (
-        options?.body && typeof options.body !== "string" &&
+        options?.body &&
+        typeof options.body !== "string" &&
         !(options.body instanceof Uint8Array)
       ) {
         options.body = JSON.stringify(options.body);
       }
       const fetchOptions = options
         ? {
-          method: options.method,
-          headers: {} as Record<string, string>,
-          body: options.body,
-        }
+            method: options.method,
+            headers: {} as Record<string, string>,
+            body: options.body,
+          }
         : {};
       fetchOptions.headers = buildProxyHeaders(options.headers);
       const resp = await client.httpSpacePrimitives.authenticatedFetch(
@@ -40,19 +41,27 @@ export const netApi = new LuaTable({
         };
       }
       // Do sensible things with the body based on the content type
+      // Read as ArrayBuffer first to safely handle empty responses (e.g.
+      // PUT/DELETE returning 204 with Content-Type: application/json).
+      // resp.arrayBuffer() never throws on an empty body, whereas
+      // resp.json() would throw a SyntaxError.
+      const rawBytes = new Uint8Array(await resp.arrayBuffer());
       let body: any;
-      const contentTypeHeader = options.responseEncoding ||
+      const contentTypeHeader =
+        options.responseEncoding ||
         resp.headers.get("x-proxy-header-content-type");
       const statusCode = +(resp.headers.get("x-proxy-status-code") || "200");
-      if (contentTypeHeader?.startsWith("application/json")) {
-        body = await resp.json();
+      if (rawBytes.length === 0) {
+        body = null;
+      } else if (contentTypeHeader?.startsWith("application/json")) {
+        body = JSON.parse(new TextDecoder().decode(rawBytes));
       } else if (
         contentTypeHeader?.startsWith("application/xml") ||
         contentTypeHeader?.startsWith("text/")
       ) {
-        body = await resp.text();
+        body = new TextDecoder().decode(rawBytes);
       } else {
-        body = new Uint8Array(await resp.arrayBuffer());
+        body = rawBytes;
       }
       return {
         ok: resp.ok,
@@ -66,7 +75,7 @@ export const netApi = new LuaTable({
     (uri: string, options: { uri?: string; encoding?: string } = {}) => {
       options.uri = uri;
       return client.clientSystem.serviceRegistry.invokeBestMatch(
-        "net.readURI:" + uri,
+        `net.readURI:${uri}`,
         options,
       );
     },
@@ -74,7 +83,7 @@ export const netApi = new LuaTable({
   writeURI: new LuaNativeJSFunction(
     (uri: string, content: string | Uint8Array) => {
       return client.clientSystem.serviceRegistry.invokeBestMatch(
-        "net.writeURI:" + uri,
+        `net.writeURI:${uri}`,
         { uri, content },
       );
     },
@@ -85,8 +94,11 @@ export const netApi = new LuaTable({
 function buildProxyUrl(client: Client, url: string) {
   url = url.replace(/^https?:\/\//, "");
   // Strip off the /.fs and replace with /.proxy
-  return client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
-    "/.proxy/" + url;
+  return (
+    client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
+    "/.proxy/" +
+    url
+  );
 }
 
 function buildProxyHeaders(headers?: Record<string, any>): Record<string, any> {
@@ -100,9 +112,7 @@ function buildProxyHeaders(headers?: Record<string, any>): Record<string, any> {
   return newHeaders;
 }
 
-function extractProxyHeaders(
-  headers: Headers,
-): Record<string, any> {
+function extractProxyHeaders(headers: Headers): Record<string, any> {
   const newHeaders: Record<string, any> = {};
   for (const [key, value] of headers.entries()) {
     if (key.toLowerCase().startsWith("x-proxy-header-")) {