@silverbulletmd/silverbullet 2.4.2 → 2.6.1

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,17 +34,16 @@ 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";
+import { isSqlNull } from "./liq_null.ts";
 
 const printFunction = new LuaBuiltinFunction(async (_sf, ...args) => {
-  console.log(
-    "[Lua]",
-    ...(await Promise.all(args.map((v) => luaToString(v)))),
-  );
+  console.log("[Lua]", ...(await Promise.all(args.map((v) => luaToString(v)))));
 });
 
 const assertFunction = new LuaBuiltinFunction(
   async (sf, value: any, message?: string) => {
-    if (!await value) {
+    if (!(await value)) {
       throw new LuaRuntimeError(`Assertion failed: ${message}`, sf);
     }
   },
@@ -121,23 +122,38 @@ 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) => {
@@ -182,10 +198,7 @@ async function pcallBoundary(
   sf: LuaStackFrame,
   fn: ILuaFunction,
   args: LuaValue[],
-): Promise<
-  | { ok: true; values: LuaValue[] }
-  | { ok: false; message: string }
-> {
+): Promise<{ ok: true; values: LuaValue[] } | { ok: false; message: string }> {
   const closeStack = luaEnsureCloseStack(sf);
   const mark = closeStack.length;
 
@@ -253,11 +266,9 @@ const setmetatableFunction = new LuaBuiltinFunction(
   },
 );
 
-const rawlenFunction = new LuaBuiltinFunction(
-  (_sf, value: LuaValue) => {
-    return luaLen(value, _sf);
-  },
-);
+const rawlenFunction = new LuaBuiltinFunction((_sf, value: LuaValue) => {
+  return luaLen(value, _sf, true);
+});
 
 const rawsetFunction = new LuaBuiltinFunction(
   (_sf, table: LuaTable, key: LuaValue, value: LuaValue) => {
@@ -269,7 +280,8 @@ const rawgetFunction = new LuaBuiltinFunction(
   (_sf, table: any, key: LuaValue) => {
     const isArray = Array.isArray(table);
 
-    const isPlainObj = typeof table === "object" &&
+    const isPlainObj =
+      typeof table === "object" &&
       table !== null &&
       (table as any).constructor === Object;
 
@@ -299,7 +311,7 @@ const rawgetFunction = new LuaBuiltinFunction(
 
     if (isLuaTable(table)) {
       const v = table.rawGet(key);
-      return v === undefined ? null : v;
+      return v === undefined || isSqlNull(v) ? null : v;
     }
 
     const k = isTaggedFloat(key) ? key.value : key;
@@ -318,13 +330,11 @@ const rawgetFunction = new LuaBuiltinFunction(
   },
 );
 
-const rawequalFunction = new LuaBuiltinFunction(
-  (_sf, a: any, b: any) => {
-    const av = isTaggedFloat(a) ? a.value : a;
-    const bv = isTaggedFloat(b) ? b.value : b;
-    return av === bv;
-  },
-);
+const rawequalFunction = new LuaBuiltinFunction((_sf, a: any, b: any) => {
+  const av = isTaggedFloat(a) ? a.value : a;
+  const bv = isTaggedFloat(b) ? b.value : b;
+  return av === bv;
+});
 
 const getmetatableFunction = new LuaBuiltinFunction((_sf, table: LuaTable) => {
   return (table as any).metatable;
@@ -332,12 +342,12 @@ const getmetatableFunction = new LuaBuiltinFunction((_sf, table: LuaTable) => {
 
 const dofileFunction = new LuaBuiltinFunction(async (sf, filename: string) => {
   const global = sf.threadLocal.get("_GLOBAL") as LuaEnv;
-  const file = await luaCall(
+  const file = (await luaCall(
     (global.get("space") as any).get("readFile"),
     [filename],
     sf.astCtx!,
     sf,
-  ) as Uint8Array;
+  )) as Uint8Array;
   const code = new TextDecoder().decode(file);
   try {
     const parsedExpr = parse(code);
@@ -413,7 +423,8 @@ const nextFunction = new LuaBuiltinFunction(
     }
     // Find index in the key list
     const idx = keys.indexOf(index);
-    if (idx === -1) { // Not found
+    if (idx === -1) {
+      // Not found
       throw new LuaRuntimeError("invalid key to 'next': key not found", sf);
     }
     const key = keys[idx + 1];
@@ -429,7 +440,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 +457,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

@@ -18,7 +18,8 @@ function skipSpace(s: string, i: number): number {
   const n = s.length;
   while (i < n) {
     const c = s.charCodeAt(i);
-    if (c === 32 || (c >= 9 && c <= 13)) { // SP, HT, LF, VT, FF, CR
+    if (c === 32 || (c >= 9 && c <= 13)) {
+      // SP, HT, LF, VT, FF, CR
       i++;
     } else {
       break;
@@ -28,21 +29,24 @@ function skipSpace(s: string, i: number): number {
 }
 
 function charToDigitBase(c: number, base: number): number {
-  if (c >= 48 && c <= 57) { // '0'..'9'
+  if (c >= 48 && c <= 57) {
+    // '0'..'9'
     const v = c - 48;
     if (v < base) {
       return v;
     }
     return -1;
   }
-  if (c >= 65 && c <= 90) { // 'A'..'Z'
+  if (c >= 65 && c <= 90) {
+    // 'A'..'Z'
     const v = 10 + (c - 65);
     if (v < base) {
       return v;
     }
     return -1;
   }
-  if (c >= 97 && c <= 122) { // 'a'..'z'
+  if (c >= 97 && c <= 122) {
+    // 'a'..'z'
     const v = 10 + (c - 97);
     if (v < base) {
       return v;
@@ -64,10 +68,12 @@ function parseIntWithBase(
   }
 
   let sign = 1;
-  if (s.charCodeAt(i) === 45) { // '-'
+  if (s.charCodeAt(i) === 45) {
+    // '-'
     sign = -1;
     i++;
-  } else if (s.charCodeAt(i) === 43) { // '+'
+  } else if (s.charCodeAt(i) === 43) {
+    // '+'
     i++;
   }
 
@@ -80,7 +86,8 @@ function parseIntWithBase(
 
   while (i < n) {
     const c = s.charCodeAt(i);
-    const isAlnum = (c >= 48 && c <= 57) || // '0'..'9'
+    const isAlnum =
+      (c >= 48 && c <= 57) || // '0'..'9'
       (c >= 65 && c <= 90) || // 'A'..'Z'
       (c >= 97 && c <= 122); // 'a'..'z'
 
@@ -119,10 +126,12 @@ function parseInt(s: string): { ok: boolean; value: number } {
   }
 
   let neg = false;
-  if (s.charCodeAt(i) === 45) { // '-'
+  if (s.charCodeAt(i) === 45) {
+    // '-'
     neg = true;
     i++;
-  } else if (s.charCodeAt(i) === 43) { // '+'
+  } else if (s.charCodeAt(i) === 43) {
+    // '+'
     i++;
   }
 
@@ -134,18 +143,23 @@ function parseInt(s: string): { ok: boolean; value: number } {
   let any = false;
 
   // hex?
-  if (s.charCodeAt(i) === 48 && i + 1 < n) { // '0'
+  if (s.charCodeAt(i) === 48 && i + 1 < n) {
+    // '0'
     const x = s.charCodeAt(i + 1);
-    if (x === 120 || x === 88) { // 'x' or 'X'
+    if (x === 120 || x === 88) {
+      // 'x' or 'X'
       i += 2;
       while (i < n) {
         const c = s.charCodeAt(i);
         let d = -1;
-        if (c >= 48 && c <= 57) { // '0'..'9'
+        if (c >= 48 && c <= 57) {
+          // '0'..'9'
           d = c - 48; // '0'
-        } else if (c >= 65 && c <= 70) { // 'A'..'F'
+        } else if (c >= 65 && c <= 70) {
+          // 'A'..'F'
           d = 10 + (c - 65);
-        } else if (c >= 97 && c <= 102) { // 'a'..'f'
+        } else if (c >= 97 && c <= 102) {
+          // 'a'..'f'
           d = 10 + (c - 97);
         } else {
           d = -1;
@@ -168,7 +182,8 @@ function parseInt(s: string): { ok: boolean; value: number } {
   // decimal integer
   while (i < n) {
     const c = s.charCodeAt(i);
-    if (c < 48 || c > 57) { // not '0'..'9'
+    if (c < 48 || c > 57) {
+      // not '0'..'9'
       break;
     }
     acc = acc * 10 + (c - 48);
@@ -193,10 +208,12 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
 
   let sign = 1;
   const c0 = s.charCodeAt(i);
-  if (c0 === 45) { // '-'
+  if (c0 === 45) {
+    // '-'
     sign = -1;
     i++;
-  } else if (c0 === 43) { // '+'
+  } else if (c0 === 43) {
+    // '+'
     i++;
   }
 
@@ -207,7 +224,8 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
   // integer part
   while (i < n) {
     const c = s.charCodeAt(i);
-    if (c < 48 || c > 57) { // not '0'..'9'
+    if (c < 48 || c > 57) {
+      // not '0'..'9'
       break;
     }
     val = val * 10 + (c - 48);
@@ -217,12 +235,14 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
 
   // fractional part
   if (i < n) {
-    if (s.charCodeAt(i) === 46) { // '.'
+    if (s.charCodeAt(i) === 46) {
+      // '.'
       i++;
       let scale = 1;
       while (i < n) {
         const c = s.charCodeAt(i);
-        if (c < 48 || c > 57) { // not '0'..'9'
+        if (c < 48 || c > 57) {
+          // not '0'..'9'
           break;
         }
         scale *= 0.1;
@@ -238,7 +258,8 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
   let hasExp = false;
   if (i < n) {
     const ec = s.charCodeAt(i);
-    if (ec === 101 || ec === 69) { // 'e' or 'E'
+    if (ec === 101 || ec === 69) {
+      // 'e' or 'E'
       hasExp = true;
       i++;
       if (i >= n) {
@@ -247,10 +268,12 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
       let expSign = 1;
       if (i < n) {
         const es = s.charCodeAt(i);
-        if (es === 45) { // '-'
+        if (es === 45) {
+          // '-'
           expSign = -1;
           i++;
-        } else if (es === 43) { // '+'
+        } else if (es === 43) {
+          // '+'
           i++;
         }
       }
@@ -260,7 +283,8 @@ function parseDecFloat(s: string): { ok: boolean; value: number } {
       let anyExp = false;
       while (i < n) {
         const c = s.charCodeAt(i);
-        if (c < 48 || c > 57) { // not '0'..'9'
+        if (c < 48 || c > 57) {
+          // not '0'..'9'
           break;
         }
         exp = exp * 10 + (c - 48);
@@ -283,7 +307,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 };
 }
 
@@ -297,18 +321,22 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
 
   let sign = 1;
   const c0 = s.charCodeAt(i);
-  if (c0 === 45) { // '-'
+  if (c0 === 45) {
+    // '-'
     sign = -1;
     i++;
-  } else if (c0 === 43) { // '+'
+  } else if (c0 === 43) {
+    // '+'
     i++;
   }
 
-  if (!(i + 1 < n && s.charCodeAt(i) === 48)) { // '0'
+  if (!(i + 1 < n && s.charCodeAt(i) === 48)) {
+    // '0'
     return { ok: false, value: 0 };
   }
   const x = s.charCodeAt(i + 1);
-  if (!(x === 120 || x === 88)) { // 'x' or 'X'
+  if (!(x === 120 || x === 88)) {
+    // 'x' or 'X'
     return { ok: false, value: 0 };
   }
   i += 2;
@@ -323,11 +351,14 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
   while (i < n) {
     const c = s.charCodeAt(i);
     let d = -1;
-    if (c >= 48 && c <= 57) { // '0'..'9'
+    if (c >= 48 && c <= 57) {
+      // '0'..'9'
       d = c - 48;
-    } else if (c >= 65 && c <= 70) { // 'A'..'F'
+    } else if (c >= 65 && c <= 70) {
+      // 'A'..'F'
       d = 10 + (c - 65);
-    } else if (c >= 97 && c <= 102) { // 'a'..'f'
+    } else if (c >= 97 && c <= 102) {
+      // 'a'..'f'
       d = 10 + (c - 97);
     } else {
       d = -1;
@@ -342,17 +373,21 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
 
   // optional fractional part
   if (i < n) {
-    if (s.charCodeAt(i) === 46) { // '.'
+    if (s.charCodeAt(i) === 46) {
+      // '.'
       sawDot = true;
       i++;
       while (i < n) {
         const c = s.charCodeAt(i);
         let d = -1;
-        if (c >= 48 && c <= 57) { // '0'..'9'
+        if (c >= 48 && c <= 57) {
+          // '0'..'9'
           d = c - 48;
-        } else if (c >= 65 && c <= 70) { // 'A'..'F'
+        } else if (c >= 65 && c <= 70) {
+          // 'A'..'F'
           d = 10 + (c - 65);
-        } else if (c >= 97 && c <= 102) { // 'a'..'f'
+        } else if (c >= 97 && c <= 102) {
+          // 'a'..'f'
           d = 10 + (c - 97);
         } else {
           d = -1;
@@ -376,14 +411,17 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
 
   if (i < n) {
     const ec = s.charCodeAt(i);
-    if (ec === 112 || ec === 80) { // 'p' or 'P'
+    if (ec === 112 || ec === 80) {
+      // 'p' or 'P'
       i++;
       if (i < n) {
         const sc = s.charCodeAt(i);
-        if (sc === 45) { // '-'
+        if (sc === 45) {
+          // '-'
           expSign = -1;
           i++;
-        } else if (sc === 43) { // '+'
+        } else if (sc === 43) {
+          // '+'
           i++;
         }
       }
@@ -394,7 +432,8 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
       let anyExp = false;
       while (i < n) {
         const c = s.charCodeAt(i);
-        if (c < 48 || c > 57) { // not '0'..'9'
+        if (c < 48 || c > 57) {
+          // not '0'..'9'
           break;
         }
         exp = exp * 10 + (c - 48);
@@ -433,8 +472,8 @@ function parseHexFloat(s: string): { ok: boolean; value: number } {
     return { ok: false, value: 0 };
   }
 
-  const frac = fracVal === 0 ? 0 : (fracVal / fracScale);
-  const result = sign * (intVal + frac) * Math.pow(2, expSign * exp);
+  const frac = fracVal === 0 ? 0 : fracVal / fracScale;
+  const result = sign * (intVal + frac) * 2 ** (expSign * exp);
   return { ok: true, value: result };
 }
 
@@ -460,6 +499,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

@@ -6,7 +6,7 @@ export function evalPromiseValues(vals: any[]): Promise<any[]> | any[] {
   for (let i = 0; i < vals.length; i++) {
     if (isPromise(vals[i])) {
       promises.push(
-        (vals[i] as Promise<any>).then((v: any) => promiseResults[i] = v),
+        (vals[i] as Promise<any>).then((v: any) => (promiseResults[i] = v)),
       );
     } else {
       promiseResults[i] = vals[i];
@@ -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);
 }
 
 /**
@@ -33,21 +32,22 @@ async function getPivot(
   z: any,
   compare: (a: any, b: any) => Promise<number>,
 ) {
-  if (await compare(x, y) < 0) {
-    if (await compare(y, z) < 0) {
+  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;
 }
 
 /**
@@ -65,7 +65,9 @@ export async function asyncQuickSort(
   right = arr.length - 1,
 ) {
   if (left < right) {
-    let i = left, j = right, tmp;
+    let i = left,
+      j = right,
+      tmp;
     const pivot = await getPivot(
       arr[i],
       arr[i + Math.floor((j - i) / 2)],
@@ -73,10 +75,10 @@ export async function asyncQuickSort(
       compare,
     );
     while (true) {
-      while (await compare(arr[i], pivot) < 0) {
+      while ((await compare(arr[i], pivot)) < 0) {
         i++;
       }
-      while (await compare(pivot, arr[j]) < 0) {
+      while ((await compare(pivot, arr[j])) < 0) {
         j--;
       }
       if (i >= j) {
@@ -94,3 +96,39 @@ 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];
+    }
+  }
+}