expo 55.0.28 → 55.0.29

package/android/build.gradle

@@ -10,7 +10,7 @@ buildscript {
 }
 
 group = 'host.exp.exponent'
-version = '55.0.28'
+version = '55.0.29'
 
 expoModule {
   // We can't prebuild the module because it depends on the generated files.
@@ -21,7 +21,7 @@ android {
   namespace "expo.core"
   defaultConfig {
     versionCode 1
-    versionName "55.0.28"
+    versionName "55.0.29"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {

package/android/src/main/java/expo/modules/fetch/NativeResponse.kt

@@ -8,7 +8,9 @@ import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.sharedobjects.SharedObject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import okhttp3.Call
 import okhttp3.Callback
 import okhttp3.Response
@@ -138,10 +140,17 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
     responseInit = createResponseInit(response)
     state = ResponseState.RESPONSE_RECEIVED
 
-    coroutineScope.launch(Dispatchers.IO) {
+    coroutineScope.launch {
       val stream = response.body?.source() ?: return@launch
-      pumpResponseBodyStream(stream)
-      response.close()
+      try {
+        pumpResponseBodyStream(stream)
+      } finally {
+        // Close off the modules queue so the blocking call doesn't stall it.
+        // NonCancellable guarantees the response is released even if the scope is canceled mid-stream.
+        withContext(NonCancellable + Dispatchers.IO) {
+          response.close()
+        }
+      }
 
       if (this@NativeResponse.state == ResponseState.BODY_STREAMING_STARTED) {
         emit("didComplete")
@@ -182,9 +191,13 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
     )
   }
 
-  private fun pumpResponseBodyStream(stream: BufferedSource) {
+  private suspend fun pumpResponseBodyStream(stream: BufferedSource) {
     try {
-      while (!stream.exhausted()) {
+      while (true) {
+        val data = withContext(Dispatchers.IO) {
+          if (stream.exhausted()) null else stream.buffer.readByteArray()
+        } ?: break
+
         if (isInvalidState(
             ResponseState.RESPONSE_RECEIVED,
             ResponseState.BODY_STREAMING_STARTED,
@@ -194,9 +207,9 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
           break
         }
         if (state == ResponseState.RESPONSE_RECEIVED) {
-          sink.appendBufferBody(stream.buffer.readByteArray())
+          sink.appendBufferBody(data)
         } else if (state == ResponseState.BODY_STREAMING_STARTED) {
-          emit("didReceiveResponseData", stream.buffer.readByteArray())
+          emit("didReceiveResponseData", data)
         } else {
           break
         }

package/build/winter/TextDecoder.d.ts

@@ -1,10 +1,5 @@
 export declare class TextDecoder {
-    private _encoding;
-    private _ignoreBOM;
-    private _errorMode;
-    private _BOMseen;
-    private _doNotFlush;
-    private _decoder;
+    private readonly _state;
     constructor(label?: string, options?: {
         fatal?: boolean;
         ignoreBOM?: boolean;
@@ -12,9 +7,8 @@ export declare class TextDecoder {
     get encoding(): string;
     get fatal(): boolean;
     get ignoreBOM(): boolean;
-    decode(input?: ArrayBuffer | DataView, options?: {
+    decode(input?: ArrayBuffer | ArrayBufferView, options?: {
         stream?: boolean;
     }): string;
-    private serializeStream;
 }
 //# sourceMappingURL=TextDecoder.d.ts.map

package/build/winter/TextDecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextDecoder.d.ts","sourceRoot":"","sources":["../../src/winter/TextDecoder.ts"],"names":[],"mappings":"AAwTA,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAA4B;gBAG1C,KAAK,GAAE,MAAgB,EACvB,OAAO,GAAE;QACP,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB;IAwBR,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,MAAM,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,EAAE,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM;IAqDlF,OAAO,CAAC,eAAe;CAcxB"}
+{"version":3,"file":"TextDecoder.d.ts","sourceRoot":"","sources":["../../src/winter/TextDecoder.ts"],"names":[],"mappings":"AAqXA,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;gBAE9B,KAAK,GAAE,MAAgB,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO;IAgB3F,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,MAAM,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,eAAe,EAAE,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM;CAsB1F"}

package/bundledNativeModules.json

@@ -16,84 +16,84 @@
   "expo-analytics-amplitude": "~11.3.0",
   "expo-app-auth": "~11.1.0",
   "expo-app-loader-provider": "~8.0.0",
-  "expo-app-metrics": "~0.2.4",
-  "expo-apple-authentication": "~55.0.15",
-  "expo-application": "~55.0.17",
-  "expo-asset": "~55.0.18",
-  "expo-audio": "~55.0.16",
-  "expo-auth-session": "~55.0.17",
-  "expo-background-fetch": "~55.0.18",
-  "expo-background-task": "~55.0.20",
-  "expo-battery": "~55.0.15",
-  "expo-blur": "~55.0.16",
-  "expo-brightness": "~55.0.15",
-  "expo-brownfield": "~55.0.26",
-  "expo-build-properties": "~55.0.16",
-  "expo-calendar": "~55.0.17",
-  "expo-camera": "~55.0.21",
-  "expo-cellular": "~55.0.15",
+  "expo-app-metrics": "~0.2.5",
+  "expo-apple-authentication": "~55.0.16",
+  "expo-application": "~55.0.18",
+  "expo-asset": "~55.0.19",
+  "expo-audio": "~55.0.17",
+  "expo-auth-session": "~55.0.18",
+  "expo-background-fetch": "~55.0.19",
+  "expo-background-task": "~55.0.21",
+  "expo-battery": "~55.0.16",
+  "expo-blur": "~55.0.17",
+  "expo-brightness": "~55.0.16",
+  "expo-brownfield": "~55.0.27",
+  "expo-build-properties": "~55.0.17",
+  "expo-calendar": "~55.0.18",
+  "expo-camera": "~55.0.22",
+  "expo-cellular": "~55.0.16",
   "expo-checkbox": "~55.0.4",
-  "expo-clipboard": "~55.0.15",
+  "expo-clipboard": "~55.0.16",
   "expo-constants": "~55.0.17",
-  "expo-contacts": "~55.0.16",
-  "expo-crypto": "~55.0.17",
-  "expo-dev-client": "~55.0.37",
-  "expo-device": "~55.0.19",
-  "expo-document-picker": "~55.0.15",
-  "expo-file-system": "~55.0.24",
+  "expo-contacts": "~55.0.17",
+  "expo-crypto": "~55.0.18",
+  "expo-dev-client": "~55.0.38",
+  "expo-device": "~55.0.20",
+  "expo-document-picker": "~55.0.16",
+  "expo-file-system": "~55.0.25",
   "expo-font": "~55.0.8",
-  "expo-gl": "~55.0.16",
+  "expo-gl": "~55.0.17",
   "expo-glass-effect": "~55.0.11",
   "expo-google-app-auth": "~8.3.0",
-  "expo-haptics": "~55.0.16",
+  "expo-haptics": "~55.0.17",
   "expo-image": "~55.0.11",
   "expo-image-loader": "~55.0.1",
-  "expo-image-manipulator": "~55.0.19",
-  "expo-image-picker": "~55.0.22",
-  "expo-intent-launcher": "~55.0.14",
-  "expo-insights": "~55.0.19",
+  "expo-image-manipulator": "~55.0.20",
+  "expo-image-picker": "~55.0.23",
+  "expo-intent-launcher": "~55.0.15",
+  "expo-insights": "~55.0.20",
   "expo-keep-awake": "~55.0.8",
-  "expo-linear-gradient": "~55.0.16",
-  "expo-linking": "~55.0.16",
-  "expo-local-authentication": "~55.0.16",
-  "expo-localization": "~55.0.17",
-  "expo-location": "~55.1.12",
-  "expo-mail-composer": "~55.0.16",
-  "expo-manifests": "~55.0.19",
-  "expo-maps": "~55.0.21",
+  "expo-linear-gradient": "~55.0.17",
+  "expo-linking": "~55.0.17",
+  "expo-local-authentication": "~55.0.17",
+  "expo-localization": "~55.0.18",
+  "expo-location": "~55.1.13",
+  "expo-mail-composer": "~55.0.17",
+  "expo-manifests": "~55.0.20",
+  "expo-maps": "~55.0.22",
   "expo-mcp": "~0.2.1",
-  "expo-media-library": "~55.0.19",
-  "expo-mesh-gradient": "~55.0.16",
-  "expo-module-template": "~55.0.23",
+  "expo-media-library": "~55.0.20",
+  "expo-mesh-gradient": "~55.0.17",
+  "expo-module-template": "~55.0.24",
   "expo-modules-core": "~55.0.25",
-  "expo-navigation-bar": "~55.0.15",
-  "expo-network": "~55.0.16",
-  "expo-notifications": "~55.0.25",
-  "expo-observe": "~0.2.4",
-  "expo-print": "~55.0.17",
-  "expo-live-photo": "~55.0.17",
-  "expo-router": "~55.0.17",
-  "expo-screen-capture": "~55.0.16",
-  "expo-screen-orientation": "~55.0.18",
-  "expo-secure-store": "~55.0.16",
-  "expo-sensors": "~55.0.17",
-  "expo-server": "~55.0.11",
-  "expo-sharing": "~55.0.22",
-  "expo-sms": "~55.0.16",
-  "expo-speech": "~55.0.16",
-  "expo-splash-screen": "~55.0.23",
-  "expo-sqlite": "~55.0.18",
+  "expo-navigation-bar": "~55.0.16",
+  "expo-network": "~55.0.17",
+  "expo-notifications": "~55.0.26",
+  "expo-observe": "~0.2.5",
+  "expo-print": "~55.0.18",
+  "expo-live-photo": "~55.0.18",
+  "expo-router": "~55.0.18",
+  "expo-screen-capture": "~55.0.17",
+  "expo-screen-orientation": "~55.0.19",
+  "expo-secure-store": "~55.0.17",
+  "expo-sensors": "~55.0.18",
+  "expo-server": "~55.0.12",
+  "expo-sharing": "~55.0.23",
+  "expo-sms": "~55.0.17",
+  "expo-speech": "~55.0.17",
+  "expo-splash-screen": "~55.0.24",
+  "expo-sqlite": "~55.0.19",
   "expo-status-bar": "~55.0.6",
-  "expo-store-review": "~55.0.16",
+  "expo-store-review": "~55.0.17",
   "expo-symbols": "~55.0.9",
-  "expo-system-ui": "~55.0.20",
-  "expo-task-manager": "~55.0.18",
-  "expo-tracking-transparency": "~55.0.16",
-  "expo-updates": "~55.0.26",
-  "expo-video-thumbnails": "~55.0.17",
-  "expo-video": "~55.0.19",
-  "expo-web-browser": "~55.0.18",
-  "jest-expo": "~55.0.20",
+  "expo-system-ui": "~55.0.21",
+  "expo-task-manager": "~55.0.19",
+  "expo-tracking-transparency": "~55.0.17",
+  "expo-updates": "~55.0.27",
+  "expo-video-thumbnails": "~55.0.18",
+  "expo-video": "~55.0.20",
+  "expo-web-browser": "~55.0.19",
+  "jest-expo": "~55.0.21",
   "lottie-react-native": "~7.3.4",
   "react": "19.2.0",
   "react-dom": "19.2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo",
-  "version": "55.0.28",
+  "version": "55.0.29",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -77,24 +77,24 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "55.0.34",
-    "@expo/config": "~55.0.19",
+    "@expo/cli": "55.0.35",
+    "@expo/config": "~55.0.20",
     "@expo/config-plugins": "~55.0.11",
     "@expo/devtools": "55.0.3",
     "@expo/fingerprint": "0.16.8",
     "@expo/local-build-cache-provider": "55.0.15",
     "@expo/log-box": "55.0.13",
     "@expo/metro": "~55.1.1",
-    "@expo/metro-config": "55.0.25",
+    "@expo/metro-config": "55.0.26",
     "@expo/vector-icons": "^15.0.2",
     "@ungap/structured-clone": "^1.3.0",
     "babel-preset-expo": "~55.0.24",
-    "expo-asset": "~55.0.18",
+    "expo-asset": "~55.0.19",
     "expo-constants": "~55.0.17",
-    "expo-file-system": "~55.0.24",
+    "expo-file-system": "~55.0.25",
     "expo-font": "~55.0.8",
     "expo-keep-awake": "~55.0.8",
-    "expo-modules-autolinking": "55.0.25",
+    "expo-modules-autolinking": "55.0.26",
     "expo-modules-core": "55.0.25",
     "pretty-format": "^29.7.0",
     "react-refresh": "^0.14.2",
@@ -130,5 +130,5 @@
       "optional": true
     }
   },
-  "gitHead": "c8f16914a2713c37fe446c46d613004626b3e6b3"
+  "gitHead": "764641f87074c1e49d004790c5a5983f4b5bfc6b"
 }

package/src/winter/TextDecoder.ts

@@ -1,429 +1,427 @@
-// A fork of text-encoding but with only UTF-8 decoder.
-// `TextEncoder` is in Hermes and we only need utf-8 decoder for React Server Components.
-//
-// https://github.com/inexorabletash/text-encoding/blob/3f330964c0e97e1ed344c2a3e963f4598610a7ad/lib/encoding.js#L1
+// UTF-8-only TextDecoder fallback for runtimes that do not provide one.
 
-/**
- * Checks if a number is within a specified range.
- * @param a The number to test.
- * @param min The minimum value in the range, inclusive.
- * @param max The maximum value in the range, inclusive.
- * @returns `true` if a passed number is within the specified range.
- */
-function inRange(a: number, min: number, max: number): boolean {
-  return min <= a && a <= max;
+const EMPTY_BYTES = new Uint8Array(0);
+
+interface TextDecoderState {
+  ignoreBOM: boolean;
+  fatal: boolean;
+  bomSeen: boolean;
+  pending: Uint8Array;
+  streaming: boolean;
 }
 
-/**
- * Converts an array of code points to a string.
- * @param codePoints Array of code points.
- * @returns The string representation of given array.
- */
-function codePointsToString(codePoints: number[]): string {
-  let s = '';
-  for (let i = 0; i < codePoints.length; ++i) {
-    let cp = codePoints[i];
-    if (cp <= 0xffff) {
-      s += String.fromCharCode(cp);
-    } else {
-      cp -= 0x10000;
-      s += String.fromCharCode((cp >> 10) + 0xd800, (cp & 0x3ff) + 0xdc00);
-    }
+function assertValidUTF8Label(label: unknown): void {
+  const normalizedLabel = String(label).trim().toLowerCase();
+  switch (normalizedLabel) {
+    case 'unicode-1-1-utf-8':
+    case 'unicode11utf8':
+    case 'unicode20utf8':
+    case 'utf-8':
+    case 'utf8':
+    case 'x-unicode20utf8':
+      return;
+    default:
+      throw new RangeError(`Unknown encoding: ${label} (normalized: ${normalizedLabel})`);
   }
-  return s;
 }
 
-function normalizeBytes(input?: ArrayBuffer | DataView): Uint8Array {
-  if (typeof input === 'object' && input instanceof ArrayBuffer) {
-    return new Uint8Array(input);
+function normalizeBytes(input: ArrayBuffer | ArrayBufferView | undefined): Uint8Array {
+  if (input === undefined) {
+    return EMPTY_BYTES;
+  } else if (input instanceof Uint8Array) {
+    return input;
+  } else if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
   } else if (
-    typeof input === 'object' &&
-    'buffer' in input &&
-    input.buffer instanceof ArrayBuffer
+    (input[Symbol.toStringTag] as string) === 'ArrayBuffer' ||
+    (input[Symbol.toStringTag] as string) === 'SharedArrayBuffer'
   ) {
-    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    return new Uint8Array(input as ArrayBuffer);
+  } else {
+    throw new TypeError('The input must be an ArrayBuffer or ArrayBufferView');
   }
-  return new Uint8Array(0);
 }
 
-/**
- * End-of-stream is a special token that signifies no more tokens
- * are in the stream.
- */
-const END_OF_STREAM = -1;
-
-const FINISHED = -1;
-
-/**
- * A stream represents an ordered sequence of tokens.
- *
- * @constructor
- * @param {!(number[]|Uint8Array)} tokens Array of tokens that provide the stream.
- */
-class Stream {
-  private tokens: number[];
-
-  constructor(tokens: number[] | Uint8Array) {
-    this.tokens = Array.prototype.slice.call(tokens);
-    // Reversed as push/pop is more efficient than shift/unshift.
-    this.tokens.reverse();
-  }
-
-  /**
-   * @return {boolean} True if end-of-stream has been hit.
-   */
-  endOfStream(): boolean {
-    return !this.tokens.length;
-  }
-
-  /**
-   * When a token is read from a stream, the first token in the
-   * stream must be returned and subsequently removed, and
-   * end-of-stream must be returned otherwise.
-   *
-   * @return {number} Get the next token from the stream, or
-   * end_of_stream.
-   */
-  read(): number {
-    if (!this.tokens.length) return END_OF_STREAM;
-    return this.tokens.pop()!;
+function decoderError(state: TextDecoderState): string {
+  if (state.fatal) {
+    throw new TypeError('Decoder error');
   }
+  return '\ufffd';
+}
 
-  /**
-   * When one or more tokens are prepended to a stream, those tokens
-   * must be inserted, in given order, before the first token in the
-   * stream.
-   *
-   * @param token The token(s) to prepend to the stream.
-   */
-  prepend(token: number | number[]): void {
-    if (Array.isArray(token)) {
-      while (token.length) this.tokens.push(token.pop()!);
-    } else {
-      this.tokens.push(token);
-    }
-  }
-
-  /**
-   * When one or more tokens are pushed to a stream, those tokens
-   * must be inserted, in given order, after the last token in the
-   * stream.
-   *
-   * @param token The tokens(s) to push to the stream.
-   */
-  push(token: number | number[]): void {
-    if (Array.isArray(token)) {
-      while (token.length) this.tokens.unshift(token.shift()!);
-    } else {
-      this.tokens.unshift(token);
-    }
+function appendASCII(output: string, bytes: Uint8Array, start: number, end: number): string {
+  // NOTE(@kitten): For longer strings, direct `apply` + `subarray` conversion w/o byte-for-byte copy or spreads is
+  // the most efficient by far (3x), leaning on native conversion below the variadic limit
+  const HERMES_VARIADIC_ARGUMENT_LIMIT = 4096;
+  while (start < end) {
+    output += String.fromCharCode.apply(
+      null,
+      bytes.subarray(
+        start,
+        Math.min(start + HERMES_VARIADIC_ARGUMENT_LIMIT, end)
+      ) as unknown as number[]
+    );
+    start += HERMES_VARIADIC_ARGUMENT_LIMIT;
   }
+  return output;
 }
 
-function decoderError(fatal: boolean, opt_code_point?: number) {
-  if (fatal) throw TypeError('Decoder error');
-  return opt_code_point || 0xfffd;
+interface DecodeFallback {
+  output: string;
+  index: number;
 }
 
-interface Encoding {
-  name: string;
-  labels: string[];
+function fallback(output: string, index: number): DecodeFallback {
+  return { output, index };
 }
 
-const LABEL_ENCODING_MAP: { [key: string]: Encoding } = {};
-
-function getEncoding(label: string): Encoding | null {
-  label = label.trim().toLowerCase();
-  if (label in LABEL_ENCODING_MAP) {
-    return LABEL_ENCODING_MAP[label];
+function decodeUTF8Fast(bytes: Uint8Array, start: number): string | DecodeFallback {
+  let output = '';
+  let i = start;
+  const length = bytes.length;
+  while (i < length) {
+    const b0 = bytes[i]!;
+    if (b0 < 0x80) {
+      // NOTE(@kitten): For ASCII text, it's fastest to process the first 32 chars directly
+      // After, `appendASCII`'s variadic apply wins out
+      const directEnd = Math.min(i + 32, length);
+      do {
+        output += String.fromCharCode(bytes[i++]!);
+      } while (i < directEnd && bytes[i]! < 0x80);
+      if (i === directEnd && i < length && bytes[i]! < 0x80) {
+        const asciiStart = i;
+        do {
+          i++;
+        } while (i < length && bytes[i]! < 0x80);
+        output = appendASCII(output, bytes, asciiStart, i);
+      }
+    } else if (b0 >= 0xc2 && b0 <= 0xdf) {
+      if (i + 1 >= length) return fallback(output, i);
+      const b1 = bytes[i + 1]!;
+      if ((b1 & 0xc0) !== 0x80) return fallback(output, i);
+      output += String.fromCharCode(((b0 & 0x1f) << 6) | (b1 & 0x3f));
+      i += 2;
+    } else if (b0 >= 0xe0 && b0 <= 0xef) {
+      if (i + 2 >= length) return fallback(output, i);
+      const b1 = bytes[i + 1]!;
+      const b2 = bytes[i + 2]!;
+      if (
+        b1 < (b0 === 0xe0 ? 0xa0 : 0x80) ||
+        b1 > (b0 === 0xed ? 0x9f : 0xbf) ||
+        (b2 & 0xc0) !== 0x80
+      ) {
+        return fallback(output, i);
+      }
+      output += String.fromCharCode(((b0 & 0x0f) << 12) | ((b1 & 0x3f) << 6) | (b2 & 0x3f));
+      i += 3;
+    } else if (b0 >= 0xf0 && b0 <= 0xf4) {
+      if (i + 3 >= length) return fallback(output, i);
+      const b1 = bytes[i + 1]!;
+      const b2 = bytes[i + 2]!;
+      const b3 = bytes[i + 3]!;
+      if (
+        b1 < (b0 === 0xf0 ? 0x90 : 0x80) ||
+        b1 > (b0 === 0xf4 ? 0x8f : 0xbf) ||
+        (b2 & 0xc0) !== 0x80 ||
+        (b3 & 0xc0) !== 0x80
+      ) {
+        return fallback(output, i);
+      }
+      const codePoint =
+        (((b0 & 0x07) << 18) | ((b1 & 0x3f) << 12) | ((b2 & 0x3f) << 6) | (b3 & 0x3f)) - 0x10000;
+      output += String.fromCharCode((codePoint >> 10) + 0xd800, (codePoint & 0x3ff) + 0xdc00);
+      i += 4;
+    } else {
+      return fallback(output, i);
+    }
   }
-  return null;
-}
-
-/** [Encodings table](https://encoding.spec.whatwg.org/encodings.json) (Incomplete as we only need TextDecoder utf8 in Expo RSC. A more complete implementation should be added to Hermes as native code.) */
-const ENCODING_MAP: { heading: string; encodings: Encoding[] }[] = [
-  {
-    encodings: [
-      {
-        labels: [
-          'unicode-1-1-utf-8',
-          'unicode11utf8',
-          'unicode20utf8',
-          'utf-8',
-          'utf8',
-          'x-unicode20utf8',
-        ],
-        name: 'UTF-8',
-      },
-    ],
-    heading: 'The Encoding',
-  },
-];
 
-ENCODING_MAP.forEach((category) => {
-  category.encodings.forEach((encoding) => {
-    encoding.labels.forEach((label) => {
-      LABEL_ENCODING_MAP[label] = encoding;
-    });
-  });
-});
-
-// Registry of of encoder/decoder factories, by encoding name.
-const DECODERS: { [key: string]: (options: { fatal: boolean }) => UTF8Decoder } = {
-  'UTF-8': (options) => new UTF8Decoder(options),
-};
-
-// 9.1.1 utf-8 decoder
-
-interface Decoder {
-  handler: (stream: Stream, bite: number) => number | number[] | null | -1;
+  return output;
 }
 
-class UTF8Decoder implements Decoder {
-  // utf-8's decoder's has an associated utf-8 code point, utf-8
-  // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8
-  // lower boundary (initially 0x80), and a utf-8 upper boundary
-  // (initially 0xBF).
-  private utf8CodePoint = 0;
-  private utf8BytesSeen = 0;
-  private utf8BytesNeeded = 0;
-  private utf8LowerBoundary = 0x80;
-  private utf8UpperBoundary = 0xbf;
-  constructor(private options: { fatal: boolean }) {}
-  /**
-   * @param {Stream} stream The stream of bytes being decoded.
-   * @param {number} bite The next byte read from the stream.
-   * @return {?(number|!Array.<number>)} The next code point(s)
-   *     decoded, or null if not enough data exists in the input
-   *     stream to decode a complete code point.
-   */
-  handler(stream: Stream, bite: number): number | null | -1 {
-    // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,
-    // set utf-8 bytes needed to 0 and return error.
-    if (bite === END_OF_STREAM && this.utf8BytesNeeded !== 0) {
-      this.utf8BytesNeeded = 0;
-      return decoderError(this.options.fatal);
+function decodeUTF8General(
+  bytes: Uint8Array,
+  state: TextDecoderState,
+  stream: boolean,
+  output = '',
+  start = 0
+): string {
+  const { ignoreBOM } = state;
+  let { pending, bomSeen } = state;
+  let i = start;
+  const length = bytes.length;
+
+  if (pending.length > 0) {
+    const b0 = pending[0]!;
+    const bytesNeeded = b0 <= 0xdf ? 1 : b0 <= 0xef ? 2 : 3;
+    let codePoint = b0 & (bytesNeeded === 1 ? 0x1f : bytesNeeded === 2 ? 0x0f : 0x07);
+    let bytesSeen = 0;
+
+    for (let p = 1; p < pending.length; p++) {
+      codePoint = (codePoint << 6) | (pending[p]! & 0x3f);
+      bytesSeen++;
     }
 
-    // 2. If byte is end-of-stream, return finished.
-    if (bite === END_OF_STREAM) return FINISHED;
+    while (bytesSeen < bytesNeeded && i < length) {
+      const byte = bytes[i]!;
+      if (
+        (byte & 0xc0) !== 0x80 ||
+        (bytesSeen === 0 &&
+          ((b0 === 0xe0 && byte < 0xa0) ||
+            (b0 === 0xed && byte > 0x9f) ||
+            (b0 === 0xf0 && byte < 0x90) ||
+            (b0 === 0xf4 && byte > 0x8f)))
+      ) {
+        pending = EMPTY_BYTES;
+        output += decoderError(state);
+        bomSeen = true;
+        break;
+      }
+      codePoint = (codePoint << 6) | (byte & 0x3f);
+      bytesSeen++;
+      i++;
+    }
 
-    // 3. If utf-8 bytes needed is 0, based on byte:
-    if (this.utf8BytesNeeded === 0) {
-      // 0x00 to 0x7F
-      if (inRange(bite, 0x00, 0x7f)) {
-        // Return a code point whose value is byte.
-        return bite;
+    if (bytesSeen === bytesNeeded) {
+      pending = EMPTY_BYTES;
+      if (bomSeen || ignoreBOM || codePoint !== 0xfeff) {
+        if (codePoint <= 0xffff) {
+          output += String.fromCharCode(codePoint);
+        } else {
+          codePoint -= 0x10000;
+          output += String.fromCharCode((codePoint >> 10) + 0xd800, (codePoint & 0x3ff) + 0xdc00);
+        }
       }
+      bomSeen = true;
+    } else if (i === length) {
+      if (stream && i > 0) {
+        const nextPending = new Uint8Array(pending.length + i);
+        nextPending.set(pending);
+        nextPending.set(bytes.subarray(0, i), pending.length);
+        pending = nextPending;
+      } else if (!stream) {
+        pending = EMPTY_BYTES;
+        output += decoderError(state);
+        bomSeen = true;
+      }
+    }
 
-      // 0xC2 to 0xDF
-      else if (inRange(bite, 0xc2, 0xdf)) {
-        // 1. Set utf-8 bytes needed to 1.
-        this.utf8BytesNeeded = 1;
+    if (pending.length > 0) {
+      state.pending = pending;
+      state.bomSeen = bomSeen;
+      return output;
+    }
+  }
 
-        // 2. Set UTF-8 code point to byte & 0x1F.
-        this.utf8CodePoint = bite & 0x1f;
+  while (i < length) {
+    const b0 = bytes[i]!;
+    if (b0 < 0x80) {
+      bomSeen = true;
+      const directEnd = Math.min(i + 32, length);
+      do {
+        output += String.fromCharCode(bytes[i++]!);
+      } while (i < directEnd && bytes[i]! < 0x80);
+      if (i === directEnd && i < length && bytes[i]! < 0x80) {
+        const asciiStart = i;
+        do {
+          i++;
+        } while (i < length && bytes[i]! < 0x80);
+        output = appendASCII(output, bytes, asciiStart, i);
       }
+      continue;
+    }
 
-      // 0xE0 to 0xEF
-      else if (inRange(bite, 0xe0, 0xef)) {
-        // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.
-        if (bite === 0xe0) this.utf8LowerBoundary = 0xa0;
-        // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.
-        if (bite === 0xed) this.utf8UpperBoundary = 0x9f;
-        // 3. Set utf-8 bytes needed to 2.
-        this.utf8BytesNeeded = 2;
-        // 4. Set UTF-8 code point to byte & 0xF.
-        this.utf8CodePoint = bite & 0xf;
+    let codePoint: number;
+    const remaining = length - i;
+    if (b0 >= 0xc2 && b0 <= 0xdf) {
+      if (remaining < 2) {
+        if (stream) {
+          pending = bytes.slice(i);
+        } else {
+          output += decoderError(state);
+        }
+        break;
       }
-
-      // 0xF0 to 0xF4
-      else if (inRange(bite, 0xf0, 0xf4)) {
-        // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.
-        if (bite === 0xf0) this.utf8LowerBoundary = 0x90;
-        // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.
-        if (bite === 0xf4) this.utf8UpperBoundary = 0x8f;
-        // 3. Set utf-8 bytes needed to 3.
-        this.utf8BytesNeeded = 3;
-        // 4. Set UTF-8 code point to byte & 0x7.
-        this.utf8CodePoint = bite & 0x7;
+      const b1 = bytes[i + 1]!;
+      if ((b1 & 0xc0) !== 0x80) {
+        output += decoderError(state);
+        bomSeen = true;
+        i++;
+        continue;
       }
-
-      // Otherwise
-      else {
-        // Return error.
-        return decoderError(this.options.fatal);
+      codePoint = ((b0 & 0x1f) << 6) | (b1 & 0x3f);
+      i += 2;
+    } else if (b0 >= 0xe0 && b0 <= 0xef) {
+      if (remaining < 2) {
+        if (stream) {
+          pending = bytes.slice(i);
+        } else {
+          output += decoderError(state);
+        }
+        break;
       }
-
-      // Return continue.
-      return null;
+      const b1 = bytes[i + 1]!;
+      if ((b1 & 0xc0) !== 0x80 || (b0 === 0xe0 && b1 < 0xa0) || (b0 === 0xed && b1 > 0x9f)) {
+        output += decoderError(state);
+        bomSeen = true;
+        i++;
+        continue;
+      } else if (remaining < 3) {
+        if (stream) {
+          pending = bytes.slice(i);
+        } else {
+          output += decoderError(state);
+        }
+        break;
+      }
+      const b2 = bytes[i + 2]!;
+      if ((b2 & 0xc0) !== 0x80) {
+        output += decoderError(state);
+        bomSeen = true;
+        i += 2;
+        continue;
+      }
+      codePoint = ((b0 & 0x0f) << 12) | ((b1 & 0x3f) << 6) | (b2 & 0x3f);
+      i += 3;
+    } else if (b0 >= 0xf0 && b0 <= 0xf4) {
+      if (remaining < 2) {
+        if (stream) {
+          pending = bytes.slice(i);
+        } else {
+          output += decoderError(state);
+        }
+        break;
+      }
+      const b1 = bytes[i + 1]!;
+      if ((b1 & 0xc0) !== 0x80 || (b0 === 0xf0 && b1 < 0x90) || (b0 === 0xf4 && b1 > 0x8f)) {
+        output += decoderError(state);
+        bomSeen = true;
+        i++;
+        continue;
+      } else if (remaining < 3) {
+        if (stream) {
+          pending = bytes.slice(i);
+        } else {
+          output += decoderError(state);
+        }
+        break;
+      }
+      const b2 = bytes[i + 2]!;
+      if ((b2 & 0xc0) !== 0x80) {
+        output += decoderError(state);
+        bomSeen = true;
+        i += 2;
+        continue;
+      } else if (remaining < 4) {
+        if (stream) {
+          pending = bytes.slice(i);
+        } else {
+          output += decoderError(state);
+        }
+        break;
+      }
+      const b3 = bytes[i + 3]!;
+      if ((b3 & 0xc0) !== 0x80) {
+        output += decoderError(state);
+        bomSeen = true;
+        i += 3;
+        continue;
+      }
+      codePoint = ((b0 & 0x07) << 18) | ((b1 & 0x3f) << 12) | ((b2 & 0x3f) << 6) | (b3 & 0x3f);
+      i += 4;
+    } else {
+      output += decoderError(state);
+      bomSeen = true;
+      i++;
+      continue;
     }
 
-    // 4. If byte is not in the range utf-8 lower boundary to utf-8
-    // upper boundary, inclusive, run these substeps:
-    if (!inRange(bite, this.utf8LowerBoundary, this.utf8UpperBoundary)) {
-      // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8
-      // bytes seen to 0, set utf-8 lower boundary to 0x80, and set
-      // utf-8 upper boundary to 0xBF.
-      this.utf8CodePoint = 0;
-      this.utf8BytesNeeded = 0;
-      this.utf8BytesSeen = 0;
-      this.utf8LowerBoundary = 0x80;
-      this.utf8UpperBoundary = 0xbf;
-
-      // 2. Prepend byte to stream.
-      stream.prepend(bite);
-
-      // 3. Return error.
-      return decoderError(this.options.fatal);
+    if (bomSeen || ignoreBOM || codePoint !== 0xfeff) {
+      if (codePoint <= 0xffff) {
+        output += String.fromCharCode(codePoint);
+      } else {
+        codePoint -= 0x10000;
+        output += String.fromCharCode((codePoint >> 10) + 0xd800, (codePoint & 0x3ff) + 0xdc00);
+      }
     }
+    bomSeen = true;
+  }
 
-    // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary
-    // to 0xBF.
-    this.utf8LowerBoundary = 0x80;
-    this.utf8UpperBoundary = 0xbf;
-
-    // 6. Set UTF-8 code point to (UTF-8 code point << 6) | (byte &
-    // 0x3F)
-    this.utf8CodePoint = (this.utf8CodePoint << 6) | (bite & 0x3f);
-
-    // 7. Increase utf-8 bytes seen by one.
-    this.utf8BytesSeen += 1;
-
-    // 8. If utf-8 bytes seen is not equal to utf-8 bytes needed,
-    // continue.
-    if (this.utf8BytesSeen !== this.utf8BytesNeeded) return null;
-
-    // 9. Let code point be utf-8 code point.
-    const code_point = this.utf8CodePoint;
-
-    // 10. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes
-    // seen to 0.
-    this.utf8CodePoint = 0;
-    this.utf8BytesNeeded = 0;
-    this.utf8BytesSeen = 0;
+  state.pending = pending;
+  state.bomSeen = bomSeen;
+  return output;
+}
 
-    // 11. Return a code point whose value is code point.
-    return code_point;
+function decodeUTF8(bytes: Uint8Array, state: TextDecoderState, stream: boolean): string {
+  if (state.pending.length === 0) {
+    if (!stream && !state.bomSeen) {
+      const skipBOM =
+        !state.ignoreBOM && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf ? 3 : 0;
+      const result = decodeUTF8Fast(bytes, skipBOM);
+      if (typeof result === 'string') {
+        state.bomSeen = bytes.length > 0;
+        return result;
+      }
+      state.bomSeen = skipBOM > 0 || result.index > skipBOM;
+      return decodeUTF8General(bytes, state, false, result.output, result.index);
+    }
   }
+
+  return decodeUTF8General(bytes, state, stream);
 }
 
-// 8.1 Interface TextDecoder
 // @docsMissing
 export class TextDecoder {
-  private _encoding: Encoding | null;
-  private _ignoreBOM: boolean;
-  private _errorMode: string;
-  private _BOMseen: boolean = false;
-  private _doNotFlush: boolean = false;
-  private _decoder: UTF8Decoder | null = null;
+  private readonly _state: TextDecoderState;
 
-  constructor(
-    label: string = 'utf-8',
-    options: {
-      fatal?: boolean;
-      ignoreBOM?: boolean;
-    } = {}
-  ) {
-    if (options != null && typeof options !== 'object') {
+  constructor(label: string = 'utf-8', options: { fatal?: boolean; ignoreBOM?: boolean } = {}) {
+    if (options == null || (typeof options !== 'object' && typeof options !== 'function')) {
       throw new TypeError(
         'Second argument of TextDecoder must be undefined or an object, e.g. { fatal: true }'
       );
     }
-
-    const normalizedLabel = String(label).trim().toLowerCase();
-    const encoding = getEncoding(normalizedLabel);
-    if (encoding === null || encoding.name === 'replacement') {
-      throw new RangeError(`Unknown encoding: ${label} (normalized: ${normalizedLabel})`);
-    }
-
-    if (!DECODERS[encoding.name]) {
-      throw new Error(`Decoder not present: ${encoding.name}`);
-    }
-
-    this._encoding = encoding;
-    this._ignoreBOM = !!options.ignoreBOM;
-    this._errorMode = options.fatal ? 'fatal' : 'replacement';
+    assertValidUTF8Label(label);
+    this._state = {
+      fatal: Boolean(options.fatal),
+      ignoreBOM: Boolean(options.ignoreBOM),
+      bomSeen: false,
+      pending: EMPTY_BYTES,
+      streaming: false,
+    };
   }
 
-  // Getter methods for encoding, fatal, and ignoreBOM
   get encoding(): string {
-    return this._encoding?.name.toLowerCase() ?? '';
+    return 'utf-8';
   }
 
   get fatal(): boolean {
-    return this._errorMode === 'fatal';
+    return this._state.fatal;
   }
 
   get ignoreBOM(): boolean {
-    return this._ignoreBOM;
+    return this._state.ignoreBOM;
   }
 
-  decode(input?: ArrayBuffer | DataView, options: { stream?: boolean } = {}): string {
-    const bytes = normalizeBytes(input);
-
-    // 1. If the do not flush flag is unset, set decoder to a new
-    // encoding's decoder, set stream to a new stream, and unset the
-    // BOM seen flag.
-    if (!this._doNotFlush) {
-      this._decoder = DECODERS[this._encoding!.name]({
-        fatal: this.fatal,
-      });
-      this._BOMseen = false;
-    }
-
-    // 2. If options's stream is true, set the do not flush flag, and
-    // unset the do not flush flag otherwise.
-    this._doNotFlush = Boolean(options['stream']);
-
-    // 3. If input is given, push a copy of input to stream.
-    // TODO: Align with spec algorithm - maintain stream on instance.
-    const input_stream = new Stream(bytes);
-
-    // 4. Let output be a new stream.
-    const output: number[] = [];
-
-    while (true) {
-      const token = input_stream.read();
-
-      if (token === END_OF_STREAM) break;
-
-      const result = this._decoder!.handler(input_stream, token);
-
-      if (result === FINISHED) break;
-
-      if (result !== null) {
-        output.push(result);
-      }
+  decode(input?: ArrayBuffer | ArrayBufferView, options: { stream?: boolean } = {}): string {
+    if (options == null || (typeof options !== 'object' && typeof options !== 'function')) {
+      throw new TypeError('The options argument must be undefined or an object');
     }
-
-    if (!this._doNotFlush) {
-      do {
-        const result = this._decoder!.handler(input_stream, input_stream.read());
-        if (result === FINISHED) break;
-        if (result === null) continue;
-        if (Array.isArray(result)) output.push(...result);
-        else output.push(result);
-      } while (!input_stream.endOfStream());
-      this._decoder = null;
+    const bytes = normalizeBytes(input);
+    const stream = Boolean(options.stream);
+    const state = this._state;
+    if (!state.streaming) {
+      state.bomSeen = false;
+      state.pending = EMPTY_BYTES;
     }
 
-    return this.serializeStream(output);
-  }
-
-  // serializeStream method for converting code points to a string
-  private serializeStream(stream: number[]): string {
-    if (this._encoding!.name === 'UTF-8') {
-      if (!this._ignoreBOM && !this._BOMseen && stream[0] === 0xfeff) {
-        // If BOM is detected at the start of the stream and we're not ignoring it
-        this._BOMseen = true;
-        stream.shift(); // Remove the BOM
-      } else if (stream.length > 0) {
-        this._BOMseen = true;
-      }
+    try {
+      const output = decodeUTF8(bytes, state, stream);
+      state.streaming = stream;
+      return output;
+    } catch (error) {
+      state.pending = EMPTY_BYTES;
+      state.streaming = false;
+      throw error;
     }
-
-    // Convert the stream of code points to a string
-    return codePointsToString(stream);
   }
 }

package/src/winter/__tests__/TextDecoder.test.native.ts

@@ -249,6 +249,8 @@ describe('TextDecoder', () => {
           chars.substring(TypeConstructor.BYTES_PER_ELEMENT, TypeConstructor.BYTES_PER_ELEMENT + 8)
         );
       });
+
+      expect(decoder.decode(new DataView(buffer, 2, 8))).toBe(chars.substring(2, 10));
     });
   });
 
@@ -274,6 +276,15 @@ describe('TextDecoder', () => {
     });
   });
 
+  it('accepts callable options dictionaries', () => {
+    const options = () => {};
+
+    // @ts-expect-error Web IDL dictionaries accept callable objects
+    expect(new TextDecoder('utf-8', options).fatal).toBe(false);
+    // @ts-expect-error Web IDL dictionaries accept callable objects
+    expect(new TextDecoder().decode(new Uint8Array([0x61]), options)).toBe('a');
+  });
+
   // https://github.com/inexorabletash/text-encoding/blob/3f330964c0e97e1ed344c2a3e963f4598610a7ad/test/test-misc.js#L383
   it('encode() called with falsy arguments (polyfill bindings)', () => {
     const encoder = new TextEncoder();
@@ -283,6 +294,137 @@ describe('TextDecoder', () => {
     expect([...encoder.encode(0)]).toEqual([48]);
   });
 
+  describe('indexed UTF-8 decoder', () => {
+    it('decodes valid sequences at each UTF-8 boundary', () => {
+      const bytes = new Uint8Array([
+        0x00, 0x7f, 0xc2, 0x80, 0xdf, 0xbf, 0xe0, 0xa0, 0x80, 0xed, 0x9f, 0xbf, 0xee, 0x80, 0x80,
+        0xf0, 0x90, 0x80, 0x80, 0xf4, 0x8f, 0xbf, 0xbf,
+      ]);
+
+      expect(new TextDecoder().decode(bytes)).toBe(
+        '\u0000\u007f\u0080\u07ff\u0800\ud7ff\ue000\u{10000}\u{10ffff}'
+      );
+    });
+
+    it('reads the stream option once for malformed input', () => {
+      let reads = 0;
+      const options = {
+        get stream() {
+          reads++;
+          return false;
+        },
+      };
+
+      expect(new TextDecoder().decode(new Uint8Array([0xff]), options)).toBe('\ufffd');
+      expect(reads).toBe(1);
+    });
+
+    it('handles incomplete and malformed sequences across every chunk boundary', () => {
+      const NativeTextDecoder = require('node:util').TextDecoder;
+      const cases = [
+        [0xef, 0xbb, 0xbf, 0x61],
+        [0xc2, 0xa2, 0xe6, 0xb0, 0xb4, 0xf0, 0x9d, 0x84, 0x9e],
+        [0xe0, 0x80, 0x80, 0x61],
+        [0xed, 0xa0, 0x80, 0x61],
+        [0xf4, 0x90, 0x80, 0x80, 0x61],
+        [0xe1, 0x80, 0x41, 0xc2],
+        [0xff, 0xef, 0xbb, 0xbf],
+        [0x61, 0xef, 0xbb, 0xbf],
+      ];
+
+      for (const input of cases) {
+        for (let split = 0; split <= input.length; split++) {
+          const decoder = new TextDecoder();
+          const nativeDecoder = new NativeTextDecoder();
+          const first = new Uint8Array(input.slice(0, split));
+          const second = new Uint8Array(input.slice(split));
+          const actual =
+            decoder.decode(first, { stream: true }) +
+            decoder.decode(second, { stream: true }) +
+            decoder.decode();
+          const expected =
+            nativeDecoder.decode(first, { stream: true }) +
+            nativeDecoder.decode(second, { stream: true }) +
+            nativeDecoder.decode();
+
+          expect(actual).toBe(expected);
+        }
+      }
+    });
+
+    it('decodes large ASCII and multi-byte inputs', () => {
+      const value = 'a'.repeat(9000) + '水𝄞'.repeat(9000);
+      const encoded = new TextEncoder().encode(value);
+
+      expect(new TextDecoder().decode(encoded)).toBe(value);
+    });
+
+    it.each([0, 1, 31, 32, 33, 4095, 4096, 4097, 8193])(
+      'decodes %i ASCII bytes across conversion boundaries',
+      (length) => {
+        const bytes = new Uint8Array(length);
+        for (let i = 0; i < length; i++) bytes[i] = 32 + (i % 95);
+
+        const NativeTextDecoder = require('node:util').TextDecoder;
+        expect(new TextDecoder().decode(bytes)).toBe(new NativeTextDecoder().decode(bytes));
+      }
+    );
+
+    it('agrees with the native decoder for every two-byte input', () => {
+      const NativeTextDecoder = require('node:util').TextDecoder;
+      const bytes = new Uint8Array(2);
+      for (let first = 0; first <= 0xff; first++) {
+        bytes[0] = first;
+        for (let second = 0; second <= 0xff; second++) {
+          bytes[1] = second;
+          expect(new TextDecoder().decode(bytes)).toBe(new NativeTextDecoder().decode(bytes));
+        }
+      }
+    });
+
+    it('agrees with the native decoder for malformed inputs and all streaming splits', () => {
+      const NativeTextDecoder = require('node:util').TextDecoder;
+      let random = 0x12345678;
+      const nextByte = () => {
+        random = (Math.imul(random, 1664525) + 1013904223) >>> 0;
+        return random >>> 24;
+      };
+
+      for (let test = 0; test < 2000; test++) {
+        const input = new Uint8Array(test % 9);
+        for (let i = 0; i < input.length; i++) input[i] = nextByte();
+        expect(new TextDecoder().decode(input)).toBe(new NativeTextDecoder().decode(input));
+
+        for (let split = 0; split <= input.length; split++) {
+          const decoder = new TextDecoder();
+          const nativeDecoder = new NativeTextDecoder();
+          const actual =
+            decoder.decode(input.subarray(0, split), { stream: true }) +
+            decoder.decode(input.subarray(split), { stream: true }) +
+            decoder.decode();
+          const expected =
+            nativeDecoder.decode(input.subarray(0, split), { stream: true }) +
+            nativeDecoder.decode(input.subarray(split), { stream: true }) +
+            nativeDecoder.decode();
+          expect(actual).toBe(expected);
+        }
+      }
+    });
+
+    it('starts a fresh BOM session after a completed decode', () => {
+      const decoder = new TextDecoder();
+      expect(decoder.decode(new Uint8Array([0x61]))).toBe('a');
+      expect(decoder.decode(new Uint8Array([0xef, 0xbb, 0xbf, 0x62]))).toBe('b');
+    });
+
+    it('recovers cleanly after a fatal streaming error', () => {
+      const decoder = new TextDecoder('utf-8', { fatal: true });
+      expect(decoder.decode(new Uint8Array([0xe2]), { stream: true })).toBe('');
+      expect(() => decoder.decode(new Uint8Array([0x41]), { stream: true })).toThrow(TypeError);
+      expect(decoder.decode(new Uint8Array([0x42]))).toBe('B');
+    });
+  });
+
   // https://github.com/inexorabletash/text-encoding/blob/master/test/test-utf.js
   describe('UTF-8 - Encode/Decode - reference sample', () => {
     // z, cent, CJK water, G-Clef, Private-use character