Skip to content

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.html
index 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.html
index 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.html
index 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.html
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.zig
index 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.Prom
if (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.zig
index 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.zig
index 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.zig
index 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.zig
index 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 E
return 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;