warpo 2.3.0 → 2.5.0-alpha-1

package/package.json

@@ -1,23 +1,25 @@
 {
   "name": "warpo",
-  "version": "2.3.0",
+  "version": "2.5.0-alpha-1",
   "description": "next generation AssemblyScript compiler with optimizations",
   "type": "module",
   "bin": {
     "warpo": "dist/warpo.js"
   },
   "scripts": {
-    "build:ts": "tsc -p tools/scripts/tsconfig.json",
+    "update": "cmake -S . -B build && cmake --build build --parallel --target warpo_binaryen_enums_gen && ./build/bin/warpo_binaryen_enums_gen",
+    "build:ts": "tsc -p tools/tsconfig.json",
     "build:cpp": "cmake -S . -B build && cmake --build build --parallel",
     "build": "npm run build:ts && npm run build:cpp",
-    "test:as:ut": "as-test",
+    "test:as:ut": "node dist/warpo.js test",
     "test:cpp:ut": "cd build && ctest --output-on-failure",
     "test:as:snapshot": "cross-env-shell ./build/tests/frontend/warpo_frontend_test",
     "test:opt:snapshot": "node tests/snapshot_diff/index.mjs",
     "test:bootstrap:debug": "./tests/bootstrap/debug.sh",
     "test:bootstrap:release": "./tests/bootstrap/release.sh",
-    "test:debug_symbol": "cross-env-shell ./build/tests/DebugSymbol/TestDebugSymbol",
-    "test:debug_symbol:update": "cross-env-shell build/tests/DebugSymbol/TestDebugSymbol --update-fixtures",
+    "test:debug_symbol": "cross-env-shell ./build/tests/dwarf/TestDebugSymbol",
+    "test:debug_symbol:update": "cross-env-shell build/tests/dwarf/TestDebugSymbol --update-fixtures",
+    "test:debug_server": "node --import tsx --test tools/debug_server/tests/**/*.test.ts",
     "test:driver": "node tests/driver/index.mjs",
     "test": "npm run test:as:ut && npm run test:cpp:ut && npm run test:as:snapshot && npm run test:opt:snapshot && npm run test:driver && npm run test:debug_symbol",
     "test:all": "npm run test && npm run test:bootstrap:debug && npm run test:bootstrap:release",
@@ -26,6 +28,7 @@
     "docs:build": "vitepress build docs",
     "prettier": "prettier --check .",
     "prettier:fix": "prettier --write .",
+    "lint": "npx eslint --config tools/debug_server/eslint.config.mjs tools/debug_server/ && npx eslint --config debugger/eslint.config.mjs debugger/src/",
     "cspell": "cspell ."
   },
   "license": "Apache-2.0",
@@ -49,16 +52,41 @@
   ],
   "devDependencies": {
     "@assemblyscript/loader": "^0.28.9",
+    "@eslint/js": "^9.0.0",
+    "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.15.21",
+    "@types/vscode": "^1.80.0",
+    "@vscode/debugadapter-testsupport": "^1.65.0",
+    "@vscode/vsce": "^3.0.0",
     "assemblyscript": "^0.28.9",
-    "assemblyscript-prettier": "^3.0.1",
-    "assemblyscript-unittest-framework": "^2.0.1",
+    "assemblyscript-prettier": "^3.0.4",
     "chalk": "^5.6.2",
     "cross-env": "^10.1.0",
     "cspell": "^9.3.0",
     "diff": "^8.0.0",
-    "prettier": "^3.6.2",
+    "eslint": "^9.0.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-sonarjs": "^4.0.0",
+    "eslint-plugin-unicorn": "^63.0.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "expect": "^30.2.0",
+    "ignore": "^7.0.5",
+    "prettier": "^3.8.1",
+    "tsx": "^4.0.0",
     "typescript": "^5.8.3",
+    "typescript-eslint": "^8.55.0",
     "vitepress": "^2.0.0-alpha.15"
+  },
+  "dependencies": {
+    "@vscode/debugadapter": "^1.68.0",
+    "@vscode/debugprotocol": "^1.68.0",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.3",
+    "glob": "^13.0.0",
+    "mermaid": "^11.12.1",
+    "source-map": "^0.7.6"
   }
 }

package/tsconfig-warpo.json

@@ -1,5 +1,5 @@
 {
-  "extends": "./assemblyscript/tsconfig-base.json",
+  "extends": "./types/tsconfig-base.json",
   "compilerOptions": {
     "target": "esnext",
     "module": "commonjs",
@@ -8,7 +8,6 @@
     "allowJs": false,
     "typeRoots": ["types"],
     "types": ["warpo"],
-    "baseUrl": ".",
-    "paths": { "*": ["./assembly/*"] }
+    "baseUrl": "."
   }
 }

package/{assemblyscript/std/assembly → types/std}/index.d.ts

@@ -82,10 +82,12 @@ declare type stringview_iter = ref_stringview_iter | null;
 
 // Compiler hints
 
-/** Compiler target. 0 = JS, 1 = WASM32, 2 = WASM64. */
+/** Compiler target. 0 = JS, 1 = WASM32. */
 declare const ASC_TARGET: i32;
 /** Runtime type. 0 = Stub, 1 = Radical, 2 = Incremental. */
 declare const ASC_RUNTIME: i32;
+/** Host selection. 0 = None, 1 = WASI Snapshot Preview 1. */
+declare const ASC_HOST: i32;
 /** Provided noAssert option. */
 declare const ASC_NO_ASSERT: bool;
 /** Provided memoryBase option. */
@@ -110,8 +112,6 @@ declare const ASC_FEATURE_NONTRAPPING_F2I: bool;
 declare const ASC_FEATURE_BULK_MEMORY: bool;
 /** Whether the SIMD feature is enabled. */
 declare const ASC_FEATURE_SIMD: bool;
-/** Whether the threads feature is enabled. */
-declare const ASC_FEATURE_THREADS: bool;
 /** Whether the exception handling feature is enabled. */
 declare const ASC_FEATURE_EXCEPTION_HANDLING: bool;
 /** Whether the tail calls feature is enabled. */
@@ -281,44 +281,6 @@ declare function decodeURI(str: string): string;
 /** Decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent. */
 declare function decodeURIComponent(str: string): string;
 
-/** Atomic operations. */
-declare namespace atomic {
-  /** Atomically loads an integer value from memory and returns it. */
-  export function load<T>(ptr: usize, immOffset?: usize): T;
-  /** Atomically stores an integer value to memory. */
-  export function store<T>(ptr: usize, value: T, immOffset?: usize): void;
-  /** Atomically adds an integer value in memory. */
-  export function add<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically subtracts an integer value in memory. */
-  export function sub<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically performs a bitwise AND operation on an integer value in memory. */
-  export function and<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically performs a bitwise OR operation on an integer value in memory. */
-  export function or<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically performs a bitwise XOR operation on an integer value in memory. */
-  export function xor<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically exchanges an integer value in memory. */
-  export function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically compares and exchanges an integer value in memory if the condition is met. */
-  export function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;
-  /** Performs a wait operation on an address in memory suspending this agent if the integer condition is met. */
-  export function wait<T>(ptr: usize, expected: T, timeout?: i64): AtomicWaitResult;
-  /** Performs a notify operation on an address in memory waking up suspended agents. */
-  export function notify(ptr: usize, count?: i32): i32;
-  /** Performs a fence operation, preserving synchronization guarantees of higher level languages. */
-  export function fence(): void;
-}
-
-/** Describes the result of an atomic wait operation. */
-declare enum AtomicWaitResult {
-  /** Woken by another agent. */
-  OK,
-  /** Loaded value did not match the expected value. */
-  NOT_EQUAL,
-  /** Not woken before the timeout expired. */
-  TIMED_OUT,
-}
-
 /** Converts any other numeric value to an 8-bit signed integer. */
 declare function i8(value: any): i8;
 declare namespace i8 {
@@ -394,73 +356,6 @@ declare namespace i32 {
   export function rem_s(left: i32, right: i32): i32;
   /** Computes the unsigned remainder of two 32-bit integers. */
   export function rem_u(left: u32, right: u32): u32;
-
-  /** Atomic 32-bit integer operations. */
-  export namespace atomic {
-    /** Atomically loads an 8-bit unsigned integer value from memory and returns it as a 32-bit integer. */
-    export function load8_u(ptr: usize, immOffset?: usize): i32;
-    /** Atomically loads a 16-bit unsigned integer value from memory and returns it as a 32-bit integer. */
-    export function load16_u(ptr: usize, immOffset?: usize): i32;
-    /** Atomically loads a 32-bit integer value from memory and returns it. */
-    export function load(ptr: usize, immOffset?: usize): i32;
-    /** Atomically stores a 32-bit integer value to memory as an 8-bit integer. */
-    export function store8(ptr: usize, value: i32, immOffset?: usize): void;
-    /** Atomically stores a 32-bit integer value to memory as a 16-bit integer. */
-    export function store16(ptr: usize, value: i32, immOffset?: usize): void;
-    /** Atomically stores a 32-bit integer value to memory. */
-    export function store(ptr: usize, value: i32, immOffset?: usize): void;
-    /** Atomic 32-bit integer read-modify-write operations on 8-bit values. */
-    export namespace rmw8 {
-      /** Atomically adds an 8-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically subtracts an 8-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise AND operation an 8-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise OR operation an 8-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise XOR operation an 8-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically exchanges an 8-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically compares and exchanges an 8-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
-    }
-    /** Atomic 32-bit integer read-modify-write operations on 16-bit values. */
-    export namespace rmw16 {
-      /** Atomically adds a 16-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically adds a 16-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise AND operation a 16-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise OR operation a 16-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise XOR operation a 16-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically exchanges a 16-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically compares and exchanges a 16-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
-    }
-    /** Atomic 32-bit integer read-modify-write operations. */
-    export namespace rmw {
-      /** Atomically adds a 32-bit integer value in memory. */
-      export function add(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically subtracts a 32-bit integer value in memory. */
-      export function sub(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise AND operation a 32-bit integer value in memory. */
-      export function and(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise OR operation a 32-bit integer value in memory. */
-      export function or(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise XOR operation a 32-bit integer value in memory. */
-      export function xor(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically exchanges a 32-bit integer value in memory. */
-      export function xchg(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically compares and exchanges a 32-bit integer value in memory if the condition is met. */
-      export function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
-    }
-  }
 }
 /** Converts any other numeric value to a 64-bit signed integer. */
 declare function i64(value: any): i64;
@@ -523,97 +418,9 @@ declare namespace i64 {
   export function rem_s(left: i64, right: i64): i64;
   /** Computes the unsigned remainder of two 64-bit integers. */
   export function rem_u(left: u64, right: u64): u64;
-
-  /** Atomic 64-bit integer operations. */
-  export namespace atomic {
-    /** Atomically loads an 8-bit unsigned integer value from memory and returns it as a 64-bit integer. */
-    export function load8_u(ptr: usize, immOffset?: usize): i64;
-    /** Atomically loads a 16-bit unsigned integer value from memory and returns it as a 64-bit integer. */
-    export function load16_u(ptr: usize, immOffset?: usize): i64;
-    /** Atomically loads a 32-bit unsigned integer value from memory and returns it as a 64-bit integer. */
-    export function load32_u(ptr: usize, immOffset?: usize): i64;
-    /** Atomically loads a 64-bit integer value from memory and returns it. */
-    export function load(ptr: usize, immOffset?: usize): i64;
-    /** Atomically stores a 64-bit integer value to memory as an 8-bit integer. */
-    export function store8(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomically stores a 64-bit integer value to memory as a 16-bit integer. */
-    export function store16(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomically stores a 64-bit integer value to memory as a 32-bit integer. */
-    export function store32(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomically stores a 64-bit integer value to memory. */
-    export function store(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomic 64-bit integer read-modify-write operations on 8-bit values. */
-    export namespace rmw8 {
-      /** Atomically adds an 8-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts an 8-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on an 8-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on an 8-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on an 8-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges an 8-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges an 8-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-    /** Atomic 64-bit integer read-modify-write operations on 16-bit values. */
-    export namespace rmw16 {
-      /** Atomically adds a 16-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts a 16-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on a 16-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on a 16-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on a 16-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges a 16-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges a 16-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-    /** Atomic 64-bit integer read-modify-write operations on 32-bit values. */
-    export namespace rmw32 {
-      /** Atomically adds a 32-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts a 32-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on a 32-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on a 32-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on a 32-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges a 32-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges a 32-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-    /** Atomic 64-bit integer read-modify-write operations. */
-    export namespace rmw {
-      /** Atomically adds a 64-bit integer value in memory. */
-      export function add(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts a 64-bit integer value in memory. */
-      export function sub(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on a 64-bit integer value in memory. */
-      export function and(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on a 64-bit integer value in memory. */
-      export function or(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on a 64-bit integer value in memory. */
-      export function xor(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges a 64-bit integer value in memory. */
-      export function xchg(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges a 64-bit integer value in memory if the condition is met. */
-      export function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-  }
 }
-/** Converts any other numeric value to a 32-bit (in WASM32) respectively 64-bit (in WASM64) signed integer. */
-declare let isize: typeof i32 | typeof i64;
+/** Converts any other numeric value to a 32-bit signed integer. */
+declare let isize: typeof i32;
 /** Converts any other numeric value to an 8-bit unsigned integer. */
 declare function u8(value: any): u8;
 declare namespace u8 {
@@ -654,8 +461,8 @@ declare namespace u64 {
   /** Parses a string as an u64. */
   export function parse(value: string, radix?: i32): u64;
 }
-/** Converts any other numeric value to a 32-bit (in WASM32) respectively 64-bit (in WASM64) unsigned integer. */
-declare let usize: typeof u32 | typeof u64;
+/** Converts any other numeric value to a 32-bit unsigned integer. */
+declare let usize: typeof u32;
 /** Converts any other numeric value to a 1-bit unsigned integer. */
 declare function bool(value: any): bool;
 declare namespace bool {
@@ -1714,6 +1521,10 @@ declare namespace f64x2 {
   export function relaxed_max(a: v128, b: v128): v128;
 }
 
+declare namespace ffi {
+  function set_ffi_closure_env(value: i32): void;
+}
+
 declare abstract class i31 {
   /** Creates a new 31-bit integer reference from the specified integer value. */
   static new(value: i32): ref_i31;
@@ -1851,13 +1662,6 @@ declare namespace memory {
   export function data(size: i32, align?: i32): usize;
   /** Gets a pointer to a pre-initialized static chunk of memory. Alignment defaults to the size of `T`. Arguments must be compile-time constants. */
   export function data<T>(values: T[], align?: i32): usize;
-
-  export namespace atomic {
-    /** Performs a wait operation on a 32-bit integer value in memory suspending this agent if the condition is met. */
-    export function wait32(ptr: usize, expected: i32, timeout?: i64): AtomicWaitResult;
-    /** Performs a wait operation on a 64-bit integer value in memory suspending this agent if the condition is met. */
-    export function wait64(ptr: usize, expected: i64, timeout?: i64): AtomicWaitResult;
-  }
 }
 
 /** Heap memory interface. */
@@ -1880,63 +1684,6 @@ declare namespace table {
   export function copy(dest: u32, src: u32, n: u32): void;
 }
 
-declare namespace Atomics {
-  export function load<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(array: TypedArray<T>, index: i32): T;
-  export function store<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): void;
-  export function add<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function sub<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function and<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function or<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function xor<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function exchange<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function compareExchange<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    expectedValue: T,
-    replacementValue: T
-  ): T;
-  export function wait<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    value: T,
-    timeout?: i64
-  ): AtomicWaitResult;
-  export function notify<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    count?: i32
-  ): i32;
-  /** The static Atomics.isLockFree() method is used to determine whether to use locks or atomic operations. It returns true, if the given size is one of the BYTES_PER_ELEMENT */
-  export function isLockFree(size: usize): bool;
-}
-
 /** Class representing a generic, fixed-length raw binary data buffer. */
 declare class ArrayBuffer {
   /** The size, in bytes, of the array. */
@@ -2025,7 +1772,7 @@ interface ArrayBufferView {
 }
 
 /** @internal */
-declare abstract class TypedArray<T> implements ArrayBufferView {
+declare abstract class TypedArray<T> implements ArrayBufferView, Iterable<T> {
   [key: number]: T;
   /** Number of bytes per element. */
   static readonly BYTES_PER_ELEMENT: usize;
@@ -2085,6 +1832,9 @@ declare abstract class TypedArray<T> implements ArrayBufferView {
   set<U extends ArrayLike<number>>(source: U, offset?: i32): void;
   /** The toString() method returns a string representing the specified array and its elements. This method has the same algorithm as Array.prototype.toString() */
   toString(): string;
+
+  /** Returns an iterator over the typed array's values. */
+  [Symbol.iterator](): Iterator<T>;
 }
 
 /** An array of twos-complement 8-bit signed integers. */
@@ -2234,7 +1984,7 @@ declare class StaticArray<T> {
 }
 
 /** Class representing a sequence of characters. */
-declare class String {
+declare class String implements Iterable<string> {
   [key: i32]: string;
   static fromCharCode(ls: i32, hs?: i32): string;
   static fromCharCodes(arr: i32[]): string;
@@ -2242,17 +1992,18 @@ declare class String {
   static fromCodePoints(arr: i32[]): string;
   static raw(parts: TemplateStringsArray, ...args: any[]): string;
   readonly length: i32;
+  [Symbol.iterator](): Iterator<string>;
   at(index: i32): string;
   charAt(index: i32): string;
   charCodeAt(index: i32): i32;
   codePointAt(index: i32): i32;
   concat(other: string): string;
-  endsWith(other: string): bool;
+  endsWith(other: string, position?: i32): bool;
   indexOf(other: string, fromIndex?: i32): i32;
   lastIndexOf(other: string, fromIndex?: i32): i32;
   localeCompare(other: string): i32;
   includes(other: string): bool;
-  startsWith(other: string): bool;
+  startsWith(other: string, position?: i32): bool;
   substr(start: i32, length?: i32): string;
   substring(start: i32, end?: i32): string;
   trim(): string;
@@ -2319,16 +2070,9 @@ declare class Object {
   static is<T>(value1: T, value2: T): bool;
 }
 
-declare namespace performance {
-  /** Gets a high resolution timestamp measured in milliseconds. */
-  export function now(): f64;
-}
-
 declare class Date {
   /** Returns the UTC timestamp in milliseconds of the specified date. */
-  static UTC(year: i32, month: i32, day: i32, hour: i32, minute: i32, second: i32, millisecond: i32): i64;
-  /** Returns the current UTC timestamp in milliseconds. */
-  static now(): i64;
+  static UTC(year: i32, month?: i32, day?: i32, hour?: i32, minute?: i32, second?: i32, millisecond?: i32): i64;
   /** Parses a string representation of a date, and returns the number of milliseconds since January 1, 1970, 00:00:00 UTC. */
   static parse(dateString: string): Date;
   static fromString(dateString: string): Date;
@@ -2396,6 +2140,8 @@ declare class URIError extends Error {}
 interface Function {
   /** Function table index. */
   readonly index: u32;
+  /** Function closure environment pointer. */
+  readonly env: usize;
   /** Function name. Always an empty string. */
   readonly name: string;
   /** Number of expected parameters. */
@@ -2511,6 +2257,7 @@ declare class Map<K, V> {
   keys(): K[]; // preliminary
   values(): V[]; // preliminary
   toString(): string;
+  [Symbol.iterator](): Iterator<[K, V]>;
 }
 
 declare class Set<K> {
@@ -2665,15 +2412,13 @@ interface INativeMath<T> extends IMath<T> {
   exp2(x: T): T;
 }
 
-/** Double precision math imported from JavaScript. */
-declare const JSMath: IMath<f64>;
 /** Double precision math implemented natively. */
 declare const NativeMath: INativeMath<f64>;
 /** Single precision math implemented natively. */
 declare const NativeMathf: INativeMath<f32>;
-/** Alias of {@link NativeMath} or {@link JSMath} respectively. Defaults to `NativeMath`. */
+/** Alias of {@link NativeMath}. */
 declare const Math: IMath<f64>;
-/** Alias of {@link NativeMathf} or {@link JSMath} respectively. Defaults to `NativeMathf`. */
+/** Alias of {@link NativeMathf}. */
 declare const Mathf: IMath<f32>;
 
 /** Environmental abort function. */
@@ -2685,69 +2430,10 @@ declare function seed(): f64;
 
 /** Node-like process. */
 declare namespace process {
-  /** String representing the CPU architecture for which the binary was compiled. Either `wasm32` or `wasm64`. */
+  /** String representing the CPU architecture for which the binary was compiled. Always `wasm32`. */
   export const arch: string;
   /** String representing the operating system platform for which the binary was compiled. Always `wasm`. */
   export const platform: string;
-  /** Array of command line arguments passed to the binary upon instantiation. */
-  export const argv: string[];
-  /** Map of variables in the binary's user environment. */
-  export const env: Map<string, string>;
-  /** Terminates the process with either the given exit code, or `process.exitCode` if omitted. */
-  export function exit(code?: i32): void;
-  /** `exit()`’s default value. Defaults to `0`. */
-  export let exitCode: i32;
-  /** Stream connected to `stdin` (fd `0`). */
-  export const stdin: ReadableStream;
-  /** Stream connected to `stdout` (fd `1`). */
-  export const stdout: WritableStream;
-  /** Stream connected to `stderr` (fd `2`). */
-  export const stderr: WritableStream;
-  /** Obtains the system's current time of day, in milliseconds since Unix epoch. */
-  export function time(): i64;
-  /** Obtains the system's monotonic high resolution time, in nanoseconds since an arbitrary time in the past. */
-  export function hrtime(): u64;
-
-  interface Stream {
-    /** Closes the stream. Throws if already closed or if the stream cannot be closed. */
-    close(): void;
-  }
-  interface ReadableStream extends Stream {
-    /** Reads available data from the stream, into `buffer` at offset `offset`, returning the number of bytes read. */
-    read(buffer: ArrayBuffer, offset?: isize): i32;
-  }
-  interface WritableStream extends Stream {
-    /** Writes string or buffer to the stream. */
-    write<T extends string | ArrayBuffer>(data: T): void;
-  }
-}
-
-/** Browser-like console. */
-declare namespace console {
-  /** Logs `message` to console if `assertion` is false-ish. */
-  export function assert<T>(assertion: T, message?: string): void;
-  /** Outputs `message` to the console. */
-  export function log(message?: string): void;
-  /** Outputs `message` to the console, prefixed with "Debug:". */
-  export function debug(message?: string): void;
-  /** Outputs `message` to the console, prefixed with "Info:". */
-  export function info(message?: string): void;
-  /** Outputs `message` to the console, prefixed with "Warning:". */
-  export function warn(message?: string): void;
-  /** Outputs `message` to the console, prefixed with "Error:". */
-  export function error(message?: string): void;
-  /** Starts a new timer using the specified `label`. */
-  export function time(label?: string): void;
-  /** Logs the current value of a timer previously started with `console.time`. */
-  export function timeLog(label?: string): void;
-  /** Logs the current value of a timer previously started with `console.time` and discards the timer. */
-  export function timeEnd(label?: string): void;
-}
-
-/** Browser-like crypto utilities. */
-declare namespace crypto {
-  /** Fills `array` with cryptographically strong random values. */
-  export function getRandomValues(array: Uint8Array): void;
 }
 
 // Decorators

package/types/std/package.json

@@ -0,0 +1,3 @@
+{
+  "types": "index.d.ts"
+}

package/types/std/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../tsconfig-std.json",
+  "include": ["./**/*.ts"]
+}

package/types/tsconfig-base.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "allowJs": false,
+    "alwaysStrict": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noEmitOnError": true,
+    "strictNullChecks": true,
+    "experimentalDecorators": true,
+    "preserveConstEnums": false,
+    "downlevelIteration": true
+  }
+}

package/types/tsconfig-std.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig-base.json",
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "noLib": true,
+    "typeRoots": ["."],
+    "types": ["std"],
+    "paths": {
+      "*": ["../assemblyscript/std/assembly/*"]
+    }
+  }
+}