porffor 0.14.0-eca486960 → 0.16.0-053a03e10

package/compiler/prototype.js

@@ -16,7 +16,7 @@ export const PrototypeFuncs = function() {
 
   this[TYPES.array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    at: (pointer, length, wIndex, iTmp) => [
+    at: (pointer, length, wIndex, wType, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
       [ Opcodes.local_tee, iTmp ],
@@ -47,31 +47,39 @@ export const PrototypeFuncs = function() {
       [ Opcodes.end ],
 
       [ Opcodes.local_get, iTmp ],
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
-
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
       // read from memory
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
     ],
 
     // todo: only for 1 argument
-    push: (pointer, length, wNewMember, _1, _2, _3, unusedValue) => [
+    push: (pointer, length, wNewMember, wType, iTmp, _2, _3, unusedValue) => [
       // get memory offset of array at last index (length)
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
-
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
-      // generated wasm for new member
+      // store value
+      [ Opcodes.local_get, iTmp ],
       ...wNewMember,
+      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
 
-      // store in memory
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      // store type
+      [ Opcodes.local_get, iTmp ],
+      ...wType,
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // bump array length by 1 and return it
       ...length.setI32([
@@ -93,7 +101,7 @@ export const PrototypeFuncs = function() {
       // ...length.get()
     ],
 
-    pop: (pointer, length, _1, _2, _3, _4, unusedValue) => [
+    pop: (pointer, length, _1, _2, iTmp, _3, _4, unusedValue) => [
       // if length == 0, noop
       ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
@@ -121,13 +129,18 @@ export const PrototypeFuncs = function() {
       // load last element
       ...(unusedValue() ? [] : [
         ...length.getCachedI32(),
-        ...number(ValtypeSize[valtype], Valtype.i32),
+        ...number(ValtypeSize[valtype] + 1, Valtype.i32),
         [ Opcodes.i32_mul ],
 
         ...pointer,
         [ Opcodes.i32_add ],
+        [ Opcodes.local_set, iTmp ],
 
-        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
       ])
     ],
 
@@ -153,8 +166,12 @@ export const PrototypeFuncs = function() {
       ]),
 
       // load first element
+      // todo/perf: unusedValue opt
       ...pointer,
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      ...pointer,
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // offset page by -1 ind
       // ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
@@ -170,13 +187,13 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_add ],
 
       // src = base array index + length size + an index
-      ...number(ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize.i32 + ValtypeSize[valtype] + 1, Valtype.i32),
       ...pointer,
       [ Opcodes.i32_add ],
 
       // size = new length * sizeof element
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
 
@@ -194,7 +211,7 @@ export const PrototypeFuncs = function() {
       // ]),
     ],
 
-    fill: (pointer, length, wElement, iTmp) => [
+    fill: (pointer, length, wElement, wType, iTmp, iTmp2) => [
       ...wElement,
       [ Opcodes.local_set, iTmp ],
 
@@ -206,7 +223,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_sub ],
 
       // * sizeof value
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
 
       ...length.setCachedI32(),
@@ -224,17 +241,25 @@ export const PrototypeFuncs = function() {
 
       [ Opcodes.loop, Blocktype.void ],
 
-      // set element using pointer
+      // calculate offset
       ...length.getCachedI32(),
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp2 ],
 
+      // store value
+      [ Opcodes.local_get, iTmp2 ],
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128( ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store type
+      [ Opcodes.local_get, iTmp2 ],
+      ...wType,
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // pointer - sizeof value
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_sub ],
 
       ...length.setCachedI32(),
@@ -254,12 +279,16 @@ export const PrototypeFuncs = function() {
   };
 
   this[TYPES.array].at.local = Valtype.i32;
+  this[TYPES.array].push.returnType = TYPES.number;
   this[TYPES.array].push.noArgRetLength = true;
+  this[TYPES.array].push.local = Valtype.i32;
+  this[TYPES.array].pop.local = Valtype.i32;
   this[TYPES.array].fill.local = valtypeBinary;
+  this[TYPES.array].fill.local2 = Valtype.i32;
   this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
-    at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+    at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -317,7 +346,7 @@ export const PrototypeFuncs = function() {
     },
 
     // todo: out of bounds properly
-    charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+    charAt: (pointer, length, wIndex, wType, _1, _2, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -347,127 +376,124 @@ export const PrototypeFuncs = function() {
       ];
     },
 
-    charCodeAt: (pointer, length, wIndex, iTmp) => {
-      return [
-        ...wIndex,
-        Opcodes.i32_to,
-
-        ...(zeroChecks.charcodeat ? [] : [
-          [ Opcodes.local_set, iTmp ],
+    charCodeAt: (pointer, length, wIndex, wType, iTmp) => [
+      ...wIndex,
+      Opcodes.i32_to,
 
-          // index < 0
-          ...(noUnlikelyChecks ? [] : [
-            [ Opcodes.local_get, iTmp ],
-            ...number(0, Valtype.i32),
-            [ Opcodes.i32_lt_s ],
-          ]),
+      ...(zeroChecks.charcodeat ? [] : [
+        [ Opcodes.local_set, iTmp ],
 
-          // index >= length
+        // index < 0
+        ...(noUnlikelyChecks ? [] : [
           [ Opcodes.local_get, iTmp ],
-          ...length.getCachedI32(),
-          [ Opcodes.i32_ge_s ],
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+        ]),
 
-          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-          [ Opcodes.if, Blocktype.void ],
-          ...number(valtype === 'i32' ? -1 : NaN),
-          [ Opcodes.br, 1 ],
-          [ Opcodes.end ],
+        // index >= length
+        [ Opcodes.local_get, iTmp ],
+        ...length.getCachedI32(),
+        [ Opcodes.i32_ge_s ],
 
-          [ Opcodes.local_get, iTmp ],
-        ]),
+        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+        [ Opcodes.if, Blocktype.void ],
+        ...number(valtype === 'i32' ? -1 : NaN),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ],
 
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
+        [ Opcodes.local_get, iTmp ],
+      ]),
 
-        ...pointer,
-        [ Opcodes.i32_add ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
 
-        // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
-        Opcodes.i32_from_u
-      ];
-    },
+      ...pointer,
+      [ Opcodes.i32_add ],
 
-    isWellFormed: (pointer, length, wIndex, iTmp, iTmp2) => {
-      return [
-        // note: we cannot presume it begins as 0 in case it was used previously
-        ...pointer,
-        [ Opcodes.local_set, iTmp ],
+      // load current string ind {arg}
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      Opcodes.i32_from_u
+    ],
 
-        // use cached length as end pointer
-        ...length.getCachedI32(),
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
-        ...pointer,
-        [ Opcodes.i32_add ],
-        ...length.setCachedI32(),
+    isWellFormed: (pointer, length, _1, _2, iTmp, iTmp2) => [
+      // note: we cannot presume it begins as 0 in case it was used previously
+      ...pointer,
+      [ Opcodes.local_set, iTmp ],
+
+      // use cached length as end pointer
+      ...length.getCachedI32(),
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
+      ...pointer,
+      [ Opcodes.i32_add ],
+      ...length.setCachedI32(),
 
-        [ Opcodes.loop, Blocktype.void ],
+      [ Opcodes.loop, Blocktype.void ],
 
-        [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
 
-        [ Opcodes.local_get, iTmp ],
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
-        [ Opcodes.local_set, iTmp2 ],
-
-        // if not surrogate, continue
-        [ Opcodes.local_get, iTmp2 ],
-        ...number(0xF800, Valtype.i32),
-        [ Opcodes.i32_and ],
-        ...number(0xD800, Valtype.i32),
-        [ Opcodes.i32_ne ],
-        [ Opcodes.br_if, 0 ],
-
-        // if not leading surrogate, return false
-        [ Opcodes.local_get, iTmp2 ],
-        ...number(0xDC00, Valtype.i32),
-        [ Opcodes.i32_ge_s ],
-        [ Opcodes.if, Blocktype.void ],
-        ...number(0),
-        [ Opcodes.br, 3 ],
-        [ Opcodes.end ],
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.local_set, iTmp2 ],
+
+      // if not surrogate, continue
+      [ Opcodes.local_get, iTmp2 ],
+      ...number(0xF800, Valtype.i32),
+      [ Opcodes.i32_and ],
+      ...number(0xD800, Valtype.i32),
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 0 ],
 
-        // if not followed by trailing surrogate, return false
-        [ Opcodes.local_get, iTmp ],
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
-        ...number(0xFC00, Valtype.i32),
-        [ Opcodes.i32_and ],
-        ...number(0xDC00, Valtype.i32),
-        [ Opcodes.i32_ne ],
-        [ Opcodes.if, Blocktype.void ],
-        ...number(0),
-        [ Opcodes.br, 3 ],
-        [ Opcodes.end ],
+      // if not leading surrogate, return false
+      [ Opcodes.local_get, iTmp2 ],
+      ...number(0xDC00, Valtype.i32),
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.if, Blocktype.void ],
+      ...number(0),
+      [ Opcodes.br, 3 ],
+      [ Opcodes.end ],
 
-        // bump index again since gone through two valid chars
-        [ Opcodes.local_get, iTmp ],
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_set, iTmp ],
+      // if not followed by trailing surrogate, return false
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
+      ...number(0xFC00, Valtype.i32),
+      [ Opcodes.i32_and ],
+      ...number(0xDC00, Valtype.i32),
+      [ Opcodes.i32_ne ],
+      [ Opcodes.if, Blocktype.void ],
+      ...number(0),
+      [ Opcodes.br, 3 ],
+      [ Opcodes.end ],
 
-        [ Opcodes.end ],
+      // bump index again since gone through two valid chars
+      [ Opcodes.local_get, iTmp ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
-        // bump pointer and loop if not at the end
-        [ Opcodes.local_get, iTmp ],
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_tee, iTmp ],
+      [ Opcodes.end ],
 
-        ...length.getCachedI32(), // end pointer
-        [ Opcodes.i32_ne ],
-        [ Opcodes.br_if, 0 ],
+      // bump pointer and loop if not at the end
+      [ Opcodes.local_get, iTmp ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, iTmp ],
 
-        [ Opcodes.end ],
+      ...length.getCachedI32(), // end pointer
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 0 ],
 
-        // return true
-        ...number(1)
-      ]
-    }
+      [ Opcodes.end ],
+
+      // return true
+      ...number(1)
+    ]
   };
 
   this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
+  this[TYPES.string].charCodeAt.returnType = TYPES.number;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
   this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
@@ -477,7 +503,7 @@ export const PrototypeFuncs = function() {
 
   if (Prefs.bytestring) {
     this[TYPES.bytestring] = {
-      at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+      at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
@@ -533,7 +559,7 @@ export const PrototypeFuncs = function() {
       },
 
       // todo: out of bounds properly
-      charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+      charAt: (pointer, length, wIndex, wType, _1, _2, arrayShell) => {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
@@ -560,55 +586,52 @@ export const PrototypeFuncs = function() {
         ];
       },
 
-      charCodeAt: (pointer, length, wIndex, iTmp) => {
-        return [
-          ...wIndex,
-          Opcodes.i32_to,
-
-          ...(zeroChecks.charcodeat ? [] : [
-            [ Opcodes.local_set, iTmp ],
+      charCodeAt: (pointer, length, wIndex, wType, iTmp) => [
+        ...wIndex,
+        Opcodes.i32_to,
 
-            // index < 0
-            ...(noUnlikelyChecks ? [] : [
-              [ Opcodes.local_get, iTmp ],
-              ...number(0, Valtype.i32),
-              [ Opcodes.i32_lt_s ],
-            ]),
+        ...(zeroChecks.charcodeat ? [] : [
+          [ Opcodes.local_set, iTmp ],
 
-            // index >= length
+          // index < 0
+          ...(noUnlikelyChecks ? [] : [
             [ Opcodes.local_get, iTmp ],
-            ...length.getCachedI32(),
-            [ Opcodes.i32_ge_s ],
+            ...number(0, Valtype.i32),
+            [ Opcodes.i32_lt_s ],
+          ]),
 
-            ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-            [ Opcodes.if, Blocktype.void ],
-            ...number(valtype === 'i32' ? -1 : NaN),
-            [ Opcodes.br, 1 ],
-            [ Opcodes.end ],
+          // index >= length
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
 
-            [ Opcodes.local_get, iTmp ],
-          ]),
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(valtype === 'i32' ? -1 : NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
 
-          ...pointer,
-          [ Opcodes.i32_add ],
+          [ Opcodes.local_get, iTmp ],
+        ]),
 
-          // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
-          Opcodes.i32_from_u
-        ];
-      },
+        ...pointer,
+        [ Opcodes.i32_add ],
 
-      isWellFormed: () => {
-        return [
-          // we know it must be true as it is a bytestring lol
-          ...number(1)
-        ]
-      }
+        // load current string ind {arg}
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        Opcodes.i32_from_u
+      ],
+
+      isWellFormed: () => [
+        // we know it must be true as it is a bytestring lol
+        ...number(1)
+      ]
     };
 
     this[TYPES.bytestring].at.local = Valtype.i32;
     this[TYPES.bytestring].at.returnType = TYPES.bytestring;
     this[TYPES.bytestring].charAt.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charCodeAt.returnType = TYPES.number;
     this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
     this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 

package/compiler/wrap.js

@@ -6,8 +6,25 @@ import { TYPES } from './types.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
 
+const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs')) : undefined);
+
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
+export const readByteStr = (memory, ptr) => {
+  const length = (new Int32Array(memory.buffer, ptr, 1))[0];
+  return Array.from(new Uint8Array(memory.buffer, ptr + 4, length)).map(x => String.fromCharCode(x)).join('');
+};
+
+export const writeByteStr = (memory, ptr, str) => {
+  const length = str.length;
+  (new Int32Array(memory.buffer, ptr, 1))[0] = length;
+
+  const arr = new Uint8Array(memory.buffer, ptr + 4, length);
+  for (let i = 0; i < length; i++) {
+    arr[i] = str.charCodeAt(i);
+  }
+};
+
 const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
   switch (type) {
     case TYPES.boolean: return Boolean(value);
@@ -41,9 +58,22 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
     case TYPES.array: {
       const length = (new Int32Array(memory.buffer, value, 1))[0];
 
-      // have to slice because of memory alignment (?)
-      const buf = memory.buffer.slice(value + 4, value + 4 + 8 * length);
-      return Array.from(new Float64Array(buf, 0, length));
+      const out = [];
+      for (let i = 0; i < length; i++) {
+        const offset = value + 4 + (i * 9);
+
+        // have to slice because of memory alignment (?)
+        const v = (new Float64Array(memory.buffer.slice(offset, offset + 8), 0, 1))[0];
+        const t = (new Uint8Array(memory.buffer, offset + 8, 1))[0];
+
+        // console.log(`reading value at index ${i}...`)
+        // console.log('  memory:', Array.from(new Uint8Array(memory.buffer, offset, 9)).map(x => x.toString(16).padStart(2, '0')).join(' '));
+        // console.log('  read:', { value: v, type: t }, '\n');
+
+        out.push(porfToJSValue({ memory, funcs, pages }, v, t));
+      }
+
+      return out;
     }
 
     case TYPES.date: {
@@ -88,28 +118,31 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
   }
 };
 
-export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
+export default (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
   const times = [];
 
   const t1 = performance.now();
-  const { wasm, funcs, globals, tags, exceptions, pages, c } = compile(source, flags);
+  const { wasm, funcs, globals, tags, exceptions, pages, c } = typeof source === 'object' ? source : compile(source, flags);
 
   globalThis.porfDebugInfo = { funcs, globals };
 
-  if (source.includes('export function')) flags.push('module');
+  if (source.includes?.('export ')) flags.push('module');
 
-  // (await import('node:fs')).writeFileSync('out.wasm', Buffer.from(wasm));
+  fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (Prefs.profileCompiler) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const backtrace = (funcInd, blobOffset) => {
-    if (funcInd == null || blobOffset == null) return false;
+    if (funcInd == null || blobOffset == null ||
+        Number.isNaN(funcInd) || Number.isNaN(blobOffset)) return false;
 
     // convert blob offset -> function wasm offset.
     // this is not good code and is somewhat duplicated
     // I just want it to work for debugging, I don't care about perf/yes
     const func = funcs.find(x => x.index === funcInd);
+    if (!func) return false;
+
     const locals = Object.values(func.locals).sort((a, b) => a.idx - b.idx).slice(func.params.length).sort((a, b) => a.idx - b.idx);
 
     let localDecl = [], typeCount = 0, lastType;
@@ -184,13 +217,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   let instance;
   try {
-    let wasmEngine = WebAssembly;
-    if (Prefs.asur) {
-      log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
-      wasmEngine = await import('../asur/index.js');
-    }
-
-    0, { instance } = await wasmEngine.instantiate(wasm, {
+    // let wasmEngine = WebAssembly;
+    // if (Prefs.asur) {
+    //   log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
+    //   wasmEngine = await import('../asur/index.js');
+    // }
+
+    // 0, { instance } = await wasmEngine.instantiate(wasm, {
+    const module = new WebAssembly.Module(wasm);
+    instance = new WebAssembly.Instance(module, {
       '': {
         p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
         c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
@@ -198,12 +233,31 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
         u: () => performance.timeOrigin,
         y: () => {},
         z: () => {},
+        w: (ind, outPtr) => { // readArgv
+          const args = process.argv.slice(2).filter(x => !x.startsWith('-'));
+          const str = args[ind];
+          if (!str) return -1;
+
+          writeByteStr(memory, outPtr, str);
+          return str.length;
+        },
+        q: (pathPtr, outPtr) => { // readFile
+          try {
+            const path = readByteStr(memory, pathPtr);
+            const contents = fs.readFileSync(path, 'utf8');
+            writeByteStr(memory, outPtr, contents);
+            return contents.length;
+          } catch {
+            return -1;
+          }
+        },
         ...customImports
       }
     });
   } catch (e) {
     // only backtrace for runner, not test262/etc
     if (!process.argv[1].includes('/runner')) throw e;
+    if (!(e instanceof WebAssembly.CompileError)) throw e;
 
     const funcInd = parseInt(e.message.match(/function #([0-9]+) /)?.[1]);
     const blobOffset = parseInt(e.message.split('@')?.[1]);
@@ -216,6 +270,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   if (Prefs.profileCompiler) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
 
   const exports = {};
+  const rawValues = process.argv.includes('-i');
 
   const exceptTag = instance.exports['0'], memory = instance.exports['$'];
   for (const x in instance.exports) {
@@ -236,7 +291,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
         const ret = exp.apply(this, arguments);
         if (ret == null) return undefined;
 
-        if (Prefs.rawValue) return { value: ret[0], type: ret[1] };
+        if (rawValues) return { value: ret[0], type: ret[1], js: porfToJSValue({ memory, funcs, pages }, ret[0], ret[1]) };
 
         return porfToJSValue({ memory, funcs, pages }, ret[0], ret[1]);
       } catch (e) {