Lightpanda: the headless browser designed for AI and automation
webapi: IndexedDB base
Karl Seguin47d540a69a7c
diff --git a/src/Config.zig b/src/Config.zigindex c5c574f8b..957fde542 100644--- a/src/Config.zig+++ b/src/Config.zig@@ -116,6 +116,7 @@ const CommonOptions = .{.{ .name = "enable_external_stylesheets", .type = bool },.{ .name = "v8_flags_unsafe", .type = ?[]const u8 },.{ .name = "v8_max_heap_mb", .type = ?u32 },+ .{ .name = "indexdb_dir", .type = ?[:0]const u8 },};fn dumpValidator(_: Allocator, args: *std.process.ArgIterator) !?DumpFormat {@@ -583,6 +584,13 @@ pub fn storageSqlitePath(self: *const Config) ?[:0]const u8 {};}+pub fn indexDBDir(self: *const Config) ?[:0]const u8 {+ return switch (self.mode) {+ inline .serve, .fetch, .mcp, .agent => |opts| opts.indexdb_dir,+ else => unreachable,+ };+}+pub const DumpFormat = enum {html,markdown,diff --git a/src/browser/Session.zig b/src/browser/Session.zigindex 4d6d67918..228bc9c77 100644--- a/src/browser/Session.zig+++ b/src/browser/Session.zig@@ -22,9 +22,10 @@ const builtin = @import("builtin");const App = @import("../App.zig");+const History = @import("webapi/History.zig");const storage = @import("webapi/storage/storage.zig");+const IdbManager = @import("webapi/storage/idb/idb.zig").Manager;const Navigation = @import("webapi/navigation/Navigation.zig");-const History = @import("webapi/History.zig");const Page = @import("Page.zig");const Frame = @import("Frame.zig");@@ -50,6 +51,8 @@ arena: Allocator,history: History,navigation: Navigation,storage_shed: storage.Shed,+// Per-origin IndexedDB engines+idb: IdbManager,// Backs `globalThis.lp.*`; values pre-stringified so the prelude splices// them in without re-encoding.bridge_store: std.StringHashMapUnmanaged([]const u8) = .empty,@@ -159,6 +162,7 @@ pub fn init(self: *Session, browser: *Browser, notification: *Notification) !voi// The prototype (EventTarget) for Navigation is created when a Frame is created..navigation = .{ ._proto = undefined },.storage_shed = .{},+ .idb = IdbManager.init(allocator, browser.app.config.indexDBDir()),.browser = browser,.notification = notification,.cookie_jar = storage.Cookie.Jar.init(allocator, notification),@@ -183,6 +187,7 @@ pub fn deinit(self: *Session) void {self.browser.env.memoryPressureNotification(.critical);self.storage_shed.deinit(self.browser.app.allocator);+ self.idb.deinit();{const allocator = self.browser.app.allocator;var it = self.bridge_store.iterator();diff --git a/src/browser/js/String.zig b/src/browser/js/String.zigindex c405b0e1c..b6dff8158 100644--- a/src/browser/js/String.zig+++ b/src/browser/js/String.zig@@ -50,12 +50,21 @@ pub fn toValue(self: String) js.Value {pub fn toSlice(self: String) ![]u8 {return self._toSlice(false, self.local.call_arena);}+pub fn toSliceZ(self: String) ![:0]u8 {return self._toSlice(true, self.local.call_arena);}+pub fn toSliceWithAlloc(self: String, allocator: Allocator) ![]u8 {return self._toSlice(false, allocator);}++// e.g. after a header byte — instead of allocating a temporary and copying.+pub fn toSliceWithBuf(self: String, buf: []u8) []u8 {+ const n = v8.v8__String__WriteUtf8(self.handle, self.local.isolate.handle, buf.ptr, buf.len, v8.NO_NULL_TERMINATION | v8.REPLACE_INVALID_UTF8);+ return buf[0..@intCast(n)];+}+fn _toSlice(self: String, comptime null_terminate: bool, allocator: Allocator) !(if (null_terminate) [:0]u8 else []u8) {const local = self.local;const handle = self.handle;diff --git a/src/browser/js/Value.zig b/src/browser/js/Value.zigindex 358561df8..dfab1f85f 100644--- a/src/browser/js/Value.zig+++ b/src/browser/js/Value.zig@@ -370,6 +370,7 @@ pub fn serialize(self: Value) !Serialized {.throw_data_clone_error = CloneDelegate.throwDataCloneError,}) orelse return error.JsException;defer v8.v8__ValueSerializer__DELETE(serializer);+// the delegate callbacks only fire during WriteValue, after this is setdelegate_ctx.serializer = serializer;diff --git a/src/browser/js/bridge.zig b/src/browser/js/bridge.zigindex 116da83b1..5082f54bf 100644--- a/src/browser/js/bridge.zig+++ b/src/browser/js/bridge.zig@@ -968,6 +968,7 @@ pub const PageJsApis = flattenTypes(&.{@import("../webapi/Node.zig"),@import("../webapi/storage/storage.zig"),@import("../webapi/storage/CookieStore.zig"),+ @import("../webapi/storage/idb/idb.zig"),@import("../webapi/event/CookieChangeEvent.zig"),@import("../webapi/URL.zig"),@import("../webapi/Window.zig"),@@ -1061,6 +1062,7 @@ pub const WorkerJsApis = flattenTypes(&.{@import("../webapi/Performance.zig"),@import("../webapi/PerformanceObserver.zig"),@import("../webapi/storage/CookieStore.zig"),+ @import("../webapi/storage/idb/idb.zig"),@import("../webapi/event/CookieChangeEvent.zig"),@import("../webapi/BroadcastChannel.zig"),@import("../webapi/event/CustomEvent.zig"),diff --git a/src/browser/tests/indexeddb.html b/src/browser/tests/indexeddb.htmlnew file mode 100644index 000000000..1c818a6eb--- /dev/null+++ b/src/browser/tests/indexeddb.html@@ -0,0 +1,330 @@+<!DOCTYPE html>+<body>+<script src="testing.js"></script>++<!-- The bare-slice milestone: open a database, create an object store during+ the upgrade, then add and read back a structured-cloned value. Exercises+ the async request model (upgradeneeded -> success), transaction autocommit+ (the writes commit when the drain task runs), and the value-serialization+ seam. -->+<script id="open_add_get" type=module>+{+ const state = await testing.async();+ const req = indexedDB.open("books-db", 1);++ let upgraded = false;+ req.onupgradeneeded = (e) => {+ const db = e.target.result;+ db.createObjectStore("books");+ upgraded = true;+ };++ req.onsuccess = (e) => {+ const db = e.target.result;+ testing.expectEqual("books-db", db.name);+ testing.expectEqual(1, db.version);++ const tx = db.transaction("books", "readwrite");+ const store = tx.objectStore("books");+ store.add({ title: "Dune", pages: 412 }, "b1");++ const getReq = store.get("b1");+ getReq.onsuccess = () => {+ state.resolve({ upgraded, value: getReq.result, readyState: getReq.readyState });+ };+ };++ await state.done((got) => {+ testing.expectEqual(true, got.upgraded);+ testing.expectEqual("done", got.readyState);+ testing.expectEqual("Dune", got.value.title);+ testing.expectEqual(412, got.value.pages);+ });+}+</script>++<!-- A missing key resolves the request with `undefined` (not an error). -->+<script id="get_missing" type=module>+{+ const state = await testing.async();+ const req = indexedDB.open("misc-db", 1);+ req.onupgradeneeded = (e) => e.target.result.createObjectStore("kv");+ req.onsuccess = (e) => {+ const store = e.target.result.transaction("kv", "readonly").objectStore("kv");+ const getReq = store.get("absent");+ getReq.onsuccess = () => state.resolve(getReq.result);+ };+ await state.done((result) => {+ testing.expectEqual(undefined, result);+ });+}+</script>++<!-- A numeric key and a second connection see data written earlier in the+ session: the engine persists across open() calls within the origin. -->+<script id="numeric_key_persists" type=module>+{+ const state = await testing.async();+ const open1 = indexedDB.open("nums-db", 1);+ open1.onupgradeneeded = (e) => e.target.result.createObjectStore("s");+ open1.onsuccess = (e) => {+ const store = e.target.result.transaction("s", "readwrite").objectStore("s");+ store.add("forty-two", 42);++ // Re-open and read back via a fresh connection/transaction.+ const open2 = indexedDB.open("nums-db");+ open2.onsuccess = (e2) => {+ const getReq = e2.target.result.transaction("s", "readonly").objectStore("s").get(42);+ getReq.onsuccess = () => state.resolve(getReq.result);+ };+ };+ await state.done((value) => {+ testing.expectEqual("forty-two", value);+ });+}+</script>++<!-- Version rules: version 0 is a synchronous TypeError; reopening at the same+ version does not re-run upgradeneeded; a downgrade fails via onerror rather+ than onsuccess. -->+<script id="version_rules" type=module>+{+ let threw = null;+ try { indexedDB.open("ver-db", 0); } catch (e) { threw = e; }+ testing.expectEqual(true, threw instanceof TypeError);++ const state = await testing.async();+ const open1 = indexedDB.open("ver-db", 2);+ let firstUpgrade = false;+ open1.onupgradeneeded = () => { firstUpgrade = true; };+ open1.onsuccess = () => {+ testing.expectEqual(true, firstUpgrade);++ // Same version again: opens successfully, no second upgrade.+ const open2 = indexedDB.open("ver-db", 2);+ let secondUpgrade = false;+ open2.onupgradeneeded = () => { secondUpgrade = true; };+ open2.onsuccess = () => {+ // Downgrade to a lower version: must reject via onerror.+ const open3 = indexedDB.open("ver-db", 1);+ open3.onsuccess = () => state.resolve({ downgradeRejected: false, secondUpgrade });+ open3.onerror = () => state.resolve({ downgradeRejected: true, secondUpgrade });+ };+ };++ await state.done((got) => {+ testing.expectEqual(false, got.secondUpgrade);+ testing.expectEqual(true, got.downgradeRejected);+ });+}+</script>++<!-- A store handle retained past its transaction's completion is inactive:+ operating on it throws TransactionInactiveError rather than touching the+ transaction's released arena. -->+<script id="store_after_complete" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("inactive-db", 1);+ open.onupgradeneeded = (e) => e.target.result.createObjectStore("s");+ open.onsuccess = (e) => {+ const tx = e.target.result.transaction("s", "readwrite");+ const store = tx.objectStore("s");+ store.put("v", "k");+ tx.oncomplete = () => {+ // The transaction has finished; the retained store is now inactive.+ let threw = null;+ try { store.get("k"); } catch (err) { threw = err; }+ state.resolve(threw);+ };+ };+ await state.done((threw) => {+ testing.expectEqual(true, threw !== null);+ testing.expectEqual("TransactionInactiveError", threw.name);+ });+}+</script>++<!-- deleteDatabase removes the database: reopening recreates it (upgradeneeded+ fires again, version back to 1). -->+<script id="delete_database" type=module>+{+ const state = await testing.async();+ const open1 = indexedDB.open("del-db", 3);+ open1.onupgradeneeded = (e) => e.target.result.createObjectStore("s");+ open1.onsuccess = (e) => {+ e.target.result.close();+ const del = indexedDB.deleteDatabase("del-db");+ del.onsuccess = () => {+ const open2 = indexedDB.open("del-db");+ let reUpgraded = false;+ open2.onupgradeneeded = () => { reUpgraded = true; };+ open2.onsuccess = (e2) => state.resolve({ reUpgraded, version: e2.target.result.version });+ };+ };+ await state.done((got) => {+ // Reopening triggered an upgrade and reset the version, proving the+ // database (which had been at version 3) was actually deleted.+ testing.expectEqual(true, got.reUpgraded);+ testing.expectEqual(1, got.version);+ });+}+</script>++<!-- indexedDB.cmp orders keys (-1/0/1); numbers sort before strings; an+ invalid key is a DataError. -->+<script id="cmp" type=module>+{+ testing.expectEqual(-1, indexedDB.cmp(1, 2));+ testing.expectEqual(0, indexedDB.cmp(2, 2));+ testing.expectEqual(1, indexedDB.cmp(2, 1));+ testing.expectEqual(-1, indexedDB.cmp("apple", "banana"));+ testing.expectEqual(-1, indexedDB.cmp(999, "0")); // number < string++ let threw = null;+ try { indexedDB.cmp(1, {}); } catch (e) { threw = e; }+ testing.expectEqual("DataError", threw && threw.name);+}+</script>++<!-- During upgradeneeded, request.transaction is the versionchange transaction;+ a store created in the upgrade belongs to it and seeded data persists. -->+<script id="request_transaction" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("rt-db", 1);+ let mode = null, present = false;+ open.onupgradeneeded = (e) => {+ const tx = e.target.transaction;+ present = tx != null;+ mode = tx && tx.mode;+ e.target.result.createObjectStore("s").add("hello", "k"); // store bound to the txn+ };+ open.onsuccess = (e) => {+ const g = e.target.result.transaction("s", "readonly").objectStore("s").get("k");+ g.onsuccess = () => state.resolve({ present, mode, value: g.result });+ };+ await state.done((got) => {+ testing.expectEqual(true, got.present);+ testing.expectEqual("versionchange", got.mode);+ testing.expectEqual("hello", got.value);+ });+}+</script>++<!-- transaction.abort() in upgradeneeded rolls the upgrade back: the open+ request fails with AbortError and the database is not created. -->+<script id="abort_upgrade" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("abrt-db", 1);+ open.onupgradeneeded = (e) => {+ e.target.result.createObjectStore("s");+ e.target.transaction.abort();+ };+ open.onerror = () => {+ const open2 = indexedDB.open("abrt-db");+ let reUpgraded = false;+ open2.onupgradeneeded = () => { reUpgraded = true; };+ open2.onsuccess = () => state.resolve({ errName: open.error && open.error.name, reUpgraded });+ };+ await state.done((got) => {+ testing.expectEqual("AbortError", got.errName);+ testing.expectEqual(true, got.reUpgraded); // rollback undid the database creation+ });+}+</script>++<!-- deleteObjectStore removes a store during the upgrade. -->+<script id="delete_object_store" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("dos-db", 1);+ open.onupgradeneeded = (e) => {+ const db = e.target.result;+ db.createObjectStore("temp");+ db.deleteObjectStore("temp");+ };+ open.onsuccess = (e) => {+ const tx = e.target.result.transaction("temp", "readonly");+ let threw = null;+ try { tx.objectStore("temp"); } catch (err) { threw = err; }+ state.resolve(threw && threw.name);+ };+ await state.done((name) => {+ testing.expectEqual("NotFoundError", name);+ });+}+</script>++<!-- upgradeneeded is an IDBVersionChangeEvent (oldVersion/newVersion), and the+ store query methods (count, getAll) + durability work. -->+<script id="objectstore_methods" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("osm-db", 2);+ let oldV = null, newV = null;+ open.onupgradeneeded = (e) => {+ oldV = e.oldVersion;+ newV = e.newVersion;+ const s = e.target.result.createObjectStore("s");+ s.add("a", 1);+ s.add("b", 2);+ s.add("c", 3);+ };+ open.onsuccess = (e) => {+ const tx = e.target.result.transaction("s", "readonly");+ testing.expectEqual("default", tx.durability);+ const store = tx.objectStore("s");+ const cReq = store.count();+ const gaReq = store.getAll();+ gaReq.onsuccess = () => state.resolve({ oldV, newV, count: cReq.result, all: gaReq.result });+ };+ await state.done((got) => {+ testing.expectEqual(0, got.oldV);+ testing.expectEqual(2, got.newV);+ testing.expectEqual(3, got.count);+ testing.expectEqual(3, got.all.length);+ testing.expectEqual("a", got.all[0]); // key order+ testing.expectEqual("c", got.all[2]);+ });+}+</script>++<!-- A write in a readonly transaction is a ReadOnlyError. -->+<script id="readonly_enforced" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("ro-db", 1);+ open.onupgradeneeded = (e) => e.target.result.createObjectStore("s");+ open.onsuccess = (e) => {+ const store = e.target.result.transaction("s", "readonly").objectStore("s");+ let threw = null;+ try { store.add("v", "k"); } catch (err) { threw = err; }+ state.resolve(threw && threw.name);+ };+ await state.done((name) => testing.expectEqual("ReadOnlyError", name));+}+</script>++<!-- clear() empties the store; commit() settles the transaction explicitly. -->+<script id="clear_and_commit" type=module>+{+ const state = await testing.async();+ const open = indexedDB.open("cc-db", 1);+ open.onupgradeneeded = (e) => e.target.result.createObjectStore("s").add("v", "k");+ open.onsuccess = (e) => {+ const db = e.target.result;+ const tx = db.transaction("s", "readwrite");+ tx.objectStore("s").clear();+ // oncomplete must be set before commit(): commit settles synchronously.+ tx.oncomplete = () => {+ const c = db.transaction("s", "readonly").objectStore("s").count();+ c.onsuccess = () => state.resolve(c.result);+ };+ tx.commit();+ };+ await state.done((count) => testing.expectEqual(0, count));+}+</script>+</body>diff --git a/src/browser/webapi/DOMException.zig b/src/browser/webapi/DOMException.zigindex 296d2965a..ab18fa05c 100644--- a/src/browser/webapi/DOMException.zig+++ b/src/browser/webapi/DOMException.zig@@ -61,14 +61,18 @@ pub fn fromError(err: anyerror) ?DOMException {error.InvalidAccessError => .{ ._code = .invalid_access_error },error.OperationError => .{ ._code = .operation_error },error.DataError => .{ ._code = .data_error },+ error.ConstraintError => .{ ._code = .constraint_error },+ error.VersionError => .{ ._code = .version_error },+ error.TransactionInactiveError => .{ ._code = .transaction_inactive_error },+ error.ReadOnlyError => .{ ._code = .read_only_error },else => null,};}pub fn getCode(self: *const DOMException) u8 {return switch (self._code) {- // WebCrypto-only errors: no legacy numeric code.- .operation_error, .data_error => 0,+ // no legacy numeric code+ .operation_error, .data_error, .constraint_error, .version_error, .transaction_inactive_error, .read_only_error => 0,else => @intFromEnum(self._code),};}@@ -103,6 +107,10 @@ pub fn getName(self: *const DOMException) []const u8 {.data_clone_error => "DataCloneError",.operation_error => "OperationError",.data_error => "DataError",+ .constraint_error => "ConstraintError",+ .version_error => "VersionError",+ .transaction_inactive_error => "TransactionInactiveError",+ .read_only_error => "ReadOnlyError",};}@@ -135,6 +143,10 @@ pub fn getMessage(self: *const DOMException) []const u8 {.data_clone_error => "The object can not be cloned",.operation_error => "The operation failed for an operation-specific reason",.data_error => "Data provided to an operation does not meet requirements",+ .constraint_error => "A mutation operation in the transaction failed because a constraint was not satisfied",+ .version_error => "An attempt was made to open a database using a lower version than the existing version",+ .transaction_inactive_error => "A request was placed against a transaction which is currently not active, or which is finished",+ .read_only_error => "A mutation operation was attempted in a read-only transaction",};}@@ -178,6 +190,14 @@ const Code = enum(u8) {data_error = 0xFE,/// Defined by WebCrypto; no legacy code, exposed via name only.operation_error = 0xFF,+ /// Defined by IndexedDB; no legacy code, exposed via name only.+ constraint_error = 0xFD,+ /// Defined by IndexedDB; no legacy code, exposed via name only.+ version_error = 0xFC,+ /// Defined by IndexedDB; no legacy code, exposed via name only.+ transaction_inactive_error = 0xFB,+ /// Defined by IndexedDB; no legacy code, exposed via name only.+ read_only_error = 0xFA,/// Maps a standard error name to its legacy code/// Returns .none (code 0) for non-legacy error names@@ -206,6 +226,10 @@ const Code = enum(u8) {.{ "DataCloneError", .data_clone_error },.{ "OperationError", .operation_error },.{ "DataError", .data_error },+ .{ "ConstraintError", .constraint_error },+ .{ "VersionError", .version_error },+ .{ "TransactionInactiveError", .transaction_inactive_error },+ .{ "ReadOnlyError", .read_only_error },});return lookup.get(name) orelse .none;}diff --git a/src/browser/webapi/Event.zig b/src/browser/webapi/Event.zigindex d47a54b48..d3aa63fa2 100644--- a/src/browser/webapi/Event.zig+++ b/src/browser/webapi/Event.zig@@ -82,6 +82,7 @@ pub const Type = union(enum) {form_data_event: *@import("event/FormDataEvent.zig"),close_event: *@import("event/CloseEvent.zig"),cookie_change_event: *@import("event/CookieChangeEvent.zig"),+ idb_version_change_event: *@import("storage/idb/IDBVersionChangeEvent.zig"),toggle_event: *@import("event/ToggleEvent.zig"),};@@ -175,6 +176,7 @@ pub fn is(self: *Event, comptime T: type) ?*T {.form_data_event => |e| return if (T == @import("event/FormDataEvent.zig")) e else null,.close_event => |e| return if (T == @import("event/CloseEvent.zig")) e else null,.cookie_change_event => |e| return if (T == @import("event/CookieChangeEvent.zig")) e else null,+ .idb_version_change_event => |e| return if (T == @import("storage/idb/IDBVersionChangeEvent.zig")) e else null,.toggle_event => |e| return if (T == @import("event/ToggleEvent.zig")) e else null,.ui_event => |e| {if (T == @import("event/UIEvent.zig")) {diff --git a/src/browser/webapi/EventTarget.zig b/src/browser/webapi/EventTarget.zigindex 93b40025f..eaf39dbdb 100644--- a/src/browser/webapi/EventTarget.zig+++ b/src/browser/webapi/EventTarget.zig@@ -51,6 +51,9 @@ pub const Type = union(enum) {font_face_set: *@import("css/FontFaceSet.zig"),websocket: *@import("net/WebSocket.zig"),cookie_store: *@import("storage/CookieStore.zig"),+ idb_request: *@import("storage/idb/IDBRequest.zig"),+ idb_database: *@import("storage/idb/IDBDatabase.zig"),+ idb_transaction: *@import("storage/idb/IDBTransaction.zig"),notification: *@import("Notification.zig"),};@@ -164,6 +167,9 @@ pub fn format(self: *EventTarget, writer: *std.Io.Writer) !void {.font_face_set => writer.writeAll("<FontFaceSet>"),.websocket => writer.writeAll("<WebSocket>"),.cookie_store => writer.writeAll("<CookieStore>"),+ .idb_request => writer.writeAll("<IDBRequest>"),+ .idb_database => writer.writeAll("<IDBDatabase>"),+ .idb_transaction => writer.writeAll("<IDBTransaction>"),.notification => writer.writeAll("<Notification>"),};}@@ -189,6 +195,9 @@ pub fn toString(self: *EventTarget) []const u8 {.font_face_set => return "[object FontFaceSet]",.websocket => return "[object WebSocket]",.cookie_store => return "[object CookieStore]",+ .idb_request => return "[object IDBRequest]",+ .idb_database => return "[object IDBDatabase]",+ .idb_transaction => return "[object IDBTransaction]",.notification => return "[object Notification]",};}diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zigindex aac9501b4..5e22b270b 100644--- a/src/browser/webapi/Window.zig+++ b/src/browser/webapi/Window.zig@@ -43,6 +43,7 @@ const MessageEvent = @import("event/MessageEvent.zig");const MessagePort = @import("MessagePort.zig");const MediaQueryList = @import("css/MediaQueryList.zig");const storage = @import("storage/storage.zig");+const idb = @import("storage/idb/idb.zig");const CookieStore = @import("storage/CookieStore.zig");const Element = @import("Element.zig");const CSSStyleProperties = @import("css/CSSStyleProperties.zig");@@ -75,6 +76,7 @@ _screen: *Screen,_visual_viewport: *VisualViewport,_performance: Performance,_cookie_store: ?*CookieStore = null,+_idb_factory: ?*idb.IDBFactory = null,_on_load: ?js.Function.Global = null,_on_pageshow: ?js.Function.Global = null,_on_popstate: ?js.Function.Global = null,@@ -297,6 +299,15 @@ pub fn getCookieStore(self: *Window, exec: *Execution) !*CookieStore {return cs;}+pub fn getIndexedDB(self: *Window, exec: *Execution) !*idb.IDBFactory {+ if (self._idb_factory) |f| {+ return f;+ }+ const f = try exec._factory.create(idb.IDBFactory{});+ self._idb_factory = f;+ return f;+}+pub fn getOrigin(self: *const Window) []const u8 {return self._frame.origin orelse "null";}@@ -1051,6 +1062,7 @@ pub const JsApi = struct {pub const localStorage = bridge.accessor(Window.getLocalStorage, null, .{});pub const sessionStorage = bridge.accessor(Window.getSessionStorage, null, .{});pub const cookieStore = bridge.accessor(Window.getCookieStore, null, .{});+ pub const indexedDB = bridge.accessor(Window.getIndexedDB, null, .{});pub const origin = bridge.accessor(Window.getOrigin, Window.setOrigin, .{});pub const location = bridge.accessor(Window.getLocation, Window.setLocation, .{ .deletable = false });pub const history = bridge.accessor(Window.getHistory, null, .{});diff --git a/src/browser/webapi/WorkerGlobalScope.zig b/src/browser/webapi/WorkerGlobalScope.zigindex 02ebb669f..92df5137f 100644--- a/src/browser/webapi/WorkerGlobalScope.zig+++ b/src/browser/webapi/WorkerGlobalScope.zig@@ -44,6 +44,7 @@ const Performance = @import("Performance.zig");const WorkerLocation = @import("WorkerLocation.zig");const ErrorEvent = @import("event/ErrorEvent.zig");const Fetch = @import("net/Fetch.zig");+const idb = @import("storage/idb/idb.zig");const CookieStore = @import("storage/CookieStore.zig");const DedicatedWorkerGlobalScope = @import("DedicatedWorkerGlobalScope.zig");@@ -103,6 +104,7 @@ _console: Console = .init,_crypto: Crypto = .init,_navigator: Navigator = .init,_performance: Performance,+_idb_factory: ?*idb.IDBFactory = null,_on_error: ?JS.Function.Global = null,_on_rejection_handled: ?JS.Function.Global = null,_on_unhandled_rejection: ?JS.Function.Global = null,@@ -503,6 +505,15 @@ pub fn clearInterval(self: *WorkerGlobalScope, id: u32) void {self._timers.clear(id);}+pub fn getIndexedDB(self: *WorkerGlobalScope, exec: *JS.Execution) !*idb.IDBFactory {+ if (self._idb_factory) |f| {+ return f;+ }+ const f = try exec._factory.create(idb.IDBFactory{});+ self._idb_factory = f;+ return f;+}+// Some properties are readonly but [Replaceable]. They get assigned as own// data properties on the underlying v8::object that represents the global (the// WorkerGlobalScope)@@ -548,6 +559,7 @@ pub const JsApi = struct {pub const self = bridge.accessor(WorkerGlobalScope.getSelf, WorkerGlobalScope.setSelf, .{});pub const location = bridge.accessor(WorkerGlobalScope.getLocation, null, .{});pub const cookieStore = bridge.accessor(WorkerGlobalScope.getCookieStore, null, .{});+ pub const indexedDB = bridge.accessor(WorkerGlobalScope.getIndexedDB, null, .{});pub const onerror = bridge.accessor(WorkerGlobalScope.getOnError, WorkerGlobalScope.setOnError, .{});pub const onrejectionhandled = bridge.accessor(WorkerGlobalScope.getOnRejectionHandled, WorkerGlobalScope.setOnRejectionHandled, .{});diff --git a/src/browser/webapi/storage/idb/Engine.zig b/src/browser/webapi/storage/idb/Engine.zignew file mode 100644index 000000000..ddd688e9d--- /dev/null+++ b/src/browser/webapi/storage/idb/Engine.zig@@ -0,0 +1,260 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const Sqlite = @import("../../../../storage/sqlite/Sqlite.zig");++const log = lp.log;+const Allocator = std.mem.Allocator;++const Engine = @This();++conn: Sqlite.Conn,++pub fn open(path: [:0]const u8) !Engine {+ const conn = try Sqlite.Conn.open(path);+ errdefer conn.close();++ try conn.busyTimeout(1000);+ try conn.exec("pragma journal_mode=wal", .{});+ try conn.exec(+ \\ create table if not exists idb_databases (+ \\ id integer primary key,+ \\ name text not null unique,+ \\ version integer not null+ \\ );+ \\ create table if not exists idb_object_stores (+ \\ id integer primary key,+ \\ database_id integer not null references idb_databases(id),+ \\ name text not null,+ \\ key_path text,+ \\ auto_increment integer not null default 0,+ \\ unique(database_id, name)+ \\ );+ \\ create table if not exists idb_records (+ \\ object_store_id integer not null references idb_object_stores(id),+ \\ key blob not null,+ \\ value blob not null,+ \\ primary key (object_store_id, key)+ \\ ) without rowid;+ , .{});+ return .{ .conn = conn };+}++pub fn close(self: *Engine) void {+ self.conn.close();+}++pub fn begin(self: *Engine) !void {+ return self.conn.exec("begin immediate", .{});+}++pub fn commit(self: *Engine) !void {+ return self.conn.exec("commit", .{});+}++pub fn rollback(self: *Engine) void {+ self.conn.exec("rollback", .{}) catch |err| {+ log.warn(.storage, "idb rollback", .{ .err = err, .sqlite = self.conn.lastError() });+ };+}+pub fn databaseId(self: *const Engine, name: []const u8) !?i64 {+ return self.conn.scalar(i64, "select id from idb_databases where name = ?1", .{name});+}++pub fn databaseVersion(self: *const Engine, name: []const u8) !?i64 {+ return self.conn.scalar(i64, "select version from idb_databases where name = ?1", .{name});+}++pub fn upsertDatabase(self: *Engine, name: []const u8, version: i64) !i64 {+ try self.conn.exec(+ \\ insert into idb_databases (name, version) values (?1, ?2)+ \\ on conflict(name) do update set version = ?2+ , .{ name, version });++ return (try self.databaseId(name)).?;+}++pub fn deleteDatabase(self: *Engine, name: []const u8) !void {+ const database_id = (try self.databaseId(name)) orelse return;++ try self.begin();+ errdefer self.rollback();+ try self.conn.exec(+ "delete from idb_records where object_store_id in (select id from idb_object_stores where database_id = ?1)",+ .{database_id},+ );+ try self.conn.exec("delete from idb_object_stores where database_id = ?1", .{database_id});+ try self.conn.exec("delete from idb_databases where id = ?1", .{database_id});+ try self.commit();+}++pub fn objectStoreId(self: *const Engine, database_id: i64, name: []const u8) !?i64 {+ return self.conn.scalar(+ i64,+ "select id from idb_object_stores where database_id = ?1 and name = ?2",+ .{ database_id, name },+ );+}++pub fn createObjectStore(+ self: *Engine,+ database_id: i64,+ name: []const u8,+ key_path: ?[]const u8,+ auto_increment: bool,+) !i64 {+ try self.conn.exec(+ \\ insert into idb_object_stores (database_id, name, key_path, auto_increment)+ \\ values (?1, ?2, ?3, ?4)+ , .{ database_id, name, key_path, auto_increment });+ return (try self.objectStoreId(database_id, name)).?;+}++pub fn deleteObjectStore(self: *Engine, database_id: i64, name: []const u8) !void {+ const store_id = (try self.objectStoreId(database_id, name)) orelse return error.NotFound;+ // caller has a transaction open+ try self.conn.exec("delete from idb_records where object_store_id = ?1", .{store_id});+ try self.conn.exec("delete from idb_object_stores where id = ?1", .{store_id});+}++pub fn add(self: *Engine, object_store_id: i64, key: []const u8, value: []const u8) !void {+ return self.conn.exec(+ "insert into idb_records (object_store_id, key, value) values (?1, ?2, ?3)",+ .{ object_store_id, key, value },+ );+}++pub fn put(self: *Engine, object_store_id: i64, key: []const u8, value: []const u8) !void {+ return self.conn.exec(+ \\ insert into idb_records (object_store_id, key, value) values (?1, ?2, ?3)+ \\ on conflict(object_store_id, key) do update set value = ?3+ , .{ object_store_id, key, value });+}++pub fn get(self: *const Engine, allocator: Allocator, object_store_id: i64, key: []const u8) !?[]u8 {+ var row = (try self.conn.row(+ "select value from idb_records where object_store_id = ?1 and key = ?2",+ .{ object_store_id, key },+ )) orelse return null;+ defer row.deinit();+ return try allocator.dupe(u8, row.get([]const u8, 0));+}++pub fn delete(self: *Engine, object_store_id: i64, key: []const u8) !void {+ return self.conn.exec(+ "delete from idb_records where object_store_id = ?1 and key = ?2",+ .{ object_store_id, key },+ );+}++pub fn clear(self: *Engine, object_store_id: i64) !void {+ return self.conn.exec("delete from idb_records where object_store_id = ?1", .{object_store_id});+}++pub fn count(self: *const Engine, object_store_id: i64) !i64 {+ return (try self.conn.scalar(+ i64,+ "select count(*) from idb_records where object_store_id = ?1",+ .{object_store_id},+ )) orelse 0;+}++pub fn getAll(self: *const Engine, arena: Allocator, object_store_id: i64) ![]const []u8 {+ var rows = try self.conn.rows(+ "select value from idb_records where object_store_id = ?1 order by key",+ .{object_store_id},+ );+ defer rows.deinit();++ var list: std.ArrayList([]u8) = .empty;+ while (try rows.next()) |row| {+ try list.append(arena, try arena.dupe(u8, row.get([]const u8, 0)));+ }+ return list.items;+}++const testing = @import("../../../../testing.zig");++test "IDB - Engine: open creates schema" {+ var engine = try Engine.open(":memory:");+ defer engine.close();+ try testing.expectEqual(null, try engine.databaseVersion("missing"));+}++test "IDB - Engine: database + object store + add/get round-trip" {+ var engine = try Engine.open(":memory:");+ defer engine.close();++ const db_id = try engine.upsertDatabase("app", 1);+ try testing.expectEqual(1, (try engine.databaseVersion("app")).?);++ const store_id = try engine.createObjectStore(db_id, "books", null, false);++ // Value bytes deliberately include an embedded NUL and high bytes to prove+ // the BLOB path is binary-safe (serialized values are arbitrary bytes).+ const value = "a\x00b\xffc";+ try engine.add(store_id, "key1", value);++ const got = (try engine.get(testing.allocator, store_id, "key1")).?;+ defer testing.allocator.free(got);+ try testing.expectEqualSlices(u8, value, got);++ try testing.expectEqual(null, try engine.get(testing.allocator, store_id, "absent"));+}++test "IDB - Engine: add rejects duplicate key, put overwrites" {+ var engine = try Engine.open(":memory:");+ defer engine.close();++ const db_id = try engine.upsertDatabase("app", 1);+ const store_id = try engine.createObjectStore(db_id, "s", null, false);++ try engine.add(store_id, "k", "v1");+ try testing.expectError(error.Constraint, engine.add(store_id, "k", "v2"));++ try engine.put(store_id, "k", "v2");+ const got = (try engine.get(testing.allocator, store_id, "k")).?;+ defer testing.allocator.free(got);+ try testing.expectEqualSlices(u8, "v2", got);+}++test "IDB - Engine: createObjectStore rejects duplicate name" {+ var engine = try Engine.open(":memory:");+ defer engine.close();++ const db_id = try engine.upsertDatabase("app", 1);+ _ = try engine.createObjectStore(db_id, "s", null, false);+ try testing.expectError(error.Constraint, engine.createObjectStore(db_id, "s", null, false));+}++test "IDB - Engine: rollback discards uncommitted writes" {+ var engine = try Engine.open(":memory:");+ defer engine.close();++ const db_id = try engine.upsertDatabase("app", 1);+ const store_id = try engine.createObjectStore(db_id, "s", null, false);++ try engine.begin();+ try engine.add(store_id, "k", "v");+ engine.rollback();++ try testing.expectEqual(null, try engine.get(testing.allocator, store_id, "k"));+}diff --git a/src/browser/webapi/storage/idb/IDBDatabase.zig b/src/browser/webapi/storage/idb/IDBDatabase.zignew file mode 100644index 000000000..5d40eeee0--- /dev/null+++ b/src/browser/webapi/storage/idb/IDBDatabase.zig@@ -0,0 +1,153 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../../js/js.zig");++const EventTarget = @import("../../EventTarget.zig");++const Engine = @import("Engine.zig");+const IDBTransaction = @import("IDBTransaction.zig");+const IDBObjectStore = @import("IDBObjectStore.zig");++const Execution = js.Execution;++const IDBDatabase = @This();++_proto: *EventTarget,+_exec: *Execution,+_engine: *Engine,+_database_id: i64,+_name: []const u8,+_version: i64,+_txn: ?*IDBTransaction = null, // only set during upgradeneeded++pub fn init(exec: *Execution, engine: *Engine, database_id: i64, name: []const u8, version: i64) !*IDBDatabase {+ return exec._factory.eventTarget(IDBDatabase{+ ._proto = undefined,+ ._exec = exec,+ ._engine = engine,+ ._database_id = database_id,+ ._name = name,+ ._version = version,+ });+}++pub fn asEventTarget(self: *IDBDatabase) *EventTarget {+ return self._proto;+}++const CreateObjectStoreOptions = struct {+ keyPath: ?[]const u8 = null,+ autoIncrement: bool = false,+};++// Only callable during upgradeneeded, hence the _txn check+pub fn createObjectStore(+ self: *IDBDatabase,+ name: []const u8,+ options: ?CreateObjectStoreOptions,+ exec: *Execution,+) !*IDBObjectStore {+ const txn = self._txn orelse return error.InvalidStateError;++ const opts = options orelse CreateObjectStoreOptions{};+ const store_id = self._engine.createObjectStore(+ self._database_id,+ name,+ opts.keyPath,+ opts.autoIncrement,+ ) catch |err| switch (err) {+ error.Constraint => return error.ConstraintError,+ else => return err,+ };++ const owned_name = try exec.dupeString(name);+ const key_path = if (opts.keyPath) |kp| try exec.dupeString(kp) else null;+ return IDBObjectStore.init(self._engine, txn, store_id, owned_name, key_path, exec);+}++// Only callable during upgradeneeded, hence the _txn check+pub fn deleteObjectStore(self: *IDBDatabase, name: []const u8, _: *Execution) !void {+ if (self._txn == null) {+ return error.InvalidStateError;+ }+ return self._engine.deleteObjectStore(self._database_id, name);+}++const TransactionMode = enum {+ readonly,+ readwrite,+ pub const js_enum_from_string = true;+};++const StoreNames = union(enum) {+ name: []const u8,+ names: []const []const u8,+};++const TransactionOptions = struct {+ durability: IDBTransaction.Durability = .default,+};++pub fn transaction(+ self: *IDBDatabase,+ store_names: StoreNames,+ mode: ?TransactionMode,+ options: ?TransactionOptions,+ exec: *Execution,+) !*IDBTransaction {+ _ = store_names; // TODO+ const opts = options orelse TransactionOptions{};+ return IDBTransaction.init(exec, self, switch (mode orelse .readonly) {+ .readonly => .readonly,+ .readwrite => .readwrite,+ }, opts.durability);+}++pub fn close(_: *IDBDatabase) void {+ // Connections are pooled on the Manager and shared across handles, so a+ // single handle's close() is a no-op for the bare slice.+}++pub fn getName(self: *const IDBDatabase) []const u8 {+ return self._name;+}++pub fn getVersion(self: *const IDBDatabase) i64 {+ return self._version;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(IDBDatabase);++ pub const Meta = struct {+ pub const name = "IDBDatabase";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const name = bridge.accessor(IDBDatabase.getName, null, .{});+ pub const version = bridge.accessor(IDBDatabase.getVersion, null, .{});+ pub const createObjectStore = bridge.function(IDBDatabase.createObjectStore, .{});+ pub const deleteObjectStore = bridge.function(IDBDatabase.deleteObjectStore, .{});+ pub const transaction = bridge.function(IDBDatabase.transaction, .{});+ pub const close = bridge.function(IDBDatabase.close, .{});+};diff --git a/src/browser/webapi/storage/idb/IDBFactory.zig b/src/browser/webapi/storage/idb/IDBFactory.zignew file mode 100644index 000000000..f21bc091d--- /dev/null+++ b/src/browser/webapi/storage/idb/IDBFactory.zig@@ -0,0 +1,225 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../../js/js.zig");++const Key = @import("Key.zig");+const Engine = @import("Engine.zig");+const IDBRequest = @import("IDBRequest.zig");+const IDBDatabase = @import("IDBDatabase.zig");+const IDBTransaction = @import("IDBTransaction.zig");++const log = lp.log;+const Execution = js.Execution;++const IDBFactory = @This();++_pad: bool = false,++pub fn open(_: *IDBFactory, name: []const u8, version: ?u64, exec: *Execution) !*IDBRequest {+ if (exec.origin() == null) {+ // unavailable for opaque origins, e.g. about:blank+ return error.SecurityError;+ }++ // A supplied version must be >= 1; open(name, 0) is a TypeError per spec.+ if (version) |v| {+ if (v == 0) return error.TypeError;+ }++ const request = try IDBRequest.init(exec);++ const ctx = try exec._factory.create(OpenContext{+ .request = request,+ .name = try exec.dupeString(name),+ .version = version,+ .exec = exec,+ });++ try exec.js.scheduler.add(ctx, OpenContext.run, 0, .{+ .name = "IDBFactory.open",+ .finalizer = OpenContext.cancelled,+ });+ return request;+}++const OpenContext = struct {+ request: *IDBRequest,+ name: []const u8,+ version: ?u64,+ exec: *Execution,++ fn cancelled(ctx: *anyopaque) void {+ const self: *OpenContext = @ptrCast(@alignCast(ctx));+ self.exec._factory.destroy(self);+ }++ fn run(ctx: *anyopaque) !?u32 {+ const self: *OpenContext = @ptrCast(@alignCast(ctx));+ defer self.exec._factory.destroy(self);++ self.runOpen() catch |err| {+ log.warn(.storage, "idb open", .{ .err = err, .name = self.name });+ self.request.setError(err);+ self.request.deliver(self.exec) catch {};+ };+ return null;+ }++ fn runOpen(self: *OpenContext) !void {+ const exec = self.exec;++ // origin being null was already guarded against, so this should be+ // unreachable, but this is safer.+ const origin = exec.origin() orelse return error.SecurityError;++ const engine = try exec.session.idb.engineForOrigin(origin);+ const existing = try engine.databaseVersion(self.name);++ // No explicit version means "open at the current version" (or 1 for a+ // brand-new database).+ const requested: i64 = if (self.version) |v| @intCast(v) else existing orelse 1;++ if (existing) |current| {+ if (requested < current) {+ self.request.setError(error.VersionError);+ self.request.deliver(exec) catch {};+ return;+ }++ if (requested == current) {+ const database_id = (try engine.databaseId(self.name)).?;+ const db = try IDBDatabase.init(exec, engine, database_id, self.name, current);+ self.request.setDatabaseResult(db);+ return self.request.fireSuccess(exec);+ }+ }++ // New database or an upgrade to a higher version. Run a versionchange+ // transaction so user JS can evolve the schema during `upgradeneeded`;+ // it's exposed as `request.transaction` and committed here once the+ // handler returns.+ try engine.begin();+ errdefer engine.rollback();++ const database_id = try engine.upsertDatabase(self.name, requested);+ const db = try IDBDatabase.init(exec, engine, database_id, self.name, requested);+ self.request.setDatabaseResult(db);++ const txn = try IDBTransaction.initVersionChange(exec, db);+ self.request._txn = txn;++ {+ db._txn = txn;+ defer db._txn = null;+ const old_version: u64 = @intCast(existing orelse 0);+ try self.request.fireUpgradeNeeded(exec, old_version, @intCast(requested));+ }++ if (txn.aborted()) {+ // updateneeded handler called abort() (what a jerk!)+ self.request._txn = null;+ self.request.setError(error.AbortError);+ return self.request.deliver(exec);+ }++ txn.settle(exec);+ self.request._txn = null;+ return self.request.fireSuccess(exec);+ }+};++pub fn deleteDatabase(_: *IDBFactory, name: []const u8, exec: *Execution) !*IDBRequest {+ if (exec.origin() == null) {+ // unavailable for opaque origins, e.g. about:blank+ return error.SecurityError;+ }++ const request = try IDBRequest.init(exec);++ const ctx = try exec._factory.create(DeleteContext{+ .request = request,+ .name = try exec.dupeString(name),+ .exec = exec,+ });++ try exec.js.scheduler.add(ctx, DeleteContext.run, 0, .{+ .name = "IDBFactory.deleteDatabase",+ .finalizer = DeleteContext.cancelled,+ });+ return request;+}++const DeleteContext = struct {+ request: *IDBRequest,+ name: []const u8,+ exec: *Execution,++ fn cancelled(ctx: *anyopaque) void {+ const self: *DeleteContext = @ptrCast(@alignCast(ctx));+ self.exec._factory.destroy(self);+ }++ fn run(ctx: *anyopaque) !?u32 {+ const self: *DeleteContext = @ptrCast(@alignCast(ctx));+ defer self.exec._factory.destroy(self);++ self.runDelete() catch |err| {+ log.warn(.storage, "idb deleteDatabase", .{ .err = err, .name = self.name });+ self.request.setError(err);+ self.request.deliver(self.exec) catch {};+ };+ return null;+ }++ fn runDelete(self: *DeleteContext) !void {+ const exec = self.exec;+ const origin = exec.origin() orelse return error.SecurityError;+ const engine = try exec.session.idb.engineForOrigin(origin);+ try engine.deleteDatabase(self.name);+ return self.request.fireSuccess(exec);+ }+};++pub fn cmp(_: *IDBFactory, first: js.Value, second: js.Value, exec: *Execution) !i32 {+ const a = try Key.encodeValue(first, exec.call_arena);+ const b = try Key.encodeValue(second, exec.call_arena);+ return switch (std.mem.order(u8, a, b)) {+ .lt => -1,+ .eq => 0,+ .gt => 1,+ };+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(IDBFactory);++ pub const Meta = struct {+ pub const name = "IDBFactory";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ pub const empty_with_no_proto = true;+ };++ pub const open = bridge.function(IDBFactory.open, .{});+ pub const deleteDatabase = bridge.function(IDBFactory.deleteDatabase, .{});+ pub const cmp = bridge.function(IDBFactory.cmp, .{});+};diff --git a/src/browser/webapi/storage/idb/IDBObjectStore.zig b/src/browser/webapi/storage/idb/IDBObjectStore.zignew file mode 100644index 000000000..8540e3b54--- /dev/null+++ b/src/browser/webapi/storage/idb/IDBObjectStore.zig@@ -0,0 +1,215 @@+// 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 lp = @import("lightpanda");++const js = @import("../../../js/js.zig");++const Key = @import("Key.zig");+const Engine = @import("Engine.zig");+const IDBRequest = @import("IDBRequest.zig");+const IDBTransaction = @import("IDBTransaction.zig");++const log = lp.log;+const Execution = js.Execution;++const IDBObjectStore = @This();++_exec: *Execution,+_engine: *Engine,+_store_id: i64,+_name: []const u8,+_key_path: ?[]const u8,+// only null during an upgradeneeded+_txn: ?*IDBTransaction,++pub fn init(+ engine: *Engine,+ txn: ?*IDBTransaction,+ store_id: i64,+ name: []const u8,+ key_path: ?[]const u8,+ exec: *Execution,+) !*IDBObjectStore {+ return exec._factory.create(IDBObjectStore{+ ._exec = exec,+ ._engine = engine,+ ._txn = txn,+ ._store_id = store_id,+ ._name = name,+ ._key_path = key_path,+ });+}++pub fn add(self: *IDBObjectStore, value: js.Value, key: ?js.Value) !*IDBRequest {+ return self.write(value, key, .add);+}++pub fn put(self: *IDBObjectStore, value: js.Value, key: ?js.Value) !*IDBRequest {+ return self.write(value, key, .put);+}++pub fn get(self: *IDBObjectStore, key: js.Value, exec: *Execution) !*IDBRequest {+ const txn = self._txn orelse return error.TransactionInactiveError;+ try txn.ensureBegun();++ // Both the encoded key and the fetched bytes are consumed within this call+ // (the bytes are deserialized below), so the per-call scratch arena suffices.+ const arena = exec.call_arena;+ const encoded = try Key.encodeValue(key, arena);+ const request = try txn.newRequest();++ const bytes = self._engine.get(arena, self._store_id, encoded) catch |err| {+ log.warn(.storage, "idb get", .{ .err = err });+ request.setError(err);+ return request;+ };++ const b = bytes orelse return request;++ const value = try js.Value.deserialize(exec.js.local.?, b);+ try request.setValueResult(value);+ return request;+}++pub fn delete(self: *IDBObjectStore, key: js.Value, _: *Execution) !*IDBRequest {+ const txn = self._txn orelse return error.TransactionInactiveError;+ if (txn._mode == .readonly) {+ return error.ReadOnlyError;+ }+ try txn.ensureBegun();++ const encoded = try Key.encodeValue(key, self._exec.call_arena);+ const request = try txn.newRequest();++ self._engine.delete(self._store_id, encoded) catch |err| {+ log.warn(.storage, "idb delete", .{ .err = err });+ request.setError(err);+ };+ return request;+}++pub fn clear(self: *IDBObjectStore, _: *Execution) !*IDBRequest {+ const txn = self._txn orelse return error.TransactionInactiveError;+ if (txn._mode == .readonly) {+ return error.ReadOnlyError;+ }+ try txn.ensureBegun();++ const request = try txn.newRequest();+ self._engine.clear(self._store_id) catch |err| {+ log.warn(.storage, "idb clear", .{ .err = err });+ request.setError(err);+ };+ return request;+}++pub fn count(self: *IDBObjectStore, exec: *Execution) !*IDBRequest {+ const txn = self._txn orelse return error.TransactionInactiveError;+ try txn.ensureBegun();++ const request = try txn.newRequest();+ const n = self._engine.count(self._store_id) catch |err| {+ log.warn(.storage, "idb count", .{ .err = err });+ request.setError(err);+ return request;+ };+ try request.setValueResult(try exec.js.local.?.zigValueToJs(n, .{}));+ return request;+}++pub fn getAll(self: *IDBObjectStore, exec: *Execution) !*IDBRequest {+ const txn = self._txn orelse return error.TransactionInactiveError;+ try txn.ensureBegun();++ const local = exec.js.local.?;+ const request = try txn.newRequest();++ const values = self._engine.getAll(exec.call_arena, self._store_id) catch |err| {+ log.warn(.storage, "idb getAll", .{ .err = err });+ request.setError(err);+ return request;+ };++ const arr = local.newArray(@intCast(values.len));+ for (values, 0..) |bytes, i| {+ const value = try js.Value.deserialize(local, bytes);+ _ = try arr.set(@intCast(i), value, .{});+ }+ try request.setValueResult(arr.toValue());+ return request;+}++pub fn getName(self: *const IDBObjectStore) []const u8 {+ return self._name;+}++pub fn getKeyPath(self: *const IDBObjectStore) ?[]const u8 {+ return self._key_path;+}++const WriteKind = enum { add, put };++fn write(self: *IDBObjectStore, value: js.Value, key_: ?js.Value, kind: WriteKind) !*IDBRequest {+ const txn = self._txn orelse return error.TransactionInactiveError;+ if (txn._mode == .readonly) {+ return error.ReadOnlyError;+ }+ try txn.ensureBegun();++ const key = key_ orelse return error.DataError;+ const encoded = try Key.encodeValue(key, self._exec.call_arena);++ const serialized = try value.serialize();+ defer serialized.deinit();++ const request = try txn.newRequest();++ const result = switch (kind) {+ .add => self._engine.add(self._store_id, encoded, serialized.bytes()),+ .put => self._engine.put(self._store_id, encoded, serialized.bytes()),+ };+ result catch |err| {+ log.warn(.storage, "idb write", .{ .err = err, .kind = kind });+ request.setError(err);+ return request;+ };++ try request.setValueResult(key);+ return request;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(IDBObjectStore);++ pub const Meta = struct {+ pub const name = "IDBObjectStore";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const name = bridge.accessor(IDBObjectStore.getName, null, .{});+ pub const keyPath = bridge.accessor(IDBObjectStore.getKeyPath, null, .{});+ pub const add = bridge.function(IDBObjectStore.add, .{});+ pub const put = bridge.function(IDBObjectStore.put, .{});+ pub const get = bridge.function(IDBObjectStore.get, .{});+ pub const delete = bridge.function(IDBObjectStore.delete, .{});+ pub const clear = bridge.function(IDBObjectStore.clear, .{});+ pub const count = bridge.function(IDBObjectStore.count, .{});+ pub const getAll = bridge.function(IDBObjectStore.getAll, .{});+};diff --git a/src/browser/webapi/storage/idb/IDBRequest.zig b/src/browser/webapi/storage/idb/IDBRequest.zignew file mode 100644index 000000000..f4d1f653c--- /dev/null+++ b/src/browser/webapi/storage/idb/IDBRequest.zig@@ -0,0 +1,183 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../../js/js.zig");++const Event = @import("../../Event.zig");+const EventTarget = @import("../../EventTarget.zig");+const DOMException = @import("../../DOMException.zig");++const idb = @import("idb.zig");+const IDBDatabase = @import("IDBDatabase.zig");+const IDBTransaction = @import("IDBTransaction.zig");+const IDBVersionChangeEvent = @import("IDBVersionChangeEvent.zig");++const Execution = js.Execution;+const FunctionSetter = idb.FunctionSetter;++const IDBRequest = @This();++_proto: *EventTarget,+_result: Result = .none,+_error: ?anyerror = null,+_txn: ?*IDBTransaction = null,+_ready_state: ReadyState = .pending,++_on_success: ?js.Function.Global = null,+_on_error: ?js.Function.Global = null,+_on_upgrade_needed: ?js.Function.Global = null,++const ReadyState = enum {+ pending,+ done,++ pub fn toString(self: ReadyState) []const u8 {+ return @tagName(self);+ }+};++const Result = union(enum) {+ none,+ value: js.Value.Global, // the result of a get/add/put+ database: *IDBDatabase, // the result of an open+};++pub fn init(exec: *Execution) !*IDBRequest {+ return exec._factory.eventTarget(IDBRequest{ ._proto = undefined });+}++pub fn asEventTarget(self: *IDBRequest) *EventTarget {+ return self._proto;+}++pub fn setValueResult(self: *IDBRequest, value: js.Value) !void {+ self._result = .{ .value = try value.persist() };+}++pub fn setDatabaseResult(self: *IDBRequest, database: *IDBDatabase) void {+ self._result = .{ .database = database };+}++pub fn setError(self: *IDBRequest, err: anyerror) void {+ self._error = err;+}++pub fn failed(self: *const IDBRequest) bool {+ return self._error != null;+}++pub fn deliver(self: *IDBRequest, exec: *Execution) !void {+ self._ready_state = .done;+ if (self._error != null) {+ return self.fire(exec, comptime .wrap("error"), self._on_error);+ }+ return self.fire(exec, comptime .wrap("success"), self._on_success);+}++pub fn fireUpgradeNeeded(self: *IDBRequest, exec: *Execution, old_version: u64, new_version: u64) !void {+ self._ready_state = .done;+ const event = try IDBVersionChangeEvent.initTrusted(.wrap("upgradeneeded"), old_version, new_version, exec);+ try exec.dispatch(self.asEventTarget(), event.asEvent(), self._on_upgrade_needed, .{ .context = "IDBRequest.upgradeneeded" });+}++pub fn fireSuccess(self: *IDBRequest, exec: *Execution) !void {+ self._ready_state = .done;+ return self.fire(exec, comptime .wrap("success"), self._on_success);+}++fn fire(self: *IDBRequest, exec: *Execution, typ: lp.String, handler: ?js.Function.Global) !void {+ const event = try Event.initTrusted(typ, null, exec.page);+ try exec.dispatch(self.asEventTarget(), event, handler, .{ .context = "IDBRequest" });+}++pub fn getReadyState(self: *const IDBRequest) ReadyState {+ return self._ready_state;+}++pub fn getResult(self: *const IDBRequest) !Result {+ return self._result;+}++pub fn getTransaction(self: *const IDBRequest) ?*IDBTransaction {+ return self._txn;+}++// Return this as a DOMException directly. If we return an error, the bridge+// *will* convert it to a DOMException, but it'll throw it, not return it.+pub fn getError(self: *const IDBRequest) ?DOMException {+ const err = self._error orelse return null;+ const mapped: anyerror = switch (err) {+ // sqlite's generic constraint failure is IDB's ConstraintError.+ error.Constraint => error.ConstraintError,+ else => err,+ };+ return DOMException.fromError(mapped) orelse DOMException.init(null, "UnknownError");+}++pub fn getOnSuccess(self: *const IDBRequest) ?js.Function.Global {+ return self._on_success;+}++pub fn setOnSuccess(self: *IDBRequest, setter: ?FunctionSetter) void {+ self._on_success = getFunctionFromSetter(setter);+}++pub fn getOnError(self: *const IDBRequest) ?js.Function.Global {+ return self._on_error;+}++pub fn setOnError(self: *IDBRequest, setter: ?FunctionSetter) void {+ self._on_error = getFunctionFromSetter(setter);+}++pub fn getOnUpgradeNeeded(self: *const IDBRequest) ?js.Function.Global {+ return self._on_upgrade_needed;+}++pub fn setOnUpgradeNeeded(self: *IDBRequest, setter: ?FunctionSetter) void {+ self._on_upgrade_needed = getFunctionFromSetter(setter);+}++fn getFunctionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {+ const s = setter orelse return null;+ return switch (s) {+ .func => |f| f,+ .anything => null,+ };+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(IDBRequest);++ pub const Meta = struct {+ pub const name = "IDBRequest";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const readyState = bridge.accessor(IDBRequest.getReadyState, null, .{});+ pub const result = bridge.accessor(IDBRequest.getResult, null, .{ .null_as_undefined = true });+ pub const transaction = bridge.accessor(IDBRequest.getTransaction, null, .{ .null_as_undefined = true });+ pub const @"error" = bridge.accessor(IDBRequest.getError, null, .{ .null_as_undefined = true });+ pub const onsuccess = bridge.accessor(IDBRequest.getOnSuccess, IDBRequest.setOnSuccess, .{});+ pub const onerror = bridge.accessor(IDBRequest.getOnError, IDBRequest.setOnError, .{});+ pub const onupgradeneeded = bridge.accessor(IDBRequest.getOnUpgradeNeeded, IDBRequest.setOnUpgradeNeeded, .{});+};diff --git a/src/browser/webapi/storage/idb/IDBTransaction.zig b/src/browser/webapi/storage/idb/IDBTransaction.zignew file mode 100644index 000000000..9d90224d0--- /dev/null+++ b/src/browser/webapi/storage/idb/IDBTransaction.zig@@ -0,0 +1,289 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../../js/js.zig");++const Event = @import("../../Event.zig");+const EventTarget = @import("../../EventTarget.zig");++const idb = @import("idb.zig");+const Engine = @import("Engine.zig");+const IDBDatabase = @import("IDBDatabase.zig");+const IDBRequest = @import("IDBRequest.zig");+const IDBObjectStore = @import("IDBObjectStore.zig");++const log = lp.log;+const Execution = js.Execution;+const FunctionSetter = idb.FunctionSetter;++const IDBTransaction = @This();++_proto: *EventTarget,+_exec: *Execution,+_db: *IDBDatabase,+_engine: *Engine,+_mode: Mode,+// Advisory only: we always commit through sqlite. Stored to expose the property.+_durability: Durability = .default,+_requests: std.ArrayList(*IDBRequest) = .empty,+_begun: bool = false,+_settled: bool = false,+_aborted: bool = false,++_on_complete: ?js.Function.Global = null,+_on_error: ?js.Function.Global = null,+_on_abort: ?js.Function.Global = null,++pub const Mode = enum {+ readonly,+ readwrite,+ versionchange,++ pub fn toString(self: Mode) []const u8 {+ return @tagName(self);+ }+};++pub const Durability = enum {+ default,+ strict,+ relaxed,++ pub const js_enum_from_string = true;++ pub fn toString(self: Durability) []const u8 {+ return @tagName(self);+ }+};++pub fn init(exec: *Execution, db: *IDBDatabase, mode: Mode, durability: Durability) !*IDBTransaction {+ const self = try exec._factory.eventTarget(IDBTransaction{+ ._proto = undefined,+ ._exec = exec,+ ._db = db,+ ._engine = db._engine,+ ._mode = mode,+ ._durability = durability,+ });++ // Schedule the drain even for an empty transaction so it still `complete`s.+ try exec.js.scheduler.add(self, drain, 0, .{+ .name = "IDBTransaction.drain",+ .finalizer = finalize,+ });+ return self;+}++// We need a "special" transaction for upgradeneeded+pub fn initVersionChange(exec: *Execution, db: *IDBDatabase) !*IDBTransaction {+ return exec._factory.eventTarget(IDBTransaction{+ ._proto = undefined,+ ._exec = exec,+ ._db = db,+ ._engine = db._engine,+ ._mode = .versionchange,+ ._begun = true,+ });+}++pub fn asEventTarget(self: *IDBTransaction) *EventTarget {+ return self._proto;+}++pub fn aborted(self: *const IDBTransaction) bool {+ return self._aborted;+}++pub fn commit(self: *IDBTransaction, exec: *Execution) !void {+ if (self._settled) {+ return error.InvalidStateError;+ }+ self.settle(exec);+}++pub fn abort(self: *IDBTransaction, exec: *Execution) !void {+ if (self._settled) {+ return error.InvalidStateError;+ }++ self._aborted = true;+ self._settled = true;++ if (self._begun) {+ self._engine.rollback();+ }++ for (self._requests.items) |request| {+ request.setError(error.AbortError);+ request.deliver(exec) catch |err| {+ log.warn(.storage, "idb abort deliver", .{ .err = err });+ };+ }+ self.fire(exec, comptime .wrap("abort"), self._on_abort);+}++// Deliver pending requests, commit, then fire `complete` (or `abort` if the+// commit fails). Drives a transaction to a successful close — shared by the+// drain task and the open path's synchronous versionchange transaction.+pub fn settle(self: *IDBTransaction, exec: *Execution) void {+ self.deliverPending(exec);+ if (self._begun) {+ self._engine.commit() catch |err| {+ log.warn(.storage, "idb commit", .{ .err = err, .sqlite = self._engine.conn.lastError() });+ self._engine.rollback();+ self.fire(exec, comptime .wrap("abort"), self._on_abort);+ return;+ };+ }+ self.fire(exec, comptime .wrap("complete"), self._on_complete);+}++pub fn ensureBegun(self: *IDBTransaction) !void {+ if (self._settled) {+ return error.TransactionInactiveError;+ }++ if (self._begun) {+ return;+ }+ try self._engine.begin();+ self._begun = true;+}++pub fn newRequest(self: *IDBTransaction) !*IDBRequest {+ const request = try IDBRequest.init(self._exec);+ request._txn = self;+ try self._requests.append(self._exec.arena, request);+ return request;+}++pub fn objectStore(self: *IDBTransaction, name: []const u8, exec: *Execution) !*IDBObjectStore {+ const database_id = self._db._database_id;+ const store_id = (try self._engine.objectStoreId(database_id, name)) orelse {+ return error.NotFound;+ };++ const owned_name = try exec.dupeString(name);+ return IDBObjectStore.init(self._engine, self, store_id, owned_name, null, exec);+}++pub fn getMode(self: *const IDBTransaction) Mode {+ return self._mode;+}++pub fn getDurability(self: *const IDBTransaction) Durability {+ return self._durability;+}++pub fn getDb(self: *IDBTransaction) *IDBDatabase {+ return self._db;+}++pub fn getOnComplete(self: *const IDBTransaction) ?js.Function.Global {+ return self._on_complete;+}++pub fn setOnComplete(self: *IDBTransaction, setter: ?FunctionSetter) void {+ self._on_complete = getFunctionFromSetter(setter);+}++pub fn getOnError(self: *const IDBTransaction) ?js.Function.Global {+ return self._on_error;+}++pub fn setOnError(self: *IDBTransaction, setter: ?FunctionSetter) void {+ self._on_error = getFunctionFromSetter(setter);+}++pub fn getOnAbort(self: *const IDBTransaction) ?js.Function.Global {+ return self._on_abort;+}++pub fn setOnAbort(self: *IDBTransaction, setter: ?FunctionSetter) void {+ self._on_abort = getFunctionFromSetter(setter);+}++fn getFunctionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {+ const s = setter orelse return null;+ return switch (s) {+ .func => |f| f,+ .anything => null,+ };+}++fn fire(self: *IDBTransaction, exec: *Execution, typ: lp.String, handler: ?js.Function.Global) void {+ self._settled = true;+ const event = Event.initTrusted(typ, null, exec.page) catch |err| {+ log.warn(.storage, "idb transaction event", .{ .err = err });+ return;+ };+ exec.dispatch(self.asEventTarget(), event, handler, .{ .context = "IDBTransaction" }) catch |err| {+ log.warn(.storage, "idb transaction dispatch", .{ .err = err });+ };+}++fn drain(ctx: *anyopaque) !?u32 {+ const self: *IDBTransaction = @ptrCast(@alignCast(ctx));+ if (self._settled) {+ // could have already been settled, e.g. via an abort)+ return null;+ }+ self.settle(self._exec);+ return null;+}++fn finalize(ctx: *anyopaque) void {+ const self: *IDBTransaction = @ptrCast(@alignCast(ctx));+ if (self._begun and !self._settled) {+ self._engine.rollback();+ }+}++// Deliver every queued request in order. Re-reads len each iteration so a+// `success` handler can enqueue a follow-up request on this transaction.+fn deliverPending(self: *IDBTransaction, exec: *Execution) void {+ var i: usize = 0;+ while (i < self._requests.items.len) : (i += 1) {+ self._requests.items[i].deliver(exec) catch |err| {+ log.warn(.storage, "idb request deliver", .{ .err = err });+ };+ }+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(IDBTransaction);++ pub const Meta = struct {+ pub const name = "IDBTransaction";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const mode = bridge.accessor(IDBTransaction.getMode, null, .{});+ pub const durability = bridge.accessor(IDBTransaction.getDurability, null, .{});+ pub const db = bridge.accessor(IDBTransaction.getDb, null, .{});+ pub const objectStore = bridge.function(IDBTransaction.objectStore, .{});+ pub const abort = bridge.function(IDBTransaction.abort, .{});+ pub const commit = bridge.function(IDBTransaction.commit, .{});+ pub const oncomplete = bridge.accessor(IDBTransaction.getOnComplete, IDBTransaction.setOnComplete, .{});+ pub const onerror = bridge.accessor(IDBTransaction.getOnError, IDBTransaction.setOnError, .{});+ pub const onabort = bridge.accessor(IDBTransaction.getOnAbort, IDBTransaction.setOnAbort, .{});+};diff --git a/src/browser/webapi/storage/idb/IDBVersionChangeEvent.zig b/src/browser/webapi/storage/idb/IDBVersionChangeEvent.zignew file mode 100644index 000000000..119dfc9de--- /dev/null+++ b/src/browser/webapi/storage/idb/IDBVersionChangeEvent.zig@@ -0,0 +1,93 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const js = @import("../../../js/js.zig");++const Event = @import("../../Event.zig");++const String = lp.String;+const Allocator = std.mem.Allocator;+const Execution = js.Execution;++const IDBVersionChangeEvent = @This();++_proto: *Event,+_old_version: u64,+_new_version: ?u64,++const IDBVersionChangeEventOptions = struct {+ oldVersion: u64 = 0,+ newVersion: ?u64 = null,+};++const Options = Event.inheritOptions(IDBVersionChangeEvent, IDBVersionChangeEventOptions);++pub fn init(typ: []const u8, opts_: ?Options, exec: *const Execution) !*IDBVersionChangeEvent {+ const arena = try exec.getArena(.tiny, "IDBVersionChangeEvent");+ errdefer exec.releaseArena(arena);+ const type_string = try String.init(arena, typ, .{});+ return initWithTrusted(arena, type_string, opts_, false, exec);+}++pub fn initTrusted(typ: String, old_version: u64, new_version: ?u64, exec: *const Execution) !*IDBVersionChangeEvent {+ const arena = try exec.getArena(.tiny, "IDBVersionChangeEvent.trusted");+ errdefer exec.releaseArena(arena);+ return initWithTrusted(arena, typ, .{ .oldVersion = old_version, .newVersion = new_version }, true, exec);+}++fn initWithTrusted(arena: Allocator, typ: String, opts_: ?Options, trusted: bool, exec: *const Execution) !*IDBVersionChangeEvent {+ const opts = opts_ orelse Options{};++ const event = try exec._factory.event(arena, typ, IDBVersionChangeEvent{+ ._proto = undefined,+ ._old_version = opts.oldVersion,+ ._new_version = opts.newVersion,+ });++ Event.populatePrototypes(event, opts, trusted);+ return event;+}++pub fn asEvent(self: *IDBVersionChangeEvent) *Event {+ return self._proto;+}++pub fn getOldVersion(self: *const IDBVersionChangeEvent) u64 {+ return self._old_version;+}++pub fn getNewVersion(self: *const IDBVersionChangeEvent) ?u64 {+ return self._new_version;+}++pub const JsApi = struct {+ pub const bridge = js.Bridge(IDBVersionChangeEvent);++ pub const Meta = struct {+ pub const name = "IDBVersionChangeEvent";+ pub const prototype_chain = bridge.prototypeChain();+ pub var class_id: bridge.ClassId = undefined;+ };++ pub const constructor = bridge.constructor(IDBVersionChangeEvent.init, .{});+ pub const oldVersion = bridge.accessor(IDBVersionChangeEvent.getOldVersion, null, .{});+ pub const newVersion = bridge.accessor(IDBVersionChangeEvent.getNewVersion, null, .{ .null_as_undefined = true });+};diff --git a/src/browser/webapi/storage/idb/Key.zig b/src/browser/webapi/storage/idb/Key.zignew file mode 100644index 000000000..c7fa1d1ef--- /dev/null+++ b/src/browser/webapi/storage/idb/Key.zig@@ -0,0 +1,131 @@+// 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 std = @import("std");++const js = @import("../../../js/js.zig");++const Allocator = std.mem.Allocator;++const Key = @This();++// Type tags are the first encoded byte. The value is for correct sort order.+const Tag = enum(u8) {+ number = 10,+ // date = 20,+ string = 30,+ // binary = 40,+ // array = 50,+};++value: Value,++pub const Value = union(enum) {+ number: f64,+ string: []const u8,+};++pub fn number(n: f64) Key {+ return .{ .value = .{ .number = n } };+}++pub fn string(s: []const u8) Key {+ return .{ .value = .{ .string = s } };+}++pub fn stringBuf(allocator: Allocator, payload_len: usize) ![]u8 {+ const buf = try allocator.alloc(u8, 1 + payload_len);+ buf[0] = @intFromEnum(Tag.string);+ return buf;+}++pub fn encodeValue(value: js.Value, allocator: Allocator) ![]u8 {+ if (value.isString()) |s| {+ const buf = try stringBuf(allocator, s.len());+ _ = s.toSliceWithBuf(buf[1..]);+ return buf;+ }+ if (value.isNumber()) {+ return number(try value.toZig(f64)).encode(allocator);+ }+ return error.DataError;+}++// Encode into an order-preserving byte slice, allocated by `allocator`.+// Caller owns the returned memory.+fn encode(self: Key, allocator: Allocator) ![]u8 {+ switch (self.value) {+ .number => |n| {+ var buf = try allocator.alloc(u8, 1 + 8);+ buf[0] = @intFromEnum(Tag.number);+ writeOrderedF64(buf[1..9], n);+ return buf;+ },+ .string => |s| {+ const buf = try stringBuf(allocator, s.len);+ @memcpy(buf[1..], s);+ return buf;+ },+ }+}++// Map an f64 to 8 big-endian bytes whose unsigned ordering matches IEEE-754+// numeric ordering. For positive numbers flip only the sign bit; for negative+// numbers flip every bit. NaN is not a valid IDB key, so it is not handled.+fn writeOrderedF64(out: *[8]u8, n: f64) void {+ var bits: u64 = @bitCast(n);+ if (bits & (1 << 63) != 0) {+ bits = ~bits;+ } else {+ bits |= (1 << 63);+ }+ std.mem.writeInt(u64, out, bits, .big);+}++const testing = @import("../../../../testing.zig");++test "IDB - Key: number encoding round-trips ordering" {+ const cases = [_]f64{ -1e308, -100.5, -1, -0.0001, 0, 0.0001, 1, 100.5, 1e308 };+ var prev: ?[]u8 = null;+ defer if (prev) |p| testing.allocator.free(p);++ for (cases) |n| {+ const enc = try Key.number(n).encode(testing.allocator);+ if (prev) |p| {+ try testing.expect(std.mem.order(u8, p, enc) == .lt);+ testing.allocator.free(p);+ }+ prev = enc;+ }+}++test "IDB - Key: numbers sort before strings" {+ const num = try Key.number(1e308).encode(testing.allocator);+ defer testing.allocator.free(num);+ const str = try Key.string("").encode(testing.allocator);+ defer testing.allocator.free(str);+ try testing.expect(std.mem.order(u8, num, str) == .lt);+}++test "IDB - Key: string encoding preserves byte order" {+ const a = try Key.string("apple").encode(testing.allocator);+ defer testing.allocator.free(a);+ const b = try Key.string("banana").encode(testing.allocator);+ defer testing.allocator.free(b);+ try testing.expect(std.mem.order(u8, a, b) == .lt);+}diff --git a/src/browser/webapi/storage/idb/Manager.zig b/src/browser/webapi/storage/idb/Manager.zignew file mode 100644index 000000000..c69a33037--- /dev/null+++ b/src/browser/webapi/storage/idb/Manager.zig@@ -0,0 +1,129 @@+// 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 std = @import("std");+const lp = @import("lightpanda");++const Engine = @import("Engine.zig");++const log = lp.log;+const Allocator = std.mem.Allocator;++const Manager = @This();++allocator: Allocator,+base_dir: []const u8,+engines: std.StringHashMapUnmanaged(*Engine) = .empty,++pub fn init(allocator: Allocator, base_dir: ?[]const u8) Manager {+ return .{ .allocator = allocator, .base_dir = base_dir orelse ":memory:" };+}++pub fn deinit(self: *Manager) void {+ var it = self.engines.iterator();+ while (it.next()) |kv| {+ kv.value_ptr.*.close();+ self.allocator.destroy(kv.value_ptr.*);+ self.allocator.free(kv.key_ptr.*);+ }+ self.engines.deinit(self.allocator);+}++// Gets or creates the engine for the given origin.+pub fn engineForOrigin(self: *Manager, origin: []const u8) !*Engine {+ const gop = try self.engines.getOrPut(self.allocator, origin);+ if (gop.found_existing) {+ return gop.value_ptr.*;+ }+ errdefer _ = self.engines.remove(origin);++ const engine = try self.allocator.create(Engine);+ errdefer self.allocator.destroy(engine);++ engine.* = try self.open(origin);+ errdefer engine.close();++ gop.key_ptr.* = try self.allocator.dupe(u8, origin);+ gop.value_ptr.* = engine;+ return engine;+}++fn open(self: *Manager, origin: []const u8) !Engine {+ if (std.mem.eql(u8, self.base_dir, ":memory:")) {+ return Engine.open(":memory:");+ }++ // we hash the origin for two reason:+ // 1 - it fixes the length, so we don't have to worry about illegally long filename+ // 2 - It removes any unsafe characters+ var digest: [16]u8 = undefined;+ std.crypto.hash.Blake3.hash(origin, &digest, .{});+ var name_buf: [64]u8 = undefined;+ const file_name = std.fmt.bufPrint(&name_buf, "idb-{x}.sqlite", .{&digest}) catch unreachable;++ const path = try std.fs.path.joinZ(self.allocator, &.{ self.base_dir, file_name });+ defer self.allocator.free(path);++ log.debug(.storage, "idb open", .{ .origin = origin, .path = path });+ return Engine.open(path);+}++const testing = @import("../../../../testing.zig");+test "IDB - Manager: same origin returns same engine, distinct origins differ" {+ var mgr = Manager.init(testing.allocator, null);+ defer mgr.deinit();++ const a1 = try mgr.engineForOrigin("https://a.com");+ const a2 = try mgr.engineForOrigin("https://a.com");+ const b1 = try mgr.engineForOrigin("https://b.com");++ try testing.expect(a1 == a2);+ try testing.expect(a1 != b1);+}++test "IDB - Manager: in-memory engines are origin-isolated" {+ var mgr = Manager.init(testing.allocator, null);+ defer mgr.deinit();++ const a = try mgr.engineForOrigin("https://a.com");+ const b = try mgr.engineForOrigin("https://b.com");++ _ = try a.upsertDatabase("db", 1);+ try testing.expectEqual(null, try b.databaseVersion("db"));+}++test "IDB - Manager: on-disk engines hash to per-origin files, isolated" {+ var tmp = std.testing.tmpDir(.{});+ defer tmp.cleanup();+ const dir = try tmp.dir.realpathAlloc(testing.allocator, ".");+ defer testing.allocator.free(dir);++ var mgr = Manager.init(testing.allocator, dir);+ defer mgr.deinit();++ // A long origin (hostname near the 253-byte limit) must still open: the+ // hashed file name stays well under NAME_MAX where a transcribed one would+ // not.+ const long_host = "https://" ++ ("a" ** 250) ++ ".com";+ const a = try mgr.engineForOrigin(long_host);+ _ = try a.upsertDatabase("db", 7);++ const b = try mgr.engineForOrigin("https://b.com");+ try testing.expectEqual(null, try b.databaseVersion("db"));+ try testing.expectEqual(7, (try a.databaseVersion("db")).?);+}diff --git a/src/browser/webapi/storage/idb/idb.zig b/src/browser/webapi/storage/idb/idb.zignew file mode 100644index 000000000..eef0c94ee--- /dev/null+++ b/src/browser/webapi/storage/idb/idb.zig@@ -0,0 +1,53 @@+// 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");++pub const Key = @import("Key.zig");+pub const Engine = @import("Engine.zig");+pub const Manager = @import("Manager.zig");++pub const IDBFactory = @import("IDBFactory.zig");+pub const IDBRequest = @import("IDBRequest.zig");+pub const IDBDatabase = @import("IDBDatabase.zig");+pub const IDBTransaction = @import("IDBTransaction.zig");+pub const IDBObjectStore = @import("IDBObjectStore.zig");+pub const IDBVersionChangeEvent = @import("IDBVersionChangeEvent.zig");++pub fn registerTypes() []const type {+ return &.{+ IDBFactory,+ IDBRequest,+ IDBDatabase,+ IDBTransaction,+ IDBObjectStore,+ IDBVersionChangeEvent,+ };+}++// An on* event-handler attribute setter. The bridge can hand the setter either+// a function (store it) or any other value (clears it).+pub const FunctionSetter = union(enum) {+ func: js.Function.Global,+ anything: js.Value,+};++const testing = @import("../../../../testing.zig");+test "WebApi: IndexedDB" {+ try testing.htmlRunner("indexeddb.html", .{});+}