@silverbulletmd/silverbullet 2.4.2 → 2.6.1

package/client/space_lua/eval.ts

@@ -4,6 +4,7 @@ import type {
   LuaExpression,
   LuaLValue,
   LuaStatement,
+  LuaTableField,
   NumericType,
 } from "./ast.ts";
 import { LuaAttribute } from "./ast.ts";
@@ -19,6 +20,7 @@ import {
   luaEnsureCloseStack,
   LuaEnv,
   luaEquals,
+  luaFormatNumber,
   LuaFunction,
   luaGet,
   luaIndexValue,
@@ -38,8 +40,9 @@ import {
   singleResult,
 } from "./runtime.ts";
 import {
-  ArrayQueryCollection,
   type LuaCollectionQuery,
+  type LuaGroupByEntry,
+  toCollection,
 } from "./query_collection.ts";
 import {
   coerceNumericPair,
@@ -107,8 +110,14 @@ function astNumberKind(e: LuaExpression | undefined): NumericType | undefined {
     result = unwrapped.numericType === "int" ? "int" : "float";
   } else if (unwrapped.type === "Binary") {
     const op = unwrapped.operator;
-    const numericOp = op === "+" || op === "-" || op === "*" || op === "/" ||
-      op === "//" || op === "%" || op === "^";
+    const numericOp =
+      op === "+" ||
+      op === "-" ||
+      op === "*" ||
+      op === "/" ||
+      op === "//" ||
+      op === "%" ||
+      op === "^";
 
     if (numericOp) {
       const lk = astNumberKind(unwrapped.left);
@@ -178,18 +187,6 @@ function blockMetaOrThrow(
   }
 }
 
-// Queryable guard to avoid `(collection as any).query` usage
-type Queryable = {
-  query: (
-    q: LuaCollectionQuery,
-    env: LuaEnv,
-    sf: LuaStackFrame,
-  ) => Promise<any>;
-};
-function isQueryable(x: unknown): x is Queryable {
-  return !!x && typeof (x as any).query === "function";
-}
-
 function arithVerbFromOperator(op: string): string | null {
   switch (op) {
     case "+":
@@ -250,7 +247,7 @@ function arithCoercionErrorOrThrow(
   throw e;
 }
 
-function luaOp(
+export function luaOp(
   op: string,
   left: any,
   right: any,
@@ -260,67 +257,68 @@ function luaOp(
   sf: LuaStackFrame,
 ): any {
   switch (op) {
-    case "+":
-    case "-":
-    case "*":
+    case "+": {
+      // Ultra-fast path: both plain numbers with no float type annotation (int + int)
+      if (
+        typeof left === "number" &&
+        typeof right === "number" &&
+        leftType !== "float" &&
+        rightType !== "float"
+      ) {
+        return left + right;
+      }
+      return luaArithGeneric("+", left, right, leftType, rightType, ctx, sf);
+    }
+    case "-": {
+      if (
+        typeof left === "number" &&
+        typeof right === "number" &&
+        leftType !== "float" &&
+        rightType !== "float"
+      ) {
+        const r = left - right;
+        // Integer subtraction can produce -0 (e.g. 0 - 0), normalize to +0
+        return r === 0 ? 0 : r;
+      }
+      return luaArithGeneric("-", left, right, leftType, rightType, ctx, sf);
+    }
+    case "*": {
+      if (
+        typeof left === "number" &&
+        typeof right === "number" &&
+        leftType !== "float" &&
+        rightType !== "float"
+      ) {
+        const r = left * right;
+        // Integer multiplication can produce -0 (e.g. 0 * -1), normalize to +0
+        return r === 0 ? 0 : r;
+      }
+      return luaArithGeneric("*", left, right, leftType, rightType, ctx, sf);
+    }
     case "/":
     case "^": {
-      const ar = numericArith[op as NumericArithOp];
-      try {
-        const { left: l, right: r, resultType } = coerceNumericPair(
-          left,
-          right,
-          leftType,
-          rightType,
-          op,
-        );
-
-        let result = ar.f(l, r);
-
-        if (
-          ar.special === "sub" &&
-          result === 0 &&
-          isNegativeZero(result) &&
-          resultType === "float"
-        ) {
-          const rhsIsIntZero = r === 0 && rightType === "int";
-          if (rhsIsIntZero) {
-            result = 0;
-          }
-        }
-
-        const normalized = normalizeArithmeticResult(result, resultType);
-
-        // Operators `/` and `^` produce float, wrap only if needed.
-        if (op === "/" || op === "^") {
-          if (normalized === 0) {
-            return makeLuaZero(normalized, "float");
-          }
-          if (!Number.isFinite(normalized)) {
-            return normalized;
-          }
-          if (!Number.isInteger(normalized)) {
-            return normalized;
-          }
-          return makeLuaFloat(normalized);
-        }
-
-        if (normalized === 0) {
-          return makeLuaZero(normalized, resultType);
-        }
-        if (resultType === "float" && Number.isInteger(normalized)) {
-          return makeLuaFloat(normalized);
-        }
-        return normalized;
-      } catch (e: any) {
-        const meta = evalMetamethod(left, right, ar.metaMethod, ctx, sf);
-        if (meta !== undefined) {
-          return meta;
-        }
-        return arithCoercionErrorOrThrow(op, left, right, ctx, sf, e);
-      }
+      return luaArithGeneric(
+        op as NumericArithOp,
+        left,
+        right,
+        leftType,
+        rightType,
+        ctx,
+        sf,
+      );
     }
     case "..": {
+      // Fast path: string .. string (most common in SilverBullet — key building, templates)
+      if (typeof left === "string" && typeof right === "string") {
+        return left + right;
+      }
+      // Fast path: string .. number or number .. string
+      if (typeof left === "string" && typeof right === "number") {
+        return left + luaFormatNumber(right);
+      }
+      if (typeof left === "number" && typeof right === "string") {
+        return luaFormatNumber(left) + right;
+      }
       try {
         const coerce = (v: any): string => {
           if (v === null || v === undefined) {
@@ -333,10 +331,10 @@ function luaOp(
             return v as string;
           }
           if (typeof v === "number") {
-            return String(v);
+            return luaFormatNumber(v);
           }
           if (isTaggedFloat(v)) {
-            return String(v.value);
+            return luaFormatNumber(v.value, "float");
           }
           const t = luaTypeName(v);
           throw new LuaRuntimeError(
@@ -354,27 +352,54 @@ function luaOp(
       }
     }
     case "==": {
+      // Fast path for same-type primitives
+      if (typeof left === typeof right && typeof left !== "object") {
+        return left === right;
+      }
       if (luaEquals(left, right)) return true;
       return luaEqWithMetamethod(left, right, ctx, sf);
     }
     case "~=":
     case "!=": {
+      if (typeof left === typeof right && typeof left !== "object") {
+        return left !== right;
+      }
       if (luaEquals(left, right)) {
         return false;
       }
       return !luaEqWithMetamethod(left, right, ctx, sf);
     }
     case "<": {
+      // Fast path: both plain numbers
+      if (typeof left === "number" && typeof right === "number") {
+        return left < right;
+      }
+      // Fast path: both strings
+      if (typeof left === "string" && typeof right === "string") {
+        return left < right;
+      }
       return luaRelWithMetamethod("<", left, right, ctx, sf);
     }
     case "<=": {
+      if (typeof left === "number" && typeof right === "number")
+        return left <= right;
+      if (typeof left === "string" && typeof right === "string")
+        return left <= right;
       return luaRelWithMetamethod("<=", left, right, ctx, sf);
     }
     // Lua: `a>b` is `b<a`, `a>=b` is `b<=a`
     case ">": {
+      if (typeof left === "number" && typeof right === "number")
+        return left > right;
+      if (typeof left === "string" && typeof right === "string")
+        return left > right;
       return luaRelWithMetamethod("<", right, left, ctx, sf);
     }
     case ">=": {
+      if (typeof left === "number" && typeof right === "number")
+        return left >= right;
+      if (typeof left === "string" && typeof right === "string")
+        return left >= right;
       return luaRelWithMetamethod("<=", right, left, ctx, sf);
     }
   }
@@ -405,13 +430,79 @@ function luaOp(
   }
 }
 
+function luaArithGeneric(
+  op: NumericArithOp,
+  left: any,
+  right: any,
+  leftType: NumericType | undefined,
+  rightType: NumericType | undefined,
+  ctx: ASTCtx,
+  sf: LuaStackFrame,
+): any {
+  const ar = numericArith[op];
+  try {
+    const {
+      left: l,
+      right: r,
+      resultType,
+    } = coerceNumericPair(left, right, leftType, rightType, op);
+
+    let result = ar.f(l, r);
+
+    if (
+      ar.special === "sub" &&
+      result === 0 &&
+      isNegativeZero(result) &&
+      resultType === "float"
+    ) {
+      const rhsIsIntZero = r === 0 && rightType === "int";
+      if (rhsIsIntZero) {
+        result = 0;
+      }
+    }
+
+    const normalized = normalizeArithmeticResult(result, resultType);
+
+    // Operators `/` and `^` produce float, wrap only if needed.
+    if (op === "/" || op === "^") {
+      if (normalized === 0) {
+        return makeLuaZero(normalized, "float");
+      }
+      if (!Number.isFinite(normalized)) {
+        return normalized;
+      }
+      if (!Number.isInteger(normalized)) {
+        return normalized;
+      }
+      return makeLuaFloat(normalized);
+    }
+
+    if (normalized === 0) {
+      return makeLuaZero(normalized, resultType);
+    }
+    if (resultType === "float" && Number.isInteger(normalized)) {
+      return makeLuaFloat(normalized);
+    }
+    return normalized;
+  } catch (e: any) {
+    const meta = evalMetamethod(left, right, ar.metaMethod, ctx, sf);
+    if (meta !== undefined) {
+      return meta;
+    }
+    return arithCoercionErrorOrThrow(op, left, right, ctx, sf, e);
+  }
+}
+
 type NumericArithOp = "+" | "-" | "*" | "/" | "^";
 
-const numericArith: Record<NumericArithOp, {
-  metaMethod: "__add" | "__sub" | "__mul" | "__div" | "__pow";
-  f: (l: number, r: number) => number;
-  special?: "sub";
-}> = {
+const numericArith: Record<
+  NumericArithOp,
+  {
+    metaMethod: "__add" | "__sub" | "__mul" | "__div" | "__pow";
+    f: (l: number, r: number) => number;
+    special?: "sub";
+  }
+> = {
   "+": { metaMethod: "__add", f: (l, r) => l + r },
   "-": { metaMethod: "__sub", f: (l, r) => l - r, special: "sub" },
   "*": { metaMethod: "__mul", f: (l, r) => l * r },
@@ -461,10 +552,7 @@ function luaFloorDiv(
   );
 
   if (resultType === "int" && right === 0) {
-    throw new LuaRuntimeError(
-      `attempt to divide by zero`,
-      sf.withCtx(ctx),
-    );
+    throw new LuaRuntimeError(`attempt to divide by zero`, sf.withCtx(ctx));
   }
 
   const result = Math.floor(left / right);
@@ -495,10 +583,7 @@ function luaMod(
   );
 
   if (resultType === "int" && right === 0) {
-    throw new LuaRuntimeError(
-      `attempt to perform 'n%0'`,
-      sf.withCtx(ctx),
-    );
+    throw new LuaRuntimeError(`attempt to perform 'n%0'`, sf.withCtx(ctx));
   }
 
   const q = Math.floor(left / right);
@@ -519,10 +604,7 @@ function luaMod(
   return normalized;
 }
 
-function luaUnaryMinus(
-  v: number,
-  numType: NumericType | undefined,
-): number {
+function luaUnaryMinus(v: number, numType: NumericType | undefined): number {
   const vType = numType ?? inferNumericType(v);
 
   if (v === 0 && vType === "int") {
@@ -536,17 +618,20 @@ function luaUnaryMinus(
   return -v;
 }
 
-const operatorsMetaMethods: Record<string, {
-  metaMethod?: string;
-  nativeImplementation: (
-    a: LuaValue,
-    b: LuaValue,
-    leftType: NumericType | undefined,
-    rightType: NumericType | undefined,
-    ctx: ASTCtx,
-    sf: LuaStackFrame,
-  ) => LuaValue;
-}> = {
+const operatorsMetaMethods: Record<
+  string,
+  {
+    metaMethod?: string;
+    nativeImplementation: (
+      a: LuaValue,
+      b: LuaValue,
+      leftType: NumericType | undefined,
+      rightType: NumericType | undefined,
+      ctx: ASTCtx,
+      sf: LuaStackFrame,
+    ) => LuaValue;
+  }
+> = {
   "//": {
     metaMethod: "__idiv",
     nativeImplementation: (a, b, lt, rt, ctx, sf) =>
@@ -609,6 +694,168 @@ const operatorsMetaMethods: Record<string, {
   },
 };
 
+function deriveFieldName(e: LuaExpression): string | undefined {
+  switch (e.type) {
+    case "Variable":
+      return e.name;
+    case "PropertyAccess":
+      return e.property;
+    case "FunctionCall":
+      if (e.name) return e.name;
+      if (e.prefix.type === "Variable") return e.prefix.name;
+      if (e.prefix.type === "PropertyAccess") return e.prefix.property;
+      return undefined;
+    case "FilteredCall":
+      return deriveFieldName(e.call);
+    case "AggregateCall":
+      return deriveFieldName((e as any).call);
+    default:
+      return undefined;
+  }
+}
+
+function fieldsToExpression(
+  fields: LuaTableField[],
+  ctx: ASTCtx,
+): LuaExpression {
+  if (fields.length === 1 && fields[0].type === "ExpressionField") {
+    return fields[0].value;
+  }
+  const promoted: LuaTableField[] = fields.map((f) => {
+    if (f.type !== "ExpressionField") return f;
+    const key = deriveFieldName(f.value);
+    if (key) {
+      return {
+        type: "PropField",
+        key,
+        value: f.value,
+        ctx: f.ctx,
+      } as LuaTableField;
+    }
+    return f;
+  });
+  return { type: "TableConstructor", fields: promoted, ctx };
+}
+
+function fieldsToGroupByEntries(fields: LuaTableField[]): LuaGroupByEntry[] {
+  return fields.map((f) => {
+    switch (f.type) {
+      case "PropField":
+        return { expr: f.value, alias: f.key };
+      case "ExpressionField":
+        return { expr: f.value };
+      case "DynamicField":
+        return { expr: f.value };
+    }
+  });
+}
+
+type FromSource =
+  | { kind: "single"; objectVariable?: string; expression: LuaExpression }
+  | { kind: "cross"; sources: { name: string; expression: LuaExpression }[] };
+
+function fromFieldsToSource(fields: LuaTableField[], ctx: ASTCtx): FromSource {
+  if (fields.length === 1) {
+    const f = fields[0];
+    if (f.type === "ExpressionField") {
+      return { kind: "single", expression: f.value };
+    }
+    if (f.type === "PropField") {
+      return { kind: "single", objectVariable: f.key, expression: f.value };
+    }
+  }
+
+  const sources: { name: string; expression: LuaExpression }[] = [];
+  for (const f of fields) {
+    if (f.type !== "PropField") {
+      throw new LuaRuntimeError("Multi-source 'from' requires named sources", {
+        ref: ctx,
+      } as any);
+    }
+    sources.push({ name: f.key, expression: f.value });
+  }
+  return { kind: "cross", sources };
+}
+
+async function normalizeToArray(
+  collection: LuaValue,
+  sf: LuaStackFrame,
+): Promise<any[]> {
+  if (collection instanceof LuaTable && collection.empty()) {
+    return [];
+  }
+  if (collection instanceof LuaTable) {
+    if (collection.length > 0) {
+      const arr: any[] = [];
+      for (let i = 1; i <= collection.length; i++) {
+        arr.push(collection.rawGet(i));
+      }
+      return arr;
+    }
+    return [collection];
+  }
+  if (Array.isArray(collection)) {
+    return collection;
+  }
+  if (
+    typeof collection === "object" &&
+    collection !== null &&
+    "query" in collection &&
+    typeof (collection as any).query === "function"
+  ) {
+    const allItems = await (collection as any).query(
+      { distinct: false },
+      new LuaEnv(),
+      sf,
+    );
+    return Array.isArray(allItems) ? allItems : [allItems];
+  }
+  const jsVal = luaValueToJS(collection, sf);
+  return Array.isArray(jsVal) ? jsVal : [jsVal];
+}
+
+async function evalCrossJoinSources(
+  sources: { name: string; expression: LuaExpression }[],
+  env: LuaEnv,
+  sf: LuaStackFrame,
+  ctx: ASTCtx,
+): Promise<LuaTable[]> {
+  // Evaluate each source and normalize to arrays
+  const arrays: { name: string; items: any[] }[] = [];
+  for (const src of sources) {
+    const val = await evalExpression(src.expression, env, sf);
+    if (val === null || val === undefined) {
+      throw new LuaRuntimeError(
+        `Cross-join source '${src.name}' is nil`,
+        sf.withCtx(ctx),
+      );
+    }
+    const items = await normalizeToArray(val, sf);
+    arrays.push({ name: src.name, items });
+  }
+
+  // Cartesian product
+  let product: Record<string, any>[] = [{}];
+  for (const { name, items } of arrays) {
+    const newProduct: Record<string, any>[] = [];
+    for (const combo of product) {
+      for (const item of items) {
+        newProduct.push({ ...combo, [name]: item });
+      }
+    }
+    product = newProduct;
+  }
+
+  // Convert each combination to a `LuaTable` row
+  return product.map((combo) => {
+    const row = new LuaTable();
+    for (const key in combo) {
+      void row.rawSet(key, combo[key]);
+    }
+    return row;
+  });
+}
+
 export function evalExpression(
   e: LuaExpression,
   env: LuaEnv,
@@ -642,14 +889,7 @@ export function evalExpression(
         if (b.operator === "and") {
           return evalLogical("and", b.left, b.right, env, sf);
         }
-        return evalBinaryWithLR(
-          b.operator,
-          b.left,
-          b.right,
-          b.ctx,
-          env,
-          sf,
-        );
+        return evalBinaryWithLR(b.operator, b.left, b.right, b.ctx, env, sf);
       }
       case "Unary": {
         const u = asUnary(e);
@@ -673,59 +913,53 @@ export function evalExpression(
           const applyTyped = (typed: TypedValue) => {
             const arg = singleResult(typed.value);
 
-            return unaryWithMeta(
-              arg,
-              "__unm",
-              u.ctx,
-              sf,
-              () => {
-                // Numeric-string coercion for unary minus
-                if (typeof arg === "string") {
-                  const n = coerceToNumber(arg);
-                  if (n === null) {
-                    throw new LuaRuntimeError(
-                      "attempt to unm a 'string' with a 'string'",
-                      sf.withCtx(u.ctx),
-                    );
-                  }
-                  if (n === 0) {
-                    return 0;
-                  }
-                  return -n;
-                }
-
-                const plain = untagNumber(arg);
-                if (typeof plain !== "number") {
+            return unaryWithMeta(arg, "__unm", u.ctx, sf, () => {
+              // Numeric-string coercion for unary minus
+              if (typeof arg === "string") {
+                const n = coerceToNumber(arg);
+                if (n === null) {
                   throw new LuaRuntimeError(
-                    "attempt to perform arithmetic on a table value",
+                    "attempt to unm a 'string' with a 'string'",
                     sf.withCtx(u.ctx),
                   );
                 }
+                if (n === 0) {
+                  return 0;
+                }
+                return -n;
+              }
 
-                const argType = isTaggedFloat(arg)
-                  ? "float"
-                  : astNumberKind(u.argument);
+              const plain = untagNumber(arg);
+              if (typeof plain !== "number") {
+                throw new LuaRuntimeError(
+                  "attempt to perform arithmetic on a table value",
+                  sf.withCtx(u.ctx),
+                );
+              }
 
-                const out = luaUnaryMinus(plain, argType);
+              const argType = isTaggedFloat(arg)
+                ? "float"
+                : astNumberKind(u.argument);
 
-                // If the operand is a float-tagged boxed number, unary
-                // minus must keep the result float-typed.
-                if (isTaggedFloat(arg)) {
-                  if (out === 0) {
-                    return makeLuaZero(out, "float");
-                  }
-                  return makeLuaFloat(out);
-                }
+              const out = luaUnaryMinus(plain, argType);
 
-                // Preserve numeric kind for zero results
+              // If the operand is a float-tagged boxed number, unary
+              // minus must keep the result float-typed.
+              if (isTaggedFloat(arg)) {
                 if (out === 0) {
-                  const outType = argType ?? inferNumericType(plain);
-                  return makeLuaZero(out, outType);
+                  return makeLuaZero(out, "float");
                 }
+                return makeLuaFloat(out);
+              }
 
-                return out;
-              },
-            );
+              // Preserve numeric kind for zero results
+              if (out === 0) {
+                const outType = argType ?? inferNumericType(plain);
+                return makeLuaZero(out, outType);
+              }
+
+              return out;
+            });
           };
 
           return rpThen(tv as any, applyTyped);
@@ -740,35 +974,29 @@ export function evalExpression(
             }
             case "~": {
               const arg = singleResult(value);
-              return unaryWithMeta(
-                arg,
-                "__bnot",
-                u.ctx,
-                sf,
-                () => {
-                  const intVal = toInteger(arg);
-                  if (intVal === null) {
-                    if (typeof arg === "string") {
-                      throw new LuaRuntimeError(
-                        `attempt to perform bitwise operation on a string value (constant '${arg}')`,
-                        sf.withCtx(u.ctx),
-                      );
-                    }
-                    const t = luaTypeName(arg);
-                    if (t === "number") {
-                      throw new LuaRuntimeError(
-                        `number has no integer representation`,
-                        sf.withCtx(u.ctx),
-                      );
-                    }
+              return unaryWithMeta(arg, "__bnot", u.ctx, sf, () => {
+                const intVal = toInteger(arg);
+                if (intVal === null) {
+                  if (typeof arg === "string") {
                     throw new LuaRuntimeError(
-                      `attempt to perform bitwise operation on a ${t} value`,
+                      `attempt to perform bitwise operation on a string value (constant '${arg}')`,
                       sf.withCtx(u.ctx),
                     );
                   }
-                  return ~intVal;
-                },
-              );
+                  const t = luaTypeName(arg);
+                  if (t === "number") {
+                    throw new LuaRuntimeError(
+                      `number has no integer representation`,
+                      sf.withCtx(u.ctx),
+                    );
+                  }
+                  throw new LuaRuntimeError(
+                    `attempt to perform bitwise operation on a ${t} value`,
+                    sf.withCtx(u.ctx),
+                  );
+                }
+                return ~intVal;
+              });
             }
             case "#": {
               return luaLengthOp(singleResult(value), u.ctx, sf);
@@ -792,31 +1020,63 @@ export function evalExpression(
       }
       case "TableConstructor": {
         const tc = asTableConstructor(e);
-        return Promise.resolve().then(async () => {
-          const table = new LuaTable();
-          // Expression fields assign consecutive integer keys starting
-          // at 1 and advance even when the value is `nil`.
-          let nextArrayIndex = 1;
-          for (const field of tc.fields) {
+        const table = new LuaTable();
+        // Expression fields assign consecutive integer keys starting
+        // at 1 and advance even when the value is `nil`.
+        let nextArrayIndex = 1;
+
+        const processField = (
+          fieldIdx: number,
+        ): LuaTable | Promise<LuaTable> => {
+          for (let fi = fieldIdx; fi < tc.fields.length; fi++) {
+            const field = tc.fields[fi];
             switch (field.type) {
               case "PropField": {
-                const value = await evalExpression(field.value, env, sf);
-                table.set(field.key, singleResult(value), sf);
+                const value = evalExpression(field.value, env, sf);
+                if (isPromise(value)) {
+                  return (value as Promise<any>).then((v) => {
+                    void table.set(field.key, singleResult(v), sf);
+                    return processField(fi + 1);
+                  });
+                }
+                void table.set(field.key, singleResult(value), sf);
                 break;
               }
               case "DynamicField": {
-                const key = await evalExpression(field.key, env, sf);
-                const value = await evalExpression(field.value, env, sf);
-                table.set(singleResult(key), singleResult(value), sf);
+                const key = evalExpression(field.key, env, sf);
+                const val = evalExpression(field.value, env, sf);
+                if (isPromise(key) || isPromise(val)) {
+                  return rpThen(key, (k) =>
+                    rpThen(val, (v) => {
+                      void table.set(singleResult(k), singleResult(v), sf);
+                      return processField(fi + 1);
+                    }),
+                  ) as Promise<LuaTable>;
+                }
+                void table.set(singleResult(key), singleResult(val), sf);
                 break;
               }
               case "ExpressionField": {
-                const value = await evalExpression(field.value, env, sf);
-
+                const value = evalExpression(field.value, env, sf);
+                if (isPromise(value)) {
+                  return (value as Promise<any>).then((v) => {
+                    if (v instanceof LuaMultiRes) {
+                      const flat = v.flatten();
+                      for (let j = 0; j < flat.values.length; j++) {
+                        table.rawSetArrayIndex(nextArrayIndex, flat.values[j]);
+                        nextArrayIndex++;
+                      }
+                    } else {
+                      table.rawSetArrayIndex(nextArrayIndex, singleResult(v));
+                      nextArrayIndex++;
+                    }
+                    return processField(fi + 1);
+                  });
+                }
                 if (value instanceof LuaMultiRes) {
                   const flat = value.flatten();
-                  for (let i = 0; i < flat.values.length; i++) {
-                    table.rawSetArrayIndex(nextArrayIndex, flat.values[i]);
+                  for (let j = 0; j < flat.values.length; j++) {
+                    table.rawSetArrayIndex(nextArrayIndex, flat.values[j]);
                     nextArrayIndex++;
                   }
                 } else {
@@ -828,7 +1088,9 @@ export function evalExpression(
             }
           }
           return table;
-        });
+        };
+
+        return processField(0);
       }
       case "FunctionDefinition": {
         const fd = asFunctionDef(e);
@@ -838,37 +1100,125 @@ export function evalExpression(
         const q = asQueryExpr(e);
         const findFromClause = q.clauses.find((c) => c.type === "From");
         if (!findFromClause) {
-          throw new LuaRuntimeError(
-            "No from clause found",
-            sf.withCtx(q.ctx),
-          );
+          throw new LuaRuntimeError("No from clause found", sf.withCtx(q.ctx));
+        }
+        const fromSource = fromFieldsToSource(
+          findFromClause.fields,
+          findFromClause.ctx,
+        );
+
+        if (fromSource.kind === "cross") {
+          // Materialize Cartesian product, then query
+          return (async () => {
+            const rows = await evalCrossJoinSources(
+              fromSource.sources,
+              env,
+              sf,
+              findFromClause.ctx,
+            );
+            const collection: any = toCollection(rows);
+
+            // Build up query object
+            const query: LuaCollectionQuery = {
+              objectVariable: undefined,
+              distinct: true,
+            };
+
+            // Map clauses to query parameters
+            for (const clause of q.clauses) {
+              switch (clause.type) {
+                case "Where": {
+                  query.where = clause.expression;
+                  break;
+                }
+                case "OrderBy": {
+                  query.orderBy = clause.orderBy.map((o) => ({
+                    expr: o.expression,
+                    desc: o.direction === "desc",
+                    nulls: o.nulls,
+                    using: o.using,
+                  }));
+                  break;
+                }
+                case "Select": {
+                  query.select = fieldsToExpression(clause.fields, clause.ctx);
+                  break;
+                }
+                case "Limit": {
+                  const limitVal = await evalExpression(clause.limit, env, sf);
+                  query.limit = Number(limitVal);
+                  if (clause.offset) {
+                    const offsetVal = await evalExpression(
+                      clause.offset,
+                      env,
+                      sf,
+                    );
+                    query.offset = Number(offsetVal);
+                  }
+                  break;
+                }
+                case "Offset": {
+                  const offsetVal = await evalExpression(
+                    clause.offset,
+                    env,
+                    sf,
+                  );
+                  query.offset = Number(offsetVal);
+                  break;
+                }
+                case "GroupBy": {
+                  query.groupBy = fieldsToGroupByEntries(clause.fields);
+                  break;
+                }
+                case "Having": {
+                  query.having = clause.expression;
+                  break;
+                }
+              }
+            }
+
+            return (collection as any)
+              .query(query, env, sf, globalThis.client?.config)
+              .then(jsToLuaValue);
+          })();
         }
-        const objectVariable = findFromClause.name;
-        const objectExpression = findFromClause.expression;
+
+        // Single-source
+        const { objectVariable, expression: objectExpression } = fromSource;
         return Promise.resolve(evalExpression(objectExpression, env, sf)).then(
           async (collection: LuaValue) => {
             if (!collection) {
-              throw new LuaRuntimeError(
-                "Collection is nil",
-                sf.withCtx(q.ctx),
-              );
+              throw new LuaRuntimeError("Collection is nil", sf.withCtx(q.ctx));
             }
-            if (collection instanceof LuaTable && collection.empty()) {
-              // Make sure we're converting an empty result to an array to "query"
-              collection = [];
-            } else {
-              collection = luaValueToJS(collection, sf);
-            }
-            // Check if collection is a queryable collection
-            if (!isQueryable(collection)) {
-              if (!Array.isArray(collection)) {
-                throw new LuaRuntimeError(
-                  "Collection does not support query",
-                  sf.withCtx(q.ctx),
-                );
+
+            // If already a queryable collection (e.g. DataStoreQueryCollection),
+            // use directly - skip all LuaTable/JS conversion.
+            if (
+              typeof collection === "object" &&
+              collection !== null &&
+              "query" in collection &&
+              typeof (collection as any).query === "function"
+            ) {
+              // Already queryable, use as-is
+            } else if (collection instanceof LuaTable && collection.empty()) {
+              // Empty table → empty array
+              collection = toCollection([]);
+            } else if (collection instanceof LuaTable) {
+              if (collection.length > 0) {
+                // Array-like table: extract array items, keep as LuaTables
+                const arr: any[] = [];
+                for (let i = 1; i <= collection.length; i++) {
+                  arr.push(collection.rawGet(i));
+                }
+                collection = toCollection(arr);
+              } else {
+                // Record-like table (no array part): treat as singleton
+                collection = toCollection([collection]);
               }
-              collection = new ArrayQueryCollection(collection);
+            } else {
+              collection = toCollection(luaValueToJS(collection, sf));
             }
+
             // Build up query object
             const query: LuaCollectionQuery = {
               objectVariable,
@@ -886,11 +1236,13 @@ export function evalExpression(
                   query.orderBy = clause.orderBy.map((o) => ({
                     expr: o.expression,
                     desc: o.direction === "desc",
+                    nulls: o.nulls,
+                    using: o.using,
                   }));
                   break;
                 }
                 case "Select": {
-                  query.select = clause.expression;
+                  query.select = fieldsToExpression(clause.fields, clause.ctx);
                   break;
                 }
                 case "Limit": {
@@ -906,12 +1258,30 @@ export function evalExpression(
                   }
                   break;
                 }
+                case "Offset": {
+                  const offsetVal = await evalExpression(
+                    clause.offset,
+                    env,
+                    sf,
+                  );
+                  query.offset = Number(offsetVal);
+                  break;
+                }
+                case "GroupBy": {
+                  query.groupBy = fieldsToGroupByEntries(clause.fields);
+                  break;
+                }
+                case "Having": {
+                  query.having = clause.expression;
+                  break;
+                }
               }
             }
 
-            return (collection as Queryable).query(query, env, sf).then(
-              jsToLuaValue,
-            );
+            // Always use the possibly-wrapped collection
+            return (collection as any)
+              .query(query, env, sf, globalThis.client?.config)
+              .then(jsToLuaValue);
           },
         );
       }
@@ -964,13 +1334,10 @@ function evalPrefixExpression(
         return luaGet(table, key, ta.ctx, sf);
       }
 
-      return rpThen(
-        objV,
-        (obj) =>
-          rpThen(
-            keyV,
-            (key) => luaGet(singleResult(obj), singleResult(key), ta.ctx, sf),
-          ),
+      return rpThen(objV, (obj) =>
+        rpThen(keyV, (key) =>
+          luaGet(singleResult(obj), singleResult(key), ta.ctx, sf),
+        ),
       );
     }
 
@@ -980,50 +1347,88 @@ function evalPrefixExpression(
       // Sync-first: evaluate object; avoid Promise when object is sync.
       const objV = evalPrefixExpression(pa.object, env, sf);
       if (!isPromise(objV)) {
-        return luaGet(objV, pa.property, pa.ctx, sf);
+        return luaGet(singleResult(objV), pa.property, pa.ctx, sf);
       }
-      return rpThen(objV, (obj) => luaGet(obj, pa.property, pa.ctx, sf));
+      return rpThen(objV, (obj) =>
+        luaGet(singleResult(obj), pa.property, pa.ctx, sf),
+      );
     }
 
     case "FunctionCall": {
       const fc = asFunctionCall(e);
-      const prefixValue = evalPrefixExpression(fc.prefix, env, sf);
-      if (prefixValue === null || prefixValue === undefined) {
-        const nilMsg = fc.prefix.type === "Variable"
-          ? `attempt to call a nil value (global '${
-            asVariable(fc.prefix).name
-          }')`
-          : `attempt to call a nil value`;
+
+      // `order by` inside function arguments is only valid for aggregate
+      // calls evaluated by the query engine
+      if (fc.orderBy && fc.orderBy.length > 0) {
         throw new LuaRuntimeError(
-          nilMsg,
-          sf.withCtx(fc.prefix.ctx),
+          `'order by' is not allowed in non-aggregate function calls`,
+          sf.withCtx(fc.ctx),
         );
       }
 
-      let selfArgs: LuaValue[] = [];
+      const prefixValue = evalPrefixExpression(fc.prefix, env, sf);
+      if (prefixValue === null || prefixValue === undefined) {
+        const nilMsg =
+          fc.prefix.type === "Variable"
+            ? `attempt to call a nil value (global '${
+                asVariable(fc.prefix).name
+              }')`
+            : `attempt to call a nil value`;
+        throw new LuaRuntimeError(nilMsg, sf.withCtx(fc.prefix.ctx));
+      }
+
+      // Fast path: non-method call with sync prefix
+      if (!fc.name && !isPromise(prefixValue)) {
+        const argsVal = evalExpressions(fc.args, env, sf);
+        if (!isPromise(argsVal)) {
+          return luaCall(prefixValue, argsVal as LuaValue[], fc.ctx, sf);
+        }
+        return (argsVal as Promise<LuaValue[]>).then((args) =>
+          luaCall(prefixValue, args, fc.ctx, sf),
+        );
+      }
 
       const handleFunctionCall = (
         calleeVal: LuaValue,
+        selfArgs: LuaValue[],
       ): LuaValue | Promise<LuaValue> => {
         // Normal argument handling for hello:there(a, b, c) type calls
         if (fc.name) {
-          selfArgs = [calleeVal];
+          const self = calleeVal;
           calleeVal = luaIndexValue(calleeVal, fc.name, sf);
 
           if (isPromise(calleeVal)) {
-            return (calleeVal as Promise<any>).then(handleFunctionCall);
+            return (calleeVal as Promise<any>).then((cv) =>
+              handleFunctionCall(cv, [self]),
+            );
           }
+          selfArgs = [self];
         }
 
         const argsVal = evalExpressions(fc.args, env, sf);
-
-        const thenCall = (args: LuaValue[]) =>
-          luaCall(calleeVal, [...selfArgs, ...args], fc.ctx, sf);
-
-        return rpThen(argsVal, thenCall);
+        if (!isPromise(argsVal)) {
+          const allArgs =
+            selfArgs.length > 0
+              ? [...selfArgs, ...(argsVal as LuaValue[])]
+              : (argsVal as LuaValue[]);
+          return luaCall(calleeVal, allArgs, fc.ctx, sf);
+        }
+        return (argsVal as Promise<LuaValue[]>).then((args) =>
+          luaCall(
+            calleeVal,
+            selfArgs.length > 0 ? [...selfArgs, ...args] : args,
+            fc.ctx,
+            sf,
+          ),
+        );
       };
 
-      return rpThen(prefixValue, handleFunctionCall);
+      if (isPromise(prefixValue)) {
+        return (prefixValue as Promise<any>).then((pv) =>
+          handleFunctionCall(pv, []),
+        );
+      }
+      return handleFunctionCall(prefixValue, []);
     }
 
     default: {
@@ -1173,22 +1578,58 @@ function evalBinaryWithLR(
     : undefined;
   const leftVal = evalExpression(leftExpr, env, sf);
 
-  const applyLeft = (lv: any) => {
+  // Sync-first fast path: avoid closure allocation when both operands are sync
+  if (!isPromise(leftVal)) {
     const rightVal = evalExpression(rightExpr, env, sf);
-    const applyRight = (rv: any) => {
+    if (!isPromise(rightVal)) {
       return luaOp(
         op,
-        singleResult(lv),
+        singleResult(leftVal),
+        singleResult(rightVal),
+        leftType,
+        rightType,
+        ctx,
+        sf,
+      );
+    }
+    return (rightVal as Promise<any>).then((rv) =>
+      luaOp(
+        op,
+        singleResult(leftVal),
         singleResult(rv),
         leftType,
         rightType,
         ctx,
         sf,
+      ),
+    );
+  }
+
+  return (leftVal as Promise<any>).then((lv) => {
+    const rightVal = evalExpression(rightExpr, env, sf);
+    if (!isPromise(rightVal)) {
+      return luaOp(
+        op,
+        singleResult(lv),
+        singleResult(rightVal),
+        leftType,
+        rightType,
+        ctx,
+        sf,
       );
-    };
-    return rpThen(rightVal, applyRight);
-  };
-  return rpThen(leftVal, applyLeft);
+    }
+    return (rightVal as Promise<any>).then((rv) =>
+      luaOp(
+        op,
+        singleResult(lv),
+        singleResult(rv),
+        leftType,
+        rightType,
+        ctx,
+        sf,
+      ),
+    );
+  });
 }
 
 function createBitwiseError(
@@ -1271,10 +1712,7 @@ function luaEqWithMetamethod(
     }
 
     const ty = luaTypeName(mm);
-    throw new LuaRuntimeError(
-      `attempt to call a ${ty} value`,
-      sf.withCtx(ctx),
-    );
+    throw new LuaRuntimeError(`attempt to call a ${ty} value`, sf.withCtx(ctx));
   };
 
   // Try left __eq first, then right.
@@ -1331,11 +1769,7 @@ function luaRelWithMetamethod(
  * - for JavaScript arrays return length,
  * - throw error otherwise.
  */
-function luaLengthOp(
-  val: any,
-  ctx: ASTCtx,
-  sf: LuaStackFrame,
-): LuaValue {
+function luaLengthOp(val: any, ctx: ASTCtx, sf: LuaStackFrame): LuaValue {
   // Strings: ignore `__len`
   if (typeof val === "string") {
     return val.length;
@@ -1382,22 +1816,26 @@ function evalExpressions(
   env: LuaEnv,
   sf: LuaStackFrame,
 ): Promise<LuaValue[]> | LuaValue[] {
-  // Evaluate all arguments first (sync-first); do not allocate a Promise if all are sync.
-  const parts = es.map((arg) => evalExpression(arg, env, sf));
+  const len = es.length;
+  if (len === 0) return [];
+
+  // Evaluate all arguments (sync-first); avoid .map() closure overhead
+  const parts = new Array(len);
+  for (let i = 0; i < len; i++) {
+    parts[i] = evalExpression(es[i], env, sf);
+  }
   const argsVal = rpAll(parts);
 
   // In Lua multi-returns propagate only in tail position of an expression list.
   const finalize = (argsResolved: any[]) => {
-    if (argsResolved.length === 0) {
-      return [];
-    }
     const out: LuaValue[] = [];
+    const lastIdx = argsResolved.length - 1;
     // All but last expression produce a single value
-    for (let i = 0; i < argsResolved.length - 1; i++) {
+    for (let i = 0; i < lastIdx; i++) {
       out.push(singleResult(argsResolved[i]));
     }
     // Last expression preserves multiple results
-    const last = argsResolved[argsResolved.length - 1];
+    const last = argsResolved[lastIdx];
     if (last instanceof LuaMultiRes) {
       out.push(...last.flatten().values);
     } else {
@@ -1410,9 +1848,9 @@ function evalExpressions(
 }
 
 type EvalBlockResult =
-  | void
+  | undefined
   | ControlSignal
-  | Promise<void | ControlSignal>;
+  | Promise<undefined | ControlSignal>;
 
 function runStatementsNoGoto(
   stmts: LuaStatement[],
@@ -1420,17 +1858,12 @@ function runStatementsNoGoto(
   sf: LuaStackFrame,
   returnOnReturn: boolean,
   startIdx: number,
-): void | ControlSignal | Promise<void | ControlSignal> {
+): undefined | ControlSignal | Promise<undefined | ControlSignal> {
   const processFrom = (
     idx: number,
-  ): void | ControlSignal | Promise<void | ControlSignal> => {
+  ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
     for (let i = idx; i < stmts.length; i++) {
-      const result = evalStatement(
-        stmts[i],
-        execEnv,
-        sf,
-        returnOnReturn,
-      );
+      const result = evalStatement(stmts[i], execEnv, sf, returnOnReturn);
       if (isPromise(result)) {
         return (result as Promise<any>).then((res) => {
           if (res !== undefined) {
@@ -1482,9 +1915,8 @@ function withCloseBoundary(
   };
 
   const onRejected = (e: any) => {
-    const errObj: LuaValue = e instanceof LuaRuntimeError
-      ? e.message
-      : (e?.message ?? String(e));
+    const errObj: LuaValue =
+      e instanceof LuaRuntimeError ? e.message : (e?.message ?? String(e));
     const r = luaCloseFromMark(sf, mark, errObj);
     if (isPromise(r)) {
       return (r as Promise<void>).then(() => {
@@ -1527,9 +1959,7 @@ function evalBlockNoClose(
   if (fnHasGotos === true && !hasLabelHere && !hasGotoFlag) {
     const execEnv = b.needsEnv === true ? new LuaEnv(env) : env;
     const stmts = b.statements;
-    const runFrom = (
-      i: number,
-    ): EvalBlockResult => {
+    const runFrom = (i: number): EvalBlockResult => {
       for (; i < stmts.length; i++) {
         const r = evalStatement(stmts[i], execEnv, sf, returnOnReturn);
         if (isPromise(r)) {
@@ -1574,9 +2004,7 @@ function evalBlockNoClose(
   const execEnv = b.needsEnv === true ? new LuaEnv(env) : env;
   const stmts = b.statements;
 
-  const runFrom = (
-    i: number,
-  ): EvalBlockResult => {
+  const runFrom = (i: number): EvalBlockResult => {
     for (; i < stmts.length; i++) {
       const r = evalStatement(stmts[i], execEnv, sf, returnOnReturn);
       if (isPromise(r)) {
@@ -1621,22 +2049,25 @@ export function evalStatement(
   env: LuaEnv,
   sf: LuaStackFrame,
   returnOnReturn = false,
-): void | ControlSignal | Promise<void | ControlSignal> {
+): undefined | ControlSignal | Promise<undefined | ControlSignal> {
   switch (s.type) {
     case "Assignment": {
       const a = asAssignment(s);
       const valuesRP = evalExpressions(a.expressions, env, sf);
-      const lvaluesRP = evalPromiseValues(a.variables
-        .map((lval) => evalLValue(lval, env, sf)));
+      const lvaluesRP = evalPromiseValues(
+        a.variables.map((lval) => evalLValue(lval, env, sf)),
+      );
 
       const apply = (values: LuaValue[], lvalues: { env: any; key: any }[]) => {
+        // Create the error-reporting frame once, not per-lvalue
+        let errSf: LuaStackFrame | undefined;
         const ps: Promise<any>[] = [];
         for (let i = 0; i < lvalues.length; i++) {
           const r = luaSet(
             lvalues[i].env,
             lvalues[i].key,
             values[i],
-            sf.withCtx(a.ctx),
+            errSf || (errSf = sf.withCtx(a.ctx)),
           );
 
           if (isPromise(r)) {
@@ -1650,29 +2081,22 @@ export function evalStatement(
       };
 
       if (!isPromise(valuesRP) && !isPromise(lvaluesRP)) {
-        return apply(
-          valuesRP as LuaValue[],
-          lvaluesRP as LuaLValueContainer[],
-        );
+        return apply(valuesRP as LuaValue[], lvaluesRP as LuaLValueContainer[]);
       }
-      if (
-        isPromise(valuesRP) && !isPromise(lvaluesRP)
-      ) {
+      if (isPromise(valuesRP) && !isPromise(lvaluesRP)) {
         return (valuesRP as Promise<LuaValue[]>).then((values: LuaValue[]) =>
-          apply(values, lvaluesRP as LuaLValueContainer[])
+          apply(values, lvaluesRP as LuaLValueContainer[]),
         );
       }
-      if (
-        !isPromise(valuesRP) && isPromise(lvaluesRP)
-      ) {
+      if (!isPromise(valuesRP) && isPromise(lvaluesRP)) {
         return (lvaluesRP as Promise<any[]>).then((lvalues: any[]) =>
-          apply(valuesRP as LuaValue[], lvalues)
+          apply(valuesRP as LuaValue[], lvalues),
         );
       }
       return (valuesRP as Promise<LuaValue[]>).then((values: LuaValue[]) =>
         (lvaluesRP as Promise<any[]>).then((lvalues: any[]) =>
-          apply(values, lvalues)
-        )
+          apply(values, lvalues),
+        ),
       );
     }
     case "Local": {
@@ -1721,10 +2145,7 @@ export function evalStatement(
 
       const bindAvailable = () => {
         while (boundCount < l.names.length && boundCount < out.length) {
-          bindOne(
-            l.names[boundCount],
-            out[boundCount] ?? null,
-          );
+          bindOne(l.names[boundCount], out[boundCount] ?? null);
           boundCount++;
         }
       };
@@ -1773,7 +2194,7 @@ export function evalStatement(
         return rpThen(rp, onValue) as any;
       };
 
-      return runFrom(0);
+      return runFrom(0) as undefined | Promise<undefined>;
     }
     case "Semicolon": {
       return;
@@ -1804,9 +2225,8 @@ export function evalStatement(
       try {
         out = evalBlockNoClose(b, env, sf, returnOnReturn);
       } catch (e: any) {
-        const errObj: LuaValue = e instanceof LuaRuntimeError
-          ? e.message
-          : (e?.message ?? String(e));
+        const errObj: LuaValue =
+          e instanceof LuaRuntimeError ? e.message : (e?.message ?? String(e));
         const r = luaCloseFromMark(sf, mark, errObj);
         if (isPromise(r)) {
           return (r as Promise<void>).then(() => {
@@ -1825,10 +2245,7 @@ export function evalStatement(
 
       const runFrom = (
         i: number,
-      ):
-        | void
-        | ControlSignal
-        | Promise<void | ControlSignal> => {
+      ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
         if (i >= conds.length) {
           if (iff.elseBlock) {
             return evalStatement(iff.elseBlock, env, sf, returnOnReturn);
@@ -1855,132 +2272,84 @@ export function evalStatement(
     case "While": {
       const w = asWhile(s);
 
-      const runAsync = async (): Promise<void | ControlSignal> => {
+      // Sync-first loop that re-enters sync mode after each async iteration
+      const runSyncFirst = ():
+        | undefined
+        | ControlSignal
+        | Promise<undefined | ControlSignal> => {
         while (true) {
-          const c = await evalExpression(w.condition, env, sf);
-          if (!luaTruthy(c)) {
-            break;
+          const c = evalExpression(w.condition, env, sf);
+          if (isPromise(c)) {
+            return (c as Promise<any>).then((cv) => {
+              if (!luaTruthy(cv)) return;
+              return rpThen(
+                evalStatement(w.block, env, sf, returnOnReturn),
+                (res) => {
+                  if (res !== undefined) {
+                    return isBreakSignal(res) ? undefined : res;
+                  }
+                  return runSyncFirst();
+                },
+              );
+            });
           }
+          if (!luaTruthy(c)) break;
           const r = evalStatement(w.block, env, sf, returnOnReturn);
-          const res = isPromise(r) ? await r : r;
-          if (res !== undefined) {
-            if (isBreakSignal(res)) {
-              break;
-            }
-            return res;
+          if (isPromise(r)) {
+            return (r as Promise<any>).then((res) => {
+              if (res !== undefined) {
+                return isBreakSignal(res) ? undefined : res;
+              }
+              return runSyncFirst();
+            });
+          }
+          if (r !== undefined) {
+            if (isBreakSignal(r)) break;
+            return r;
           }
         }
         return;
       };
 
-      while (true) {
-        const c = evalExpression(w.condition, env, sf);
-        if (isPromise(c)) {
-          return (c as Promise<any>).then((cv) => {
-            if (!luaTruthy(cv)) {
-              return;
-            }
-            try {
-              const r = evalStatement(w.block, env, sf, returnOnReturn);
-              if (isPromise(r)) {
-                return (r as Promise<any>).then((res) => {
-                  if (res !== undefined) {
-                    if (isBreakSignal(res)) {
-                      return;
-                    }
-                    return res;
-                  }
-                  return runAsync();
-                });
-              }
-              if (r !== undefined) {
-                if (isBreakSignal(r)) {
-                  return;
-                }
-                return r;
-              }
-              return runAsync();
-            } catch (e: any) {
-              throw e;
-            }
-          });
-        }
-        if (!luaTruthy(c)) {
-          break;
-        }
-        const r = evalStatement(w.block, env, sf, returnOnReturn);
-        if (isPromise(r)) {
-          return (r as Promise<any>).then((res) => {
-            if (res !== undefined) {
-              if (isBreakSignal(res)) {
-                return;
-              }
-              return res;
-            }
-            return runAsync();
-          });
-        }
-        if (r !== undefined) {
-          if (isBreakSignal(r)) {
-            break;
-          }
-          return r;
-        }
-      }
-      return;
+      return runSyncFirst();
     }
     case "Repeat": {
-      const r = asRepeat(s);
+      const rep = asRepeat(s);
 
-      const runAsync = async (): Promise<void | ControlSignal> => {
+      // Sync-first loop that re-enters sync mode after each async iteration
+      const runSyncFirst = ():
+        | undefined
+        | ControlSignal
+        | Promise<undefined | ControlSignal> => {
         while (true) {
-          const rr = evalStatement(r.block, env, sf, returnOnReturn);
-          const res = isPromise(rr) ? await rr : rr;
-          if (res !== undefined) {
-            if (isBreakSignal(res)) {
-              break;
-            }
-            return res;
+          const rr = evalStatement(rep.block, env, sf, returnOnReturn);
+          if (isPromise(rr)) {
+            return (rr as Promise<any>).then((res) => {
+              if (res !== undefined) {
+                return isBreakSignal(res) ? undefined : res;
+              }
+              return rpThen(evalExpression(rep.condition, env, sf), (cv) =>
+                luaTruthy(cv) ? undefined : runSyncFirst(),
+              );
+            });
           }
-          const c = await evalExpression(r.condition, env, sf);
-          if (luaTruthy(c)) {
-            break;
+          if (rr !== undefined) {
+            if (isBreakSignal(rr)) return;
+            return rr;
           }
-        }
-        return;
-      };
 
-      while (true) {
-        const rr = evalStatement(r.block, env, sf, returnOnReturn);
-        if (isPromise(rr)) {
-          return (rr as Promise<any>).then((res) => {
-            if (res !== undefined) {
-              if (isBreakSignal(res)) {
-                return;
-              }
-              return res;
-            }
-            return runAsync();
-          });
-        }
-        if (rr !== undefined) {
-          if (isBreakSignal(rr)) {
-            return;
+          const c = evalExpression(rep.condition, env, sf);
+          if (isPromise(c)) {
+            return (c as Promise<any>).then((cv) =>
+              luaTruthy(cv) ? undefined : runSyncFirst(),
+            );
           }
-          return rr;
+          if (luaTruthy(c)) break;
         }
+        return;
+      };
 
-        const c = evalExpression(r.condition, env, sf);
-        if (isPromise(c)) {
-          return (c as Promise<any>).then((cv) =>
-            luaTruthy(cv) ? undefined : runAsync()
-          );
-        }
-        if (luaTruthy(c)) {
-          break;
-        }
-      }
-      return;
+      return runSyncFirst();
     }
     case "Break": {
       return { ctrl: "break" };
@@ -2000,7 +2369,7 @@ export function evalStatement(
       if (fn.name.colonName) {
         // function hello:there() -> function hello.there(self) transformation
         body = {
-          ...(fn.body),
+          ...fn.body,
           parameters: ["self", ...fn.body.parameters],
         };
         propNames = [...fn.name.propNames, fn.name.colonName];
@@ -2023,17 +2392,14 @@ export function evalStatement(
     }
     case "LocalFunction": {
       const lf = asLocalFunction(s);
-      env.setLocal(
-        lf.name,
-        new LuaFunction(lf.body, env),
-      );
+      env.setLocal(lf.name, new LuaFunction(lf.body, env));
       return;
     }
     case "Return": {
       const ret = asReturn(s);
 
       const parts = ret.expressions.map((value: LuaExpression) =>
-        evalExpression(value, env, sf)
+        evalExpression(value, env, sf),
       );
       const valuesRP = rpAll(parts);
 
@@ -2081,9 +2447,7 @@ export function evalStatement(
       const determineLoopType = (): NumericType => {
         const startType = astNumberKind(fr.start);
         const stepType = fr.step ? astNumberKind(fr.step) : "int";
-        return (startType === "float" || stepType === "float")
-          ? "float"
-          : "int";
+        return startType === "float" || stepType === "float" ? "float" : "int";
       };
 
       const wrapLoopVar = (i: number, loopType: NumericType) => {
@@ -2093,53 +2457,59 @@ export function evalStatement(
         return i;
       };
 
-      const canReuseEnv = !fr.block.hasFunctionDef ||
-        fr.capturesLoopVar === false;
+      const canReuseEnv =
+        !fr.block.hasFunctionDef || fr.capturesLoopVar === false;
 
       const executeIteration = canReuseEnv
         ? (
-          loopEnv: LuaEnv,
-          i: number,
-          loopType: NumericType,
-        ): void | ControlSignal | Promise<void | ControlSignal> => {
-          loopEnv.setLocal(fr.name, wrapLoopVar(i, loopType));
-          return evalStatement(fr.block, loopEnv, sf, returnOnReturn);
-        }
+            loopEnv: LuaEnv,
+            i: number,
+            loopType: NumericType,
+          ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
+            loopEnv.setLocal(fr.name, wrapLoopVar(i, loopType));
+            return evalStatement(fr.block, loopEnv, sf, returnOnReturn);
+          }
         : (
-          _loopEnv: LuaEnv,
-          i: number,
-          loopType: NumericType,
-        ): void | ControlSignal | Promise<void | ControlSignal> => {
-          const localEnv = new LuaEnv(env);
-          localEnv.setLocal(fr.name, wrapLoopVar(i, loopType));
-          return evalStatement(fr.block, localEnv, sf, returnOnReturn);
-        };
+            _loopEnv: LuaEnv,
+            i: number,
+            loopType: NumericType,
+          ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
+            const localEnv = new LuaEnv(env);
+            localEnv.setLocal(fr.name, wrapLoopVar(i, loopType));
+            return evalStatement(fr.block, localEnv, sf, returnOnReturn);
+          };
 
-      const runAsync = async (
+      // Continuation that re-enters sync mode after each async iteration
+      const runFromIndex = (
         loopEnv: LuaEnv,
         end: number,
         step: number,
         startIndex: number,
         loopType: NumericType,
-      ) => {
+      ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
         if (step === 0) {
           throw new LuaRuntimeError("'for' step is zero", sf.withCtx(fr.ctx));
         }
 
-        const shouldContinue = step > 0
-          ? (i: number) => i <= end
-          : (i: number) => i >= end;
+        const shouldContinue =
+          step > 0 ? (i: number) => i <= end : (i: number) => i >= end;
 
         for (let i = startIndex; shouldContinue(i); i += step) {
           const r = executeIteration(loopEnv, i, loopType);
-          const res = isPromise(r) ? await r : r;
-          if (res !== undefined) {
-            if (isBreakSignal(res)) {
-              return;
-            }
-            return res;
+          if (isPromise(r)) {
+            return (r as Promise<any>).then((res) => {
+              if (res !== undefined) {
+                return isBreakSignal(res) ? undefined : res;
+              }
+              return runFromIndex(loopEnv, end, step, i + step, loopType);
+            });
+          }
+          if (r !== undefined) {
+            if (isBreakSignal(r)) return;
+            return r;
           }
         }
+        return;
       };
 
       const runSyncFirst = (
@@ -2147,17 +2517,13 @@ export function evalStatement(
         end: number,
         step: number,
         loopType: NumericType,
-      ):
-        | void
-        | ControlSignal
-        | Promise<void | ControlSignal> => {
+      ): undefined | ControlSignal | Promise<undefined | ControlSignal> => {
         if (step === 0) {
           throw new LuaRuntimeError("'for' step is zero", sf.withCtx(fr.ctx));
         }
 
-        const shouldContinue = step > 0
-          ? (i: number) => i <= end
-          : (i: number) => i >= end;
+        const shouldContinue =
+          step > 0 ? (i: number) => i <= end : (i: number) => i >= end;
 
         const loopEnv = new LuaEnv(env);
 
@@ -2171,7 +2537,7 @@ export function evalStatement(
                 }
                 return res;
               }
-              return runAsync(loopEnv, end, step, i + step, loopType);
+              return runFromIndex(loopEnv, end, step, i + step, loopType);
             });
           }
           if (r !== undefined) {
@@ -2186,11 +2552,7 @@ export function evalStatement(
 
       const loopType = determineLoopType();
 
-      if (
-        !isPromise(startV) &&
-        !isPromise(endV) &&
-        !isPromise(stepV)
-      ) {
+      if (!isPromise(startV) && !isPromise(endV) && !isPromise(stepV)) {
         return runSyncFirst(
           untagNumber(startV) as number,
           untagNumber(endV) as number,
@@ -2217,8 +2579,8 @@ export function evalStatement(
         fi.expressions.map((e: LuaExpression) => evalExpression(e, env, sf)),
       );
 
-      const canReuseEnv = !fi.block.hasFunctionDef ||
-        fi.capturesLoopVar === false;
+      const canReuseEnv =
+        !fi.block.hasFunctionDef || fi.capturesLoopVar === false;
       const setIterVars = (
         localEnv: LuaEnv,
         names: string[],
@@ -2289,39 +2651,8 @@ export function evalStatement(
           return new LuaEnv(env);
         };
 
-        try {
-          const runAsync = async () => {
-            while (true) {
-              const callRes = luaCall(
-                iteratorValue,
-                [state, control],
-                fi.ctx,
-                sf,
-              );
-              const iterResult = new LuaMultiRes(
-                isPromise(callRes) ? await callRes : callRes,
-              ).flatten();
-              const nextControl = iterResult.values[0];
-              if (nextControl === null || nextControl === undefined) {
-                break;
-              }
-              control = nextControl;
-
-              const localEnv = makeIterEnv();
-              setIterVars(localEnv, fi.names, iterResult.values);
-
-              const r = evalStatement(fi.block, localEnv, sf, returnOnReturn);
-              const res = isPromise(r) ? await r : r;
-              if (res !== undefined) {
-                if (isBreakSignal(res)) {
-                  break;
-                }
-                return await finish(res);
-              }
-            }
-            return await finish(undefined);
-          };
-
+        // Sync-first loop that re-enters sync mode after each async iteration
+        const runSyncFirst = (): any => {
           while (true) {
             const iterCall = luaCall(
               iteratorValue,
@@ -2329,55 +2660,40 @@ export function evalStatement(
               fi.ctx,
               sf,
             );
-            if (isPromise(iterCall)) {
-              return (iterCall as Promise<any>).then((itv) => {
-                const iterResult = new LuaMultiRes(itv).flatten();
-                const nextControl = iterResult.values[0];
-                if (nextControl === null || nextControl === undefined) {
-                  const r = finish(undefined);
-                  if (isPromise(r)) return (r as Promise<void>).then(() => {});
-                  return;
-                }
-                control = nextControl;
 
-                const localEnv = makeIterEnv();
-                setIterVars(localEnv, fi.names, iterResult.values);
+            const afterIterCall = (itv: any): any => {
+              const iterResult = new LuaMultiRes(itv).flatten();
+              const nextControl = iterResult.values[0];
+              if (nextControl === null || nextControl === undefined) {
+                return finish(undefined);
+              }
+              control = nextControl;
 
-                const r = evalStatement(
-                  fi.block,
-                  localEnv,
-                  sf,
-                  returnOnReturn,
-                );
-                if (isPromise(r)) {
-                  return (r as Promise<any>).then((res) => {
-                    if (res !== undefined) {
-                      if (isBreakSignal(res)) {
-                        return finish(undefined);
-                      }
-                      return rpThen(finish(undefined), () => res);
-                    }
-                    return runAsync();
-                  });
-                }
-                if (r !== undefined) {
-                  if (isBreakSignal(r)) {
+              const localEnv = makeIterEnv();
+              setIterVars(localEnv, fi.names, iterResult.values);
+
+              const r = evalStatement(fi.block, localEnv, sf, returnOnReturn);
+              return rpThen(r, (res) => {
+                if (res !== undefined) {
+                  if (isBreakSignal(res)) {
                     return finish(undefined);
                   }
-                  return rpThen(finish(undefined), () => r);
+                  return rpThen(finish(undefined), () => res);
                 }
-                return runAsync();
-              }).catch((e: any) => finishErr(e));
+                return runSyncFirst();
+              });
+            };
+
+            if (isPromise(iterCall)) {
+              return (iterCall as Promise<any>)
+                .then(afterIterCall)
+                .catch((e: any) => finishErr(e));
             }
 
             const iterResult = new LuaMultiRes(iterCall).flatten();
             const nextControl = iterResult.values[0];
             if (nextControl === null || nextControl === undefined) {
-              const r = finish(undefined);
-              if (isPromise(r)) {
-                return (r as Promise<void>);
-              }
-              return;
+              return finish(undefined);
             }
             control = nextControl;
 
@@ -2386,15 +2702,17 @@ export function evalStatement(
 
             const r = evalStatement(fi.block, localEnv, sf, returnOnReturn);
             if (isPromise(r)) {
-              return (r as Promise<any>).then((res) => {
-                if (res !== undefined) {
-                  if (isBreakSignal(res)) {
-                    return finish(undefined);
+              return (r as Promise<any>)
+                .then((res) => {
+                  if (res !== undefined) {
+                    if (isBreakSignal(res)) {
+                      return finish(undefined);
+                    }
+                    return rpThen(finish(undefined), () => res);
                   }
-                  return rpThen(finish(undefined), () => res);
-                }
-                return runAsync();
-              }).catch((e: any) => finishErr(e));
+                  return runSyncFirst();
+                })
+                .catch((e: any) => finishErr(e));
             }
             if (r !== undefined) {
               if (isBreakSignal(r)) {
@@ -2403,6 +2721,10 @@ export function evalStatement(
               return rpThen(finish(undefined), () => r);
             }
           }
+        };
+
+        try {
+          return runSyncFirst();
         } catch (e: any) {
           return finishErr(e);
         }
@@ -2431,16 +2753,9 @@ function evalLValue(
     }
     case "TableAccess": {
       const ta = asLValueTableAccess(lval);
-      const objValue = evalExpression(
-        ta.object,
-        env,
-        sf,
-      );
+      const objValue = evalExpression(ta.object, env, sf);
       const keyValue = evalExpression(ta.key, env, sf);
-      if (
-        isPromise(objValue) ||
-        isPromise(keyValue)
-      ) {
+      if (isPromise(objValue) || isPromise(keyValue)) {
         return Promise.all([
           isPromise(objValue) ? objValue : Promise.resolve(objValue),
           isPromise(keyValue) ? keyValue : Promise.resolve(keyValue),
@@ -2456,11 +2771,7 @@ function evalLValue(
     }
     case "PropertyAccess": {
       const pa = asLValuePropertyAccess(lval);
-      const objValue = evalExpression(
-        pa.object,
-        env,
-        sf,
-      );
+      const objValue = evalExpression(pa.object, env, sf);
       if (isPromise(objValue)) {
         return (objValue as Promise<any>).then((ov) => {
           return {