Lightpanda: the headless browser designed for AI and automation
streams: store errors as js.Value.Global, reject writes with them
nikneyma0b9c007ed72
diff --git a/src/browser/tests/compression/compression_stream.html b/src/browser/tests/compression/compression_stream.htmlindex 142c415a7..a758a8b1a 100644--- a/src/browser/tests/compression/compression_stream.html+++ b/src/browser/tests/compression/compression_stream.html@@ -224,10 +224,17 @@const write = await rejection(writer.write(noise(200 * 1024)));const next_write = await rejection(writer.write(new Uint8Array([1])));+ // The flush always has output (the gzip trailer), so close() fails too.+ const closing = new CompressionStream('gzip');+ const closing_writer = closing.writable.getWriter();+ await closing.readable.cancel();+ const close = await rejection(closing_writer.close());+state.resolve();await state.done(() => {testing.expectEqual('TypeError', write);testing.expectEqual('TypeError', next_write);+ testing.expectEqual('TypeError', close);});</script>diff --git a/src/browser/tests/compression/decompression_stream.html b/src/browser/tests/compression/decompression_stream.htmlindex a149453c5..479eece63 100644--- a/src/browser/tests/compression/decompression_stream.html+++ b/src/browser/tests/compression/decompression_stream.html@@ -384,22 +384,45 @@const state = await testing.async();// A stream errored by a bad chunk rejects with one TypeError object, on- // both sides.+ // both sides, starting with the write that failed.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 writer.write('hello').catch((e) => e),await pending_read,await reader.read().catch((e) => e),await reader.cancel().catch((e) => e),await writer.write(new Uint8Array(1)).catch((e) => e),+ await writer.close().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]));+ testing.expectEqual([true, true, true, true, true, true], errors.map((e) => e === errors[0]));+ });+</script>++<script id=stored_flush_error type=module>+ const state = await testing.async();++ // Truncated input only fails in close(), which rejects with the TypeError+ // that both sides errored with.+ const ds = new DecompressionStream('gzip');+ const writer = ds.writable.getWriter();+ await writer.write(new Uint8Array(HELLO.gzip.slice(0, -1)));+ const close_error = await writer.close().catch((e) => e);+ const errors = [+ await ds.readable.getReader().read().catch((e) => e),+ await writer.write(new Uint8Array(1)).catch((e) => e),+ await writer.close().catch((e) => e),+ ];++ state.resolve();+ await state.done(() => {+ testing.expectEqual(true, close_error instanceof TypeError);+ testing.expectEqual([true, true, true], errors.map((e) => e === close_error));});</script>diff --git a/src/browser/tests/streams/readable_stream.html b/src/browser/tests/streams/readable_stream.htmlindex a00ea8edc..d677f751e 100644--- a/src/browser/tests/streams/readable_stream.html+++ b/src/browser/tests/streams/readable_stream.html@@ -454,17 +454,23 @@<script id=stored_error type=module>const state = await testing.async();- // read() and cancel() reject with whatever controller.error() was given.+ // read(), cancel(), write() and close() 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 errored_sink = new WritableStream({ start(c) { c.error('err!'); } }).getWriter();+ const no_reason_sink = new WritableStream({ start(c) { c.error(); } }).getWriter();const results = [await errored.read().catch((e) => e),await errored.cancel().catch((e) => e),await no_reason.read().then(() => 'resolved', (e) => e),+ await errored_sink.write('a').catch((e) => e),+ await errored_sink.close().catch((e) => e),+ await no_reason_sink.close().then(() => 'resolved', (e) => e),];state.resolve();await state.done(() => {- testing.expectEqual(['err!', 'err!', undefined], results);+ testing.expectEqual(['err!', 'err!', undefined, 'err!', 'err!', undefined], results);});</script>diff --git a/src/browser/tests/streams/transform_stream.html b/src/browser/tests/streams/transform_stream.htmlindex 32bedcc68..ee8b2cecd 100644--- a/src/browser/tests/streams/transform_stream.html+++ b/src/browser/tests/streams/transform_stream.html@@ -172,10 +172,14 @@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)];+ const errors = [+ await reader.read().catch((e) => e),+ await writer.write('b').catch((e) => e),+ await writer.close().catch((e) => e),+ ];state.resolve();await state.done(() => {- testing.expectEqual([true, true], errors.map((e) => e === err));+ testing.expectEqual([true, true, true], errors.map((e) => e === err));});</script>diff --git a/src/browser/webapi/compression/brotli.zig b/src/browser/webapi/compression/brotli.zigindex 31931b670..44a67471f 100644--- a/src/browser/webapi/compression/brotli.zig+++ b/src/browser/webapi/compression/brotli.zig@@ -80,7 +80,7 @@ pub const EncodingStream = struct {) !void {self.end();try controller.typeError(message);- return self.exec.js.typeError(message);+ return error.StreamError;}/// Feed the stream and collect encoded bytes.@@ -231,7 +231,7 @@ pub const DecodingStream = struct {) !void {self.end();try controller.typeError(message);- return self.exec.js.typeError(message);+ return error.StreamError;}/// Feed the stream and collect decoded bytes.diff --git a/src/browser/webapi/compression/zlib.zig b/src/browser/webapi/compression/zlib.zigindex 970213ee7..db42530a3 100644--- a/src/browser/webapi/compression/zlib.zig+++ b/src/browser/webapi/compression/zlib.zig@@ -97,7 +97,7 @@ pub fn Deflate(comptime mode: enum(u1) { compress, decompress }) type {fn fail(self: *Deflate(mode), controller: *TransformStream.DefaultController, message: []const u8) !void {self.end();try controller.typeError(message);- return self.exec.js.typeError(message);+ return error.StreamError;}const FeedError = error{ StreamNotReadable, OutOfMemory, CreateObjectFailure, HasJunkData, InvalidData };diff --git a/src/browser/webapi/streams/ReadableStream.zig b/src/browser/webapi/streams/ReadableStream.zigindex 5ca167dc3..57a7d7140 100644--- a/src/browser/webapi/streams/ReadableStream.zig+++ b/src/browser/webapi/streams/ReadableStream.zig@@ -43,47 +43,12 @@ 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: ?StoredError,+/// What the stream errored with, e.g. the `e` of controller.error(e).+_stored_error: ?js.Value.Global,_pull_fn: ?js.Function.Global = null,_pulling: bool = false,_pull_again: bool = false,@@ -288,7 +253,7 @@ pub fn cancel(self: *ReadableStream, reason: ?js.Value, exec: *const Execution)},.errored => {const resolver = local.createPromiseResolver();- self._stored_error.?.reject("ReadableStream.cancel", resolver);+ resolver.reject("ReadableStream.cancel", self._stored_error.?);return resolver.promise();},}diff --git a/src/browser/webapi/streams/ReadableStreamDefaultController.zig b/src/browser/webapi/streams/ReadableStreamDefaultController.zigindex 3a5e26ff1..6212056a8 100644--- a/src/browser/webapi/streams/ReadableStreamDefaultController.zig+++ b/src/browser/webapi/streams/ReadableStreamDefaultController.zig@@ -206,36 +206,39 @@ pub fn close(self: *ReadableStreamDefaultController) !void {}pub fn doError(self: *ReadableStreamDefaultController, reason: ?js.Value) !void {- return self.fail(try .fromJs(reason));+ var ls: js.Local.Scope = undefined;+ self._execution.js.localScope(&ls);+ defer ls.deinit();++ const local = &ls.local;+ return self.fail(local, reason orelse .{ .local = local, .handle = local.isolate.initUndefined() });}pub fn typeError(self: *ReadableStreamDefaultController, message: []const u8) !void {- return self.fail(.{ .type_error = try self._arena.dupe(u8, message) });+ var ls: js.Local.Scope = undefined;+ self._execution.js.localScope(&ls);+ defer ls.deinit();++ const local = &ls.local;+ return self.fail(local, .{ .local = local, .handle = local.isolate.createTypeError(message) });}-fn fail(self: *ReadableStreamDefaultController, err: ReadableStream.StoredError) !void {+/// Errors the stream. Pending and later reads reject with `reason` itself.+pub fn fail(self: *ReadableStreamDefaultController, local: *const js.Local, reason: js.Value) !void {const stream = self._stream;if (stream._state != .readable) {return;}+ stream._stored_error = try reason.persist();stream._state = .errored;- stream._stored_error = err;self.clearQueue();// 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));+ local.toLocal(resolver).reject("stream error", reason);resolver.release();}}diff --git a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig b/src/browser/webapi/streams/ReadableStreamDefaultReader.zigindex 320cca5c4..4cd1c5925 100644--- a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig+++ b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig@@ -54,7 +54,7 @@ pub fn read(self: *ReadableStreamDefaultReader, exec: *const Execution) !js.Promif (stream._state == .errored) {const resolver = local.createPromiseResolver();- stream._stored_error.?.reject("ReadableStreamDefaultReader.read", resolver);+ resolver.reject("ReadableStreamDefaultReader.read", stream._stored_error.?);return resolver.promise();}diff --git a/src/browser/webapi/streams/TransformStream.zig b/src/browser/webapi/streams/TransformStream.zigindex dc055db67..8e729370c 100644--- a/src/browser/webapi/streams/TransformStream.zig+++ b/src/browser/webapi/streams/TransformStream.zig@@ -211,11 +211,9 @@ pub const TransformStreamDefaultController = struct {try self._stream._readable._controller.enqueueValue(value);}- /// 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);+ fn doError(self: *TransformStreamDefaultController, reason: ?js.Value, exec: *const Execution) !void {+ const local = exec.js.local.?;+ return self.fail(local, reason orelse .{ .local = local, .handle = local.isolate.initUndefined() });}/// Errors both sides with the same TypeError object.@@ -225,7 +223,14 @@ pub const TransformStreamDefaultController = struct {defer ls.deinit();const local = &ls.local;- return self.doError(.{ .local = local, .handle = local.isolate.createTypeError(message) });+ return self.fail(local, .{ .local = local, .handle = local.isolate.createTypeError(message) });+ }++ /// 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 fail(self: *TransformStreamDefaultController, local: *const js.Local, reason: js.Value) !void {+ try self._stream._writable._controller.fail(reason);+ try self._stream._readable._controller.fail(local, reason);}pub fn terminate(self: *TransformStreamDefaultController) !void {diff --git a/src/browser/webapi/streams/WritableStream.zig b/src/browser/webapi/streams/WritableStream.zigindex ffe15dc65..b6198abc8 100644--- a/src/browser/webapi/streams/WritableStream.zig+++ b/src/browser/webapi/streams/WritableStream.zig@@ -18,13 +18,11 @@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();@@ -37,7 +35,8 @@ pub const State = enum {_state: State,_writer: ?*WritableStreamDefaultWriter,_controller: *WritableStreamDefaultController,-_stored_error: ?StoredError,+/// What the stream errored with, e.g. the `e` of controller.error(e).+_stored_error: ?js.Value.Global,_write_fn: ?js.Function.Global,_close_fn: ?js.Function.Global,_transform_stream: ?*TransformStream,@@ -125,8 +124,19 @@ pub fn closeStream(self: *WritableStream, exec: *const Execution) !void {self._state = .closed;if (self._transform_stream) |ts| {- try ts.transformClose(exec);- return;+ return ts.transformClose(exec) catch |err| {+ // The flush failed and errored the readable side. Like a failed+ // close in the spec, this side ends up errored too. A cancelled+ // readable has nothing stored, and this side stays closed.+ if (err == error.StreamError) {+ if (ts._readable._stored_error) |stored| {+ const local = exec.js.local.?;+ self._stored_error = try local.toLocal(stored).persist();+ self._state = .errored;+ }+ }+ return err;+ };}if (self._close_fn) |close_fn| {diff --git a/src/browser/webapi/streams/WritableStreamDefaultController.zig b/src/browser/webapi/streams/WritableStreamDefaultController.zigindex 809c4faed..818eb9ed3 100644--- a/src/browser/webapi/streams/WritableStreamDefaultController.zig+++ b/src/browser/webapi/streams/WritableStreamDefaultController.zig@@ -31,10 +31,16 @@ pub fn init(stream: *WritableStream, exec: *const Execution) !*WritableStreamDef});}-pub fn doError(self: *WritableStreamDefaultController, reason: ?js.Value) !void {+pub fn doError(self: *WritableStreamDefaultController, reason: ?js.Value, exec: *const Execution) !void {+ const local = exec.js.local.?;+ return self.fail(reason orelse .{ .local = local, .handle = local.isolate.initUndefined() });+}++/// Errors the stream. Later writes reject with `reason` itself.+pub fn fail(self: *WritableStreamDefaultController, reason: js.Value) !void {if (self._stream._state != .writable) return;+ self._stream._stored_error = try reason.persist();self._stream._state = .errored;- 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 c97bd38bd..3d1354f4f 100644--- a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig+++ b/src/browser/webapi/streams/WritableStreamDefaultWriter.zig@@ -37,17 +37,14 @@ pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const Ereturn local.typeError("Writer has been released");};- 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"),+ if (stream._state != .writable) {+ return rejectNotWritable(stream, local);}- try stream.writeChunk(chunk, exec);+ stream.writeChunk(chunk, exec) catch |err| switch (err) {+ error.StreamError => return rejectNotWritable(stream, local),+ else => return err,+ };return local.resolvePromise(.{});}@@ -59,14 +56,29 @@ pub fn close(self: *WritableStreamDefaultWriter, exec: *const Execution) !js.Pro};if (stream._state != .writable) {- return local.typeError("Stream is not writable");+ return rejectNotWritable(stream, local);}- try stream.closeStream(exec);+ stream.closeStream(exec) catch |err| switch (err) {+ error.StreamError => return rejectNotWritable(stream, local),+ else => return err,+ };return local.resolvePromise(.{});}+/// An errored stream rejects with what it errored with; a closed one with a TypeError.+fn rejectNotWritable(stream: *const WritableStream, local: *const js.Local) !js.Promise {+ switch (stream._state) {+ .writable, .closed => return local.typeError("Stream is not writable"),+ .errored => {+ const resolver = local.createPromiseResolver();+ resolver.reject("WritableStreamDefaultWriter", stream._stored_error.?);+ return resolver.promise();+ },+ }+}+pub fn releaseLock(self: *WritableStreamDefaultWriter) void {if (self._stream) |stream| {stream._writer = null;