fix(ext/node): reject structuredClone for file-backed Blobs (#34075)

`parallel/test-blob-file-backed.js` in the Node compatibility suite
expects `structuredClone(await fs.openAsBlob(path))` to throw a
`DOMException`/`DataCloneError`. Deno currently implements
`node:fs.openAsBlob()` by reading the file into an in-memory `Blob`, so
the Blob is treated as serializable and `structuredClone()` succeeds.
That diverges from Node behavior for file-backed Blobs.

## Summary
- mark `node:fs.openAsBlob()` results as file-backed in the Blob
internals
- propagate that marker through Blob construction and slicing
- reject structured clone serialization for marked Blobs so
`structuredClone()` surfaces `DataCloneError`
- add a node fs regression covering direct and sliced openAsBlob Blobs

Co-authored-by: divybot <divybot@users.noreply.github.com>
Co-authored-by: Divy Srivastava <me@littledivy.com>

Author: divybot

ext/node/polyfills/fs.ts

@@ -200,6 +200,9 @@ const {
 const { isArrayBufferView } = core.loadExtScript(
   "ext:deno_node/internal/util/types.ts",
 );
+const { Blob, markFileBackedBlob } = core.loadExtScript(
+  "ext:deno_web/09_file.js",
+);
 // Re-exported under both names for tests.
 const _toUnixTimestamp = toUnixTimestamp;
 
@@ -2360,7 +2363,7 @@ function openAsBlob(
   path = getValidatedPath(path);
   return PromisePrototypeThen(
     op_fs_read_file_async(path as string, undefined, 0),
-    (data: Uint8Array) => new Blob([data], { type }),
+    (data: Uint8Array) => markFileBackedBlob(new Blob([data], { type })),
   );
 }
 

ext/web/09_file.js

@@ -218,11 +218,26 @@ function getParts(blob, bag = []) {
 const _type = Symbol("Type");
 const _size = Symbol("Size");
 const _parts = Symbol("Parts");
+const _fileBacked = Symbol("FileBacked");
+
+/** @param {(BlobReference | Blob)[]} parts */
+function hasFileBackedPart(parts) {
+  for (let i = 0; i < parts.length; ++i) {
+    const part = parts[i];
+    if (
+      ObjectPrototypeIsPrototypeOf(BlobPrototype, part) && part[_fileBacked]
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
 
 class Blob {
   [_type] = "";
   [_size] = 0;
   [_parts];
+  [_fileBacked] = false;
 
   /**
    * @param {BlobPart[]} blobParts
@@ -251,6 +266,7 @@ class Blob {
     this[_parts] = parts;
     this[_size] = size;
     this[_type] = normalizeType(options.type);
+    this[_fileBacked] = hasFileBackedPart(parts);
   }
 
   /** @returns {number} */
@@ -360,6 +376,7 @@ class Blob {
     const blob = new Blob([], { type: relativeContentType });
     blob[_parts] = blobParts;
     blob[_size] = span;
+    blob[_fileBacked] = this[_fileBacked];
     return blob;
   }
 
@@ -684,6 +701,9 @@ function getPartRefs(blob, bag = []) {
  * @returns {{ uuid: string, size: number }[]}
  */
 function cloneBlobParts(blob) {
+  if (blob[_fileBacked]) {
+    throw new TypeError("Invalid state: File-backed Blobs are not cloneable");
+  }
   const refs = getPartRefs(blob);
   const cloned = [];
   for (let i = 0; i < refs.length; ++i) {
@@ -720,6 +740,18 @@ core.registerCloneableResource("Blob", (data) => {
   return blob;
 });
 
+/**
+ * Mark a Blob as backed by file storage. File-backed Blobs are intentionally
+ * rejected by the structured clone serializer, matching Node's behavior.
+ * @param {Blob} blob
+ * @returns {Blob}
+ */
+function markFileBackedBlob(blob) {
+  webidl.assertBranded(blob, BlobPrototype);
+  blob[_fileBacked] = true;
+  return blob;
+}
+
 ObjectDefineProperty(File.prototype, core.hostObjectBrand, {
   __proto__: null,
   value: function () {
@@ -834,5 +866,6 @@ return {
   FilePrototype,
   getParts,
   isBlob,
+  markFileBackedBlob,
 };
 })();

tests/unit_node/fs_test.ts

@@ -614,6 +614,29 @@ Deno.test(
   },
 );
 
+Deno.test(
+  "[node/fs openAsBlob] structuredClone throws DataCloneError",
+  async () => {
+    const filename = mkdtempSync(join(tmpdir(), "foo-")) + "/test.txt";
+    writeFileSync(filename, "content");
+
+    const blob = await openAsBlob(filename);
+    const err = assertThrows(
+      () => structuredClone(blob),
+      DOMException,
+      "Invalid state: File-backed Blobs are not cloneable",
+    );
+    assertEquals(err.name, "DataCloneError");
+
+    const sliceErr = assertThrows(
+      () => structuredClone(blob.slice(0, 1)),
+      DOMException,
+      "Invalid state: File-backed Blobs are not cloneable",
+    );
+    assertEquals(sliceErr.name, "DataCloneError");
+  },
+);
+
 Deno.test(
   "[node/fs openAsBlob] rejects for non-existent file",
   async () => {