Lightpanda: the headless browser designed for AI and automation
wpt: improve webcrypto WPT results
Karl Seguinb415cbe9444c
diff --git a/src/browser/js/Caller.zig b/src/browser/js/Caller.zigindex 6bc056b34..4e9deed75 100644--- a/src/browser/js/Caller.zig+++ b/src/browser/js/Caller.zig@@ -605,10 +605,29 @@ fn handleError(comptime T: type, comptime F: type, local: *const Local, err: any};};+ if (comptime returnsPromise(F) and @TypeOf(info) == FunctionCallbackInfo) {+ // An operation that returns a promise must not throw. It rejects.+ const resolver = js.PromiseResolver.init(&err_local);+ resolver.rejectValue(.{ .local = &err_local, .handle = js_err }) catch |reject_err| {+ log.err(.bug, "handleError reject", .{ .err = reject_err });+ };+ info.getReturnValue().set(resolver.promise().toValue());+ return;+ }+const js_exception = isolate.throwException(js_err);info.getReturnValue().setValueHandle(js_exception);}+fn returnsPromise(comptime F: type) bool {+ const R = @typeInfo(F).@"fn".return_type orelse return false;+ const payload = switch (@typeInfo(R)) {+ .error_union => |eu| eu.payload,+ else => R,+ };+ return payload == js.Promise;+}+// Convert a Zig error to a DOMException. If the error is unknown, return null.fn domExceptionToJs(local: *const Local, err: anyerror) ?*const v8.Value {const DOMException = @import("../webapi/DOMException.zig");diff --git a/src/browser/js/PromiseResolver.zig b/src/browser/js/PromiseResolver.zigindex 287ddd221..d6e9fe571 100644--- a/src/browser/js/PromiseResolver.zig+++ b/src/browser/js/PromiseResolver.zig@@ -108,13 +108,19 @@ pub fn rejectError(fn _reject(self: PromiseResolver, value: anytype) !void {const local = self.local;const js_val = try local.zigValueToJs(value, .{});+ try self.rejectValue(js_val);+ local.runMicrotasks();+}+/// Rejects with an already-built JS value, without running a microtask+/// checkpoint. For use while the calling script is still on the stack, where+/// draining the queue would run unrelated reactions mid-script.+pub fn rejectValue(self: PromiseResolver, value: js.Value) !void {var out: v8.MaybeBool = undefined;- v8.v8__Promise__Resolver__Reject(self.handle, local.handle, js_val.handle, &out);+ v8.v8__Promise__Resolver__Reject(self.handle, self.local.handle, value.handle, &out);if (!out.has_value or !out.value) {return error.FailedToRejectPromise;}- local.runMicrotasks();}pub fn persist(self: PromiseResolver) !Global {diff --git a/src/browser/js/bridge.zig b/src/browser/js/bridge.zigindex bd2088395..a49444ff2 100644--- a/src/browser/js/bridge.zig+++ b/src/browser/js/bridge.zig@@ -962,6 +962,7 @@ pub const PageJsApis = flattenTypes(&.{@import("../webapi/DocumentType.zig"),@import("../webapi/ShadowRoot.zig"),@import("../webapi/DOMException.zig"),+ @import("../webapi/QuotaExceededError.zig"),@import("../webapi/DOMImplementation.zig"),@import("../webapi/DOMTreeWalker.zig"),@import("../webapi/DOMNodeIterator.zig"),@@ -1229,6 +1230,7 @@ const worker_common_apis = [_]type{@import("../webapi/event/PromiseRejectionEvent.zig"),@import("../webapi/event/CloseEvent.zig"),@import("../webapi/DOMException.zig"),+ @import("../webapi/QuotaExceededError.zig"),@import("../webapi/DOMRectReadOnly.zig"),@import("../webapi/DOMRect.zig"),@import("../webapi/DOMMatrixReadOnly.zig"),diff --git a/src/browser/webapi/Crypto.zig b/src/browser/webapi/Crypto.zigindex 714b89543..cdd0a9a26 100644--- a/src/browser/webapi/Crypto.zig+++ b/src/browser/webapi/Crypto.zig@@ -20,6 +20,7 @@ const lp = @import("lightpanda");const js = @import("../js/js.zig");const SubtleCrypto = @import("SubtleCrypto.zig");+const QuotaExceededError = @import("QuotaExceededError.zig");const Crypto = @This();_subtle: SubtleCrypto = .{},@@ -28,11 +29,17 @@ pub const init: Crypto = .{};// We take a js.Value, because we want to return the same instance, not a new// TypedArray-pub fn getRandomValues(_: *const Crypto, js_obj: js.Object) !js.Object {+pub fn getRandomValues(_: *const Crypto, js_obj: js.Object, exec: *const js.Execution) !js.Object {+ const value = js_obj.toValue();+ if (value.isFloat16Array() or value.isFloat32Array() or value.isFloat64Array() or (value.isArrayBufferView() and !value.isTypedArray())) {+ // only integer TypedArrays are supported+ return error.TypeMismatch;+ }+var into = try js_obj.toZig(RandomValues);const buf = into.asBuffer();if (buf.len > 65_536) {- return error.QuotaExceeded;+ return QuotaExceededError.throw(js_obj.local, exec);}lp.io.random(buf);return js_obj;diff --git a/src/browser/webapi/DOMException.zig b/src/browser/webapi/DOMException.zigindex ab18fa05c..8dd7850dd 100644--- a/src/browser/webapi/DOMException.zig+++ b/src/browser/webapi/DOMException.zig@@ -50,6 +50,7 @@ pub fn fromError(err: anyerror) ?DOMException {error.InvalidModification => .{ ._code = .invalid_modification_error },error.NamespaceError => .{ ._code = .namespace_error },error.InvalidAccess => .{ ._code = .invalid_access_error },+ error.TypeMismatch => .{ ._code = .type_mismatch_error },error.SecurityError => .{ ._code = .security_error },error.NetworkError => .{ ._code = .network_error },error.AbortError => .{ ._code = .abort_error },@@ -97,6 +98,7 @@ pub fn getName(self: *const DOMException) []const u8 {.invalid_modification_error => "InvalidModificationError",.namespace_error => "NamespaceError",.invalid_access_error => "InvalidAccessError",+ .type_mismatch_error => "TypeMismatchError",.security_error => "SecurityError",.network_error => "NetworkError",.abort_error => "AbortError",@@ -133,6 +135,7 @@ pub fn getMessage(self: *const DOMException) []const u8 {.invalid_modification_error => "The object can not be modified in this way",.namespace_error => "The operation is not allowed by Namespaces in XML",.invalid_access_error => "The object does not support the operation or argument",+ .type_mismatch_error => "The type of an object was incompatible with the expected type of the parameter associated to the object",.security_error => "The operation is insecure",.network_error => "A network error occurred",.abort_error => "The operation was aborted",@@ -178,6 +181,7 @@ const Code = enum(u8) {invalid_modification_error = 13,namespace_error = 14,invalid_access_error = 15,+ type_mismatch_error = 17,security_error = 18,network_error = 19,abort_error = 20,@@ -216,6 +220,7 @@ const Code = enum(u8) {.{ "InvalidModificationError", .invalid_modification_error },.{ "NamespaceError", .namespace_error },.{ "InvalidAccessError", .invalid_access_error },+ .{ "TypeMismatchError", .type_mismatch_error },.{ "SecurityError", .security_error },.{ "NetworkError", .network_error },.{ "AbortError", .abort_error },diff --git a/src/browser/webapi/QuotaExceededError.zig b/src/browser/webapi/QuotaExceededError.zignew file mode 100644index 000000000..2b44fb212--- /dev/null+++ b/src/browser/webapi/QuotaExceededError.zig@@ -0,0 +1,88 @@+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)+//+// Francis Bouvier <[email protected]>+// Pierre Tachoire <[email protected]>+//+// This program is free software: you can redistribute it and/or modify+// it under the terms of the GNU Affero General Public License as+// published by the Free Software Foundation, either version 3 of the+// License, or (at your option) any later version.+//+// This program is distributed in the hope that it will be useful,+// but WITHOUT ANY WARRANTY; without even the implied warranty of+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+// GNU Affero General Public License for more details.+//+// You should have received a copy of the GNU Affero General Public License+// along with this program. If not, see <https://www.gnu.org/licenses/>.++const js = @import("../js/js.zig");++const DOMException = @import("DOMException.zig");++const Execution = js.Execution;++const QuotaExceededError = @This();++pub const Proto = DOMException;++_proto: *DOMException,+_quota: ?f64 = null,+_requested: ?f64 = null,++const Options = struct {+ quota: ?f64 = null,+ requested: ?f64 = null,+};++pub fn init(message_: ?[]const u8, options_: ?Options, exec: *const Execution) !*QuotaExceededError {+ const opts = options_ orelse Options{};+ if (opts.quota) |quota| {+ if (quota < 0) {+ return error.RangeError;+ }+ }+ if (opts.requested) |requested| {+ if (requested < 0) {+ return error.RangeError;+ }+ }+ if (opts.quota != null and opts.requested != null and opts.requested.? < opts.quota.?) {+ return error.RangeError;+ }++ const message = if (message_) |m| try exec.dupeString(m) else null;+ return exec._factory.chained(.{+ DOMException.init(message, "QuotaExceededError"),+ QuotaExceededError{ ._proto = undefined, ._quota = opts.quota, ._requested = opts.requested },+ });+}++pub fn throw(local: *const js.Local, exec: *const Execution) error{ TryCatchRethrow, OutOfMemory } {+ const self = init(null, null, exec) catch return error.OutOfMemory;+ const js_val = local.zigValueToJs(self, .{}) catch return error.OutOfMemory;+ _ = local.isolate.throwException(js_val.handle);+ return error.TryCatchRethrow;+}++pub fn getQuota(self: *const QuotaExceededError) ?f64 {+ return self._quota;+}++pub fn getRequested(self: *const QuotaExceededError) ?f64 {+ return self._requested;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(QuotaExceededError);++ pub const Meta = struct {+ pub const name = "QuotaExceededError";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const constructor = bridge.constructor(QuotaExceededError.init, .{});+ pub const quota = bridge.accessor(QuotaExceededError.getQuota, null, .{});+ pub const requested = bridge.accessor(QuotaExceededError.getRequested, null, .{});+};diff --git a/src/browser/webapi/SubtleCrypto.zig b/src/browser/webapi/SubtleCrypto.zigindex 8743aed04..f6b030a9e 100644--- a/src/browser/webapi/SubtleCrypto.zig+++ b/src/browser/webapi/SubtleCrypto.zig@@ -524,10 +524,10 @@ pub fn verify(/// or an object (`{name: "SHA-256"}`). The object variant must come first — a/// `[]const u8` coerces *any* JS value to a string, so it has to be the fallback.const DigestInput = union(enum) {- obj: struct { name: []const u8 },+ obj: struct { name: ?[]const u8 = null },str: []const u8,- fn name(self: DigestInput) []const u8 {+ fn name(self: DigestInput) ?[]const u8 {return switch (self) {.obj => |o| o.name,.str => |s| s,@@ -539,7 +539,9 @@ const DigestInput = union(enum) {pub fn digest(_: *const SubtleCrypto, algo: DigestInput, data: js.TypedArray(u8), exec: *const Execution) !js.Promise {const local = exec.js.local.?;- const algo_name = algo.name();+ const algo_name = algo.name() orelse {+ return local.rejectPromise(.{ .type_error = "required member name is undefined" });+ };if (algo_name.len > 10) {return local.rejectPromise(.{ .dom_exception = .{ .err = error.NotSupported } });}diff --git a/src/browser/webapi/crypto/HMAC.zig b/src/browser/webapi/crypto/HMAC.zigindex 475b6553b..19f6d51c6 100644--- a/src/browser/webapi/crypto/HMAC.zig+++ b/src/browser/webapi/crypto/HMAC.zig@@ -37,6 +37,11 @@ pub fn init(exec: *const Execution,) !js.Promise {const local = exec.js.local.?;+ // The union probe match to get here is pretty simple, so we can end up here+ // for an unknown/invalid algo.+ if (!std.ascii.eqlIgnoreCase(params.name, "HMAC")) {+ return local.rejectPromise(.{ .dom_exception = .{ .err = error.NotSupported } });+ }const hash_name = switch (params.hash) {.string => |str| str,.object => |obj| obj.name,diff --git a/src/browser/webapi/crypto/algorithm.zig b/src/browser/webapi/crypto/algorithm.zigindex aa96c0e53..8eb9404ef 100644--- a/src/browser/webapi/crypto/algorithm.zig+++ b/src/browser/webapi/crypto/algorithm.zig@@ -26,12 +26,13 @@ const CryptoKey = @import("../CryptoKey.zig");pub const Init = union(enum) {/// For RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP: pass an RsaHashedKeyGenParams object.rsa_hashed_key_gen: RsaHashedKeyGen,+ /// Must be before `hmac_key_gen`, since we need to ignore this param even+ /// if it has a 'hash' property, and if it's after, we'll match that instead.+ ec_key_gen: EcKeyGen,/// For HMAC: pass an HmacKeyGenParams object.hmac_key_gen: HmacKeyGen,/// For AES variants: pass an AesKeyGenParams object.aes_key_gen: AesKeyGen,- /// For ECDSA / ECDH: pass an EcKeyGenParams object.- ec_key_gen: EcKeyGen,/// don't use []const u8 here, we don't want non-strings coerced. Let those/// fall to the invalid case