@silverbulletmd/silverbullet 2.4.2 → 2.5.3

package/client/space_lua/query_env.ts

@@ -0,0 +1,26 @@
+import { LuaEnv, luaGet, luaKeys, type LuaStackFrame } from "./runtime.ts";
+
+/**
+ * Build an environment for evaluating per-item expressions in queries.
+ * Extracted to its own module to avoid circular imports between
+ * query_collection.ts and aggregates.ts.
+ */
+export function buildItemEnv(
+  objectVariable: string | undefined,
+  item: any,
+  env: LuaEnv,
+  sf: LuaStackFrame,
+): LuaEnv {
+  const itemEnv = new LuaEnv(env);
+  if (!objectVariable) {
+    // Inject all item keys as variables
+    for (const key of luaKeys(item)) {
+      itemEnv.setLocal(key, luaGet(item, key, sf.astCtx ?? null, sf));
+    }
+    // As well as _
+    itemEnv.setLocal("_", item);
+  } else {
+    itemEnv.setLocal(objectVariable, item);
+  }
+  return itemEnv;
+}

package/client/space_lua/runtime.ts

@@ -128,7 +128,7 @@ export function luaIsCallable(
   }
   if (v instanceof LuaTable) {
     const mt = getMetatable(v, sf);
-    if (mt && mt.has("__call")) {
+    if (mt?.has("__call")) {
       const mm = mt.get("__call", sf);
       return !!mm && (typeof mm === "function" || isILuaFunction(mm));
     }
@@ -614,7 +614,7 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
 
     if (init && !Array.isArray(init)) {
       for (const k in init) {
-        if (Object.prototype.hasOwnProperty.call(init, k)) {
+        if (Object.hasOwn(init, k)) {
           this.stringKeys[k] = (init as any)[k];
         }
       }
@@ -689,7 +689,7 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
   keys(): any[] {
     const keys: any[] = [];
     for (const k in this.stringKeys) {
-      if (Object.prototype.hasOwnProperty.call(this.stringKeys, k)) {
+      if (Object.hasOwn(this.stringKeys, k)) {
         keys.push(k);
       }
     }
@@ -706,7 +706,7 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
 
   empty(): boolean {
     for (const k in this.stringKeys) {
-      if (Object.prototype.hasOwnProperty.call(this.stringKeys, k)) {
+      if (Object.hasOwn(this.stringKeys, k)) {
         return false;
       }
     }
@@ -927,6 +927,20 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
     const errSf = sf || LuaStackFrame.lostFrame;
     const ctx = sf?.astCtx ?? EMPTY_CTX;
 
+    if (key === null || key === undefined) {
+      throw new LuaRuntimeError(
+        "table index is nil",
+        errSf,
+      );
+    }
+
+    if (typeof key === "number" && Number.isNaN(key)) {
+      throw new LuaRuntimeError(
+        "table index is NaN",
+        errSf,
+      );
+    }
+
     if (this.has(key)) {
       return this.rawSet(key, value, numType);
     }
@@ -1121,9 +1135,9 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
       if (typeof key === "string") {
         result += key;
       } else {
-        result += "[" + key + "]";
+        result += `[${key}]`;
       }
-      result += " = " + await luaToString(this.get(key));
+      result += ` = ${await luaToString(this.get(key))}`;
     }
     result += "}";
     return result;
@@ -1243,21 +1257,24 @@ export function luaGet(
       errSf,
     );
   }
+
+  // In Lua reading with a nil key returns nil silently
   if (key === null || key === undefined) {
-    throw new LuaRuntimeError(
-      `attempt to index with a nil key`,
-      errSf,
-    );
+    return null;
   }
 
   if (obj instanceof LuaTable || obj instanceof LuaEnv) {
     return obj.get(key, sf);
   }
+  // Native JS array access: normalize undefined → null (Lua nil).
+  // Without this, accessing an out-of-bounds index on a JS array
+  // leaks JS undefined into the Lua runtime, breaking nil checks
+  // such as `tags[1] ~= nil` on an empty array.
   if (typeof key === "number") {
-    return (obj as any[])[key - 1];
+    return (obj as any[])[key - 1] ?? null;
   }
   if (isTaggedFloat(key)) {
-    return (obj as any[])[key.value - 1];
+    return (obj as any[])[key.value - 1] ?? null;
   }
   // Native JS object
   const k = toNumKey(key);
@@ -1275,7 +1292,8 @@ export function luaGet(
 export function luaLen(
   obj: any,
   sf?: LuaStackFrame,
-): number {
+  raw = false,
+): number | Promise<number> {
   if (typeof obj === "string") {
     return obj.length;
   }
@@ -1283,6 +1301,18 @@ export function luaLen(
     return obj.length;
   }
   if (obj instanceof LuaTable) {
+    // Check __len metamethod unless raw access is requested
+    if (!raw) {
+      const mt = getMetatable(obj, sf || LuaStackFrame.lostFrame);
+      const mm = mt ? mt.rawGet("__len") : null;
+      if (mm !== undefined && mm !== null) {
+        const r = luaCall(mm, [obj], (sf?.astCtx ?? {}) as ASTCtx, sf);
+        if (isPromise(r)) {
+          return (r as Promise<any>).then((v: any) => Number(singleResult(v)));
+        }
+        return Number(singleResult(r));
+      }
+    }
     return obj.rawLength;
   }
 
@@ -1462,7 +1492,7 @@ export class LuaRuntimeError extends Error {
       );
 
       // Add position indicator
-      const pointer = " ".repeat(column) + "^";
+      const pointer = `${" ".repeat(column)}^`;
 
       traceStr += `* ${ctx.ref || "(unknown source)"} @ ${line}:${column}:\n` +
         `   ${codeLine}\n` +
@@ -1549,7 +1579,7 @@ export function luaToString(
           const strVal = await luaToString(val, visited);
           result += strVal;
         }
-        return result + "}";
+        return `${result}}`;
       }
 
       // Handle objects
@@ -1576,7 +1606,7 @@ export function luaToString(
 }
 
 export function luaFormatNumber(n: number, kind?: "int" | "float"): string {
-  if (kind !== "float" && Number.isInteger(n) && isFinite(n)) {
+  if (kind !== "float" && Number.isInteger(n) && Number.isFinite(n)) {
     return String(n);
   }
   if (n !== n) return "-nan";
@@ -1589,7 +1619,7 @@ export function luaFormatNumber(n: number, kind?: "int" | "float"): string {
   const s = luaFormat("%.14g", n);
   // Guarantee `.01 suffix for integer-valued floats
   if (s.indexOf(".") === -1 && s.indexOf("e") === -1) {
-    return s + ".0";
+    return `${s}.0`;
   }
   return s;
 }

package/client/space_lua/stdlib/format.ts

@@ -128,8 +128,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 +200,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 +216,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";
@@ -275,9 +275,9 @@ function formatFloat(n: number, spec: FormatSpec): string {
       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}.`;
       }
     }
   }
@@ -287,16 +287,16 @@ function formatFloat(n: number, spec: FormatSpec): string {
     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 +322,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;
 }
@@ -353,7 +353,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 +373,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";
     }
@@ -395,14 +395,14 @@ function formatHexFloat(n: number, spec: FormatSpec): string {
         }
       }
       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);
   }
@@ -474,9 +474,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
@@ -581,7 +581,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 +643,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 +652,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 {

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,28 @@ 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 +78,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
@@ -117,10 +113,38 @@ export const mathApi = new LuaTable({
   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 +153,9 @@ export const mathApi = new LuaTable({
     }
     return Math.log(untagNumber(x)) / Math.log(untagNumber(base));
   }),
+  // Power function (deprecated in Lua 5.4 but retained for compatibility)
   pow: new LuaBuiltinFunction((_sf, x: number, y: number) =>
-    Math.pow(untagNumber(x), untagNumber(y))
+    untagNumber(x) ** untagNumber(y)
   ),
   sqrt: new LuaBuiltinFunction((_sf, x: number) => Math.sqrt(untagNumber(x))),
 
@@ -147,7 +172,7 @@ 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))),

package/client/space_lua/stdlib/net.ts

@@ -66,7 +66,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 +74,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 },
       );
     },

package/client/space_lua/stdlib/os.ts

@@ -365,4 +365,9 @@ export const osApi = new LuaTable({
       return luaFormatTime(fmt, d, utc);
     },
   ),
+
+  // Returns an approximation of CPU time used by the program in seconds.
+  clock: new LuaBuiltinFunction((_sf): number => {
+    return performance.now() / 1000.0;
+  }),
 });