porffor 0.2.0-fde989a → 0.14.0-4057a18e9

package/compiler/{codeGen.js → codegen.js}

@@ -1,12 +1,14 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from "./encoding.js";
-import { operatorOpcode } from "./expression.js";
-import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./builtins.js";
-import { PrototypeFuncs } from "./prototype.js";
-import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enforceEightBytes } from "./embedding.js";
-import { log } from "./log.js";
-import parse from "./parse.js";
-import * as Rhemyn from "../rhemyn/compile.js";
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.js';
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
+import { operatorOpcode } from './expression.js';
+import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
+import { PrototypeFuncs } from './prototype.js';
+import { number } from './embedding.js';
+import { TYPES, TYPE_NAMES } from './types.js';
+import * as Rhemyn from '../rhemyn/compile.js';
+import parse from './parse.js';
+import { log } from './log.js';
+import Prefs from './prefs.js';
 
 let globals = {};
 let globalInd = 0;
@@ -17,44 +19,32 @@ let funcIndex = {};
 let currentFuncIndex = importedFuncs.length;
 let builtinFuncs = {}, builtinVars = {}, prototypeFuncs = {};
 
-const debug = str => {
-  const code = [];
-
-  const logChar = n => {
-    code.push(...number(n));
-
-    code.push(Opcodes.call);
-    code.push(...unsignedLEB128(0));
-  };
-
-  for (let i = 0; i < str.length; i++) {
-    logChar(str.charCodeAt(i));
+class TodoError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'TodoError';
   }
+}
+const todo = (scope, msg, expectsValue = undefined) => {
+  switch (Prefs.todoTime ?? 'runtime') {
+    case 'compile':
+      throw new TodoError(msg);
 
-  logChar('\n'.charCodeAt(0));
+    case 'runtime':
+      return internalThrow(scope, 'TodoError', msg, expectsValue);
 
-  return code;
-};
-
-const todo = msg => {
-  class TodoError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = 'TodoError';
-    }
+      // return [
+      //   ...debug(`todo! ${msg}`),
+      //   [ Opcodes.unreachable ]
+      // ];
   }
-
-  throw new TodoError(`todo: ${msg}`);
-
-  const code = [];
-
-  code.push(...debug(`todo! ` + msg));
-  code.push(Opcodes.unreachable);
-
-  return code;
 };
 
 const isFuncType = type => type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
+const hasFuncWithName = name => {
+  const func = funcs.find(x => x.name === name);
+  return !!(func || builtinFuncs[name] || importedFuncs[name] || internalConstrs[name]);
+};
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
     case 'BinaryExpression':
@@ -104,7 +94,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       return generateUnary(scope, decl);
 
     case 'UpdateExpression':
-      return generateUpdate(scope, decl);
+      return generateUpdate(scope, decl, global, name, valueUnused);
 
     case 'IfStatement':
       return generateIf(scope, decl);
@@ -115,6 +105,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
+    case 'DoWhileStatement':
+      return generateDoWhile(scope, decl);
+
     case 'ForOfStatement':
       return generateForOf(scope, decl);
 
@@ -124,6 +117,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'ContinueStatement':
       return generateContinue(scope, decl);
 
+    case 'LabeledStatement':
+      return generateLabel(scope, decl);
+
     case 'EmptyStatement':
       return generateEmpty(scope, decl);
 
@@ -137,7 +133,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       return generateTry(scope, decl);
 
     case 'DebuggerStatement':
-      // todo: add fancy terminal debugger?
+      // todo: hook into terminal debugger
       return [];
 
     case 'ArrayExpression':
@@ -151,16 +147,17 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       const funcsBefore = funcs.length;
       generate(scope, decl.declaration);
 
-      if (funcsBefore === funcs.length) throw new Error('no new func added in export');
-
-      const newFunc = funcs[funcs.length - 1];
-      newFunc.export = true;
+      if (funcsBefore !== funcs.length) {
+        // new func added
+        const newFunc = funcs[funcs.length - 1];
+        newFunc.export = true;
+      }
 
       return [];
 
     case 'TaggedTemplateExpression': {
       const funcs = {
-        __Porffor_asm: str => {
+        __Porffor_wasm: str => {
           let out = [];
 
           for (const line of str.split('\n')) {
@@ -168,8 +165,8 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (asm[0] === '') continue; // blank
 
             if (asm[0] === 'local') {
-              const [ name, idx, type ] = asm.slice(1);
-              scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
+              const [ name, type ] = asm.slice(1);
+              scope.locals[name] = { idx: scope.localInd++, type: Valtype[type] };
               continue;
             }
 
@@ -179,52 +176,74 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             }
 
             if (asm[0] === 'memory') {
-              allocPage('asm instrinsic');
+              allocPage(scope, 'asm instrinsic');
               // todo: add to store/load offset insts
               continue;
             }
 
             let inst = Opcodes[asm[0].replace('.', '_')];
-            if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+            if (inst == null) throw new Error(`inline asm: inst ${asm[0]} not found`);
 
             if (!Array.isArray(inst)) inst = [ inst ];
-            const immediates = asm.slice(1).map(x => parseInt(x));
+            const immediates = asm.slice(1).map(x => {
+              const int = parseInt(x);
+              if (Number.isNaN(int)) return scope.locals[x]?.idx;
+              return int;
+            });
 
-            out.push([ ...inst, ...immediates ]);
+            out.push([ ...inst, ...immediates.flatMap(x => signedLEB128(x)) ]);
           }
 
           return out;
         },
 
         __Porffor_bs: str => [
-          ...makeString(scope, str, undefined, undefined, true),
+          ...makeString(scope, str, global, name, true),
 
-          ...number(TYPES._bytestring, Valtype.i32),
-          setLastType(scope)
+          ...(name ? setType(scope, name, TYPES.bytestring) : [
+            ...number(TYPES.bytestring, Valtype.i32),
+            ...setLastType(scope)
+          ])
         ],
         __Porffor_s: str => [
-          ...makeString(scope, str, undefined, undefined, false),
+          ...makeString(scope, str, global, name, false),
 
-          ...number(TYPES.string, Valtype.i32),
-          setLastType(scope)
+          ...(name ? setType(scope, name, TYPES.string) : [
+            ...number(TYPES.string, Valtype.i32),
+            ...setLastType(scope)
+          ])
         ],
       };
 
-      const name = decl.tag.name;
+      const func = decl.tag.name;
       // hack for inline asm
-      if (!funcs[name]) return todo('tagged template expressions not implemented');
+      if (!funcs[func]) return todo(scope, 'tagged template expressions not implemented', true);
+
+      const { quasis, expressions } = decl.quasi;
+      let str = quasis[0].value.raw;
+
+      for (let i = 0; i < expressions.length; i++) {
+        const e = expressions[i];
+        if (!e.name) {
+          if (e.type === 'BinaryExpression' && e.operator === '+' && e.left.type === 'Identifier' && e.right.type === 'Literal') {
+            str += lookupName(scope, e.left.name)[0].idx + e.right.value;
+          } else todo(scope, 'unsupported expression in intrinsic');
+        } else str += lookupName(scope, e.name)[0].idx;
 
-      const str = decl.quasi.quasis[0].value.raw;
-      return funcs[name](str);
+        str += quasis[i + 1].value.raw;
+      }
+
+      return funcs[func](str);
     }
 
     default:
-      if (decl.type.startsWith('TS')) {
-        // ignore typescript nodes
+      // ignore typescript nodes
+      if (decl.type.startsWith('TS') ||
+          decl.type === 'ImportDeclaration' && decl.importKind === 'type') {
         return [];
       }
 
-      return todo(`no generation for ${decl.type}!`);
+      return todo(scope, `no generation for ${decl.type}!`);
   }
 };
 
@@ -252,7 +271,7 @@ const lookupName = (scope, _name) => {
   return [ undefined, undefined ];
 };
 
-const internalThrow = (scope, constructor, message, expectsValue = false) => [
+const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysValueInternalThrows) => [
   ...generateThrow(scope, {
     argument: {
       type: 'NewExpression',
@@ -276,7 +295,10 @@ const generateIdent = (scope, decl) => {
 
     if (Object.hasOwn(builtinVars, name)) {
       if (builtinVars[name].floatOnly && valtype[0] === 'i') throw new Error(`Cannot use ${unhackName(name)} with integer valtype`);
-      return builtinVars[name];
+
+      let wasm = builtinVars[name];
+      if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name });
+      return wasm.slice();
     }
 
     if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(internalConstrs, name)) {
@@ -284,6 +306,11 @@ const generateIdent = (scope, decl) => {
       return number(1);
     }
 
+    if (isExistingProtoFunc(name)) {
+      // todo: return an actual something
+      return number(1);
+    }
+
     if (local?.idx === undefined) {
       // no local var with name
       if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name]);
@@ -314,14 +341,18 @@ const generateReturn = (scope, decl) => {
     // just bare "return"
     return [
       ...number(UNDEFINED), // "undefined" if func returns
-      ...number(TYPES.undefined, Valtype.i32), // type undefined
+      ...(scope.returnType != null ? [] : [
+        ...number(TYPES.undefined, Valtype.i32) // type undefined
+      ]),
       [ Opcodes.return ]
     ];
   }
 
   return [
     ...generate(scope, decl.argument),
-    ...getNodeType(scope, decl.argument),
+    ...(scope.returnType != null ? [] : [
+      ...getNodeType(scope, decl.argument)
+    ]),
     [ Opcodes.return ]
   ];
 };
@@ -335,7 +366,8 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
-const isIntOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
+const isIntOp = op => op && ((op[0] >= 0x45 && op[0] <= 0x4f) || (op[0] >= 0x67 && op[0] <= 0x78) || op[0] === 0x41);
+const isFloatToIntOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
 
 const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
@@ -344,7 +376,7 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
     '??': nullish
   };
 
-  if (!checks[op]) return todo(`logic operator ${op} not implemented yet`);
+  if (!checks[op]) return todo(scope, `logic operator ${op} not implemented yet`, true);
 
   // generic structure for {a} OP {b}
   // -->
@@ -352,8 +384,8 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
 
   // if we can, use int tmp and convert at the end to help prevent unneeded conversions
   // (like if we are in an if condition - very common)
-  const leftIsInt = isIntOp(left[left.length - 1]);
-  const rightIsInt = isIntOp(right[right.length - 1]);
+  const leftIsInt = isFloatToIntOp(left[left.length - 1]);
+  const rightIsInt = isFloatToIntOp(right[right.length - 1]);
 
   const canInt = leftIsInt && rightIsInt;
 
@@ -370,12 +402,12 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
       ...right,
       // note type
       ...rightType,
-      setLastType(scope),
+      ...setLastType(scope),
       [ Opcodes.else ],
       [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
       // note type
       ...leftType,
-      setLastType(scope),
+      ...setLastType(scope),
       [ Opcodes.end ],
       Opcodes.i32_from
     ];
@@ -389,17 +421,17 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
     ...right,
     // note type
     ...rightType,
-    setLastType(scope),
+    ...setLastType(scope),
     [ Opcodes.else ],
     [ Opcodes.local_get, localTmp(scope, 'logictmp') ],
     // note type
     ...leftType,
-    setLastType(scope),
+    ...setLastType(scope),
     [ Opcodes.end ]
   ];
 };
 
-const concatStrings = (scope, left, right, global, name, assign) => {
+const concatStrings = (scope, left, right, global, name, assign = false, bytestrings = false) => {
   // todo: this should be rewritten into a built-in/func: String.prototype.concat
   // todo: convert left and right to strings if not
   // todo: optimize by looking up names in arrays and using that if exists?
@@ -409,11 +441,8 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
-  const aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
-  if (aotWFA) addVarMeta(name, { wellFormed: undefined });
-
-  if (assign) {
-    const pointer = arrays.get(name ?? '$undeclared');
+  if (assign && Prefs.aotPointerOpt) {
+    const pointer = scope.arrays?.get(name ?? '$undeclared');
 
     return [
       // setup right
@@ -438,11 +467,11 @@ const concatStrings = (scope, left, right, global, name, assign) => {
       [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ],
 
       // copy right
-      // dst = out pointer + length size + current length * i16 size
+      // dst = out pointer + length size + current length * sizeof valtype
       ...number(pointer + ValtypeSize.i32, Valtype.i32),
 
       [ Opcodes.local_get, leftLength ],
-      ...number(ValtypeSize.i16, Valtype.i32),
+      ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
       [ Opcodes.i32_add ],
 
@@ -451,9 +480,9 @@ const concatStrings = (scope, left, right, global, name, assign) => {
       ...number(ValtypeSize.i32, Valtype.i32),
       [ Opcodes.i32_add ],
 
-      // size = right length * i16 size
+      // size = right length * sizeof valtype
       [ Opcodes.local_get, rightLength ],
-      ...number(ValtypeSize.i16, Valtype.i32),
+      ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
 
       [ ...Opcodes.memory_copy, 0x00, 0x00 ],
@@ -511,11 +540,11 @@ const concatStrings = (scope, left, right, global, name, assign) => {
     [ ...Opcodes.memory_copy, 0x00, 0x00 ],
 
     // copy right
-    // dst = out pointer + length size + left length * i16 size
+    // dst = out pointer + length size + left length * sizeof valtype
     ...number(pointer + ValtypeSize.i32, Valtype.i32),
 
     [ Opcodes.local_get, leftLength ],
-    ...number(ValtypeSize.i16, Valtype.i32),
+    ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
     [ Opcodes.i32_mul ],
     [ Opcodes.i32_add ],
 
@@ -524,9 +553,9 @@ const concatStrings = (scope, left, right, global, name, assign) => {
     ...number(ValtypeSize.i32, Valtype.i32),
     [ Opcodes.i32_add ],
 
-    // size = right length * i16 size
+    // size = right length * sizeof valtype
     [ Opcodes.local_get, rightLength ],
-    ...number(ValtypeSize.i16, Valtype.i32),
+    ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
     [ Opcodes.i32_mul ],
 
     [ ...Opcodes.memory_copy, 0x00, 0x00 ],
@@ -536,7 +565,7 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   ];
 };
 
-const compareStrings = (scope, left, right) => {
+const compareStrings = (scope, left, right, bytestrings = false) => {
   // todo: this should be rewritten into a func
   // todo: convert left and right to strings if not
   // todo: optimize by looking up names in arrays and using that if exists?
@@ -545,7 +574,6 @@ const compareStrings = (scope, left, right) => {
   const leftPointer = localTmp(scope, 'compare_left_pointer', Valtype.i32);
   const leftLength = localTmp(scope, 'compare_left_length', Valtype.i32);
   const rightPointer = localTmp(scope, 'compare_right_pointer', Valtype.i32);
-  const rightLength = localTmp(scope, 'compare_right_length', Valtype.i32);
 
   const index = localTmp(scope, 'compare_index', Valtype.i32);
   const indexEnd = localTmp(scope, 'compare_index_end', Valtype.i32);
@@ -573,7 +601,6 @@ const compareStrings = (scope, left, right) => {
 
     [ Opcodes.local_get, rightPointer ],
     [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
-    [ Opcodes.local_tee, rightLength ],
 
     // fast path: check leftLength != rightLength
     [ Opcodes.i32_ne ],
@@ -588,11 +615,13 @@ const compareStrings = (scope, left, right) => {
     ...number(0, Valtype.i32),
     [ Opcodes.local_set, index ],
 
-    // setup index end as length * sizeof i16 (2)
+    // setup index end as length * sizeof valtype (1 for bytestring, 2 for string)
     // we do this instead of having to do mul/div each iter for perf™
     [ Opcodes.local_get, leftLength ],
-    ...number(ValtypeSize.i16, Valtype.i32),
-    [ Opcodes.i32_mul ],
+    ...(bytestrings ? [] : [
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
+    ]),
     [ Opcodes.local_set, indexEnd ],
 
     // iterate over each char and check if eq
@@ -602,13 +631,17 @@ const compareStrings = (scope, left, right) => {
     [ Opcodes.local_get, index ],
     [ Opcodes.local_get, leftPointer ],
     [ Opcodes.i32_add ],
-    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+    bytestrings ?
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ] :
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
     // fetch right
     [ Opcodes.local_get, index ],
     [ Opcodes.local_get, rightPointer ],
     [ Opcodes.i32_add ],
-    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+    bytestrings ?
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ] :
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
     // not equal, "return" false
     [ Opcodes.i32_ne ],
@@ -617,13 +650,13 @@ const compareStrings = (scope, left, right) => {
     [ Opcodes.br, 2 ],
     [ Opcodes.end ],
 
-    // index += sizeof i16 (2)
+    // index += sizeof valtype (1 for bytestring, 2 for string)
     [ Opcodes.local_get, index ],
-    ...number(ValtypeSize.i16, Valtype.i32),
+    ...number(bytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
     [ Opcodes.i32_add ],
     [ Opcodes.local_tee, index ],
 
-    // if index != index end (length * sizeof 16), loop
+    // if index != index end (length * sizeof valtype), loop
     [ Opcodes.local_get, indexEnd ],
     [ Opcodes.i32_ne ],
     [ Opcodes.br_if, 0 ],
@@ -644,16 +677,18 @@ const compareStrings = (scope, left, right) => {
 };
 
 const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
-  if (isIntOp(wasm[wasm.length - 1])) return [
+  if (isFloatToIntOp(wasm[wasm.length - 1])) return [
     ...wasm,
     ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
   ];
+  // if (isIntOp(wasm[wasm.length - 1])) return [ ...wasm ];
 
-  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  const useTmp = knownType(scope, type) == null;
+  const tmp = useTmp && localTmp(scope, `#logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
 
   const def = [
     // if value != 0
-    [ Opcodes.local_get, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
     // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
     ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
@@ -665,16 +700,16 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
 
   return [
     ...wasm,
-    [ Opcodes.local_set, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
       // [TYPES.number]: def,
-      [TYPES._array]: [
+      [TYPES.array]: [
         // arrays are always truthy
         ...number(1, intOut ? Valtype.i32 : valtypeBinary)
       ],
       [TYPES.string]: [
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
         // get length
@@ -685,8 +720,8 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ], */
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
-      [TYPES._bytestring]: [ // duplicate of string
-        [ Opcodes.local_get, tmp ],
+      [TYPES.bytestring]: [ // duplicate of string
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
         // get length
@@ -700,18 +735,20 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
 };
 
 const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
-  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  const useTmp = knownType(scope, type) == null;
+  const tmp = useTmp && localTmp(scope, `#logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+
   return [
     ...wasm,
-    [ Opcodes.local_set, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
-      [TYPES._array]: [
+      [TYPES.array]: [
         // arrays are always truthy
         ...number(0, intOut ? Valtype.i32 : valtypeBinary)
       ],
       [TYPES.string]: [
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
         // get length
@@ -721,8 +758,8 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ],
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
-      [TYPES._bytestring]: [ // duplicate of string
-        [ Opcodes.local_get, tmp ],
+      [TYPES.bytestring]: [ // duplicate of string
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
         // get length
@@ -734,7 +771,7 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
       ],
       default: [
         // if value == 0
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
         ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
@@ -744,10 +781,12 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
 };
 
 const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
-  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  const useTmp = knownType(scope, type) == null;
+  const tmp = useTmp && localTmp(scope, `#logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+
   return [
     ...wasm,
-    [ Opcodes.local_set, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
       [TYPES.undefined]: [
@@ -756,7 +795,7 @@ const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
       ],
       [TYPES.object]: [
         // object, null if == 0
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
         ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
@@ -785,39 +824,17 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     return performLogicOp(scope, op, left, right, leftType, rightType);
   }
 
+  const knownLeft = knownType(scope, leftType);
+  const knownRight = knownType(scope, rightType);
+
   const eqOp = ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op);
   const strictOp = op === '===' || op === '!==';
 
   const startOut = [], endOut = [];
-  const finalise = out => startOut.concat(out, endOut);
+  const finalize = out => startOut.concat(out, endOut);
 
   // if strict (in)equal check types match
   if (strictOp) {
-    // startOut.push(
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_eq ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.i32_and ]
-    // );
-
-    // startOut.push(
-    //   [ Opcodes.block, Valtype.i32 ],
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_ne ],
-    //   [ Opcodes.if, Blocktype.void ],
-    //   ...number(op === '===' ? 0 : 1, Valtype.i32),
-    //   [ Opcodes.br, 1 ],
-    //   [ Opcodes.end ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.end ]
-    // );
-
     endOut.push(
       ...leftType,
       ...rightType,
@@ -834,31 +851,59 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   // todo: if equality op and an operand is undefined, return false
   // todo: niche null hell with 0
 
-  // if (leftType === TYPES.string || rightType === TYPES.string) {
-  //   if (op === '+') {
-  //     // string concat (a + b)
-  //     return finalise(concatStrings(scope, left, right, _global, _name, assign));
-  //   }
-
-  //   // not an equality op, NaN
-  //   if (!eqOp) return finalise(number(NaN));
-
-  //   // else leave bool ops
-  //   // todo: convert string to number if string and number/bool
-  //   // todo: string (>|>=|<|<=) string
-
-  //   // string comparison
-  //   if (op === '===' || op === '==') {
-  //     return finalise(compareStrings(scope, left, right));
-  //   }
-
-  //   if (op === '!==' || op === '!=') {
-  //     return finalise([
-  //       ...compareStrings(scope, left, right),
-  //       [ Opcodes.i32_eqz ]
-  //     ]);
-  //   }
-  // }
+  if (knownLeft === TYPES.string || knownRight === TYPES.string) {
+    if (op === '+') {
+      // todo: this should be dynamic too but for now only static
+      // string concat (a + b)
+      return concatStrings(scope, left, right, _global, _name, assign, false);
+    }
+
+    // not an equality op, NaN
+    if (!eqOp) return number(NaN);
+
+    // else leave bool ops
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string comparison
+    if (op === '===' || op === '==') {
+      return compareStrings(scope, left, right);
+    }
+
+    if (op === '!==' || op === '!=') {
+      return [
+        ...compareStrings(scope, left, right),
+        [ Opcodes.i32_eqz ]
+      ];
+    }
+  }
+
+  if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) {
+    if (op === '+') {
+      // todo: this should be dynamic too but for now only static
+      // string concat (a + b)
+      return concatStrings(scope, left, right, _global, _name, assign, true);
+    }
+
+    // not an equality op, NaN
+    if (!eqOp) return number(NaN);
+
+    // else leave bool ops
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string comparison
+    if (op === '===' || op === '==') {
+      return compareStrings(scope, left, right, true);
+    }
+
+    if (op === '!==' || op === '!=') {
+      return [
+        ...compareStrings(scope, left, right, true),
+        [ Opcodes.i32_eqz ]
+      ];
+    }
+  }
 
   let ops = operatorOpcode[valtype][op];
 
@@ -868,33 +913,69 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     includeBuiltin(scope, builtinName);
     const idx = funcIndex[builtinName];
 
-    return finalise([
+    return finalize([
       ...left,
       ...right,
       [ Opcodes.call, idx ]
     ]);
   }
 
-  if (!ops) return todo(`operator ${op} not implemented yet`); // throw new Error(`unknown operator ${op}`);
+  if (!ops) return todo(scope, `operator ${op} not implemented yet`, true);
 
   if (!Array.isArray(ops)) ops = [ ops ];
   ops = [ ops ];
 
   let tmpLeft, tmpRight;
   // if equal op, check if strings for compareStrings
-  if (op === '===' || op === '==' || op === '!==' || op === '!=') (() => {
-    const knownLeft = knownType(scope, leftType);
-    const knownRight = knownType(scope, rightType);
-
-    // todo: intelligent partial skip later
-    // if neither known are string, stop this madness
-    if ((knownLeft != null && knownLeft !== TYPES.string) && (knownRight != null && knownRight !== TYPES.string)) {
-      return;
-    }
+  // todo: intelligent partial skip later
+  // if neither known are string, stop this madness
+  // we already do known checks earlier, so don't need to recheck
 
+  if ((op === '===' || op === '==' || op === '!==' || op === '!=') && (knownLeft == null && knownRight == null)) {
     tmpLeft = localTmp(scope, '__tmpop_left');
     tmpRight = localTmp(scope, '__tmpop_right');
 
+    // returns false for one string, one not - but more ops/slower
+    // ops.unshift(...stringOnly([
+    //   // if left is string
+    //   ...leftType,
+    //   ...number(TYPES.string, Valtype.i32),
+    //   [ Opcodes.i32_eq ],
+
+    //   // if right is string
+    //   ...rightType,
+    //   ...number(TYPES.string, Valtype.i32),
+    //   [ Opcodes.i32_eq ],
+
+    //   // if either are true
+    //   [ Opcodes.i32_or ],
+    //   [ Opcodes.if, Blocktype.void ],
+
+    //   // todo: convert non-strings to strings, for now fail immediately if one is not
+    //   // if left is not string
+    //   ...leftType,
+    //   ...number(TYPES.string, Valtype.i32),
+    //   [ Opcodes.i32_ne ],
+
+    //   // if right is not string
+    //   ...rightType,
+    //   ...number(TYPES.string, Valtype.i32),
+    //   [ Opcodes.i32_ne ],
+
+    //   // if either are true
+    //   [ Opcodes.i32_or ],
+    //   [ Opcodes.if, Blocktype.void ],
+    //   ...number(0, Valtype.i32),
+    //   [ Opcodes.br, 2 ],
+    //   [ Opcodes.end ],
+
+    //   ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+    //   ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
+    //   [ Opcodes.br, 1 ],
+    //   [ Opcodes.end ],
+    // ]));
+
+    // does not handle one string, one not (such cases go past)
     ops.unshift(...stringOnly([
       // if left is string
       ...leftType,
@@ -906,30 +987,28 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       ...number(TYPES.string, Valtype.i32),
       [ Opcodes.i32_eq ],
 
-      // if either are true
-      [ Opcodes.i32_or ],
+      // if both are true
+      [ Opcodes.i32_and ],
       [ Opcodes.if, Blocktype.void ],
+      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+      ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
 
-      // todo: convert non-strings to strings, for now fail immediately if one is not
-      // if left is not string
+      // if left is bytestring
       ...leftType,
-      ...number(TYPES.string, Valtype.i32),
-      [ Opcodes.i32_ne ],
+      ...number(TYPES.bytestring, Valtype.i32),
+      [ Opcodes.i32_eq ],
 
-      // if right is not string
+      // if right is bytestring
       ...rightType,
-      ...number(TYPES.string, Valtype.i32),
-      [ Opcodes.i32_ne ],
+      ...number(TYPES.bytestring, Valtype.i32),
+      [ Opcodes.i32_eq ],
 
-      // if either are true
-      [ Opcodes.i32_or ],
+      // if both are true
+      [ Opcodes.i32_and ],
       [ Opcodes.if, Blocktype.void ],
-      ...number(0, Valtype.i32),
-      [ Opcodes.br, 2 ],
-      [ Opcodes.end ],
-
-      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
-      // ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], true),
       ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
       [ Opcodes.br, 1 ],
       [ Opcodes.end ],
@@ -941,9 +1020,9 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       // endOut.push(stringOnly([ Opcodes.end ]));
       endOut.unshift(stringOnly([ Opcodes.end ]));
     // }
-  })();
+  }
 
-  return finalise([
+  return finalize([
     ...left,
     ...(tmpLeft != null ? stringOnly([ [ Opcodes.local_tee, tmpLeft ] ]) : []),
     ...right,
@@ -960,7 +1039,22 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
   return out;
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [] }) => {
+const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals = [], returns = [], localInd = 0 }) => {
+  return func({ name, params, locals, returns, localInd }, {
+    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
+    builtin: name => {
+      let idx = funcIndex[name] ?? importedFuncs[name];
+      if (idx === undefined && builtinFuncs[name]) {
+        includeBuiltin(null, name);
+        idx = funcIndex[name];
+      }
+
+      return idx;
+    }
+  });
+};
+
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [] }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -972,18 +1066,14 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     locals[nameParam(i)] = { idx: i, type: allLocals[i] };
   }
 
-  if (typeof wasm === 'function') {
-    const scope = {
-      name,
-      params,
-      locals,
-      returns,
-      localInd: allLocals.length,
-    };
-
-    wasm = wasm(scope, { TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString });
+  for (const x of _data) {
+    const copy = { ...x };
+    copy.offset += pages.size * pageSize;
+    data.push(copy);
   }
 
+  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name, params, locals, returns, localInd: allLocals.length });
+
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
     if (baseGlobalIdx === undefined) baseGlobalIdx = globalInd;
@@ -1006,7 +1096,7 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     params,
     locals,
     returns,
-    returnType: TYPES[returnType ?? 'number'],
+    returnType: returnType ?? TYPES.number,
     wasm,
     internal: true,
     index: currentFuncIndex++
@@ -1029,6 +1119,7 @@ const generateLogicExp = (scope, decl) => {
   return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 };
 
+// potential future ideas for nan boxing (unused):
 // T = JS type, V = value/pointer
 // 0bTTT
 // qNAN: 0 11111111111 1000000000000000000000000000000000000000000000000001
@@ -1042,7 +1133,6 @@ const generateLogicExp = (scope, decl) => {
 // js type: 4 bits
 // internal type: ? bits
 // pointer: 32 bits
-
 // generic
 // 1              23   4             5
 // 0 11111111111 11TTTTIIII??????????PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
@@ -1052,49 +1142,29 @@ const generateLogicExp = (scope, decl) => {
 // 4: internal type
 // 5: pointer
 
-const TYPES = {
-  number: 0x00,
-  boolean: 0x01,
-  string: 0x02,
-  undefined: 0x03,
-  object: 0x04,
-  function: 0x05,
-  symbol: 0x06,
-  bigint: 0x07,
-
-  // these are not "typeof" types but tracked internally
-  _array: 0x10,
-  _regexp: 0x11,
-  _bytestring: 0x12
-};
-
-const TYPE_NAMES = {
-  [TYPES.number]: 'Number',
-  [TYPES.boolean]: 'Boolean',
-  [TYPES.string]: 'String',
-  [TYPES.undefined]: 'undefined',
-  [TYPES.object]: 'Object',
-  [TYPES.function]: 'Function',
-  [TYPES.symbol]: 'Symbol',
-  [TYPES.bigint]: 'BigInt',
-
-  [TYPES._array]: 'Array',
-  [TYPES._regexp]: 'RegExp',
-  [TYPES._bytestring]: 'ByteString'
+const isExistingProtoFunc = name => {
+  if (name.startsWith('__Array_prototype')) return !!prototypeFuncs[TYPES.array][name.slice(18)];
+  if (name.startsWith('__String_prototype_')) return !!prototypeFuncs[TYPES.string][name.slice(19)];
+
+  return false;
 };
 
 const getType = (scope, _name) => {
   const name = mapName(_name);
 
+  // if (scope.locals[name] && !scope.locals[name + '#type']) console.log(name);
+
+  if (typedInput && scope.locals[name]?.metadata?.type != null) return number(scope.locals[name].metadata.type, Valtype.i32);
   if (scope.locals[name]) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
+
+  if (typedInput && globals[name]?.metadata?.type != null) return number(globals[name].metadata.type, Valtype.i32);
   if (globals[name]) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
 
   let type = TYPES.undefined;
-  if (builtinVars[name]) type = TYPES[builtinVars[name].type ?? 'number'];
+  if (builtinVars[name]) type = builtinVars[name].type ?? TYPES.number;
   if (builtinFuncs[name] !== undefined || importedFuncs[name] !== undefined || funcIndex[name] !== undefined || internalConstrs[name] !== undefined) type = TYPES.function;
 
-  if (name.startsWith('__Array_prototype_') && prototypeFuncs[TYPES._array][name.slice(18)] ||
-    name.startsWith('__String_prototype_') && prototypeFuncs[TYPES.string][name.slice(19)]) type = TYPES.function;
+  if (isExistingProtoFunc(name)) type = TYPES.function;
 
   return number(type, Valtype.i32);
 };
@@ -1117,23 +1187,24 @@ const setType = (scope, _name, type) => {
   ];
 
   // throw new Error('could not find var');
+  return [];
 };
 
 const getLastType = scope => {
   scope.gotLastType = true;
-  return [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ];
+  return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
 };
 
 const setLastType = scope => {
-  return [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ];
+  return [ [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ] ];
 };
 
 const getNodeType = (scope, node) => {
-  const inner = () => {
+  const ret = (() => {
     if (node.type === 'Literal') {
-      if (node.regex) return TYPES._regexp;
+      if (node.regex) return TYPES.regexp;
 
-      if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES._bytestring;
+      if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES.bytestring;
 
       return TYPES[typeof node.value];
     }
@@ -1150,21 +1221,32 @@ const getNodeType = (scope, node) => {
       const name = node.callee.name;
       if (!name) {
         // iife
-        if (scope.locals['#last_type']) return [ getLastType(scope) ];
+        if (scope.locals['#last_type']) return getLastType(scope);
 
         // presume
         // todo: warn here?
         return TYPES.number;
       }
 
+      if (node.type === 'NewExpression' && builtinFuncs[name + '$constructor']) {
+        if (builtinFuncs[name + '$constructor'].typedReturns) {
+          if (scope.locals['#last_type']) return getLastType(scope);
+
+          // presume
+          // todo: warn here?
+          return TYPES.number;
+        }
+
+        return builtinFuncs[name + '$constructor'].returnType ?? TYPES.number;
+      }
+
       const func = funcs.find(x => x.name === name);
 
       if (func) {
-        // console.log(scope, func, func.returnType);
         if (func.returnType) return func.returnType;
       }
 
-      if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
+      if (builtinFuncs[name] && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
       if (internalConstrs[name]) return internalConstrs[name].type;
 
       // check if this is a prototype function
@@ -1175,11 +1257,16 @@ const getNodeType = (scope, node) => {
         const spl = name.slice(2).split('_');
 
         const func = spl[spl.length - 1];
-        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES._bytestring && prototypeFuncs[x][func] != null);
+        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
         if (protoFuncs.length === 1) return protoFuncs[0].returnType ?? TYPES.number;
       }
 
-      if (scope.locals['#last_type']) return [ getLastType(scope) ];
+      if (name.startsWith('__Porffor_wasm_')) {
+        // todo: return undefined for non-returning ops
+        return TYPES.number;
+      }
+
+      if (scope.locals['#last_type']) return getLastType(scope);
 
       // presume
       // todo: warn here?
@@ -1222,11 +1309,20 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'ArrayExpression') {
-      return TYPES._array;
+      return TYPES.array;
     }
 
     if (node.type === 'BinaryExpression') {
       if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      if (node.operator !== '+') return TYPES.number;
+
+      const knownLeft = knownType(scope, getNodeType(scope, node.left));
+      const knownRight = knownType(scope, getNodeType(scope, node.right));
+
+      // todo: this should be dynamic but for now only static
+      if (knownLeft === TYPES.string || knownRight === TYPES.string) return TYPES.string;
+      if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) return TYPES.bytestring;
+
       return TYPES.number;
 
       // todo: string concat types
@@ -1251,34 +1347,47 @@ const getNodeType = (scope, node) => {
       if (node.operator === '!') return TYPES.boolean;
       if (node.operator === 'void') return TYPES.undefined;
       if (node.operator === 'delete') return TYPES.boolean;
-      if (node.operator === 'typeof') return process.argv.includes('-bytestring') ? TYPES._bytestring : TYPES.string;
+      if (node.operator === 'typeof') return Prefs.bytestring ? TYPES.bytestring : TYPES.string;
 
       return TYPES.number;
     }
 
     if (node.type === 'MemberExpression') {
+      // hack: if something.name, string type
+      if (node.property.name === 'name') {
+        if (hasFuncWithName(node.object.name)) {
+          return TYPES.bytestring;
+        } else {
+          return TYPES.undefined;
+        }
+      }
+
       // hack: if something.length, number type
       if (node.property.name === 'length') return TYPES.number;
 
       // ts hack
       if (scope.locals[node.object.name]?.metadata?.type === TYPES.string) return TYPES.string;
-      if (scope.locals[node.object.name]?.metadata?.type === TYPES._array) return TYPES.number;
+      if (scope.locals[node.object.name]?.metadata?.type === TYPES.bytestring) return TYPES.bytestring;
+      if (scope.locals[node.object.name]?.metadata?.type === TYPES.array) return TYPES.number;
 
-      if (scope.locals['#last_type']) return [ getLastType(scope) ];
+      if (scope.locals['#last_type']) return getLastType(scope);
 
       // presume
       return TYPES.number;
     }
 
-    if (scope.locals['#last_type']) return [ getLastType(scope) ];
+    if (node.type === 'TaggedTemplateExpression') {
+      // hack
+      if (node.tag.name.startsWith('__Porffor_')) return TYPES.number;
+    }
+
+    if (scope.locals['#last_type']) return getLastType(scope);
 
     // presume
     // todo: warn here?
     return TYPES.number;
-  };
+  })();
 
-  const ret = inner();
-  // console.trace(node, ret);
   if (typeof ret === 'number') return number(ret, Valtype.i32);
   return ret;
 };
@@ -1303,7 +1412,7 @@ const generateLiteral = (scope, decl, global, name) => {
       return makeString(scope, decl.value, global, name);
 
     default:
-      return todo(`cannot generate literal of type ${typeof decl.value}`);
+      return todo(scope, `cannot generate literal of type ${typeof decl.value}`, true);
   }
 };
 
@@ -1312,6 +1421,8 @@ const countLeftover = wasm => {
 
   for (let i = 0; i < wasm.length; i++) {
     const inst = wasm[i];
+    if (inst[0] == null) continue;
+
     if (depth === 0 && (inst[0] === Opcodes.if || inst[0] === Opcodes.block || inst[0] === Opcodes.loop)) {
       if (inst[0] === Opcodes.if) count--;
       if (inst[1] !== Blocktype.void) count++;
@@ -1320,18 +1431,25 @@ const countLeftover = wasm => {
     if (inst[0] === Opcodes.end) depth--;
 
     if (depth === 0)
-      if ([Opcodes.throw,Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
+      if ([Opcodes.throw, Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
         else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.i32_load8_u, Opcodes.i32_load8_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x0a)) {}
-        else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const].includes(inst[0])) count++;
+        else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const, Opcodes.memory_size].includes(inst[0])) count++;
         else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16, Opcodes.i32_store8].includes(inst[0])) count -= 2;
         else if (Opcodes.memory_copy[0] === inst[0] && Opcodes.memory_copy[1] === inst[1]) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
           let func = funcs.find(x => x.index === inst[1]);
-          if (func) {
-            count -= func.params.length;
-          } else count--;
-          if (func) count += func.returns.length;
+          if (inst[1] === -1) {
+            // todo: count for calling self
+          } else if (!func && inst[1] < importedFuncs.length) {
+            count -= importedFuncs[inst[1]].params;
+            count += importedFuncs[inst[1]].returns;
+          } else {
+            if (func) {
+              count -= func.params.length;
+            } else count--;
+            if (func) count += func.returns.length;
+          }
         } else count--;
 
     // console.log(count, decompile([ inst ]).slice(0, -1));
@@ -1408,25 +1526,27 @@ const RTArrayUtil = {
 };
 
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
-  /* const callee = decl.callee;
-  const args = decl.arguments;
-
-  return [
-    ...generate(args),
-    ...generate(callee),
-    Opcodes.call_indirect,
-  ]; */
-
   let name = mapName(decl.callee.name);
   if (isFuncType(decl.callee.type)) { // iife
     const func = generateFunc(scope, decl.callee);
     name = func.name;
   }
 
-  if (name === 'eval' && decl.arguments[0].type === 'Literal') {
+  if (name === 'eval' && decl.arguments[0]?.type === 'Literal') {
     // literal eval hack
-    const code = decl.arguments[0].value;
-    const parsed = parse(code, []);
+    const code = decl.arguments[0]?.value ?? '';
+
+    let parsed;
+    try {
+      parsed = parse(code, []);
+    } catch (e) {
+      if (e.name === 'SyntaxError') {
+        // throw syntax errors of evals at runtime instead
+        return internalThrow(scope, 'SyntaxError', e.message, true);
+      }
+
+      throw e;
+    }
 
     const out = generate(scope, {
       type: 'BlockStatement',
@@ -1440,13 +1560,13 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       const finalStatement = parsed.body[parsed.body.length - 1];
       out.push(
         ...getNodeType(scope, finalStatement),
-        setLastType(scope)
+        ...setLastType(scope)
       );
     } else if (countLeftover(out) === 0) {
       out.push(...number(UNDEFINED));
       out.push(
         ...number(TYPES.undefined, Valtype.i32),
-        setLastType(scope)
+        ...setLastType(scope)
       );
     }
 
@@ -1468,6 +1588,9 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
     target = { ...decl.callee };
     target.name = spl.slice(0, -1).join('_');
+
+    // failed to lookup name, abort
+    if (!lookupName(scope, target.name)[0]) protoName = null;
   }
 
   // literal.func()
@@ -1475,22 +1598,29 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     // megahack for /regex/.func()
     const funcName = decl.callee.property.name;
     if (decl.callee.object.regex && Object.hasOwn(Rhemyn, funcName)) {
-      const func = Rhemyn[funcName](decl.callee.object.regex.pattern, currentFuncIndex++);
+      const regex = decl.callee.object.regex.pattern;
+      const rhemynName = `regex_${funcName}_${regex}`;
 
-      funcIndex[func.name] = func.index;
-      funcs.push(func);
+      if (!funcIndex[rhemynName]) {
+        const func = Rhemyn[funcName](regex, currentFuncIndex++, rhemynName);
 
+        funcIndex[func.name] = func.index;
+        funcs.push(func);
+      }
+
+      const idx = funcIndex[rhemynName];
       return [
         // make string arg
         ...generate(scope, decl.arguments[0]),
+        Opcodes.i32_to_u,
+        ...getNodeType(scope, decl.arguments[0]),
 
         // call regex func
-        Opcodes.i32_to_u,
-        [ Opcodes.call, func.index ],
+        [ Opcodes.call, idx ],
         Opcodes.i32_from_u,
 
         ...number(TYPES.boolean, Valtype.i32),
-        setLastType(scope)
+        ...setLastType(scope)
       ];
     }
 
@@ -1515,12 +1645,31 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   // }
 
   if (protoName) {
+    const protoBC = {};
+
+    const builtinProtoCands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + protoName));
+
+    if (!decl._protoInternalCall && builtinProtoCands.length > 0) {
+      for (const x of builtinProtoCands) {
+        const type = TYPES[x.split('_prototype_')[0].slice(2).toLowerCase()];
+        if (type == null) continue;
+
+        protoBC[type] = generateCall(scope, {
+          callee: {
+            type: 'Identifier',
+            name: x
+          },
+          arguments: [ target, ...decl.arguments ],
+          _protoInternalCall: true
+        });
+      }
+    }
+
     const protoCands = Object.keys(prototypeFuncs).reduce((acc, x) => {
       if (Object.hasOwn(prototypeFuncs[x], protoName)) acc[x] = prototypeFuncs[x][protoName];
       return acc;
     }, {});
 
-    // no prototype function candidates, ignore
     if (Object.keys(protoCands).length > 0) {
       // use local for cached i32 length as commonly used
       const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
@@ -1538,7 +1687,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       let allOptUnused = true;
       let lengthI32CacheUsed = false;
-      const protoBC = {};
       for (const x in protoCands) {
         const protoFunc = protoCands[x];
         if (protoFunc.noArgRetLength && decl.arguments.length === 0) {
@@ -1546,13 +1694,11 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             ...RTArrayUtil.getLength(getPointer),
 
             ...number(TYPES.number, Valtype.i32),
-            setLastType(scope)
+            ...setLastType(scope)
           ];
           continue;
         }
 
-        // const protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp`, protoFunc.local) : -1;
-        // const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp2`, protoFunc.local2) : -1;
         const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
         const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
@@ -1583,7 +1729,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           ...protoOut,
 
           ...number(protoFunc.returnType ?? TYPES.number, Valtype.i32),
-          setLastType(scope),
+          ...setLastType(scope),
           [ Opcodes.end ]
         ];
       }
@@ -1609,10 +1755,19 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         }, allOptUnused && unusedValue ? Blocktype.void : valtypeBinary),
       ];
     }
+
+    if (Object.keys(protoBC).length > 0) {
+      return typeSwitch(scope, getNodeType(scope, target), {
+        ...protoBC,
+
+        // TODO: error better
+        default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
+      }, valtypeBinary);
+    }
   }
 
   // TODO: only allows callee as literal
-  if (!name) return todo(`only literal callees (got ${decl.callee.type})`);
+  if (!name) return todo(scope, `only literal callees (got ${decl.callee.type})`);
 
   let idx = funcIndex[name] ?? importedFuncs[name];
   if (idx === undefined && builtinFuncs[name]) {
@@ -1620,22 +1775,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
     includeBuiltin(scope, name);
     idx = funcIndex[name];
-
-    // infer arguments types from builtins params
-    const func = funcs.find(x => x.name === name);
-    for (let i = 0; i < decl.arguments.length; i++) {
-      const arg = decl.arguments[i];
-      if (!arg.name) continue;
-
-      const local = scope.locals[arg.name];
-      if (!local) continue;
-
-      local.type = func.params[i];
-      if (local.type === Valtype.v128) {
-        // specify vec subtype inferred from last vec type in function name
-        local.vecType = name.split('_').reverse().find(x => x.includes('x'));
-      }
-    }
   }
 
   if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
@@ -1645,16 +1784,62 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     idx = -1;
   }
 
+  if (idx === undefined && name.startsWith('__Porffor_wasm_')) {
+    const wasmOps = {
+      // pointer, align, offset
+      i32_load: { imms: 2, args: [ true ], returns: 1 },
+      // pointer, value, align, offset
+      i32_store: { imms: 2, args: [ true, true ], returns: 0 },
+      // pointer, align, offset
+      i32_load8_u: { imms: 2, args: [ true ], returns: 1 },
+      // pointer, value, align, offset
+      i32_store8: { imms: 2, args: [ true, true ], returns: 0 },
+      // pointer, align, offset
+      i32_load16_u: { imms: 2, args: [ true ], returns: 1 },
+      // pointer, value, align, offset
+      i32_store16: { imms: 2, args: [ true, true ], returns: 0 },
+
+      // pointer, align, offset
+      f64_load: { imms: 2, args: [ true ], returns: 0 }, // 0 due to not i32
+      // pointer, value, align, offset
+      f64_store: { imms: 2, args: [ true, false ], returns: 0 },
+
+      // value
+      i32_const: { imms: 1, args: [], returns: 1 },
+    };
+
+    const opName = name.slice('__Porffor_wasm_'.length);
+
+    if (wasmOps[opName]) {
+      const op = wasmOps[opName];
+
+      const argOut = [];
+      for (let i = 0; i < op.args.length; i++) argOut.push(
+        ...generate(scope, decl.arguments[i]),
+        ...(op.args[i] ? [ Opcodes.i32_to ] : [])
+      );
+
+      // literals only
+      const imms = decl.arguments.slice(op.args.length).map(x => x.value);
+
+      return [
+        ...argOut,
+        [ Opcodes[opName], ...imms ],
+        ...(new Array(op.returns).fill(Opcodes.i32_from))
+      ];
+    }
+  }
+
   if (idx === undefined) {
-    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`);
-    return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
+    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+    return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
   const func = funcs.find(x => x.index === idx);
 
   const userFunc = (funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name]) || idx === -1;
   const typedParams = userFunc || builtinFuncs[name]?.typedParams;
-  const typedReturn = userFunc || builtinFuncs[name]?.typedReturn;
+  const typedReturns = (func ? func.returnType == null : userFunc) || builtinFuncs[name]?.typedReturns;
   const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
@@ -1671,14 +1856,24 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   if (func && func.throws) scope.throws = true;
 
   let out = [];
-  for (const arg of args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
     out = out.concat(generate(scope, arg));
+
+    if (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
+      out.push(Opcodes.i32_to);
+    }
+
+    if (importedFuncs[name] && name.startsWith('profile')) {
+      out.push(Opcodes.i32_to);
+    }
+
     if (typedParams) out = out.concat(getNodeType(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
 
-  if (!typedReturn) {
+  if (!typedReturns) {
     // let type;
     // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
     // if (internalConstrs[name]) type = internalConstrs[name].type;
@@ -1688,7 +1883,11 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     //   ...number(type, Valtype.i32),
     //   [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
     // );
-  } else out.push(setLastType(scope));
+  } else out.push(...setLastType(scope));
+
+  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
+    out.push(Opcodes.i32_from);
+  }
 
   return out;
 };
@@ -1696,8 +1895,21 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 const generateNew = (scope, decl, _global, _name) => {
   // hack: basically treat this as a normal call for builtins for now
   const name = mapName(decl.callee.name);
+
   if (internalConstrs[name] && !internalConstrs[name].notConstr) return internalConstrs[name].generate(scope, decl, _global, _name);
-  if (!builtinFuncs[name]) return todo(`new statement is not supported yet`); // return todo(`new statement is not supported yet (new ${unhackName(name)})`);
+
+  if (builtinFuncs[name + '$constructor']) {
+    // custom ...$constructor override builtin func
+    return generateCall(scope, {
+      ...decl,
+      callee: {
+        type: 'Identifier',
+        name: name + '$constructor'
+      }
+    }, _global, _name);
+  }
+
+  if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
 };
@@ -1814,14 +2026,14 @@ const brTable = (input, bc, returns) => {
 };
 
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
-  if (!process.argv.includes('-bytestring')) delete bc[TYPES._bytestring];
+  if (!Prefs.bytestring) delete bc[TYPES.bytestring];
 
   const known = knownType(scope, type);
   if (known != null) {
     return bc[known] ?? bc.default;
   }
 
-  if (process.argv.includes('-typeswitch-use-brtable'))
+  if (Prefs.typeswitchUseBrtable)
     return brTable(type, bc, returns);
 
   const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
@@ -1831,8 +2043,6 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
     [ Opcodes.block, returns ]
   ];
 
-  // todo: use br_table?
-
   for (const x in bc) {
     if (x === 'default') continue;
 
@@ -1856,7 +2066,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
   return out;
 };
 
-const allocVar = (scope, name, global = false) => {
+const allocVar = (scope, name, global = false, type = true) => {
   const target = global ? globals : scope.locals;
 
   // already declared
@@ -1870,8 +2080,10 @@ const allocVar = (scope, name, global = false) => {
   let idx = global ? globalInd++ : scope.localInd++;
   target[name] = { idx, type: valtypeBinary };
 
-  let typeIdx = global ? globalInd++ : scope.localInd++;
-  target[name + '#type'] = { idx: typeIdx, type: Valtype.i32 };
+  if (type) {
+    let typeIdx = global ? globalInd++ : scope.localInd++;
+    target[name + '#type'] = { idx: typeIdx, type: Valtype.i32 };
+  }
 
   return idx;
 };
@@ -1886,11 +2098,13 @@ const addVarMetadata = (scope, name, global = false, metadata = {}) => {
 };
 
 const typeAnnoToPorfType = x => {
-  if (TYPES[x]) return TYPES[x];
-  if (TYPES['_' + x]) return TYPES['_' + x];
+  if (!x) return null;
+  if (TYPES[x.toLowerCase()] != null) return TYPES[x.toLowerCase()];
 
   switch (x) {
     case 'i32':
+    case 'i64':
+    case 'f64':
       return TYPES.number;
   }
 
@@ -1901,7 +2115,7 @@ const extractTypeAnnotation = decl => {
   let a = decl;
   while (a.typeAnnotation) a = a.typeAnnotation;
 
-  let type, elementType;
+  let type = null, elementType = null;
   if (a.typeName) {
     type = a.typeName.name;
   } else if (a.type.endsWith('Keyword')) {
@@ -1914,7 +2128,7 @@ const extractTypeAnnotation = decl => {
   const typeName = type;
   type = typeAnnoToPorfType(type);
 
-  if (type === TYPES._bytestring && !process.argv.includes('-bytestring')) type = TYPES.string;
+  if (type === TYPES.bytestring && !Prefs.bytestring) type = TYPES.string;
 
   // if (decl.name) console.log(decl.name, { type, elementType });
 
@@ -1926,13 +2140,13 @@ const generateVar = (scope, decl) => {
 
   const topLevel = scope.name === 'main';
 
-  // global variable if in top scope (main) and var ..., or if wanted
-  const global = topLevel || decl._bare; // decl.kind === 'var';
+  // global variable if in top scope (main) or if internally wanted
+  const global = topLevel || decl._bare;
 
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
 
-    if (!name) return todo('destructuring is not supported yet');
+    if (!name) return todo(scope, 'destructuring is not supported yet');
 
     if (x.init && isFuncType(x.init.type)) {
       // hack for let a = function () { ... }
@@ -1941,7 +2155,6 @@ const generateVar = (scope, decl) => {
       continue;
     }
 
-    // console.log(name);
     if (topLevel && builtinVars[name]) {
       // cannot redeclare
       if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
@@ -1949,16 +2162,29 @@ const generateVar = (scope, decl) => {
       continue; // always ignore
     }
 
-    let idx = allocVar(scope, name, global);
+    // // generate init before allocating var
+    // let generated;
+    // if (x.init) generated = generate(scope, x.init, global, name);
 
-    if (typedInput && x.id.typeAnnotation) {
+    const typed = typedInput && x.id.typeAnnotation;
+    let idx = allocVar(scope, name, global, !(typed && extractTypeAnnotation(x.id).type != null));
+
+    if (typed) {
       addVarMetadata(scope, name, global, extractTypeAnnotation(x.id));
     }
 
     if (x.init) {
-      out = out.concat(generate(scope, x.init, global, name));
-
-      out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+      const generated = generate(scope, x.init, global, name);
+      if (scope.arrays?.get(name) != null) {
+        // hack to set local as pointer before
+        out.push(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+        if (generated.at(-1) == Opcodes.i32_from_u) generated.pop();
+        generated.pop();
+        out = out.concat(generated);
+      } else {
+        out = out.concat(generated);
+        out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+      }
       out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
 
@@ -1969,7 +2195,8 @@ const generateVar = (scope, decl) => {
   return out;
 };
 
-const generateAssign = (scope, decl) => {
+// todo: optimize this func for valueUnused
+const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
 
   if (type === 'ObjectPattern') {
@@ -1984,22 +2211,30 @@ const generateAssign = (scope, decl) => {
     return [];
   }
 
+  const op = decl.operator.slice(0, -1) || '=';
+
   // hack: .length setter
   if (decl.left.type === 'MemberExpression' && decl.left.property.name === 'length') {
     const name = decl.left.object.name;
-    const pointer = arrays.get(name);
+    const pointer = scope.arrays?.get(name);
 
-    const aotPointer = pointer != null;
+    const aotPointer = Prefs.aotPointerOpt && pointer != null;
 
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
+    const pointerTmp = op === '=' ? null : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
       ...(aotPointer ? number(0, Valtype.i32) : [
         ...generate(scope, decl.left.object),
         Opcodes.i32_to_u
       ]),
+      ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-      ...generate(scope, decl.right),
+      ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+        [ Opcodes.local_get, pointerTmp ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        Opcodes.i32_from_u
+      ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right))),
       [ Opcodes.local_tee, newValueTmp ],
 
       Opcodes.i32_to_u,
@@ -2009,21 +2244,19 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  const op = decl.operator.slice(0, -1) || '=';
-
   // arr[i]
   if (decl.left.type === 'MemberExpression' && decl.left.computed) {
     const name = decl.left.object.name;
-    const pointer = arrays.get(name);
+    const pointer = scope.arrays?.get(name);
 
-    const aotPointer = pointer != null;
+    const aotPointer = Prefs.aotPointerOpt && pointer != null;
 
     const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
     const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
       ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
-        [TYPES._array]: [
+        [TYPES.array]: [
           ...(aotPointer ? [] : [
             ...generate(scope, decl.left.object),
             Opcodes.i32_to_u
@@ -2072,7 +2305,7 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  if (!name) return todo('destructuring is not supported yet');
+  if (!name) return todo(scope, 'destructuring is not supported yet', true);
 
   const [ local, isGlobal ] = lookupName(scope, name);
 
@@ -2120,9 +2353,7 @@ const generateAssign = (scope, decl) => {
       ], getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
       [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
 
-      getLastType(scope),
-      // hack: type is idx+1
-      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
+      ...setType(scope, name, getLastType(scope))
     ];
   }
 
@@ -2133,9 +2364,7 @@ const generateAssign = (scope, decl) => {
 
     // todo: string concat types
 
-    // hack: type is idx+1
-    ...number(TYPES.number, Valtype.i32),
-    [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
+    ...setType(scope, name, TYPES.number)
   ];
 };
 
@@ -2181,7 +2410,7 @@ const generateUnary = (scope, decl) => {
       return out;
     }
 
-    case 'delete':
+    case 'delete': {
       let toReturn = true, toGenerate = true;
 
       if (decl.argument.type === 'Identifier') {
@@ -2203,40 +2432,60 @@ const generateUnary = (scope, decl) => {
 
       out.push(...number(toReturn ? 1 : 0));
       return out;
+    }
+
+    case 'typeof': {
+      let overrideType, toGenerate = true;
+
+      if (decl.argument.type === 'Identifier') {
+        const out = generateIdent(scope, decl.argument);
+
+        // if ReferenceError (undeclared var), ignore and return undefined
+        if (out[1]) {
+          // does not exist (2 ops from throw)
+          overrideType = number(TYPES.undefined, Valtype.i32);
+          toGenerate = false;
+        }
+      }
 
-    case 'typeof':
-      return typeSwitch(scope, getNodeType(scope, decl.argument), {
+      const out = toGenerate ? generate(scope, decl.argument) : [];
+      disposeLeftover(out);
+
+      out.push(...typeSwitch(scope, overrideType ?? getNodeType(scope, decl.argument), {
         [TYPES.number]: makeString(scope, 'number', false, '#typeof_result'),
         [TYPES.boolean]: makeString(scope, 'boolean', false, '#typeof_result'),
         [TYPES.string]: makeString(scope, 'string', false, '#typeof_result'),
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
 
-        [TYPES._bytestring]: makeString(scope, 'string', false, '#typeof_result'),
+        [TYPES.bytestring]: makeString(scope, 'string', false, '#typeof_result'),
 
         // object and internal types
         default: makeString(scope, 'object', false, '#typeof_result'),
-      });
+      }));
+
+      return out;
+    }
 
     default:
-      return todo(`unary operator ${decl.operator} not implemented yet`);
+      return todo(scope, `unary operator ${decl.operator} not implemented yet`, true);
   }
 };
 
-const generateUpdate = (scope, decl) => {
+const generateUpdate = (scope, decl, _global, _name, valueUnused = false) => {
   const { name } = decl.argument;
 
   const [ local, isGlobal ] = lookupName(scope, name);
 
   if (local === undefined) {
-    return todo(`update expression with undefined variable`);
+    return todo(scope, `update expression with undefined variable`, true);
   }
 
   const idx = local.idx;
   const out = [];
 
   out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
-  if (!decl.prefix) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
+  if (!decl.prefix && !valueUnused) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
 
   switch (decl.operator) {
     case '++':
@@ -2249,7 +2498,7 @@ const generateUpdate = (scope, decl) => {
   }
 
   out.push([ isGlobal ? Opcodes.global_set : Opcodes.local_set, idx ]);
-  if (decl.prefix) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
+  if (decl.prefix && !valueUnused) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
 
   return out;
 };
@@ -2289,7 +2538,7 @@ const generateConditional = (scope, decl) => {
   // note type
   out.push(
     ...getNodeType(scope, decl.consequent),
-    setLastType(scope)
+    ...setLastType(scope)
   );
 
   out.push([ Opcodes.else ]);
@@ -2298,7 +2547,7 @@ const generateConditional = (scope, decl) => {
   // note type
   out.push(
     ...getNodeType(scope, decl.alternate),
-    setLastType(scope)
+    ...setLastType(scope)
   );
 
   out.push([ Opcodes.end ]);
@@ -2312,7 +2561,7 @@ const generateFor = (scope, decl) => {
   const out = [];
 
   if (decl.init) {
-    out.push(...generate(scope, decl.init));
+    out.push(...generate(scope, decl.init, false, undefined, true));
     disposeLeftover(out);
   }
 
@@ -2330,7 +2579,7 @@ const generateFor = (scope, decl) => {
   out.push(...generate(scope, decl.body));
   out.push([ Opcodes.end ]);
 
-  if (decl.update) out.push(...generate(scope, decl.update));
+  if (decl.update) out.push(...generate(scope, decl.update, false, undefined, true));
 
   out.push([ Opcodes.br, 1 ]);
   out.push([ Opcodes.end ], [ Opcodes.end ]);
@@ -2358,6 +2607,36 @@ const generateWhile = (scope, decl) => {
   return out;
 };
 
+const generateDoWhile = (scope, decl) => {
+  const out = [];
+
+  out.push([ Opcodes.loop, Blocktype.void ]);
+  depth.push('dowhile');
+
+  // block for break (includes all)
+  out.push([ Opcodes.block, Blocktype.void ]);
+  depth.push('block');
+
+  // block for continue
+  // includes body but not test+loop so we can exit body at anytime
+  // and still test+loop after
+  out.push([ Opcodes.block, Blocktype.void ]);
+  depth.push('block');
+
+  out.push(...generate(scope, decl.body));
+
+  out.push([ Opcodes.end ]);
+  depth.pop();
+
+  out.push(...generate(scope, decl.test), Opcodes.i32_to);
+  out.push([ Opcodes.br_if, 1 ]);
+
+  out.push([ Opcodes.end ], [ Opcodes.end ]);
+  depth.pop(); depth.pop();
+
+  return out;
+};
+
 const generateForOf = (scope, decl) => {
   const out = [];
 
@@ -2394,7 +2673,10 @@ const generateForOf = (scope, decl) => {
     generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name: leftName } } ] })
   }
 
+  // if (!leftName) console.log(decl.left?.declarations?.[0]?.id ?? decl.left);
+
   const [ local, isGlobal ] = lookupName(scope, leftName);
+  if (!local) return todo(scope, 'for of failed to get left local (probably destructure)');
 
   depth.push('block');
   depth.push('block');
@@ -2403,6 +2685,7 @@ const generateForOf = (scope, decl) => {
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.f64), newPointer = -1;
   if (pages.hasAnyString) {
+    // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(1)
     }, isGlobal, leftName, true, 'i16');
@@ -2411,7 +2694,7 @@ const generateForOf = (scope, decl) => {
   // set type for local
   // todo: optimize away counter and use end pointer
   out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
-    [TYPES._array]: [
+    [TYPES.array]: [
       ...setType(scope, leftName, TYPES.number),
 
       [ Opcodes.loop, Blocktype.void ],
@@ -2494,6 +2777,56 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+    [TYPES.bytestring]: [
+      ...setType(scope, leftName, TYPES.bytestring),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
+
+      ...number(0, Valtype.i32), // base 0 for store after
+
+      // load current string ind {arg}
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.local_get, counter ],
+      [ Opcodes.i32_add ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store to new string ind 0
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+      // return new string (page)
+      ...number(newPointer),
+
+      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+
+      [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
+      ...generate(scope, decl.body),
+      [ Opcodes.end ],
+
+      // increment iter pointer
+      // [ Opcodes.local_get, pointer ],
+      // ...number(1, Valtype.i32),
+      // [ Opcodes.i32_add ],
+      // [ Opcodes.local_set, pointer ],
+
+      // increment counter by 1
+      [ Opcodes.local_get, counter ],
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, counter ],
+
+      // loop if counter != length
+      [ Opcodes.local_get, length ],
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 1 ],
+
+      [ Opcodes.end ],
+      [ Opcodes.end ]
+    ],
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
@@ -2504,28 +2837,65 @@ const generateForOf = (scope, decl) => {
   return out;
 };
 
+// find the nearest loop in depth map by type
 const getNearestLoop = () => {
   for (let i = depth.length - 1; i >= 0; i--) {
-    if (depth[i] === 'while' || depth[i] === 'for' || depth[i] === 'forof') return i;
+    if (['while', 'dowhile', 'for', 'forof'].includes(depth[i])) return i;
   }
 
   return -1;
 };
 
 const generateBreak = (scope, decl) => {
-  const nearestLoop = depth.length - getNearestLoop();
+  const target = decl.label ? scope.labels.get(decl.label.name) : getNearestLoop();
+  const type = depth[target];
+
+  // different loop types have different branch offsets
+  // as they have different wasm block/loop/if structures
+  // we need to use the right offset by type to branch to the one we want
+  // for a break: exit the loop without executing anything else inside it
+  const offset = ({
+    for: 2, // loop > if (wanted branch) > block (we are here)
+    while: 2, // loop > if (wanted branch) (we are here)
+    dowhile: 2, // loop > block (wanted branch) > block (we are here)
+    forof: 2, // loop > block (wanted branch) > block (we are here)
+    if: 1 // break inside if, branch 0 to skip the rest of the if
+  })[type];
+
   return [
-    [ Opcodes.br, ...signedLEB128(nearestLoop - 2) ]
+    [ Opcodes.br, ...signedLEB128(depth.length - target - offset) ]
   ];
 };
 
 const generateContinue = (scope, decl) => {
-  const nearestLoop = depth.length - getNearestLoop();
+  const target = decl.label ? scope.labels.get(decl.label.name) : getNearestLoop();
+  const type = depth[target];
+
+  // different loop types have different branch offsets
+  // as they have different wasm block/loop/if structures
+  // we need to use the right offset by type to branch to the one we want
+  // for a continue: do test for the loop, and then loop depending on that success
+  const offset = ({
+    for: 3, // loop (wanted branch) > if > block (we are here)
+    while: 1, // loop (wanted branch) > if (we are here)
+    dowhile: 3, // loop > block > block (wanted branch) (we are here)
+    forof: 3 // loop > block > block (wanted branch) (we are here)
+  })[type];
+
   return [
-    [ Opcodes.br, ...signedLEB128(nearestLoop - 3) ]
+    [ Opcodes.br, ...signedLEB128(depth.length - target - offset) ]
   ];
 };
 
+const generateLabel = (scope, decl) => {
+  scope.labels ??= new Map();
+
+  const name = decl.label.name;
+  scope.labels.set(name, depth.length);
+
+  return generate(scope, decl.body);
+};
+
 const generateThrow = (scope, decl) => {
   scope.throws = true;
 
@@ -2546,6 +2916,9 @@ const generateThrow = (scope, decl) => {
   let exceptId = exceptions.push({ constructor, message }) - 1;
   let tagIdx = tags[0].idx;
 
+  scope.exceptions ??= [];
+  scope.exceptions.push(exceptId);
+
   // todo: write a description of how this works lol
 
   return [
@@ -2555,7 +2928,7 @@ const generateThrow = (scope, decl) => {
 };
 
 const generateTry = (scope, decl) => {
-  if (decl.finalizer) return todo('try finally not implemented yet');
+  if (decl.finalizer) return todo(scope, 'try finally not implemented yet');
 
   const out = [];
 
@@ -2582,15 +2955,8 @@ const generateEmpty = (scope, decl) => {
   return [];
 };
 
-const generateAssignPat = (scope, decl) => {
-  // TODO
-  // if identifier declared, use that
-  // else, use default (right)
-  return todo('assignment pattern (optional arg)');
-};
-
 let pages = new Map();
-const allocPage = (reason, type) => {
+const allocPage = (scope, reason, type) => {
   if (pages.has(reason)) return pages.get(reason).ind;
 
   if (reason.startsWith('array:')) pages.hasArray = true;
@@ -2601,16 +2967,20 @@ const allocPage = (reason, type) => {
   const ind = pages.size;
   pages.set(reason, { ind, type });
 
-  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
+  scope.pages ??= new Map();
+  scope.pages.set(reason, { ind, type });
+
+  if (Prefs.allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
 
   return ind;
 };
 
+// todo: add scope.pages
 const freePage = reason => {
   const { ind } = pages.get(reason);
   pages.delete(reason);
 
-  if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
+  if (Prefs.allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
 
   return ind;
 };
@@ -2661,16 +3031,22 @@ const getAllocType = itemType => {
 const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype) => {
   const out = [];
 
+  scope.arrays ??= new Map();
+
   let firstAssign = false;
-  if (!arrays.has(name) || name === '$undeclared') {
+  if (!scope.arrays.has(name) || name === '$undeclared') {
     firstAssign = true;
 
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
-    arrays.set(name, allocPage(`${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
+
+    if (Prefs.scopedPageNames) scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType) * pageSize);
+      else scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
   }
 
-  const pointer = arrays.get(name);
+  const pointer = scope.arrays.get(name);
+
+  const local = global ? globals[name] : scope.locals[name];
 
   const useRawElements = !!decl.rawElements;
   const elements = useRawElements ? decl.rawElements : decl.elements;
@@ -2678,19 +3054,25 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
-  if (firstAssign && useRawElements) {
-    let bytes = compileBytes(length, 'i32');
+  if (firstAssign && useRawElements && !Prefs.noData) {
+    // if length is 0 memory/data will just be 0000... anyway
+    if (length !== 0) {
+      let bytes = compileBytes(length, 'i32');
 
-    if (!initEmpty) for (let i = 0; i < length; i++) {
-      if (elements[i] == null) continue;
+      if (!initEmpty) for (let i = 0; i < length; i++) {
+        if (elements[i] == null) continue;
 
-      bytes.push(...compileBytes(elements[i], itemType));
-    }
+        bytes.push(...compileBytes(elements[i], itemType));
+      }
 
-    data.push({
-      offset: pointer,
-      bytes
-    });
+      const ind = data.push({
+        offset: pointer,
+        bytes
+      }) - 1;
+
+      scope.data ??= [];
+      scope.data.push(ind);
+    }
 
     // local value as pointer
     out.push(...number(pointer));
@@ -2698,11 +3080,22 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     return [ out, pointer ];
   }
 
+  const pointerTmp = local != null ? localTmp(scope, '#makearray_pointer_tmp', Valtype.i32) : null;
+  if (pointerTmp != null) {
+    out.push(
+      [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_set, pointerTmp ]
+    );
+  }
+
+  const pointerWasm = pointerTmp != null ? [ [ Opcodes.local_get, pointerTmp ] ] : number(pointer, Valtype.i32);
+
   // store length as 0th array
   out.push(
-    ...number(0, Valtype.i32),
+    ...pointerWasm,
     ...number(length, Valtype.i32),
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ]
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
   );
 
   const storeOp = StoreOps[itemType];
@@ -2711,20 +3104,20 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     if (elements[i] == null) continue;
 
     out.push(
-      ...number(0, Valtype.i32),
+      ...pointerWasm,
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
-      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
+      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
     );
   }
 
   // local value as pointer
-  out.push(...number(pointer));
+  out.push(...pointerWasm, Opcodes.i32_from_u);
 
   return [ out, pointer ];
 };
 
 const byteStringable = str => {
-  if (!process.argv.includes('-bytestring')) return false;
+  if (!Prefs.bytestring) return false;
 
   for (let i = 0; i < str.length; i++) {
     if (str.charCodeAt(i) > 0xFF) return false;
@@ -2735,7 +3128,7 @@ const byteStringable = str => {
 
 const makeString = (scope, str, global = false, name = '$undeclared', forceBytestring = undefined) => {
   const rawElements = new Array(str.length);
-  let byteStringable = process.argv.includes('-bytestring');
+  let byteStringable = Prefs.bytestring;
   for (let i = 0; i < str.length; i++) {
     const c = str.charCodeAt(i);
     rawElements[i] = c;
@@ -2750,20 +3143,53 @@ const makeString = (scope, str, global = false, name = '$undeclared', forceBytes
   }, global, name, false, byteStringable ? 'i8' : 'i16')[0];
 };
 
-let arrays = new Map();
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
   return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
 export const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
-  const pointer = arrays.get(name);
+  const pointer = scope.arrays?.get(name);
+
+  const aotPointer = Prefs.aotPointerOpt && pointer != null;
+
+  // hack: .name
+  if (decl.property.name === 'name') {
+    if (hasFuncWithName(name)) {
+      let nameProp = name;
+
+      // eg: __String_prototype_toLowerCase -> toLowerCase
+      if (nameProp.startsWith('__')) nameProp = nameProp.split('_').pop();
 
-  const aotPointer = pointer != null;
+      return makeString(scope, nameProp, _global, _name, true);
+    } else {
+      return generate(scope, DEFAULT_VALUE);
+    }
+  }
 
   // hack: .length
   if (decl.property.name === 'length') {
-    // if (![TYPES._array, TYPES.string].includes(type)) return number(UNDEFINED);
+    const func = funcs.find(x => x.name === name);
+    if (func) {
+      const userFunc = funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name];
+      const typedParams = userFunc || builtinFuncs[name]?.typedParams;
+      return number(typedParams ? func.params.length / 2 : func.params.length);
+    }
+
+    if (builtinFuncs[name + '$constructor']) {
+      const regularFunc = builtinFuncs[name];
+      const regularParams = regularFunc.typedParams ? (regularFunc.params.length / 2) : regularFunc.params.length;
+
+      const constructorFunc = builtinFuncs[name + '$constructor'];
+      const constructorParams = constructorFunc.typedParams ? (constructorFunc.params.length / 2) : constructorFunc.params.length;
+
+      return number(Math.max(regularParams, constructorParams));
+    }
+
+    if (builtinFuncs[name]) return number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length);
+    if (importedFuncs[name]) return number(importedFuncs[name].params);
+    if (internalConstrs[name]) return number(internalConstrs[name].length ?? 0);
+
     return [
       ...(aotPointer ? number(0, Valtype.i32) : [
         ...generate(scope, decl.object),
@@ -2788,7 +3214,7 @@ export const generateMember = (scope, decl, _global, _name) => {
   }
 
   return typeSwitch(scope, getNodeType(scope, decl.object), {
-    [TYPES._array]: [
+    [TYPES.array]: [
       // get index as valtype
       ...property,
 
@@ -2807,7 +3233,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       ...number(TYPES.number, Valtype.i32),
-      setLastType(scope)
+      ...setLastType(scope)
     ],
 
     [TYPES.string]: [
@@ -2839,9 +3265,9 @@ export const generateMember = (scope, decl, _global, _name) => {
       ...number(newPointer),
 
       ...number(TYPES.string, Valtype.i32),
-      setLastType(scope)
+      ...setLastType(scope)
     ],
-    [TYPES._bytestring]: [
+    [TYPES.bytestring]: [
       // setup new/out array
       ...newOut,
       [ Opcodes.drop ],
@@ -2858,19 +3284,19 @@ export const generateMember = (scope, decl, _global, _name) => {
       ]),
 
       // load current string ind {arg}
-      [ Opcodes.i32_load8_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       // store to new string ind 0
-      [ Opcodes.i32_store8, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
 
       // return new string (page)
       ...number(newPointer),
 
-      ...number(TYPES._bytestring, Valtype.i32),
-      setLastType(scope)
+      ...number(TYPES.bytestring, Valtype.i32),
+      ...setLastType(scope)
     ],
 
-    default: internalThrow(scope, 'TypeError', 'Member expression is not supported for non-string non-array yet')
+    default: internalThrow(scope, 'TypeError', 'Member expression is not supported for non-string non-array yet', true)
   });
 };
 
@@ -2880,28 +3306,36 @@ const objectHack = node => {
   if (!node) return node;
 
   if (node.type === 'MemberExpression') {
-    if (node.computed || node.optional) return node;
+    const out = (() => {
+      if (node.computed || node.optional) return;
 
-    let objectName = node.object.name;
+      let objectName = node.object.name;
 
-    // if object is not identifier or another member exp, give up
-    if (node.object.type !== 'Identifier' && node.object.type !== 'MemberExpression') return node;
+      // if object is not identifier or another member exp, give up
+      if (node.object.type !== 'Identifier' && node.object.type !== 'MemberExpression') return;
+      if (objectName && ['undefined', 'null', 'NaN', 'Infinity'].includes(objectName)) return;
 
-    if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
+      if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
 
-    // if .length, give up (hack within a hack!)
-    if (node.property.name === 'length') return node;
+      // if .name or .length, give up (hack within a hack!)
+      if (['name', 'length'].includes(node.property.name)) {
+        node.object = objectHack(node.object);
+        return;
+      }
 
-    // no object name, give up
-    if (!objectName) return node;
+      // no object name, give up
+      if (!objectName) return;
 
-    const name = '__' + objectName + '_' + node.property.name;
-    if (codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
+      const name = '__' + objectName + '_' + node.property.name;
+      if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
-    return {
-      type: 'Identifier',
-      name
-    };
+      return {
+        type: 'Identifier',
+        name
+      };
+    })();
+
+    if (out) return out;
   }
 
   for (const x in node) {
@@ -2915,8 +3349,8 @@ const objectHack = node => {
 };
 
 const generateFunc = (scope, decl) => {
-  if (decl.async) return todo('async functions are not supported');
-  if (decl.generator) return todo('generator functions are not supported');
+  if (decl.async) return todo(scope, 'async functions are not supported');
+  if (decl.generator) return todo(scope, 'generator functions are not supported');
 
   const name = decl.id ? decl.id.name : `anonymous_${randId()}`;
   const params = decl.params ?? [];
@@ -2932,6 +3366,14 @@ const generateFunc = (scope, decl) => {
     name
   };
 
+  if (typedInput && decl.returnType) {
+    const { type } = extractTypeAnnotation(decl.returnType);
+    if (type != null) {
+      innerScope.returnType = type;
+      innerScope.returns = [ valtypeBinary ];
+    }
+  }
+
   for (let i = 0; i < params.length; i++) {
     allocVar(innerScope, params[i].name, false);
 
@@ -2958,6 +3400,8 @@ const generateFunc = (scope, decl) => {
   };
   funcIndex[name] = func.index;
 
+  if (name === 'main') func.gotLastType = true;
+
   // quick hack fixes
   for (const inst of wasm) {
     if (inst[0] === Opcodes.call && inst[1] === -1) {
@@ -2969,7 +3413,7 @@ const generateFunc = (scope, decl) => {
   if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
     wasm.push(
       ...number(0),
-      ...number(TYPES.undefined, Valtype.i32),
+      ...(innerScope.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
       [ Opcodes.return ]
     );
   }
@@ -2992,16 +3436,6 @@ const generateCode = (scope, decl) => {
 };
 
 const internalConstrs = {
-  Boolean: {
-    generate: (scope, decl) => {
-      if (decl.arguments.length === 0) return number(0);
-
-      // should generate/run all args
-      return truthy(scope, generate(scope, decl.arguments[0]), getNodeType(scope, decl.arguments[0]), false, false);
-    },
-    type: TYPES.boolean
-  },
-
   Array: {
     generate: (scope, decl, global, name) => {
       // new Array(i0, i1, ...)
@@ -3019,7 +3453,7 @@ const internalConstrs = {
 
       // todo: check in wasm instead of here
       const literalValue = arg.value ?? 0;
-      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length');
+      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
 
       return [
         ...number(0, Valtype.i32),
@@ -3030,7 +3464,8 @@ const internalConstrs = {
         ...number(pointer)
       ];
     },
-    type: TYPES._array
+    type: TYPES.array,
+    length: 1
   },
 
   __Array_of: {
@@ -3041,27 +3476,134 @@ const internalConstrs = {
         elements: decl.arguments
       }, global, name);
     },
-    type: TYPES._array,
+    type: TYPES.array,
+    notConstr: true,
+    length: 0
+  },
+
+  __Porffor_fastOr: {
+    generate: (scope, decl) => {
+      const out = [];
+
+      for (let i = 0; i < decl.arguments.length; i++) {
+        out.push(
+          ...generate(scope, decl.arguments[i]),
+          Opcodes.i32_to_u,
+          ...(i > 0 ? [ [ Opcodes.i32_or ] ] : [])
+        );
+      }
+
+      out.push(Opcodes.i32_from_u);
+
+      return out;
+    },
+    type: TYPES.boolean,
     notConstr: true
-  }
-};
+  },
 
-// const _ = Array.prototype.push;
-// Array.prototype.push = function (a) {
-//   const check = arr => {
-//     for (const x of arr) {
-//       if (x === undefined) {
-//         console.trace(arr);
-//         process.exit();
-//       }
-//       if (Array.isArray(x)) check(x);
-//     }
-//   };
-//   if (Array.isArray(a) && !new Error().stack.includes('node:')) check(a);
-//   // if (Array.isArray(a)) check(a);
+  __Porffor_fastAnd: {
+    generate: (scope, decl) => {
+      const out = [];
 
-//   return _.apply(this, arguments);
-// };
+      for (let i = 0; i < decl.arguments.length; i++) {
+        out.push(
+          ...generate(scope, decl.arguments[i]),
+          Opcodes.i32_to_u,
+          ...(i > 0 ? [ [ Opcodes.i32_and ] ] : [])
+        );
+      }
+
+      out.push(Opcodes.i32_from_u);
+
+      return out;
+    },
+    type: TYPES.boolean,
+    notConstr: true
+  },
+
+  Boolean: {
+    generate: (scope, decl) => {
+      // todo: boolean object when used as constructor
+      const arg = decl.arguments[0] ?? DEFAULT_VALUE;
+      return truthy(scope, generate(scope, arg), getNodeType(scope, arg));
+    },
+    type: TYPES.boolean,
+    length: 1
+  },
+
+  __Math_max: {
+    generate: (scope, decl) => {
+      const out = [
+        ...number(-Infinity)
+      ];
+
+      for (let i = 0; i < decl.arguments.length; i++) {
+        out.push(
+          ...generate(scope, decl.arguments[i]),
+          [ Opcodes.f64_max ]
+        );
+      }
+
+      return out;
+    },
+    type: TYPES.number,
+    notConstr: true,
+    length: 2
+  },
+
+  __Math_min: {
+    generate: (scope, decl) => {
+      const out = [
+        ...number(Infinity)
+      ];
+
+      for (let i = 0; i < decl.arguments.length; i++) {
+        out.push(
+          ...generate(scope, decl.arguments[i]),
+          [ Opcodes.f64_min ]
+        );
+      }
+
+      return out;
+    },
+    type: TYPES.number,
+    notConstr: true,
+    length: 2
+  },
+
+  __console_log: {
+    generate: (scope, decl) => {
+      const out = [];
+
+      for (let i = 0; i < decl.arguments.length; i++) {
+        out.push(
+          ...generateCall(scope, {
+            callee: {
+              type: 'Identifier',
+              name: '__Porffor_print'
+            },
+            arguments: [ decl.arguments[i] ]
+          }),
+
+          // print space
+          ...number(32),
+          [ Opcodes.call, importedFuncs.printChar ]
+        );
+      }
+
+      // print newline
+      out.push(
+        ...number(10),
+        [ Opcodes.call, importedFuncs.printChar ]
+      );
+
+      return out;
+    },
+    type: TYPES.undefined,
+    notConstr: true,
+    length: 0
+  }
+};
 
 export default program => {
   globals = {};
@@ -3071,20 +3613,23 @@ export default program => {
   funcs = [];
   funcIndex = {};
   depth = [];
-  arrays = new Map();
   pages = new Map();
   data = [];
   currentFuncIndex = importedFuncs.length;
 
   globalThis.valtype = 'f64';
 
-  const valtypeOpt = process.argv.find(x => x.startsWith('-valtype='));
+  const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
   if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
 
   globalThis.valtypeBinary = Valtype[valtype];
 
   const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
 
+  globalThis.pageSize = PageSize;
+  const pageSizeOpt = process.argv.find(x => x.startsWith('--page-size='));
+  if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
+
   // set generic opcodes for current valtype
   Opcodes.const = [ Opcodes.i32_const, Opcodes.i64_const, Opcodes.f64_const ][valtypeInd];
   Opcodes.eq = [ Opcodes.i32_eq, Opcodes.i64_eq, Opcodes.f64_eq ][valtypeInd];
@@ -3093,10 +3638,10 @@ export default program => {
   Opcodes.add = [ Opcodes.i32_add, Opcodes.i64_add, Opcodes.f64_add ][valtypeInd];
   Opcodes.sub = [ Opcodes.i32_sub, Opcodes.i64_sub, Opcodes.f64_sub ][valtypeInd];
 
-  Opcodes.i32_to = [ [ null ], [ Opcodes.i32_wrap_i64 ], Opcodes.i32_trunc_sat_f64_s ][valtypeInd];
-  Opcodes.i32_to_u = [ [ null ], [ Opcodes.i32_wrap_i64 ], Opcodes.i32_trunc_sat_f64_u ][valtypeInd];
-  Opcodes.i32_from = [ [ null ], [ Opcodes.i64_extend_i32_s ], [ Opcodes.f64_convert_i32_s ] ][valtypeInd];
-  Opcodes.i32_from_u = [ [ null ], [ Opcodes.i64_extend_i32_u ], [ Opcodes.f64_convert_i32_u ] ][valtypeInd];
+  Opcodes.i32_to = [ [], [ Opcodes.i32_wrap_i64 ], Opcodes.i32_trunc_sat_f64_s ][valtypeInd];
+  Opcodes.i32_to_u = [ [], [ Opcodes.i32_wrap_i64 ], Opcodes.i32_trunc_sat_f64_u ][valtypeInd];
+  Opcodes.i32_from = [ [], [ Opcodes.i64_extend_i32_s ], [ Opcodes.f64_convert_i32_s ] ][valtypeInd];
+  Opcodes.i32_from_u = [ [], [ Opcodes.i64_extend_i32_u ], [ Opcodes.f64_convert_i32_u ] ][valtypeInd];
 
   Opcodes.load = [ Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load ][valtypeInd];
   Opcodes.store = [ Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store ][valtypeInd];
@@ -3109,10 +3654,6 @@ export default program => {
 
   program.id = { name: 'main' };
 
-  globalThis.pageSize = PageSize;
-  const pageSizeOpt = process.argv.find(x => x.startsWith('-page-size='));
-  if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
-
   const scope = {
     locals: {},
     localInd: 0
@@ -3123,7 +3664,7 @@ export default program => {
     body: program.body
   };
 
-  if (process.argv.includes('-ast-log')) console.log(program.body.body);
+  if (Prefs.astLog) console.log(JSON.stringify(program.body.body, null, 2));
 
   generateFunc(scope, program);
 
@@ -3140,7 +3681,11 @@ export default program => {
   }
 
   if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {
-    main.returns = [];
+    if (lastInst[0] === Opcodes.local_set && lastInst[1] === main.locals['#last_type'].idx) {
+      main.wasm.splice(main.wasm.length - 1, 1);
+    } else {
+      main.returns = [];
+    }
   }
 
   if (lastInst[0] === Opcodes.call) {