stremio/stremio-core-web

1. Overall role

- This repository is a WebAssembly bridge package between the Rust-based stremio-core and the JavaScript application stremio-web.

- Its job is not to implement the whole product, but to adapt core domain data and events into a web-friendly boundary that can be consumed from JS/npm.

2. Top-level runtime split

- The codebase is split into a Rust/WASM side and a JavaScript integration side.

- Rust owns the domain-facing logic and serialization adapters.

- JS owns the package entry points and worker/bridge glue used by the web app.

3. Rust crate as the main architecture center

- Cargo.toml, Cargo.lock, rust-toolchain.toml, and src/lib.rs indicate the primary deliverable is a Rust library compiled to WASM.

- src/stremio_core_web.rs is likely the crate façade that exposes the web bridge API.

- src/env.rs and src/event.rs suggest the bridge depends on a controlled runtime environment and an event channel for notifications back to the web layer.

4. Boundary between core models and web serialization

- The src/model/ directory is the most important subsystem.

- It contains a set of serializer/adaptor modules such as serialize_library.rs, serialize_player.rs, serialize_streaming_server.rs, serialize_discover.rs, and others.

- This indicates the repo translates internal stremio-core structures into JS/WASM-safe shapes for specific product areas instead of exposing raw core types.

5. Feature-oriented model adapters

- src/model/model.rs and src/model/mod.rs likely define the shared model layer and module wiring.

- The various serialize_* files map to distinct product domains: library, discover, player, local search, remote addons, installed addons, data export, meta details, continue-watching preview, and catalogs.

- This means the architecture is organized around use-case slices, not around generic transport helpers.

6. Deep-link support as a dedicated extension layer

- src/model/deep_links_ext/ is a separate subsystem for deep-link handling.

- Files like video_deep_links.rs, stream_deep_links.rs, library_deep_links.rs, and search_history_deep_links.rs show that navigation/state-entry points are modeled explicitly.

- This layer likely converts app-specific routes or intents into core actions and serializable link targets.

7. JavaScript bridge and worker boundary

- src/bridge.js and src/worker.js are the browser-side integration points.

- Their presence strongly suggests the WASM module runs behind a worker-based or message-passing bridge, isolating heavy core logic from the UI thread.

- This is the main boundary where JS communicates with Rust-generated behavior.

8. Data flow through the package

- The likely flow is: stremio-web sends requests/events into the JS bridge → JS forwards them to the WASM/Rust layer → Rust uses core-derived models and env/event abstractions → results are serialized back to JS.

- The event module implies asynchronous updates are pushed back out, not just request/response calls.

- The model serializers are the main output boundary for these flows.

9. Build and packaging architecture

- package.json, package-lock.json, .babelrc, and .npmignore show this repo is packaged for the npm ecosystem.

- scripts/build.sh and the README’s build flow indicate a production build compiles the Rust crate to WASM and then prepares JS/package artifacts.

- The repo is therefore a cross-language build pipeline, not a single-language library.

10. Development and debug mode

- The README notes a --dev build path and a cargo wasm-watch workflow from .cargo/config.toml.

- That implies the package supports incremental recompilation and verbose debug logging during development, with a warning that debug logs may include sensitive data.

- This is a tooling concern that affects how the bridge is operated locally.

11. CI/CD and release lifecycle

- .github/workflows/build.yml, prerelease.yml, and publish.yml define automated build and release flows.

- Publishing targets both GitHub Releases and the npm registry.

- Versioning is coordinated across Cargo and npm manifests, so release management is part of the repo’s operational architecture.

12. External dependencies and product boundaries

- The repository depends structurally on stremio-core and is consumed by stremio-web.

- That makes it an adapter layer between a shared domain core and a web client, with a stable contract defined by WASM exports, JS bridges, and serialized model shapes.

- For an architecture diagram, this repo should be shown as a middle-tier packaging/interop layer rather than an end-user application or backend service.