Lightpanda: the headless browser designed for AI and automation
streams: correct error throws
Halil Durak86f9e3495c53
diff --git a/src/browser/tests/compression/decompression_stream.html b/src/browser/tests/compression/decompression_stream.htmlindex 4a9beba09..a149453c5 100644--- a/src/browser/tests/compression/decompression_stream.html+++ b/src/browser/tests/compression/decompression_stream.html@@ -379,3 +379,27 @@testing.expectEqual({ whole: true, split: true }, results);});</script>++<script id=stored_type_error type=module>+ const state = await testing.async();++ // A stream errored by a bad chunk rejects with one TypeError object, on+ // both sides.+ const ds = new DecompressionStream('gzip');+ const writer = ds.writable.getWriter();+ const reader = ds.readable.getReader();+ const pending_read = reader.read().catch((e) => e);+ await writer.write('hello').catch(() => {});+ const errors = [+ await pending_read,+ await reader.read().catch((e) => e),+ await reader.cancel().catch((e) => e),+ await writer.write(new Uint8Array(1)).catch((e) => e),+ ];++ state.resolve();+ await state.done(() => {+ testing.expectEqual(true, errors[0] instanceof TypeError);+ testing.expectEqual([true, true, true, true], errors.map((e) => e === errors[0]));+ });+</script>diff --git a/src/browser/tests/net/fetch.html b/src/browser/tests/net/fetch.htmlindex a39452611..91d779fca 100644--- a/src/browser/tests/net/fetch.html+++ b/src/browser/tests/net/fetch.html@@ -369,6 +369,11 @@c6.abort();const stream_read = await rejection(streamed.body.getReader().read());+ const c7 = new AbortController();+ const streamed_custom = await fetch('http://127.0.0.1:9582/xhr', { signal: c7.signal });+ c7.abort(custom);+ const stream_read_custom = await rejection(streamed_custom.body.getReader().read());+state.resolve();await state.done(() => {testing.expectEqual('AbortError', inflight.name);@@ -380,7 +385,8 @@testing.expectEqual(100, text.length);testing.expectEqual(custom, unread_text);testing.expectEqual(custom, unread_clone_json);- testing.expectTrue(stream_read !== 'resolved', 'aborted body stream read resolved');+ testing.expectEqual('AbortError', stream_read.name);+ testing.expectEqual(custom, stream_read_custom);});}</script>diff --git a/src/browser/tests/streams/readable_stream.html b/src/browser/tests/streams/readable_stream.htmlindex 050daa6cd..a00ea8edc 100644--- a/src/browser/tests/streams/readable_stream.html+++ b/src/browser/tests/streams/readable_stream.html@@ -450,3 +450,21 @@], results);});</script>++<script id=stored_error type=module>+ const state = await testing.async();++ // read() and cancel() reject with whatever controller.error() was given.+ const errored = new ReadableStream({ start(c) { c.error('err!'); } }).getReader();+ const no_reason = new ReadableStream({ start(c) { c.error(); } }).getReader();+ const results = [+ await errored.read().catch((e) => e),+ await errored.cancel().catch((e) => e),+ await no_reason.read().then(() => 'resolved', (e) => e),+ ];++ state.resolve();+ await state.done(() => {+ testing.expectEqual(['err!', 'err!', undefined], results);+ });+</script>diff --git a/src/browser/tests/streams/transform_stream.html b/src/browser/tests/streams/transform_stream.htmlindex 575189153..32bedcc68 100644--- a/src/browser/tests/streams/transform_stream.html+++ b/src/browser/tests/streams/transform_stream.html@@ -162,3 +162,20 @@testing.expectEqual(true, result2.done);})();</script>++<script id=transform_error_both_sides type=module>+ const state = await testing.async();++ // controller.error(e) errors the readable and the writable side with e.+ const err = new Error('boom');+ const ts = new TransformStream({ transform(chunk, controller) { controller.error(err); } });+ const writer = ts.writable.getWriter();+ const reader = ts.readable.getReader();+ await writer.write('a').catch(() => {});+ const errors = [await reader.read().catch((e) => e), await writer.write('b').catch((e) => e)];++ state.resolve();+ await state.done(() => {+ testing.expectEqual([true, true], errors.map((e) => e === err));+ });+</script>diff --git a/src/browser/webapi/net/Response.zig b/src/browser/webapi/net/Response.zigindex 7e17ffffb..bc8397639 100644--- a/src/browser/webapi/net/Response.zig+++ b/src/browser/webapi/net/Response.zig@@ -307,9 +307,10 @@ pub fn getBody(self: *Response, exec: *const Execution) !?*ReadableStream {return stream;}const stream = blk: {- if (self.abortReason() != null) {+ if (self.abortReason()) |reason| {+ // Like text() and json(), reads reject with the signal's reason.const stream = try ReadableStream.init(null, null, exec);- try stream._controller.doError("The operation was aborted.");+ try stream._controller.doError(try AbortSignal.reasonJsValue(reason, exec.js.local.?));break :blk stream;}if (body.len == 0) {@@ -330,7 +331,7 @@ pub fn getBody(self: *Response, exec: *const Execution) !?*ReadableStream {return stream;}const stream = try ReadableStream.init(null, null, exec);- try stream._controller.doError("Failed to read response body");+ try stream._controller.typeError("Failed to read response body");self._body_stream = stream;if (self._body_used) {try lockStream(stream, exec);diff --git a/src/browser/webapi/streams/ReadableStream.zig b/src/browser/webapi/streams/ReadableStream.zigindex fd1300689..5ca167dc3 100644--- a/src/browser/webapi/streams/ReadableStream.zig+++ b/src/browser/webapi/streams/ReadableStream.zig@@ -43,11 +43,47 @@ pub const State = enum {errored,};+/// Why a stream errored; WritableStream uses it too.+pub const StoredError = union(enum) {+ /// What page JS errored the stream with, e.g. controller.error(e).+ js_val: js.Value.Global,+ type_error: []const u8,+ undefined,++ pub fn fromJs(value_: ?js.Value) !StoredError {+ const value = value_ orelse return .undefined;+ if (value.isUndefined()) {+ return .undefined;+ }+ return .{ .js_val = try value.persist() };+ }++ pub fn toJs(self: *StoredError, local: *const js.Local) !js.Value {+ switch (self.*) {+ .js_val => |global| return local.toLocal(global),+ .undefined => return .{ .local = local, .handle = local.isolate.initUndefined() },+ .type_error => |message| {+ const value: js.Value = .{ .local = local, .handle = local.isolate.createTypeError(message) };+ self.* = .{ .js_val = try value.persist() };+ return value;+ },+ }+ }++ pub fn reject(self: *StoredError, comptime source: []const u8, resolver: js.PromiseResolver) void {+ const value = self.toJs(resolver.local) catch {+ resolver.rejectError(source, .{ .type_error = "Stream errored" });+ return;+ };+ resolver.reject(source, value);+ }+};+_state: State,_execution: *const Execution,_reader: ?*ReadableStreamDefaultReader,_controller: *ReadableStreamDefaultController,-_stored_error: ?[]const u8,+_stored_error: ?StoredError,_pull_fn: ?js.Function.Global = null,_pulling: bool = false,_pull_again: bool = false,@@ -236,17 +272,25 @@ fn shouldCallPull(self: *const ReadableStream) bool {return desired_size > 0;}-pub fn cancel(self: *ReadableStream, reason: ?[]const u8, exec: *const Execution) !js.Promise {+pub fn cancel(self: *ReadableStream, reason: ?js.Value, exec: *const Execution) !js.Promise {const local = exec.js.local.?;self._disturbed = true;- if (self._state != .readable) {- if (self._cancel) |c| {- if (c.resolver) |r| {- return local.toLocal(r).promise();+ switch (self._state) {+ .readable => {},+ .closed => {+ if (self._cancel) |c| {+ if (c.resolver) |r| {+ return local.toLocal(r).promise();+ }}- }- return local.resolvePromise(.{});+ return local.resolvePromise(.{});+ },+ .errored => {+ const resolver = local.createPromiseResolver();+ self._stored_error.?.reject("ReadableStream.cancel", resolver);+ return resolver.promise();+ },}if (self._cancel == null) {@@ -411,7 +455,6 @@ const PipeState = struct {const Cancel = struct {callback: ?js.Function.Global = null,- reason: ?[]const u8 = null,resolver: ?js.PromiseResolver.Global = null,};diff --git a/src/browser/webapi/streams/ReadableStreamDefaultController.zig b/src/browser/webapi/streams/ReadableStreamDefaultController.zigindex 015a939da..3a5e26ff1 100644--- a/src/browser/webapi/streams/ReadableStreamDefaultController.zig+++ b/src/browser/webapi/streams/ReadableStreamDefaultController.zig@@ -205,36 +205,39 @@ pub fn close(self: *ReadableStreamDefaultController) !void {self._pending_reads.clearRetainingCapacity();}-pub fn doError(self: *ReadableStreamDefaultController, err: []const u8) !void {- return self.fail(err, false);+pub fn doError(self: *ReadableStreamDefaultController, reason: ?js.Value) !void {+ return self.fail(try .fromJs(reason));}-/// Like doError, but pending reads reject with a TypeError instead of the-/// bare message, which is what native transforms (e.g. CompressionStream) throw.pub fn typeError(self: *ReadableStreamDefaultController, message: []const u8) !void {- return self.fail(message, true);+ return self.fail(.{ .type_error = try self._arena.dupe(u8, message) });}-fn fail(self: *ReadableStreamDefaultController, err: []const u8, type_error: bool) !void {- if (self._stream._state != .readable) {+fn fail(self: *ReadableStreamDefaultController, err: ReadableStream.StoredError) !void {+ const stream = self._stream;+ if (stream._state != .readable) {return;}- self._stream._state = .errored;- self._stream._stored_error = try self._arena.dupe(u8, err);+ stream._state = .errored;+ stream._stored_error = err;self.clearQueue();- // Reject all pending reads- for (self._pending_reads.items) |resolver| {- const local_resolver = self._execution.js.toLocal(resolver);- if (type_error) {- local_resolver.rejectError("stream error", .{ .type_error = err });- } else {- local_resolver.reject("stream error", err);- }+ // Rejecting runs page JS, which can reach the list too.+ const pending_reads = self._pending_reads;+ self._pending_reads = .empty;+ if (pending_reads.items.len == 0) {+ return;+ }++ var ls: js.Local.Scope = undefined;+ self._execution.js.localScope(&ls);+ defer ls.deinit();++ for (pending_reads.items) |resolver| {+ stream._stored_error.?.reject("stream error", ls.toLocal(resolver));resolver.release();}- self._pending_reads.clearRetainingCapacity();}/// The caller owns the returned global and must release it.@@ -323,6 +326,7 @@ test "ReadableStreamDefaultController: chunks and pending reads release their gl\\new Response('native chunk').body.getReader().read();, null);- // cancel() keeps its own resolver so a repeated cancel returns the same promise.- try testing.expectEqual(base + 1, tracker.list.items.len);+ // cancel() keeps its own resolver so a repeated cancel returns the same+ // promise, and each errored stream keeps what it errored with.+ try testing.expectEqual(base + 3, tracker.list.items.len);}diff --git a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig b/src/browser/webapi/streams/ReadableStreamDefaultReader.zigindex 3f2be22c0..320cca5c4 100644--- a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig+++ b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig@@ -53,8 +53,9 @@ pub fn read(self: *ReadableStreamDefaultReader, exec: *const Execution) !js.Promstream._disturbed = true;if (stream._state == .errored) {- //const err = stream._stored_error orelse "Stream errored";- return local.rejectPromise(.{ .type_error = "Stream errored" });+ const resolver = local.createPromiseResolver();+ stream._stored_error.?.reject("ReadableStreamDefaultReader.read", resolver);+ return resolver.promise();}if (stream._controller.dequeue()) |chunk| {@@ -85,7 +86,7 @@ pub fn releaseLock(self: *ReadableStreamDefaultReader) void {}}-pub fn cancel(self: *ReadableStreamDefaultReader, reason_: ?[]const u8, exec: *const Execution) !js.Promise {+pub fn cancel(self: *ReadableStreamDefaultReader, reason_: ?js.Value, exec: *const Execution) !js.Promise {const stream = self._stream orelse {return exec.js.typeError("Reader has been released");};diff --git a/src/browser/webapi/streams/TransformStream.zig b/src/browser/webapi/streams/TransformStream.zigindex 2470f59e0..dc055db67 100644--- a/src/browser/webapi/streams/TransformStream.zig+++ b/src/browser/webapi/streams/TransformStream.zig@@ -211,13 +211,21 @@ pub const TransformStreamDefaultController = struct {try self._stream._readable._controller.enqueueValue(value);}- fn doError(self: *TransformStreamDefaultController, reason: []const u8) !void {+ /// Errors both sides of the stream. The writable side goes first; erroring+ /// it runs no JS, while rejecting the readable's pending reads does.+ fn doError(self: *TransformStreamDefaultController, reason: ?js.Value) !void {+ try self._stream._writable._controller.doError(reason);try self._stream._readable._controller.doError(reason);}+ /// Errors both sides with the same TypeError object.pub fn typeError(self: *TransformStreamDefaultController, message: []const u8) !void {- try self._stream._readable._controller.typeError(message);- self._stream._writable._controller.doError(message);+ var ls: js.Local.Scope = undefined;+ self._stream._readable._execution.js.localScope(&ls);+ defer ls.deinit();++ const local = &ls.local;+ return self.doError(.{ .local = local, .handle = local.isolate.createTypeError(message) });}pub fn terminate(self: *TransformStreamDefaultController) !void {diff --git a/src/browser/webapi/streams/WritableStream.zig b/src/browser/webapi/streams/WritableStream.zigindex 90f3624f1..ffe15dc65 100644--- a/src/browser/webapi/streams/WritableStream.zig+++ b/src/browser/webapi/streams/WritableStream.zig@@ -18,11 +18,13 @@const js = @import("../../js/js.zig");+const ReadableStream = @import("ReadableStream.zig");const WritableStreamDefaultWriter = @import("WritableStreamDefaultWriter.zig");const WritableStreamDefaultController = @import("WritableStreamDefaultController.zig");const TransformStream = @import("TransformStream.zig");const Execution = js.Execution;+const StoredError = ReadableStream.StoredError;const WritableStream = @This();@@ -35,7 +37,7 @@ pub const State = enum {_state: State,_writer: ?*WritableStreamDefaultWriter,_controller: *WritableStreamDefaultController,-_stored_error: ?[]const u8,+_stored_error: ?StoredError,_write_fn: ?js.Function.Global,_close_fn: ?js.Function.Global,_transform_stream: ?*TransformStream,diff --git a/src/browser/webapi/streams/WritableStreamDefaultController.zig b/src/browser/webapi/streams/WritableStreamDefaultController.zigindex eebb5c3b3..809c4faed 100644--- a/src/browser/webapi/streams/WritableStreamDefaultController.zig+++ b/src/browser/webapi/streams/WritableStreamDefaultController.zig@@ -31,10 +31,10 @@ pub fn init(stream: *WritableStream, exec: *const Execution) !*WritableStreamDef});}-pub fn doError(self: *WritableStreamDefaultController, reason: []const u8) void {+pub fn doError(self: *WritableStreamDefaultController, reason: ?js.Value) !void {if (self._stream._state != .writable) return;self._stream._state = .errored;- self._stream._stored_error = reason;+ self._stream._stored_error = try .fromJs(reason);}pub const JsApi = struct {diff --git a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig b/src/browser/webapi/streams/WritableStreamDefaultWriter.zigindex e149a9625..c97bd38bd 100644--- a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig+++ b/src/browser/webapi/streams/WritableStreamDefaultWriter.zig@@ -37,8 +37,14 @@ pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const Ereturn local.typeError("Writer has been released");};- if (stream._state != .writable) {- return local.typeError("Stream is not writable");+ switch (stream._state) {+ .writable => {},+ .errored => {+ const resolver = local.createPromiseResolver();+ stream._stored_error.?.reject("WritableStreamDefaultWriter.write", resolver);+ return resolver.promise();+ },+ .closed => return local.typeError("Stream is not writable"),}try stream.writeChunk(chunk, exec);