warpo 3.2.2 → 3.4.0

package/asconfig.schema.json

@@ -89,7 +89,15 @@
           "items": {
             "type": "string",
             "description": "Name of a feature to disable.",
-            "enum": ["mutable-globals", "sign-extension", "nontrapping-f2i", "bulk-memory", "multi-value", "tail-call"]
+            "enum": [
+              "mutable-globals",
+              "sign-extension",
+              "nontrapping-f2i",
+              "bulk-memory",
+              "multi-value",
+              "tail-call",
+              "return-to-br"
+            ]
           }
         },
         "enable": {
@@ -98,7 +106,15 @@
           "items": {
             "type": "string",
             "description": "Name of a feature to enable.",
-            "enum": ["mutable-globals", "sign-extension", "nontrapping-f2i", "bulk-memory", "multi-value", "tail-call"]
+            "enum": [
+              "mutable-globals",
+              "sign-extension",
+              "nontrapping-f2i",
+              "bulk-memory",
+              "multi-value",
+              "tail-call",
+              "return-to-br"
+            ]
           }
         },
         "debug": {

package/assemblyscript/std/assembly/array.ts

@@ -7,6 +7,7 @@ import { REVERSE, FILL } from "./util/bytes";
 import { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from "./util/string";
 import { idof, isArray as builtin_isArray } from "./builtins";
 import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from "./util/error";
+import { ReadonlyArray } from "./readonlyarray";
 
 // @ts-ignore: decorator
 @inline @lazy const MIN_SIZE: usize = 8;
@@ -46,7 +47,7 @@ function ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: b
   }
 }
 
-export class Array<T> implements Iterable<T> {
+export class Array<T> implements ReadonlyArray<T> {
   [key: number]: T;
 
   // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code

package/assemblyscript/std/assembly/map.ts

@@ -57,6 +57,41 @@ function ENTRY_SIZE<K, V>(): usize {
   return size;
 }
 
+/**
+ * Forward-only history of entries layouts: the map keeps the latest version,
+ * while each iterator keeps the version matching its cursor. Old versions retain
+ * removed slot indices, not obsolete entries buffers or references to their contents.
+ */
+class MapIteratorVersion {
+  private nextVersion: MapIteratorVersion | null = null;
+  // For versions with a successor, null marks clear(); otherwise indices are sorted in the old layout.
+  private removedIndices: StaticArray<i32> | null = null;
+
+  transition(removedIndices: StaticArray<i32> | null): MapIteratorVersion {
+    this.removedIndices = removedIndices;
+    return (this.nextVersion = new MapIteratorVersion());
+  }
+
+  translateIndex(index: i32): i32 {
+    const removedIndices = this.removedIndices;
+    if (!removedIndices) return 0;
+    // New cursor = old cursor - number of removed slots strictly before it.
+    // A removed slot at index is unvisited and must not move the boundary backward.
+    let lower = 0;
+    let upper = removedIndices.length;
+    while (lower < upper) {
+      const middle = lower + ((upper - lower) >> 1);
+      if (unchecked(removedIndices[middle]) < index) lower = middle + 1;
+      else upper = middle;
+    }
+    return index - lower;
+  }
+
+  getNext(): MapIteratorVersion {
+    return assert(this.nextVersion);
+  }
+}
+
 // @ts-ignore: decorator
 @lazy
 const GET_START = Symbol();
@@ -65,11 +100,33 @@ const GET_START = Symbol();
 @lazy
 const GET_ENTRIES_OFFSET = Symbol();
 
+// @ts-ignore: decorator
+@lazy
+const GET_ITERATOR_VERSION = Symbol();
+
 class MapIterator<K, V> implements Iterator<[K, V]> {
+  // Next physical slot in this.version's layout, not the number of values returned.
   private i: i32 = 0;
-  constructor(private map: Map<K, V>) {}
+  private map: Map<K, V> | null;
+  private version: MapIteratorVersion | null;
+
+  constructor(map: Map<K, V>) {
+    this.map = map;
+    this.version = map[GET_ITERATOR_VERSION]();
+  }
+
   next(): IteratorResult<[K, V]> {
     const map = this.map;
+    if (!map) return IteratorResult.done<[K, V]>();
+    // Apply every missed compaction or clear before accessing the current entries buffer.
+    const currentVersion = map[GET_ITERATOR_VERSION]();
+    let version = assert(this.version);
+    while (version != currentVersion) {
+      this.i = version.translateIndex(this.i);
+      version = version.getNext();
+    }
+    this.version = version;
+
     const start = map[GET_START]();
     const size = map[GET_ENTRIES_OFFSET]();
     for (let i = this.i; i < size; ++i) {
@@ -79,6 +136,10 @@ class MapIterator<K, V> implements Iterator<[K, V]> {
         return IteratorResult.fromValue<[K, V]>([entry.key, entry.value]);
       }
     }
+    // Once done, later insertions must not revive this iterator.
+    // Release the map and any layout history still retained by this iterator.
+    this.map = null;
+    this.version = null;
     return IteratorResult.done<[K, V]>();
   }
 }
@@ -93,6 +154,8 @@ export class Map<K, V> implements Iterable<[K, V]> {
   private entriesCapacity: i32 = INITIAL_CAPACITY;
   private entriesOffset: i32 = 0;
   private entriesCount: i32 = 0;
+  // Lazy state: maps that never create iterators need no layout-change history.
+  private iteratorVersion: MapIteratorVersion | null = null;
 
   constructor() {
     /* nop */
@@ -107,6 +170,12 @@ export class Map<K, V> implements Iterable<[K, V]> {
   [GET_ENTRIES_OFFSET](): i32 {
     return this.entriesOffset;
   }
+  @inline
+  [GET_ITERATOR_VERSION](): MapIteratorVersion {
+    let iteratorVersion = this.iteratorVersion;
+    if (!iteratorVersion) this.iteratorVersion = iteratorVersion = new MapIteratorVersion();
+    return iteratorVersion;
+  }
 
   get size(): i32 {
     return this.entriesCount;
@@ -116,6 +185,9 @@ export class Map<K, V> implements Iterable<[K, V]> {
     this.buckets = new ArrayBuffer(INITIAL_CAPACITY * <i32>BUCKET_SIZE);
     this.bucketsMask = INITIAL_CAPACITY - 1;
     this.entries = new ArrayBuffer(INITIAL_CAPACITY * <i32>ENTRY_SIZE<K, V>());
+    // Live iterators must restart at entries inserted after clear(), rather than keep their old indices.
+    let iteratorVersion = this.iteratorVersion;
+    if (iteratorVersion) this.iteratorVersion = iteratorVersion.transition(null);
     this.entriesCapacity = INITIAL_CAPACITY;
     this.entriesOffset = 0;
     this.entriesCount = 0;
@@ -206,9 +278,17 @@ export class Map<K, V> implements Iterable<[K, V]> {
     let newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K, V>());
 
     // copy old entries to new entries
-    let oldPtr = changetype<usize>(this.entries);
+    let oldStart = changetype<usize>(this.entries);
+    let oldPtr = oldStart;
     let oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<K, V>();
     let newPtr = changetype<usize>(newEntries);
+    let iteratorVersion = this.iteratorVersion;
+    // Record deleted slots only if iterator state exists; growth without holes leaves indices unchanged.
+    let removedIndices: StaticArray<i32> | null =
+      iteratorVersion && this.entriesOffset != this.entriesCount
+        ? new StaticArray<i32>(this.entriesOffset - this.entriesCount)
+        : null;
+    let removedCount = 0;
     while (oldPtr != oldEnd) {
       let oldEntry = changetype<MapEntry<K, V>>(oldPtr);
       if (!(oldEntry.taggedNext & EMPTY)) {
@@ -221,6 +301,9 @@ export class Map<K, V> implements Iterable<[K, V]> {
         newEntry.taggedNext = load<usize>(newBucketPtrBase);
         store<usize>(newBucketPtrBase, newPtr);
         newPtr += ENTRY_SIZE<K, V>();
+      } else if (removedIndices) {
+        // Old slots are scanned in order, keeping the indices sorted for the lower-bound search.
+        unchecked((removedIndices[removedCount++] = <i32>((oldPtr - oldStart) / ENTRY_SIZE<K, V>())));
       }
       oldPtr += ENTRY_SIZE<K, V>();
     }
@@ -228,6 +311,7 @@ export class Map<K, V> implements Iterable<[K, V]> {
     this.buckets = newBuckets;
     this.bucketsMask = newBucketsMask;
     this.entries = newEntries;
+    if (iteratorVersion && removedIndices) this.iteratorVersion = iteratorVersion.transition(removedIndices);
     this.entriesCapacity = newEntriesCapacity;
     this.entriesOffset = this.entriesCount;
   }
@@ -276,6 +360,9 @@ export class Map<K, V> implements Iterable<[K, V]> {
 
   @unsafe private __visit(cookie: u32): void {
     __visit(changetype<usize>(this.buckets), cookie);
+    // Map uses a custom visitor, so its managed iterator-version field must be traced explicitly.
+    let iteratorVersion = this.iteratorVersion;
+    if (iteratorVersion) __visit(changetype<usize>(iteratorVersion), cookie);
     let entries = changetype<usize>(this.entries);
     if (isManaged<K>() || isManaged<V>()) {
       let cur = entries;

package/assemblyscript/std/assembly/readonlyarray.ts

@@ -0,0 +1,24 @@
+// Copyright (C) 2026 wasm-ecosystem
+// SPDX-License-Identifier: Apache-2.0
+
+import { Array } from "./array";
+
+export interface ReadonlyArray<T> extends Iterable<T> {
+  [key: i32]: T;
+  readonly length: i32;
+  at(index: i32): T;
+  findIndex(fn: (value: T, index: i32, array: ReadonlyArray<T>) => bool): i32;
+  findLastIndex(fn: (value: T, index: i32, array: ReadonlyArray<T>) => bool): i32;
+  includes(value: T, fromIndex: i32): bool;
+  indexOf(value: T, fromIndex: i32): i32;
+  lastIndexOf(value: T, fromIndex: i32): i32;
+  forEach(fn: (value: T, index: i32, array: ReadonlyArray<T>) => void): void;
+  filter(fn: (value: T, index: i32, array: ReadonlyArray<T>) => bool): Array<T>;
+  every(fn: (value: T, index: i32, array: ReadonlyArray<T>) => bool): bool;
+  some(fn: (value: T, index: i32, array: ReadonlyArray<T>) => bool): bool;
+  concat(other: Array<T>): Array<T>;
+  slice(start: i32, end: i32): Array<T>;
+  join(separator: string): string;
+  flat(): T;
+  toString(): string;
+}

package/assemblyscript/std/assembly/string.ts

@@ -207,10 +207,10 @@ class StringIterator implements Iterator<string> {
 
   indexOf(search: String, start: i32 = 0): i32 {
     let searchLen = <isize>search.length;
-    if (!searchLen) return 0;
     let len = <isize>this.length;
-    if (!len) return -1;
     let searchStart = min(max(<isize>start, 0), len);
+    if (!searchLen) return <i32>searchStart;
+    if (!len) return -1;
     for (len -= searchLen; searchStart <= len; ++searchStart) {
       // @ts-ignore: string <-> String
       if (!compareImpl(this, searchStart, search, 0, searchLen)) return <i32>searchStart;
@@ -456,8 +456,9 @@ class StringIterator implements Iterator<string> {
     while (~(next = <isize>this.indexOf(search, <i32>prev))) {
       if (!out) out = changetype<String>(__new(thisLen << 1, idof<String>()));
       let chunk = next - prev;
-      if (offset + chunk + replaceLen > outSize) {
-        outSize <<= 1;
+      let requiredSize = offset + chunk + replaceLen;
+      if (requiredSize > outSize) {
+        outSize = max(outSize << 1, requiredSize);
         out = changetype<String>(__renew(changetype<usize>(out), outSize << 1));
       }
       memory.copy(changetype<usize>(out) + (offset << 1), changetype<usize>(this) + (prev << 1), chunk << 1);
@@ -468,8 +469,9 @@ class StringIterator implements Iterator<string> {
     }
     if (out) {
       let rest = thisLen - prev;
-      if (offset + rest > outSize) {
-        outSize <<= 1;
+      let requiredSize = offset + rest;
+      if (requiredSize > outSize) {
+        outSize = max(outSize << 1, requiredSize);
         out = changetype<String>(__renew(changetype<usize>(out), outSize << 1));
       }
       if (rest) {
@@ -886,7 +888,3 @@ export namespace String {
     }
   }
 }
-
-export class TemplateStringsArray extends Array<string> {
-  readonly raw: string[];
-}

package/assemblyscript/std/assembly/templatestringsarray.ts

@@ -0,0 +1,113 @@
+// Copyright (C) 2026 wasm-ecosystem
+// SPDX-License-Identifier: Apache-2.0
+
+import { Array } from "./array";
+import { ReadonlyArray } from "./readonlyarray";
+
+export class TemplateStringsArray implements ReadonlyArray<string> {
+  [key: i32]: string;
+
+  private values: Array<string>;
+  readonly raw: ReadonlyArray<string>;
+
+  constructor(values: Array<string>, raw: ReadonlyArray<string>) {
+    this.values = values;
+    this.raw = raw;
+  }
+
+
+  @operator("[]") private __get(index: i32): string {
+    return this.values[index];
+  }
+
+
+  @unsafe @operator("{}") private __uget(index: i32): string {
+    return unchecked(this.values[index]);
+  }
+
+  get length(): i32 {
+    return this.values.length;
+  }
+
+  at(index: i32): string {
+    return this.values.at(index);
+  }
+
+  findIndex(fn: (value: string, index: i32, array: ReadonlyArray<string>) => bool): i32 {
+    return this.values.findIndex(fn);
+  }
+
+  findLastIndex(fn: (value: string, index: i32, array: ReadonlyArray<string>) => bool): i32 {
+    return this.values.findLastIndex(fn);
+  }
+
+  includes(value: string, fromIndex: i32 = 0): bool {
+    return this.values.includes(value, fromIndex);
+  }
+
+  indexOf(value: string, fromIndex: i32 = 0): i32 {
+    return this.values.indexOf(value, fromIndex);
+  }
+
+  lastIndexOf(value: string, fromIndex: i32 = i32.MAX_VALUE): i32 {
+    return this.values.lastIndexOf(value, fromIndex);
+  }
+
+  forEach(fn: (value: string, index: i32, array: ReadonlyArray<string>) => void): void {
+    this.values.forEach(fn);
+  }
+
+  map<U>(fn: (value: string, index: i32, array: ReadonlyArray<string>) => U): Array<U> {
+    return this.values.map<U>(fn);
+  }
+
+  filter(fn: (value: string, index: i32, array: ReadonlyArray<string>) => bool): Array<string> {
+    return this.values.filter(fn);
+  }
+
+  reduce<U>(
+    fn: (previousValue: U, currentValue: string, currentIndex: i32, array: ReadonlyArray<string>) => U,
+    initialValue: U
+  ): U {
+    return this.values.reduce<U>(fn, initialValue);
+  }
+
+  reduceRight<U>(
+    fn: (previousValue: U, currentValue: string, currentIndex: i32, array: ReadonlyArray<string>) => U,
+    initialValue: U
+  ): U {
+    return this.values.reduceRight<U>(fn, initialValue);
+  }
+
+  every(fn: (value: string, index: i32, array: ReadonlyArray<string>) => bool): bool {
+    return this.values.every(fn);
+  }
+
+  some(fn: (value: string, index: i32, array: ReadonlyArray<string>) => bool): bool {
+    return this.values.some(fn);
+  }
+
+  concat(other: Array<string>): Array<string> {
+    return this.values.concat(other);
+  }
+
+  slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array<string> {
+    return this.values.slice(start, end);
+  }
+
+  join(separator: string = ","): string {
+    return this.values.join(separator);
+  }
+
+  flat(): string {
+    return this.values.flat();
+  }
+
+  toString(): string {
+    return this.values.toString();
+  }
+
+  [Symbol.iterator](): Iterator<string> {
+    return this.values[Symbol.iterator]();
+  }
+}

package/assemblyscript/std/assembly/typedarray.ts

@@ -1679,7 +1679,7 @@ function COPY_WITHIN<TArray extends ArrayBufferView, T extends number>(
   let to    = target < 0 ? max(len + target, 0) : min(target, len);
   let from  = start < 0 ? max(len + start, 0) : min(start, len);
   let last  = end < 0 ? max(len + end, 0) : min(end, len);
-  let count = min(last - from, len - to);
+  let count = max(min(last - from, len - to), 0);
 
   memory.copy(
     ptr + (<usize>to << alignof<T>()),
@@ -1908,7 +1908,7 @@ function WRAP<TArray extends ArrayBufferView, T>(
   byteOffset: i32 = 0,
   len: i32 = -1
 ): TArray {
-  let byteLength: i32;
+  let byteLength: usize;
   let bufferByteLength = buffer.byteLength;
   const mask: u32 = sizeof<T>() - 1;
   if (i32(<u32>byteOffset > <u32>bufferByteLength) | (byteOffset & mask)) {
@@ -1924,8 +1924,8 @@ function WRAP<TArray extends ArrayBufferView, T>(
       throw new RangeError(E_INVALIDLENGTH);
     }
   } else {
-    byteLength = len << alignof<T>();
-    if (byteOffset + byteLength > bufferByteLength) {
+    byteLength = <usize>len << alignof<T>();
+    if (<usize>byteOffset + byteLength > <usize>bufferByteLength) {
       throw new RangeError(E_INVALIDLENGTH);
     }
   }
@@ -1952,7 +1952,7 @@ function SET<
     ERROR(E_NOTIMPLEMENTED);
   }
   let sourceLen = source.length;
-  if (offset < 0 || sourceLen + offset > target.length) {
+  if (offset < 0 || <usize>offset + <usize>sourceLen > <usize>target.length) {
     // offset is out of bounds
     throw new RangeError(E_INDEXOUTOFRANGE);
   }

package/create/resolveModule.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import * as api from "./__warpo_create";
+import { memory_expose } from "warpo/memory";
 
 export class ModuleResolve {
   packageName!: string;
@@ -13,5 +14,6 @@ export class ModuleResolve {
 
 export type Fn = (task: ModuleResolve) => void;
 export function onModuleResolve(fn: Fn): void {
+  memory_expose<ModuleResolve>();
   api.onModuleResolve(fn.index, idof<ModuleResolve>());
 }

package/dist/debug_server/debugSession.d.ts

@@ -7,6 +7,7 @@ interface WarpoLaunchRequestArguments extends DebugProtocol.LaunchRequestArgumen
     entryFunctionName?: string;
     cwd?: string;
     warpoPath?: string;
+    testNamePattern?: string;
     debugSessionLogging?: boolean;
     debugSessionLogFile?: string;
     args?: number[];

package/dist/debug_server/debugSession.js

@@ -255,6 +255,7 @@ export class WarpoDebugSession extends LoggingDebugSession {
                         wasmFilePath,
                         cwd,
                         warpoPath: args.warpoPath,
+                        testNamePattern: args.testNamePattern,
                     }
                     : {
                         wasmFilePath,