From 05e4fcb89b1dcb011e64043206d54e4a8a836ec3 Mon Sep 17 00:00:00 2001
From: avivkeller <me@aviv.sh>
Date: Thu, 5 Nov 2026 10:46:31 -0500
Subject: [PATCH 1/4] lib: add FileAPI support

Signed-off-by: avivkeller <me@aviv.sh>
---
 doc/api/globals.md                            |  58 ++
 eslint.config.mjs                             |   4 +
 .../bootstrap/web/exposed-window-or-worker.js |   7 +
 lib/internal/file.js                          |   1 +
 lib/internal/filereader.js                    | 777 ++++++++++++++++++
 lib/internal/progress_event.js                | 142 ++++
 lib/internal/webidl.js                        |  21 +
 lib/internal/webworker.js                     |   3 +
 test/parallel/test-filereader.js              | 243 ++++++
 test/wpt/status/FileAPI.json                  |   1 +
 .../status/FileAPI/reading-data-section.json  |  11 +
 test/wpt/status/workers.json                  |   6 +-
 test/wpt/test-fileapi.js                      |  19 +
 test/wpt/test-filereader.js                   |   8 +
 14 files changed, 1296 insertions(+), 5 deletions(-)
 create mode 100644 lib/internal/filereader.js
 create mode 100644 lib/internal/progress_event.js
 create mode 100644 test/parallel/test-filereader.js
 create mode 100644 test/wpt/status/FileAPI.json
 create mode 100644 test/wpt/status/FileAPI/reading-data-section.json
 create mode 100644 test/wpt/test-fileapi.js
 create mode 100644 test/wpt/test-filereader.js

diff --git a/doc/api/globals.md b/doc/api/globals.md
index f07ac97431b6..c22ca33a1599 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -607,6 +607,48 @@ added: v20.0.0
 
 See {File}.
 
+## Class: `FileList`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A browser-compatible implementation of {FileList} from the [File API][]. The
+interface has no constructor. It is a list of {File} objects, with a `length`
+attribute and an `item(index)` method that returns the `File` at `index`, or
+`null` when `index` is past the end of the list.
+
+## Class: `FileReader`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A browser-compatible implementation of {FileReader} from the [File API][].
+`readAsArrayBuffer()`, `readAsBinaryString()`, `readAsText()`, and
+`readAsDataURL()` read a {Blob} asynchronously and report the result through
+`loadstart`, `progress`, `load`, `abort`, `error`, and `loadend` events.
+`readyState` is `FileReader.EMPTY` (`0`), `FileReader.LOADING` (`1`), or
+`FileReader.DONE` (`2`).
+
+`readAsDataURL()` produces a base64 `data:` URL. When the blob's type is the
+empty string, the URL has no media type.
+
+## Class: `FileReaderSync`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A browser-compatible implementation of {FileReaderSync} from the [File API][].
+It is exposed only inside a [Web Worker][] (`--experimental-web-worker`),
+matching `[Exposed=(DedicatedWorker,SharedWorker)]`. It is not available on
+the main thread or in threads created with `node:worker_threads`.
+
+`readAsArrayBuffer()`, `readAsBinaryString()`, `readAsText()`, and
+`readAsDataURL()` read a {Blob} synchronously. A file-backed blob, such as
+one returned by [`fs.openAsBlob()`][], throws a `NotReadableError`.
+
 ## Class: `FormData`
 
 <!-- YAML
@@ -942,6 +984,19 @@ added: v0.1.7
 
 The process object. See the [`process` object][] section.
 
+## Class: `ProgressEvent`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+A browser-compatible implementation of {ProgressEvent} from the
+[XMLHttpRequest Standard][]. `FileReader` dispatches `ProgressEvent`s for
+`loadstart`, `progress`, `load`, `abort`, `error`, and `loadend`. Those events
+do not bubble and are not cancelable. `lengthComputable`, `loaded`, and
+`total` return the values they were initialized to (`false`, `0`, and `0`
+when omitted).
+
 ## `queueMicrotask(callback)`
 
 <!-- YAML
@@ -1475,7 +1530,10 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][].
 [CommonJS module]: modules.md
 [CommonJS modules]: modules.md
 [ECMAScript module]: esm.md
+[File API]: https://w3c.github.io/FileAPI/
 [HTML Standard]: https://html.spec.whatwg.org/multipage/workers.html
+[Web Worker]: #class-worker
+[XMLHttpRequest Standard]: https://xhr.spec.whatwg.org/#interface-progressevent
 [Navigator API]: https://html.spec.whatwg.org/multipage/system-state.html#the-navigator-object
 [RFC 5646]: https://www.rfc-editor.org/rfc/rfc5646.txt
 [Refable protocol]: process.md#processrefmayberefable
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 9c4ad8f05651..dcd5e7833b63 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -131,10 +131,14 @@ export default [
         DisposableStack: 'readonly',
         EventSource: 'readonly',
         fetch: 'readonly',
+        FileList: 'readonly',
+        FileReader: 'readonly',
+        FileReaderSync: 'readonly',
         Float16Array: 'readonly',
         FormData: 'readonly',
         localStorage: 'readonly',
         navigator: 'readonly',
+        ProgressEvent: 'readonly',
         QuotaExceededError: 'readonly',
         ReadableByteStreamController: 'readonly',
         ReadableStream: 'readonly',
diff --git a/lib/internal/bootstrap/web/exposed-window-or-worker.js b/lib/internal/bootstrap/web/exposed-window-or-worker.js
index 35cb1d5120e1..b6052b212482 100644
--- a/lib/internal/bootstrap/web/exposed-window-or-worker.js
+++ b/lib/internal/bootstrap/web/exposed-window-or-worker.js
@@ -57,6 +57,13 @@ exposeLazyInterfaces(globalThis, 'internal/webworker', ['Worker']);
 exposeLazyInterfaces(globalThis, 'internal/blob', ['Blob']);
 // https://www.w3.org/TR/FileAPI/#dfn-file
 exposeLazyInterfaces(globalThis, 'internal/file', ['File']);
+// https://w3c.github.io/FileAPI/#filelist-section
+// https://w3c.github.io/FileAPI/#APIASynch
+exposeLazyInterfaces(globalThis, 'internal/filereader', [
+  'FileList', 'FileReader',
+]);
+// https://xhr.spec.whatwg.org/#interface-progressevent
+exposeLazyInterfaces(globalThis, 'internal/progress_event', ['ProgressEvent']);
 // https://www.w3.org/TR/hr-time-2/#the-performance-attribute
 exposeLazyInterfaces(globalThis, 'perf_hooks', [
   'Performance', 'PerformanceEntry', 'PerformanceMark', 'PerformanceMeasure',
diff --git a/lib/internal/file.js b/lib/internal/file.js
index aa05a602975e..bd1e2c3ef3d6 100644
--- a/lib/internal/file.js
+++ b/lib/internal/file.js
@@ -149,4 +149,5 @@ ObjectDefineProperties(File.prototype, {
 module.exports = {
   File,
   TransferableFile,
+  isFile,
 };
diff --git a/lib/internal/filereader.js b/lib/internal/filereader.js
new file mode 100644
index 000000000000..ef20fb680716
--- /dev/null
+++ b/lib/internal/filereader.js
@@ -0,0 +1,777 @@
+'use strict';
+
+// The Web IDL and specification prose quoted below is reproduced verbatim
+// from the specification, including its original (lowercase) casing.
+// Refs: https://w3c.github.io/FileAPI/
+/* eslint-disable capitalized-comments */
+
+const {
+  ArrayPrototypePush,
+  DateNow,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  PromisePrototypeThen,
+  Symbol,
+  SymbolToStringTag,
+  TypedArrayPrototypeSet,
+  TypedArrayPrototypeSubarray,
+  Uint8Array,
+} = primordials;
+
+const { Buffer } = require('buffer');
+
+const { setImmediate } = require('timers');
+
+const {
+  EventTarget,
+  defineEventHandler,
+} = require('internal/event_target');
+
+const {
+  getBlobDataSync,
+  isBlob,
+} = require('internal/blob');
+
+const { TextDecoder, getEncodingFromLabel } = require('internal/encoding');
+
+const { isFile } = require('internal/file');
+
+const { MIMEType } = require('internal/mime');
+
+const { ProgressEvent } = require('internal/progress_event');
+
+const {
+  ERR_ILLEGAL_CONSTRUCTOR,
+  ERR_INVALID_ARG_TYPE,
+} = require('internal/errors').codes;
+
+const {
+  kEnumerableProperty,
+  lazyDOMException,
+} = require('internal/util');
+
+const { isUint8Array } = require('internal/util/types');
+
+const {
+  validateThisInternalField,
+} = require('internal/validators');
+
+const {
+  converters,
+  createInterfaceConverter,
+  requiredArguments,
+} = require('internal/webidl');
+
+const kError = Symbol('error');
+const kFiles = Symbol('files');
+const kGeneration = Symbol('generation');
+const kReader = Symbol('reader');
+const kResult = Symbol('result');
+const kState = Symbol('state');
+const kSync = Symbol('sync');
+
+const kProgressInterval = 50;
+
+const convertBlob = createInterfaceConverter('Blob', isBlob);
+
+// https://w3c.github.io/FileAPI/#filelist-section
+//
+// [Exposed=(Window,Worker), Serializable]
+// interface FileList {
+class FileList {
+  constructor() {
+    throw new ERR_ILLEGAL_CONSTRUCTOR();
+  }
+
+  // getter File? item(unsigned long index);
+  item(index) {
+    const prefix = "Failed to execute 'item' on 'FileList'";
+    validateThisInternalField(this, kFiles, 'FileList');
+    requiredArguments(arguments.length, 1, { prefix });
+    index = converters['unsigned long'](index, {
+      prefix,
+      context: 'Argument 1',
+    });
+    // "must return the indexth File object in the FileList.
+    // If there is no indexth File object in the FileList,
+    // then this method must return null."
+    const files = this[kFiles];
+    if (index >= files.length) {
+      return null;
+    }
+    return files[index];
+  }
+
+  // readonly attribute unsigned long length;
+  get length() {
+    validateThisInternalField(this, kFiles, 'FileList');
+    // "must return the number of files in the FileList object.
+    // If there are no files, this attribute must return 0."
+    return this[kFiles].length;
+  }
+}
+// };
+
+function createFileList(files) {
+  const list = { __proto__: FileList.prototype };
+  const items = [];
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (!isFile(file)) {
+      throw new ERR_INVALID_ARG_TYPE('files', 'File[]', files);
+    }
+    ArrayPrototypePush(items, file);
+    // "Supported property indices are the numbers in the range zero to one
+    // less than the number of File objects represented by the FileList
+    // object."
+    ObjectDefineProperty(list, `${i}`, {
+      __proto__: null,
+      configurable: true,
+      enumerable: true,
+      writable: false,
+      value: file,
+    });
+  }
+  list[kFiles] = items;
+  return list;
+}
+
+ObjectDefineProperties(FileList.prototype, {
+  item: kEnumerableProperty,
+  length: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'FileList',
+  },
+});
+
+// "When this specification says to fire a progress event called e (for some
+// ProgressEvent e at a given FileReader reader), the following are normative:
+//
+// * The progress event e does not bubble. e.bubbles must be false
+// * The progress event e is NOT cancelable. e.cancelable must be false"
+function fireAProgressEvent(name, reader) {
+  reader.dispatchEvent(new ProgressEvent(name));
+}
+
+// "Use the file reading task source for all these tasks."
+function queueFileReadingTask(fr, generation, steps) {
+  setImmediate(() => {
+    if (fr[kGeneration] !== generation) {
+      return;
+    }
+    steps();
+  });
+}
+
+function combineByteSequences(chunks, totalBytes) {
+  const bytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const chunk = chunks[i];
+    TypedArrayPrototypeSet(bytes, chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+
+// https://encoding.spec.whatwg.org/#bom-sniff
+//
+// "To BOM sniff an I/O queue of bytes ioQueue:"
+function bomSniff(bytes) {
+  // "Let BOM be the result of peeking 3 bytes from ioQueue, converted to a
+  // byte sequence."
+  const length = bytes.byteLength;
+  const a = bytes[0];
+  const b = bytes[1];
+  const c = bytes[2];
+  // "For each of the rows in the table below, starting with the first one
+  // and going down, if BOM starts with the bytes given in the first column,
+  // then return the encoding given in the cell in the second column of that
+  // row. Otherwise, return null."
+  //
+  // 0xEF 0xBB 0xBF  UTF-8
+  // 0xFE 0xFF       UTF-16BE
+  // 0xFF 0xFE       UTF-16LE
+  if (length >= 3 && a === 0xEF && b === 0xBB && c === 0xBF) {
+    return 'utf-8';
+  }
+  if (length >= 2 && a === 0xFE && b === 0xFF) {
+    return 'utf-16be';
+  }
+  if (length >= 2 && a === 0xFF && b === 0xFE) {
+    return 'utf-16le';
+  }
+  return null;
+}
+
+// https://encoding.spec.whatwg.org/#decode
+//
+// "To decode an I/O queue of bytes ioQueue given a fallback encoding
+// encoding:"
+function decode(bytes, encoding) {
+  // "Let BOMEncoding be the result of BOM sniffing ioQueue."
+  const bomEncoding = bomSniff(bytes);
+  let offset = 0;
+  // "If BOMEncoding is non-null:
+  //  1. Set encoding to BOMEncoding.
+  //  2. Read three bytes from ioQueue, if BOMEncoding is UTF-8; otherwise
+  //     read two bytes. (Do nothing with those bytes.)"
+  if (bomEncoding !== null) {
+    encoding = bomEncoding;
+    offset = bomEncoding === 'utf-8' ? 3 : 2;
+  }
+  // "Process a queue with an instance of encoding's decoder, ioQueue,
+  // output, and "replacement"."
+  // "Return output."
+  const view = offset === 0 ? bytes :
+    TypedArrayPrototypeSubarray(bytes, offset);
+  return new TextDecoder(encoding, { ignoreBOM: true }).decode(view);
+}
+
+// https://w3c.github.io/FileAPI/#packaging-data
+//
+// "A Blob has an associated package data algorithm, given bytes, a type,
+// a mimeType, and an optional encodingLabel, which switches on type and
+// runs the associated steps:"
+function packageData(bytes, type, mimeType, encodingLabel) {
+  switch (type) {
+    case 'DataURL': {
+      // "Return bytes as a DataURL subject to the considerations below:
+      //  * Use mimeType as part of the Data URL if it is not the empty
+      //    string in keeping with the Data URL specification.
+      //  * Otherwise, return a Data URL without a media-type."
+      const encoded = Buffer.from(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
+      ).toString('base64');
+      if (mimeType === '') {
+        return `data:;base64,${encoded}`;
+      }
+      return `data:${mimeType};base64,${encoded}`;
+    }
+    case 'Text': {
+      // "1. Let encoding be failure."
+      let encoding;
+      // "2. If the encodingLabel is present, set encoding to the result of
+      // getting an encoding from encodingLabel."
+      if (encodingLabel !== undefined) {
+        encoding = getEncodingFromLabel(encodingLabel);
+      }
+      // "3. If encoding is failure:"
+      if (encoding === undefined) {
+        // "1. Let type be the result of parse a MIME type given mimeType."
+        const parsed = mimeType === '' ? null : MIMEType.parse(mimeType);
+        // "2. If type is not failure, set encoding to the result of getting
+        // an encoding from type's parameters["charset"]."
+        if (parsed !== null) {
+          const charset = parsed.params.get('charset');
+          if (charset !== null) {
+            encoding = getEncodingFromLabel(charset);
+          }
+        }
+      }
+      // "4. If encoding is failure, then set encoding to UTF-8."
+      if (encoding === undefined) {
+        encoding = 'utf-8';
+      }
+      // "5. Decode bytes using fallback encoding encoding, and return the
+      // result."
+      return decode(bytes, encoding);
+    }
+    case 'ArrayBuffer':
+      // "Return a new ArrayBuffer whose contents are bytes."
+      return combineByteSequences([bytes], bytes.byteLength).buffer;
+    case 'BinaryString':
+      // "Return bytes as a binary string, in which every byte is
+      // represented by a code unit of equal value [0..255]."
+      return Buffer.from(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength,
+      ).toString('latin1');
+  }
+}
+
+function settleWithError(fr, generation, error) {
+  // "Otherwise, if chunkPromise is rejected with an error error, queue a
+  // task to run the following steps and abort this algorithm:"
+  queueFileReadingTask(fr, generation, () => {
+    // "1. Set fr's state to "done"."
+    fr[kState] = 'done';
+    // "2. Set fr's error to error."
+    fr[kError] = error;
+    // "3. Fire a progress event called error at fr."
+    fireAProgressEvent('error', fr);
+    queueLoadEnd(fr, generation);
+  });
+}
+
+function queueLoadEnd(fr, generation) {
+  // "If fr's state is not "loading", fire a progress event called loadend
+  // at the fr."
+  //
+  // "Event handler for the load or error events could have started another
+  // load, if that happens the loadend event for this load is not fired."
+  queueFileReadingTask(fr, generation, () => {
+    if (fr[kState] !== 'loading') {
+      fireAProgressEvent('loadend', fr);
+    }
+  });
+}
+
+// "A FileReader fr has an associated read operation algorithm, which given
+// blob, a type and an optional encodingLabel, runs the following steps:"
+function readOperation(fr, blob, type, encodingLabel) {
+  // "1. If fr's state is "loading", throw an InvalidStateError DOMException."
+  if (fr[kState] === 'loading') {
+    throw lazyDOMException(
+      'The object is in an invalid state.',
+      'InvalidStateError');
+  }
+  // "2. Set fr's state to "loading"."
+  fr[kState] = 'loading';
+  // "3. Set fr's result to null."
+  fr[kResult] = null;
+  // "4. Set fr's error to null."
+  fr[kError] = null;
+
+  const generation = ++fr[kGeneration];
+  // "5. Let stream be the result of calling get stream on blob."
+  const stream = blob.stream();
+  // "6. Let reader be the result of getting a reader from stream."
+  const reader = stream.getReader();
+  fr[kReader] = reader;
+  // "7. Let bytes be an empty byte sequence."
+  const chunks = [];
+  let totalBytes = 0;
+  // "8. Let chunkPromise be the result of reading a chunk from stream with
+  // reader."
+  let chunkPromise = reader.read();
+  // "9. Let isFirstChunk be true."
+  let isFirstChunk = true;
+  let lastStepsAt;
+
+  // "10. In parallel, while true:"
+  async function readInParallel() {
+    while (true) {
+      if (fr[kGeneration] !== generation) {
+        return;
+      }
+
+      // "1. Wait for chunkPromise to be fulfilled or rejected."
+      let chunk;
+      try {
+        chunk = await chunkPromise;
+      } catch (error) {
+        if (fr[kGeneration] !== generation) {
+          return;
+        }
+        settleWithError(fr, generation, error);
+        return;
+      }
+
+      if (fr[kGeneration] !== generation) {
+        return;
+      }
+
+      // "2. If chunkPromise is fulfilled, and isFirstChunk is true, queue a
+      // task to fire a progress event called loadstart at fr."
+      if (isFirstChunk) {
+        queueFileReadingTask(fr, generation, () => {
+          fireAProgressEvent('loadstart', fr);
+        });
+      }
+      // "3. Set isFirstChunk to false."
+      isFirstChunk = false;
+
+      // "4. If chunkPromise is fulfilled with an object whose done property
+      // is false and whose value property is a Uint8Array object, run these
+      // steps:"
+      if (chunk.done !== true && isUint8Array(chunk.value)) {
+        // "1. Let bs be the byte sequence represented by the Uint8Array
+        // object."
+        const bs = chunk.value;
+        // "2. Append bs to bytes."
+        ArrayPrototypePush(chunks, bs);
+        totalBytes += bs.byteLength;
+        // "3. If roughly 50ms have passed since these steps were last
+        // invoked, queue a task to fire a progress event called progress
+        // at fr."
+        const now = DateNow();
+        if (lastStepsAt !== undefined && now - lastStepsAt >= kProgressInterval) {
+          queueFileReadingTask(fr, generation, () => {
+            fireAProgressEvent('progress', fr);
+          });
+        }
+        lastStepsAt = now;
+        // "4. Set chunkPromise to the result of reading a chunk from stream
+        // with reader."
+        chunkPromise = reader.read();
+        continue;
+      }
+
+      // "5. Otherwise, if chunkPromise is fulfilled with an object whose
+      // done property is true, queue a task to run the following steps and
+      // abort this algorithm:"
+      if (chunk.done === true) {
+        const bytes = combineByteSequences(chunks, totalBytes);
+        const mimeType = blob.type;
+        // "One progress event will fire when blob has been completely read
+        // into memory."
+        if (totalBytes > 0) {
+          queueFileReadingTask(fr, generation, () => {
+            fireAProgressEvent('progress', fr);
+          });
+        }
+        queueFileReadingTask(fr, generation, () => {
+          // "1. Set fr's state to "done"."
+          fr[kState] = 'done';
+          fr[kReader] = undefined;
+          try {
+            // "2. Let result be the result of package data given bytes,
+            // type, blob's type, and encodingLabel."
+            const result = packageData(bytes, type, mimeType, encodingLabel);
+            // "4. Else:
+            //  1. Set fr's result to result.
+            //  2. Fire a progress event called load at the fr."
+            fr[kResult] = result;
+            fireAProgressEvent('load', fr);
+          } catch (error) {
+            // "3. If package data threw an exception error:
+            //  1. Set fr's error to error.
+            //  2. Fire a progress event called error at fr."
+            fr[kError] = error;
+            fireAProgressEvent('error', fr);
+          }
+          queueLoadEnd(fr, generation);
+        });
+        return;
+      }
+
+      return;
+    }
+  }
+
+  readInParallel().catch((error) => {
+    if (fr[kGeneration] !== generation) {
+      return;
+    }
+    settleWithError(fr, generation, error);
+  });
+}
+
+function defineReadStateConstants(target) {
+  // const unsigned short EMPTY = 0;
+  ObjectDefineProperty(target, 'EMPTY', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: false,
+    value: 0,
+  });
+  // const unsigned short LOADING = 1;
+  ObjectDefineProperty(target, 'LOADING', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: false,
+    value: 1,
+  });
+  // const unsigned short DONE = 2;
+  ObjectDefineProperty(target, 'DONE', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: false,
+    value: 2,
+  });
+}
+
+// https://w3c.github.io/FileAPI/#APIASynch
+//
+// [Exposed=(Window,Worker)]
+// interface FileReader: EventTarget {
+class FileReader extends EventTarget {
+  // constructor();
+  constructor() {
+    super();
+    // "The FileReader() constructor, when invoked, must return a new
+    // FileReader object."
+    //
+    // "A FileReader has an associated state, that is "empty", "loading",
+    // or "done". It is initially "empty"."
+    this[kState] = 'empty';
+    // "A FileReader has an associated result (null, a DOMString or an
+    // ArrayBuffer). It is initially null."
+    this[kResult] = null;
+    // "A FileReader has an associated error (null or a DOMException).
+    // It is initially null."
+    this[kError] = null;
+    this[kGeneration] = 0;
+  }
+
+  // undefined readAsArrayBuffer(Blob blob);
+  readAsArrayBuffer(blob) {
+    const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsArrayBuffer(blob) method, when invoked, must initiate a
+    // read operation for blob with ArrayBuffer."
+    readOperation(this, blob, 'ArrayBuffer');
+  }
+
+  // undefined readAsBinaryString(Blob blob);
+  readAsBinaryString(blob) {
+    const prefix = "Failed to execute 'readAsBinaryString' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsBinaryString(blob) method, when invoked, must initiate a
+    // read operation for blob with BinaryString."
+    readOperation(this, blob, 'BinaryString');
+  }
+
+  // undefined readAsText(Blob blob, optional DOMString encoding);
+  readAsText(blob, encoding = undefined) {
+    const prefix = "Failed to execute 'readAsText' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    let encodingLabel;
+    if (arguments.length > 1) {
+      encodingLabel = converters.DOMString(encoding, {
+        prefix,
+        context: 'Argument 2',
+      });
+    }
+    // "The readAsText(blob, encoding) method, when invoked, must initiate a
+    // read operation for blob with Text and encoding."
+    readOperation(this, blob, 'Text', encodingLabel);
+  }
+
+  // undefined readAsDataURL(Blob blob);
+  readAsDataURL(blob) {
+    const prefix = "Failed to execute 'readAsDataURL' on 'FileReader'";
+    validateThisInternalField(this, kState, 'FileReader');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsDataURL(blob) method, when invoked, must initiate a read
+    // operation for blob with DataURL."
+    readOperation(this, blob, 'DataURL');
+  }
+
+  // undefined abort();
+  abort() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "When the abort() method is called, the user agent must run the steps
+    // below:"
+    // "1. If this's state is "empty" or if this's state is "done" set
+    // this's result to null and terminate this algorithm."
+    if (this[kState] === 'empty' || this[kState] === 'done') {
+      this[kResult] = null;
+      return;
+    }
+    // "2. If this's state is "loading" set this's state to "done" and set
+    // this's result to null."
+    if (this[kState] === 'loading') {
+      this[kState] = 'done';
+      this[kResult] = null;
+    }
+    // "3. If there are any tasks from this on the file reading task source
+    // in an affiliated task queue, then remove those tasks from that task
+    // queue."
+    // "4. Terminate the algorithm for the read method being processed."
+    this[kGeneration]++;
+    const reader = this[kReader];
+    this[kReader] = undefined;
+    if (reader !== undefined) {
+      PromisePrototypeThen(reader.cancel(), undefined, () => {});
+    }
+    // "5. Fire a progress event called abort at this."
+    fireAProgressEvent('abort', this);
+    // "6. If this's state is not "loading", fire a progress event called
+    // loadend at this."
+    if (this[kState] !== 'loading') {
+      fireAProgressEvent('loadend', this);
+    }
+  }
+
+  // readonly attribute unsigned short readyState;
+  get readyState() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "The readyState attribute's getter, when invoked, switches on this's
+    // state and runs the associated step:"
+    switch (this[kState]) {
+      case 'empty':
+        // `"empty"`
+        // Return EMPTY
+        return 0;
+      case 'loading':
+        // `"loading"`
+        // Return LOADING
+        return 1;
+      case 'done':
+        // `"done"`
+        // Return DONE
+        return 2;
+      default:
+        return 0;
+    }
+  }
+
+  // readonly attribute (DOMString or ArrayBuffer)? result;
+  get result() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "The result attribute's getter, when invoked, must return this's
+    // result."
+    return this[kResult];
+  }
+
+  // readonly attribute DOMException? error;
+  get error() {
+    validateThisInternalField(this, kState, 'FileReader');
+    // "The error attribute's getter, when invoked, must return this's
+    // error."
+    return this[kError];
+  }
+}
+// };
+
+defineReadStateConstants(FileReader);
+defineReadStateConstants(FileReader.prototype);
+
+ObjectDefineProperties(FileReader.prototype, {
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  abort: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  result: kEnumerableProperty,
+  error: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'FileReader',
+  },
+});
+
+// "The following are the event handler content attributes (and their
+// corresponding event handler event types) that user agents must support
+// on FileReader as DOM attributes:"
+// onloadstart / loadstart
+defineEventHandler(FileReader.prototype, 'loadstart');
+// onprogress / progress
+defineEventHandler(FileReader.prototype, 'progress');
+// onload / load
+defineEventHandler(FileReader.prototype, 'load');
+// onabort / abort
+defineEventHandler(FileReader.prototype, 'abort');
+// onerror / error
+defineEventHandler(FileReader.prototype, 'error');
+// onloadend / loadend
+defineEventHandler(FileReader.prototype, 'loadend');
+
+function readSync(blob, type, encodingLabel) {
+  // "Let stream be the result of calling get stream on blob."
+  // "Let reader be the result of getting a reader from stream."
+  // "Let promise be the result of reading all bytes from stream with
+  // reader."
+  // "Wait for promise to be fulfilled or rejected."
+  const buffer = getBlobDataSync(blob);
+  // "If promise fulfilled with a byte sequence bytes:"
+  if (buffer !== undefined) {
+    return packageData(new Uint8Array(buffer), type, blob.type, encodingLabel);
+  }
+  // "Throw promise's rejection reason."
+  throw lazyDOMException(
+    'The blob could not be read',
+    'NotReadableError');
+}
+
+// https://w3c.github.io/FileAPI/#FileReaderSync
+//
+// [Exposed=(DedicatedWorker,SharedWorker)]
+// interface FileReaderSync {
+class FileReaderSync {
+  // constructor();
+  constructor() {
+    // "When the FileReaderSync() constructor is invoked, the user agent
+    // must return a new FileReaderSync object."
+    this[kSync] = true;
+  }
+
+  // ArrayBuffer readAsArrayBuffer(Blob blob);
+  readAsArrayBuffer(blob) {
+    const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsArrayBuffer(blob) method, when invoked, must run these
+    // steps:"
+    return readSync(blob, 'ArrayBuffer');
+  }
+
+  // DOMString readAsBinaryString(Blob blob);
+  readAsBinaryString(blob) {
+    const prefix = "Failed to execute 'readAsBinaryString' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsBinaryString(blob) method, when invoked, must run these
+    // steps:"
+    return readSync(blob, 'BinaryString');
+  }
+
+  // DOMString readAsText(Blob blob, optional DOMString encoding);
+  readAsText(blob, encoding = undefined) {
+    const prefix = "Failed to execute 'readAsText' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    let encodingLabel;
+    if (arguments.length > 1) {
+      encodingLabel = converters.DOMString(encoding, {
+        prefix,
+        context: 'Argument 2',
+      });
+    }
+    // "The readAsText(blob, encoding) method, when invoked, must run these
+    // steps:"
+    return readSync(blob, 'Text', encodingLabel);
+  }
+
+  // DOMString readAsDataURL(Blob blob);
+  readAsDataURL(blob) {
+    const prefix = "Failed to execute 'readAsDataURL' on 'FileReaderSync'";
+    validateThisInternalField(this, kSync, 'FileReaderSync');
+    requiredArguments(arguments.length, 1, { prefix });
+    blob = convertBlob(blob, { prefix, context: 'Argument 1' });
+    // "The readAsDataURL(blob) method, when invoked, must run these steps:"
+    return readSync(blob, 'DataURL');
+  }
+}
+// };
+
+ObjectDefineProperties(FileReaderSync.prototype, {
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'FileReaderSync',
+  },
+});
+
+module.exports = {
+  FileList,
+  FileReader,
+  FileReaderSync,
+  createFileList,
+};
diff --git a/lib/internal/progress_event.js b/lib/internal/progress_event.js
new file mode 100644
index 000000000000..fd3dd002e561
--- /dev/null
+++ b/lib/internal/progress_event.js
@@ -0,0 +1,142 @@
+'use strict';
+
+// The Web IDL and specification prose quoted below is reproduced verbatim
+// from the specification, including its original (lowercase) casing.
+// Refs: https://xhr.spec.whatwg.org/#interface-progressevent
+/* eslint-disable capitalized-comments */
+
+const {
+  ObjectDefineProperties,
+  Symbol,
+  SymbolToStringTag,
+} = primordials;
+
+const {
+  Event,
+} = require('internal/event_target');
+
+const {
+  kEnumerableProperty,
+  kEmptyObject,
+} = require('internal/util');
+
+const {
+  validateThisInternalField,
+} = require('internal/validators');
+
+const {
+  converters,
+  createDictionaryConverter,
+  requiredArguments,
+} = require('internal/webidl');
+
+const kLengthComputable = Symbol('lengthComputable');
+const kLoaded = Symbol('loaded');
+const kTotal = Symbol('total');
+
+// dictionary EventInit {
+const kEventInit = [
+  {
+    // boolean bubbles = false;
+    key: 'bubbles',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+  {
+    // boolean cancelable = false;
+    key: 'cancelable',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+  {
+    // boolean composed = false;
+    key: 'composed',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+];
+// };
+
+// dictionary ProgressEventInit : EventInit {
+const kProgressEventInit = [
+  {
+    // boolean lengthComputable = false;
+    key: 'lengthComputable',
+    converter: converters.boolean,
+    defaultValue: () => false,
+  },
+  {
+    // double loaded = 0;
+    key: 'loaded',
+    converter: converters.double,
+    defaultValue: () => 0,
+  },
+  {
+    // double total = 0;
+    key: 'total',
+    converter: converters.double,
+    defaultValue: () => 0,
+  },
+];
+// };
+
+const convertProgressEventInit = createDictionaryConverter(
+  'ProgressEventInit',
+  [kEventInit, kProgressEventInit],
+);
+
+// [Exposed=(Window,Worker)]
+// interface ProgressEvent : Event {
+class ProgressEvent extends Event {
+  // constructor(DOMString type, optional ProgressEventInit eventInitDict = {});
+  constructor(type, eventInitDict = kEmptyObject) {
+    const prefix = "Failed to construct 'ProgressEvent'";
+    requiredArguments(arguments.length, 1, { prefix });
+    type = converters.DOMString(type, { prefix, context: 'Argument 1' });
+    eventInitDict = convertProgressEventInit(eventInitDict, {
+      prefix,
+      context: 'Argument 2',
+    });
+    super(type, eventInitDict);
+
+    // "The lengthComputable, loaded, and total getter steps are to return
+    // the value they were initialized to."
+    this[kLengthComputable] = eventInitDict.lengthComputable;
+    this[kLoaded] = eventInitDict.loaded;
+    this[kTotal] = eventInitDict.total;
+  }
+
+  // readonly attribute boolean lengthComputable;
+  get lengthComputable() {
+    validateThisInternalField(this, kLengthComputable, 'ProgressEvent');
+    return this[kLengthComputable];
+  }
+
+  // readonly attribute double loaded;
+  get loaded() {
+    validateThisInternalField(this, kLengthComputable, 'ProgressEvent');
+    return this[kLoaded];
+  }
+
+  // readonly attribute double total;
+  get total() {
+    validateThisInternalField(this, kLengthComputable, 'ProgressEvent');
+    return this[kTotal];
+  }
+}
+// };
+
+ObjectDefineProperties(ProgressEvent.prototype, {
+  lengthComputable: kEnumerableProperty,
+  loaded: kEnumerableProperty,
+  total: kEnumerableProperty,
+  [SymbolToStringTag]: {
+    __proto__: null,
+    configurable: true,
+    value: 'ProgressEvent',
+  },
+});
+
+module.exports = {
+  ProgressEvent,
+};
diff --git a/lib/internal/webidl.js b/lib/internal/webidl.js
index 819b5af205b7..4983801a6e51 100644
--- a/lib/internal/webidl.js
+++ b/lib/internal/webidl.js
@@ -544,6 +544,27 @@ converters.boolean = (V) => {
   return !!V;
 };
 
+/**
+ * Converts a JavaScript value to the IDL double type.
+ * @see https://webidl.spec.whatwg.org/#es-double
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {number}
+ */
+converters.double = (V, options = kEmptyObject) => {
+  // Step 1: Let x be ? ToNumber(V).
+  const x = toNumber(V, options);
+  // Step 2: If x is NaN, +Infinity, or -Infinity, then throw a TypeError.
+  if (!NumberIsFinite(x)) {
+    throw makeException(
+      'is not a finite floating-point value.',
+      options);
+  }
+  // Step 3: Return the IDL double value that represents the same
+  // numeric value as x.
+  return x;
+};
+
 /**
  * Converts a JavaScript value to the IDL object type.
  * @see https://webidl.spec.whatwg.org/#es-object
diff --git a/lib/internal/webworker.js b/lib/internal/webworker.js
index 1361b6daa6e3..2df2d46a5069 100644
--- a/lib/internal/webworker.js
+++ b/lib/internal/webworker.js
@@ -43,6 +43,7 @@ const {
   assignFunctionName,
   defineOperation,
   exposeInterface,
+  exposeLazyInterfaces,
   getCWDURL,
   getLazy,
   kEmptyObject,
@@ -1002,6 +1003,8 @@ function installDedicatedWorkerGlobalScope(url, {
     globalThis, 'DedicatedWorkerGlobalScope', DedicatedWorkerGlobalScope);
   exposeInterface(globalThis, 'WorkerNavigator', WorkerNavigator);
   exposeInterface(globalThis, 'WorkerLocation', WorkerLocation);
+  // [Exposed=(DedicatedWorker,SharedWorker)]
+  exposeLazyInterfaces(globalThis, 'internal/filereader', ['FileReaderSync']);
   return globalThis;
 }
 
diff --git a/test/parallel/test-filereader.js b/test/parallel/test-filereader.js
new file mode 100644
index 000000000000..b32dbe011507
--- /dev/null
+++ b/test/parallel/test-filereader.js
@@ -0,0 +1,243 @@
+// Flags: --expose-internals --experimental-web-worker
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { createFileList } = require('internal/filereader');
+
+{
+  assert.strictEqual(typeof FileReader, 'function');
+  assert.strictEqual(typeof FileList, 'function');
+  assert.strictEqual(typeof ProgressEvent, 'function');
+  assert.strictEqual(typeof FileReaderSync, 'undefined');
+}
+
+{
+  const reader = new FileReader();
+  assert.strictEqual(reader.readyState, FileReader.EMPTY);
+  assert.strictEqual(reader.result, null);
+  assert.strictEqual(reader.error, null);
+  for (const name of [
+    'onloadstart', 'onprogress', 'onload', 'onabort', 'onerror', 'onloadend',
+  ]) {
+    assert.strictEqual(reader[name], null);
+  }
+  assert.strictEqual(FileReader.EMPTY, 0);
+  assert.strictEqual(FileReader.LOADING, 1);
+  assert.strictEqual(FileReader.DONE, 2);
+  assert.strictEqual(FileReader.prototype.EMPTY, 0);
+  assert.throws(() => {
+    reader.readAsText({});
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+  assert.throws(() => {
+    FileReader.prototype.readAsText.call({}, new Blob());
+  }, { code: 'ERR_INVALID_THIS' });
+  reader.abort();
+  assert.strictEqual(reader.readyState, FileReader.EMPTY);
+  assert.strictEqual(reader.result, null);
+}
+
+{
+  const reader = new FileReader();
+  const events = [];
+  reader.addEventListener('loadstart', common.mustCall(() => {
+    events.push('loadstart');
+    assert.strictEqual(reader.readyState, FileReader.LOADING);
+    assert.strictEqual(reader.result, null);
+  }));
+  reader.addEventListener('progress', common.mustCall(() => {
+    events.push('progress');
+    assert.strictEqual(reader.readyState, FileReader.LOADING);
+    assert.strictEqual(reader.result, null);
+  }));
+  reader.addEventListener('load', common.mustCall(() => {
+    events.push('load');
+    assert.strictEqual(reader.readyState, FileReader.DONE);
+    assert.strictEqual(reader.result, 'TEST');
+  }));
+  reader.addEventListener('loadend', common.mustCall(() => {
+    events.push('loadend');
+    assert.deepStrictEqual(events, ['loadstart', 'progress', 'load', 'loadend']);
+  }));
+  reader.readAsText(new Blob(['TEST']));
+}
+
+{
+  const reader = new FileReader();
+  const events = [];
+  reader.onloadstart = common.mustCall(() => events.push('loadstart'));
+  reader.onprogress = common.mustNotCall();
+  reader.onload = common.mustCall(() => {
+    events.push('load');
+    assert.strictEqual(reader.result, '');
+  });
+  reader.onloadend = common.mustCall(() => {
+    events.push('loadend');
+    assert.deepStrictEqual(events, ['loadstart', 'load', 'loadend']);
+  });
+  reader.readAsText(new Blob());
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '\u4554\u5453');
+  });
+  reader.readAsText(new Blob(['TEST']), 'UTF-16');
+}
+
+{
+  const data = [0xFE, 0xFF, 0x00, 0x68, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x6F];
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, 'hello');
+  });
+  reader.readAsText(new Blob([new Uint8Array(data)], {
+    type: 'text/plain;charset=UTF-16BE',
+  }));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, 'data:text/plain;base64,VEVTVA==');
+    assert.strictEqual(reader.result instanceof ArrayBuffer, false);
+  });
+  reader.readAsDataURL(new Blob(['TEST'], { type: 'text/plain' }));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(
+      reader.result,
+      'data:;base64,VEVTVA==');
+  });
+  reader.readAsDataURL(new Blob(['TEST']));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.ok(reader.result instanceof ArrayBuffer);
+    assert.deepStrictEqual(
+      new Uint8Array(reader.result),
+      new Uint8Array([84, 69, 83, 84]));
+  });
+  reader.readAsArrayBuffer(new Blob(['TEST']));
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '\xcf\x83');
+  });
+  reader.readAsBinaryString(new Blob(['σ']));
+}
+
+{
+  const reader = new FileReader();
+  const blob = new Blob(['TEST THE ABORT METHOD']);
+  reader.onloadstart = common.mustCall(() => {
+    assert.strictEqual(reader.readyState, FileReader.LOADING);
+    reader.onabort = common.mustCall((event) => {
+      assert.strictEqual(event.type, 'abort');
+      assert.strictEqual(event.bubbles, false);
+      assert.strictEqual(event.cancelable, false);
+      assert.ok(event instanceof ProgressEvent);
+      assert.strictEqual(reader.readyState, FileReader.DONE);
+      assert.strictEqual(reader.result, null);
+    });
+    reader.onloadend = common.mustCall(() => {
+      assert.strictEqual(reader.readyState, FileReader.DONE);
+    });
+    reader.onload = common.mustNotCall();
+    reader.abort();
+  });
+  reader.readAsText(blob);
+}
+
+{
+  const reader = new FileReader();
+  reader.readAsText(new Blob(['one']));
+  assert.throws(() => {
+    reader.readAsText(new Blob(['two']));
+  }, { name: 'InvalidStateError' });
+}
+
+{
+  const first = new FileReader();
+  first.onloadstart = common.mustCall(() => {
+    first.abort();
+    first.onloadstart = null;
+    first.onloadend = common.mustCall(() => {
+      assert.strictEqual(first.result, 'second');
+    });
+    first.readAsText(new Blob(['second']));
+  });
+  first.readAsText(new Blob(['first']));
+}
+
+{
+  assert.throws(() => new FileList(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' });
+  const file = new File(['hello'], 'hello.txt');
+  const list = createFileList([file]);
+  assert.ok(list instanceof FileList);
+  assert.strictEqual(list.length, 1);
+  assert.strictEqual(list.item(0), file);
+  assert.strictEqual(list[0], file);
+  assert.strictEqual(list.item(1), null);
+  const empty = createFileList([]);
+  assert.strictEqual(empty.length, 0);
+  assert.strictEqual(empty.item(0), null);
+}
+
+{
+  const event = new ProgressEvent('progress', {
+    lengthComputable: true,
+    loaded: 3,
+    total: 4,
+    bubbles: true,
+  });
+  assert.strictEqual(event.type, 'progress');
+  assert.strictEqual(event.lengthComputable, true);
+  assert.strictEqual(event.loaded, 3);
+  assert.strictEqual(event.total, 4);
+  assert.strictEqual(event.bubbles, true);
+  assert.strictEqual(event.cancelable, false);
+  assert.throws(() => new ProgressEvent('load', { loaded: Infinity }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+  assert.throws(() => ProgressEvent.prototype.loaded, {
+    code: 'ERR_INVALID_THIS',
+  });
+}
+
+if (common.hasCrypto) {
+  const source = `
+    const sync = new FileReaderSync();
+    const blob = new Blob(['test']);
+    const empty = new Blob();
+    postMessage({
+      hasReader: typeof FileReader === 'function',
+      text: sync.readAsText(blob),
+      empty: sync.readAsText(empty),
+      binary: sync.readAsBinaryString(blob),
+      url: sync.readAsDataURL(empty),
+      bytes: sync.readAsArrayBuffer(blob).byteLength,
+    });
+  `;
+  const url = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+  const worker = new Worker(url);
+  URL.revokeObjectURL(url);
+  worker.onerror = common.mustNotCall('worker failed');
+  worker.onmessage = common.mustCall(({ data }) => {
+    worker.terminate();
+    assert.strictEqual(data.hasReader, true);
+    assert.strictEqual(data.text, 'test');
+    assert.strictEqual(data.empty, '');
+    assert.strictEqual(data.binary, 'test');
+    assert.strictEqual(data.url.indexOf('data:'), 0);
+    assert.strictEqual(data.bytes, 4);
+  });
+}
diff --git a/test/wpt/status/FileAPI.json b/test/wpt/status/FileAPI.json
new file mode 100644
index 000000000000..0967ef424bce
--- /dev/null
+++ b/test/wpt/status/FileAPI.json
@@ -0,0 +1 @@
+{}
diff --git a/test/wpt/status/FileAPI/reading-data-section.json b/test/wpt/status/FileAPI/reading-data-section.json
new file mode 100644
index 000000000000..27c8c41fb141
--- /dev/null
+++ b/test/wpt/status/FileAPI/reading-data-section.json
@@ -0,0 +1,11 @@
+{
+  "filereader_readAsDataURL.any.js": {
+    "fail": {
+      "note": "package data returns a data URL without a media type when the blob type is empty",
+      "expected": [
+        "readAsDataURL result for Blob with unspecified MIME type",
+        "readAsDataURL result for empty Blob"
+      ]
+    }
+  }
+}
diff --git a/test/wpt/status/workers.json b/test/wpt/status/workers.json
index 015ac98d0084..64eb1fb4359d 100644
--- a/test/wpt/status/workers.json
+++ b/test/wpt/status/workers.json
@@ -112,7 +112,7 @@
   },
   "semantics/interface-objects/001.worker.js": {
     "fail": {
-      "note": "Canvas, XHR, EventSource, PromiseRejectionEvent, ProgressEvent, the File API reader classes and IndexedDB are not implemented",
+      "note": "Canvas, XHR, EventSource, PromiseRejectionEvent, and IndexedDB are not implemented",
       "expected": [
         "The ImageData interface object should be exposed.",
         "The ImageBitmap interface object should be exposed.",
@@ -125,10 +125,6 @@
         "The XMLHttpRequestEventTarget interface object should be exposed.",
         "The XMLHttpRequestUpload interface object should be exposed.",
         "The XMLHttpRequest interface object should be exposed.",
-        "The ProgressEvent interface object should be exposed.",
-        "The FileList interface object should be exposed.",
-        "The FileReader interface object should be exposed.",
-        "The FileReaderSync interface object should be exposed.",
         "The IDBRequest interface object should be exposed.",
         "The IDBOpenDBRequest interface object should be exposed.",
         "The IDBVersionChangeEvent interface object should be exposed.",
diff --git a/test/wpt/test-fileapi.js b/test/wpt/test-fileapi.js
new file mode 100644
index 000000000000..cb3344d49578
--- /dev/null
+++ b/test/wpt/test-fileapi.js
@@ -0,0 +1,19 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+// FileAPI/blob, FileAPI/file, and FileAPI/reading-data-section have their own
+// runners. These two tests live in the FileAPI root.
+const included = new Set([
+  'fileReader.any.js',
+  'FileReaderSync.worker.js',
+]);
+
+const runner = new WPTRunner('FileAPI');
+for (const spec of runner.specs) {
+  if (!included.has(spec.filename)) {
+    runner.specs.delete(spec);
+  }
+}
+runner.runJsTests();
diff --git a/test/wpt/test-filereader.js b/test/wpt/test-filereader.js
new file mode 100644
index 000000000000..6ecd466201f9
--- /dev/null
+++ b/test/wpt/test-filereader.js
@@ -0,0 +1,8 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('FileAPI/reading-data-section');
+
+runner.runJsTests();

From 635dde8b2297975d2ccb4f570a10e6d44ab4f152 Mon Sep 17 00:00:00 2001
From: avivkeller <me@aviv.sh>
Date: Thu, 5 Nov 2026 14:34:25 -0500
Subject: [PATCH 2/4] lib: add FileAPI support

Signed-off-by: avivkeller <me@aviv.sh>
---
 doc/api/globals.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index c22ca33a1599..2c99b1f6e2ff 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -1532,12 +1532,12 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][].
 [ECMAScript module]: esm.md
 [File API]: https://w3c.github.io/FileAPI/
 [HTML Standard]: https://html.spec.whatwg.org/multipage/workers.html
-[Web Worker]: #class-worker
-[XMLHttpRequest Standard]: https://xhr.spec.whatwg.org/#interface-progressevent
 [Navigator API]: https://html.spec.whatwg.org/multipage/system-state.html#the-navigator-object
 [RFC 5646]: https://www.rfc-editor.org/rfc/rfc5646.txt
 [Refable protocol]: process.md#processrefmayberefable
 [Web Crypto API]: webcrypto.md
+[Web Worker]: #class-worker
+[XMLHttpRequest Standard]: https://xhr.spec.whatwg.org/#interface-progressevent
 [`--experimental-eventsource`]: cli.md#--experimental-eventsource
 [`--experimental-web-worker`]: cli.md#--experimental-web-worker
 [`--localstorage-file`]: cli.md#--localstorage-filefile

From 3d6db63b236c20bf4dc2020abe26065d7e3afc88 Mon Sep 17 00:00:00 2001
From: avivkeller <me@aviv.sh>
Date: Thu, 5 Nov 2026 18:10:28 -0500
Subject: [PATCH 3/4] lib: add FileAPI support

Signed-off-by: avivkeller <me@aviv.sh>
---
 doc/api/globals.md                            |  79 ++++++----
 eslint.config.mjs                             |   1 -
 .../bootstrap/web/exposed-window-or-worker.js |   5 +-
 lib/internal/filereader.js                    | 149 ++++++------------
 lib/internal/progress_event.js                |   7 +
 test/parallel/test-filereader.js              |  64 +++++---
 test/wpt/status/workers.json                  |   3 +-
 7 files changed, 156 insertions(+), 152 deletions(-)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index 2c99b1f6e2ff..dd9ad9bd0aac 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -607,32 +607,36 @@ added: v20.0.0
 
 See {File}.
 
-## Class: `FileList`
+## Class: `FileReader`
 
 <!-- YAML
 added: REPLACEME
 -->
 
-A browser-compatible implementation of {FileList} from the [File API][]. The
-interface has no constructor. It is a list of {File} objects, with a `length`
-attribute and an `item(index)` method that returns the `File` at `index`, or
-`null` when `index` is past the end of the list.
+> Stability: 1 - Experimental
 
-## Class: `FileReader`
+An implementation of {FileReader} from the [File API][]. `readAsArrayBuffer()`,
+`readAsBinaryString()`, `readAsText()`, and `readAsDataURL()` read a {Blob}
+asynchronously and report the result through `loadstart`, `progress`, `load`,
+`abort`, `error`, and `loadend` events. `readyState` is `FileReader.EMPTY`
+(`0`), `FileReader.LOADING` (`1`), or `FileReader.DONE` (`2`).
 
-<!-- YAML
-added: REPLACEME
--->
+`readAsDataURL()` produces a base64 `data:` URL. When the blob's type is the
+empty string, the URL has no media type (`data:;base64,...`). Chrome and
+Firefox use `application/octet-stream` in that case.
 
-A browser-compatible implementation of {FileReader} from the [File API][].
-`readAsArrayBuffer()`, `readAsBinaryString()`, `readAsText()`, and
-`readAsDataURL()` read a {Blob} asynchronously and report the result through
-`loadstart`, `progress`, `load`, `abort`, `error`, and `loadend` events.
-`readyState` is `FileReader.EMPTY` (`0`), `FileReader.LOADING` (`1`), or
-`FileReader.DONE` (`2`).
+`readAsText()` follows {TextDecoder} for the chosen encoding, including its
+ICU requirement. Labels that the Encoding Standard maps to the replacement
+encoding, such as `'iso-2022-kr'`, decode to U+FFFD when the input is not
+empty.
 
-`readAsDataURL()` produces a base64 `data:` URL. When the blob's type is the
-empty string, the URL has no media type.
+```js
+const reader = new FileReader();
+reader.addEventListener('load', () => {
+  console.log(reader.result); // Prints: hello
+});
+reader.readAsText(new Blob(['hello']));
+```
 
 ## Class: `FileReaderSync`
 
@@ -640,15 +644,23 @@ empty string, the URL has no media type.
 added: REPLACEME
 -->
 
-A browser-compatible implementation of {FileReaderSync} from the [File API][].
-It is exposed only inside a [Web Worker][] (`--experimental-web-worker`),
-matching `[Exposed=(DedicatedWorker,SharedWorker)]`. It is not available on
-the main thread or in threads created with `node:worker_threads`.
+> Stability: 1 - Experimental
+
+An implementation of {FileReaderSync} from the [File API][]. It is
+`[Exposed=(DedicatedWorker,SharedWorker)]`, so it exists only inside a
+[Web Worker][] (`--experimental-web-worker`). It is not available on the main
+thread or in threads created with `node:worker_threads`.
 
 `readAsArrayBuffer()`, `readAsBinaryString()`, `readAsText()`, and
 `readAsDataURL()` read a {Blob} synchronously. A file-backed blob, such as
 one returned by [`fs.openAsBlob()`][], throws a `NotReadableError`.
 
+```js
+// Inside a Web Worker (`--experimental-web-worker`):
+const text = new FileReaderSync().readAsText(new Blob(['hello']));
+postMessage(text); // Sends 'hello'
+```
+
 ## Class: `FormData`
 
 <!-- YAML
@@ -990,12 +1002,25 @@ The process object. See the [`process` object][] section.
 added: REPLACEME
 -->
 
-A browser-compatible implementation of {ProgressEvent} from the
-[XMLHttpRequest Standard][]. `FileReader` dispatches `ProgressEvent`s for
-`loadstart`, `progress`, `load`, `abort`, `error`, and `loadend`. Those events
-do not bubble and are not cancelable. `lengthComputable`, `loaded`, and
-`total` return the values they were initialized to (`false`, `0`, and `0`
-when omitted).
+> Stability: 1 - Experimental
+
+An implementation of {ProgressEvent} from the [XMLHttpRequest Standard][].
+`FileReader`
+dispatches `ProgressEvent`s for `loadstart`, `progress`, `load`, `abort`,
+`error`, and `loadend`. Those events do not bubble and are not cancelable.
+`lengthComputable`, `loaded`, and `total` return the values they were
+initialized to (`false`, `0`, and `0` when omitted). The File API's
+"fire a progress event" algorithm does not set those three fields, so events
+fired by `FileReader` leave them at the defaults.
+
+```js
+const event = new ProgressEvent('progress', {
+  lengthComputable: true,
+  loaded: 50,
+  total: 100,
+});
+console.log(event.loaded / event.total); // Prints: 0.5
+```
 
 ## `queueMicrotask(callback)`
 
diff --git a/eslint.config.mjs b/eslint.config.mjs
index dcd5e7833b63..cebc1b482e36 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -131,7 +131,6 @@ export default [
         DisposableStack: 'readonly',
         EventSource: 'readonly',
         fetch: 'readonly',
-        FileList: 'readonly',
         FileReader: 'readonly',
         FileReaderSync: 'readonly',
         Float16Array: 'readonly',
diff --git a/lib/internal/bootstrap/web/exposed-window-or-worker.js b/lib/internal/bootstrap/web/exposed-window-or-worker.js
index b6052b212482..974261639ea9 100644
--- a/lib/internal/bootstrap/web/exposed-window-or-worker.js
+++ b/lib/internal/bootstrap/web/exposed-window-or-worker.js
@@ -57,11 +57,8 @@ exposeLazyInterfaces(globalThis, 'internal/webworker', ['Worker']);
 exposeLazyInterfaces(globalThis, 'internal/blob', ['Blob']);
 // https://www.w3.org/TR/FileAPI/#dfn-file
 exposeLazyInterfaces(globalThis, 'internal/file', ['File']);
-// https://w3c.github.io/FileAPI/#filelist-section
 // https://w3c.github.io/FileAPI/#APIASynch
-exposeLazyInterfaces(globalThis, 'internal/filereader', [
-  'FileList', 'FileReader',
-]);
+exposeLazyInterfaces(globalThis, 'internal/filereader', ['FileReader']);
 // https://xhr.spec.whatwg.org/#interface-progressevent
 exposeLazyInterfaces(globalThis, 'internal/progress_event', ['ProgressEvent']);
 // https://www.w3.org/TR/hr-time-2/#the-performance-attribute
diff --git a/lib/internal/filereader.js b/lib/internal/filereader.js
index ef20fb680716..26db994e70b8 100644
--- a/lib/internal/filereader.js
+++ b/lib/internal/filereader.js
@@ -13,6 +13,7 @@ const {
   PromisePrototypeThen,
   Symbol,
   SymbolToStringTag,
+  TypedArrayPrototypeGetByteLength,
   TypedArrayPrototypeSet,
   TypedArrayPrototypeSubarray,
   Uint8Array,
@@ -25,26 +26,23 @@ const { setImmediate } = require('timers');
 const {
   EventTarget,
   defineEventHandler,
+  kTrustEvent,
 } = require('internal/event_target');
 
 const {
+  createBlobReaderStream,
   getBlobDataSync,
   isBlob,
+  kHandle,
+  kType,
 } = require('internal/blob');
 
 const { TextDecoder, getEncodingFromLabel } = require('internal/encoding');
 
-const { isFile } = require('internal/file');
-
 const { MIMEType } = require('internal/mime');
 
 const { ProgressEvent } = require('internal/progress_event');
 
-const {
-  ERR_ILLEGAL_CONSTRUCTOR,
-  ERR_INVALID_ARG_TYPE,
-} = require('internal/errors').codes;
-
 const {
   kEnumerableProperty,
   lazyDOMException,
@@ -63,7 +61,6 @@ const {
 } = require('internal/webidl');
 
 const kError = Symbol('error');
-const kFiles = Symbol('files');
 const kGeneration = Symbol('generation');
 const kReader = Symbol('reader');
 const kResult = Symbol('result');
@@ -74,85 +71,18 @@ const kProgressInterval = 50;
 
 const convertBlob = createInterfaceConverter('Blob', isBlob);
 
-// https://w3c.github.io/FileAPI/#filelist-section
-//
-// [Exposed=(Window,Worker), Serializable]
-// interface FileList {
-class FileList {
-  constructor() {
-    throw new ERR_ILLEGAL_CONSTRUCTOR();
-  }
-
-  // getter File? item(unsigned long index);
-  item(index) {
-    const prefix = "Failed to execute 'item' on 'FileList'";
-    validateThisInternalField(this, kFiles, 'FileList');
-    requiredArguments(arguments.length, 1, { prefix });
-    index = converters['unsigned long'](index, {
-      prefix,
-      context: 'Argument 1',
-    });
-    // "must return the indexth File object in the FileList.
-    // If there is no indexth File object in the FileList,
-    // then this method must return null."
-    const files = this[kFiles];
-    if (index >= files.length) {
-      return null;
-    }
-    return files[index];
-  }
-
-  // readonly attribute unsigned long length;
-  get length() {
-    validateThisInternalField(this, kFiles, 'FileList');
-    // "must return the number of files in the FileList object.
-    // If there are no files, this attribute must return 0."
-    return this[kFiles].length;
-  }
-}
-// };
-
-function createFileList(files) {
-  const list = { __proto__: FileList.prototype };
-  const items = [];
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
-    if (!isFile(file)) {
-      throw new ERR_INVALID_ARG_TYPE('files', 'File[]', files);
-    }
-    ArrayPrototypePush(items, file);
-    // "Supported property indices are the numbers in the range zero to one
-    // less than the number of File objects represented by the FileList
-    // object."
-    ObjectDefineProperty(list, `${i}`, {
-      __proto__: null,
-      configurable: true,
-      enumerable: true,
-      writable: false,
-      value: file,
-    });
-  }
-  list[kFiles] = items;
-  return list;
-}
-
-ObjectDefineProperties(FileList.prototype, {
-  item: kEnumerableProperty,
-  length: kEnumerableProperty,
-  [SymbolToStringTag]: {
-    __proto__: null,
-    configurable: true,
-    value: 'FileList',
-  },
-});
-
 // "When this specification says to fire a progress event called e (for some
 // ProgressEvent e at a given FileReader reader), the following are normative:
 //
 // * The progress event e does not bubble. e.bubbles must be false
 // * The progress event e is NOT cancelable. e.cancelable must be false"
+const kTrustedProgressEventInit = {
+  __proto__: null,
+  [kTrustEvent]: true,
+};
+
 function fireAProgressEvent(name, reader) {
-  reader.dispatchEvent(new ProgressEvent(name));
+  reader.dispatchEvent(new ProgressEvent(name, kTrustedProgressEventInit));
 }
 
 // "Use the file reading task source for all these tasks."
@@ -171,7 +101,7 @@ function combineByteSequences(chunks, totalBytes) {
   for (let i = 0; i < chunks.length; i++) {
     const chunk = chunks[i];
     TypedArrayPrototypeSet(bytes, chunk, offset);
-    offset += chunk.byteLength;
+    offset += TypedArrayPrototypeGetByteLength(chunk);
   }
   return bytes;
 }
@@ -182,10 +112,7 @@ function combineByteSequences(chunks, totalBytes) {
 function bomSniff(bytes) {
   // "Let BOM be the result of peeking 3 bytes from ioQueue, converted to a
   // byte sequence."
-  const length = bytes.byteLength;
-  const a = bytes[0];
-  const b = bytes[1];
-  const c = bytes[2];
+  const length = TypedArrayPrototypeGetByteLength(bytes);
   // "For each of the rows in the table below, starting with the first one
   // and going down, if BOM starts with the bytes given in the first column,
   // then return the encoding given in the cell in the second column of that
@@ -194,14 +121,19 @@ function bomSniff(bytes) {
   // 0xEF 0xBB 0xBF  UTF-8
   // 0xFE 0xFF       UTF-16BE
   // 0xFF 0xFE       UTF-16LE
-  if (length >= 3 && a === 0xEF && b === 0xBB && c === 0xBF) {
+  if (length >= 3 &&
+      bytes[0] === 0xEF && bytes[1] === 0xBB && bytes[2] === 0xBF) {
     return 'utf-8';
   }
-  if (length >= 2 && a === 0xFE && b === 0xFF) {
-    return 'utf-16be';
-  }
-  if (length >= 2 && a === 0xFF && b === 0xFE) {
-    return 'utf-16le';
+  if (length >= 2) {
+    const a = bytes[0];
+    const b = bytes[1];
+    if (a === 0xFE && b === 0xFF) {
+      return 'utf-16be';
+    }
+    if (a === 0xFF && b === 0xFE) {
+      return 'utf-16le';
+    }
   }
   return null;
 }
@@ -222,11 +154,21 @@ function decode(bytes, encoding) {
     encoding = bomEncoding;
     offset = bomEncoding === 'utf-8' ? 3 : 2;
   }
+  const view = offset === 0 ? bytes :
+    TypedArrayPrototypeSubarray(bytes, offset);
+  // "replacement's decoder's handler, given unused and byte, runs these
+  // steps:
+  //  1. If byte is end-of-queue, then return finished.
+  //  2. If replacement error returned is false, then set replacement error
+  //     returned to true and return error.
+  //  3. Return finished."
+  // Error mode "replacement" turns that error into U+FFFD.
+  if (encoding === 'replacement') {
+    return TypedArrayPrototypeGetByteLength(view) === 0 ? '' : '\uFFFD';
+  }
   // "Process a queue with an instance of encoding's decoder, ioQueue,
   // output, and "replacement"."
   // "Return output."
-  const view = offset === 0 ? bytes :
-    TypedArrayPrototypeSubarray(bytes, offset);
   return new TextDecoder(encoding, { ignoreBOM: true }).decode(view);
 }
 
@@ -331,6 +273,9 @@ function readOperation(fr, blob, type, encodingLabel) {
       'The object is in an invalid state.',
       'InvalidStateError');
   }
+  const previousState = fr[kState];
+  const previousResult = fr[kResult];
+  const previousError = fr[kError];
   // "2. Set fr's state to "loading"."
   fr[kState] = 'loading';
   // "3. Set fr's result to null."
@@ -340,7 +285,15 @@ function readOperation(fr, blob, type, encodingLabel) {
 
   const generation = ++fr[kGeneration];
   // "5. Let stream be the result of calling get stream on blob."
-  const stream = blob.stream();
+  let stream;
+  try {
+    stream = createBlobReaderStream(blob[kHandle].getReader());
+  } catch (error) {
+    fr[kState] = previousState;
+    fr[kResult] = previousResult;
+    fr[kError] = previousError;
+    throw error;
+  }
   // "6. Let reader be the result of getting a reader from stream."
   const reader = stream.getReader();
   fr[kReader] = reader;
@@ -418,7 +371,7 @@ function readOperation(fr, blob, type, encodingLabel) {
       // abort this algorithm:"
       if (chunk.done === true) {
         const bytes = combineByteSequences(chunks, totalBytes);
-        const mimeType = blob.type;
+        const mimeType = blob[kType];
         // "One progress event will fire when blob has been completely read
         // into memory."
         if (totalBytes > 0) {
@@ -685,7 +638,7 @@ function readSync(blob, type, encodingLabel) {
   const buffer = getBlobDataSync(blob);
   // "If promise fulfilled with a byte sequence bytes:"
   if (buffer !== undefined) {
-    return packageData(new Uint8Array(buffer), type, blob.type, encodingLabel);
+    return packageData(new Uint8Array(buffer), type, blob[kType], encodingLabel);
   }
   // "Throw promise's rejection reason."
   throw lazyDOMException(
@@ -770,8 +723,6 @@ ObjectDefineProperties(FileReaderSync.prototype, {
 });
 
 module.exports = {
-  FileList,
   FileReader,
   FileReaderSync,
-  createFileList,
 };
diff --git a/lib/internal/progress_event.js b/lib/internal/progress_event.js
index fd3dd002e561..a08278ef7c09 100644
--- a/lib/internal/progress_event.js
+++ b/lib/internal/progress_event.js
@@ -13,6 +13,7 @@ const {
 
 const {
   Event,
+  kTrustEvent,
 } = require('internal/event_target');
 
 const {
@@ -92,11 +93,17 @@ class ProgressEvent extends Event {
   constructor(type, eventInitDict = kEmptyObject) {
     const prefix = "Failed to construct 'ProgressEvent'";
     requiredArguments(arguments.length, 1, { prefix });
+    const trusted = eventInitDict != null &&
+      typeof eventInitDict === 'object' &&
+      eventInitDict[kTrustEvent] === true;
     type = converters.DOMString(type, { prefix, context: 'Argument 1' });
     eventInitDict = convertProgressEventInit(eventInitDict, {
       prefix,
       context: 'Argument 2',
     });
+    if (trusted) {
+      eventInitDict[kTrustEvent] = true;
+    }
     super(type, eventInitDict);
 
     // "The lengthComputable, loaded, and total getter steps are to return
diff --git a/test/parallel/test-filereader.js b/test/parallel/test-filereader.js
index b32dbe011507..5e3982794413 100644
--- a/test/parallel/test-filereader.js
+++ b/test/parallel/test-filereader.js
@@ -3,11 +3,9 @@
 
 const common = require('../common');
 const assert = require('node:assert');
-const { createFileList } = require('internal/filereader');
 
 {
   assert.strictEqual(typeof FileReader, 'function');
-  assert.strictEqual(typeof FileList, 'function');
   assert.strictEqual(typeof ProgressEvent, 'function');
   assert.strictEqual(typeof FileReaderSync, 'undefined');
 }
@@ -40,23 +38,31 @@ const { createFileList } = require('internal/filereader');
 {
   const reader = new FileReader();
   const events = [];
-  reader.addEventListener('loadstart', common.mustCall(() => {
+  reader.addEventListener('loadstart', common.mustCall((event) => {
     events.push('loadstart');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
     assert.strictEqual(reader.readyState, FileReader.LOADING);
     assert.strictEqual(reader.result, null);
   }));
-  reader.addEventListener('progress', common.mustCall(() => {
+  reader.addEventListener('progress', common.mustCall((event) => {
     events.push('progress');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
     assert.strictEqual(reader.readyState, FileReader.LOADING);
     assert.strictEqual(reader.result, null);
   }));
-  reader.addEventListener('load', common.mustCall(() => {
+  reader.addEventListener('load', common.mustCall((event) => {
     events.push('load');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
     assert.strictEqual(reader.readyState, FileReader.DONE);
     assert.strictEqual(reader.result, 'TEST');
   }));
-  reader.addEventListener('loadend', common.mustCall(() => {
+  reader.addEventListener('loadend', common.mustCall((event) => {
     events.push('loadend');
+    assert.ok(event instanceof ProgressEvent);
+    assert.strictEqual(event.isTrusted, true);
     assert.deepStrictEqual(events, ['loadstart', 'progress', 'load', 'loadend']);
   }));
   reader.readAsText(new Blob(['TEST']));
@@ -178,20 +184,6 @@ const { createFileList } = require('internal/filereader');
   first.readAsText(new Blob(['first']));
 }
 
-{
-  assert.throws(() => new FileList(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' });
-  const file = new File(['hello'], 'hello.txt');
-  const list = createFileList([file]);
-  assert.ok(list instanceof FileList);
-  assert.strictEqual(list.length, 1);
-  assert.strictEqual(list.item(0), file);
-  assert.strictEqual(list[0], file);
-  assert.strictEqual(list.item(1), null);
-  const empty = createFileList([]);
-  assert.strictEqual(empty.length, 0);
-  assert.strictEqual(empty.item(0), null);
-}
-
 {
   const event = new ProgressEvent('progress', {
     lengthComputable: true,
@@ -211,6 +203,38 @@ const { createFileList } = require('internal/filereader');
   assert.throws(() => ProgressEvent.prototype.loaded, {
     code: 'ERR_INVALID_THIS',
   });
+  assert.strictEqual(new ProgressEvent('load').isTrusted, false);
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '\uFFFD');
+  });
+  reader.readAsText(new Blob(['hello']), 'iso-2022-kr');
+}
+
+{
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, '');
+  });
+  reader.readAsText(new Blob(), 'iso-2022-kr');
+}
+
+{
+  const blob = new Blob(['TEST']);
+  blob.stream = () => {
+    throw new Error('public stream should not be used');
+  };
+  Object.defineProperty(blob, 'type', {
+    get() { return 'text/evil'; },
+  });
+  const reader = new FileReader();
+  reader.onload = common.mustCall(() => {
+    assert.strictEqual(reader.result, 'data:;base64,VEVTVA==');
+  });
+  reader.readAsDataURL(blob);
 }
 
 if (common.hasCrypto) {
diff --git a/test/wpt/status/workers.json b/test/wpt/status/workers.json
index 64eb1fb4359d..86f2ec1c39db 100644
--- a/test/wpt/status/workers.json
+++ b/test/wpt/status/workers.json
@@ -112,7 +112,7 @@
   },
   "semantics/interface-objects/001.worker.js": {
     "fail": {
-      "note": "Canvas, XHR, EventSource, PromiseRejectionEvent, and IndexedDB are not implemented",
+      "note": "Canvas, XHR, EventSource, PromiseRejectionEvent, FileList, and IndexedDB are not implemented",
       "expected": [
         "The ImageData interface object should be exposed.",
         "The ImageBitmap interface object should be exposed.",
@@ -121,6 +121,7 @@
         "The TextMetrics interface object should be exposed.",
         "The Path2D interface object should be exposed.",
         "The PromiseRejectionEvent interface object should be exposed.",
+        "The FileList interface object should be exposed.",
         "The EventSource interface object should be exposed.",
         "The XMLHttpRequestEventTarget interface object should be exposed.",
         "The XMLHttpRequestUpload interface object should be exposed.",

From cd0e0fb1e9684afed3b6e77ad3d80b6cf18e7d58 Mon Sep 17 00:00:00 2001
From: avivkeller <me@aviv.sh>
Date: Fri, 6 Nov 2026 10:42:36 -0500
Subject: [PATCH 4/4] fixup! lib: add FileAPI support

---
 doc/api/cli.md                        | 12 ++++++++++++
 doc/api/globals.md                    | 10 +++++++---
 doc/node.1                            |  7 +++++++
 lib/internal/process/pre_execution.js | 10 ++++++++++
 src/node_options.cc                   |  5 +++++
 src/node_options.h                    |  1 +
 test/parallel/test-filereader-flag.js |  9 +++++++++
 test/parallel/test-filereader.js      |  2 +-
 test/wpt/test-fileapi.js              |  1 +
 test/wpt/test-filereader.js           |  1 +
 test/wpt/test-workers.js              |  1 +
 11 files changed, 55 insertions(+), 4 deletions(-)
 create mode 100644 test/parallel/test-filereader-flag.js

diff --git a/doc/api/cli.md b/doc/api/cli.md
index d3309ae6192d..9545f40f3460 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1465,6 +1465,16 @@ added:
 
 Enable exposition of [EventSource Web API][] on the global scope.
 
+### `--experimental-fileapi`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Enable exposition of the [File API][] globals `FileReader` and `ProgressEvent`
+on the global scope. `FileReaderSync` is exposed only inside a Web Worker
+started with `--experimental-web-worker`.
+
 ### `--experimental-import-meta-resolve`
 
 <!-- YAML
@@ -4305,6 +4315,7 @@ one is included in the list below.
 * `--experimental-detect-module`
 * `--experimental-dtls`
 * `--experimental-eventsource`
+* `--experimental-fileapi`
 * `--experimental-import-meta-resolve`
 * `--experimental-import-text`
 * `--experimental-json-modules`
@@ -4920,6 +4931,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [EventSource Web API]: https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
 [ExperimentalWarning: `vm.measureMemory` is an experimental feature]: vm.md#vmmeasurememoryoptions
 [FIPS mode]: crypto.md#fips-mode
+[File API]: https://w3c.github.io/FileAPI/
 [File System Permissions]: permissions.md#file-system-permissions
 [Loading ECMAScript modules using `require()`]: modules.md#loading-ecmascript-modules-using-require
 [Module resolution and loading]: packages.md#module-resolution-and-loading
diff --git a/doc/api/globals.md b/doc/api/globals.md
index dd9ad9bd0aac..b6d54e620007 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -613,7 +613,8 @@ See {File}.
 added: REPLACEME
 -->
 
-> Stability: 1 - Experimental
+> Stability: 1.1 - Active development. Enable this API with the
+> [`--experimental-fileapi`][] CLI flag.
 
 An implementation of {FileReader} from the [File API][]. `readAsArrayBuffer()`,
 `readAsBinaryString()`, `readAsText()`, and `readAsDataURL()` read a {Blob}
@@ -644,7 +645,8 @@ reader.readAsText(new Blob(['hello']));
 added: REPLACEME
 -->
 
-> Stability: 1 - Experimental
+> Stability: 1.1 - Active development. Enable this API with the
+> [`--experimental-fileapi`][] CLI flag.
 
 An implementation of {FileReaderSync} from the [File API][]. It is
 `[Exposed=(DedicatedWorker,SharedWorker)]`, so it exists only inside a
@@ -1002,7 +1004,8 @@ The process object. See the [`process` object][] section.
 added: REPLACEME
 -->
 
-> Stability: 1 - Experimental
+> Stability: 1.1 - Active development. Enable this API with the
+> [`--experimental-fileapi`][] CLI flag.
 
 An implementation of {ProgressEvent} from the [XMLHttpRequest Standard][].
 `FileReader`
@@ -1564,6 +1567,7 @@ A browser-compatible implementation of [`WritableStreamDefaultWriter`][].
 [Web Worker]: #class-worker
 [XMLHttpRequest Standard]: https://xhr.spec.whatwg.org/#interface-progressevent
 [`--experimental-eventsource`]: cli.md#--experimental-eventsource
+[`--experimental-fileapi`]: cli.md#--experimental-fileapi
 [`--experimental-web-worker`]: cli.md#--experimental-web-worker
 [`--localstorage-file`]: cli.md#--localstorage-filefile
 [`--no-experimental-global-navigator`]: cli.md#--no-experimental-global-navigator
diff --git a/doc/node.1 b/doc/node.1
index 444da29eed3d..31d05dbb4b88 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -858,6 +858,11 @@ dtls documentation for details.
 .It Fl -experimental-eventsource
 Enable exposition of EventSource Web API on the global scope.
 .
+.It Fl -experimental-fileapi
+Enable exposition of the File API globals \fBFileReader\fR and \fBProgressEvent\fR
+on the global scope. \fBFileReaderSync\fR is exposed only inside a Web Worker
+started with \fB--experimental-web-worker\fR.
+.
 .It Fl -experimental-import-meta-resolve
 Enable experimental \fBimport.meta.resolve()\fR parent URL support, which allows
 passing a second \fBparentURL\fR argument for contextual resolution.
@@ -2266,6 +2271,8 @@ one is included in the list below.
 .It
 \fB--experimental-eventsource\fR
 .It
+\fB--experimental-fileapi\fR
+.It
 \fB--experimental-import-meta-resolve\fR
 .It
 \fB--experimental-import-text\fR
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 0f5aaf857aeb..0fe8ca417482 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -122,6 +122,7 @@ function prepareExecution(options) {
   setupWebStorage();
   removeWebWorkersIfDisabled();
   setupEventsource();
+  removeFileAPIIfDisabled();
   setupCodeCoverage();
   setupDebugEnv();
   // Process initial diagnostic reporting configuration, if present.
@@ -463,6 +464,15 @@ function removeWebWorkersIfDisabled() {
   }
 }
 
+// https://w3c.github.io/FileAPI/
+function removeFileAPIIfDisabled() {
+  if (!getOptionValue('--experimental-fileapi')) {
+    delete globalThis.FileReader;
+    delete globalThis.FileReaderSync;
+    delete globalThis.ProgressEvent;
+  }
+}
+
 // https://html.spec.whatwg.org/multipage/server-sent-events.html
 function setupEventsource() {
   if (!getOptionValue('--experimental-eventsource')) {
diff --git a/src/node_options.cc b/src/node_options.cc
index 4ba4801ad1dc..11dda59af97c 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -776,6 +776,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             BOOL_FIELD(experimental_eventsource),
             kAllowedInEnvvar,
             false);
+  AddOption("--experimental-fileapi",
+            "experimental File API globals",
+            BOOL_FIELD(experimental_fileapi),
+            kAllowedInEnvvar,
+            false);
   AddOption("--experimental-fetch", "", NoOp{}, kAllowedInEnvvar);
 #if HAVE_FFI
   AddOption("--experimental-ffi",
diff --git a/src/node_options.h b/src/node_options.h
index f8aa58253862..ae75f9e301eb 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -210,6 +210,7 @@ class EnvironmentOptions : public Options {
   DEFINE_BOOL_FIELD(experimental_addon_modules) = true;
   DEFINE_BOOL_FIELD(experimental_bench) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_eventsource) = EXPERIMENTALS_DEFAULT_VALUE;
+  DEFINE_BOOL_FIELD(experimental_fileapi) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_ffi) = HAVE_FFI;
   DEFINE_BOOL_FIELD(experimental_web_worker) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_websocket) = true;
diff --git a/test/parallel/test-filereader-flag.js b/test/parallel/test-filereader-flag.js
new file mode 100644
index 000000000000..f660ee46f80a
--- /dev/null
+++ b/test/parallel/test-filereader-flag.js
@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+
+// Without --experimental-fileapi, the File API globals are not exposed.
+assert.strictEqual(typeof FileReader, 'undefined');
+assert.strictEqual(typeof FileReaderSync, 'undefined');
+assert.strictEqual(typeof ProgressEvent, 'undefined');
diff --git a/test/parallel/test-filereader.js b/test/parallel/test-filereader.js
index 5e3982794413..42b41895b1c7 100644
--- a/test/parallel/test-filereader.js
+++ b/test/parallel/test-filereader.js
@@ -1,4 +1,4 @@
-// Flags: --expose-internals --experimental-web-worker
+// Flags: --expose-internals --experimental-web-worker --experimental-fileapi
 'use strict';
 
 const common = require('../common');
diff --git a/test/wpt/test-fileapi.js b/test/wpt/test-fileapi.js
index cb3344d49578..7c7f6bc136a8 100644
--- a/test/wpt/test-fileapi.js
+++ b/test/wpt/test-fileapi.js
@@ -11,6 +11,7 @@ const included = new Set([
 ]);
 
 const runner = new WPTRunner('FileAPI');
+runner.setFlags(['--experimental-fileapi']);
 for (const spec of runner.specs) {
   if (!included.has(spec.filename)) {
     runner.specs.delete(spec);
diff --git a/test/wpt/test-filereader.js b/test/wpt/test-filereader.js
index 6ecd466201f9..678a315c1f3a 100644
--- a/test/wpt/test-filereader.js
+++ b/test/wpt/test-filereader.js
@@ -4,5 +4,6 @@ require('../common');
 const { WPTRunner } = require('../common/wpt');
 
 const runner = new WPTRunner('FileAPI/reading-data-section');
+runner.setFlags(['--experimental-fileapi']);
 
 runner.runJsTests();
diff --git a/test/wpt/test-workers.js b/test/wpt/test-workers.js
index 21ec86057b6e..d1595a716846 100644
--- a/test/wpt/test-workers.js
+++ b/test/wpt/test-workers.js
@@ -5,5 +5,6 @@ const { WPTRunner } = require('../common/wpt');
 
 const runner = new WPTRunner('workers');
 
+runner.setFlags(['--experimental-fileapi']);
 runner.pretendGlobalThisAs('Window');
 runner.runJsTests();