@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/space_lua/runtime.ts

@@ -3,6 +3,7 @@ import { evalStatement } from "./eval.ts";
 import { asyncQuickSort } from "./util.ts";
 import { isPromise, rpAll } from "./rp.ts";
 import { isNegativeZero, isTaggedFloat } from "./numeric.ts";
+import { isSqlNull } from "./liq_null.ts";
 import { luaFormat } from "./stdlib/format.ts";
 
 export type LuaType =
@@ -79,7 +80,7 @@ function isLuaNumber(v: any): boolean {
 }
 
 export function luaTypeName(val: any): LuaType {
-  if (val === null || val === undefined) {
+  if (val === null || val === undefined || isSqlNull(val)) {
     return "nil";
   }
 
@@ -113,10 +114,7 @@ export function luaTypeName(val: any): LuaType {
 }
 
 // Check whether a value is callable without invoking it.
-export function luaIsCallable(
-  v: LuaValue,
-  sf: LuaStackFrame,
-): boolean {
+export function luaIsCallable(v: LuaValue, sf: LuaStackFrame): boolean {
   if (v === null || v === undefined) {
     return false;
   }
@@ -128,7 +126,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));
     }
@@ -137,9 +135,7 @@ export function luaIsCallable(
 }
 
 // In Lua, `__close` must be a function (no `__call` fallback).
-function luaIsCloseMethod(
-  v: LuaValue,
-): boolean {
+function luaIsCloseMethod(v: LuaValue): boolean {
   return typeof v === "function" || isILuaFunction(v);
 }
 
@@ -261,14 +257,13 @@ export class LuaEnv implements ILuaSettable, ILuaGettable {
   private readonly consts = new Set<string>();
   private readonly numericTypes = new Map<string, NumericType>();
 
-  constructor(readonly parent?: LuaEnv) {
-  }
+  constructor(readonly parent?: LuaEnv) {}
 
   setLocal(name: string, value: LuaValue, numType?: NumericType) {
     this.variables.set(name, value);
-    if (isLuaNumber(value) && numType) {
+    if (numType) {
       this.numericTypes.set(name, numType);
-    } else {
+    } else if (this.numericTypes.size > 0) {
       this.numericTypes.delete(name);
     }
   }
@@ -276,9 +271,9 @@ export class LuaEnv implements ILuaSettable, ILuaGettable {
   setLocalConst(name: string, value: LuaValue, numType?: NumericType) {
     this.variables.set(name, value);
     this.consts.add(name);
-    if (isLuaNumber(value) && numType) {
+    if (numType) {
       this.numericTypes.set(name, numType);
-    } else {
+    } else if (this.numericTypes.size > 0) {
       this.numericTypes.delete(name);
     }
   }
@@ -297,9 +292,9 @@ export class LuaEnv implements ILuaSettable, ILuaGettable {
         );
       }
       this.variables.set(key, value);
-      if (isLuaNumber(value) && numType) {
+      if (numType) {
         this.numericTypes.set(key, numType);
-      } else {
+      } else if (this.numericTypes.size > 0) {
         this.numericTypes.delete(key);
       }
     } else {
@@ -327,13 +322,15 @@ export class LuaEnv implements ILuaSettable, ILuaGettable {
     return false;
   }
 
-  get(
-    name: string,
-    _sf?: LuaStackFrame,
-  ): Promise<LuaValue> | LuaValue | null {
-    if (this.variables.has(name)) {
-      return this.variables.get(name);
+  get(name: string, _sf?: LuaStackFrame): Promise<LuaValue> | LuaValue | null {
+    // Fast path: single Map.get() instead of has() + get() for the common case
+    // where the variable exists and has a non-undefined value (null = Lua nil is fine).
+    const v = this.variables.get(name);
+    if (v !== undefined) {
+      return v;
     }
+    // Variable set to null (Lua nil) returns null from Map.get() which is !== undefined,
+    // so it's handled above. Only fall through when the key is truly absent.
     if (this.parent) {
       return this.parent.get(name, _sf);
     }
@@ -378,8 +375,7 @@ export class LuaStackFrame {
     readonly parent?: LuaStackFrame,
     readonly currentFunction?: LuaFunction,
     readonly threadState: LuaThreadState = { closeStack: undefined },
-  ) {
-  }
+  ) {}
 
   static createWithGlobalEnv(
     globalEnv: LuaEnv,
@@ -458,46 +454,71 @@ export class LuaFunction implements ILuaFunction {
   private capturedEnv: LuaEnv;
   funcHasGotos?: boolean;
 
-  constructor(readonly body: LuaFunctionBody, closure: LuaEnv) {
+  constructor(
+    readonly body: LuaFunctionBody,
+    closure: LuaEnv,
+  ) {
     this.capturedEnv = closure;
   }
 
   call(sf: LuaStackFrame, ...args: LuaValue[]): Promise<LuaValue> | LuaValue {
     // Create a new environment that chains to the captured environment
     const env = new LuaEnv(this.capturedEnv);
-    if (!sf) {
-      console.trace(sf);
-    }
     // Set _CTX to the thread local environment from the stack frame
     env.setLocal("_CTX", sf.threadLocal);
 
     // Eval using a stack frame that knows the current function
     const sfWithFn = sf.currentFunction === this ? sf : sf.withFunction(this);
 
+    const params = this.body.parameters;
+    const hasVarargs = params.length > 0 && params[params.length - 1] === "...";
+
     // Resolve args (sync-first)
     const argsRP = rpAll(args as any[]);
     const resolveArgs = (resolvedArgs: any[]) => {
-      // Assign parameter values to variable names in env
-      let varargs: LuaValue[] = [];
-      for (let i = 0; i < this.body.parameters.length; i++) {
-        const paramName = this.body.parameters[i];
-        if (paramName === "...") {
-          // Vararg parameter, let's collect the remainder of the resolved args into the varargs array
-          varargs = resolvedArgs.slice(i);
-          // Done, break out of this loop
-          break;
+      if (hasVarargs) {
+        // Variadic function: bind named params, collect rest into varargs
+        const varargStart = params.length - 1;
+        for (let i = 0; i < varargStart; i++) {
+          env.setLocal(params[i], resolvedArgs[i] ?? null);
+        }
+        env.setLocal(
+          "...",
+          new LuaMultiRes(resolvedArgs.slice(varargStart)),
+        );
+      } else {
+        // Non-variadic: bind all named params directly
+        for (let i = 0; i < params.length; i++) {
+          env.setLocal(params[i], resolvedArgs[i] ?? null);
         }
-        env.setLocal(paramName, resolvedArgs[i] ?? null);
       }
-      env.setLocal("...", new LuaMultiRes(varargs));
 
       // Evaluate the function body with returnOnReturn set to true
       const r = evalStatement(this.body.block, env, sfWithFn, true);
 
-      const map = (val: any) => {
-        if (val === undefined) {
-          return;
+      if (!isPromise(r)) {
+        // Fast path: synchronous result
+        if (r === undefined) return;
+        if (r && typeof r === "object" && r.ctrl === "return") {
+          return mapFunctionReturnValue(r.values);
+        }
+        if (r && typeof r === "object" && r.ctrl === "break") {
+          throw new LuaRuntimeError(
+            "break outside loop",
+            sfWithFn.withCtx(this.body.block.ctx),
+          );
         }
+        if (r && typeof r === "object" && r.ctrl === "goto") {
+          throw new LuaRuntimeError(
+            "unexpected goto signal",
+            sfWithFn.withCtx(this.body.block.ctx),
+          );
+        }
+        return;
+      }
+
+      return r.then((val: any) => {
+        if (val === undefined) return;
         if (val && typeof val === "object" && val.ctrl === "return") {
           return mapFunctionReturnValue(val.values);
         }
@@ -513,12 +534,7 @@ export class LuaFunction implements ILuaFunction {
             sfWithFn.withCtx(this.body.block.ctx),
           );
         }
-      };
-
-      if (isPromise(r)) {
-        return r.then(map);
-      }
-      return map(r);
+      });
     };
 
     if (isPromise(argsRP)) {
@@ -549,17 +565,24 @@ function mapFunctionReturnValue(values: any[]): any {
 }
 
 export class LuaNativeJSFunction implements ILuaFunction {
-  constructor(readonly fn: (...args: JSValue[]) => JSValue) {
-  }
+  constructor(readonly fn: (...args: JSValue[]) => JSValue) {}
 
   // Performs automatic conversion between Lua and JS values for arguments, but not for return values
   call(sf: LuaStackFrame, ...args: LuaValue[]): Promise<LuaValue> | LuaValue {
-    const jsArgsRP = args.map((v) => luaValueToJS(v, sf));
-    const resolved = rpAll(jsArgsRP);
-    if (isPromise(resolved)) {
-      return resolved.then((jsArgs) => this.fn(...jsArgs));
+    // Avoid .map() allocation: convert in-place and check for promises
+    const len = args.length;
+    let hasAsync = false;
+    for (let i = 0; i < len; i++) {
+      const converted = luaValueToJS(args[i], sf);
+      args[i] = converted;
+      if (!hasAsync && isPromise(converted)) {
+        hasAsync = true;
+      }
     }
-    return this.fn(...resolved);
+    if (hasAsync) {
+      return Promise.all(args).then((jsArgs) => this.fn(...jsArgs));
+    }
+    return this.fn(...args);
   }
 
   asString(): string {
@@ -574,8 +597,7 @@ export class LuaNativeJSFunction implements ILuaFunction {
 export class LuaBuiltinFunction implements ILuaFunction {
   constructor(
     readonly fn: (sf: LuaStackFrame, ...args: LuaValue[]) => LuaValue,
-  ) {
-  }
+  ) {}
 
   call(sf: LuaStackFrame, ...args: LuaValue[]): Promise<LuaValue> | LuaValue {
     // _CTX is already available via the stack frame
@@ -602,24 +624,16 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
   // When tables are used as arrays, we use a native JavaScript array for that
   private arrayPart: any[];
 
-  // Numeric type metadata at storage boundaries
-  private readonly stringKeyTypes = new Map<string, NumericType>();
+  // Numeric type metadata at storage boundaries (lazily allocated)
+  private stringKeyTypes: Map<string, NumericType> | null = null;
   private otherKeyTypes: Map<any, NumericType> | null = null;
-  private readonly arrayTypes: (NumericType | undefined)[] = [];
+  private arrayTypes: (NumericType | undefined)[] | null = null;
 
   constructor(init?: any[] | Record<string, any>) {
     // For efficiency and performance reasons we pre-allocate these (modern JS engines are very good at optimizing this)
     this.arrayPart = Array.isArray(init) ? init : [];
     this.stringKeys = init && !Array.isArray(init) ? init : {};
-
-    if (init && !Array.isArray(init)) {
-      for (const k in init) {
-        if (Object.prototype.hasOwnProperty.call(init, k)) {
-          this.stringKeys[k] = (init as any)[k];
-        }
-      }
-    }
-    this.otherKeys = null; // Only create this when needed
+    this.otherKeys = null;
     this.metatable = null;
   }
 
@@ -689,7 +703,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 +720,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;
       }
     }
@@ -724,10 +738,20 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
       return this.stringKeys[key] !== undefined;
     }
 
+    // Fast path for plain integer keys (common in for loops)
+    if (typeof key === "number") {
+      if (key >= 1 && (key | 0) === key) {
+        if (this.arrayPart[key - 1] !== undefined) return true;
+        return this.otherKeys ? this.otherKeys.has(key) : false;
+      }
+      return this.otherKeys ? this.otherKeys.has(key) : false;
+    }
+
     const normalizedKey = LuaTable.normalizeNumericKey(key);
 
     if (
-      typeof normalizedKey === "number" && Number.isInteger(normalizedKey) &&
+      typeof normalizedKey === "number" &&
+      Number.isInteger(normalizedKey) &&
       normalizedKey >= 1
     ) {
       const idx = normalizedKey - 1;
@@ -759,8 +783,9 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
 
     this.arrayPart[idx] = value;
     if (isLuaNumber(value) && numType) {
+      if (!this.arrayTypes) this.arrayTypes = [];
       this.arrayTypes[idx] = numType;
-    } else {
+    } else if (this.arrayTypes) {
       this.arrayTypes[idx] = undefined;
     }
   }
@@ -785,7 +810,12 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
       }
 
       this.arrayPart.push(v);
-      this.arrayTypes.push(nt);
+      if (nt) {
+        if (!this.arrayTypes) this.arrayTypes = [];
+        this.arrayTypes.push(nt);
+      } else if (this.arrayTypes) {
+        this.arrayTypes.push(undefined);
+      }
     }
   }
 
@@ -805,12 +835,13 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
     if (typeof key === "string") {
       if (value === null || value === undefined) {
         delete this.stringKeys[key];
-        this.stringKeyTypes.delete(key);
+        if (this.stringKeyTypes) this.stringKeyTypes.delete(key);
       } else {
         this.stringKeys[key] = value;
-        if (isLuaNumber(value) && numType) {
+        if (numType) {
+          if (!this.stringKeyTypes) this.stringKeyTypes = new Map();
           this.stringKeyTypes.set(key, numType);
-        } else {
+        } else if (this.stringKeyTypes) {
           this.stringKeyTypes.delete(key);
         }
       }
@@ -822,12 +853,13 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
     if (typeof normalizedKey === "string") {
       if (value === null || value === undefined) {
         delete this.stringKeys[normalizedKey];
-        this.stringKeyTypes.delete(normalizedKey);
+        if (this.stringKeyTypes) this.stringKeyTypes.delete(normalizedKey);
       } else {
         this.stringKeys[normalizedKey] = value;
         if (isLuaNumber(value) && numType) {
+          if (!this.stringKeyTypes) this.stringKeyTypes = new Map();
           this.stringKeyTypes.set(normalizedKey, numType);
-        } else {
+        } else if (this.stringKeyTypes) {
           this.stringKeyTypes.delete(normalizedKey);
         }
       }
@@ -835,7 +867,8 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
     }
 
     if (
-      typeof normalizedKey === "number" && Number.isInteger(normalizedKey) &&
+      typeof normalizedKey === "number" &&
+      Number.isInteger(normalizedKey) &&
       normalizedKey >= 1
     ) {
       const idx = normalizedKey - 1;
@@ -845,8 +878,9 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
       if (idx <= this.arrayPart.length) {
         this.arrayPart[idx] = value;
         if (isLuaNumber(value) && numType) {
+          if (!this.arrayTypes) this.arrayTypes = [];
           this.arrayTypes[idx] = numType;
-        } else {
+        } else if (this.arrayTypes) {
           this.arrayTypes[idx] = undefined;
         }
 
@@ -869,7 +903,7 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
           }
           if (n !== this.arrayPart.length) {
             this.arrayPart.length = n;
-            this.arrayTypes.length = n;
+            if (this.arrayTypes) this.arrayTypes.length = n;
           }
         }
 
@@ -924,23 +958,39 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
     sf?: LuaStackFrame,
     numType?: NumericType,
   ): Promise<void> | void {
-    const errSf = sf || LuaStackFrame.lostFrame;
-    const ctx = sf?.astCtx ?? EMPTY_CTX;
+    if (key === null || key === undefined) {
+      throw new LuaRuntimeError(
+        "table index is nil",
+        sf || LuaStackFrame.lostFrame,
+      );
+    }
 
-    if (this.has(key)) {
-      return this.rawSet(key, value, numType);
+    if (typeof key === "number" && Number.isNaN(key)) {
+      throw new LuaRuntimeError(
+        "table index is NaN",
+        sf || LuaStackFrame.lostFrame,
+      );
     }
 
+    // Fast path: no metatable — skip has() check and metamethod machinery
     if (this.metatable === null) {
       return this.rawSet(key, value, numType);
     }
 
+    // Key exists — rawSet directly, no metamethod needed
+    if (this.has(key)) {
+      return this.rawSet(key, value, numType);
+    }
+
     const newIndexMM = this.metatable.rawGet("__newindex");
 
     if (newIndexMM === undefined || newIndexMM === null) {
       return this.rawSet(key, value, numType);
     }
 
+    // Slow path: __newindex metamethod chain (rare)
+    const errSf = sf || LuaStackFrame.lostFrame;
+    const ctx = sf?.astCtx ?? EMPTY_CTX;
     const k: LuaValue = key;
     const v: LuaValue = value;
     const nt: NumericType | undefined = numType;
@@ -1000,10 +1050,19 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
 
   getNumericType(key: LuaValue): NumericType | undefined {
     if (typeof key === "string") {
-      return this.stringKeyTypes.get(key);
+      return this.stringKeyTypes ? this.stringKeyTypes.get(key) : undefined;
+    }
+    // Fast path for plain integer keys
+    if (typeof key === "number") {
+      if (key >= 1 && (key | 0) === key) {
+        return this.arrayTypes ? this.arrayTypes[key - 1] : undefined;
+      }
+      return this.otherKeyTypes ? this.otherKeyTypes.get(key) : undefined;
     }
     if (LuaTable.isIntegerKey(key)) {
-      return this.arrayTypes[LuaTable.toIndex(key)];
+      return this.arrayTypes
+        ? this.arrayTypes[LuaTable.toIndex(key)]
+        : undefined;
     }
     if (this.otherKeyTypes) {
       return this.otherKeyTypes.get(key);
@@ -1016,6 +1075,19 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
       return this.stringKeys[key];
     }
 
+    // Fast path for plain integer keys (common in for loops)
+    if (typeof key === "number") {
+      if (key >= 1 && (key | 0) === key) {
+        const v = this.arrayPart[key - 1];
+        if (v !== undefined) return v;
+        if (this.otherKeys) return this.otherKeys.get(key);
+        return undefined;
+      }
+      // Non-integer or zero/negative number keys
+      if (this.otherKeys) return this.otherKeys.get(key);
+      return undefined;
+    }
+
     const normalizedKey = LuaTable.normalizeNumericKey(key);
 
     if (typeof normalizedKey === "string") {
@@ -1023,7 +1095,8 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
     }
 
     if (
-      typeof normalizedKey === "number" && Number.isInteger(normalizedKey) &&
+      typeof normalizedKey === "number" &&
+      Number.isInteger(normalizedKey) &&
       normalizedKey >= 1
     ) {
       const idx = normalizedKey - 1;
@@ -1044,6 +1117,11 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
   }
 
   get(key: LuaValue, sf?: LuaStackFrame): LuaValue | Promise<LuaValue> | null {
+    // Fast path: no metatable means rawGet is the final answer (most tables in SilverBullet)
+    if (this.metatable === null) {
+      const raw = this.rawGet(key);
+      return raw !== undefined ? raw : null;
+    }
     return luaIndexValue(this, key, sf);
   }
 
@@ -1067,8 +1145,21 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
 
   toJSObject(sf = LuaStackFrame.lostFrame): Record<string, any> {
     const result: Record<string, any> = {};
-    for (const key of this.keys()) {
-      result[key] = luaValueToJS(this.get(key, sf), sf);
+    // Direct access to stringKeys avoids keys() allocation and get() metatable checks
+    for (const k in this.stringKeys) {
+      if (Object.hasOwn(this.stringKeys, k)) {
+        result[k] = luaValueToJS(this.stringKeys[k], sf);
+      }
+    }
+    // Include array part with 1-based keys
+    for (let i = 0; i < this.arrayPart.length; i++) {
+      result[i + 1] = luaValueToJS(this.arrayPart[i], sf);
+    }
+    // Include other keys
+    if (this.otherKeys) {
+      for (const [key, val] of this.otherKeys) {
+        result[key] = luaValueToJS(val, sf);
+      }
     }
     return result;
   }
@@ -1097,10 +1188,7 @@ export class LuaTable implements ILuaSettable, ILuaGettable {
 
         const s = singleResult(v);
         if (typeof s !== "string") {
-          throw new LuaRuntimeError(
-            "'__tostring' must return a string",
-            sf,
-          );
+          throw new LuaRuntimeError("'__tostring' must return a string", sf);
         }
         return s;
       }
@@ -1121,9 +1209,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;
@@ -1154,6 +1242,7 @@ export function luaIndexValue(
     if (t instanceof LuaTable) {
       const raw = t.rawGet(key);
       if (raw !== undefined) {
+        if (isSqlNull(raw)) return null;
         return raw;
       }
       // If no metatable, raw miss => nil
@@ -1205,27 +1294,32 @@ export function luaIndexValue(
 
 export type LuaLValueContainer = { env: ILuaSettable; key: LuaValue };
 
-export async function luaSet(
+export function luaSet(
   obj: any,
   key: any,
   value: any,
   sf: LuaStackFrame,
   numType?: NumericType,
-): Promise<void> {
+): void | Promise<void> {
   if (!obj) {
-    throw new LuaRuntimeError(
-      `Not a settable object: nil`,
-      sf,
-    );
+    throw new LuaRuntimeError(`Not a settable object: nil`, sf);
   }
 
   const normKey = isTaggedFloat(key) ? key.value : key;
 
   if (obj instanceof LuaTable || obj instanceof LuaEnv) {
-    await obj.set(normKey, value, sf, numType);
+    return obj.set(normKey, value, sf, numType);
   } else {
     const k = toNumKey(normKey);
-    (obj as Record<string | number, any>)[k] = await luaValueToJS(value, sf);
+    const jsVal = luaValueToJS(value, sf);
+    if (isPromise(jsVal)) {
+      return (jsVal as Promise<any>).then(
+        (v) => {
+          (obj as Record<string | number, any>)[k] = v;
+        },
+      );
+    }
+    (obj as Record<string | number, any>)[k] = jsVal;
   }
 }
 
@@ -1235,29 +1329,30 @@ export function luaGet(
   ctx: ASTCtx | null,
   sf: LuaStackFrame,
 ): Promise<any> | any {
-  const errSf = ctx ? sf.withCtx(ctx) : sf;
-
   if (obj === null || obj === undefined) {
     throw new LuaRuntimeError(
       `attempt to index a nil value`,
-      errSf,
+      ctx ? sf.withCtx(ctx) : sf,
     );
   }
+
+  // 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 +1370,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 +1379,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;
   }
 
@@ -1308,16 +1416,23 @@ export function luaCall(
 
   // Fast path: native JS function
   if (typeof callee === "function") {
-    const jsArgs = rpAll(
-      args.map((v) => luaValueToJS(v, sf || LuaStackFrame.lostFrame)),
-    );
+    const baseSf = sf || LuaStackFrame.lostFrame;
+    const len = args.length;
+    let hasAsync = false;
+    for (let i = 0; i < len; i++) {
+      const converted = luaValueToJS(args[i], baseSf);
+      args[i] = converted;
+      if (!hasAsync && isPromise(converted)) {
+        hasAsync = true;
+      }
+    }
 
-    if (isPromise(jsArgs)) {
-      return jsArgs.then((resolved) =>
-        (callee as (...a: any[]) => any)(...resolved)
+    if (hasAsync) {
+      return Promise.all(args).then((resolved) =>
+        (callee as (...a: any[]) => any)(...resolved),
       );
     }
-    return (callee as (...a: any[]) => any)(...jsArgs);
+    return (callee as (...a: any[]) => any)(...args);
   }
 
   // Lua table: may be callable via __call metamethod
@@ -1353,14 +1468,20 @@ export function luaCall(
 
   // ILuaFunction (LuaFunction/LuaBuiltinFunction/LuaNativeJSFunction/etc.)
   if (isILuaFunction(callee)) {
+    // Fast path for builtins: skip withFunction, defer withCtx
+    if (callee instanceof LuaBuiltinFunction) {
+      const base = sf || LuaStackFrame.lostFrame;
+      return callee.call(base, ...args);
+    }
+    // Fast path for native JS functions: skip withCtx/withFunction
+    if (callee instanceof LuaNativeJSFunction) {
+      const base = sf || LuaStackFrame.lostFrame;
+      return callee.call(base, ...args);
+    }
     const base = (sf || LuaStackFrame.lostFrame).withCtx(ctx);
-    const frameForCall = callee instanceof LuaFunction
-      ? base.withFunction(callee)
-      : base;
-    return callee.call(
-      frameForCall,
-      ...args,
-    );
+    const frameForCall =
+      callee instanceof LuaFunction ? base.withFunction(callee) : base;
+    return callee.call(frameForCall, ...args);
   }
 
   throw new LuaRuntimeError(
@@ -1370,8 +1491,17 @@ export function luaCall(
 }
 
 export function luaEquals(a: any, b: any): boolean {
-  const an = isTaggedFloat(a) ? a.value : a;
-  const bn = isTaggedFloat(b) ? b.value : b;
+  // Normalize nil variants (null, undefined, SQL NULL) to null
+  const an = (a === null || a === undefined || isSqlNull(a))
+    ? null
+    : isTaggedFloat(a)
+    ? a.value
+    : a;
+  const bn = (b === null || b === undefined || isSqlNull(b))
+    ? null
+    : isTaggedFloat(b)
+    ? b.value
+    : b;
   return an === bn;
 }
 
@@ -1386,7 +1516,7 @@ export function luaKeys(val: any): any[] {
 }
 
 export function luaTypeOf(val: any): LuaType | Promise<LuaType> {
-  if (val === null || val === undefined) {
+  if (val === null || val === undefined || isSqlNull(val)) {
     return "nil";
   }
   if (isPromise(val)) {
@@ -1462,9 +1592,10 @@ export class LuaRuntimeError extends Error {
       );
 
       // Add position indicator
-      const pointer = " ".repeat(column) + "^";
+      const pointer = `${" ".repeat(column)}^`;
 
-      traceStr += `* ${ctx.ref || "(unknown source)"} @ ${line}:${column}:\n` +
+      traceStr +=
+        `* ${ctx.ref || "(unknown source)"} @ ${line}:${column}:\n` +
         `   ${codeLine}\n` +
         `   ${pointer}\n`;
       current = current.parent;
@@ -1497,7 +1628,7 @@ export function luaToString(
   value: any,
   visited: Set<any> = new Set(),
 ): string | Promise<string> {
-  if (value === null || value === undefined) {
+  if (value === null || value === undefined || isSqlNull(value)) {
     return "nil";
   }
   if (isPromise(value)) {
@@ -1549,7 +1680,7 @@ export function luaToString(
           const strVal = await luaToString(val, visited);
           result += strVal;
         }
-        return result + "}";
+        return `${result}}`;
       }
 
       // Handle objects
@@ -1576,20 +1707,20 @@ 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";
   if (n === Infinity) return "inf";
   if (n === -Infinity) return "-inf";
   if (n === 0) {
-    return (1 / n === -Infinity) ? "-0.0" : "0.0";
+    return 1 / n === -Infinity ? "-0.0" : "0.0";
   }
   // Delegate to luaFormat for `%.14g`
   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;
 }
@@ -1613,7 +1744,7 @@ export function getMetatable(
       }
 
       const stringMetatable = new LuaTable();
-      stringMetatable.set("__index", (globalEnv as any).get("string"));
+      void stringMetatable.set("__index", (globalEnv as any).get("string"));
       thread.setLocal("_STRING_MT", stringMetatable);
 
       return stringMetatable;
@@ -1629,6 +1760,9 @@ export function getMetatable(
 }
 
 export function jsToLuaValue(value: any): any {
+  if (value === null || value === undefined) {
+    return value;
+  }
   if (isPromise(value)) {
     return (value as Promise<any>).then(jsToLuaValue);
   }
@@ -1643,26 +1777,26 @@ export function jsToLuaValue(value: any): any {
     const regexMatch = value as RegExpMatchArray;
     const regexMatchTable = new LuaTable();
     for (let i = 0; i < regexMatch.length; i++) {
-      regexMatchTable.set(i + 1, regexMatch[i]);
+      void regexMatchTable.set(i + 1, regexMatch[i]);
     }
-    regexMatchTable.set("index", regexMatch.index);
-    regexMatchTable.set("input", regexMatch.input);
-    regexMatchTable.set("groups", regexMatch.groups);
+    void regexMatchTable.set("index", regexMatch.index);
+    void regexMatchTable.set("input", regexMatch.input);
+    void regexMatchTable.set("groups", regexMatch.groups);
     return regexMatchTable;
   }
   if (Array.isArray(value)) {
-    const table = new LuaTable();
+    const converted = new Array(value.length);
     for (let i = 0; i < value.length; i++) {
-      table.set(i + 1, jsToLuaValue(value[i]));
+      converted[i] = jsToLuaValue(value[i]);
     }
-    return table;
+    return new LuaTable(converted);
   }
   if (typeof value === "object") {
-    const table = new LuaTable();
+    const converted: Record<string, any> = {};
     for (const key in value) {
-      table.set(key, jsToLuaValue((value as any)[key]));
+      converted[key] = jsToLuaValue((value as any)[key]);
     }
-    return table;
+    return new LuaTable(converted);
   }
   if (typeof value === "function") {
     return new LuaNativeJSFunction(value);
@@ -1679,13 +1813,12 @@ export function luaValueToJS(value: any, sf: LuaStackFrame): any {
     return value.toJS(sf);
   }
   if (
-    value instanceof LuaNativeJSFunction || value instanceof LuaFunction ||
+    value instanceof LuaNativeJSFunction ||
+    value instanceof LuaFunction ||
     value instanceof LuaBuiltinFunction
   ) {
     return (...args: any[]) => {
-      const jsArgs = rpAll(
-        args.map((v) => luaValueToJS(v, sf)),
-      );
+      const jsArgs = rpAll(args.map((v) => luaValueToJS(v, sf)));
       if (isPromise(jsArgs)) {
         return luaValueToJS(
           jsArgs.then((jsArgs) => (value as ILuaFunction).call(sf, ...jsArgs)),