refactor: simplify identity cache — drop compact id, key by pointer

The initial implementation used a Swift-assigned compact Int32 id so that
JS could index a dense Array<wrapper>. In isolation Array[i] is ~2x faster
than Map.get (194ns vs 98ns for 1M integer-keyed lookups), but end-to-end
benchmarks never surfaced that win — the swift-mode hit path came in at
parity with pointer mode regardless. Meanwhile the id machinery carried
real cost: five per-class globals, id allocation + recycling, reverse
lookup dictionary, two i32 push/pop pairs per return.

Swift per-class state: 5 globals → 2

    _identityTable:  [ptr:id] → Set<ptr>
    _idToPointer:    [id:ptr] → removed
    _wrapperRefs:    [Int32]  → [ptr:Int32]
    _freeIds                  → removed
    _nextId                   → removed

JS per-class cache: Array<wrapper>[id] → Map<ptr, wrapper>
Stack pushes per return: 2 (id, freshBit) → 1 (freshBit)
Wasm exports: register_wrapper / release_wrapper now take pointer

ABI contract, === semantics, and lifetime guarantees are unchanged.

Performance impact (500k iters, median ms, swift mode only):

                              v1    v2    delta
    passBothWaysRoundtrip      33    28    -15%
    getPoolRepeated_100        41    34    -17%
    swiftCreatesObject         846   592   -30%
    churnObjects               456   438    -4%

Simpler code runs faster; the id-allocation + reverse-dict upkeep was net
negative. 165/165 tests green.

Author: krodak

Benchmarks/Sources/Generated/BridgeJS.swift

@@ -352,35 +352,27 @@ public class ExportSwift {
                     """
                 )
             case .swiftHeapObject(let className) where isSwiftIdentityMode(className):
-                // identityMode: "swift" — Swift owns the wrapper lifetime and
-                // the authoritative pointer→id table. On hit, skip the
-                // passRetained; on miss, retain once and reserve a wrapper
-                // slot. JS pops (id, freshBit) from the i32 stack after the
-                // return pointer and either returns the cached wrapper or
-                // builds a fresh one and calls back via
-                // `bjs_<Class>_register_wrapper` to install the strong JS ref.
+                // identityMode: "swift" — Swift tracks which pointers have
+                // an associated JS wrapper via a per-class Set. On hit, skip
+                // the passRetained; JS keeps the wrapper alive via its
+                // strong `Map<pointer, wrapper>`. On miss, retain once and
+                // signal freshBit=1 so JS builds the wrapper.
+                //
+                // ABI: one i32 push after the return pointer — `freshBit`.
+                // JS pops `freshBit` and either returns its cached wrapper
+                // (0) or builds a fresh one and calls `register_wrapper` to
+                // give Swift the retained JS ref (1).
                 append(
                     """
                     return withExtendedLifetime(ret) {
                         let ptr = Unmanaged.passUnretained(ret).toOpaque()
-                        if let id = _\(raw: className)_identityTable[ptr] {
-                            // Cache hit: do NOT retain. JS keeps the wrapper alive via _wrapperRefs[id].
-                            _swift_js_push_i32(id)
+                        if _\(raw: className)_identityTable.contains(ptr) {
+                            // Cache hit: do NOT retain. JS has the wrapper cached.
                             _swift_js_push_i32(0)
                             return ptr
                         }
                         _ = Unmanaged.passRetained(ret)
-                        let id: Int32
-                        if let recycled = _\(raw: className)_freeIds.popLast() {
-                            id = recycled
-                        } else {
-                            id = _\(raw: className)_nextId
-                            _\(raw: className)_nextId += 1
-                            _\(raw: className)_wrapperRefs.append(0)
-                        }
-                        _\(raw: className)_identityTable[ptr] = id
-                        _\(raw: className)_idToPointer[id] = ptr
-                        _swift_js_push_i32(id)
+                        _\(raw: className)_identityTable.insert(ptr)
                         _swift_js_push_i32(1)
                         return ptr
                     }
@@ -719,25 +711,19 @@ public class ExportSwift {
     func renderSingleExportedClass(klass: ExportedClass) throws -> [DeclSyntax] {
         var decls: [DeclSyntax] = []
 
-        // identityMode: "swift" — emit the per-class Swift-owned identity cache
-        // state (pointer→id forward map, id→pointer reverse map for O(1)
-        // release, dense wrapper-ref array, free-id stack, monotonic counter).
-        // See Docs/superpowers/specs/2026-04-21-swift-side-identity-cache-design.md §5.1.
+        // identityMode: "swift" — per-class state. Simpler than the original
+        // id-based design: the JS-side cache is keyed directly by pointer (as
+        // a strong Map), so Swift only needs:
+        //   - a Set of pointers that already have a JS wrapper
+        //   - a Map of pointer → JS ref (so Swift can release the JS ref
+        //     when the wrapper is released)
+        // See DECISIONS.md D18 for why this supersedes the 5-global design.
         if isSwiftIdentityMode(klass.name) {
             decls.append(
-                "nonisolated(unsafe) var _\(raw: klass.name)_identityTable: [UnsafeMutableRawPointer: Int32] = [:]"
+                "nonisolated(unsafe) var _\(raw: klass.name)_identityTable: Set<UnsafeMutableRawPointer> = []"
             )
             decls.append(
-                "nonisolated(unsafe) var _\(raw: klass.name)_idToPointer: [Int32: UnsafeMutableRawPointer] = [:]"
-            )
-            decls.append(
-                "nonisolated(unsafe) var _\(raw: klass.name)_wrapperRefs: [Int32] = []"
-            )
-            decls.append(
-                "nonisolated(unsafe) var _\(raw: klass.name)_freeIds: [Int32] = []"
-            )
-            decls.append(
-                "nonisolated(unsafe) var _\(raw: klass.name)_nextId: Int32 = 0"
+                "nonisolated(unsafe) var _\(raw: klass.name)_wrapperRefs: [UnsafeMutableRawPointer: Int32] = [:]"
             )
         }
 
@@ -781,18 +767,18 @@ public class ExportSwift {
         }
 
         // identityMode: "swift" — emit the register/release thunks that pair
-        // with the JS-side fresh-wrapper handshake. See spec §5.3 and §5.4.
-        // Per D8.3, release uses the reverse dictionary (O(1) drop).
+        // with the JS-side fresh-wrapper handshake. Both thunks are keyed by
+        // raw pointer — no id indirection. See DECISIONS.md D18.
         if isSwiftIdentityMode(klass.name) {
             do {
                 let registerDecl = SwiftCodePattern.buildExposedFunctionDecl(
                     abiName: "bjs_\(klass.abiName)_register_wrapper",
                     signature: SwiftSignatureBuilder.buildABIFunctionSignature(
-                        abiParameters: [("id", .i32), ("jsRef", .i32)],
+                        abiParameters: [("pointer", .pointer), ("jsRef", .i32)],
                         returnType: nil
                     )
                 ) { printer in
-                    printer.write("_\(klass.name)_wrapperRefs[Int(id)] = jsRef")
+                    printer.write("_\(klass.name)_wrapperRefs[pointer] = jsRef")
                 }
                 decls.append(DeclSyntax(registerDecl))
             }
@@ -801,59 +787,33 @@ public class ExportSwift {
                 let releaseDecl = SwiftCodePattern.buildExposedFunctionDecl(
                     abiName: "bjs_\(klass.abiName)_release_wrapper",
                     signature: SwiftSignatureBuilder.buildABIFunctionSignature(
-                        abiParameters: [("id", .i32)],
+                        abiParameters: [("pointer", .pointer)],
                         returnType: nil
                     )
                 ) { printer in
-                    printer.write("let slot = Int(id)")
-                    printer.write("let jsRef = _\(klass.name)_wrapperRefs[slot]")
-                    printer.write("guard jsRef != 0 else { return }")
-                    printer.write("_\(klass.name)_wrapperRefs[slot] = 0")
-                    printer.write("if let ptr = _\(klass.name)_idToPointer.removeValue(forKey: id) {")
-                    printer.write("    _\(klass.name)_identityTable.removeValue(forKey: ptr)")
-                    printer.write("    Unmanaged<\(klass.swiftCallName)>.fromOpaque(ptr).release()")
-                    printer.write("}")
-                    printer.write("_\(klass.name)_freeIds.append(id)")
+                    printer.write("guard let jsRef = _\(klass.name)_wrapperRefs.removeValue(forKey: pointer) else { return }")
+                    printer.write("_\(klass.name)_identityTable.remove(pointer)")
+                    printer.write("Unmanaged<\(klass.swiftCallName)>.fromOpaque(pointer).release()")
                     printer.write("_swift_js_release_ref(jsRef)")
                 }
                 decls.append(DeclSyntax(releaseDecl))
             }
 
-            // Override the default `_BridgedSwiftHeapObject.bridgeJSStackPush` so
-            // array-element returns (`[SwiftCached]`) go through the same
-            // identity-cache handshake as scalar returns.
-            //
-            // See DECISIONS.md D15. The default in BridgeJSIntrinsics.swift just
-            // calls `_swift_js_push_pointer(Unmanaged.passRetained(self).toOpaque())`
-            // — that bypasses `_<Class>_identityTable` and leaves JS's `__wrap`
-            // popping garbage instead of `(id, freshBit)`.
-            //
-            // Push order: `(id, freshBit)` on the i32 stack first, then the
-            // pointer on the pointer stack. JS pops in reverse (pointer, then
-            // freshBit, then id), matching how the codegen-emitted `__wrap`
-            // already reads them.
+            // Override the default `_BridgedSwiftHeapObject.bridgeJSStackPush`
+            // so array-element returns (`[SwiftCached]`) go through the same
+            // identity-cache handshake. See DECISIONS.md D15 (still applies —
+            // only the internals changed; D18 simplified them).
             let stackPushExt: DeclSyntax = """
                 extension \(raw: klass.swiftCallName) {
                     @_spi(BridgeJS) public consuming func bridgeJSStackPush() {
                         let ptr: UnsafeMutableRawPointer = withExtendedLifetime(self) {
                             let ptr = Unmanaged.passUnretained(self).toOpaque()
-                            if let id = _\(raw: klass.name)_identityTable[ptr] {
-                                _swift_js_push_i32(id)
+                            if _\(raw: klass.name)_identityTable.contains(ptr) {
                                 _swift_js_push_i32(0)
                                 return ptr
                             }
                             _ = Unmanaged.passRetained(self)
-                            let id: Int32
-                            if let recycled = _\(raw: klass.name)_freeIds.popLast() {
-                                id = recycled
-                            } else {
-                                id = _\(raw: klass.name)_nextId
-                                _\(raw: klass.name)_nextId += 1
-                                _\(raw: klass.name)_wrapperRefs.append(0)
-                            }
-                            _\(raw: klass.name)_identityTable[ptr] = id
-                            _\(raw: klass.name)_idToPointer[id] = ptr
-                            _swift_js_push_i32(id)
+                            _\(raw: klass.name)_identityTable.insert(ptr)
                             _swift_js_push_i32(1)
                             return ptr
                         }

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -2060,42 +2060,37 @@ extension BridgeJSLink {
         dtsExportEntryPrinter.write("\(klass.name): {")
 
         if useSwiftIdentity {
-            // Spec §6.2: a `.swift`-mode class is STANDALONE — it does NOT extend
-            // `SwiftHeapObject`. It owns its own dense-array wrapper cache and lifetime
-            // (no `FinalizationRegistry`, no `WeakRef`). Swift holds wrappers strongly
-            // via `_<Class>_wrapperRefs`; JS clears the slot on `release()`.
+            // DECISIONS.md D18: the `.swift`-mode class is standalone — it does NOT
+            // extend `SwiftHeapObject`. It keeps a strong `Map<pointer, wrapper>` so
+            // re-exports of the same Swift pointer get the same JS wrapper. Swift
+            // signals "cache hit" via a single `freshBit` push on the i32 stack
+            // (0 = cached, 1 = fresh). No id indirection, no dense array.
             jsPrinter.write("class \(klass.name) {")
             jsPrinter.indent {
-                jsPrinter.write("static __swiftIdentityWrappers = [];")
+                jsPrinter.write("static __swiftIdentityWrappers = new Map();")
                 jsPrinter.nextLine()
                 jsPrinter.write("static __wrap(pointer) {")
                 jsPrinter.indent {
-                    // Swift pushes (id, freshBit) to the i32 stack AFTER returning the
-                    // pointer; JS pops LIFO — freshBit first, id second.
                     jsPrinter.write("const freshBit = bjs.swift_js_pop_i32();")
-                    jsPrinter.write("const id = bjs.swift_js_pop_i32();")
                     jsPrinter.write("if (freshBit === 0) {")
                     jsPrinter.indent {
-                        jsPrinter.write("return \(klass.name).__swiftIdentityWrappers[id];")
+                        jsPrinter.write("return \(klass.name).__swiftIdentityWrappers.get(pointer);")
                     }
                     jsPrinter.write("}")
                     jsPrinter.write("const obj = Object.create(\(klass.name).prototype);")
                     jsPrinter.write("obj.pointer = pointer;")
-                    jsPrinter.write("obj.__swiftIdentityId = id;")
                     jsPrinter.write("obj.__swiftIdentityHasReleased = false;")
-                    jsPrinter.write("\(klass.name).__swiftIdentityWrappers[id] = obj;")
+                    jsPrinter.write("\(klass.name).__swiftIdentityWrappers.set(pointer, obj);")
                     // Retain the wrapper in swift.memory so Swift can hold it strongly
-                    // via `_<Class>_wrapperRefs[id]` until release_wrapper fires.
+                    // via `_<Class>_wrapperRefs[pointer]` until release_wrapper fires.
                     jsPrinter.write("const jsRef = swift.memory.retain(obj);")
-                    jsPrinter.write("instance.exports.bjs_\(klass.abiName)_register_wrapper(id, jsRef);")
+                    jsPrinter.write("instance.exports.bjs_\(klass.abiName)_register_wrapper(pointer, jsRef);")
                     jsPrinter.write("return obj;")
                 }
                 jsPrinter.write("}")
                 jsPrinter.nextLine()
                 jsPrinter.write("static __construct(pointer) {")
                 jsPrinter.indent {
-                    // Swift's `_init` export pushed (id, freshBit) itself. `__wrap`
-                    // pops them and returns either the cached wrapper or a fresh one.
                     jsPrinter.write("return \(klass.name).__wrap(pointer);")
                 }
                 jsPrinter.write("}")
@@ -2104,11 +2099,11 @@ extension BridgeJSLink {
                 jsPrinter.indent {
                     jsPrinter.write("if (this.__swiftIdentityHasReleased) return;")
                     jsPrinter.write("this.__swiftIdentityHasReleased = true;")
-                    jsPrinter.write("const id = this.__swiftIdentityId;")
-                    jsPrinter.write("instance.exports.bjs_\(klass.abiName)_release_wrapper(id);")
-                    // Swift's release_wrapper already called `_swift_js_release_ref(jsRef)`,
-                    // so we just clear our JS-side slot so the id can be recycled.
-                    jsPrinter.write("\(klass.name).__swiftIdentityWrappers[id] = undefined;")
+                    jsPrinter.write("const pointer = this.pointer;")
+                    jsPrinter.write("instance.exports.bjs_\(klass.abiName)_release_wrapper(pointer);")
+                    // Swift's release_wrapper already released the JS ref; clear
+                    // the JS-side map entry.
+                    jsPrinter.write("\(klass.name).__swiftIdentityWrappers.delete(pointer);")
                 }
                 jsPrinter.write("}")
             }

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -1,12 +1,6 @@
-nonisolated(unsafe) var _SwiftCached_identityTable: [UnsafeMutableRawPointer: Int32] = [:]
+nonisolated(unsafe) var _SwiftCached_identityTable: Set<UnsafeMutableRawPointer> = []
 
-nonisolated(unsafe) var _SwiftCached_idToPointer: [Int32: UnsafeMutableRawPointer] = [:]
-
-nonisolated(unsafe) var _SwiftCached_wrapperRefs: [Int32] = []
-
-nonisolated(unsafe) var _SwiftCached_freeIds: [Int32] = []
-
-nonisolated(unsafe) var _SwiftCached_nextId: Int32 = 0
+nonisolated(unsafe) var _SwiftCached_wrapperRefs: [UnsafeMutableRawPointer: Int32] = [:]
 
 @_expose(wasm, "bjs_SwiftCached_init")
 @_cdecl("bjs_SwiftCached_init")
@@ -15,24 +9,13 @@ public func _bjs_SwiftCached_init(_ nameBytes: Int32, _ nameLength: Int32) -> Un
     let ret = SwiftCached(name: String.bridgeJSLiftParameter(nameBytes, nameLength))
     return withExtendedLifetime(ret) {
         let ptr = Unmanaged.passUnretained(ret).toOpaque()
-        if let id = _SwiftCached_identityTable[ptr] {
-            // Cache hit: do NOT retain. JS keeps the wrapper alive via _wrapperRefs[id].
-            _swift_js_push_i32(id)
+        if _SwiftCached_identityTable.contains(ptr) {
+            // Cache hit: do NOT retain. JS has the wrapper cached.
             _swift_js_push_i32(0)
             return ptr
         }
         _ = Unmanaged.passRetained(ret)
-        let id: Int32
-        if let recycled = _SwiftCached_freeIds.popLast() {
-            id = recycled
-        } else {
-            id = _SwiftCached_nextId
-            _SwiftCached_nextId += 1
-            _SwiftCached_wrapperRefs.append(0)
-        }
-        _SwiftCached_identityTable[ptr] = id
-        _SwiftCached_idToPointer[id] = ptr
-        _swift_js_push_i32(id)
+        _SwiftCached_identityTable.insert(ptr)
         _swift_js_push_i32(1)
         return ptr
     }
@@ -74,27 +57,21 @@ public func _bjs_SwiftCached_deinit(_ pointer: UnsafeMutableRawPointer) -> Void
 
 @_expose(wasm, "bjs_SwiftCached_register_wrapper")
 @_cdecl("bjs_SwiftCached_register_wrapper")
-public func _bjs_SwiftCached_register_wrapper(_ id: Int32, _ jsRef: Int32) -> Void {
+public func _bjs_SwiftCached_register_wrapper(_ pointer: UnsafeMutableRawPointer, _ jsRef: Int32) -> Void {
     #if arch(wasm32)
-    _SwiftCached_wrapperRefs[Int(id)] = jsRef
+    _SwiftCached_wrapperRefs[pointer] = jsRef
     #else
     fatalError("Only available on WebAssembly")
     #endif
 }
 
 @_expose(wasm, "bjs_SwiftCached_release_wrapper")
 @_cdecl("bjs_SwiftCached_release_wrapper")
-public func _bjs_SwiftCached_release_wrapper(_ id: Int32) -> Void {
+public func _bjs_SwiftCached_release_wrapper(_ pointer: UnsafeMutableRawPointer) -> Void {
     #if arch(wasm32)
-    let slot = Int(id)
-    let jsRef = _SwiftCached_wrapperRefs[slot]
-    guard jsRef != 0 else { return }
-    _SwiftCached_wrapperRefs[slot] = 0
-    if let ptr = _SwiftCached_idToPointer.removeValue(forKey: id) {
-        _SwiftCached_identityTable.removeValue(forKey: ptr)
-        Unmanaged<SwiftCached>.fromOpaque(ptr).release()
-    }
-    _SwiftCached_freeIds.append(id)
+    guard let jsRef = _SwiftCached_wrapperRefs.removeValue(forKey: pointer) else { return }
+    _SwiftCached_identityTable.remove(pointer)
+    Unmanaged<SwiftCached>.fromOpaque(pointer).release()
     _swift_js_release_ref(jsRef)
     #else
     fatalError("Only available on WebAssembly")
@@ -105,23 +82,12 @@ extension SwiftCached {
     @_spi(BridgeJS) public consuming func bridgeJSStackPush() {
         let ptr: UnsafeMutableRawPointer = withExtendedLifetime(self) {
             let ptr = Unmanaged.passUnretained(self).toOpaque()
-            if let id = _SwiftCached_identityTable[ptr] {
-                _swift_js_push_i32(id)
+            if _SwiftCached_identityTable.contains(ptr) {
                 _swift_js_push_i32(0)
                 return ptr
             }
             _ = Unmanaged.passRetained(self)
-            let id: Int32
-            if let recycled = _SwiftCached_freeIds.popLast() {
-                id = recycled
-            } else {
-                id = _SwiftCached_nextId
-                _SwiftCached_nextId += 1
-                _SwiftCached_wrapperRefs.append(0)
-            }
-            _SwiftCached_identityTable[ptr] = id
-            _SwiftCached_idToPointer[id] = ptr
-            _swift_js_push_i32(id)
+            _SwiftCached_identityTable.insert(ptr)
             _swift_js_push_i32(1)
             return ptr
         }