diff --git a/src/browser/Factory.zig b/src/browser/Factory.zig
index a1a7ed600..424ae7ee3 100644
--- a/src/browser/Factory.zig
+++ b/src/browser/Factory.zig
@@ -33,6 +33,7 @@ const Document = @import("webapi/Document.zig");
 const EventTarget = @import("webapi/EventTarget.zig");
 const AbortSignal = @import("webapi/AbortSignal.zig");
 const XMLHttpRequestEventTarget = @import("webapi/net/XMLHttpRequestEventTarget.zig");
+const IDBRequest = @import("webapi/storage/idb/IDBRequest.zig");
 const Blob = @import("webapi/Blob.zig");
 const AbstractRange = @import("webapi/AbstractRange.zig");
 const DOMRect = @import("webapi/DOMRect.zig");
@@ -505,6 +506,12 @@ pub fn xhrEventTarget(_: *const Factory, allocator: Allocator, child: anytype) !
     ).create(allocator, child);
 }
 
+pub fn idbOpenRequest(self: *Factory, child: anytype) !*@TypeOf(child) {
+    return try AutoPrototypeChain(
+        &.{ EventTarget, IDBRequest, @TypeOf(child) },
+    ).create(self._slab.allocator(), child);
+}
+
 pub fn taskSignal(self: *Factory, child: anytype) !*@TypeOf(child) {
     return try AutoPrototypeChain(
         &.{ EventTarget, AbortSignal, @TypeOf(child) },
diff --git a/src/browser/tests/indexeddb.html b/src/browser/tests/indexeddb.html
index fd0d0637a..4e0e657fa 100644
--- a/src/browser/tests/indexeddb.html
+++ b/src/browser/tests/indexeddb.html
@@ -329,9 +329,9 @@
         db.deleteObjectStore("temp");
     };
     open.onsuccess = (e) => {
-        const tx = e.target.result.transaction("temp", "readonly");
+        // The deleted store is not in the database: transaction() itself throws.
         let threw = null;
-        try { tx.objectStore("temp"); } catch (err) { threw = err; }
+        try { e.target.result.transaction("temp", "readonly"); } catch (err) { threw = err; }
         state.resolve(threw && threw.name);
     };
     await state.done((name) => {
@@ -1189,6 +1189,7 @@
     });
 }
 </script>
+<<<<<<< HEAD
 
 <!-- put()/add() structured-clone the value at call time: the record is the
      clone as of the call (later mutation of the argument is not stored), a
@@ -1228,6 +1229,42 @@
 }
 </script>
 
+<!-- Open requests are IDBOpenDBRequests; result/error throw while pending and
+     error is null (not undefined) after success; databases() lists the
+     origin's databases. -->
+<script id="request_conformance" type=module>
+{
+    const state = await testing.async();
+    const open = indexedDB.open("conformance-db", 2);
+    testing.expectEqual("IDBOpenDBRequest", Object.getPrototypeOf(open).constructor.name);
+    testing.expectEqual(true, open instanceof IDBRequest);
+    testing.expectEqual(true, "onblocked" in open);
+    testing.expectError("InvalidStateError", () => open.result);
+    testing.expectError("InvalidStateError", () => open.error);
+    open.onupgradeneeded = (e) => e.target.result.createObjectStore("s");
+    open.onsuccess = async () => {
+        const db = open.result;
+        const req = db.transaction("s").objectStore("s").get(1);
+        testing.expectError("InvalidStateError", () => req.result);
+        req.onsuccess = async () => {
+            const all = await indexedDB.databases();
+            state.resolve({
+                openError: open.error,
+                openTransaction: open.transaction,
+                reqError: req.error,
+                listed: all.filter((d) => d.name === "conformance-db"),
+            });
+        };
+    };
+    await state.done((got) => {
+        testing.expectEqual(null, got.openError);
+        testing.expectEqual(null, got.openTransaction);
+        testing.expectEqual(null, got.reqError);
+        testing.expectEqual([{ name: "conformance-db", version: 2 }], got.listed);
+    });
+}
+</script>
+
 <!-- A version above 2^32 (Date.now() is a common choice) survives the round
      trip as a Number; out-of-range versions are a TypeError. -->
 <script id="open_version_64bit" type=module>
@@ -1367,3 +1404,39 @@
 }
 </script>
 </body>
+
+<!-- transaction() validates up front: closed connection, empty scope, unknown
+     store; a DOMStringList scope (db.objectStoreNames) is accepted; getAll's
+     count is [EnforceRange]; objectStore()/index() throw once the
+     transaction finished. -->
+<script id="transaction_argument_checks" type=module>
+{
+    const state = await testing.async();
+    const open = indexedDB.open("txn-args-db", 1);
+    open.onupgradeneeded = (e) => {
+        const db = e.target.result;
+        db.createObjectStore("a").createIndex("by_x", "x");
+        db.createObjectStore("b");
+    };
+    open.onsuccess = () => {
+        const db = open.result;
+        testing.expectError("InvalidAccessError", () => db.transaction([]));
+        testing.expectError("NotFoundError", () => db.transaction("nope"));
+        testing.expectError("NotFoundError", () => db.transaction(["a", "nope"]));
+        const tx = db.transaction(db.objectStoreNames, "readonly");
+        testing.expectEqual(["a", "b"], [...tx.objectStoreNames]);
+        const store = tx.objectStore("a");
+        testing.expectError("TypeError", () => store.getAll(null, -1));
+        testing.expectError("TypeError", () => store.getAll(null, NaN));
+        testing.expectError("TypeError", () => store.index("by_x").getAllKeys({ count: Infinity }));
+        tx.abort();
+        testing.expectError("InvalidStateError", () => tx.objectStore("a"));
+        testing.expectError("InvalidStateError", () => store.index("by_x"));
+        db.close();
+        testing.expectError("InvalidStateError", () => db.transaction("a"));
+        state.resolve(true);
+    };
+    await state.done((got) => testing.expectEqual(true, got));
+}
+</script>
+</body>
diff --git a/src/browser/webapi/storage/idb/Engine.zig b/src/browser/webapi/storage/idb/Engine.zig
index d43b93c82..7f51e5bce 100644
--- a/src/browser/webapi/storage/idb/Engine.zig
+++ b/src/browser/webapi/storage/idb/Engine.zig
@@ -200,6 +200,31 @@ 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 const DatabaseInfo = struct {
+    name: []const u8,
+    version: i64,
+};
+
+// Every database of the origin, by name (IDBFactory.databases).
+pub fn databases(self: *const Engine, arena: Allocator) ![]const DatabaseInfo {
+    var rows = try self.conn.rows("select name, version from idb_databases order by name", .{});
+    defer rows.deinit();
+
+    var list: std.ArrayList(DatabaseInfo) = .empty;
+    while (try rows.next()) |row| {
+        try list.append(arena, .{
+            .name = try arena.dupe(u8, row.get([]const u8, 0)),
+            .version = row.get(i64, 1),
+        });
+    }
+    return list.items;
+}
+
+pub fn indexExists(self: *const Engine, object_store_id: i64, name: []const u8) !bool {
+    const id = try self.conn.scalar(i64, "select id from idb_indexes where object_store_id = ?1 and name = ?2", .{ object_store_id, name });
+    return id != null;
+}
+
 pub fn upsertDatabase(self: *Engine, name: []const u8, version: i64) !i64 {
     try self.conn.exec(
         \\ insert into idb_databases (name, version) values (?1, ?2)
diff --git a/src/browser/webapi/storage/idb/IDBDatabase.zig b/src/browser/webapi/storage/idb/IDBDatabase.zig
index 7eef142ec..0b3dde2e2 100644
--- a/src/browser/webapi/storage/idb/IDBDatabase.zig
+++ b/src/browser/webapi/storage/idb/IDBDatabase.zig
@@ -47,6 +47,7 @@ _version: i64,
 _txn: ?*IDBTransaction = null, // only set during upgradeneeded
 _on_error: ?js.Function.Global = null,
 _on_abort: ?js.Function.Global = null,
+_closed: bool = false,
 
 pub fn init(exec: *Execution, engine: *Engine, database_id: i64, name: []const u8, version: i64) !*IDBDatabase {
     return exec._factory.eventTarget(IDBDatabase{
@@ -82,12 +83,19 @@ pub fn createObjectStore(
 
     const opts = options orelse CreateObjectStoreOptions{};
 
-    // Validate + copy the key path onto the transaction arena so it outlives the
-    // call. autoIncrement is incompatible with an empty or compound key path.
-    const key_path: ?Key.KeyPath = if (opts.keyPath) |kp| blk: {
+    // Spec order: key path syntax, then the name, then autoIncrement vs. key path.
+    if (opts.keyPath) |kp| {
         if (Key.isValidKeyPathSpec(kp) == false) {
             return error.SyntaxError;
         }
+    }
+    if ((try self._engine.objectStoreId(self._database_id, name)) != null) {
+        return error.ConstraintError;
+    }
+
+    // Copy the key path onto the transaction arena so it outlives the call.
+    // autoIncrement is incompatible with an empty or compound key path.
+    const key_path: ?Key.KeyPath = if (opts.keyPath) |kp| blk: {
         if (opts.autoIncrement and keyPathBlocksAutoIncrement(kp)) {
             return error.InvalidAccessError;
         }
@@ -139,8 +147,17 @@ const TransactionMode = enum {
 };
 
 const StoreNames = union(enum) {
+    list: *DOMStringList,
     name: []const u8,
     names: []const []const u8,
+
+    fn slice(self: *const StoreNames) []const []const u8 {
+        return switch (self.*) {
+            .names => |names| names,
+            .list => |l| l._items,
+            .name => |*n| (n)[0..1],
+        };
+    }
 };
 
 const TransactionOptions = struct {
@@ -154,6 +171,25 @@ pub fn transaction(
     options: ?TransactionOptions,
     exec: *Execution,
 ) !*IDBTransaction {
+    if (self._closed) {
+        return error.InvalidStateError;
+    }
+    if (self._txn) |upgrade| {
+        // An upgrade still running owns the connection; once it settled, new
+        // transactions may start even before the open request's success fires.
+        if (!upgrade._settled) {
+            return error.InvalidStateError;
+        }
+    }
+
+    const names = store_names.slice();
+    if (names.len == 0) {
+        return error.InvalidAccessError;
+    }
+    for (names) |name| {
+        try self.assertStoreExists(name);
+    }
+
     const opts = options orelse TransactionOptions{};
     const txn = try IDBTransaction.init(self, switch (mode orelse .readonly) {
         .readonly => .readonly,
@@ -163,18 +199,19 @@ pub fn transaction(
     return txn;
 }
 
+fn assertStoreExists(self: *const IDBDatabase, name: []const u8) !void {
+    if ((try self._engine.objectStoreId(self._database_id, name)) == null) {
+        return error.NotFound;
+    }
+}
+
 // The transaction's scope: the requested store names, sorted with duplicates
 // removed (per the IndexedDB spec's "transaction scope" steps).
 fn normalizeStoreNames(arena: Allocator, store_names: StoreNames) ![]const []const u8 {
-    var list: std.ArrayList([]const u8) = .empty;
-    switch (store_names) {
-        .name => |name| try list.append(arena, try arena.dupe(u8, name)),
-        .names => |names| {
-            try list.ensureUnusedCapacity(arena, names.len);
-            for (names) |name| {
-                list.appendAssumeCapacity(try arena.dupe(u8, name));
-            }
-        },
+    const names = store_names.slice();
+    var list: std.ArrayList([]const u8) = try .initCapacity(arena, names.len);
+    for (names) |name| {
+        list.appendAssumeCapacity(try arena.dupe(u8, name));
     }
 
     std.mem.sort([]const u8, list.items, {}, struct {
@@ -199,9 +236,8 @@ fn normalizeStoreNames(arena: Allocator, store_names: StoreNames) ![]const []con
     return list.items[0..write];
 }
 
-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 close(self: *IDBDatabase) void {
+    self._closed = true;
 }
 
 pub fn getName(self: *const IDBDatabase) []const u8 {
diff --git a/src/browser/webapi/storage/idb/IDBFactory.zig b/src/browser/webapi/storage/idb/IDBFactory.zig
index 878921c0f..b520acd53 100644
--- a/src/browser/webapi/storage/idb/IDBFactory.zig
+++ b/src/browser/webapi/storage/idb/IDBFactory.zig
@@ -45,7 +45,7 @@ pub fn open(_: *IDBFactory, name: []const u8, version: ?u64, exec: *Execution) !
         if (v == 0) return error.TypeError;
     }
 
-    const request = try IDBRequest.init(exec);
+    const request = try IDBRequest.initOpen(exec);
 
     const ctx = try exec._factory.create(OpenContext{
         .request = request,
@@ -177,7 +177,7 @@ const OpenContext = struct {
         txn._db._txn = null;
         txn.releaseRef(exec.page);
 
-        if (aborted) {
+        if (aborted or txn._db._closed) {
             self.request._result = .{ .none = js.Undefined{} };
             self.request.setError(error.AbortError);
             return self.request.deliver(exec);
@@ -295,7 +295,7 @@ pub fn deleteDatabase(_: *IDBFactory, name: []const u8, exec: *Execution) !*IDBR
         return error.SecurityError;
     }
 
-    const request = try IDBRequest.init(exec);
+    const request = try IDBRequest.initOpen(exec);
 
     const ctx = try exec._factory.create(DeleteContext{
         .request = request,
@@ -386,6 +386,14 @@ const DeleteContext = struct {
     }
 };
 
+pub fn databases(_: *IDBFactory, exec: *Execution) !js.Promise {
+    const local = exec.js.local.?;
+    // unavailable for opaque origins, e.g. about:blank
+    const origin = exec.origin() orelse return local.rejectPromise(.{ .dom_exception = .{ .err = error.SecurityError } });
+    const engine = try exec.session.idb.engineForOrigin(origin);
+    return local.resolvePromise(try engine.databases(exec.call_arena));
+}
+
 pub fn cmp(_: *IDBFactory, first: js.Value, second: js.Value, exec: *Execution) !i32 {
     const a = try Key.encodeValue(exec.call_arena, first);
     const b = try Key.encodeValue(exec.call_arena, second);
@@ -408,5 +416,6 @@ pub const JsApi = struct {
 
     pub const open = bridge.function(IDBFactory.open, .{});
     pub const deleteDatabase = bridge.function(IDBFactory.deleteDatabase, .{});
+    pub const databases = bridge.function(IDBFactory.databases, .{});
     pub const cmp = bridge.function(IDBFactory.cmp, .{});
 };
diff --git a/src/browser/webapi/storage/idb/IDBIndex.zig b/src/browser/webapi/storage/idb/IDBIndex.zig
index 5c55f5a97..ab2002264 100644
--- a/src/browser/webapi/storage/idb/IDBIndex.zig
+++ b/src/browser/webapi/storage/idb/IDBIndex.zig
@@ -123,11 +123,11 @@ pub fn runGetKey(self: *IDBIndex, request: *IDBRequest, bounds: Engine.Bounds, e
     try request.setValue(try Key.decodeToJs(arena, exec.js.local.?, b));
 }
 
-pub fn getAll(self: *IDBIndex, query_or_options: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {
+pub fn getAll(self: *IDBIndex, query_or_options: ?js.Value, count_: ?f64, exec: *Execution) !*IDBRequest {
     return self._getAll(query_or_options, count_, .value, exec);
 }
 
-pub fn getAllKeys(self: *IDBIndex, query_or_options: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {
+pub fn getAllKeys(self: *IDBIndex, query_or_options: ?js.Value, count_: ?f64, exec: *Execution) !*IDBRequest {
     return self._getAll(query_or_options, count_, .key, exec);
 }
 
@@ -138,7 +138,7 @@ pub fn getAllRecords(self: *IDBIndex, options: ?js.Value, exec: *Execution) !*ID
     return request.submit(.{ .index_get_all = .{ .index = self, .args = args, .mode = .record } }, exec);
 }
 
-fn _getAll(self: *IDBIndex, query_or_options: ?js.Value, count_: ?u32, mode: IDBObjectStore.GetAllMode, exec: *Execution) !*IDBRequest {
+fn _getAll(self: *IDBIndex, query_or_options: ?js.Value, count_: ?f64, mode: IDBObjectStore.GetAllMode, exec: *Execution) !*IDBRequest {
     const t = try self.txn();
     const args = try IDBKeyRange.resolveGetAll(t._arena.allocator(), query_or_options, count_, exec);
     const request = try t.newRequest();
@@ -199,14 +199,14 @@ pub fn runCount(self: *IDBIndex, request: *IDBRequest, bounds: Engine.Bounds, ex
 }
 
 pub fn openCursor(self: *IDBIndex, query: ?js.Value, direction: ?IDBCursor.Direction, exec: *Execution) !*IDBRequest {
-    try self.assertLive();
-    const bounds = try IDBKeyRange.resolveQuery(self._store._txn._arena.allocator(), query, exec);
+    const t = try self.txn();
+    const bounds = try IDBKeyRange.resolveQuery(t._arena.allocator(), query, exec);
     return IDBCursor.initIndex(self, bounds, direction orelse .next, false, exec);
 }
 
 pub fn openKeyCursor(self: *IDBIndex, query: ?js.Value, direction: ?IDBCursor.Direction, exec: *Execution) !*IDBRequest {
-    try self.assertLive();
-    const bounds = try IDBKeyRange.resolveQuery(self._store._txn._arena.allocator(), query, exec);
+    const t = try self.txn();
+    const bounds = try IDBKeyRange.resolveQuery(t._arena.allocator(), query, exec);
     return IDBCursor.initIndex(self, bounds, direction orelse .next, true, exec);
 }
 
diff --git a/src/browser/webapi/storage/idb/IDBKeyRange.zig b/src/browser/webapi/storage/idb/IDBKeyRange.zig
index 5e9c90927..7833cb122 100644
--- a/src/browser/webapi/storage/idb/IDBKeyRange.zig
+++ b/src/browser/webapi/storage/idb/IDBKeyRange.zig
@@ -161,13 +161,13 @@ pub const GetAllArgs = struct {
 // IDBGetAllOptions dictionary as the first argument. Per Web IDL, the first
 // argument is the options dictionary when it's an object that is not itself a key
 // or an IDBKeyRange; otherwise it's the query and `count` is the count.
-pub fn resolveGetAll(arena: Allocator, query_or_options: ?js.Value, count: ?u32, exec: *Execution) !GetAllArgs {
+pub fn resolveGetAll(arena: Allocator, query_or_options: ?js.Value, count: ?f64, exec: *Execution) !GetAllArgs {
     if (query_or_options) |v| {
         if (isOptionsDictionary(v, exec)) {
             return resolveOptions(arena, v, exec);
         }
     }
-    return .{ .bounds = try resolveQuery(arena, query_or_options, exec), .count = normalizeCount(count) };
+    return .{ .bounds = try resolveQuery(arena, query_or_options, exec), .count = try normalizeCount(count) };
 }
 
 // getAllRecords always takes an IDBGetAllOptions dictionary (or nothing).
@@ -200,7 +200,7 @@ fn resolveOptions(arena: Allocator, v: js.Value, exec: *Execution) !GetAllArgs {
 
     const count = try obj.get("count");
     if (!count.isNullOrUndefined()) {
-        args.count = normalizeCount(try count.toU32());
+        args.count = try normalizeCount(try count.toF64());
     }
 
     const direction = try obj.get("direction");
@@ -211,9 +211,19 @@ fn resolveOptions(arena: Allocator, v: js.Value, exec: *Execution) !GetAllArgs {
     return args;
 }
 
-fn normalizeCount(count: ?u32) ?u32 {
+// count is [EnforceRange] unsigned long: NaN, the infinities and anything
+// outside [0, 2^32) are a TypeError (fractions truncate). 0 means "no limit".
+fn normalizeCount(count: ?f64) !?u32 {
     const c = count orelse return null;
-    return if (c == 0) null else c;
+    if (!std.math.isFinite(c)) {
+        return error.TypeError;
+    }
+    const truncated = @trunc(c);
+    if (truncated < 0 or truncated > std.math.maxInt(u32)) {
+        return error.TypeError;
+    }
+    const n: u32 = @intFromFloat(truncated);
+    return if (n == 0) null else n;
 }
 
 pub const JsApi = struct {
diff --git a/src/browser/webapi/storage/idb/IDBObjectStore.zig b/src/browser/webapi/storage/idb/IDBObjectStore.zig
index 418743386..620a2f29c 100644
--- a/src/browser/webapi/storage/idb/IDBObjectStore.zig
+++ b/src/browser/webapi/storage/idb/IDBObjectStore.zig
@@ -112,10 +112,10 @@ pub fn runGet(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bounds
 pub fn delete(self: *IDBObjectStore, query: js.Value, exec: *Execution) !*IDBRequest {
     try self.assertLive();
     const txn = self._txn;
+    try txn.assertActive();
     if (txn._mode == .readonly) {
         return error.ReadOnlyError;
     }
-    try txn.assertActive();
     const bounds = try IDBKeyRange.resolveKey(txn._arena.allocator(), query, exec);
     const request = try txn.newRequest();
     return request.submit(.{ .store_delete = .{ .store = self, .bounds = bounds } }, exec);
@@ -177,11 +177,11 @@ pub fn runCount(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Boun
 // What a getAll/getAllKeys/getAllRecords produces
 pub const GetAllMode = enum { value, key, record };
 
-pub fn getAll(self: *IDBObjectStore, query_or_options: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {
+pub fn getAll(self: *IDBObjectStore, query_or_options: ?js.Value, count_: ?f64, exec: *Execution) !*IDBRequest {
     return self._getAll(query_or_options, count_, .value, exec);
 }
 
-pub fn getAllKeys(self: *IDBObjectStore, query_or_options: ?js.Value, count_: ?u32, exec: *Execution) !*IDBRequest {
+pub fn getAllKeys(self: *IDBObjectStore, query_or_options: ?js.Value, count_: ?f64, exec: *Execution) !*IDBRequest {
     return self._getAll(query_or_options, count_, .key, exec);
 }
 
@@ -194,7 +194,7 @@ pub fn getAllRecords(self: *IDBObjectStore, options: ?js.Value, exec: *Execution
     return request.submit(.{ .store_get_all = .{ .store = self, .args = args, .mode = .record } }, exec);
 }
 
-fn _getAll(self: *IDBObjectStore, query_or_options: ?js.Value, count_: ?u32, mode: GetAllMode, exec: *Execution) !*IDBRequest {
+fn _getAll(self: *IDBObjectStore, query_or_options: ?js.Value, count_: ?f64, mode: GetAllMode, exec: *Execution) !*IDBRequest {
     try self.assertLive();
     const txn = self._txn;
     try txn.assertActive();
@@ -259,12 +259,14 @@ pub fn runGetKey(self: *IDBObjectStore, request: *IDBRequest, bounds: Engine.Bou
 
 pub fn openCursor(self: *IDBObjectStore, query: ?js.Value, direction: ?IDBCursor.Direction, exec: *Execution) !*IDBRequest {
     try self.assertLive();
+    try self._txn.assertActive();
     const bounds = try IDBKeyRange.resolveQuery(self._txn._arena.allocator(), query, exec);
     return IDBCursor.init(self, bounds, direction orelse .next, false, exec);
 }
 
 pub fn openKeyCursor(self: *IDBObjectStore, query: ?js.Value, direction: ?IDBCursor.Direction, exec: *Execution) !*IDBRequest {
     try self.assertLive();
+    try self._txn.assertActive();
     const bounds = try IDBKeyRange.resolveQuery(self._txn._arena.allocator(), query, exec);
     return IDBCursor.init(self, bounds, direction orelse .next, true, exec);
 }
@@ -509,8 +511,10 @@ pub fn createIndex(self: *IDBObjectStore, name: []const u8, key_path: Key.KeyPat
     if (txn._mode != .versionchange) {
         return error.InvalidStateError;
     }
-    // Spec order: the transaction-state check precedes the index-name check.
     try txn.assertActive();
+    if (try self._engine.indexExists(self._store_id, name)) {
+        return error.ConstraintError;
+    }
     if (Key.isValidKeyPathSpec(key_path) == false) {
         return error.SyntaxError;
     }
@@ -580,7 +584,6 @@ pub fn deleteIndex(self: *IDBObjectStore, name: []const u8, _: *Execution) !void
     if (txn._mode != .versionchange) {
         return error.InvalidStateError;
     }
-    // Spec order: the transaction-state check precedes the index-name check.
     try txn.assertActive();
     self._engine.deleteIndexRow(self._store_id, name) catch |err| switch (err) {
         error.NotFound => return error.NotFoundError,
@@ -598,6 +601,9 @@ pub fn deleteIndex(self: *IDBObjectStore, name: []const u8, _: *Execution) !void
 
 pub fn index(self: *IDBObjectStore, name: []const u8, _: *Execution) !*IDBIndex {
     try self.assertLive();
+    if (self._txn._settled) {
+        return error.InvalidStateError;
+    }
     for (self._indexes.items) |idx| {
         if (std.mem.eql(u8, idx._name, name)) {
             return idx;
diff --git a/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig b/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig
new file mode 100644
index 000000000..29dadef12
--- /dev/null
+++ b/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig
@@ -0,0 +1,63 @@
+// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// 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 idb = @import("idb.zig");
+const IDBRequest = @import("IDBRequest.zig");
+
+const FunctionSetter = idb.FunctionSetter;
+
+// The request returned by IDBFactory.open / deleteDatabase.
+const IDBOpenDBRequest = @This();
+
+pub const Proto = IDBRequest;
+
+_proto: *IDBRequest,
+// Stored, never fired: an open that upgrades does not wait on other
+// connections (see IDBFactory.OpenContext), so nothing ever blocks.
+_on_blocked: ?js.Function.Global = null,
+
+pub fn getOnBlocked(self: *const IDBOpenDBRequest) ?js.Function.Global {
+    return self._on_blocked;
+}
+
+pub fn setOnBlocked(self: *IDBOpenDBRequest, setter: ?FunctionSetter) void {
+    self._on_blocked = idb.functionFromSetter(setter);
+}
+
+pub fn getOnUpgradeNeeded(self: *const IDBOpenDBRequest) ?js.Function.Global {
+    return self._proto.getOnUpgradeNeeded();
+}
+
+pub fn setOnUpgradeNeeded(self: *IDBOpenDBRequest, setter: ?FunctionSetter) void {
+    self._proto.setOnUpgradeNeeded(setter);
+}
+
+pub const JsApi = struct {
+    pub const bridge = js.Bridge(IDBOpenDBRequest);
+
+    pub const Meta = struct {
+        pub const name = "IDBOpenDBRequest";
+        pub const prototype_chain = bridge.prototypeChain();
+        pub var class_id: bridge.ClassId = undefined;
+    };
+
+    pub const onblocked = bridge.accessor(IDBOpenDBRequest.getOnBlocked, IDBOpenDBRequest.setOnBlocked, .{});
+    pub const onupgradeneeded = bridge.accessor(IDBOpenDBRequest.getOnUpgradeNeeded, IDBOpenDBRequest.setOnUpgradeNeeded, .{});
+};
diff --git a/src/browser/webapi/storage/idb/IDBRequest.zig b/src/browser/webapi/storage/idb/IDBRequest.zig
index 591d0e600..a1758563f 100644
--- a/src/browser/webapi/storage/idb/IDBRequest.zig
+++ b/src/browser/webapi/storage/idb/IDBRequest.zig
@@ -29,6 +29,7 @@ const idb = @import("idb.zig");
 const Engine = @import("Engine.zig");
 const IDBIndex = @import("IDBIndex.zig");
 const IDBCursor = @import("IDBCursor.zig");
+const IDBOpenDBRequest = @import("IDBOpenDBRequest.zig");
 const IDBDatabase = @import("IDBDatabase.zig");
 const IDBKeyRange = @import("IDBKeyRange.zig");
 const IDBObjectStore = @import("IDBObjectStore.zig");
@@ -44,6 +45,7 @@ const IDBRequest = @This();
 pub const Proto = EventTarget;
 
 _proto: *EventTarget,
+_type: Type = .generic,
 _op: Operation = .none,
 _error: ?anyerror = null,
 _txn: Txn = .none,
@@ -101,8 +103,15 @@ const Txn = union(enum) {
     borrowed: *IDBTransaction,
 };
 
-pub fn init(exec: *Execution) !*IDBRequest {
-    return exec._factory.eventTarget(IDBRequest{ ._proto = undefined });
+pub const Type = union(enum) {
+    generic,
+    open: *IDBOpenDBRequest,
+};
+
+// An open/deleteDatabase request: page-scoped, exposed as IDBOpenDBRequest.
+pub fn initOpen(exec: *Execution) !*IDBRequest {
+    const open = try exec._factory.idbOpenRequest(IDBOpenDBRequest{ ._proto = undefined });
+    return open._proto;
 }
 
 pub fn asEventTarget(self: *IDBRequest) *EventTarget {
@@ -321,7 +330,10 @@ const JsResult = union(enum) {
     database: *IDBDatabase,
 };
 
-pub fn getResult(self: *const IDBRequest, exec: *Execution) JsResult {
+pub fn getResult(self: *const IDBRequest, exec: *Execution) !JsResult {
+    if (self._ready_state == .pending) {
+        return error.InvalidStateError;
+    }
     return switch (self._result) {
         .none => |n| .{ .none = n },
         .value => |global| .{ .value = global.local(exec.js.local.?) },
@@ -344,7 +356,10 @@ pub fn getTransaction(self: *const IDBRequest) ?*IDBTransaction {
 
 // 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 {
+pub fn getError(self: *const IDBRequest) !?DOMException {
+    if (self._ready_state == .pending) {
+        return error.InvalidStateError;
+    }
     const err = self._error orelse return null;
     const mapped: anyerror = switch (err) {
         // sqlite's generic constraint failure is IDB's ConstraintError.
@@ -493,9 +508,8 @@ pub const JsApi = struct {
     pub const readyState = bridge.accessor(IDBRequest.getReadyState, null, .{});
     pub const result = bridge.accessor(IDBRequest.getResult, null, .{});
     pub const source = bridge.accessor(IDBRequest.getSource, null, .{});
-    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 transaction = bridge.accessor(IDBRequest.getTransaction, null, .{});
+    pub const @"error" = bridge.accessor(IDBRequest.getError, null, .{});
     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.zig
index 7ab2f6e3b..e742f1f2d 100644
--- a/src/browser/webapi/storage/idb/IDBTransaction.zig
+++ b/src/browser/webapi/storage/idb/IDBTransaction.zig
@@ -507,6 +507,9 @@ pub fn enqueue(self: *IDBTransaction, request: *IDBRequest) !void {
 }
 
 pub fn objectStore(self: *IDBTransaction, name: []const u8) !*IDBObjectStore {
+    if (self._settled) {
+        return error.InvalidStateError;
+    }
     for (self._stores.items) |store| {
         if (std.mem.eql(u8, store._name, name)) {
             return store;
diff --git a/src/browser/webapi/storage/idb/idb.zig b/src/browser/webapi/storage/idb/idb.zig
index 33d7da71a..2bd2b3cd0 100644
--- a/src/browser/webapi/storage/idb/idb.zig
+++ b/src/browser/webapi/storage/idb/idb.zig
@@ -26,6 +26,7 @@ pub const Manager = @import("Manager.zig");
 pub const IDBFactory = @import("IDBFactory.zig");
 pub const IDBRecord = @import("IDBRecord.zig");
 pub const IDBRequest = @import("IDBRequest.zig");
+pub const IDBOpenDBRequest = @import("IDBOpenDBRequest.zig");
 pub const IDBCursor = @import("IDBCursor.zig");
 pub const IDBIndex = @import("IDBIndex.zig");
 pub const IDBDatabase = @import("IDBDatabase.zig");
@@ -40,6 +41,7 @@ pub fn registerTypes() []const type {
         IDBFactory,
         IDBRecord,
         IDBRequest,
+        IDBOpenDBRequest,
         IDBCursor,
         IDBIndex,
         IDBDatabase,
@@ -76,6 +78,14 @@ pub const FunctionSetter = union(enum) {
     anything: js.Value,
 };
 
+pub fn functionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {
+    const s = setter orelse return null;
+    return switch (s) {
+        .func => |f| f,
+        .anything => null,
+    };
+}
+
 const testing = @import("../../../../testing.zig");
 test "WebApi: IndexedDB" {
     try testing.htmlRunner("indexeddb.html", .{});