diff --git a/.github/wasm-prelude.js b/.github/wasm-prelude.js
new file mode 100644
index 0000000..513fc87
--- /dev/null
+++ b/.github/wasm-prelude.js
@@ -0,0 +1,11 @@
+// Prelude for running BSWFoundation's test suite on WebAssembly under Node
+// (`swift package --swift-sdk … js test --prelude .github/wasm-prelude.js`).
+//
+// Node provides `fetch` but not `localStorage` (a browser API), so we shim it in memory
+// for the storage tests (KeychainBacked / UserDefaultsBacked → WASMKeyValueStore).
+const store = new Map()
+globalThis.localStorage = {
+    getItem: (key) => (store.has(key) ? store.get(key) : null),
+    setItem: (key, value) => { store.set(key, String(value)) },
+    removeItem: (key) => { store.delete(key) },
+}
diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml
index cf5431b..6fa41f1 100644
--- a/.github/workflows/swift.yml
+++ b/.github/workflows/swift.yml
@@ -59,3 +59,27 @@ jobs:
           fi
       - name: Run tests on Android
         run: SKIP_ENABLED=1 skip android test
+
+  wasm-build:
+    # GitHub-hosted: the self-hosted `mobile` runners don't have the WebAssembly Swift SDK.
+    # The official Swift image provides the toolchain; we then install the matching wasm SDK,
+    # compile the package for WebAssembly, and run the (wasm-eligible) unit tests in Node.
+    runs-on: ubuntu-latest
+    container: swift:6.3.3
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Swift SDK for WebAssembly
+        run: |
+          swift sdk install \
+            https://download.swift.org/swift-6.3.3-release/wasm-sdk/swift-6.3.3-RELEASE/swift-6.3.3-RELEASE_wasm.artifactbundle.tar.gz \
+            --checksum cabfa08b73bb8ac783927ecd15fa386e99d0c139c5f232445067bcf58379cae7
+      - name: Build for WebAssembly
+        run: swift build --swift-sdk swift-6.3.3-RELEASE_wasm
+      - name: Install Node.js (for the wasm test runner)
+        run: apt-get update && apt-get install -y nodejs npm
+      - name: Install the WASI shim
+        run: npm install @bjorn3/browser_wasi_shim@0.3.0
+      - name: Run unit tests on WebAssembly (Node)
+        run: |
+          swift package --swift-sdk swift-6.3.3-RELEASE_wasm --disable-sandbox \
+            js test --prelude .github/wasm-prelude.js
diff --git a/Docs/context/platform-support.md b/Docs/context/platform-support.md
index 439c684..bc3257c 100644
--- a/Docs/context/platform-support.md
+++ b/Docs/context/platform-support.md
@@ -1,6 +1,6 @@
 # Platform Support
 
-`BSWFoundation` is Apple-first and has an explicit Skip/Android path for the subset that can run without Apple-only frameworks.
+`BSWFoundation` is Apple-first and has explicit Android and browser WebAssembly paths for the subset that can run without Apple-only frameworks.
 
 ## Apple Platforms
 
@@ -26,8 +26,34 @@ When `SKIP_ENABLED` is present, the package adds Skip dependencies and Android-s
 - `FoundationInternationalization`
 - Android logging and platform APIs where needed.
 
-The README states that all features except `AuthStorage` and `LocationFetcher` are intended to be available on Android. `KeychainBacked` uses `SkipKeychain` on Android when Skip dependencies are enabled. The JWT helpers currently live under the `AuthStorage.swift` Darwin guard, so their intended Android availability should be clarified before relying on them from Skip code.
+The README states that all features except `AuthStorage` and `LocationFetcher` are intended to be available on Android. Some Android storage APIs require Skip-only modules: `KeychainBacked` and `CodableKeychainBacked` require `SkipKeychain`; `UserDefaultsBacked` and `CodableUserDefaultsBacked` require the Skip user defaults bridge. Build with `SKIP_ENABLED=1` so SwiftPM includes these dependencies. Without those modules, the wrappers remain present but unavailable with a targeted compiler diagnostic.
+
+The JWT helpers currently live under the `AuthStorage.swift` Darwin guard, so their intended Android availability should be clarified before relying on them from Skip code.
+
+## Browser WebAssembly Via SwiftWasm
+
+The package compiles for WASI browser-hosted SwiftWasm. WASM dependencies are conditioned in `Package.swift`:
+
+- `JavaScriptKit`
+- `JavaScriptEventLoop`
+- `JavaScriptFoundationCompat`
+- `swift-log`
+
+Browser networking is handled by the WASI-only fetch implementation. `APIClient` defaults to the browser fetch-backed network fetcher on WASM and keeps the URLSession-backed default on platforms where URLSession is available. Browser fetch follows browser security rules for TLS, CORS and mixed content; `Environment.shouldAllowInsecureConnections` is not emulated in the browser.
+
+WASM consumers must install the JavaScriptKit event-loop executor once during host startup by calling `BSWBrowserRuntime.installJavaScriptEventLoop()` before creating an `APIClient` or starting async work that depends on JavaScript callbacks.
+
+Persistence support on WASM is intentionally narrow:
+
+- `UserDefaultsBacked` uses an internal browser `localStorage` adapter and supports only the value types documented in README. Use `CodableUserDefaultsBacked` for codable values.
+
+Current WASM exclusions and limitations:
+
+- `AuthStorage` and `LocationFetcher` are unavailable.
+- `KeychainBacked` and `CodableKeychainBacked` are unavailable because browsers do not expose Keychain-equivalent secure storage to SwiftWasm.
+- URL file uploads are unavailable; browser upload support must use the WASM browser upload body API.
+- APIs that require Apple-only frameworks or URLSession delegates remain guarded out of WASI.
 
 ## Compatibility Rule
 
-New shared APIs should compile on all declared Apple platforms unless intentionally guarded. New APIs meant to be available on Android should avoid Darwin-only dependencies or provide Android-specific branches.
+New shared APIs should compile on all declared Apple platforms unless intentionally guarded. New APIs meant to be available on Android or WASM should avoid Darwin-only dependencies or provide platform-specific branches. Public APIs that are intentionally unavailable on Android or WASM should fail clearly at compile time or with a targeted runtime diagnostic.
diff --git a/Docs/features/persistence.md b/Docs/features/persistence.md
index f40a74a..0e3da12 100644
--- a/Docs/features/persistence.md
+++ b/Docs/features/persistence.md
@@ -29,13 +29,13 @@ The same source file includes JWT decoding helpers derived from Auth0's JWT deco
 
 ## KeychainBacked
 
-`KeychainBacked` stores optional strings in Keychain. It supports Darwin through `KeychainAccess` and Android through `SkipKeychain`; Linux is excluded.
+`KeychainBacked` stores optional strings in Keychain. It supports Darwin through `KeychainAccess` and Android through `SkipKeychain`; Linux and WebAssembly are excluded. Android consumers must build with `SKIP_ENABLED=1` so SwiftPM includes `SkipKeychain`.
 
-`CodableKeychainBacked` stores optional `Codable` values by encoding them before persistence and decoding them on read.
+`CodableKeychainBacked` stores optional `Codable` values by encoding them before persistence and decoding them on read. It is also unavailable on WebAssembly because browsers do not expose Keychain-equivalent secure storage to SwiftWasm.
 
 ## UserDefaultsBacked
 
-`UserDefaultsBacked` stores optional primitive values in user defaults. Darwin can use standard defaults or an app group suite. The Android path currently supports a narrower set of value types.
+`UserDefaultsBacked` stores optional primitive values in user defaults. Darwin can use standard defaults or an app group suite. The Android path requires Skip's user defaults bridge, which is included when building with `SKIP_ENABLED=1`, and currently supports a narrower set of value types.
 
 `CodableUserDefaultsBacked` stores optional `Codable` values by encoding them into user defaults.
 
diff --git a/Package.resolved b/Package.resolved
index d684186..5a9db5a 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -1,6 +1,15 @@
 {
-  "originHash" : "853b5e05ad3a6efd70b566d40499cfe0ffe0bf6b722d3a464a158a209c5edcb0",
+  "originHash" : "a0588d2d225b95fd6407c40311d363ba7ecd9b60e74db69c8c03e5e288155693",
   "pins" : [
+    {
+      "identity" : "javascriptkit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftwasm/JavaScriptKit.git",
+      "state" : {
+        "revision" : "22905075f8b61834810babe5fb9a2f613f22f398",
+        "version" : "0.56.1"
+      }
+    },
     {
       "identity" : "keychainaccess",
       "kind" : "remoteSourceControl",
@@ -10,6 +19,15 @@
         "version" : "4.2.2"
       }
     },
+    {
+      "identity" : "swift-android-native",
+      "kind" : "remoteSourceControl",
+      "location" : "https://source.skip.tools/swift-android-native.git",
+      "state" : {
+        "revision" : "7e6e833e6f163a2b75340f75c70b1d96ea6b8135",
+        "version" : "1.5.1"
+      }
+    },
     {
       "identity" : "swift-asn1",
       "kind" : "remoteSourceControl",
@@ -36,6 +54,33 @@
         "revision" : "db774a277f60063a32d854f2980299caf06da041",
         "version" : "1.6.0"
       }
+    },
+    {
+      "identity" : "swift-jni",
+      "kind" : "remoteSourceControl",
+      "location" : "https://source.skip.tools/swift-jni.git",
+      "state" : {
+        "revision" : "fe76ac21aca639976833b5ea3e875dc072519ac4",
+        "version" : "0.5.0"
+      }
+    },
+    {
+      "identity" : "swift-log",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-log.git",
+      "state" : {
+        "revision" : "a878e7f8f46cfc0e1125e565b5c08e7d5272dc9a",
+        "version" : "1.14.0"
+      }
+    },
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftlang/swift-syntax",
+      "state" : {
+        "revision" : "79e4b74a295b6eb74a8b585e3a39d29e70c1dbd1",
+        "version" : "603.0.2"
+      }
     }
   ],
   "version" : 3
diff --git a/Package.swift b/Package.swift
index 5b8d30b..85468ac 100644
--- a/Package.swift
+++ b/Package.swift
@@ -17,10 +17,31 @@ let applePlatforms = TargetDependencyCondition.when(
     ]
 )
 
+let androidPlatforms = TargetDependencyCondition.when(platforms: [.android])
+
+// Platforms where URLSession / FoundationNetworking exist. Excludes WASM (WASI), where
+// HTTPTypesFoundation's URLSession bridge does not compile.
+let foundationNetworkingPlatforms = TargetDependencyCondition.when(
+    platforms: [
+        .iOS,
+        .macOS,
+        .macCatalyst,
+        .tvOS,
+        .watchOS,
+        .visionOS,
+        .linux,
+        .android,
+        .windows
+    ]
+)
+
 var packageDependencies: [Package.Dependency] = [
     .package(url: "https://github.com/kishikawakatsumi/KeychainAccess.git", from: "4.2.2"),
     .package(url: "https://github.com/apple/swift-crypto.git", from: "3.12.3"),
     .package(url: "https://github.com/apple/swift-http-types.git", from: "1.6.0"),
+    .package(url: "https://github.com/swiftwasm/JavaScriptKit.git", from: "0.56.1"),
+    .package(url: "https://github.com/apple/swift-log.git", from: "1.5.0"),
+    .package(url: "https://source.skip.tools/swift-android-native.git", from: "1.4.1"),
 ]
 
 if skipIsEnabled {
@@ -33,11 +54,13 @@ if skipIsEnabled {
 var targetDependencies: [Target.Dependency] = [
     .product(name: "Crypto", package: "swift-crypto"),
     .product(name: "KeychainAccess", package: "KeychainAccess", condition: applePlatforms),
-    // `HTTPTypes` is pure Swift (no Foundation) and links on every platform, including WASM.
     .product(name: "HTTPTypes", package: "swift-http-types"),
-    // `HTTPTypesFoundation` bridges to URLSession/URLRequest. Its API compiles to nothing on
-    // WASI, so linking it everywhere is harmless; we only `import` it from the URLSession fetcher.
-    .product(name: "HTTPTypesFoundation", package: "swift-http-types"),
+    .product(name: "HTTPTypesFoundation", package: "swift-http-types", condition: foundationNetworkingPlatforms),
+    .product(name: "JavaScriptKit", package: "JavaScriptKit", condition: .when(platforms: [.wasi])),
+    .product(name: "JavaScriptEventLoop", package: "JavaScriptKit", condition: .when(platforms: [.wasi])),
+    .product(name: "JavaScriptFoundationCompat", package: "JavaScriptKit", condition: .when(platforms: [.wasi])),
+    .product(name: "Logging", package: "swift-log", condition: .when(platforms: [.wasi])),
+    .product(name: "AndroidLogging", package: "swift-android-native", condition: androidPlatforms),
 ]
 
 if skipIsEnabled {
@@ -70,7 +93,13 @@ let package = Package(
         ),
         .testTarget(
             name: "BSWFoundationTests",
-            dependencies: ["BSWFoundation"]
+            dependencies: [
+                "BSWFoundation",
+                // On wasm, linking this activates the JavaScriptKit event-loop executor for the
+                // test bundle, so async tests (Task.sleep, etc.) run instead of hitting an
+                // unsupported WASI async-io syscall.
+                .product(name: "JavaScriptEventLoopTestSupport", package: "JavaScriptKit", condition: .when(platforms: [.wasi])),
+            ]
         ),
     ],
     swiftLanguageModes: [.v6],
diff --git a/README.md b/README.md
index e5255f0..15b58fa 100644
--- a/README.md
+++ b/README.md
@@ -17,4 +17,150 @@ Please checkout [the documentation](https://swiftpackageindex.com/theleftbit/BSW
 
 Android support is in an ongoing effort, and it's' built on top of the [Skip Native toolchain](https://skip.tools/docs/native/). All features of this package except for `AuthStorage` and `LocationFetcher` are available and ready to use. 
 
+Some Android storage APIs require Skip-only dependencies. Build with `SKIP_ENABLED=1` so SwiftPM includes those packages before using `KeychainBacked`, `CodableKeychainBacked`, `UserDefaultsBacked`, or `CodableUserDefaultsBacked` on Android.
+
 If you find any issue, please report it using GitHub.
+
+## WebAssembly / Browser Support
+
+BSWFoundation compiles for WebAssembly and runs in the browser via [SwiftWasm](https://swiftwasm.org) and [JavaScriptKit](https://github.com/swiftwasm/JavaScriptKit). Networking goes through the browser's `fetch` API (`FetchNetworkFetcher`, used automatically as the default fetcher on wasm), and `UserDefaultsBacked` uses browser `localStorage` for non-sensitive values. As on Android, `AuthStorage` and `LocationFetcher` are excluded.
+
+> ⚠️ `KeychainBacked` and `CodableKeychainBacked` are unavailable on WebAssembly. Browsers do not expose Keychain-equivalent secure storage to SwiftWasm; use host-managed auth instead.
+
+### Building a browser app
+
+To build a browser app on top of BSWFoundation, add JavaScriptKit's event-loop products to your executable target — wasi-conditioned, so your Apple/Android builds are unaffected:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/theleftbit/BSWFoundation.git", from: "..."),
+    .package(url: "https://github.com/swiftwasm/JavaScriptKit.git", from: "0.56.1"),
+],
+targets: [
+    .executableTarget(
+        name: "MyWebApp",
+        dependencies: [
+            .product(name: "BSWFoundation", package: "BSWFoundation"),
+            .product(name: "JavaScriptKit", package: "JavaScriptKit", condition: .when(platforms: [.wasi])),
+            .product(name: "JavaScriptEventLoop", package: "JavaScriptKit", condition: .when(platforms: [.wasi])),
+        ]
+    )
+]
+```
+
+Install the JavaScriptKit global executor through BSWFoundation **once, before creating `APIClient` or spawning async work**. In a browser app hosted by JavaScript, do this from the Swift bootstrap function that your JS entrypoint calls before invoking any other Swift API:
+
+```swift
+import BSWFoundation
+
+@_cdecl("bsw_bootstrap")
+public func bsw_bootstrap() {
+    BSWBrowserRuntime.installJavaScriptEventLoop()
+}
+```
+
+```js
+wasm.instance.exports.bsw_bootstrap();
+// Now call exported Swift APIs that create APIClient, use storage, or spawn async work.
+```
+
+Bundle it with the [PackageToJS](https://github.com/swiftwasm/JavaScriptKit) plugin JavaScriptKit ships, then serve the output folder over HTTP:
+
+```sh
+swift package --swift-sdk swift-6.3.3-RELEASE_wasm --disable-sandbox \
+  js --use-cdn -c release --product MyWebApp --output Public
+npx serve Public
+```
+
+(`--use-cdn` resolves the `@bjorn3/browser_wasi_shim` runtime dependency from a CDN; drop it and `npm install` instead if you bundle with a package manager. See [Production builds & binary size](#production-builds--binary-size) below for shrinking the `.wasm`.)
+
+> ⚠️ `UserDefaultsBacked<T>` on wasm only supports `Bool` and `String`. For any other type — `Int`, `Date`, your own `Codable` — use **`CodableUserDefaultsBacked`**, which JSON-encodes the value and behaves identically on every platform.
+
+### Reusing a Swift `ViewModel` from React (or any JS framework)
+
+You don't have to render the DOM from Swift. A common pattern is to keep your `@Observable` model and business logic in Swift and let a JS framework own the view, via a thin "bridge" executable target that:
+
+1. builds the `ViewModel` (which uses `APIClient`, storage, etc.),
+2. pushes its state to JavaScript through `globalThis` callbacks whenever it changes (drive updates with `Observable.stream(for:)`),
+3. exposes its actions back on `globalThis` (e.g. a `bump()` method).
+
+The JS side registers the callbacks, renders from the pushed state, and calls the exposed actions — it never re-implements any logic:
+
+```swift
+// The front-end sets these on globalThis before the module boots:
+//   __swiftDemoUpdate(state)   — called with a plain JS object on every change
+//   __onSwiftDemoReady(api)    — called once when ready; `api.bump()` drives the model
+guard let update = JSObject.global.__swiftDemoUpdate.function else { return }
+let state = JSObject.global.Object.function!.new()
+state.counter = .number(Double(viewModel.counter))
+_ = update(state.jsValue)
+```
+
+**Bundler note (Vite):** the generated `.wasm` + loader are static assets. Put the bundle in `public/` and boot it from a tiny `<script type="module">`, rather than `import()`-ing it from your React source — Vite's dev server otherwise tries to transform the `/public` file and fails. A one-line `public/boot-swift.js` (`import { init } from "/swift/index.js"; init()`) referenced from `index.html` sidesteps this.
+
+A complete worked example — the same `ViewModel` powering a SwiftUI app *and* a React website — lives in the **BSWDemo** sample (its `DemoCore` / `DemoBridge` targets plus a Vite + React app).
+
+### Running the test harness
+
+[`WASMHarness/`](WASMHarness) is a small executable that exercises the wasm paths at runtime — a real `fetch` GET decoded by `JSONParser`, plus a `localStorage` round-trip through `UserDefaultsBacked`.
+
+1. **Install the WebAssembly Swift SDK** (once). The version must match your Swift toolchain — check `swift --version` and see [swift.org's WebAssembly guide](https://www.swift.org/documentation/articles/wasm-getting-started.html) for the current URL/checksum:
+
+   ```sh
+   swift sdk install \
+     https://download.swift.org/swift-6.3.3-release/wasm-sdk/swift-6.3.3-RELEASE/swift-6.3.3-RELEASE_wasm.artifactbundle.tar.gz \
+     --checksum cabfa08b73bb8ac783927ecd15fa386e99d0c139c5f232445067bcf58379cae7
+   ```
+
+2. **Build** the harness bundle (use the SDK id printed by `swift sdk list`):
+
+   ```sh
+   swift package --package-path WASMHarness --swift-sdk swift-6.3.3-RELEASE_wasm --disable-sandbox js
+   ```
+
+3. **Run in Node** — Node provides `fetch`; `main.mjs` shims `localStorage`, which Node lacks:
+
+   ```sh
+   npm install --prefix WASMHarness   # installs @bjorn3/browser_wasi_shim
+   node WASMHarness/main.mjs
+   ```
+
+   Expected output:
+
+   ```
+   ✅ fetch GET https://httpbingo.org/ip → origin = …
+   ✅ UserDefaultsBacked localStorage round-trip → 'hello-from-wasm'
+   ```
+
+4. **Run in a browser** — `fetch` and `localStorage` are both native there. Serve the folder over HTTP (wasm can't load from `file://`) and open `index.html`:
+
+   ```sh
+   npx serve WASMHarness   # then open the printed URL + /index.html and check the devtools console
+   ```
+
+### Production builds & binary size
+
+A **debug** wasm build is very large (~76 MB) — never ship it. For deployment, build in
+**release** *and* make sure [Binaryen](https://github.com/WebAssembly/binaryen)'s `wasm-opt` is on
+`PATH` before building, so the PackageToJS plugin runs its size-optimization pass. What the browser
+actually downloads is the compressed (`Content-Encoding: br`/`gzip`) file, which is far smaller.
+
+Reference sizes for the `WASMHarness` bundle (which links all of BSWFoundation + Foundation):
+
+| Build | raw | gzip | brotli (served) |
+|---|---|---|---|
+| debug | ~76 MB | — | — |
+| release, no `wasm-opt` | ~71 MB | ~23 MB | — |
+| **release + `wasm-opt`** | **~45 MB** | ~18 MB | **~12 MB** |
+
+```sh
+brew install binaryen   # or your platform's package providing `wasm-opt`
+swift package --package-path WASMHarness --swift-sdk swift-6.3.3-RELEASE_wasm --disable-sandbox js -c release
+```
+
+Then serve the `.wasm` with brotli or gzip enabled (browsers stream-compile it). Most of the
+remaining size is the Swift runtime + Foundation — an inherent baseline for Swift-with-Foundation
+in the browser. To go further, a production build can also strip reflection metadata
+(`-Xswiftc -disable-reflection-metadata`), at the cost of `Mirror`/runtime reflection.
+
+The whole package also has a wasm compile gate in CI (plus the unit tests run on wasm in Node), and builds are verified on Apple, Android, and WebAssembly.
diff --git a/Sources/BSWFoundation/APIClient/APIClient+FetchFetcher.swift b/Sources/BSWFoundation/APIClient/APIClient+FetchFetcher.swift
new file mode 100644
index 0000000..3728956
--- /dev/null
+++ b/Sources/BSWFoundation/APIClient/APIClient+FetchFetcher.swift
@@ -0,0 +1,110 @@
+//
+//  Browser networking for BSWFoundation on WebAssembly.
+//
+
+#if os(WASI)
+
+import Foundation
+import HTTPTypes
+import JavaScriptKit
+import JavaScriptFoundationCompat
+
+
+// MARK: Platforms without URLSession (e.g. WASM)
+
+extension APIClient {
+    
+    static func makeDefaultNetworkFetcher(environment: Environment) -> APIClientNetworkFetcher {
+        return FetchNetworkFetcher()
+    }
+}
+
+/// An ``APIClientNetworkFetcher`` backed by the browser's `fetch` API via JavaScriptKit.
+///
+/// This is the default fetcher on WebAssembly, where `URLSession` is unavailable.
+///
+/// - Important: The host application must call
+///   ``BSWBrowserRuntime/installJavaScriptEventLoop()`` once at startup, before creating this
+///   fetcher or spawning async work.
+private struct FetchNetworkFetcher: APIClientNetworkFetcher {
+    
+    init() {
+        guard BSWBrowserRuntime.isJavaScriptEventLoopInstalled else {
+            fatalError("BSWFoundation: call BSWBrowserRuntime.installJavaScriptEventLoop() once at startup before creating APIClient or FetchNetworkFetcher.")
+        }
+    }
+    
+    public func perform(_ request: APIClient.OutboundRequest) async throws -> APIClient.Response {
+        // Uploading a file by path is meaningless in the browser sandbox.
+        guard request.fileToUpload == nil else {
+            throw APIClient.Error.encodingRequestFailed
+        }
+        guard let url = request.httpRequest.url else {
+            throw APIClient.Error.malformedURL
+        }
+        guard let fetch = JSObject.global.fetch.object else {
+            throw APIClient.Error.malformedResponse
+        }
+        
+        // Build the `fetch` options object: { method, headers, body }.
+        let options = JSObject()
+        options["method"] = .string(request.httpRequest.method.rawValue)
+        
+        let headers = JSObject()
+        for field in request.httpRequest.headerFields {
+            headers[field.name.rawName] = .string(field.value)
+        }
+        options["headers"] = headers.jsValue
+        
+        if let body = request.body {
+            options["body"] = body.jsValue // Data -> Uint8Array (JavaScriptFoundationCompat)
+        }
+        
+        // fetch(url, options) -> Promise<Response>
+        let responseValue = try await awaitPromise(fetch(url.absoluteString, options))
+        guard let response = responseValue.object else {
+            throw APIClient.Error.malformedResponse
+        }
+        
+        let statusCode = Int(response.status.number ?? 0)
+        
+        // response.arrayBuffer() -> Promise<ArrayBuffer>; wrap in Uint8Array and copy to Data.
+        let arrayBuffer = try await awaitPromise(response.arrayBuffer!())
+        let bytes = JSObject.global.Uint8Array.function!.new(arrayBuffer)
+        let data = Data.construct(from: bytes.jsValue) ?? Data()
+        
+        let httpResponse = HTTPResponse(
+            status: .init(code: statusCode),
+            headerFields: Self.headerFields(from: response)
+        )
+        return APIClient.Response(data: data, httpResponse: httpResponse)
+    }
+    
+    /// Awaits a `JSValue` that is expected to wrap a JavaScript `Promise`.
+    private func awaitPromise(_ value: JSValue) async throws -> JSValue {
+        guard let object = value.object else {
+            throw APIClient.Error.malformedResponse
+        }
+        return try await JSPromise(unsafelyWrapping: object).value
+    }
+    
+    /// Reads a JS `Response.headers` (`Headers` object) into `HTTPFields`.
+    /// `Array.from(headers)` yields `[[name, value], …]`, which we walk by index.
+    private static func headerFields(from response: JSObject) -> HTTPFields {
+        var fields = HTTPFields()
+        guard let arrayConstructor = JSObject.global.Array.object,
+              let entries = arrayConstructor.from!(response.headers).object else {
+            return fields
+        }
+        let count = Int(entries.length.number ?? 0)
+        for index in 0..<count {
+            guard let pair = entries[index].object,
+                  let name = pair[0].string,
+                  let value = pair[1].string,
+                  let fieldName = HTTPField.Name(name) else { continue }
+            fields[fieldName] = value
+        }
+        return fields
+    }
+}
+#endif
diff --git a/Sources/BSWFoundation/APIClient/APIClient+Logging.swift b/Sources/BSWFoundation/APIClient/APIClient+Logging.swift
index 9f6fe2d..55ef0c4 100644
--- a/Sources/BSWFoundation/APIClient/APIClient+Logging.swift
+++ b/Sources/BSWFoundation/APIClient/APIClient+Logging.swift
@@ -1,10 +1,5 @@
 import Foundation
 import HTTPTypes
-#if os(Android)
-import AndroidLogging
-#else
-import OSLog
-#endif
 
 //MARK: Logging
 
@@ -14,7 +9,7 @@ extension APIClient {
         guard loggingConfiguration.requestBehaviour == .all else {
             return
         }
-        let logger = Logger(subsystem: submoduleName("APIClient"), category: "APIClient.Request")
+        let logger = BSWLogger(subsystem: submoduleName("APIClient"), category: "APIClient.Request")
         let httpMethod = request.httpRequest.method.rawValue
         let path = request.httpRequest.path ?? ""
         logger.debug("Sending Request → \(httpMethod) \(path)")
@@ -24,7 +19,7 @@ extension APIClient {
     }
 
     func logResponse(_ response: Response, forPath path: String) {
-        let logger = Logger(subsystem: submoduleName("APIClient"), category: "APIClient.Response")
+        let logger = BSWLogger(subsystem: submoduleName("APIClient"), category: "APIClient.Response")
         let statusCode = response.statusCode
         let isError = !(200..<300).contains(statusCode)
         let shouldLogThis: Bool = {
@@ -38,7 +33,7 @@ extension APIClient {
             }
         }()
         guard shouldLogThis else { return }
-        let logType: OSLogType = isError ? .error : .debug
+        let logType: BSWLogger.Level = isError ? .error : .debug
         logger.log(level: logType, "Receiving Response → Path: \(path) HTTPStatusCode: \(statusCode) ")
         if isError, let errorString = String(data: response.data, encoding: .utf8), !errorString.isEmpty {
             logger.log(level: logType, "Error Message: \(errorString)")
@@ -49,7 +44,7 @@ extension APIClient {
         guard loggingConfiguration.responseBehaviour != .none else {
             return
         }
-        let logger = Logger(subsystem: submoduleName("APIClient"), category: "APIClient.Network")
+        let logger = BSWLogger(subsystem: submoduleName("APIClient"), category: "APIClient.Network")
         let httpMethod = request.httpRequest.method.rawValue
         let path = request.httpRequest.path ?? ""
         logger.error("Error Received for Request → \(httpMethod) \(path). Error: \(networkError)")
diff --git a/Sources/BSWFoundation/APIClient/APIClient+URLSession.swift b/Sources/BSWFoundation/APIClient/APIClient+URLSession.swift
index 2cacf2f..bbe9f0f 100644
--- a/Sources/BSWFoundation/APIClient/APIClient+URLSession.swift
+++ b/Sources/BSWFoundation/APIClient/APIClient+URLSession.swift
@@ -50,7 +50,6 @@ extension APIClient {
 
 //MARK: OutboundRequest bridging
 
-#if canImport(FoundationNetworking) || canImport(Darwin)
 extension APIClient.OutboundRequest {
     var urlRequest: URLRequest? {
         guard var urlRequest = URLRequest(httpRequest: self.httpRequest) else { return nil }
@@ -61,7 +60,6 @@ extension APIClient.OutboundRequest {
         return urlRequest
     }
 }
-#endif
 
 //MARK: APIClientNetworkFetcher
 
@@ -148,17 +146,5 @@ private extension APIClient {
 }
 #endif
 
-#else
-
-// MARK: Platforms without URLSession (e.g. WASM)
-
-extension APIClient {
-
-    /// No `URLSession` is available on this platform, so an `APIClientNetworkFetcher` must be
-    /// supplied explicitly to `APIClient(environment:networkFetcher:)`.
-    static func makeDefaultNetworkFetcher(environment: Environment) -> APIClientNetworkFetcher {
-        fatalError("BSWFoundation: no default APIClientNetworkFetcher is available on this platform. Pass one explicitly to APIClient(environment:networkFetcher:).")
-    }
-}
 
 #endif
diff --git a/Sources/BSWFoundation/Browser/BSWBrowserRuntime.swift b/Sources/BSWFoundation/Browser/BSWBrowserRuntime.swift
new file mode 100644
index 0000000..a8c4264
--- /dev/null
+++ b/Sources/BSWFoundation/Browser/BSWBrowserRuntime.swift
@@ -0,0 +1,26 @@
+//
+//  Browser support for WebAssembly hosts.
+//
+
+#if os(WASI)
+import JavaScriptEventLoop
+
+/// Browser-hosted WebAssembly setup helpers.
+public enum BSWBrowserRuntime {
+
+    nonisolated(unsafe) private static var didInstallJavaScriptEventLoop = false
+
+    static var isJavaScriptEventLoopInstalled: Bool {
+        didInstallJavaScriptEventLoop
+    }
+
+    /// Installs JavaScriptKit's event-loop executor.
+    ///
+    /// Browser WebAssembly applications must call this once at startup before creating
+    /// ``APIClient`` or spawning async work.
+    public static func installJavaScriptEventLoop() {
+        JavaScriptEventLoop.installGlobalExecutor()
+        didInstallJavaScriptEventLoop = true
+    }
+}
+#endif
diff --git a/Sources/BSWFoundation/Extensions/BSWLogger.swift b/Sources/BSWFoundation/Extensions/BSWLogger.swift
new file mode 100644
index 0000000..960f44c
--- /dev/null
+++ b/Sources/BSWFoundation/Extensions/BSWLogger.swift
@@ -0,0 +1,126 @@
+//
+//  A small, unified logging facade for BSWFoundation and its consumers.
+//
+
+#if canImport(OSLog)
+import OSLog
+#elseif os(Android)
+import AndroidLogging
+#elseif os(WASI)
+import Logging
+#else
+#error("BSWLogger is only available on Apple platforms, Android, and WASI")
+#endif
+
+/// A lightweight, cross-platform logging facade used throughout BSWFoundation.
+///
+/// It forwards to the platform's native logging backend, so output lands where you expect:
+/// - **Apple** platforms: `OSLog` (the unified logging system / Console.app)
+/// - **Android**: `AndroidLogging` (logcat)
+/// - **WebAssembly**: `swift-log` (its installed `LogHandler`, e.g. the browser console)
+///
+/// The API intentionally mirrors `OSLog.Logger` (`init(subsystem:category:)`), so it is a drop-in
+/// across the ecosystem and gives every app built on BSWFoundation a single, consistent logger.
+public struct BSWLogger: Sendable {
+
+    /// The severity of a log message.
+    public enum Level: Sendable {
+        case debug, info, warning, error
+    }
+
+    private let backing: Logger
+
+    /// Creates a logger for the given subsystem and category.
+    public init(subsystem: String, category: String) {
+        #if canImport(OSLog) || os(Android)
+        self.backing = Logger(subsystem: subsystem, category: category)
+        #elseif os(WASI)
+        self.backing = Logger(label: "\(subsystem).\(category)")
+        #endif
+    }
+
+    public func debug(
+        _ message: @autoclosure () -> String,
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
+    ) {
+        log(level: .debug, message(), file: file, function: function, line: line)
+    }
+
+    public func info(
+        _ message: @autoclosure () -> String,
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
+    ) {
+        log(level: .info, message(), file: file, function: function, line: line)
+    }
+
+    public func warning(
+        _ message: @autoclosure () -> String,
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
+    ) {
+        log(level: .warning, message(), file: file, function: function, line: line)
+    }
+
+    public func error(
+        _ message: @autoclosure () -> String,
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
+    ) {
+        log(level: .error, message(), file: file, function: function, line: line)
+    }
+
+    public func log(
+        level: Level,
+        _ message: @autoclosure () -> String,
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
+    ) {
+        let text = message()
+        #if canImport(OSLog) || os(Android)
+        backing.log(level: level.osLogType, "\(formatMessage(text, file: file, function: function, line: line))")
+        #elseif os(WASI)
+        backing.log(
+            level: level.loggingLevel,
+            "\(text)",
+            file: file,
+            function: function,
+            line: line
+        )
+        #endif
+    }
+
+    private func formatMessage(_ message: String, file: String, function: String, line: UInt) -> String {
+        "[\(file):\(line) \(function)] \(message)"
+    }
+}
+
+#if canImport(OSLog) || os(Android)
+private extension BSWLogger.Level {
+    var osLogType: OSLogType {
+        switch self {
+        case .debug: return .debug
+        case .info: return .info
+        case .warning: return .default
+        case .error: return .error
+        }
+    }
+}
+#elseif os(WASI)
+private extension BSWLogger.Level {
+    var loggingLevel: Logging.Logger.Level {
+        switch self {
+        case .debug: return .debug
+        case .info: return .info
+        case .warning: return .warning
+        case .error: return .error
+        }
+    }
+}
+#endif
diff --git a/Sources/BSWFoundation/Extensions/Bundle+Extensions.swift b/Sources/BSWFoundation/Extensions/Bundle+Extensions.swift
index 0ed6bf7..9e6f92d 100644
--- a/Sources/BSWFoundation/Extensions/Bundle+Extensions.swift
+++ b/Sources/BSWFoundation/Extensions/Bundle+Extensions.swift
@@ -37,11 +37,15 @@ extension Bundle {
     public var osName: String {
         #if os(Android)
         return "Android API \(operatingSystemVersion)"
-        #elseif os(watchOS)
-        let osName = "watchOS"
         #else
-        let osName = ProcessInfo.processInfo.isCatalystOriIOSAppOnMac ? "macOS" : "iOS"
+        #if os(watchOS)
+        let name = "watchOS"
+        #elseif os(visionOS)
+        let name = "visionOS"
+        #else
+        let name = ProcessInfo.processInfo.isCatalystOriIOSAppOnMac ? "macOS" : "iOS"
+        #endif
+        return "\(name) \(operatingSystemVersion)"
         #endif
-        return "\(osName) \(operatingSystemVersion)"
     }
 }
diff --git a/Sources/BSWFoundation/Location/LocationFetcher.swift b/Sources/BSWFoundation/Location/LocationFetcher.swift
index 68471e7..82cebf8 100644
--- a/Sources/BSWFoundation/Location/LocationFetcher.swift
+++ b/Sources/BSWFoundation/Location/LocationFetcher.swift
@@ -109,7 +109,8 @@ public final class LocationFetcher: NSObject, CLLocationManagerDelegate {
     }
     
     public nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Swift.Error) {
-        print("Error finding location: \(error.localizedDescription)")
+        let logger = BSWLogger(subsystem: submoduleName("LocationFetcher"), category: "CoreLocation")
+        logger.error("Error finding location: \(error.localizedDescription)")
         MainActor.assumeIsolated {
             completeCurrentRequest(.failure(.coreLocationError(error)))
         }
diff --git a/Sources/BSWFoundation/Parse/FailableCodableArray.swift b/Sources/BSWFoundation/Parse/FailableCodableArray.swift
index deaa5c7..7caad9a 100644
--- a/Sources/BSWFoundation/Parse/FailableCodableArray.swift
+++ b/Sources/BSWFoundation/Parse/FailableCodableArray.swift
@@ -3,12 +3,6 @@ import FoundationInternationalization
 #endif
 import Foundation
 
-#if os(Android)
-import AndroidLogging
-#else
-import OSLog
-#endif
-
 public struct FailableCodableArray<Element : Decodable> : Decodable {
 
     public let elements: [Element]
@@ -38,7 +32,7 @@ private struct FailableDecodable<Base : Decodable> : Decodable {
             do {
                 return try container.decode(Base.self)
             } catch let error {
-                let logger = Logger(subsystem: submoduleName("FailableDecodable"), category: "error")
+                let logger = BSWLogger(subsystem: submoduleName("FailableDecodable"), category: "error")
                 logger.warning("Error decoding \(Base.self): \(error)")
                 return nil
             }
diff --git a/Sources/BSWFoundation/Parse/JSONParser.swift b/Sources/BSWFoundation/Parse/JSONParser.swift
index 08641db..f9e34e5 100644
--- a/Sources/BSWFoundation/Parse/JSONParser.swift
+++ b/Sources/BSWFoundation/Parse/JSONParser.swift
@@ -4,11 +4,6 @@
 //
 
 import Foundation
-#if os(Android)
-import AndroidLogging
-#else
-import OSLog
-#endif
 
 public enum JSONParser {
     
@@ -80,7 +75,7 @@ public enum JSONParser {
         do {
             return try jsonDecoder.decode(T.self, from: data)
         } catch let decodingError as DecodingError {
-            let logger = Logger(subsystem: submoduleName("JSONParser"), category: "parseData<\(T.self)>")
+            let logger = BSWLogger(subsystem: submoduleName("JSONParser"), category: "parseData<\(T.self)>")
             switch decodingError {
             case .keyNotFound(let missingKey, let context):
                 logger.warning("Decoding error: key \(String(describing: missingKey)) is missing, Context: \(context.debugDescription)")
diff --git a/Sources/BSWFoundation/PropertyWrappers/KeychainBacked.swift b/Sources/BSWFoundation/PropertyWrappers/KeychainBacked.swift
index 0cd41cf..979b1ee 100644
--- a/Sources/BSWFoundation/PropertyWrappers/KeychainBacked.swift
+++ b/Sources/BSWFoundation/PropertyWrappers/KeychainBacked.swift
@@ -3,16 +3,67 @@
 //
 import Foundation
 
-#if os(Android)
+#if canImport(SkipKeychain)
 import SkipKeychain
-#else
+#elseif canImport(Darwin)
 import KeychainAccess
 #endif
 
-/// This is supported anywhere but Linux
-#if !os(Linux)
+#if os(WASI)
 
-/// Stores a String on the Keychain
+/// Unavailable on WebAssembly because browsers do not provide Keychain-equivalent secure storage
+/// to SwiftWasm. Use host-managed auth or `UserDefaultsBacked` only for non-sensitive values.
+@available(*, unavailable, message: "KeychainBacked is unavailable on WebAssembly. Use host-managed auth, or UserDefaultsBacked only for non-sensitive values.")
+@propertyWrapper
+public final class KeychainBacked {
+    public init(key: String, appGroupID: String? = nil) {}
+    public var wrappedValue: String? {
+        get { nil }
+        set {}
+    }
+}
+
+/// Unavailable on WebAssembly because browsers do not provide Keychain-equivalent secure storage
+/// to SwiftWasm. Use host-managed auth or `CodableUserDefaultsBacked` only for non-sensitive values.
+@available(*, unavailable, message: "CodableKeychainBacked is unavailable on WebAssembly. Use host-managed auth, or CodableUserDefaultsBacked only for non-sensitive values.")
+@propertyWrapper
+public final class CodableKeychainBacked<T: Codable> {
+    public init(key: String) {}
+    public var wrappedValue: T? {
+        get { nil }
+        set {}
+    }
+}
+
+#elseif os(Android) && !canImport(SkipKeychain)
+
+/// Unavailable on plain Swift Android SDK builds because Android secure storage integration is
+/// supplied by SkipKeychain, which is only present when building with Skip enabled.
+@available(*, unavailable, message: "KeychainBacked is unavailable on Android unless building with SkipKeychain enabled. Pass SKIP_ENABLED=1 so SwiftPM includes the SkipKeychain dependency.")
+@propertyWrapper
+public final class KeychainBacked {
+    public init(key: String, appGroupID: String? = nil) {}
+    public var wrappedValue: String? {
+        get { nil }
+        set {}
+    }
+}
+
+/// Unavailable on plain Swift Android SDK builds because Android secure storage integration is
+/// supplied by SkipKeychain, which is only present when building with Skip enabled.
+@available(*, unavailable, message: "CodableKeychainBacked is unavailable on Android unless building with SkipKeychain enabled. Pass SKIP_ENABLED=1 so SwiftPM includes the SkipKeychain dependency.")
+@propertyWrapper
+public final class CodableKeychainBacked<T: Codable> {
+    public init(key: String) {}
+    public var wrappedValue: T? {
+        get { nil }
+        set {}
+    }
+}
+
+#elseif !os(Linux)
+
+/// Stores a String on the Keychain.
 @propertyWrapper
 public class KeychainBacked {
     private let key: String
@@ -28,11 +79,11 @@ public class KeychainBacked {
                 return Keychain(service: Bundle.main.bundleIdentifier!)
             }
         }()
-        #else
+        #elseif canImport(SkipKeychain)
         self.keychain = Keychain.shared
         #endif
     }
-    
+
     #if canImport(Darwin)
     public var wrappedValue: String? {
         get {
@@ -62,7 +113,7 @@ public extension KeychainBacked {
     }
 }
 
-/// Stores the given `T` type on the Keychain (as long as it's `Codable`)
+/// Stores the given `T` type on the Keychain, as long as it's `Codable`.
 @propertyWrapper
 public class CodableKeychainBacked<T: Codable> {
     private let key: String
@@ -72,11 +123,11 @@ public class CodableKeychainBacked<T: Codable> {
         self.key = key
         #if canImport(Darwin)
         self.keychain = Keychain(service: Bundle.main.bundleIdentifier!)
-        #else
+        #elseif canImport(SkipKeychain)
         self.keychain = Keychain.shared
         #endif
     }
-    
+
     #if canImport(Darwin)
     public var wrappedValue: T? {
         get {
diff --git a/Sources/BSWFoundation/PropertyWrappers/UserDefaultsBacked.swift b/Sources/BSWFoundation/PropertyWrappers/UserDefaultsBacked.swift
index 6927e75..912ad28 100644
--- a/Sources/BSWFoundation/PropertyWrappers/UserDefaultsBacked.swift
+++ b/Sources/BSWFoundation/PropertyWrappers/UserDefaultsBacked.swift
@@ -4,12 +4,47 @@
 
 import Foundation
 
-#if os(Android)
+#if canImport(SkipFuse)
 import SkipFuse
+#endif
+
+#if canImport(SkipAndroidBridge)
 import SkipAndroidBridge
+#elseif os(WASI)
+import JavaScriptKit
 #endif
 
-#if !os(Linux)
+/// Supported everywhere except Linux. On WebAssembly it is backed by `localStorage`
+/// through an internal browser storage adapter.
+#if os(Android) && !canImport(SkipAndroidBridge)
+/// Unavailable on plain Swift Android SDK builds because Android user defaults integration is
+/// supplied by SkipAndroidBridge, which is only present when building with Skip enabled.
+@available(*, unavailable, message: "UserDefaultsBacked is unavailable on Android unless building with SkipAndroidBridge enabled. Pass SKIP_ENABLED=1 so SwiftPM includes the required Skip dependencies.")
+@propertyWrapper
+public final class UserDefaultsBacked<T: Sendable>: Sendable {
+    public init(key: String, defaultValue: T? = nil, appGroupID: String? = nil) {}
+    public var wrappedValue: T? {
+        get { nil }
+        set {}
+    }
+
+    public func reset() {}
+}
+
+/// Unavailable on plain Swift Android SDK builds because Android user defaults integration is
+/// supplied by SkipAndroidBridge, which is only present when building with Skip enabled.
+@available(*, unavailable, message: "CodableUserDefaultsBacked is unavailable on Android unless building with SkipAndroidBridge enabled. Pass SKIP_ENABLED=1 so SwiftPM includes the required Skip dependencies.")
+@propertyWrapper
+public final class CodableUserDefaultsBacked<T: Codable & Sendable>: Sendable {
+    public init(key: String, defaultValue: T? = nil, appGroupID: String? = nil) {}
+    public var wrappedValue: T? {
+        get { nil }
+        set {}
+    }
+
+    public func reset() {}
+}
+#elseif !os(Linux)
 /// Stores the given `T` type on User Defaults.
 ///
 /// The value parameter can be only property list objects: `NSData`, `NSString`, `NSNumber`, `NSDate`, `NSArray`, or `NSDictionary`.
@@ -17,8 +52,12 @@ import SkipAndroidBridge
 public final class UserDefaultsBacked<T: Sendable>: Sendable {
     private let key: String
     private let defaultValue: T?
+    #if os(WASI)
+    private let store = WASMKeyValueStore.shared
+    #else
     private nonisolated(unsafe) let store: UserDefaults
-    
+    #endif
+
     public init(key: String, defaultValue: T? = nil, appGroupID: String? = nil) {
         self.key = key
         self.defaultValue = defaultValue
@@ -30,11 +69,11 @@ public final class UserDefaultsBacked<T: Sendable>: Sendable {
                 return UserDefaults.standard
             }
         }()
-        #else
+        #elseif canImport(SkipAndroidBridge)
         self.store = SkipAndroidBridge.AndroidUserDefaults.standard
         #endif
     }
-    
+
     public var wrappedValue: T? {
         get {
             #if canImport(Darwin)
@@ -42,6 +81,14 @@ public final class UserDefaultsBacked<T: Sendable>: Sendable {
                 return defaultValue
             }
             return value
+            #elseif os(WASI)
+            if T.self == Bool.self {
+                return (store.string(forKey: key).map { $0 == "true" } as? T) ?? defaultValue
+            } else if T.self == String.self {
+                return (store.string(forKey: key) as? T) ?? defaultValue
+            } else {
+                fatalError("Type not yet supported on WebAssembly")
+            }
             #else
             if T.self == Bool.self {
                 return self.store.bool(forKey: key) as? T
@@ -52,12 +99,26 @@ public final class UserDefaultsBacked<T: Sendable>: Sendable {
             }
             #endif
         } set {
+            #if os(WASI)
+            if let newValue {
+                if let bool = newValue as? Bool {
+                    store.set(bool ? "true" : "false", forKey: key)
+                } else if let string = newValue as? String {
+                    store.set(string, forKey: key)
+                } else {
+                    fatalError("Type not yet supported on WebAssembly")
+                }
+            } else {
+                store.removeObject(forKey: key)
+            }
+            #else
             if newValue != nil {
                 self.store.set(newValue, forKey: key)
             } else {
                 self.store.removeObject(forKey: key)
             }
             _ = self.store.synchronize()
+            #endif
         }
     }
 }
@@ -74,7 +135,11 @@ public extension UserDefaultsBacked {
 public final class CodableUserDefaultsBacked<T: Codable & Sendable>: Sendable {
     private let key: String
     private let defaultValue: T?
+    #if os(WASI)
+    private let store = WASMKeyValueStore.shared
+    #else
     private nonisolated(unsafe) let store: UserDefaults
+    #endif
 
     public init(key: String, defaultValue: T? = nil, appGroupID: String? = nil) {
         self.key = key
@@ -87,11 +152,11 @@ public final class CodableUserDefaultsBacked<T: Codable & Sendable>: Sendable {
                 return UserDefaults.standard
             }
         }()
-        #else
+        #elseif canImport(SkipAndroidBridge)
         self.store = SkipAndroidBridge.AndroidUserDefaults.standard
         #endif
     }
-    
+
     public var wrappedValue: T? {
         get {
             guard let data = store.data(forKey: key) else {
@@ -102,9 +167,15 @@ public final class CodableUserDefaultsBacked<T: Codable & Sendable>: Sendable {
             if let newValue, let data = try? JSONEncoder().encode(newValue) {
                 store.set(data, forKey: key)
             } else {
+                #if os(WASI)
+                store.set(Data?.none, forKey: key)
+                #else
                 store.set(nil, forKey: key)
+                #endif
             }
+            #if !os(WASI)
             _ = store.synchronize()
+            #endif
         }
     }
 }
@@ -114,4 +185,44 @@ public extension CodableUserDefaultsBacked {
         self.store.removeObject(forKey: key)
     }
 }
+
+#if os(WASI)
+private final class WASMKeyValueStore: @unchecked Sendable {
+
+    static let shared = WASMKeyValueStore()
+
+    /// `nil` when `localStorage` is unavailable (e.g. a Worker context); the store then no-ops.
+    private let localStorage: JSObject?
+
+    private init() {
+        localStorage = JSObject.global.localStorage.object
+    }
+
+    func string(forKey key: String) -> String? {
+        guard let localStorage else { return nil }
+        return localStorage.getItem!(key).string
+    }
+
+    func data(forKey key: String) -> Data? {
+        string(forKey: key)?.data(using: .utf8)
+    }
+
+    func set(_ value: String?, forKey key: String) {
+        guard let localStorage else { return }
+        if let value {
+            _ = localStorage.setItem!(key, value)
+        } else {
+            _ = localStorage.removeItem!(key)
+        }
+    }
+
+    func set(_ value: Data?, forKey key: String) {
+        set(value.flatMap { String(data: $0, encoding: .utf8) }, forKey: key)
+    }
+
+    func removeObject(forKey key: String) {
+        set(String?.none, forKey: key)
+    }
+}
+#endif
 #endif
diff --git a/Tests/BSWFoundationTests/APIClient/APIClientErrorTests.swift b/Tests/BSWFoundationTests/APIClient/APIClientErrorTests.swift
index 4589c40..d984347 100644
--- a/Tests/BSWFoundationTests/APIClient/APIClientErrorTests.swift
+++ b/Tests/BSWFoundationTests/APIClient/APIClientErrorTests.swift
@@ -7,7 +7,7 @@ struct APIClientErrorTests {
     @Test
     func errorPrinting_encodingRequestFailed() {
         let localizedDescription = APIClient.Error.encodingRequestFailed.localizedDescription
-        #if os(Android)
+        #if os(Android) || os(WASI)
         #expect(localizedDescription == "The operation could not be completed. (BSWFoundation.APIClient.Error.encodingRequestFailed)")
         #else
         #expect(localizedDescription == "The operation couldn’t be completed. (BSWFoundation.APIClient.Error.encodingRequestFailed)")
@@ -20,7 +20,7 @@ struct APIClientErrorTests {
         ["Please try again"]
         """.data(using: .utf8)
         let localizedDescription = APIClient.Error.failureStatusCode(400, errorMessageData).localizedDescription
-        #if os(Android)
+        #if os(Android) || os(WASI)
         #expect(localizedDescription == "The operation could not be completed. (BSWFoundation.APIClient.Error.FailureStatusCode: 400, Message: [\"Please try again\"])")
         #else
         #expect(localizedDescription == "The operation couldn’t be completed. (BSWFoundation.APIClient.Error.FailureStatusCode: 400, Message: [\"Please try again\"])")
@@ -33,7 +33,7 @@ struct APIClientErrorTests {
         "Please try again"
         """.data(using: .utf8)
         let localizedDescription = APIClient.Error.failureStatusCode(400, errorMessageData).localizedDescription
-        #if os(Android)
+        #if os(Android) || os(WASI)
         #expect(localizedDescription == "The operation could not be completed. (BSWFoundation.APIClient.Error.FailureStatusCode: 400, Message: \"Please try again\")")
         #else
         #expect(localizedDescription == "The operation couldn’t be completed. (BSWFoundation.APIClient.Error.FailureStatusCode: 400, Message: \"Please try again\")")
diff --git a/Tests/BSWFoundationTests/APIClient/APIClientTests.swift b/Tests/BSWFoundationTests/APIClient/APIClientTests.swift
index c1f40bc..64630b9 100644
--- a/Tests/BSWFoundationTests/APIClient/APIClientTests.swift
+++ b/Tests/BSWFoundationTests/APIClient/APIClientTests.swift
@@ -10,14 +10,22 @@ import HTTPTypes
 import FoundationNetworking
 #endif
 
+// On WebAssembly the network / URLSession / file / Dispatch based tests are excluded (`#if
+// !os(WASI)`); the deterministic, mock-backed tests below run there. Real networking is covered
+// by the Apple/Android jobs and by the runtime harness in `WASMHarness/`.
+
 actor APIClientTests {
 
     var sut: APIClient
 
     init() {
+        #if os(WASI)
+        BSWBrowserRuntime.installJavaScriptEventLoop()
+        #endif
         sut = APIClient(environment: HTTPBin.Hosts.production)
     }
 
+    #if !os(WASI)
     @Test
     func GET() async throws {
         let ipRequest = BSWFoundation.APIClient.Request<HTTPBin.Responses.IP>(
@@ -99,6 +107,7 @@ actor APIClientTests {
         }
         try FileManager.default.removeItem(at: file)
     }
+    #endif
 
     @Test
     func unauthorizedCallsRightMethod() async throws {
@@ -115,6 +124,7 @@ actor APIClientTests {
         #expect(failedPath != nil)
     }
 
+    #if !os(WASI)
     @Test
     func unauthorizedRetriesAfterGeneratingNewCredentials() async throws {
 
@@ -156,6 +166,7 @@ actor APIClientTests {
         )
         let _ = try await sut.perform(ipRequest)
     }
+    #endif
 
     @Test
     func customizeRequests() async throws {
@@ -200,6 +211,7 @@ actor APIClientTests {
         #expect(capturedRequest.httpRequest.headerFields[.init("Signature")!] == "hello")
     }
 
+    #if !os(WASI)
     static func generateRandomFile() throws -> URL {
         let length = 2048
         let bytes = [UInt32](repeating: 0, count: length).map { _ in arc4random() }
@@ -211,13 +223,16 @@ actor APIClientTests {
 
         return url
     }
+    #endif
 }
 
 @MainActor
 private class MockAPIClientDelegate: NSObject, APIClientDelegate {
     func apiClientDidReceiveUnauthorized(forRequest atPath: String, apiClientID: APIClient.ID) async throws -> Bool {
         failedPath = atPath
+        #if !os(WASI)
         dispatchPrecondition(condition: .onQueue(.main))
+        #endif
         return false
     }
     var failedPath: String?
diff --git a/Tests/BSWFoundationTests/Extensions/Android.swift b/Tests/BSWFoundationTests/Extensions/Android.swift
deleted file mode 100644
index 8ca3b89..0000000
--- a/Tests/BSWFoundationTests/Extensions/Android.swift
+++ /dev/null
@@ -1,10 +0,0 @@
-
-/// Bundle.module is not available on Android
-/// unit tests, so for now we are turning these off
-var isAndroid: Bool {
-    #if os(Android)
-    return true
-    #else
-    return false
-    #endif
-}
diff --git a/Tests/BSWFoundationTests/Extensions/ObservationTests.swift b/Tests/BSWFoundationTests/Extensions/ObservationTests.swift
index 03b28d8..c804daa 100644
--- a/Tests/BSWFoundationTests/Extensions/ObservationTests.swift
+++ b/Tests/BSWFoundationTests/Extensions/ObservationTests.swift
@@ -1,14 +1,18 @@
 
 import Testing
 import Observation
+import BSWFoundation
 
 @Suite
 struct ObservationTests {
     
     @Observable
     @MainActor
-    class ViewModel {
+    final class ViewModel {
         var isReady: Bool = false
+        var count: Int = 0
+        var title: String = "Initial"
+
         func setIsReady() {
             isReady = true
         }
@@ -26,4 +30,97 @@ struct ObservationTests {
         await viewModel.stream(for: \.isReady).until(true)
         #expect(viewModel.isReady)
     }
+
+    @MainActor
+    @Test
+    func streamImmediatelyYieldsCurrentValue() async throws {
+        let viewModel = ViewModel()
+        viewModel.count = 42
+
+        var iterator = viewModel.stream(for: \.count).makeAsyncIterator()
+
+        #expect(await iterator.next() == 42)
+    }
+
+    @MainActor
+    @Test
+    func streamYieldsSequentialChanges() async throws {
+        let viewModel = ViewModel()
+        var iterator = viewModel.stream(for: \.count).makeAsyncIterator()
+
+        #expect(await iterator.next() == 0)
+
+        viewModel.count = 1
+        #expect(await iterator.next() == 1)
+
+        viewModel.count = 2
+        #expect(await iterator.next() == 2)
+
+        viewModel.count = -1
+        #expect(await iterator.next() == -1)
+    }
+
+    @MainActor
+    @Test
+    func changingUnobservedPropertyDoesNotYield() async throws {
+        let viewModel = ViewModel()
+
+        await confirmation(expectedCount: 1) { confirmation in
+            let task = Task { @MainActor in
+                for await _ in viewModel.stream(for: \.count) {
+                    confirmation()
+                }
+            }
+
+            try? await Task.sleep(for: .milliseconds(20))
+            viewModel.title = "Changed"
+            try? await Task.sleep(for: .milliseconds(20))
+            task.cancel()
+        }
+    }
+
+    @MainActor
+    @Test
+    func terminatingStreamStopsFurtherObservation() async throws {
+        let viewModel = ViewModel()
+
+        await confirmation(expectedCount: 2) { confirmation in
+            let task = Task { @MainActor in
+                for await value in viewModel.stream(for: \.count) {
+                    confirmation()
+                    if value == 1 {
+                        break
+                    }
+                }
+            }
+
+            try? await Task.sleep(for: .milliseconds(20))
+            viewModel.count = 1
+            try? await Task.sleep(for: .milliseconds(20))
+            viewModel.count = 2
+            try? await Task.sleep(for: .milliseconds(20))
+            task.cancel()
+        }
+    }
+
+    @MainActor
+    @Test
+    func streamDoesNotRetainObservedObject() async throws {
+        weak var weakViewModel: ViewModel?
+        var stream: AsyncStream<Int>?
+
+        do {
+            let viewModel = ViewModel()
+            weakViewModel = viewModel
+            stream = viewModel.stream(for: \.count)
+        }
+
+        #expect(weakViewModel == nil)
+
+        if var iterator = stream?.makeAsyncIterator() {
+            #expect(await iterator.next() == 0)
+        } else {
+            Issue.record("Expected stream to exist")
+        }
+    }
 }
diff --git a/Tests/BSWFoundationTests/Extensions/Platforms.swift b/Tests/BSWFoundationTests/Extensions/Platforms.swift
new file mode 100644
index 0000000..ed1a946
--- /dev/null
+++ b/Tests/BSWFoundationTests/Extensions/Platforms.swift
@@ -0,0 +1,20 @@
+
+/// Bundle.module is not available on Android
+/// unit tests, so for now we are turning these off
+var isAndroid: Bool {
+    #if os(Android)
+    return true
+    #else
+    return false
+    #endif
+}
+
+/// On WebAssembly, storage is localStorage-backed and `UserDefaults.standard` semantics differ,
+/// so some Apple-coupled tests are turned off there (their wasm paths are covered by `WASMHarness`).
+var isWASI: Bool {
+    #if os(WASI)
+    return true
+    #else
+    return false
+    #endif
+}
diff --git a/Tests/BSWFoundationTests/Extensions/UserDefaultsBackedTests.swift b/Tests/BSWFoundationTests/Extensions/UserDefaultsBackedTests.swift
index b841a86..e48ab35 100644
--- a/Tests/BSWFoundationTests/Extensions/UserDefaultsBackedTests.swift
+++ b/Tests/BSWFoundationTests/Extensions/UserDefaultsBackedTests.swift
@@ -3,7 +3,7 @@ import Foundation
 import BSWFoundation
 import Testing
 
-@Suite(.serialized, .disabled(if: isAndroid))
+@Suite(.serialized, .disabled(if: isAndroid || isWASI))
 actor UserDefaultsBackedTests {
     
     @Test
diff --git a/WASMHarness/.gitignore b/WASMHarness/.gitignore
new file mode 100644
index 0000000..6deb4f6
--- /dev/null
+++ b/WASMHarness/.gitignore
@@ -0,0 +1,3 @@
+.build/
+node_modules/
+package-lock.json
diff --git a/WASMHarness/Package.resolved b/WASMHarness/Package.resolved
new file mode 100644
index 0000000..b7e5546
--- /dev/null
+++ b/WASMHarness/Package.resolved
@@ -0,0 +1,69 @@
+{
+  "originHash" : "0ffaaced017efc045757e24601281659815e9a80a0f18d078e3040a97cca3dc0",
+  "pins" : [
+    {
+      "identity" : "javascriptkit",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftwasm/JavaScriptKit.git",
+      "state" : {
+        "revision" : "22905075f8b61834810babe5fb9a2f613f22f398",
+        "version" : "0.56.1"
+      }
+    },
+    {
+      "identity" : "keychainaccess",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/kishikawakatsumi/KeychainAccess.git",
+      "state" : {
+        "revision" : "84e546727d66f1adc5439debad16270d0fdd04e7",
+        "version" : "4.2.2"
+      }
+    },
+    {
+      "identity" : "swift-asn1",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-asn1.git",
+      "state" : {
+        "revision" : "a9a5efd40eaf558a2bcd48d64b1d1646be686008",
+        "version" : "1.7.1"
+      }
+    },
+    {
+      "identity" : "swift-crypto",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-crypto.git",
+      "state" : {
+        "revision" : "95ba0316a9b733e92bb6b071255ff46263bbe7dc",
+        "version" : "3.15.1"
+      }
+    },
+    {
+      "identity" : "swift-http-types",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-http-types.git",
+      "state" : {
+        "revision" : "db774a277f60063a32d854f2980299caf06da041",
+        "version" : "1.6.0"
+      }
+    },
+    {
+      "identity" : "swift-log",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-log.git",
+      "state" : {
+        "revision" : "a878e7f8f46cfc0e1125e565b5c08e7d5272dc9a",
+        "version" : "1.14.0"
+      }
+    },
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/swiftlang/swift-syntax",
+      "state" : {
+        "revision" : "79e4b74a295b6eb74a8b585e3a39d29e70c1dbd1",
+        "version" : "603.0.2"
+      }
+    }
+  ],
+  "version" : 3
+}
diff --git a/WASMHarness/Package.swift b/WASMHarness/Package.swift
new file mode 100644
index 0000000..cfcddb5
--- /dev/null
+++ b/WASMHarness/Package.swift
@@ -0,0 +1,29 @@
+// swift-tools-version: 6.2
+import PackageDescription
+
+// A small executable that exercises BSWFoundation's WebAssembly paths at runtime:
+// a real `fetch` GET through FetchNetworkFetcher and a localStorage round-trip through
+// UserDefaultsBacked. Build + run with:
+//
+//   swift package --swift-sdk swift-6.3.x-RELEASE_wasm js
+//   node main.mjs
+//
+let package = Package(
+    name: "WASMHarness",
+    platforms: [.macOS(.v15)],
+    dependencies: [
+        .package(name: "BSWFoundation", path: ".."),
+        .package(url: "https://github.com/swiftwasm/JavaScriptKit.git", from: "0.56.1"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "WASMHarness",
+            dependencies: [
+                .product(name: "BSWFoundation", package: "BSWFoundation"),
+                .product(name: "JavaScriptKit", package: "JavaScriptKit"),
+                .product(name: "JavaScriptEventLoop", package: "JavaScriptKit"),
+            ]
+        )
+    ],
+    swiftLanguageModes: [.v6]
+)
diff --git a/WASMHarness/README.md b/WASMHarness/README.md
new file mode 100644
index 0000000..bcf85a6
--- /dev/null
+++ b/WASMHarness/README.md
@@ -0,0 +1,53 @@
+# BSWFoundation WebAssembly harness
+
+A tiny executable that proves BSWFoundation's WebAssembly paths work at **runtime**
+(not just at compile time) in a real JavaScript host:
+
+- a real `fetch` GET through `FetchNetworkFetcher`, decoded by `JSONParser`, and
+- a `localStorage` round-trip through `UserDefaultsBacked`.
+
+## Prerequisite
+
+Install the WebAssembly Swift SDK matching your Swift toolchain — see the
+top-level README's "WebAssembly / Browser Support" section, or
+[swift.org's WASM guide](https://www.swift.org/documentation/articles/wasm-getting-started.html).
+Confirm the installed SDK id with `swift sdk list`.
+
+## Build
+
+```sh
+swift package --package-path WASMHarness \
+  --swift-sdk swift-6.3.x-RELEASE_wasm \
+  --disable-sandbox js
+```
+
+This bundles to `WASMHarness/.build/plugins/PackageToJS/outputs/Package/`
+(both a Node and a browser entrypoint are generated).
+
+## Run in Node
+
+Node has `fetch` built in but no `localStorage`, so `main.mjs` shims it in memory.
+
+```sh
+npm install --prefix WASMHarness   # installs @bjorn3/browser_wasi_shim (see package.json)
+node WASMHarness/main.mjs
+```
+
+Expected output:
+
+```
+— BSWFoundation WebAssembly runtime harness —
+✅ fetch GET https://httpbingo.org/ip → origin = …
+✅ UserDefaultsBacked localStorage round-trip → 'hello-from-wasm'
+— harness complete —
+```
+
+## Run in a browser
+
+In a browser both `fetch` and `localStorage` are native — no shims. Serve this
+folder over HTTP (wasm can't load from `file://`) and open `index.html`:
+
+```sh
+npx serve WASMHarness   # or any static file server
+# open the printed URL + /index.html and check the devtools console
+```
diff --git a/WASMHarness/Sources/WASMHarness/main.swift b/WASMHarness/Sources/WASMHarness/main.swift
new file mode 100644
index 0000000..c2c7013
--- /dev/null
+++ b/WASMHarness/Sources/WASMHarness/main.swift
@@ -0,0 +1,60 @@
+import Foundation
+import JavaScriptKit
+import BSWFoundation
+
+@main
+struct WASMHarness {
+    static func main() {
+        BSWBrowserRuntime.installJavaScriptEventLoop()
+        Task {
+            await runHarness()
+            // Tell the node runner (main.mjs) the async work is finished.
+            _ = JSObject.global.__harnessDone.function?()
+        }
+    }
+}
+
+private func log(_ message: String) {
+    if let console = JSObject.global.console.object {
+        _ = console.log!(message)
+    }
+}
+
+private struct HarnessEnvironment: Environment {
+    var baseURL: URL { URL(string: "https://httpbingo.org")! }
+}
+
+private enum HarnessAPI: Endpoint {
+    case ip
+    var path: String { "/ip" }
+}
+
+private struct IPResponse: Decodable {
+    let origin: String
+}
+
+private func runHarness() async {
+    log("— BSWFoundation WebAssembly runtime harness —")
+
+    // 1. A real network GET through the default fetcher (FetchNetworkFetcher → JS fetch).
+    let client = APIClient(environment: HarnessEnvironment())
+    do {
+        let request = APIClient.Request<IPResponse>(endpoint: HarnessAPI.ip)
+        let ip = try await client.perform(request)
+        log("✅ fetch GET https://httpbingo.org/ip → origin = \(ip.origin)")
+    } catch {
+        log("❌ fetch GET failed: \(error)")
+    }
+
+    // 2. A localStorage round-trip through UserDefaultsBacked.
+    let value = UserDefaultsBacked<String>(key: "harness.value")
+    value.wrappedValue = "hello-from-wasm"
+    let readBack = value.wrappedValue
+    if readBack == "hello-from-wasm" {
+        log("✅ UserDefaultsBacked localStorage round-trip → '\(readBack ?? "")'")
+    } else {
+        log("❌ UserDefaultsBacked round-trip failed → '\(readBack ?? "nil")'")
+    }
+
+    log("— harness complete —")
+}
diff --git a/WASMHarness/index.html b/WASMHarness/index.html
new file mode 100644
index 0000000..aa6cded
--- /dev/null
+++ b/WASMHarness/index.html
@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>BSWFoundation WebAssembly harness</title>
+</head>
+<body>
+    <p>Running the BSWFoundation wasm harness — open the developer console to see results.</p>
+    <script type="module">
+        // In a real browser, `fetch` and `localStorage` are native — no shims needed.
+        globalThis.__harnessDone = () => console.log("[harness] complete");
+        import("./.build/plugins/PackageToJS/outputs/Package/index.js")
+            .then(({ init }) => init())
+            .catch((error) => console.error(error));
+    </script>
+</body>
+</html>
diff --git a/WASMHarness/main.mjs b/WASMHarness/main.mjs
new file mode 100644
index 0000000..cdc1901
--- /dev/null
+++ b/WASMHarness/main.mjs
@@ -0,0 +1,29 @@
+// Node.js runner for the BSWFoundation WebAssembly harness.
+//
+//   swift package --swift-sdk swift-6.3.x-RELEASE_wasm js
+//   node main.mjs
+//
+// node provides `fetch`, but not `localStorage` (a browser API), so we shim it in memory.
+
+import { instantiate } from "./.build/plugins/PackageToJS/outputs/Package/instantiate.js"
+import { defaultNodeSetup } from "./.build/plugins/PackageToJS/outputs/Package/platforms/node.js"
+
+// Minimal in-memory localStorage shim (node has no localStorage).
+const _store = new Map()
+globalThis.localStorage = {
+    getItem: (key) => (_store.has(key) ? _store.get(key) : null),
+    setItem: (key, value) => { _store.set(key, String(value)) },
+    removeItem: (key) => { _store.delete(key) },
+}
+
+async function main() {
+    let resolveDone
+    const done = new Promise((resolve) => { resolveDone = resolve })
+    globalThis.__harnessDone = () => resolveDone()
+
+    const options = await defaultNodeSetup()
+    await instantiate(options)   // runs WASMHarness.main(), which starts the async Task
+    await done                   // wait until the Swift harness signals completion
+}
+
+main()
diff --git a/WASMHarness/package.json b/WASMHarness/package.json
new file mode 100644
index 0000000..63a1ead
--- /dev/null
+++ b/WASMHarness/package.json
@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@bjorn3/browser_wasi_shim": "^0.3.0"
+  }
+}