@@ -9,6 +9,18 @@ TaffyJS is intended to bring Taffy, a high-performance layout engine written in
 - A future `@taffyjs/yoga` package may provide a Yoga-compatible JavaScript API built on top of `@taffyjs/node` rather than as a second native implementation. [VOUCHED @hyfdev 2026-08-14]
 - The package family should support real consumers such as terminal UI frameworks without forcing those consumers to own their own Taffy bindings.
 
+## Bun and Deno runtime support
+
+[VOUCHED @hyfdev 2026-08-16]
+
+**Ruling:** The implemented `@taffyjs/node` and `@taffyjs/wasm` packages support Bun 1.2+ within the Bun 1 major and Deno 2.2+ within the Deno 2 major. Runtime support follows one current major at a time rather than spanning majors.
+
+**Limits:** Adopting a new Bun or Deno major requires choosing and documenting a new mainstream minimum minor and ends the support promise for the previous major. This ruling does not treat unimplemented packages as supported. Deno use of `@taffyjs/node` requires local `node_modules` plus environment, read, and FFI permissions; `@taffyjs/wasm` requires no Deno permission flags.
+
+**Verification:** CI runs one minimal public-package layout smoke at only the first release of each supported minor floor, Bun 1.2.0 and Deno 2.2.0. It does not copy the complete behavior suite, test a second endpoint, or retain a cross-major matrix.
+
+**Source:** Yunfei (`@hyfdev`), 2026-08-16; selected mainstream minimum minors within only the current runtime majors, chose Bun 1.2+ and Deno 2.2+ after both package paths passed at their `.0` releases, required only that minimum endpoint in CI, and asked to vouch the rule.
+
 ## @taffyjs/node binding role
 
 `@taffyjs/node` exposes Taffy's high-level `TaffyTree` workflow without exposing low-level extension machinery or reimplementing layout in JavaScript. Taffy owns topology, Style, Layout, cache, and computation state; JavaScript adds only the public wrapper data needed for safe Node.js use.
@@ -19,5 +31,5 @@ The binding role and API priority are recorded in [@taffyjs/node decisions](taff
 
 ## Open questions
 
-- Runtime and platform support beyond the current native targets and the approved `@taffyjs/wasm` Node.js and bundled-browser scope require a concrete consumer need.
+- Runtime and platform support beyond the current native targets, the approved `@taffyjs/wasm` Node.js and bundled-browser scope, Bun 1.2+ within major 1, and Deno 2.2+ within major 2 requires a concrete consumer need.
 - The coverage and release timing of `@taffyjs/yoga` remain open. Yoga compatibility is not part of the `@taffyjs/node` contract.
@@ -8,7 +8,7 @@ The package reuses the public API and authored JavaScript behavior of `@taffyjs/
 
 ## Public use
 
-Node.js and browser applications use the same ESM import and receive an initialized API:
+Node.js, Bun 1.2+ within major 1, Deno 2.2+ within major 2, and browser applications use the same ESM import and receive an initialized API:
 
 ```ts
 import { TaffyTree } from "@taffyjs/wasm";
@@ -44,7 +44,7 @@ Exact output extensions and directories may follow the repository's Vite+ conven
 
 ## Runtime chains
 
-The default Node entry connects the existing authored TaffyJS source to a private ESM bridge and a generated CommonJS factory. The bridge statically imports the shared payload and immediately calls that factory. The factory is mechanically derived from napi-rs's generated eager Node loader: it decodes the supplied payload with `Buffer.from`, uses `instantiateNapiModuleSync`, and retains the generated registration, rollback, cleanup, and binding-export lifecycle. The selected graph has no top-level await, so ordinary static imports expose an initialized `TaffyTree` without making Node consumers await package initialization.
+The default entry used by Node.js, Bun, and Deno connects the existing authored TaffyJS source to a private ESM bridge and a generated CommonJS factory. The bridge statically imports the shared payload and immediately calls that factory. The factory is mechanically derived from napi-rs's generated eager Node loader: it decodes the supplied payload with `Buffer.from`, uses `instantiateNapiModuleSync`, and retains the generated registration, rollback, cleanup, and binding-export lifecycle. The selected graph has no top-level await, so ordinary static imports expose an initialized `TaffyTree` without making consumers await package initialization. Deno uses this package without runtime permission flags.
 
 The browser entry connects the same authored source to a private ESM adapter. That adapter decodes the shared payload with `Uint8Array.fromBase64` when available and otherwise uses `atob` plus a direct `Uint8Array` fill, calls `WebAssembly.compile` exactly once, and passes the resulting `WebAssembly.Module` to napi-rs's unmodified deferred loader through `instantiate(module)`. It uses top-level await, so browser static importers run only after initialization and still use `new TaffyTree()` without an explicit initialization call.
 
@@ -68,11 +68,12 @@ Both runtime chains use napi-rs's JavaScript WASI implementation without forward
 - Do not publish or ask users to install a TaffyJS WASIP binding package.
 - Do not add a public initialization API, public raw binding, hand-maintained WASI or emnapi implementation, or Wasm-specific Taffy API.
 - Do not use wasm-bindgen, a second Rust binding implementation, a second authored `TaffyTree`, gzip, `wasm-opt`, or a threaded WASIP target.
-- Do not claim workerd, Deno, Bun, unbundled CDN, or legacy-browser support without separate evidence and a deliberate support decision.
+- Do not claim support below the documented Bun or Deno minor floors, across Bun or Deno majors, for workerd, for unbundled CDN use, or for legacy browsers without separate evidence and a deliberate support decision.
 
 ## Verification contract
 
 - A Node.js ESM consumer must import `@taffyjs/wasm` and use the ordinary public Taffy API without initialization calls, top-level await in the selected package graph, or native platform packages.
+- Consumers on Bun 1.2+ within major 1 and Deno 2.2+ within major 2 must import the same public entry and complete a minimal layout through the ordinary API; the Deno check must run without permission flags. CI covers only Bun 1.2.0 and Deno 2.2.0 as the first releases of the supported minor floors and does not retain a cross-major runtime matrix.
 - A bundled browser consumer must use the same import and API, include the inline payload without emitting a `.wasm` asset, and work without `SharedArrayBuffer`, cross-origin isolation, COOP, or COEP.
 - The Node and browser builds must derive their JavaScript and TypeScript surface from the same authored source. Except for a documented and evidenced host-specific exception, every public Node binding behavior test must run unchanged against both `@taffyjs/node` and `@taffyjs/wasm`; one test configuration redirects the exact package import instead of copying test files.
 - Package inspection must show exactly one base64 Wasm payload, no independent `.wasm` file, exactly one browser-side `WebAssembly.compile`, synchronous `instantiateNapiModuleSync` in the Node graph, no Node environment or filesystem-root WASI capabilities, no retained `require.resolve` or dependency on `@taffyjs/binding-wasm32-wasip1`, no public initialization subpath, and no accidentally published raw binding entry.
 
@@ -26,7 +26,7 @@ The root Vite+ task graph builds the napi-rs artifacts into `packages/taffyjs-wa
 
 `tools/api-codegen` owns source generation that must keep Rust and TypeScript API facts aligned. Its first maintained input is `api/numeric-families.json`; `vp run codegen` updates both language outputs. CI runs `vp run check:codegen`, which regenerates and rejects any resulting Git diff.
 
-CI has five jobs. Ubuntu x64 and Windows x64 each build the native addon and run all Rust, JavaScript, and type tests with Node.js 22.18.0. Ubuntu also rejects stale committed package JavaScript and declarations after the build. A separate Ubuntu WASIP job installs the Rust target and Playwright Chromium, builds `@taffyjs/wasm`, reruns the complete Node public API suite against it, and runs type, package-content, packed-consumer, bundled-consumer, and browser-runtime checks against the generated package. A Node-only job checks formatting, JavaScript and repository TypeScript including maintained tools through Vite+'s type-aware lint path, and generated-source drift. A Rust-only job checks formatting and Clippy. macOS and publication workflows are not configured.
+CI has five jobs. Ubuntu x64 and Windows x64 each build the native addon and run all Rust, JavaScript, and type tests with Node.js 22.18.0, then smoke-test the public `@taffyjs/node` entry with Bun 1.2.0 and Deno 2.2.0; Ubuntu also rejects stale committed package JavaScript and declarations after the build. A separate Ubuntu WASIP job installs the Rust target and Playwright Chromium, builds `@taffyjs/wasm`, reruns the complete Node public API suite against it, runs type, package-content, packed-consumer, bundled-consumer, and browser-runtime checks against the generated package, and applies the same Bun 1.2.0 and Deno 2.2.0 smoke checks to the public entry. Alternate-runtime smoke checks perform one fixed layout rather than copying the complete behavior suite. A Node-only job checks formatting, JavaScript and repository TypeScript including maintained tools through Vite+'s type-aware lint path, and generated-source drift. A Rust-only job checks formatting and Clippy. macOS and publication workflows are not configured.
 
 ## Public website
 
 
@@ -24,6 +24,10 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - name: Build and run all tests
         run: pnpm exec vp run check:test
+      - name: Smoke test @taffyjs/node with Bun 1.2
+        run: pnpm dlx bun@1.2.0 packages/taffyjs-node/tests/runtime-smoke.mjs
+      - name: Smoke test @taffyjs/node with Deno 2.2
+        run: pnpm dlx deno@2.2.0 run --node-modules-dir=manual --allow-env --allow-read --allow-ffi packages/taffyjs-node/tests/runtime-smoke.mjs
       - name: Verify committed package outputs are current
         run: git diff --exit-code -- packages/taffyjs-node/index.js packages/taffyjs-node/index.d.ts packages/taffyjs-node/binding.js packages/taffyjs-node/binding.d.ts
 
@@ -42,6 +46,10 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - name: Build and run all tests
         run: pnpm exec vp run check:test
+      - name: Smoke test @taffyjs/node with Bun 1.2
+        run: pnpm dlx bun@1.2.0 packages/taffyjs-node/tests/runtime-smoke.mjs
+      - name: Smoke test @taffyjs/node with Deno 2.2
+        run: pnpm dlx deno@2.2.0 run --node-modules-dir=manual --allow-env --allow-read --allow-ffi packages/taffyjs-node/tests/runtime-smoke.mjs
 
   test-wasm:
     name: Build and test WASIP
@@ -62,6 +70,10 @@ jobs:
         run: pnpm --filter tests-taffy-wasm exec playwright install --with-deps chromium
       - name: Build and test the Wasm package
         run: pnpm exec vp run check:wasm
+      - name: Smoke test @taffyjs/wasm with Bun 1.2
+        run: pnpm dlx bun@1.2.0 packages/taffyjs-wasm/tests/runtime-smoke.mjs
+      - name: Smoke test @taffyjs/wasm with Deno 2.2
+        run: pnpm dlx deno@2.2.0 run --node-modules-dir=manual packages/taffyjs-wasm/tests/runtime-smoke.mjs
 
   check-node:
     name: Node checks
 
@@ -26,6 +26,17 @@ npm install @taffyjs/node
 | [`@taffyjs/yoga`](https://www.npmjs.com/package/@taffyjs/yoga)           | Yoga-compatible API backed by `@taffyjs/node`.  | —       |
 | [`@taffyjs/yoga-wasm`](https://www.npmjs.com/package/@taffyjs/yoga-wasm) | Yoga-compatible API backed by `@taffyjs/wasm`.  | WIP     |
 
+## Runtime compatibility
+
+TaffyJS supports Bun 1.2+ within the Bun 1 major and Deno 2.2+ within the Deno 2 major. CI smoke-tests the first release of each minimum minor by importing each public package, computing a minimal layout, and verifying the result. Support follows one current major per runtime rather than spanning runtime majors.
+
+| Package              | Bun 1.2+           | Deno 2.2+                                                                   |
+| -------------------- | ------------------ | --------------------------------------------------------------------------- |
+| `@taffyjs/node`      | ✅                 | ✅ (local `node_modules`; `--allow-env`, `--allow-read`, and `--allow-ffi`) |
+| `@taffyjs/wasm`      | ✅                 | ✅ (without permission flags)                                               |
+| `@taffyjs/yoga`      | ⚠️ Not implemented | ⚠️ Not implemented                                                          |
+| `@taffyjs/yoga-wasm` | ⚠️ Not implemented | ⚠️ Not implemented                                                          |
+
 ## Documentation
 
 - [Guide](apps/website/guide/index.md) explains the shared layout model, layout modes, and text and image measurement.
 
@@ -13,6 +13,8 @@ The package requires Node.js 22.18.0 or newer and currently provides native bina
 | Linux            | x64          | `x86_64-unknown-linux-gnu` |
 | Windows          | x64          | `x86_64-pc-windows-msvc`   |
 
+Bun 1.2+ within major 1 and Deno 2.2+ within major 2 are also supported on these native targets. CI smoke-tests Bun 1.2.0 and Deno 2.2.0 through the public package entry. Support does not span runtime majors. Deno requires a local `node_modules` directory and the `--allow-env`, `--allow-read`, and `--allow-ffi` permissions.
+
 The package is ESM-only. Application code imports the public package entry:
 
 ```ts
 
@@ -31,11 +31,13 @@ The [Guide](../guide/getting-started.md) and [`TaffyTree` reference](../node/nod
 | Environment | Support                                                                                       |
 | ----------- | --------------------------------------------------------------------------------------------- |
 | Node.js     | Node.js 22.18 or newer                                                                        |
+| Bun         | Version 1.2 or newer within the Bun 1 major                                                   |
+| Deno        | Version 2.2 or newer within the Deno 2 major, without permission flags                        |
 | Browser     | Applications built with a bundler that supports package export conditions and top-level await |
 
 The browser build contains the Wasm payload inside JavaScript, so it does not fetch a separate `.wasm` file. It is threadless and does not require `SharedArrayBuffer` or cross-origin isolation headers.
 
-Direct imports from a CDN and runtimes other than the supported Node.js and bundled-browser paths are not currently part of the package contract.
+Bun versions below 1.2, Deno versions below 2.2, other Bun and Deno majors, direct CDN imports, and runtimes not listed above are not part of the package contract.
 
 ## Loading
 
@@ -58,7 +60,7 @@ Your bundler must select the package's browser entry. No TaffyJS-specific loader
 |                                 | `@taffyjs/node`                  | `@taffyjs/wasm`                          |
 | ------------------------------- | -------------------------------- | ---------------------------------------- |
 | Engine                          | Taffy compiled as a native addon | Taffy compiled to threadless WebAssembly |
-| Main use                        | Supported Node.js platforms      | Bundled browsers and supported Node.js   |
+| Main use                        | Supported native platforms       | Bundled browsers and supported runtimes  |
 | Public layout API               | Direct TaffyJS API               | The same direct TaffyJS API              |
 | Initialization visible to users | None                             | None                                     |
 | Distribution                    | Platform-specific native binary  | Wasm payload embedded in JavaScript      |
 
@@ -8,7 +8,7 @@ Install it with npm:
 npm install @taffyjs/node
 ```
 
-The package requires Node.js 22.18.0 or newer. Its native targets are Linux x64 GNU and Windows x64 MSVC. Application code imports only the public package entry:
+The package requires Node.js 22.18.0 or newer. Its native targets are Linux x64 GNU and Windows x64 MSVC. Bun 1.2+ within major 1 and Deno 2.2+ within major 2 are also supported and smoke-tested on those targets; support does not span runtime majors. Deno requires a local `node_modules` directory and the `--allow-env`, `--allow-read`, and `--allow-ffi` permissions. Application code imports only the public package entry:
 
 ```ts
 import { TaffyTree } from "@taffyjs/node";
 
@@ -0,0 +1,12 @@
+import { TaffyTree } from "@taffyjs/node";
+
+import { runRuntimeSmoke } from "../../../tests/runtime-smoke.ts";
+
+const packageName = "@taffyjs/node";
+const resolvedEntry = import.meta.resolve(packageName);
+
+if (!resolvedEntry.endsWith("/index.js")) {
+  throw new Error(`${packageName} resolved to an unexpected entry: ${resolvedEntry}`);
+}
+
+runRuntimeSmoke(packageName, new TaffyTree());
@@ -1,6 +1,6 @@
 # `@taffyjs/wasm`
 
-`@taffyjs/wasm` runs the Taffy layout engine as threadless WebAssembly in Node.js and bundled browsers. It exposes the same public TaffyJS API as `@taffyjs/node`; choosing this package guarantees that the implementation is Wasm rather than a native addon.
+`@taffyjs/wasm` runs the Taffy layout engine as threadless WebAssembly in Node.js, Bun 1.2+ within major 1, Deno 2.2+ within major 2, and bundled browsers. It exposes the same public TaffyJS API as `@taffyjs/node`; choosing this package guarantees that the implementation is Wasm rather than a native addon.
 
 ```ts
 import { TaffyTree } from "@taffyjs/wasm";
@@ -16,4 +16,4 @@ No explicit initialization call is needed. The Wasm payload is inlined once in t
 const { TaffyTree } = await import("@taffyjs/wasm");
 ```
 
-The supported browser path is through a bundler that honors conditional exports and top-level await. It does not emit or fetch a separate `.wasm` asset. Direct CDN use and runtimes other than supported Node.js and bundled browsers are not currently part of the package contract.
+The supported browser path is through a bundler that honors conditional exports and top-level await. It does not emit or fetch a separate `.wasm` asset. Deno needs no runtime permission flags. Bun versions below 1.2, Deno versions below 2.2, other Bun and Deno majors, direct CDN use, and other runtimes are not currently part of the package contract.