diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000..185ff96182
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,4 @@
+[submodule "packages/react/preact-upstream-tests/preact"]
+	path = packages/react/preact-upstream-tests/preact
+	url = https://github.com/hzy/preact.git
+	branch = lynx/v10.24.x
diff --git a/.typos.toml b/.typos.toml
index dd9d79bff9..c026c36464 100644
--- a/.typos.toml
+++ b/.typos.toml
@@ -15,6 +15,8 @@ extend-exclude = [
   "packages/web-platform/web-tests/tests/react.spec.ts",
   "packages/web-platform/web-tests/tests/react/basic-element-x-overlay-ng-playground-test/index.jsx",
   "packages/web-platform/offscreen-document/src/webworker/OffscreenCSSStyleDeclaration.ts",
+  # Upstream Preact submodule — do not spell-check third-party content
+  "packages/react/preact-upstream-tests/preact/**",
 ]
 
 [default]
@@ -31,3 +33,5 @@ nd = "nd"
 bui = "bui"
 ba = "ba"
 alog = "alog"
+# "apppend" is an intentional typo in an upstream Preact test name that we mirror in our skiplist
+apppend = "apppend"
diff --git a/eslint.config.js b/eslint.config.js
index 6e5e773d9d..3d352ad374 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -98,6 +98,7 @@ export default tseslint.config(
       // testing-library
       'packages/testing-library/**',
       'packages/react/testing-library/**',
+      'packages/react/preact-upstream-tests/**',
 
       // gesture-runtime-testing
       'packages/lynx/gesture-runtime/__test__/**',
diff --git a/packages/react/preact-upstream-tests/.github/skiplist.instructions.md b/packages/react/preact-upstream-tests/.github/skiplist.instructions.md
new file mode 100644
index 0000000000..b13bb1067a
--- /dev/null
+++ b/packages/react/preact-upstream-tests/.github/skiplist.instructions.md
@@ -0,0 +1,8 @@
+---
+applyTo: "{skiplist.json,vitest.shared.ts,README.md,package.json}"
+---
+
+When updating skiplist categories, always run each selected group in both projects (`preact-upstream` and `preact-upstream-compiled`) with `SKIPLIST_ONLY=<category>:<index>` before moving entries.
+Keep mode orthogonality explicit: shared failures stay in `skip_list`/`permanent_skip_list`, no-compile-only failures go to `nocompile_skip_list`, compiled-only failures go to `compiler_skip_list`.
+Because skip matching is title-based, check for duplicate test titles across files before removing an entry; a single title may map to multiple test cases with different outcomes.
+In README positioning and run-order guidance, treat compiled mode as the primary product-path confidence signal and describe no-compile mode as a runtime baseline/regression-isolation tool.
diff --git a/packages/react/preact-upstream-tests/README.md b/packages/react/preact-upstream-tests/README.md
new file mode 100644
index 0000000000..6079ce1361
--- /dev/null
+++ b/packages/react/preact-upstream-tests/README.md
@@ -0,0 +1,489 @@
+# Preact Upstream Tests: E2E Pipeline Verification
+
+Run Preact's own test suite through the **ReactLynx dual-threaded rendering pipeline**
+to verify semantic alignment between "Preact rendering to the Web" and
+"Preact rendering to Lynx through the Snapshot -> Element PAPI path".
+
+## Dual-Mode Testing
+
+The same test suite runs in **two modes** via Vitest workspace:
+
+| Mode          | Project Name               | What Preact Sees                                 | Primary Purpose                           |
+| ------------- | -------------------------- | ------------------------------------------------ | ----------------------------------------- |
+| With compiler | `preact-upstream-compiled` | `{ values: ['foo'] }` via SWC snapshot transform | **Primary product-path confidence**       |
+| No compiler   | `preact-upstream`          | Raw props `{ className: 'foo' }`                 | Runtime baseline and regression isolation |
+
+The compiler is **conservative** (like Vue 3's compiler-hinted Virtual DOM) — it only
+optimizes what it can statically analyze. As an optimization, it should **not change
+program semantics**. Both modes' `scratch.innerHTML` should be identical for any given
+test. A discrepancy = a bug in the compiler or runtime.
+
+**Current results (compiled)**: 413 pass / 0 fail / 192 skip (across 605 tests in 36 files)
+**Current results (no-compiler)**: 438 pass / 0 fail / 167 skip (across 605 tests in 36 files)
+
+### Mode Positioning
+
+- **Default signal for release confidence**: compiled mode (`preact-upstream-compiled`).
+- **Baseline and triage tool**: no-compiler mode (`preact-upstream`).
+- If a test fails in compiled mode but passes in no-compiler mode, treat it as a likely
+  compiler/snapshot-path regression.
+- If a test fails in both modes, treat it as a shared runtime/pipeline gap.
+
+No-compiler mode is retained to validate runtime fundamentals independent of the SWC transform:
+
+1. Raw-props path behavior (`setProperty` semantics through BSI shims)
+2. Generic snapshot fallback behavior (unknown tag create/update without compiled artifacts)
+3. Shared dual-thread runtime stability (commit, patch apply, scratch sync timing)
+
+> Skiplist categories are mode-orthogonal:
+>
+> - `skip_list` + `permanent_skip_list`: shared by both modes
+> - `nocompile_skip_list`: applied only in `preact-upstream`
+> - `compiler_skip_list`: applied only in `preact-upstream-compiled`
+
+## Goals and Non-Goals
+
+### Goal: High-Level Operational Semantics
+
+The purpose of this test suite is to confirm that `@lynx-js/react`'s use of Preact
+preserves the high-level semantics of upstream Preact:
+
+- Component lifecycle (mount, update, unmount)
+- Reconciliation / diffing (keyed reordering, fragment handling, conditional rendering)
+- Context propagation (`createContext`, nested providers, consumer updates)
+- State management (`setState` batching, callbacks, functional updates)
+- Ref forwarding and callback refs
+- Error boundaries
+- `shouldComponentUpdate` / `PureComponent` behavior
+
+Tests that **pass** = alignment confirmed.
+Tests that **fail** = semantic gap that needs investigation.
+
+### Non-Goal: Web DOM Specifics
+
+Lynx is not a web browser. Many Preact tests assert behaviors that depend on web-specific
+APIs and conventions that are **structurally absent** in the Lynx platform. These tests are
+**non-goals** — they don't tell us anything about whether our Preact fork preserves the
+rendering semantics we care about.
+
+Categories of non-goals (managed via `skiplist.json`):
+
+1. **DOM mutation order** (`getLog`/`clearLog`): Tests that assert the exact sequence
+   of `appendChild`/`removeChild`/`insertBefore` calls. The Lynx pipeline routes through
+   a `<page>` root element, producing structurally different (but semantically equivalent)
+   mutation sequences. (~77 tests)
+
+2. **`dangerouslySetInnerHTML`**: Lynx Element PAPI has no `innerHTML` equivalent.
+   (~7 tests)
+
+3. **`MutationObserver`**: Lynx environment does not provide this API. (~2 tests)
+
+4. **Web DOM IDL properties**: Preact's `setProperty()` sets DOM properties like
+   `element.value`, `element.checked`, `element.contentEditable` directly (`dom[prop] = val`).
+   BSI has no IDL property layer, so these take a different code path. (~9 tests)
+
+5. **Boolean-to-attribute serialization**: Web convention (`true->''`, `false->remove`)
+   vs Lynx convention — not relevant to Element PAPI. (~3 tests)
+
+6. **JSON serialization limits**: `NaN`, `BigInt`, objects with custom `toString()` are
+   lost during `JSON.stringify` in the BSI->patch IPC boundary. (~6 tests)
+
+7. **`component.base` / Refs as DOM nodes**: Tests that expect `component.base` or refs
+   to return real DOM nodes. In Lynx, these return BSI (background thread objects). (~14 tests)
+
+8. **Direct DOM mutation**: Tests that mutate jsdom directly and expect Preact to detect
+   the change — BSI has no access to main-thread DOM state. (permanent skip)
+
+9. **Event registration** (`events.test.js`): Tests spy on DOM `element.addEventListener`
+   but BSI event stubs register on the background thread and never reach jsdom. Lynx has
+   its own event model separate from the Web DOM event system. (permanent skip)
+
+10. **Focus / selection** (`focus.test.js`): Tests call `element.focus()` and
+    `setSelectionRange()` via `document.activeElement`. Lynx has its own focus model.
+    (permanent skip, except `should maintain focus when hydrating` which passes in no-compiler mode)
+
+11. **Dual-thread lifecycle DOM timing**: Tests that read DOM state synchronously inside
+    lifecycle hooks (`componentWillMount`, `getSnapshotBeforeUpdate`, etc.). In the dual-thread
+    model the background thread cannot observe main-thread DOM state mid-commit. (~5 tests)
+
+12. **Preact internals** (`getDomSibling.test.js`): Tests import and directly invoke
+    Preact's internal `getDomSibling()` algorithm, walking `dom._children` VNode attachment.
+    Our pipeline renders to `globalThis.__root` (BSI), not to `scratch`, so `scratch._children`
+    is always `undefined`. These test Preact's internal algorithm, not rendering semantics.
+    (excluded entirely)
+
+13. **`replaceNode` parameter** (`replaceNode.test.js`): Tests pre-populate jsdom with
+    raw HTML and then call `render(jsx, container, replaceNode)` to reuse/replace specific
+    nodes. Requires `dom._children` internal VNode state and is web-specific (no SSR reuse
+    in Lynx). (excluded entirely)
+
+## Test Subsetting via `skiplist.json`
+
+Inspired by the Hermes test runner, we use a structured `skiplist.json` to declaratively manage
+which tests are excluded and why.
+
+### Structure
+
+```jsonc
+{
+  // Keyword-based: scan each it() body for these keywords, auto-skip if found
+  "unsupported_features": [
+    {
+      "keywords": ["getLog", "clearLog"],
+      "comment": "DOM mutation order — ...",
+      "skipped_count": 77 // approximate, for documentation
+    }
+  ],
+
+  // Manual: skip specific tests by exact name match
+  "skip_list": [
+    {
+      "tests": ["test name 1", "test name 2"],
+      "comment": "Reason these are skipped"
+    }
+  ],
+
+  // No-compiler-only: fails in preact-upstream, passes in preact-upstream-compiled
+  "nocompile_skip_list": [
+    {
+      "tests": ["test name"],
+      "comment": "No-compile specific gap"
+    }
+  ],
+
+  // Compiler-only: fails in preact-upstream-compiled, passes in preact-upstream
+  "compiler_skip_list": [
+    {
+      "tests": ["test name"],
+      "comment": "Compile-only semantic gap"
+    }
+  ],
+
+  // Permanent: fundamentally incompatible, never expected to pass
+  "permanent_skip_list": [
+    {
+      "tests": ["test name"],
+      "comment": "Reason this will never work"
+    }
+  ]
+}
+```
+
+### How It Works
+
+A Vite transform plugin (`preact-skiplist` in `vitest.config.ts`) processes each test
+file at build time:
+
+1. **Keyword scanning**: For each `it()` block, the plugin extracts the full body text
+   and checks against `unsupported_features[].keywords` using word-boundary regex.
+   If any keyword matches, `it(` is rewritten to `it.skip(`.
+
+2. **Manual skip**: The test name (first string argument to `it()`) is checked against:
+   - shared: `skip_list` + `permanent_skip_list`
+   - no-compiler-only: `nocompile_skip_list` (only in `preact-upstream`)
+   - compiled-only: `compiler_skip_list` (only in `preact-upstream-compiled`)
+     Exact match -> `it.skip(`.
+
+This approach means:
+
+- **No upstream test modifications** — the submodule stays pristine
+- **Self-documenting** — every skip has a `comment` explaining why
+- **Easy to audit** — `skipped_count` shows the blast radius of each keyword
+- **Easy to evolve** — as Lynx gains features, remove entries and watch tests pass
+
+### Decision: `skip_list` vs `nocompile_skip_list` vs `compiler_skip_list` vs `permanent_skip_list`
+
+- **`skip_list`**: Tests that _could_ pass someday if we bridge the gap (e.g., BSI IDL
+  properties, JSON serialization). We keep them separate to track potential future work.
+- **`nocompile_skip_list`**: Tests that fail only in no-compiler mode and already pass
+  in compiled mode.
+- **`permanent_skip_list`**: Tests that are _structurally impossible_ in Lynx (e.g.,
+  direct DOM mutation, `<template>.content`). No point tracking these as future work.
+- **`compiler_skip_list`**: Tests that fail **only in compiled mode**. Applied only when
+  running the `preact-upstream-compiled` project. These are _not_ tag-name issues (real
+  HTML tags are preserved — see Architecture below), but rather structural differences
+  in compiler output:
+  - `<wrapper>` elements around text expressions (~29 tests)
+  - Serialized event attributes in `innerHTML` (~4 tests)
+  - Changed `render()` return value signature (~10 tests)
+  - Boolean attributes baked into `create()` (~4 tests)
+  - DOM IDL properties via `values` array (~3 tests)
+  - Keyed hole operations with changed component identity (~4 tests)
+
+## Architecture
+
+Both modes share the same dual-thread pipeline infrastructure. The difference is
+**what Preact sees as VNodes** and **how attributes reach Element PAPI**.
+
+### Compiled Mode (`preact-upstream-compiled`)
+
+The SWC snapshot transform compiles JSX ahead of time. Instead of raw props, Preact
+sees `{ values: ['foo'] }` and a snapshot type like `"__snapshot_a1b2c3"`. Attribute
+dispatch happens via compiler-generated **`update` functions** instead of `applyViaElementPAPI`.
+
+```
+Build Time (SWC)
+================
+<div className={cls}>hello</div>
+      │
+      ▼  snapshot transform
+_jsx("__snapshot_a1b2c3", { values: [cls] })
++
+registerSnapshot("__snapshot_a1b2c3", {
+  create() { __CreateElement("div", pageId) },  ← real HTML tag preserved!
+  update: [
+    (ctx) => __SetClasses(ctx.__elements[0], ctx.__values[0])
+  ]
+})
+```
+
+```
+ Background Thread                         Main Thread
+ ========================                  ======================
+
+ Preact diff/render                        snapshotPatchApply()
+       │                                         │
+       ▼                                         ▼
+ VNode { type: "__snapshot_a1b2c3",       SnapshotInstance
+         props: { values: [cls] } }        ├─ insertBefore(child)
+       │                                   │   └─ ensureElements()
+       ▼                                   │       └─ snapshot.create()
+ BackgroundSnapshotInstance                │           └─ __CreateElement("div")
+  ├─ setAttribute("values", [cls])         ├─ setAttribute("values", [cls])
+  │   └─ pushes to patch array             │   └─ snapshot.update[0](ctx)
+  │       key="values", val=[cls]          │       └─ __SetClasses(el, cls)
+  └─ (same tree ops as no-compiler)        └─ __elements[0] ← <div> jsdom node
+       │                                         │
+       ▼                                         ▼
+ (same patch IPC as no-compiler)          Element PAPI (jsdom)
+                                           └─ same __CreateElement / __SetClasses / etc.
+```
+
+Key difference: Preact never calls `setProperty(bsi, 'className', cls)`. Instead it
+calls `setAttribute("values", [cls])`, and the **compiler-generated `update` function**
+maps `values[0]` → `__SetClasses(el, cls)`. This is the same path production
+ReactLynx uses.
+
+### No-Compiler Mode (`preact-upstream`) — Runtime Baseline
+
+Preact sees raw props (`{ className: 'foo' }`) and diffs them directly. Attribute
+changes go through BSI shims → patch IPC → `applyViaElementPAPI()` on the main thread.
+This mode is intentionally kept as a runtime baseline and regression-isolation tool.
+
+```
+ Background Thread                         Main Thread
+ ========================                  ======================
+
+ Preact diff/render                        snapshotPatchApply()
+       │                                         │
+       ▼                                         ▼
+ BackgroundSnapshotInstance               SnapshotInstance
+  ├─ insertBefore(child)                  ├─ insertBefore(child)
+  ├─ removeChild(child)                   │   └─ ensureElements()
+  ├─ setAttribute(key, val)               │       └─ __CreateElement(tag)
+  │   └─ pushes to patch array            ├─ setAttribute(key, val)
+  └─ BSI shims:                           │   └─ applyViaElementPAPI(el,k,v)
+      ├─ .style proxy -> SetAttribute     │       ├─ __SetClasses
+      ├─ .addEventListener (stub)         │       ├─ __SetInlineStyles
+      ├─ .removeEventListener (stub)      │       ├─ __SetID / __AddDataset
+      ├─ .dispatchEvent (stub)            │       └─ __SetAttribute
+      └─ .removeAttribute (stub)          └─ __elements[0] ← jsdom node
+       │                                         │
+       ▼                                         ▼
+ __globalSnapshotPatch[]                  Element PAPI (jsdom)
+  [CreateElement, type, id]               ├─ __CreateElement(tag)
+  [InsertBefore, parent, child, before]   ├─ __AppendElement(parent, child)
+  [SetAttribute, id, key, value]          ├─ __InsertElementBefore(...)
+  [RemoveChild, parent, child]            └─ __RemoveElement(parent, child)
+       │                                         │
+       ▼                                         ▼
+ commitPatchUpdate()                      vitest jsdom document
+  └─ JSON.stringify(patchList)                    │
+       │                                         ▼
+       └──── callLepusMethod ──────►       syncSnapshotToScratch()
+              (IPC simulation)              └─ move children from
+              switches thread                  <page> to scratch div
+```
+
+In this mode, `__CreateElement(tag)` receives the **real HTML tag** (e.g. `"div"`)
+because the generic snapshot factory passes through the tag name directly.
+
+### snapshotCreatorMap: Bridging Compiler Definitions to Both Threads
+
+`snapshotCreatorMap` is a **module-level singleton** shared between simulated threads.
+When the SWC-compiled test module is imported, it calls `registerSnapshot()` which
+populates `snapshotCreatorMap["__snapshot_a1b2c3"] = (type) => { ... }`.
+
+The `setup.js` monkey-patch on `snapshotManager.values.has/get` checks
+`snapshotCreatorMap[type]` **before** falling back to the generic snapshot factory:
+
+```
+snapshotManager.values.has(type)
+  → snapshotCreatorMap[type] exists?
+    → YES: invoke creator (registers real snapshot with create/update functions)
+    → NO:  register generic snapshot (create calls __CreateElement(type))
+```
+
+This ensures that in compiled mode, `__CreateElement` receives the **real HTML tag**
+(from the compiler's `create()` function) rather than the snapshot type name.
+
+### Key Design Decisions
+
+1. **Element PAPI dispatch** (not direct jsdom writes): Both modes route attribute
+   changes through Element PAPI (`__SetClasses`, `__SetInlineStyles`, `__SetAttribute`,
+   etc.). No-compiler mode does this via `applyViaElementPAPI()`. Compiled mode does
+   this via compiler-generated `update` functions. Both exercise the real
+   SI->Element PAPI->jsdom path.
+
+2. **Shared jsdom instance**: Element PAPI and the test scratch container use the
+   same jsdom document (vitest's built-in jsdom environment). This allows direct
+   DOM node moves between the `<page>` element and the test's scratch div.
+
+3. **Generic Snapshot factory** (no-compiler mode): Preact tests use arbitrary HTML
+   tags (`div`, `span`, `p`, etc.) which don't have compiler-generated definitions.
+   A generic snapshot is auto-registered for any unknown element type via
+   monkey-patching `snapshotManager.values.has/get`.
+
+4. **Compiler snapshot priority** (compiled mode): When `snapshotCreatorMap` has an
+   entry for a type, the monkey-patch invokes the compiler's creator instead of
+   generating a generic snapshot. This preserves real HTML tags and typed `update`
+   functions.
+
+5. **BSI shims** (no-compiler mode only): Preact's `setProperty()` tries
+   `dom[name] = value` first, but since `'className' in bsi === false`, it falls
+   through to `dom.setAttribute(name, value)`. Only `style`, events, and
+   `removeAttribute` need shims. In compiled mode these shims are not exercised
+   because Preact only sets `values` — never individual props.
+
+6. **Render transform**: A Vite plugin rewrites `render(` -> `__pipelineRender(` in
+   test files so that Preact's render calls go through the full dual-thread pipeline
+   instead of directly to DOM. Shared by both modes.
+
+7. **Option name bridging**: Upstream Preact uses `options._commit` while the
+   ReactLynx-forked Preact uses `options.__c` (mangled). A `defineProperty`
+   getter/setter bridges the two.
+
+### Vite Plugin Pipeline
+
+The two modes share most plugins but differ in whether the SWC snapshot transform runs:
+
+**Compiled mode** (`preact-upstream-compiled`):
+
+1. `preact-snapshot-transform` — JSX → snapshot definitions + `_jsx()` calls (SWC)
+2. `preact-pipeline-render` — `render(` → `__pipelineRender(`
+3. `preact-skiplist` — `it(` → `it.skip(` (shared + `compiler_skip_list`)
+4. esbuild — no-op (no JSX remaining after SWC)
+
+**No-compiler mode** (`preact-upstream`):
+
+1. `preact-pipeline-render` — `render(` → `__pipelineRender(`
+2. `preact-skiplist` — `it(` → `it.skip(` (shared + `nocompile_skip_list`)
+3. esbuild JSX transform — JSX → `createElement()` calls
+
+## Managing the Preact submodule (upstream)
+
+The `preact/` directory is a **git submodule** that points to the Lynx fork of Preact
+(branch `lynx/v10.24.x`). You must initialize or update it before running tests.
+
+| Script               | Description                                                                                                       |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `pnpm preact:init`   | Initialize the submodule (first-time clone or after a fresh repo clone). Run from this package or from repo root. |
+| `pnpm preact:update` | Update the submodule to the latest commit on the tracked branch.                                                  |
+| `pnpm preact:status` | Show the current submodule commit and whether it is dirty.                                                        |
+
+**First-time setup** (from repo root or from this package):
+
+```bash
+# From this package
+pnpm preact:init
+
+# Or from repo root
+git submodule update --init packages/react/preact-upstream-tests/preact
+```
+
+**Clone the whole repo with submodules:**
+
+```bash
+git clone --recurse-submodules <repo-url>
+```
+
+If you already cloned without `--recurse-submodules`, run `pnpm preact:init` once from
+`packages/react/preact-upstream-tests` (or the equivalent `git submodule update --init`
+from repo root).
+
+**Updating upstream:** To pull the latest Preact changes from the Lynx fork:
+
+```bash
+pnpm preact:update
+```
+
+Then run tests and commit the updated submodule reference if needed.
+
+## Running
+
+Ensure the Preact submodule is initialized (see above), then from this package:
+
+```bash
+# Primary signal (recommended in daily work)
+pnpm test:compiled
+
+# Baseline / regression isolation
+pnpm test:no-compile
+
+# Full matrix (both modes)
+pnpm test
+```
+
+Recommended workflow:
+
+1. Run `pnpm test:compiled` first.
+2. If something fails, run `pnpm test:no-compile` to determine whether the issue is
+   compiler-path-specific or shared runtime behavior.
+3. Use `SKIPLIST_ONLY` to isolate specific skip groups while investigating.
+
+### Investigating Skipped Tests (`SKIPLIST_ONLY`)
+
+To run **only** the skipped tests (instead of skipping them), use the `SKIPLIST_ONLY`
+environment variable. This inverts the skiplist plugin: specified tests run normally,
+everything else is skipped.
+
+```bash
+# Run all tests from skip_list + nocompile_skip_list (no-compiler mode)
+pnpm test:skipped
+
+# Run all tests from skip_list + compiler_skip_list (compiled mode)
+pnpm test:skipped:compiled
+
+# Run a specific category
+SKIPLIST_ONLY=permanent_skip_list pnpm test:no-compile
+
+# Run a specific group within a category (0-indexed)
+SKIPLIST_ONLY=skip_list:0 pnpm test:no-compile     # NaN/BigInt serialization group
+SKIPLIST_ONLY=skip_list:3 pnpm test:no-compile     # component.base semantics group
+
+# Run unsupported_features keyword group
+SKIPLIST_ONLY=unsupported_features:2 pnpm test:no-compile  # dangerouslySetInnerHTML
+
+# Run no-compile-only group
+SKIPLIST_ONLY=nocompile_skip_list:1 pnpm test:no-compile   # boolean attribute semantics
+
+# Combine multiple categories/groups (comma-separated)
+SKIPLIST_ONLY=skip_list:0,skip_list:1 pnpm test:no-compile
+SKIPLIST_ONLY=skip_list,nocompile_skip_list pnpm test:no-compile
+SKIPLIST_ONLY=skip_list,permanent_skip_list pnpm test:no-compile
+```
+
+**Valid categories**: `unsupported_features`, `skip_list`, `nocompile_skip_list`, `permanent_skip_list`, `compiler_skip_list`
+
+Each category corresponds to a top-level key in `skiplist.json`. The optional `:N` suffix
+selects a specific group (0-indexed array position) within that category.
+
+Use this to investigate _why_ tests are skipped — run them, see the actual failure output,
+and determine if the gap can be bridged.
+
+**Tip for AI agents**: When investigating skipped tests, prefer running
+`SKIPLIST_ONLY=skip_list:N pnpm test:no-compile` and reading the terminal output over
+manually reading test source files. The test runner output shows exact assertion failures
+with expected vs actual values, which is far more informative (and cheaper on context)
+than trying to trace through test code manually. Use the group index (`:N`) to narrow
+down to a small batch of related failures.
diff --git a/packages/react/preact-upstream-tests/package.json b/packages/react/preact-upstream-tests/package.json
new file mode 100644
index 0000000000..ad7b921f5a
--- /dev/null
+++ b/packages/react/preact-upstream-tests/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@lynx-js/preact-upstream-tests",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "preact:init": "cd ../../.. && git submodule update --init packages/react/preact-upstream-tests/preact",
+    "preact:status": "cd ../../.. && git submodule status packages/react/preact-upstream-tests/preact",
+    "preact:update": "cd ../../.. && git submodule update --remote packages/react/preact-upstream-tests/preact",
+    "test": "vitest run --workspace vitest.workspace.ts",
+    "test:compiled": "vitest run --workspace vitest.workspace.ts --project preact-upstream-compiled",
+    "test:no-compile": "vitest run --workspace vitest.workspace.ts --project preact-upstream",
+    "test:report": "node report.mjs",
+    "test:skipped": "SKIPLIST_ONLY=skip_list,nocompile_skip_list vitest run --workspace vitest.workspace.ts --project preact-upstream",
+    "test:skipped:compiled": "SKIPLIST_ONLY=skip_list,compiler_skip_list vitest run --workspace vitest.workspace.ts --project preact-upstream-compiled"
+  },
+  "devDependencies": {
+    "@lynx-js/react": "workspace:*",
+    "@lynx-js/testing-environment": "workspace:*",
+    "chai": "^5.2.0",
+    "jsdom": "^26.1.0",
+    "sinon": "^19.0.2",
+    "sinon-chai": "^4.0.0",
+    "vitest": "^3.2.4"
+  }
+}
diff --git a/packages/react/preact-upstream-tests/preact b/packages/react/preact-upstream-tests/preact
new file mode 160000
index 0000000000..4af811515e
--- /dev/null
+++ b/packages/react/preact-upstream-tests/preact
@@ -0,0 +1 @@
+Subproject commit 4af811515e30d3d6a45fb638f3fb6bd7a0b053d6
diff --git a/packages/react/preact-upstream-tests/report.mjs b/packages/react/preact-upstream-tests/report.mjs
new file mode 100644
index 0000000000..aa0dc87845
--- /dev/null
+++ b/packages/react/preact-upstream-tests/report.mjs
@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+/**
+ * report.mjs — pass/skip dashboard for preact-upstream-tests.
+ *
+ * Runs both vitest projects, parses per-file summaries, and prints a grouped
+ * coverage table.  Progress goes to stderr; the table goes to stdout so it can
+ * be piped / redirected freely.
+ *
+ * Usage:
+ *   pnpm test:report
+ *   pnpm test:report > report.txt
+ */
+
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ── Groupings (order matters — first match wins) ──────────────────────────────
+const GROUPS = [
+  {
+    label: 'Core Reconciliation',
+    match: f => /\/(?:render|components|fragments|keys)\.test\.js$/.test(f),
+  },
+  {
+    label: 'Lifecycle Methods',
+    match: f => f.includes('/lifecycles/'),
+  },
+  {
+    label: 'Hooks',
+    match: f => f.includes('/hooks/test/browser/'),
+  },
+  {
+    label: 'API & Utilities',
+    match: () => true, // catch-all
+  },
+];
+
+// Files excluded from the vitest run (not counted in dashboard totals)
+const EXCLUDED = [
+  {
+    file: 'getDomSibling.test.js',
+    tests: 18,
+    category: 'test_methodology',
+    reason: 'Preact internals: _children VNode attachment',
+  },
+  { file: 'refs.test.js', tests: 26, category: 'dual_thread', reason: 'BSI refs ≠ DOM nodes (deferred)' },
+  {
+    file: 'replaceNode.test.js',
+    tests: 11,
+    category: 'test_methodology',
+    reason: 'SSR replaceNode / pre-populated DOM',
+  },
+];
+
+// Skiplist (with category tags) — used for attribution
+const skiplist = JSON.parse(readFileSync(path.resolve(__dirname, 'skiplist.json'), 'utf-8'));
+
+const CATEGORY_LABELS = {
+  lynx_not_web: 'Lynx ≠ Web',
+  dual_thread: 'Dual-thread / IPC',
+  test_methodology: 'Test methodology',
+};
+
+// ── Run one vitest project and return per-file stats ──────────────────────────
+function runProject(project) {
+  process.stderr.write(`  ${project.padEnd(32)} …`);
+  const r = spawnSync(
+    'npx',
+    ['vitest', 'run', '--workspace', 'vitest.workspace.ts', '--project', project],
+    { cwd: __dirname, encoding: 'utf-8', maxBuffer: 16 * 1024 * 1024 },
+  );
+  const output = (r.stdout ?? '') + (r.stderr ?? '');
+  const stats = parse(output);
+  const total = Object.values(stats).reduce((a, v) => a + v.total, 0);
+  const pass = Object.values(stats).reduce((a, v) => a + v.pass, 0);
+  process.stderr.write(` done  (${pass}/${total} pass)\n`);
+  return stats;
+}
+
+// ── Parse vitest verbose output into { file → {total, pass, skip} } ──────────
+function parse(raw) {
+  // Strip ANSI colour codes first
+  // eslint-disable-next-line no-control-regex
+  const clean = raw.replace(/\u001b\[[0-9;]*m/g, '');
+
+  // Matches lines like:
+  //   ✓ |project| preact/…/file.test.js (12 tests | 4 skipped) 30ms
+  //   ↓ |project| preact/…/file.test.js (11 tests | 11 skipped)
+  //   ✓ |project| preact/…/file.test.js (1 test) 6ms
+  const re = /\|[^|]+\|\s+(preact[^\s(]+\.test\.js)\s+\((\d+) tests?(?:\s*\|\s*(\d+) skipped)?\)/g;
+  const stats = {};
+  for (const m of clean.matchAll(re)) {
+    const file = m[1].trim();
+    const total = +m[2];
+    const skip = m[3] ? +m[3] : 0;
+    stats[file] = { total, skip, pass: total - skip };
+  }
+  return stats;
+}
+
+// ── Formatting helpers ────────────────────────────────────────────────────────
+const groupOf = f => GROUPS.find(g => g.match(f));
+const sum = (obj, k) => Object.values(obj).reduce((a, v) => a + v[k], 0);
+const pct = (n, d) => d ? `${Math.round(n * 100 / d)}%` : '—';
+const lp = (s, n) => String(s).padStart(n);
+const rp = (s, n) => String(s).padEnd(n);
+const shortName = f =>
+  f
+    .replace('preact/hooks/test/browser/', 'hooks/')
+    .replace('preact/test/browser/lifecycles/', 'lifecycles/')
+    .replace('preact/test/browser/', '');
+
+const out = (...a) => process.stdout.write(a.join('') + '\n');
+
+// ── Collect data ──────────────────────────────────────────────────────────────
+process.stderr.write('\nCollecting results:\n');
+const nc = runProject('preact-upstream');
+const co = runProject('preact-upstream-compiled');
+const files = [...new Set([...Object.keys(nc), ...Object.keys(co)])].sort();
+process.stderr.write('\n');
+
+// ── Overall totals ────────────────────────────────────────────────────────────
+const ncT = sum(nc, 'total'), ncP = sum(nc, 'pass'), ncS = sum(nc, 'skip');
+const coT = sum(co, 'total'), coP = sum(co, 'pass'), coS = sum(co, 'skip');
+const exTests = EXCLUDED.reduce((a, e) => a + e.tests, 0);
+
+const LINE = '─'.repeat(78);
+out(LINE);
+out('  Preact Upstream Tests — Coverage Dashboard');
+out(LINE);
+out(`  Excluded (not counted): ${EXCLUDED.map(e => `${e.file} (${e.tests})`).join(', ')} = ${exTests}×2 test cases`);
+out();
+
+out('OVERALL');
+out(`  ${''.padEnd(22)}  ${'no-compile'.padEnd(20)}  compiled`);
+out(`  ${rp('Total', 22)}  ${lp(ncT, 20)}  ${coT}`);
+out(`  ${rp('Pass', 22)}  ${rp(`${ncP}  (${pct(ncP, ncT)})`, 20)}  ${coP}  (${pct(coP, coT)})`);
+out(`  ${rp('Skip', 22)}  ${rp(`${ncS}  (${pct(ncS, ncT)})`, 20)}  ${coS}  (${pct(coS, coT)})`);
+out();
+
+// ── By group ──────────────────────────────────────────────────────────────────
+out(`  ${rp('GROUP', 22)}  ${rp('total', 6)}  ${rp('no-compile  pass/skip/%', 26)}  compiled  pass/skip/%`);
+out('  ' + '─'.repeat(74));
+
+for (const { label } of GROUPS) {
+  const gf = files.filter(f => groupOf(f)?.label === label);
+  if (gf.length === 0) continue;
+
+  const gt = gf.reduce((a, f) => a + (nc[f]?.total ?? co[f]?.total ?? 0), 0);
+  const ncp = gf.reduce((a, f) => a + (nc[f]?.pass ?? 0), 0);
+  const ncs = gf.reduce((a, f) => a + (nc[f]?.skip ?? 0), 0);
+  const cop = gf.reduce((a, f) => a + (co[f]?.pass ?? 0), 0);
+  const cos = gf.reduce((a, f) => a + (co[f]?.skip ?? 0), 0);
+
+  out(
+    `  ${rp(label, 22)}  ${lp(gt, 6)}  `
+      + `${rp(`${ncp}/${ncs}  (${pct(ncp, gt)})`, 26)}  `
+      + `${cop}/${cos}  (${pct(cop, gt)})`,
+  );
+}
+out();
+
+// ── Per-file detail ───────────────────────────────────────────────────────────
+out('PER FILE  (pass/skip/%)');
+out('  ' + '─'.repeat(74));
+
+for (const { label } of GROUPS) {
+  const gf = files.filter(f => groupOf(f)?.label === label).sort();
+  if (gf.length === 0) continue;
+  out(`\n  ── ${label}`);
+  for (const file of gf) {
+    const ns = nc[file] ?? { pass: 0, skip: 0, total: 0 };
+    const cs = co[file] ?? { pass: 0, skip: 0, total: 0 };
+    const tot = ns.total || cs.total;
+    const ncStr = `${lp(ns.pass, 3)}/${lp(ns.skip, 3)}  ${lp(pct(ns.pass, tot), 4)}`;
+    const coStr = `${lp(cs.pass, 3)}/${lp(cs.skip, 3)}  ${lp(pct(cs.pass, tot), 4)}`;
+    out(`  ${rp(shortName(file), 42)}  nc: ${ncStr}   co: ${coStr}`);
+  }
+}
+out();
+
+// ── Excluded files ────────────────────────────────────────────────────────────
+out('EXCLUDED FILES  (vitest exclude — not reflected above)');
+out('  ' + '─'.repeat(74));
+for (const { file, tests, category, reason } of EXCLUDED) {
+  out(`  ${rp(file, 32)}  ${lp(tests, 2)} tests/mode  [${CATEGORY_LABELS[category]}]  ${reason}`);
+}
+out(`\n  Total: ${exTests} tests × 2 modes = ${exTests * 2} test cases`);
+out();
+
+// ── Skip attribution ──────────────────────────────────────────────────────────
+// For named entries: count test names × mode factor (1 per mode the list applies to).
+// For unsupported_features: all lynx_not_web, inferred as actual_skip − named_skip.
+// Excluded files are added separately using their own category tags.
+
+function countByCat(entries, factor = 1) {
+  const acc = {};
+  for (const entry of (entries ?? [])) {
+    const cat = entry.category;
+    acc[cat] = (acc[cat] ?? 0) + entry.tests.length * factor;
+  }
+  return acc;
+}
+
+function mergeCounts(...maps) {
+  const out = {};
+  for (const m of maps) for (const [k, v] of Object.entries(m)) out[k] = (out[k] ?? 0) + v;
+  return out;
+}
+
+// Named skips per mode (each test name counted once per mode the list applies to)
+const ncNamedCats = mergeCounts(
+  countByCat(skiplist.skip_list),
+  countByCat(skiplist.permanent_skip_list),
+  countByCat(skiplist.nocompile_skip_list),
+);
+const coNamedCats = mergeCounts(
+  countByCat(skiplist.skip_list),
+  countByCat(skiplist.permanent_skip_list),
+  countByCat(skiplist.compiler_skip_list),
+);
+
+// unsupported_features contribution = actual skip − named skips (all lynx_not_web)
+const ncNamedTotal = Object.values(ncNamedCats).reduce((a, v) => a + v, 0);
+const coNamedTotal = Object.values(coNamedCats).reduce((a, v) => a + v, 0);
+ncNamedCats.lynx_not_web = (ncNamedCats.lynx_not_web ?? 0) + (ncS - ncNamedTotal);
+coNamedCats.lynx_not_web = (coNamedCats.lynx_not_web ?? 0) + (coS - coNamedTotal);
+
+// Add excluded files
+for (const { tests, category } of EXCLUDED) {
+  ncNamedCats[category] = (ncNamedCats[category] ?? 0) + tests;
+  coNamedCats[category] = (coNamedCats[category] ?? 0) + tests;
+}
+
+const ncGrand = ncS + exTests;
+const coGrand = coS + exTests;
+
+out('SKIP ATTRIBUTION  (skipped + excluded, per mode)');
+out(`  Note: unsupported_features counts inferred (actual skip − named skip), all Lynx ≠ Web`);
+out('  ' + '─'.repeat(74));
+out(`  ${rp('Category', 22)}  ${rp('no-compile', 16)}  ${rp('compiled', 16)}  combined`);
+out('  ' + '─'.repeat(74));
+
+for (const [cat, label] of Object.entries(CATEGORY_LABELS)) {
+  const nc_ = ncNamedCats[cat] ?? 0;
+  const co_ = coNamedCats[cat] ?? 0;
+  const total_ = nc_ + co_;
+  out(
+    `  ${rp(label, 22)}  `
+      + `${rp(`${nc_}  (${pct(nc_, ncGrand)})`, 16)}  `
+      + `${rp(`${co_}  (${pct(co_, coGrand)})`, 16)}  `
+      + `${total_}  (${pct(total_, ncGrand + coGrand)})`,
+  );
+}
+
+out('  ' + '─'.repeat(74));
+out(`  ${rp('Total not running', 22)}  ${rp(`${ncGrand}`, 16)}  ${rp(`${coGrand}`, 16)}  ${ncGrand + coGrand}`);
+out(`  ${rp('  of which: skipped', 22)}  ${rp(`${ncS}`, 16)}  ${rp(`${coS}`, 16)}  ${ncS + coS}`);
+out(`  ${rp('  of which: excluded', 22)}  ${rp(`${exTests}`, 16)}  ${rp(`${exTests}`, 16)}  ${exTests * 2}`);
+out(LINE);
diff --git a/packages/react/preact-upstream-tests/setup-compiled.js b/packages/react/preact-upstream-tests/setup-compiled.js
new file mode 100644
index 0000000000..37d3a0051e
--- /dev/null
+++ b/packages/react/preact-upstream-tests/setup-compiled.js
@@ -0,0 +1,109 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+/* global Element */
+/**
+ * Preact Upstream Tests — Compiled Mode Setup
+ *
+ * In compiled mode, the SWC snapshot compiler transforms JSX into snapshot
+ * elements with `values` arrays. Preact sees `{ values: [cls, handler] }`
+ * instead of raw props like `{ className: cls, onClick: handler }`.
+ *
+ * This means:
+ * - Preact's diff/props.js never calls setProperty(bsi, 'className', ...)
+ *   → no BSI style/event/removeAttribute shims needed
+ * - Compiler-generated update[] functions dispatch to Element PAPI directly
+ *   → no applyViaElementPAPI() or SI.setAttribute override needed
+ *
+ * The only addition is a minimal removeAttribute shim on BSI — Preact's
+ * setProperty calls dom.removeAttribute() when removing stale props (values,
+ * __0, key, etc.), and BSI doesn't have this method natively.
+ *
+ * Generic snapshot registration is handled by setup-shared.js.
+ */
+
+import { lynxTestingEnv } from './setup-shared.js';
+
+// --- Wrapper transparency shim ---
+// The compiler wraps text expressions in <wrapper> elements. Upstream Preact
+// tests assert on innerHTML and expect bare text. Patch the innerHTML getter
+// to strip <wrapper>/<\/wrapper> tags so these tests pass.
+
+const _innerHTMLDesc = Object.getOwnPropertyDescriptor(Element.prototype, 'innerHTML');
+Object.defineProperty(Element.prototype, 'innerHTML', {
+  get() {
+    return _innerHTMLDesc.get.call(this).replace(/<\/?wrapper>/g, '');
+  },
+  set(v) {
+    _innerHTMLDesc.set.call(this, v);
+  },
+  configurable: true,
+});
+
+// --- Boolean attribute shim ---
+// The compiler generates __SetAttribute(el, "translate", false). Element PAPI
+// JSON.stringify's booleans, producing translate="false" instead of translate="no".
+// Wrap __SetAttribute on the main thread globals to handle boolean semantics.
+// Must patch mainThread.globalThis because switchToMainThread() copies these
+// onto globalThis, overwriting any direct globalThis patches.
+
+function wrapSetAttribute(target) {
+  const orig = target.__SetAttribute;
+  if (!orig || orig.__booleanShimmed) return;
+  target.__SetAttribute = function(el, key, value) {
+    if (key === 'translate') {
+      return orig.call(this, el, key, value === true ? 'yes' : (value === false ? 'no' : value));
+    }
+    if (key === 'popover') {
+      if (value === false) return orig.call(this, el, key, null);
+      if (value === true) return orig.call(this, el, key, '');
+      return orig.call(this, el, key, value);
+    }
+    return orig.call(this, el, key, value);
+  };
+  target.__SetAttribute.__booleanShimmed = true;
+}
+
+// Patch the current main thread globals:
+wrapSetAttribute(lynxTestingEnv.mainThread.globalThis);
+
+// Re-patch whenever main thread globals are re-injected:
+const _origOnInjectMT = globalThis.onInjectMainThreadGlobals;
+globalThis.onInjectMainThreadGlobals = (target) => {
+  _origOnInjectMT(target);
+  wrapSetAttribute(target);
+};
+
+// --- Minimal BSI shim: removeAttribute only ---
+// Preact calls dom.removeAttribute(name) when a prop is removed. BSI doesn't
+// have this method. Convert to setAttribute(key, null) which generates a patch.
+
+function addRemoveAttribute(bsi) {
+  bsi.removeAttribute = function(key) {
+    bsi.setAttribute(key, null);
+  };
+  return bsi;
+}
+
+const _origOnInjectBG = globalThis.onInjectBackgroundThreadGlobals;
+globalThis.onInjectBackgroundThreadGlobals = (target) => {
+  _origOnInjectBG(target);
+  wrapBgDocumentMinimal(target._document);
+};
+// Also patch the already-initialized background thread _document:
+wrapBgDocumentMinimal(lynxTestingEnv.backgroundThread.globalThis._document);
+
+function wrapBgDocumentMinimal(doc) {
+  const origCE = doc.createElement;
+  const origCENS = doc.createElementNS;
+  const origCTN = doc.createTextNode;
+  doc.createElement = function(type) {
+    return addRemoveAttribute(origCE(type));
+  };
+  doc.createElementNS = function(_ns, type) {
+    return addRemoveAttribute(origCENS(_ns, type));
+  };
+  doc.createTextNode = function(text) {
+    return addRemoveAttribute(origCTN(text));
+  };
+}
diff --git a/packages/react/preact-upstream-tests/setup-nocompile.js b/packages/react/preact-upstream-tests/setup-nocompile.js
new file mode 100644
index 0000000000..3855c6ceb1
--- /dev/null
+++ b/packages/react/preact-upstream-tests/setup-nocompile.js
@@ -0,0 +1,141 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+/**
+ * Preact Upstream Tests — Non-Compiled Mode Setup
+ *
+ * Adds BSI shims and generic snapshot registration for running upstream Preact
+ * tests without the SWC snapshot compiler. In this mode, Preact sees raw props
+ * (e.g. { className: 'foo' }) and its diff/props.js calls DOM-like APIs on BSI
+ * (style, addEventListener, removeAttribute), which must be shimmed.
+ *
+ * The string-keyed attributes from BSI are dispatched to Element PAPI via
+ * applyProp(), mirroring the updateSpread() logic in the runtime.
+ */
+
+import { applyProp } from '@lynx-js/testing-environment';
+
+import { SnapshotInstance, lynxTestingEnv } from './setup-shared.js';
+
+// --- 1. Shim BSI for DOM property compatibility ---
+// Preact's diff/props.js sets properties via:
+//   1. style: dom.style.cssText = v → needs .style proxy
+//   2. events: dom._listeners + addEventListener → needs stubs
+//   3. dom.removeAttribute(name) → needs stub
+//   4. other: dom[name] = v → 'name' in bsi === false → falls to bsi.setAttribute()
+
+function shimBSI(bsi) {
+  // Style proxy
+  const styleStore = {};
+  bsi.style = new Proxy(styleStore, {
+    set(target, prop, value) {
+      target[prop] = value;
+      if (prop === 'cssText') {
+        bsi.setAttribute('style:cssText', value);
+      }
+      return true;
+    },
+    get(target, prop) {
+      if (prop === 'setProperty') {
+        return (k, v) => {
+          target[k] = v;
+          bsi.setAttribute('style:' + k, v);
+        };
+      }
+      if (prop === 'removeProperty') {
+        return (k) => {
+          const old = target[k];
+          delete target[k];
+          return old;
+        };
+      }
+      if (prop === 'getPropertyValue') {
+        return (k) => target[k] || '';
+      }
+      if (prop === 'cssText') return target.cssText || '';
+      if (prop === 'length') return Object.keys(target).filter(k => k !== 'cssText').length;
+      return target[prop] === undefined ? '' : target[prop];
+    },
+  });
+
+  // Event listener stubs
+  bsi._listeners = {};
+  bsi.addEventListener = function(type, handler) {
+    (this._listeners[type] || (this._listeners[type] = [])).push(handler);
+  };
+  bsi.removeEventListener = function(type, handler) {
+    const list = this._listeners[type];
+    if (list) this._listeners[type] = list.filter(h => h !== handler);
+  };
+  bsi.dispatchEvent = function(event) {
+    const list = this._listeners[event.type];
+    if (list) list.forEach(h => typeof h === 'function' ? h(event) : h.handleEvent(event));
+    return true;
+  };
+
+  // removeAttribute — Preact calls this to clear falsy attrs
+  bsi.removeAttribute = function(key) {
+    bsi.setAttribute(key, null);
+  };
+
+  return bsi;
+}
+
+// --- 2. Override SnapshotInstance.setAttribute for generic snapshots ---
+// Forward string-keyed attributes to the actual jsdom element via Element PAPI.
+
+const _origSISetAttribute = SnapshotInstance.prototype.setAttribute;
+SnapshotInstance.prototype.setAttribute = function(key, value) {
+  _origSISetAttribute.call(this, key, value);
+
+  if (
+    typeof key === 'string'
+    && key !== 'values'
+    && this.__snapshot_def?.__isGeneric
+    && this.__elements?.[0]
+  ) {
+    applyProp(this.__elements[0], key, value);
+  }
+};
+
+// After ensureElements() creates jsdom elements, apply any pending __extraProps
+// that were set before the element was materialized.
+const _origEnsureElements = SnapshotInstance.prototype.ensureElements;
+SnapshotInstance.prototype.ensureElements = function() {
+  _origEnsureElements.call(this);
+  if (this.__snapshot_def?.__isGeneric && this.__extraProps && this.__elements?.[0]) {
+    const el = this.__elements[0];
+    for (const [key, value] of Object.entries(this.__extraProps)) {
+      applyProp(el, key, value);
+    }
+  }
+};
+
+// --- 3. Wrap background thread hooks to inject BSI shims ---
+// vitest-global-setup.js creates _document.createElement that returns plain BSI;
+// upstream Preact's setProperty needs .style, .addEventListener, .removeAttribute.
+
+const _origOnInjectBG = globalThis.onInjectBackgroundThreadGlobals;
+globalThis.onInjectBackgroundThreadGlobals = (target) => {
+  _origOnInjectBG(target);
+  wrapBgDocumentWithShims(target._document);
+};
+// Also patch the already-initialized background thread _document:
+wrapBgDocumentWithShims(lynxTestingEnv.backgroundThread.globalThis._document);
+
+function wrapBgDocumentWithShims(doc) {
+  const origCE = doc.createElement;
+  const origCENS = doc.createElementNS;
+  const origCTN = doc.createTextNode;
+  doc.createElement = function(type) {
+    return shimBSI(origCE(type));
+  };
+  doc.createElementNS = function(_ns, type) {
+    return shimBSI(origCENS(_ns, type));
+  };
+  doc.createTextNode = function(text) {
+    const i = origCTN(text);
+    shimBSI(i);
+    return i;
+  };
+}
diff --git a/packages/react/preact-upstream-tests/setup-shared.js b/packages/react/preact-upstream-tests/setup-shared.js
new file mode 100644
index 0000000000..a00e530fea
--- /dev/null
+++ b/packages/react/preact-upstream-tests/setup-shared.js
@@ -0,0 +1,248 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+/* global __CreateRawText, __CreateElement */
+/**
+ * Preact Upstream Tests — Shared E2E Pipeline Setup
+ *
+ * Common setup for both compiled and non-compiled modes. Initializes the
+ * dual-thread Lynx testing environment and the pipeline render wrapper.
+ *
+ * Mode-specific setup is in setup-nocompile.js and setup-compiled.js.
+ */
+
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import { chai, describe, expect } from 'vitest';
+
+import { LynxTestingEnv } from '@lynx-js/testing-environment';
+
+import { options, render as preactRender } from './preact/src/index.js';
+
+// --- 1. Initialize the dual-thread Lynx testing environment ---
+
+// Use vitest's jsdom environment (the global `window`) so that Element PAPI
+// creates nodes in the same document as the test's scratch container.
+// LynxTestingEnv expects a JSDOM-like object with `.window`.
+const jsdomShim = { window: globalThis.window ?? globalThis };
+const lynxTestingEnv = new LynxTestingEnv(jsdomShim);
+globalThis.lynxTestingEnv = lynxTestingEnv;
+
+// --- 2. Reuse the standard ReactLynx testing pipeline setup ---
+// vitest-global-setup.js handles: runtime imports, injectCalledByNative(),
+// injectUpdateMainThread(), replaceCommitHook(), all hook definitions
+// (onInjectMainThreadGlobals, onInjectBackgroundThreadGlobals,
+// onSwitchedToMainThread/BackgroundThread, onResetLynxTestingEnv),
+// and initial hook invocation.
+await import('../testing-library/src/vitest-global-setup.js');
+
+// --- 3. Import remaining runtime internals needed for custom logic ---
+
+const { initGlobalSnapshotPatch } = await import('../runtime/lib/lifecycle/patch/snapshotPatch.js');
+const { injectTt } = await import('../runtime/lib/lynx/tt.js');
+const { addCtxNotFoundEventListener } = await import('../runtime/lib/lifecycle/patch/error.js');
+const {
+  SnapshotInstance,
+  snapshotManager,
+  snapshotCreatorMap,
+  snapshotInstanceManager,
+  setupPage,
+} = await import('../runtime/lib/snapshot.js');
+const { DynamicPartType } = await import('../runtime/lib/snapshot/dynamicPartType.js');
+
+// --- 4. Register generic snapshots for arbitrary element types ---
+// Preact upstream tests use HTML tags (div, span, p, etc.) which don't have
+// compiler-generated Snapshot definitions. In compiled mode, the compiler
+// generates snapshot hash types whose creators are in snapshotCreatorMap.
+// We intercept snapshotManager.values so that:
+//   1. Compiler-registered creators (snapshotCreatorMap) are called first
+//   2. Unknown types get a generic snapshot as fallback
+//
+// The __isGeneric marker is used by the non-compiled mode's SI.setAttribute
+// override to know when to dispatch string-keyed attrs to Element PAPI.
+
+function createGenericSnapshot(type) {
+  const isText = type === null || type === 'null';
+  return {
+    create(ctx) {
+      if (isText) {
+        return [__CreateRawText(ctx.__values?.[0] ?? '')];
+      }
+      return [__CreateElement(ctx.type, 0)];
+    },
+    update: isText
+      ? [
+        function updateTextContent(si) {
+          const el = si.__elements?.[0];
+          if (el) el.data = si.__values?.[0] ?? '';
+        },
+      ]
+      : null,
+    slot: [[DynamicPartType.Children, 0]],
+    isListHolder: false,
+    __isGeneric: true,
+  };
+}
+
+const _origHas = snapshotManager.values.has.bind(snapshotManager.values);
+const _origGet = snapshotManager.values.get.bind(snapshotManager.values);
+
+snapshotManager.values.has = function(type) {
+  if (_origHas(type)) return true;
+  if (typeof type === 'string' || type === null) {
+    if (snapshotCreatorMap[type]) {
+      snapshotCreatorMap[type](type);
+      return _origHas(type);
+    }
+    snapshotManager.values.set(type, createGenericSnapshot(type));
+    return true;
+  }
+  return false;
+};
+
+snapshotManager.values.get = function(type) {
+  const existing = _origGet(type);
+  if (existing) return existing;
+  if (typeof type === 'string' || type === null) {
+    if (snapshotCreatorMap[type]) {
+      snapshotCreatorMap[type](type);
+      const compiled = _origGet(type);
+      if (compiled) return compiled;
+    }
+    const snapshot = createGenericSnapshot(type);
+    snapshotManager.values.set(type, snapshot);
+    return snapshot;
+  }
+  return undefined;
+};
+
+// --- 5. Override onResetLynxTestingEnv ---
+// Skip worklet cleanup (not needed for upstream tests).
+globalThis.onResetLynxTestingEnv = () => {
+  lynxTestingEnv.switchToBackgroundThread();
+  injectTt();
+  addCtxNotFoundEventListener();
+};
+
+// Ensure background thread is active and runtime is initialized.
+lynxTestingEnv.switchToBackgroundThread();
+injectTt();
+addCtxNotFoundEventListener();
+
+// --- 6. Pipeline render setup ---
+// Upstream tests call render(jsx, scratch). We redirect to the dual-thread pipeline.
+//
+// Bridge mangled → unmangled option names:
+// The ReactLynx-forked Preact uses `options.__c` for commit, but upstream
+// Preact uses `options._commit`. replaceCommitHook() hooks `__c`, so we
+// alias `_commit` → the hooked `__c` function.
+
+let _lastScratch = null;
+
+Object.defineProperty(options, '_commit', {
+  get() {
+    return this.__c;
+  },
+  set(v) {
+    this.__c = v;
+  },
+  configurable: true,
+});
+
+// No custom commit hook needed: scratch IS the page root element, so patches
+// applied by snapshotPatchApply (via callLepusMethod inside the runtime commit
+// hook) operate directly on scratch. No move-back or sync-out required.
+
+globalThis.__pipelineRender = function pipelineRender(vnode, parentDom, replaceNode) {
+  // When the scratch container changes (new test), reinitialize the dual-thread
+  // roots so Preact starts with a clean vnode tree. Without this, Preact would
+  // diff against the previous test's BSI children and produce wrong patches.
+  if (parentDom !== _lastScratch) {
+    _lastScratch = parentDom;
+    lynxTestingEnv.switchToMainThread();
+    globalThis.onInjectMainThreadGlobals(lynxTestingEnv.mainThread.globalThis);
+    lynxTestingEnv.switchToBackgroundThread();
+    globalThis.onInjectBackgroundThreadGlobals(lynxTestingEnv.backgroundThread.globalThis);
+    injectTt();
+    addCtxNotFoundEventListener();
+  }
+
+  // Ensure main thread root SI has elements and is registered under BSI root's ID.
+  lynxTestingEnv.switchToMainThread();
+  const mtRoot = globalThis.__root;
+  const bgRootId = lynxTestingEnv.backgroundThread.globalThis.__root?.__id;
+
+  if (!mtRoot.__elements) {
+    // Use scratch itself as the page root element. This avoids __CreatePage
+    // (which clears document.body) and eliminates all child-moving between a
+    // separate <page> element and scratch.
+    //
+    // The 'root' snapshot's create() returns [__page] on the main thread, so
+    // setupPage(scratch) causes ensureElements() to set:
+    //   mtRoot.__elements = [scratch]
+    //   mtRoot.__element_root = scratch
+    //
+    // Subsequent snapshotPatchApply calls (AppendElement, RemoveChild, etc.)
+    // operate directly on scratch — tests see the live DOM immediately.
+    if (!parentDom.$$uiSign) parentDom.$$uiSign = -1;
+    globalThis.elementTree.root = parentDom;
+    setupPage(parentDom);
+    mtRoot.ensureElements();
+  }
+
+  // Always ensure the SI root is findable by BSI root's ID
+  if (bgRootId != null && !snapshotInstanceManager.values.has(bgRootId)) {
+    snapshotInstanceManager.values.set(bgRootId, mtRoot);
+  }
+
+  lynxTestingEnv.switchToBackgroundThread();
+
+  // Initialize the snapshot patch array so BSI operations generate patches
+  initGlobalSnapshotPatch();
+
+  // Preact render → BSI → commit hook → callLepusMethod → main thread snapshotPatchApply
+  // Patches land directly in scratch. callLepusMethod restores the background thread.
+  preactRender(vnode, globalThis.__root, replaceNode);
+
+  lynxTestingEnv.switchToBackgroundThread();
+};
+
+// --- 7. Globals expected by upstream tests ---
+
+chai.use(sinonChai);
+globalThis.context = describe;
+globalThis.sinon = sinon;
+
+if (typeof globalThis.requestAnimationFrame === 'undefined') {
+  globalThis.requestAnimationFrame = (cb) => setTimeout(cb, 0);
+}
+
+globalThis.window?.addEventListener?.('error', () => {
+  // Suppress uncaught errors from reaching the test runner
+});
+
+expect.extend({
+  equalNode(received, expected) {
+    if (expected == null) {
+      return {
+        pass: received == null,
+        message: () => `expected node to "== null" but got ${received} instead.`,
+      };
+    }
+    return {
+      pass: received?.tagName === expected.tagName && received === expected,
+      message: () => `expected node to have tagName ${expected.tagName} but got ${received?.tagName} instead.`,
+    };
+  },
+});
+
+// --- Exports for mode-specific setup files ---
+export {
+  lynxTestingEnv,
+  SnapshotInstance,
+  snapshotManager,
+  snapshotCreatorMap,
+  DynamicPartType,
+  injectTt,
+  addCtxNotFoundEventListener,
+};
diff --git a/packages/react/preact-upstream-tests/skiplist.json b/packages/react/preact-upstream-tests/skiplist.json
new file mode 100644
index 0000000000..8d7ddc3461
--- /dev/null
+++ b/packages/react/preact-upstream-tests/skiplist.json
@@ -0,0 +1,364 @@
+{
+  "unsupported_features": [
+    {
+      "category": "lynx_not_web",
+      "keywords": ["getLog", "clearLog"],
+      "comment": "DOM mutation order — pipeline routes through <page> root, producing different mutation sequences"
+    },
+    {
+      "category": "lynx_not_web",
+      "keywords": ["MutationObserver"],
+      "comment": "Lynx environment does not provide MutationObserver"
+    },
+    {
+      "category": "lynx_not_web",
+      "keywords": ["dangerouslySetInnerHTML"],
+      "comment": "Lynx does not support dangerouslySetInnerHTML"
+    }
+  ],
+
+  "skip_list": [
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should not render falsy values",
+        "should render NaN as text content",
+        "should clear falsy attributes",
+        "should not render falsy attributes on hydrate"
+      ],
+      "comment": "JSON.stringify(NaN) → null — NaN is lost in BSI→patch IPC serialization"
+    },
+    {
+      "category": "dual_thread",
+      "tests": ["should render bigint as text content"],
+      "comment": "JSON.stringify(BigInt) throws — BigInt cannot cross BSI→patch IPC boundary"
+    },
+    {
+      "category": "dual_thread",
+      "tests": ["should serialize object props as attributes"],
+      "comment": "JSON.stringify strips custom toString() — object identity lost in IPC serialization"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should keep c.base up to date if a nested child component changes DOM nodes",
+        "should not update sibling c.base if child component changes DOM nodes",
+        "should not update parent c.base if child component changes DOM nodes and it is not first child component",
+        "should update parent c.base if child component changes DOM nodes and it is first non-null child component",
+        "should not update parent c.base if child component changes DOM nodes and a parent is not first child component",
+        "should update parent c.base if first child becomes null",
+        "should update parent c.base if first child becomes non-null",
+        "should update parent c.base if first non-null child becomes null with multiple null siblings",
+        "should update parent c.base if a null child returns DOM with multiple null siblings",
+        "should update parent c.base to null if last child becomes null",
+        "should update parent c.base if last child returns dom",
+        "should not update parent if it is a DOM node"
+      ],
+      "comment": "component.base returns BSI (background thread), not a DOM node"
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should set enumerable boolean attribute",
+        "should allow setting contentEditable to false",
+        "should not clear falsy DOM properties",
+        "should mask value on password input elements",
+        "should not throw when changing contentEditable to undefined or null",
+        "should support subsequent renders w/ defaultValue",
+        "should support subsequent renders w/ defaultChecked"
+      ],
+      "comment": "Web DOM IDL properties (value, checked, contentEditable, spellcheck, …) — Preact does dom[prop]=val but BSI has no IDL property, causing a different code path in setProperty()"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should not execute append operation when child is at last",
+        "should always diff `checked` and `value` properties against the DOM"
+      ],
+      "comment": "Refs return BSI, not DOM node — tests call ref.focus(), ref.value, etc."
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "is invoked after refs are set"
+      ],
+      "comment": "BSI ref timing — ref callback receives BSI object (background thread), test asserts DOM node is set before componentDidMount/componentDidUpdate lifecycle hook fires"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should be called after children are mounted"
+      ],
+      "comment": "Pipeline timing — DOM check in componentDidUpdate fires before children's main-thread patches are applied via IPC"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "can be set by another component",
+        "should handle queued useState"
+      ],
+      "comment": "setupRerender() timing — cross-component useState update triggers rerender before pipeline IPC roundtrip syncs DOM to scratch"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "can be dispatched by another component"
+      ],
+      "comment": "setupRerender() timing — cross-component useReducer dispatch triggers rerender before pipeline IPC roundtrip syncs DOM to scratch"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "hooks should be called in right order"
+      ],
+      "comment": "useEffect order — BSI commit hook changes Preact's internal microtask/effect queue ordering, causing effects to fire in a different sequence than the test expects"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should correctly display DOM",
+        "should invoke layout effects after subtree is fully connected"
+      ],
+      "comment": "useLayoutEffect DOM check — DOM content/connectivity assertion inside layout effect fires before main-thread patch IPC roundtrip completes"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should run layout affects after all refs are invoked"
+      ],
+      "comment": "BSI ref + layout effect timing — ref.current contains BSI (background thread object), not DOM node; document.body.contains(ref.current) fails"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "can access refs from within a layout effect callback",
+        "should have a right call order with correct dom ref",
+        "parent and child refs should be set before all effects"
+      ],
+      "comment": "BSI refs in effect callbacks — tests read ref.current expecting DOM nodes (tagName, querySelector, etc.) but ref.current is BSI"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should not duplicate in lists where an item throws and the parent catches and returns a differing type"
+      ],
+      "comment": "Error boundary with list diffing — pipeline timing causes extra mount/unmount cycles when error boundary catches during list reconciliation, duplicating items"
+    }
+  ],
+
+  "nocompile_skip_list": [
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should clear falsy input values",
+        "should allow <input list /> to pass through as an attribute"
+      ],
+      "comment": "No-compile path lacks DOM IDL/property parity for these cases; compiled snapshot path already passes"
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should set checked attribute on custom elements without checked property",
+        "should support false aria-* attributes",
+        "should re-render nested components"
+      ],
+      "comment": "Boolean-to-attribute serialization mismatch is no-compile specific; compiled mode already passes these tests"
+    },
+    {
+      "category": "dual_thread",
+      "tests": ["should reorder Fragment children"],
+      "comment": "BSI .type field collision only reproduces in no-compile mode; compiled mode passes"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "handles errors correctly",
+        "orders effects effectively",
+        "should cancel effects from a disposed render",
+        "should not rerun committed effects",
+        "should not schedule effects that have no change"
+      ],
+      "comment": "useEffect scheduling — BSI shim interaction with Preact's no-compile effect queue causes incorrect ordering/cancellation; compiled snapshot path already passes these"
+    }
+  ],
+
+  "compiler_skip_list": [
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should render functional components",
+        "should render components with props",
+        "should not serialize function props as attributes",
+        "should initialize props & context but not state in Component constructor"
+      ],
+      "comment": "Compiler serializes event handlers as attributes (e.g. onbaz=\"2:0:onBaz\") and changes render() return signature — tests assert on exact innerHTML or spy on render calls"
+    },
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should render components",
+        "should render components that don't call Component constructor",
+        "should render components that don't call Component constructor and don't initialize state",
+        "should render components that don't inherit from Component",
+        "should render components that don't inherit from Component (unistore pattern)",
+        "should render components that don't inherit from Component and don't initialize state",
+        "should render components that don't pass args into the Component constructor (unistore pattern)",
+        "should render Component classes that don't pass args into the Component constructor",
+        "should render nested functional components"
+      ],
+      "comment": "Compiler changes component render return value (snapshot type instead of raw vnode) — spy-based assertions on render() return value fail"
+    },
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should be a VNode with a DOM node child",
+        "should be an array with multiple children",
+        "should be ignored when explicit children exist",
+        "should support passing children as a prop"
+      ],
+      "comment": "Compiler transforms children into snapshot types — children.type becomes '__snapshot_xxx' instead of 'span', and spread children are serialized as JSON attributes instead of rendered"
+    },
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should render sibling array children",
+        "should swap nested fragments correctly",
+        "should allow VNode reuse"
+      ],
+      "comment": "Compiler wraps text in <wrapper> — DOM structure changes (childNodes count, serializeHtml output) beyond innerHTML patching"
+    },
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should preserve state when moving keyed children components",
+        "should reorder child pairs",
+        "should retain state for inserted children"
+      ],
+      "comment": "Compiler changes component identity — keyed children reorder/insert causes different mount/unmount cycles"
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should keep value of uncontrolled checkboxes",
+        "should keep value of uncontrolled inputs",
+        "should not emit when value does not update"
+      ],
+      "comment": "Compiler-generated snapshots don't set DOM IDL properties (value, checked) — these go through snapshot values array instead of direct dom[prop]=val"
+    },
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should handle hole prepend",
+        "should handle hole replace",
+        "should handle hole insert",
+        "should handle hole apppend"
+      ],
+      "comment": "Compiler changes component identity — keyed hole operations cause extra mount/unmount cycles due to snapshot type changes"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should be called when applying a DOM ref",
+        "should be called when unmounting a ref",
+        "should bubble up when ref throws on component that is not an error boundary"
+      ],
+      "comment": "Compiled mode ref attachment — snapshot create/ensureElements delays ref binding, causing ref-throwing error boundary tests to fire at wrong lifecycle phase"
+    },
+    {
+      "category": "test_methodology",
+      "tests": [
+        "returns an array containing a VNode with a DOM node child",
+        "returns an array with multiple children"
+      ],
+      "comment": "Compiler transforms element VNodes into snapshot types — toChildArray result has type='__snapshot_xxx' instead of 'span', breaking type identity assertions"
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should maintain focus when hydrating"
+      ],
+      "comment": "Compiled snapshot path sets input attributes via update[] functions — type attribute timing differs, causing input not to match expected type='text' during hydration focus test"
+    }
+  ],
+
+  "permanent_skip_list": [
+    {
+      "category": "test_methodology",
+      "tests": [
+        "should reconcile mutated DOM attributes",
+        "should remove attributes on pre-existing DOM"
+      ],
+      "comment": "Test mutates or pre-populates jsdom directly — BSI has no access to main-thread DOM state"
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": ["should support the <template> tag"],
+      "comment": "BSI has no .content DocumentFragment — web-specific <template> API"
+    },
+    {
+      "category": "test_methodology",
+      "tests": ["handle shuffled (stress test)"],
+      "comment": "Exceeds 5s timeout due to pipeline overhead per commit"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should call getSnapshotBeforeUpdate before mutations are committed"
+      ],
+      "comment": "Dual-thread gap — getSnapshotBeforeUpdate must read DOM before patch is applied, but background thread cannot observe main-thread DOM state; the pre-patch snapshot is structurally inaccessible"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should be invoked when dom does (DidMount, WillUnmount) or does not (WillMount, DidUnmount) exist"
+      ],
+      "comment": "DOM existence in lifecycle hooks — test checks scratch.firstChild during componentWillMount (expects null) and componentWillUnmount (expects present), but pipeline's <page> element is always initialized before render"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "should maintain context"
+      ],
+      "comment": "TIMEOUT — requestAnimationFrame-driven context update conflicts with pipeline commit hook; the render loop never settles"
+    },
+    {
+      "category": "dual_thread",
+      "tests": [
+        "support render roots from an effect"
+      ],
+      "comment": "TIMEOUT — creating a new render root inside useEffect conflicts with pipeline's single _lastScratch/_currentMtRoot global state, causing the effect to loop indefinitely"
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should only register on* functions as handlers",
+        "should only register truthy values as handlers",
+        "should support native event names",
+        "should support camel-case event names",
+        "should update event handlers",
+        "should remove event handlers",
+        "should register events not appearing on dom nodes",
+        "should use capturing for event props ending with *Capture",
+        "should support both capturing and non-capturing events on the same element",
+        "should support (got|lost)PointerCapture events",
+        "should support camel-case focus event names"
+      ],
+      "comment": "Event registration tests — spy on DOM element.addEventListener but BSI event stubs register on the background thread and never reach jsdom. Lynx has its own event model separate from the Web DOM event system."
+    },
+    {
+      "category": "lynx_not_web",
+      "tests": [
+        "should maintain focus when moving the input around",
+        "should maintain focus when adding children around input",
+        "should maintain focus when adding children around input (unkeyed)",
+        "should maintain focus when conditional elements around input",
+        "should maintain focus when removing elements around input",
+        "should  maintain focus when removing element directly before input",
+        "should maintain focus when adding input next to the current input",
+        "should keep focus in Fragments",
+        "should keep text selection"
+      ],
+      "comment": "Focus/selection DOM APIs — element.focus() and setSelectionRange require browser-level focus management which is absent in the Lynx dual-thread pipeline. Lynx has its own focus model."
+    }
+  ]
+}
diff --git a/packages/react/preact-upstream-tests/tsconfig.json b/packages/react/preact-upstream-tests/tsconfig.json
new file mode 100644
index 0000000000..bb957a82d7
--- /dev/null
+++ b/packages/react/preact-upstream-tests/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "target": "ESNext",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "resolveJsonModule": true,
+  },
+  "include": [
+    "vitest.config.ts",
+    "vitest.compiled.config.ts",
+    "vitest.shared.ts",
+    "vitest.workspace.ts",
+  ],
+}
diff --git a/packages/react/preact-upstream-tests/vitest.compiled.config.ts b/packages/react/preact-upstream-tests/vitest.compiled.config.ts
new file mode 100644
index 0000000000..cc4122863e
--- /dev/null
+++ b/packages/react/preact-upstream-tests/vitest.compiled.config.ts
@@ -0,0 +1,64 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import path from 'node:path';
+
+import { defineConfig, mergeConfig } from 'vitest/config';
+import type { Plugin } from 'vitest/config';
+
+import { __dirname, createBaseConfig } from './vitest.shared.js';
+import { transformReactLynxPlugin } from '../testing-library/src/transformReactLynxPlugin.js';
+
+// Strip classic JSX pragmas (/** @jsx createElement */) that conflict with
+// the SWC transform's automatic runtime mode. The pragma is only needed for
+// esbuild in no-compiler mode; the SWC transform handles JSX itself.
+function stripJsxPragmaPlugin(): Plugin {
+  return {
+    name: 'strip-jsx-pragma',
+    enforce: 'pre',
+    transform(sourceText: string, sourcePath: string) {
+      if (!sourcePath.endsWith('.js') && !sourcePath.endsWith('.jsx')) return null;
+      if (sourcePath.includes('node_modules')) return null;
+      const stripped = sourceText.replace(/\/\*\*\s*@jsx\s+\w+\s*\*\//g, '');
+      if (stripped !== sourceText) return { code: stripped, map: null };
+      return null;
+    },
+  };
+}
+
+const baseConfig = createBaseConfig('preact-upstream-compiled', {
+  setupFile: 'setup-compiled.js',
+});
+
+// Compiled mode: SWC transforms JSX into snapshot elements with values arrays.
+// Preact sees { values: ['foo'] } instead of raw props.
+// The same tests should produce the same DOM output as no-compiler mode —
+// any discrepancy indicates a bug in the compiler or runtime.
+export default defineConfig(mergeConfig(baseConfig, {
+  plugins: [
+    stripJsxPragmaPlugin(),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    transformReactLynxPlugin({
+      runtimePkgName: '@lynx-js/react',
+      rootDir: __dirname,
+    }) as Plugin,
+  ],
+  resolve: {
+    alias: [
+      // Compiler-generated imports: import * as ReactLynx from "@lynx-js/react/internal"
+      {
+        find: /^@lynx-js\/react\/internal$/,
+        replacement: path.resolve(__dirname, '../runtime/lib/internal.js'),
+      },
+      // Compiler-generated JSX runtime: import { jsx } from "@lynx-js/react/jsx-runtime"
+      {
+        find: /^@lynx-js\/react\/jsx-runtime$/,
+        replacement: path.resolve(__dirname, '../runtime/jsx-runtime/index.js'),
+      },
+      {
+        find: /^@lynx-js\/react$/,
+        replacement: path.resolve(__dirname, '../runtime/lib/index.js'),
+      },
+    ],
+  },
+}));
diff --git a/packages/react/preact-upstream-tests/vitest.config.ts b/packages/react/preact-upstream-tests/vitest.config.ts
new file mode 100644
index 0000000000..c3782f005b
--- /dev/null
+++ b/packages/react/preact-upstream-tests/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+import { createBaseConfig } from './vitest.shared';
+
+// No-compiler mode: Preact sees raw props ({ className: 'foo' })
+// Tests Preact reconciler semantics through the dual-thread pipeline
+// without the SWC snapshot transform.
+export default defineConfig(createBaseConfig('preact-upstream'));
diff --git a/packages/react/preact-upstream-tests/vitest.shared.ts b/packages/react/preact-upstream-tests/vitest.shared.ts
new file mode 100644
index 0000000000..144980cf9b
--- /dev/null
+++ b/packages/react/preact-upstream-tests/vitest.shared.ts
@@ -0,0 +1,447 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import type { Plugin, UserConfig } from 'vitest/config';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const preactDir = path.resolve(__dirname, 'preact');
+
+// --- Skiplist parsing ---
+
+interface SkiplistEntry {
+  tests: string[];
+  comment?: string;
+}
+
+interface UnsupportedFeatureEntry {
+  keywords: string[];
+  comment: string;
+}
+
+interface Skiplist {
+  unsupported_features: UnsupportedFeatureEntry[];
+  skip_list: SkiplistEntry[];
+  nocompile_skip_list: SkiplistEntry[];
+  permanent_skip_list: SkiplistEntry[];
+  compiler_skip_list: SkiplistEntry[];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const skiplist: Skiplist = JSON.parse(
+  readFileSync(path.resolve(__dirname, 'skiplist.json'), 'utf-8'),
+);
+
+const unsupportedFeatures = skiplist.unsupported_features
+  .flatMap(({ keywords }) =>
+    keywords.map((kw) => ({
+      keyword: kw,
+      pattern: new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`),
+    }))
+  );
+
+const commonSkips = new Set<string>(
+  [...skiplist.skip_list, ...skiplist.permanent_skip_list]
+    .flatMap((entry) => entry.tests),
+);
+
+const noCompileSkips = new Set<string>(
+  skiplist.nocompile_skip_list
+    .flatMap((entry) => entry.tests),
+);
+
+const compilerSkips = new Set<string>(
+  skiplist.compiler_skip_list
+    .flatMap((entry) => entry.tests),
+);
+
+// --- Utility functions ---
+
+// Find the closing ')' that matches the opening '(' at position 0 of string s.
+function findMatchingParen(s: string): number {
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '(') depth++;
+    else if (s[i] === ')') {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+// Extract the source text of an it() block starting from the '(' after 'it'.
+// Returns the full source from '(' to the matching ')'.
+function extractItBody(code: string, openParenOffset: number): string | null {
+  const closeIdx = findMatchingParen(code.slice(openParenOffset));
+  if (closeIdx === -1) return null;
+  return code.slice(openParenOffset, openParenOffset + closeIdx + 1);
+}
+
+// --- Shared plugins ---
+
+export function pipelineRenderPlugin(): Plugin {
+  return {
+    name: 'preact-pipeline-render',
+    enforce: 'pre',
+    transform(code, id) {
+      if (!id.includes('/test/') || id.includes('_util/')) return null;
+      if (!id.endsWith('.js') && !id.endsWith('.jsx')) return null;
+
+      if (code.includes('render') && (code.includes('from \'preact\'') || code.includes('from "preact"'))) {
+        const transformed = code.replace(
+          /\brender\s*\(/g,
+          (match, offset) => {
+            // Skip if part of another word (rerender, prerender, etc.)
+            if (offset > 0 && /\w/.test(code[offset - 1])) return match;
+            // Skip property access: .render(
+            if (offset > 0 && code[offset - 1] === '.') return match;
+            // Skip method definitions: render() { or render(props) {
+            const afterRender = code.slice(offset + match.length - 1);
+            const closeIdx = findMatchingParen(afterRender);
+            if (closeIdx !== -1) {
+              const afterClose = afterRender.slice(closeIdx + 1).trimStart();
+              if (afterClose.startsWith('{')) return match;
+            }
+            return '__pipelineRender(';
+          },
+        );
+        if (transformed !== code) {
+          return { code: transformed, map: null };
+        }
+      }
+      return null;
+    },
+  };
+}
+
+// --- SKIPLIST_ONLY mode ---
+// Parse SKIPLIST_ONLY env var to determine which skipped tests to run exclusively.
+// Format: "category" or "category:groupIndex" (comma-separated for multiple).
+// Examples:
+//   SKIPLIST_ONLY=skip_list                    — run all tests from skip_list
+//   SKIPLIST_ONLY=nocompile_skip_list          — run all tests from nocompile_skip_list
+//   SKIPLIST_ONLY=skip_list:0                  — run only the first group in skip_list
+//   SKIPLIST_ONLY=skip_list:0,skip_list:1      — run first two groups
+//   SKIPLIST_ONLY=unsupported_features:2       — run tests matching dangerouslySetInnerHTML keywords
+//   SKIPLIST_ONLY=permanent_skip_list           — run all permanently skipped tests
+
+interface SkiplistOnlySpec {
+  /** Set of test names to run (from name-based categories) */
+  names: Set<string>;
+  /** Keyword patterns to match in test bodies (from unsupported_features) */
+  keywords: Array<{ keyword: string; pattern: RegExp }>;
+}
+
+function parseSkiplistOnly(): SkiplistOnlySpec | null {
+  const envVal = process.env['SKIPLIST_ONLY'];
+  if (!envVal) return null;
+
+  const names = new Set<string>();
+  const keywords: SkiplistOnlySpec['keywords'] = [];
+
+  for (const part of envVal.split(',')) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+
+    const colonIdx = trimmed.indexOf(':');
+    const category = colonIdx === -1 ? trimmed : trimmed.slice(0, colonIdx);
+    const groupIdx = colonIdx === -1 ? undefined : Number.parseInt(trimmed.slice(colonIdx + 1), 10);
+
+    if (category === 'unsupported_features') {
+      const entries = groupIdx === undefined
+        ? skiplist.unsupported_features
+        : [skiplist.unsupported_features[groupIdx]!];
+      for (const entry of entries) {
+        for (const kw of entry.keywords) {
+          keywords.push({
+            keyword: kw,
+            pattern: new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`),
+          });
+        }
+      }
+    } else {
+      const list =
+        skiplist[category as 'skip_list' | 'nocompile_skip_list' | 'permanent_skip_list' | 'compiler_skip_list'];
+      if (!list) {
+        throw new Error(
+          `SKIPLIST_ONLY: unknown category "${category}". `
+            + `Valid: unsupported_features, skip_list, nocompile_skip_list, permanent_skip_list, compiler_skip_list`,
+        );
+      }
+      const entries = groupIdx === undefined ? list : [list[groupIdx]!];
+      for (const entry of entries) {
+        for (const t of entry.tests) {
+          names.add(t);
+        }
+      }
+    }
+  }
+
+  return { names, keywords };
+}
+
+const skiplistOnlySpec = parseSkiplistOnly();
+
+export function skiplistPlugin(projectName?: string): Plugin {
+  const isCompiled = projectName === 'preact-upstream-compiled';
+  return {
+    name: 'preact-skiplist',
+    enforce: 'pre',
+    transform(code, id) {
+      if (!id.includes('/test/') || id.includes('_util/')) return null;
+      if (!id.endsWith('.js') && !id.endsWith('.jsx')) return null;
+
+      let transformed = code;
+      let changed = false;
+
+      // Process it( and it.only( calls — rewrite to it.skip( when matched.
+      // Regex matches: it('name' or it("name" or it.only('name' etc.
+      const itPattern = /\b(it(?:\.only)?)\s*\(\s*(['"`])((?:(?!\2).)*)\2/g;
+      let match;
+      const replacements: Array<{ start: number; end: number; replacement: string }> = [];
+
+      if (skiplistOnlySpec) {
+        // --- SKIPLIST_ONLY mode: only run specified skipped tests ---
+        while ((match = itPattern.exec(code)) !== null) {
+          const itKeyword = match[1]; // 'it' or 'it.only'
+          const testName = match[3];
+          const fullMatchStart = match.index;
+
+          // Check if this test is in the "only" set
+          let shouldRun = false;
+
+          // Check name-based match
+          if (skiplistOnlySpec.names.has(testName)) {
+            shouldRun = true;
+          }
+
+          // Check keyword-based match (unsupported_features)
+          if (!shouldRun && skiplistOnlySpec.keywords.length > 0) {
+            const openParen = code.indexOf('(', fullMatchStart + itKeyword.length);
+            if (openParen !== -1) {
+              const body = extractItBody(code, openParen);
+              if (body) {
+                for (const { pattern } of skiplistOnlySpec.keywords) {
+                  if (pattern.test(body)) {
+                    shouldRun = true;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+
+          // Skip tests that are NOT in the "only" set
+          if (!shouldRun) {
+            replacements.push({
+              start: fullMatchStart,
+              end: fullMatchStart + itKeyword.length,
+              replacement: 'it.skip',
+            });
+          }
+        }
+      } else {
+        // --- Normal mode: skip tests that are in skip lists ---
+        while ((match = itPattern.exec(code)) !== null) {
+          const itKeyword = match[1]; // 'it' or 'it.only'
+          const testName = match[3];
+          const fullMatchStart = match.index;
+
+          // Check manual skip lists first
+          if (commonSkips.has(testName)) {
+            replacements.push({
+              start: fullMatchStart,
+              end: fullMatchStart + itKeyword.length,
+              replacement: 'it.skip',
+            });
+            continue;
+          }
+
+          // Check no-compile-specific skip list
+          if (!isCompiled && noCompileSkips.has(testName)) {
+            replacements.push({
+              start: fullMatchStart,
+              end: fullMatchStart + itKeyword.length,
+              replacement: 'it.skip',
+            });
+            continue;
+          }
+
+          // Check compiler-specific skip list (only in compiled mode)
+          if (isCompiled && compilerSkips.has(testName)) {
+            replacements.push({
+              start: fullMatchStart,
+              end: fullMatchStart + itKeyword.length,
+              replacement: 'it.skip',
+            });
+            continue;
+          }
+
+          // Check keyword-based unsupported features by scanning the it() body
+          const openParen = code.indexOf('(', fullMatchStart + itKeyword.length);
+          if (openParen === -1) continue;
+          const body = extractItBody(code, openParen);
+          if (!body) continue;
+
+          for (const { pattern } of unsupportedFeatures) {
+            if (pattern.test(body)) {
+              replacements.push({
+                start: fullMatchStart,
+                end: fullMatchStart + itKeyword.length,
+                replacement: 'it.skip',
+              });
+              break;
+            }
+          }
+        }
+      }
+
+      // Apply replacements in reverse order to preserve offsets
+      for (const r of replacements.reverse()) {
+        transformed = transformed.slice(0, r.start) + r.replacement + transformed.slice(r.end);
+        changed = true;
+      }
+
+      if (changed) {
+        return { code: transformed, map: null };
+      }
+      return null;
+    },
+  };
+}
+
+// --- Shared config factory ---
+
+export function createBaseConfig(name: string, options?: { setupFile?: string }): UserConfig {
+  const setupFile = options?.setupFile ?? 'setup-nocompile.js';
+  return {
+    esbuild: {
+      // Treat .js files as JSX (upstream tests use /** @jsx createElement */ pragma)
+      loader: 'jsx',
+      include: /.*\.js$/,
+      exclude: ['node_modules'],
+      jsx: 'transform',
+      jsxFactory: 'createElement',
+      jsxFragment: 'Fragment',
+    },
+    resolve: {
+      alias: [
+        // Map preact bare specifiers to fork source (from submodule)
+        // Order matters: more specific paths must come before less specific ones.
+        {
+          find: /^preact\/hooks$/,
+          replacement: path.join(preactDir, 'hooks/src/index.js'),
+        },
+        {
+          find: /^preact\/test-utils$/,
+          replacement: path.join(preactDir, 'test-utils/src/index.js'),
+        },
+        {
+          find: /^preact\/compat$/,
+          replacement: path.join(preactDir, 'compat/src/index.js'),
+        },
+        {
+          find: /^preact\/debug$/,
+          replacement: path.join(preactDir, 'debug/src/index.js'),
+        },
+        {
+          find: /^preact\/devtools$/,
+          replacement: path.join(preactDir, 'devtools/src/index.js'),
+        },
+        {
+          find: /^preact\/jsx-runtime$/,
+          replacement: path.join(preactDir, 'jsx-runtime/src/index.js'),
+        },
+        {
+          find: /^preact$/,
+          replacement: path.join(preactDir, 'src/index.js'),
+        },
+      ],
+    },
+    plugins: [
+      pipelineRenderPlugin(),
+      skiplistPlugin(name),
+    ],
+    test: {
+      name,
+      globals: true,
+      environment: 'jsdom',
+      setupFiles: [path.resolve(__dirname, setupFile)],
+
+      include: [
+        // Core rendering tests — the most valuable for alignment verification
+        'preact/test/browser/render.test.js',
+        'preact/test/browser/components.test.js',
+        'preact/test/browser/fragments.test.js',
+        'preact/test/browser/keys.test.js',
+        'preact/test/browser/createContext.test.js',
+
+        // Lifecycle methods
+        'preact/test/browser/lifecycles/lifecycle.test.js',
+        'preact/test/browser/lifecycles/componentDidCatch.test.js',
+        'preact/test/browser/lifecycles/getDerivedStateFromError.test.js',
+        'preact/test/browser/lifecycles/getDerivedStateFromProps.test.js',
+        'preact/test/browser/lifecycles/getSnapshotBeforeUpdate.test.js',
+        'preact/test/browser/lifecycles/shouldComponentUpdate.test.js',
+        'preact/test/browser/lifecycles/componentDidMount.test.js',
+        'preact/test/browser/lifecycles/componentDidUpdate.test.js',
+        'preact/test/browser/lifecycles/componentWillMount.test.js',
+        'preact/test/browser/lifecycles/componentWillUnmount.test.js',
+        'preact/test/browser/lifecycles/componentWillUpdate.test.js',
+        'preact/test/browser/lifecycles/componentWillReceiveProps.test.js',
+
+        // Utilities and additional browser tests
+        'preact/test/browser/spec.test.js',
+        'preact/test/browser/cloneElement.test.js',
+        'preact/test/browser/isValidElement.test.js',
+        'preact/test/browser/toChildArray.test.js',
+        'preact/test/browser/placeholders.test.js',
+        'preact/test/browser/events.test.js',
+        'preact/test/browser/focus.test.js',
+
+        // Hooks
+        'preact/hooks/test/browser/useState.test.js',
+        'preact/hooks/test/browser/useEffect.test.js',
+        'preact/hooks/test/browser/useContext.test.js',
+        'preact/hooks/test/browser/useReducer.test.js',
+        'preact/hooks/test/browser/useCallback.test.js',
+        'preact/hooks/test/browser/useMemo.test.js',
+        'preact/hooks/test/browser/useRef.test.js',
+        'preact/hooks/test/browser/useLayoutEffect.test.js',
+        'preact/hooks/test/browser/useImperativeHandle.test.js',
+        'preact/hooks/test/browser/combinations.test.js',
+        'preact/hooks/test/browser/errorBoundary.test.js',
+        'preact/hooks/test/browser/componentDidCatch.test.js',
+      ],
+
+      exclude: [
+        // PAPI: no createElementNS — SVG/MathML namespace tests fail
+        'preact/test/browser/svg.test.js',
+        'preact/test/browser/mathml.test.js',
+        'preact/test/browser/customBuiltInElements.test.js',
+        // Missing dep: preact-render-to-string (deferred to v2)
+        'preact/hooks/test/browser/useId.test.js',
+        // JSDOM: CSSStyleDeclaration.setProperty behavior differs from browsers
+        'preact/test/browser/style.test.js',
+        // Preact internals: accesses _children VNode attachment on DOM nodes, not pipeline-compatible
+        'preact/test/browser/getDomSibling.test.js',
+        // replaceNode (3rd render() param): pre-populated DOM + internal _children state, web-specific
+        'preact/test/browser/replaceNode.test.js',
+        // refs: ~17/26 fail in both modes — BSI refs vs DOM nodes (tracked in skip_list)
+        // Deferred until BSI ref bridging is implemented
+        'preact/test/browser/refs.test.js',
+      ],
+      // Exclude compat tests (fork deleted handleDomVNode — className→class, onChange→onInput etc.)
+      // Exclude debug tests (deferred to v2)
+      // Exclude devtools tests (deferred to v2)
+    },
+  };
+}
+
+export { __dirname };
diff --git a/packages/react/preact-upstream-tests/vitest.workspace.ts b/packages/react/preact-upstream-tests/vitest.workspace.ts
new file mode 100644
index 0000000000..ad2a405e8d
--- /dev/null
+++ b/packages/react/preact-upstream-tests/vitest.workspace.ts
@@ -0,0 +1,15 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { defineWorkspace } from 'vitest/config';
+
+// Run the same Preact upstream tests in two modes:
+//   1. No compiler   — Preact sees raw props, tests reconciler semantics
+//   2. With compiler — SWC transforms JSX to snapshots, tests that the
+//                      compiler optimization doesn't change output semantics
+//
+// Both modes should produce identical DOM output. Discrepancies = bugs.
+export default defineWorkspace([
+  'vitest.config.ts',
+  'vitest.compiled.config.ts',
+]);
diff --git a/packages/react/testing-library/rslib.config.ts b/packages/react/testing-library/rslib.config.ts
index 10790990fe..6ba1a24455 100644
--- a/packages/react/testing-library/rslib.config.ts
+++ b/packages/react/testing-library/rslib.config.ts
@@ -36,6 +36,7 @@ export default defineConfig({
           'index': './src/index.jsx',
           'vitest.config': './src/vitest.config.js',
           'vitest-global-setup': './src/vitest-global-setup.js',
+          'transformReactLynxPlugin': './src/transformReactLynxPlugin.js',
         },
       },
       output: {
diff --git a/packages/react/testing-library/src/transformReactLynxPlugin.js b/packages/react/testing-library/src/transformReactLynxPlugin.js
new file mode 100644
index 0000000000..7c320c720e
--- /dev/null
+++ b/packages/react/testing-library/src/transformReactLynxPlugin.js
@@ -0,0 +1,100 @@
+import path from 'path';
+import { createRequire } from 'module';
+
+function normalizeSlashes(file) {
+  return file.replaceAll(path.win32.sep, '/');
+}
+
+/**
+ * Vite plugin that runs the ReactLynx SWC snapshot transform on source files.
+ *
+ * @param {object} pluginOptions
+ * @param {string} pluginOptions.runtimePkgName - Runtime package name, e.g. '@lynx-js/react'
+ * @param {string} pluginOptions.rootDir - Root directory for computing stable relative paths
+ * @param {string} [pluginOptions.engineVersion] - Engine version string
+ * @param {boolean|object} [pluginOptions.dynamicImport] - Dynamic import config, or false to disable
+ * @param {boolean|object} [pluginOptions.worklet] - Worklet config (filename is auto-populated per file), or false to disable
+ */
+export function transformReactLynxPlugin(pluginOptions) {
+  const {
+    runtimePkgName,
+    rootDir,
+    engineVersion,
+    dynamicImport = false,
+    worklet = false,
+  } = pluginOptions;
+
+  const _require = createRequire(import.meta.url);
+
+  return {
+    name: 'transformReactLynxPlugin',
+    enforce: 'pre',
+    transform(sourceText, sourcePath) {
+      // Only transform JS/TS files
+      // Using the same regex as rspack's `CHAIN_ID.RULE.JS` rule
+      const regex = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)(\?.*)?$/;
+      if (!regex.test(sourcePath)) return null;
+
+      const { transformReactLynxSync } = _require(
+        '@lynx-js/react/transform',
+      );
+      // relativePath should be stable between different runs with different cwd
+      const relativePath = normalizeSlashes(path.relative(
+        rootDir,
+        sourcePath,
+      ));
+      const basename = path.basename(sourcePath);
+
+      // Auto-populate worklet.filename with per-file relativePath
+      let workletOption = worklet;
+      if (worklet && typeof worklet === 'object') {
+        workletOption = { ...worklet, filename: relativePath };
+      }
+
+      const result = transformReactLynxSync(sourceText, {
+        mode: 'test',
+        pluginName: '',
+        filename: basename,
+        sourcemap: true,
+        snapshot: {
+          preserveJsx: false,
+          runtimePkg: `${runtimePkgName}/internal`,
+          jsxImportSource: runtimePkgName,
+          filename: relativePath,
+          target: 'MIXED',
+        },
+        engineVersion: engineVersion ?? '',
+        dynamicImport,
+        directiveDCE: false,
+        defineDCE: false,
+        shake: false,
+        compat: false,
+        worklet: workletOption,
+        refresh: false,
+        cssScope: false,
+      });
+      if (result.errors.length > 0) {
+        // https://rollupjs.org/plugin-development/#this-error
+        result.errors.forEach(error => {
+          this.error(
+            error.text,
+            error.location,
+          );
+        });
+      }
+      if (result.warnings.length > 0) {
+        result.warnings.forEach(warning => {
+          this.warn(
+            warning.text,
+            warning.location,
+          );
+        });
+      }
+
+      return {
+        code: result.code,
+        map: result.map,
+      };
+    },
+  };
+}
diff --git a/packages/react/testing-library/src/vitest.config.js b/packages/react/testing-library/src/vitest.config.js
index 7c37d9dda5..359e70320b 100644
--- a/packages/react/testing-library/src/vitest.config.js
+++ b/packages/react/testing-library/src/vitest.config.js
@@ -3,6 +3,8 @@ import { VitestPackageInstaller } from 'vitest/node';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
+import { transformReactLynxPlugin } from './transformReactLynxPlugin.js';
+export { transformReactLynxPlugin } from './transformReactLynxPlugin.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -201,83 +203,6 @@ export const createVitestConfig = async (options) => {
     };
   }
 
-  function transformReactLynxPlugin() {
-    return {
-      name: 'transformReactLynxPlugin',
-      enforce: 'pre',
-      transform(sourceText, sourcePath) {
-        const id = sourcePath;
-        // Only transform JS files
-        // Using the same regex as rspack's `CHAIN_ID.RULE.JS` rule
-        const regex = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)(\?.*)?$/;
-        if (!regex.test(id)) return null;
-
-        const { transformReactLynxSync } = require(
-          '@lynx-js/react/transform',
-        );
-        // relativePath should be stable between different runs with different cwd
-        const relativePath = normalizeSlashes(path.relative(
-          __dirname,
-          sourcePath,
-        ));
-        const basename = path.basename(sourcePath);
-        const result = transformReactLynxSync(sourceText, {
-          mode: 'test',
-          pluginName: '',
-          filename: basename,
-          sourcemap: true,
-          snapshot: {
-            preserveJsx: false,
-            runtimePkg: `${runtimePkgName}/internal`,
-            jsxImportSource: runtimePkgName,
-            filename: relativePath,
-            target: 'MIXED',
-          },
-          engineVersion: options?.engineVersion ?? '',
-          dynamicImport: {
-            injectLazyBundle: false,
-            layer: 'test',
-            runtimePkg: `${runtimePkgName}/internal`,
-          },
-          // snapshot: true,
-          directiveDCE: false,
-          defineDCE: false,
-          shake: false,
-          compat: false,
-          worklet: {
-            filename: relativePath,
-            runtimePkg: `${runtimePkgName}/internal`,
-            target: 'MIXED',
-          },
-          refresh: false,
-          cssScope: false,
-        });
-        if (result.errors.length > 0) {
-          // https://rollupjs.org/plugin-development/#this-error
-          result.errors.forEach(error => {
-            this.error(
-              error.text,
-              error.location,
-            );
-          });
-        }
-        if (result.warnings.length > 0) {
-          result.warnings.forEach(warning => {
-            this.warn(
-              warning.text,
-              warning.location,
-            );
-          });
-        }
-
-        return {
-          code: result.code,
-          map: result.map,
-        };
-      },
-    };
-  }
-
   return defineConfig({
     server: {
       fs: {
@@ -292,7 +217,20 @@ export const createVitestConfig = async (options) => {
           transformReactCompilerPlugin(),
         ]
         : []),
-      transformReactLynxPlugin(),
+      transformReactLynxPlugin({
+        runtimePkgName,
+        rootDir: __dirname,
+        engineVersion: options?.engineVersion,
+        dynamicImport: {
+          injectLazyBundle: false,
+          layer: 'test',
+          runtimePkg: `${runtimePkgName}/internal`,
+        },
+        worklet: {
+          runtimePkg: `${runtimePkgName}/internal`,
+          target: 'MIXED',
+        },
+      }),
     ],
     test: {
       environment: require.resolve(
@@ -305,7 +243,3 @@ export const createVitestConfig = async (options) => {
     },
   });
 };
-
-function normalizeSlashes(file) {
-  return file.replaceAll(path.win32.sep, '/');
-}
diff --git a/packages/testing-library/testing-environment/etc/testing-environment.api.md b/packages/testing-library/testing-environment/etc/testing-environment.api.md
index 1b47bf4d0e..0d3e1d9509 100644
--- a/packages/testing-library/testing-environment/etc/testing-environment.api.md
+++ b/packages/testing-library/testing-environment/etc/testing-environment.api.md
@@ -6,6 +6,9 @@
 
 import { JSDOM } from 'jsdom';
 
+// @public
+export function applyProp(el: LynxElement, key: string, value: unknown): void;
+
 // @public
 export type ElementTree = ReturnType<typeof initElementTree>;
 
diff --git a/packages/testing-library/testing-environment/src/index.ts b/packages/testing-library/testing-environment/src/index.ts
index 8d2aa611ec..3d6ceb563b 100644
--- a/packages/testing-library/testing-environment/src/index.ts
+++ b/packages/testing-library/testing-environment/src/index.ts
@@ -14,6 +14,7 @@ import { GlobalEventEmitter } from './lynx/GlobalEventEmitter.js';
 export { initElementTree } from './lynx/ElementPAPI.js';
 export type { LynxElement } from './lynx/ElementPAPI.js';
 export type { LynxGlobalThis } from './lynx/GlobalThis.js';
+export { applyProp } from './lynx/applyProp.js';
 /**
  * @public
  * The lynx element tree
diff --git a/packages/testing-library/testing-environment/src/lynx/applyProp.ts b/packages/testing-library/testing-environment/src/lynx/applyProp.ts
new file mode 100644
index 0000000000..fe5ed86c9b
--- /dev/null
+++ b/packages/testing-library/testing-environment/src/lynx/applyProp.ts
@@ -0,0 +1,73 @@
+// Copyright 2026 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+import type { LynxElement } from './ElementPAPI.js';
+
+// Element PAPI 方法在测试环境初始化后全局可用（由 __injectElementApi() 注入）
+// 签名直接对应 ElementPAPI.ts 中 ElementTree class 的方法定义
+declare var __SetClasses: (e: LynxElement, cls: string) => void;
+declare var __SetInlineStyles: (
+  e: LynxElement,
+  styles: string | Record<string, string>,
+) => void;
+declare var __SetID: (e: LynxElement, id: string) => void;
+declare var __SetAttribute: (e: LynxElement, key: string, value: any) => void;
+declare var __AddDataset: (e: LynxElement, key: string, value: string) => void;
+
+/**
+ * Dispatch a string-keyed prop to the correct Element PAPI method.
+ *
+ * Mirrors the updateSpread() dispatch logic in the runtime. Used by framework
+ * adapters operating in non-compiled mode, where the renderer writes raw DOM
+ * properties (className, style, id, data-*, etc.) to Lynx elements.
+ *
+ * @public
+ */
+export function applyProp(el: LynxElement, key: string, value: unknown): void {
+  // Style: shimBSI generates 'style:cssText' and 'style:<prop>' keys
+  if (key === 'style:cssText' || key === 'style') {
+    __SetInlineStyles(el, (value ?? '') as string | Record<string, string>);
+    return;
+  }
+  if (key.startsWith('style:')) {
+    const prop = key.slice(6);
+    __SetInlineStyles(el, { [prop]: (value ?? '') as string });
+    return;
+  }
+  if (key === 'className' || key === 'class') {
+    __SetClasses(el, (value ?? '') as string);
+    return;
+  }
+  if (key === 'id') {
+    __SetID(el, (value ?? '') as string);
+    return;
+  }
+  if (key === 'htmlFor') {
+    __SetAttribute(el, 'for', value as string | null);
+    return;
+  }
+  if (key.startsWith('data-')) {
+    __AddDataset(el, key.slice(5), (value ?? '') as string);
+    return;
+  }
+  // Skip event/internal/ref keys — forbidden by __SetAttribute
+  if (key.startsWith('on') || key.startsWith('__') || key === '_listeners') {
+    return;
+  }
+  if (key === 'ref' || key === 'key') return;
+  // Boolean → string conversion
+  if (key === 'translate') {
+    __SetAttribute(el, key, value ? 'yes' : 'no');
+    return;
+  }
+  if (value === true) {
+    __SetAttribute(el, key, '');
+    return;
+  }
+  if (value == null || value === false) {
+    __SetAttribute(el, key, null);
+    return;
+  }
+  __SetAttribute(el, key, typeof value === 'string' ? value : String(value));
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 55b79bc44b..559a2a3bda 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -265,7 +265,7 @@ importers:
         version: 3.7.0
       '@rsbuild/plugin-babel':
         specifier: 1.1.0
-        version: 1.1.0(@rsbuild/core@1.7.3)
+        version: 1.1.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))
       '@types/react':
         specifier: ^18.3.28
         version: 18.3.28
@@ -492,6 +492,30 @@ importers:
         specifier: ^18.3.28
         version: 18.3.28
 
+  packages/react/preact-upstream-tests:
+    devDependencies:
+      '@lynx-js/react':
+        specifier: workspace:*
+        version: link:..
+      '@lynx-js/testing-environment':
+        specifier: workspace:*
+        version: link:../../testing-library/testing-environment
+      chai:
+        specifier: ^5.2.0
+        version: 5.2.0
+      jsdom:
+        specifier: ^26.1.0
+        version: 26.1.0
+      sinon:
+        specifier: ^19.0.2
+        version: 19.0.2
+      sinon-chai:
+        specifier: ^4.0.0
+        version: 4.0.0(chai@5.2.0)(sinon@19.0.2)
+      vitest:
+        specifier: ^3.2.4
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.10.13)(@vitest/ui@3.2.4)(jsdom@26.1.0)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6)
+
   packages/react/refresh:
     devDependencies:
       '@lynx-js/react':
@@ -923,10 +947,10 @@ importers:
         version: link:../../web-platform/web-elements
       '@rsbuild/plugin-less':
         specifier: 1.6.0
-        version: 1.6.0(@rsbuild/core@1.7.3)
+        version: 1.6.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))
       '@rsbuild/plugin-sass':
         specifier: 1.5.0
-        version: 1.5.0(@rsbuild/core@1.7.3)
+        version: 1.5.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))
       commander:
         specifier: ^13.1.0
         version: 13.1.0
@@ -941,7 +965,7 @@ importers:
         version: 1.1.1
       rsbuild-plugin-tailwindcss:
         specifier: 0.2.4
-        version: 0.2.4(@rsbuild/core@1.7.3)(tailwindcss@3.4.19)
+        version: 0.2.4(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))(tailwindcss@3.4.19)
       rslog:
         specifier: ^1.3.2
         version: 1.3.2
@@ -1761,13 +1785,13 @@ importers:
         version: 7.32.2(@types/node@24.10.13)
       '@rsbuild/plugin-sass':
         specifier: 1.5.0
-        version: 1.5.0(@rsbuild/core@1.7.3)
+        version: 1.5.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))
       '@rsbuild/plugin-type-check':
         specifier: 1.3.3
-        version: 1.3.3(@rsbuild/core@1.7.3)(@rspack/core@1.7.6(@swc/helpers@0.5.18))(tslib@2.8.1)(typescript@5.9.3)
+        version: 1.3.3(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))(@rspack/core@1.7.6(@swc/helpers@0.5.18))(tslib@2.8.1)(typescript@5.9.3)
       '@rsbuild/plugin-typed-css-modules':
         specifier: 1.2.1
-        version: 1.2.1(@rsbuild/core@1.7.3)
+        version: 1.2.1(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))
       '@rspress/core':
         specifier: 2.0.3
         version: 2.0.3(@types/react@19.2.14)(core-js@3.48.0)
@@ -3871,6 +3895,22 @@ packages:
   '@sinclair/typebox@0.34.37':
     resolution: {integrity: sha512-2TRuQVgQYfy+EzHRTIvkhv2ADEouJ2xNS/Vq+W5EuuewBdOrvATvljZTxHWZSTYr2sTjTHpGvucaGAt67S2akw==}
 
+  '@sinonjs/commons@3.0.1':
+    resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
+
+  '@sinonjs/fake-timers@13.0.5':
+    resolution: {integrity: sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==}
+
+  '@sinonjs/fake-timers@15.1.1':
+    resolution: {integrity: sha512-cO5W33JgAPbOh07tvZjUOJ7oWhtaqGHiZw+11DPbyqh2kHTBc3eF/CjJDeQ4205RLQsX6rxCuYOroFQwl7JDRw==}
+
+  '@sinonjs/samsam@8.0.3':
+    resolution: {integrity: sha512-hw6HbX+GyVZzmaYNh82Ecj1vdGZrqVIn/keDTg63IgAwiQPO+xCz99uG6Woqgb4tM0mUiFENKZ4cqd7IX94AXQ==}
+
+  '@sinonjs/text-encoding@0.7.3':
+    resolution: {integrity: sha512-DE427ROAphMQzU4ENbliGYrBSYPXF+TtLg9S8vzeA+OF4ZKzoDdzfL8sxuMUGS/lgRhM6j1URSk9ghf7Xo1tyA==}
+    deprecated: 'Deprecated: no longer maintained, as we are not depending on it'
+
   '@smithy/abort-controller@3.1.9':
     resolution: {integrity: sha512-yiW0WI30zj8ZKoSYNx90no7ugVn3khlyH/z5W8qtKBtVE6awRALbhSG+2SAHA1r6bO/6M9utxYKVZ3PCJ1rWxw==}
     engines: {node: '>=16.0.0'}
@@ -5658,6 +5698,10 @@ packages:
     resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==}
     engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0}
 
+  diff@7.0.0:
+    resolution: {integrity: sha512-PJWHUb1RFevKCwaFA9RlG5tCd+FO5iRh9A8HEtkmBH2Li03iJriB6m6JIN4rGz3K3JLawI7/veA1xzRKP6ISBw==}
+    engines: {node: '>=0.3.1'}
+
   diff@8.0.2:
     resolution: {integrity: sha512-sSuxWU5j5SR9QQji/o2qMvqRNYRDOcBTgsJ/DeCf4iSN4gW+gNMXM7wFIP+fdXZxoNiAnHUTGjCr+TSWXdRDKg==}
     engines: {node: '>=0.3.1'}
@@ -7135,6 +7179,9 @@ packages:
   jsonfile@6.1.0:
     resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==}
 
+  just-extend@6.2.0:
+    resolution: {integrity: sha512-cYofQu2Xpom82S6qD778jBDpwvvy39s1l/hrYij2u9AMdQcGRpaBu6kY4mVhuno5kJVi1DAz4aiphA2WI1/OAw==}
+
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
@@ -7623,6 +7670,9 @@ packages:
   neo-async@2.6.2:
     resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
 
+  nise@6.1.2:
+    resolution: {integrity: sha512-zPM6UobDUDnhGcaWYjzig0tZCv4tXfF/1fnV58mfzL7pXSEwDLG0lXreuZ3u19O2ABghlYO8tFL1m1hrKUz/nw==}
+
   node-addon-api@7.1.1:
     resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
 
@@ -8887,6 +8937,15 @@ packages:
     resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
     engines: {node: '>=14'}
 
+  sinon-chai@4.0.0:
+    resolution: {integrity: sha512-cWqO7O2I4XfJDWyWElAQ9D/dtdh5Mo0RHndsfiiYyjWnlPzBJdIvjCVURO4EjyYaC3BjV+ISNXCfTXPXTEIEWA==}
+    peerDependencies:
+      chai: ^5.0.0
+      sinon: '>=4.0.0'
+
+  sinon@19.0.2:
+    resolution: {integrity: sha512-euuToqM+PjO4UgXeLETsfQiuoyPXlqFezr6YZDFwHR3t4qaX0fZUe1MfPMznTL5f8BWrVS89KduLdMUsxFCO6g==}
+
   sirv@2.0.4:
     resolution: {integrity: sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==}
     engines: {node: '>= 10'}
@@ -9401,6 +9460,10 @@ packages:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
 
+  type-detect@4.0.8:
+    resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
+    engines: {node: '>=4'}
+
   type-detect@4.1.0:
     resolution: {integrity: sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==}
     engines: {node: '>=4'}
@@ -12107,13 +12170,13 @@ snapshots:
     optionalDependencies:
       core-js: 3.48.0
 
-  '@rsbuild/plugin-babel@1.1.0(@rsbuild/core@1.7.3)':
+  '@rsbuild/plugin-babel@1.1.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))':
     dependencies:
       '@babel/core': 7.29.0
       '@babel/plugin-proposal-decorators': 7.29.0(@babel/core@7.29.0)
       '@babel/plugin-transform-class-properties': 7.28.6(@babel/core@7.29.0)
       '@babel/preset-typescript': 7.28.5(@babel/core@7.29.0)
-      '@rsbuild/core': 1.7.3
+      '@rsbuild/core': 2.0.0-beta.3(core-js@3.48.0)
       '@types/babel__core': 7.20.5
       deepmerge: 4.3.1
       reduce-configs: 1.1.1
@@ -12153,9 +12216,9 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-less@1.6.0(@rsbuild/core@1.7.3)':
+  '@rsbuild/plugin-less@1.6.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))':
     dependencies:
-      '@rsbuild/core': 1.7.3
+      '@rsbuild/core': 2.0.0-beta.3(core-js@3.48.0)
       deepmerge: 4.3.1
       reduce-configs: 1.1.1
 
@@ -12176,6 +12239,15 @@ snapshots:
       reduce-configs: 1.1.1
       sass-embedded: 1.97.3
 
+  '@rsbuild/plugin-sass@1.5.0(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))':
+    dependencies:
+      '@rsbuild/core': 2.0.0-beta.3(core-js@3.48.0)
+      deepmerge: 4.3.1
+      loader-utils: 2.0.4
+      postcss: 8.5.6
+      reduce-configs: 1.1.1
+      sass-embedded: 1.97.3
+
   '@rsbuild/plugin-source-build@1.0.4(@rsbuild/core@1.7.3)':
     dependencies:
       fast-glob: 3.3.3
@@ -12184,19 +12256,6 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
-  '@rsbuild/plugin-type-check@1.3.3(@rsbuild/core@1.7.3)(@rspack/core@1.7.6(@swc/helpers@0.5.18))(tslib@2.8.1)(typescript@5.9.3)':
-    dependencies:
-      deepmerge: 4.3.1
-      json5: 2.2.3
-      reduce-configs: 1.1.1
-      ts-checker-rspack-plugin: 1.2.6(@rspack/core@1.7.6(@swc/helpers@0.5.18))(tslib@2.8.1)(typescript@5.9.3)
-    optionalDependencies:
-      '@rsbuild/core': 1.7.3
-    transitivePeerDependencies:
-      - '@rspack/core'
-      - tslib
-      - typescript
-
   '@rsbuild/plugin-type-check@1.3.3(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))(@rspack/core@1.7.6(@swc/helpers@0.5.18))(tslib@2.8.1)(typescript@5.9.3)':
     dependencies:
       deepmerge: 4.3.1
@@ -12214,6 +12273,10 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 1.7.3
 
+  '@rsbuild/plugin-typed-css-modules@1.2.1(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))':
+    optionalDependencies:
+      '@rsbuild/core': 2.0.0-beta.3(core-js@3.48.0)
+
   '@rsdoctor/client@1.2.3': {}
 
   '@rsdoctor/core@1.2.3(@rsbuild/core@1.7.3)(@rspack/core@1.7.6(@swc/helpers@0.5.18))(webpack@5.105.2)':
@@ -12665,6 +12728,25 @@ snapshots:
 
   '@sinclair/typebox@0.34.37': {}
 
+  '@sinonjs/commons@3.0.1':
+    dependencies:
+      type-detect: 4.0.8
+
+  '@sinonjs/fake-timers@13.0.5':
+    dependencies:
+      '@sinonjs/commons': 3.0.1
+
+  '@sinonjs/fake-timers@15.1.1':
+    dependencies:
+      '@sinonjs/commons': 3.0.1
+
+  '@sinonjs/samsam@8.0.3':
+    dependencies:
+      '@sinonjs/commons': 3.0.1
+      type-detect: 4.1.0
+
+  '@sinonjs/text-encoding@0.7.3': {}
+
   '@smithy/abort-controller@3.1.9':
     dependencies:
       '@smithy/types': 3.7.2
@@ -13636,7 +13718,7 @@ snapshots:
       sirv: 3.0.1
       tinyglobby: 0.2.15
       tinyrainbow: 2.0.0
-      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.10.13)(@vitest/ui@3.2.4)(jsdom@27.4.0)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6)
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.10.13)(@vitest/ui@3.2.4)(jsdom@26.1.0)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6)
 
   '@vitest/utils@3.2.4':
     dependencies:
@@ -14668,6 +14750,8 @@ snapshots:
 
   diff-sequences@29.6.3: {}
 
+  diff@7.0.0: {}
+
   diff@8.0.2: {}
 
   dir-glob@3.0.1:
@@ -16537,6 +16621,8 @@ snapshots:
     optionalDependencies:
       graceful-fs: 4.2.11
 
+  just-extend@6.2.0: {}
+
   keyv@4.5.4:
     dependencies:
       json-buffer: 3.0.1
@@ -17272,6 +17358,14 @@ snapshots:
 
   neo-async@2.6.2: {}
 
+  nise@6.1.2:
+    dependencies:
+      '@sinonjs/commons': 3.0.1
+      '@sinonjs/fake-timers': 15.1.1
+      '@sinonjs/text-encoding': 0.7.3
+      just-extend: 6.2.0
+      path-to-regexp: 8.3.0
+
   node-addon-api@7.1.1:
     optional: true
 
@@ -18265,12 +18359,6 @@ snapshots:
     optionalDependencies:
       '@rsbuild/core': 2.0.0-beta.3(core-js@3.48.0)
 
-  rsbuild-plugin-tailwindcss@0.2.4(@rsbuild/core@1.7.3)(tailwindcss@3.4.19):
-    dependencies:
-      tailwindcss: 3.4.19
-    optionalDependencies:
-      '@rsbuild/core': 1.7.3
-
   rsbuild-plugin-tailwindcss@0.2.4(@rsbuild/core@2.0.0-beta.3(core-js@3.48.0))(tailwindcss@3.4.19):
     dependencies:
       tailwindcss: 3.4.19
@@ -18625,6 +18713,20 @@ snapshots:
 
   signal-exit@4.1.0: {}
 
+  sinon-chai@4.0.0(chai@5.2.0)(sinon@19.0.2):
+    dependencies:
+      chai: 5.2.0
+      sinon: 19.0.2
+
+  sinon@19.0.2:
+    dependencies:
+      '@sinonjs/commons': 3.0.1
+      '@sinonjs/fake-timers': 13.0.5
+      '@sinonjs/samsam': 8.0.3
+      diff: 7.0.0
+      nise: 6.1.2
+      supports-color: 7.2.0
+
   sirv@2.0.4:
     dependencies:
       '@polka/url': 1.0.0-next.25
@@ -19204,6 +19306,8 @@ snapshots:
     dependencies:
       prelude-ls: 1.2.1
 
+  type-detect@4.0.8: {}
+
   type-detect@4.1.0: {}
 
   type-fest@0.21.3: {}
@@ -19487,6 +19591,47 @@ snapshots:
       sass-embedded: 1.97.3
       terser: 5.31.6
 
+  vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.10.13)(@vitest/ui@3.2.4)(jsdom@26.1.0)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6):
+    dependencies:
+      '@types/chai': 5.2.2
+      '@vitest/expect': 3.2.4
+      '@vitest/mocker': 3.2.4(vite@5.4.2(@types/node@24.10.13)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6))
+      '@vitest/pretty-format': 3.2.4
+      '@vitest/runner': 3.2.4
+      '@vitest/snapshot': 3.2.4
+      '@vitest/spy': 3.2.4
+      '@vitest/utils': 3.2.4
+      chai: 5.2.0
+      debug: 4.4.3
+      expect-type: 1.2.1
+      magic-string: 0.30.21
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.9.0
+      tinybench: 2.9.0
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.15
+      tinypool: 1.1.1
+      tinyrainbow: 2.0.0
+      vite: 5.4.2(@types/node@24.10.13)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6)
+      vite-node: 3.2.4(@types/node@24.10.13)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/debug': 4.1.12
+      '@types/node': 24.10.13
+      '@vitest/ui': 3.2.4(vitest@3.2.4)
+      jsdom: 26.1.0
+    transitivePeerDependencies:
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
   vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.10.13)(@vitest/ui@3.2.4)(jsdom@27.4.0)(sass-embedded@1.97.3)(sass@1.97.3)(terser@5.31.6):
     dependencies:
       '@types/chai': 5.2.2
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 34a0891e5d..948ea4e074 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -5,6 +5,7 @@ packages:
   - packages/lynx/*
   - packages/mcp-servers/*
   - packages/react
+  - packages/react/preact-upstream-tests
   - packages/react/refresh
   - packages/react/runtime
   - packages/react/testing-library