fix(fetch): #234 real Blob with arrayBuffer/text/bytes/slice instance methods

[TheHypnoo]

Summary

Closes #234.

Pre-fix await response.blob() returned a metadata-only stub {size, type} and silently dropped resp.body. Calls to blob.arrayBuffer() / .text() / .bytes() / .slice() got nothing because no codegen dispatch arms existed.

Approach

Three-part fix mirroring the precedent from #232 (real BufferHeader for response.arrayBuffer) and #227 (registered-buffer is_registered_buffer plumbing):

1. Runtime — crates/perry-stdlib/src/fetch.rs

• New BlobData { body, content_type } + BLOB_REGISTRY: Mutex<HashMap<usize, BlobData>> + NEXT_BLOB_ID + alloc_blob helper, mirroring the HEADERS_REGISTRY / alloc_headers pattern in the same file.
• js_response_blob rewritten: clones body bytes + content-type into a fresh BlobData, registers it, resolves the promise with the numeric handle as f64. Matches the Response-handle ABI documented at lower_call.rs:2788.
• 6 new FFIs:
  • js_blob_size(handle) -> f64
  • js_blob_type(handle) -> *mut StringHeader (codegen NaN-boxes with STRING_TAG)
  • js_blob_array_buffer(handle) -> *mut Promise — allocates a real BufferHeader via perry_runtime::buffer::buffer_alloc(len), memcpys body, NaN-boxes as POINTER_TAG. Same shape as js_response_array_buffer from fix(fetch): copy body bytes into response.arrayBuffer() result #232 so new Uint8Array(buf) and Buffer.from(buf) see real bytes via the is_registered_buffer path from response.arrayBuffer() returns metadata-only object — body bytes never reach TS #227.
  • js_blob_bytes(handle) -> *mut Promise — alias to js_blob_array_buffer (the BufferHeader is already byte-array-shaped).
  • js_blob_text(handle) -> *mut Promise — UTF-8 lossy decode to StringHeader, matches WHATWG Blob.text() replacement-character semantics.
  • js_blob_slice(handle, start, end, type_ptr) -> f64 — canonical f64::NAN sentinel for missing numeric args, null type_ptr to inherit the original content-type. Negative indices count from the end and clamp to [0, len] per WHATWG Blob spec; allocates a fresh blob with sliced bytes.

2. HIR — crates/perry-hir/src/destructuring.rs

Two new arms in lower_var_decl next to the existing Response.clone() propagation:

• const blob = await <recv>.blob() where <recv> is fetch::Response → register_native_instance(name, "blob", "Blob").
• const b2 = <recv>.slice(...) where <recv> is blob::Blob → propagate the type so chained slicing keeps Blob-ness.

The existing native-instance method-call lowering at expr_call.rs:723-740 and property access at expr_member.rs:312-326 then route subsequent .text() / .size / etc. to Expr::NativeMethodCall { module: "blob", method: ..., args: [] } automatically — no other HIR changes needed.

3. Codegen — crates/perry-codegen/src/lower_call.rs + runtime_decls.rs

New if module == "blob" arm right after the existing if module == "fetch" block:

• size → js_blob_size (DOUBLE return)
• type → js_blob_type + nanbox_string_inline
• arrayBuffer / bytes / text → respective Promise-returning FFIs + nanbox_pointer_inline
• slice → 0-3 args with double_literal(f64::NAN) sentinels for missing numeric args and "0" for missing type pointer; returns the new blob handle as f64 directly.

6 new module.declare_function(...) rows in runtime_decls.rs with the matching ABIs.

Out of scope

• blob.stream() — needs a full WHATWG Web Streams API implementation (ReadableStream, ReadableStreamDefaultReader, Symbol.asyncIterator protocol for streams, eventually WritableStream + TransformStream for pipeTo / pipeThrough). That affects response.body / Request.body / new Response(stream) too, so a Blob-only stub would create inconsistency. Tracked as Web Streams API: implement ReadableStream + blob.stream() / response.body #237.
• response.formData() — separate gap; not requested by response.blob() drops body bytes — same shape as #227, needs Blob instance methods #234.

Test plan

• New test-files/test_issue_234_blob_methods.ts covers 11 cases: size, text, arrayBuffer + Uint8Array roundtrip, bytes alias, multi-byte UTF-8 + Buffer.from roundtrip, slice(start, end), slice() (no args, full clone), slice(start) (defaults end to length), slice(0, 3, "text/plain") (typed slice), empty body, negative slice indices. All match node --experimental-strip-types byte-for-byte.
• test-files/test_issue_227_array_buffer_bytes.ts (the response.arrayBuffer() returns metadata-only object — body bytes never reach TS #227 regression) continues to match Node byte-for-byte.
• test-files/test_gap_fetch_response.ts continues to match Node modulo the pre-existing experimental-strip-types preamble.
• cargo build --release -p perry-runtime -p perry-stdlib -p perry clean.

Refs

• Closes response.blob() drops body bytes — same shape as #227, needs Blob instance methods #234
• Follow-up Web Streams API: implement ReadableStream + blob.stream() / response.body #237 (blob.stream() + Web Streams API)
• Same lineage as response.arrayBuffer() returns metadata-only object — body bytes never reach TS #227 (response.arrayBuffer() body bytes) and fix(fetch): copy body bytes into response.arrayBuffer() result #232 (real BufferHeader for response.arrayBuffer)

[proggeramlug]

Folded in via main as commits 1264fb1 (your fix) + 9e72f26 (your CI skip) + d1aa185 (maintainer fold-in: v0.5.359 bump + slice() type-default spec fix per WHATWG + duplicate-comment cleanup). Thanks for the fix — closing as merged. Refs #237 for blob.stream() follow-up.