diff --git a/CHANGELOG.md b/CHANGELOG.md
index e4853f9..3c91e92 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,12 +37,25 @@ V8 Fast API callbacks, idle-task GC scheduling, and CI consolidation.
 
 ### Changed
 
-* **Sandbox status** (`cgo.go`, `deps/build.py`):
-  `V8_ENABLE_SANDBOX` remains active in `cgo.go` to match the prebuilt
-  static libraries. `deps/build.py` sets `v8_enable_sandbox=false` for
-  local rebuilds — once deps are rebuilt without the sandbox, the
-  `NewArrayBufferExternal` zero-copy path activates automatically.
-  `SandboxEnabled()` reports the compile-time state at runtime.
+* **V8 sandbox disabled** (`cgo.go`, `deps/build.py`, `deps/*/`):
+  Rebuilt V8 monolith for all 4 platforms with
+  `v8_enable_sandbox=false`. Removed `-DV8_ENABLE_SANDBOX` from
+  `cgo.go`. `SandboxEnabled()` now returns `false` and
+  `NewArrayBufferExternal` uses true zero-copy (no memcpy fallback).
+
+* **Fork-maintained V8 deps** (`deps/{os}_{arch}/`):
+  Replaced upstream `tommie/v8go/deps/*` submodules with local
+  platform directories containing split archives, `cgo.go`, `go.mod`,
+  and `vendor.go`. `go.mod` uses `replace` directives to point to
+  these local deps.
+
+* **V8 build infrastructure** (`.github/workflows/build-v8-deps.yml`,
+  `deps/build-all-local.sh`, `Makefile`, `deps/Dockerfile.builder`):
+  Added CI workflow for rebuilding V8 from source via
+  `workflow_dispatch`, plus local build tooling (`make v8-deps-all`)
+  with Docker for Linux targets. linux/amd64 uses gcc
+  (`is_clang=false`) for GNU `ld` compatibility; cross-compile targets
+  use V8's clang with `use_custom_libcxx=true`.
 
 * **CI consolidated** (`.github/workflows/ci.yml`):
   Collapsed from 10 jobs to 2 (one per OS). Each job runs lint, build,
diff --git a/README.md b/README.md
index 6ad58d9..ca303e0 100644
--- a/README.md
+++ b/README.md
@@ -276,13 +276,16 @@ The ChessCom fork adds:
   caller-controlled time budget.
 * **Zero-copy ArrayBuffer** -- `NewArrayBufferExternal(ctx, []byte)`
   wraps Go memory as an ArrayBuffer via external BackingStore +
-  `runtime.Pinner`. Falls back to copy when V8 sandbox is active;
+  `runtime.Pinner`. True zero-copy with fork deps (sandbox disabled);
   `SandboxEnabled()` reports the mode at runtime.
 * **V8 Fast API callbacks** -- `NewFastFunctionTemplate` registers a
   C-linkage fast path that TurboFan calls directly, bypassing CGo and
   argument marshaling on hot call sites.
 * **GC lifecycle callbacks** -- `AddGCPrologueCallback` and
   `AddGCEpilogueCallback` for observing GC cycles with typed events.
+* **Sandbox-disabled V8 deps** -- fork-maintained V8 static libraries
+  compiled with `v8_enable_sandbox=false` for all 4 platforms, with
+  CI rebuild workflow and local build tooling (`make v8-deps-all`).
 
 ## Versioning
 
@@ -292,10 +295,26 @@ the changes above).
 
 ## V8 dependency
 
-See `deps/v8/` for the version of V8 currently in use. Prebuilt static
-libraries of V8 are included for Linux and macOS so you should not need
+The fork maintains its own V8 static libraries under `deps/{os}_{arch}/`
+compiled with `v8_enable_sandbox=false` to enable zero-copy ArrayBuffer.
+Prebuilt archives are included for all platforms so you should not need
 to build V8 yourself.
 
+### Rebuilding V8 deps
+
+To rebuild V8 from source (e.g. after updating `deps/v8_hash`):
+
+```bash
+# Via GitHub Actions (recommended)
+gh workflow run build-v8-deps.yml
+
+# Or locally on macOS (all 4 platforms)
+make v8-deps-all
+```
+
+See [docs/maintaining.md](docs/maintaining.md) for full details on the
+build pipeline, platform-specific flags, and linker compatibility.
+
 ## Documentation
 
 | Document | Description |
diff --git a/docs/api-reference.md b/docs/api-reference.md
index 746ebc5..ec8bd0c 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -82,6 +82,15 @@ global.Set("version", "1.0.0")
 val, _ := ctx.RunScript("version", "v.js")
 ```
 
+### Retained value count
+
+Returns the number of C-side persistent handles tracked by a context.
+Useful for detecting value leaks.
+
+```go
+count := ctx.RetainedValueCount()
+```
+
 ### Microtask checkpoint
 
 ```go
@@ -100,6 +109,11 @@ go func() {
 }()
 val, err := ctx.RunScript(longRunningScript, "slow.js")
 // err will be an ExecutionTerminated error
+
+// Check termination state
+if iso.IsExecutionTerminating() {
+    iso.CancelTerminateExecution()
+}
 ```
 
 ### Heap statistics
@@ -210,7 +224,22 @@ val.Object()       // *Object (returns nil if not an object)
 ### Comparison
 
 ```go
-val1.SameValue(val2) // Object.is() semantics
+val1.SameValue(val2)    // Object.is() semantics
+val1.StrictEquals(val2) // === semantics
+```
+
+### Type introspection
+
+```go
+val.TypeOf() // "string", "number", "object", etc.
+```
+
+### JSON marshaling
+
+`Value` implements `json.Marshaler`:
+
+```go
+data, err := json.Marshal(val) // calls val.MarshalJSON()
 ```
 
 ### Release
@@ -296,6 +325,14 @@ fn, _ := val.AsFunction()
 result, err := fn.Call(ctx.Global(), arg1, arg2)
 ```
 
+### Constructing objects from functions
+
+```go
+val, _ := ctx.Global().Get("MyClass")
+fn, _ := val.AsFunction()
+obj, err := fn.NewInstance(arg1, arg2) // equivalent to `new MyClass(arg1, arg2)`
+```
+
 ### Creating functions from Go
 
 ```go
@@ -1186,30 +1223,33 @@ copy(backing, myData)
 
 ### NewArrayBufferExternal
 
-Creates an ArrayBuffer backed directly by a Go byte slice. When the V8
-sandbox is disabled, this is true zero-copy — JS and Go share the same
-memory. When `V8_ENABLE_SANDBOX` is active (current prebuilt deps), it
-falls back to alloc + copy internally. The slice is pinned via
+Creates an ArrayBuffer backed directly by a Go byte slice with true
+zero-copy — JS and Go share the same memory. The slice is pinned via
 `runtime.Pinner` and released when V8 GCs the ArrayBuffer.
 
 ```go
 data := make([]byte, 64*1024)
 ab, _ := v8.NewArrayBufferExternal(ctx, data)
-// With sandbox disabled: JS reads/writes `data` directly.
-// With sandbox enabled: V8 copies data in; subsequent mutations
-// to the Go slice are NOT visible in JS.
+// JS reads/writes `data` directly (zero-copy).
 ```
 
+The fork's prebuilt deps are compiled with `v8_enable_sandbox=false`,
+so `NewArrayBufferExternal` always uses the zero-copy path. If a
+custom V8 build has the sandbox enabled, the function falls back to
+alloc + `memcpy` internally.
+
 ### SandboxEnabled
 
 Reports whether the V8 binary was compiled with `V8_ENABLE_SANDBOX`.
-Use this to decide between zero-copy and copy-in strategies at runtime.
+The fork's prebuilt deps have the sandbox disabled, so this returns
+`false`. Useful for downstream consumers that may build against
+different V8 binaries.
 
 ```go
 if v8.SandboxEnabled() {
     // External ArrayBuffer will copy; use NewArrayBufferAlloc + write instead
 } else {
-    // True zero-copy via NewArrayBufferExternal
+    // True zero-copy via NewArrayBufferExternal (default for fork deps)
 }
 ```
 
diff --git a/docs/architecture.md b/docs/architecture.md
index 82f7637..e7af896 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -95,13 +95,15 @@ consists of:
 | File | Role |
 |---|---|
 | `v8go.h` / `v8go.cc` | Core exports: `Init`, `Version`, `SetFlags`, `NewIsolate`, `RunScript` |
-| `isolate.h` / `isolate.cc` | Isolate lifecycle, heap stats, script compilation |
+| `isolate.h` / `isolate.cc` | Isolate lifecycle, heap stats, script compilation, idle tasks |
 | `context.h` / `context.cc` | Context creation/disposal, `RunScript`, global object |
 | `value.h` / `value.cc` | Value type checks, conversions, constructors |
-| `object.h` / `object.cc` | Object property get/set/has/delete |
-| `function_template.h` / `function_template.cc` | FunctionTemplate creation, callback wiring |
+| `object.h` / `object.cc` | Object property get/set/has/delete, enumeration, prototype |
+| `function_template.h` / `function_template.cc` | FunctionTemplate creation, callback wiring, Fast API |
 | `object_template.h` / `object_template.cc` | ObjectTemplate creation, property configuration |
 | `snapshot.h` / `snapshot.cc` | **Fork-specific.** SnapshotCreator lifecycle, blob serialisation |
+| `arraybuffer.h` / `arraybuffer.cc` | **Fork-specific.** ArrayBuffer creation (copy, alloc, external zero-copy) |
+| `fast_api.h` / `fast_api.cc` | **Fork-specific.** V8 Fast API CFunctionInfo builder |
 | `symbol.h` / `symbol.cc` | Well-known symbol accessors |
 | `inspector.h` / `inspector.cc` | V8 Inspector protocol bridge |
 | `errors.h` / `errors.cc` | Error/exception construction |
@@ -426,16 +428,13 @@ enqueuing.
 caller can then write directly into the backing store via
 `ArrayBufferGetData`.
 
-`NewArrayBufferExternal` attempts true zero-copy: it wraps Go-owned
+`NewArrayBufferExternal` provides true zero-copy: it wraps Go-owned
 memory as an external `BackingStore` via `runtime.Pinner`, so JS and
-Go share the same bytes. However, when `V8_ENABLE_SANDBOX` is active
-(the case with current prebuilt deps), V8 requires all backing stores
-to reside inside its sandbox address space. In this mode, the C++
-implementation (`arraybuffer.cc`) falls back to alloc + `memcpy` and
-immediately releases the Go-side pin. The runtime function
-`SandboxEnabled()` reports which mode is active. Once V8 deps are
-rebuilt with `v8_enable_sandbox=false` (configured in `deps/build.py`),
-the zero-copy path activates automatically.
+Go share the same bytes. The fork's prebuilt V8 deps are compiled
+with `v8_enable_sandbox=false`, enabling the zero-copy path. The C++
+implementation (`arraybuffer.cc`) includes a fallback to alloc +
+`memcpy` for custom V8 builds with the sandbox enabled; the runtime
+function `SandboxEnabled()` reports which mode is active.
 
 `NewExternalOneByteString` wraps a C++ `ExternalOneByteStringResource`
 subclass that points at Go-owned memory. V8 reads directly from the Go
@@ -503,3 +502,64 @@ Module pointers are managed separately from Values because
 `StringOutputStream` adapter, copies the result to a `malloc`'d buffer,
 and deletes the V8-side snapshot. The Go side copies the buffer into a
 Go byte slice and frees the C buffer.
+
+## V8 build pipeline
+
+The fork maintains its own V8 static libraries (with
+`v8_enable_sandbox=false`) rather than consuming upstream's prebuilt
+deps. The build pipeline produces split archives for 4 platforms.
+
+```mermaid
+graph LR
+    subgraph source ["Source"]
+        Hash["deps/v8_hash"]
+        Fetch["gclient sync"]
+    end
+
+    subgraph build ["Build (per platform)"]
+        GN["gn gen"]
+        Ninja["ninja v8_monolith"]
+        Split["split_ar"]
+    end
+
+    subgraph output ["Output"]
+        Archives["libv8-0.a, libv8-1.a, ..."]
+        CGo["update_cgo.py"]
+        GoMod["go.mod replace"]
+    end
+
+    Hash --> Fetch
+    Fetch --> GN
+    GN --> Ninja
+    Ninja --> Split
+    Split --> Archives
+    Archives --> CGo
+    CGo --> GoMod
+```
+
+### Platform decision tree
+
+Each platform requires specific build flags to produce archives
+that are compatible with the target's system linker:
+
+| Platform | `is_clang` | `use_sysroot` | `use_custom_libcxx` | Reason |
+|----------|-----------|---------------|---------------------|--------|
+| linux/amd64 | `false` (gcc) | `false` | `false` | GNU `ld` cannot parse clang's ELF objects |
+| linux/arm64 | `true` | `true` | `true` | Cross-compile from x86\_64; system headers lack C++20 |
+| darwin/arm64 | `true` | `false` | `false` | Native build |
+| darwin/amd64 | `true` | `false` | `true` | Cross-compile from arm64; system headers vary |
+
+### Sandbox-disabled implications
+
+With `v8_enable_sandbox=false`:
+
+- `v8::ArrayBuffer::NewBackingStore` accepts external (Go-owned)
+  memory pointers, enabling true zero-copy `NewArrayBufferExternal`.
+- The `V8_ENABLE_SANDBOX` preprocessor define is absent from `cgo.go`,
+  so C++ code compiled by CGo takes the non-sandbox code paths.
+- `SandboxEnabled()` returns `false` at runtime.
+- V8's virtual memory cage is not allocated, slightly reducing the
+  process address space footprint.
+
+See [docs/maintaining.md](maintaining.md) for full rebuild
+instructions via CI or locally.
diff --git a/docs/maintaining.md b/docs/maintaining.md
index 78e2c91..10b6120 100644
--- a/docs/maintaining.md
+++ b/docs/maintaining.md
@@ -40,6 +40,13 @@ The fork-specific C++ files are the most common source of conflicts:
 | `fast_api_test_helpers.cc` | _does not exist upstream_ | Test-only C++ fast function for Fast API tests |
 | `fast_api_test_export.go` | _does not exist upstream_ | CGo bridge to test fast function address |
 | `isolate_registry.go` | _does not exist upstream_ | Global Go-side isolate registry for CGO callback dispatch |
+| `deps/*/cgo.go` | _does not exist upstream_ | Platform-specific CGo linker directives for local V8 archives |
+| `deps/*/go.mod` | _does not exist upstream_ | Go module definition for each platform dep |
+| `deps/*/vendor.go` | _does not exist upstream_ | Empty Go file to make platform dep a valid package |
+| `.gitattributes` | _does not exist upstream_ | Marks `*.a` as binary to prevent git line-ending corruption |
+| `Makefile` | _does not exist upstream_ | Convenience targets for local V8 builds |
+| `deps/Dockerfile.builder` | _does not exist upstream_ | Docker image for local Linux V8 builds |
+| `deps/build-all-local.sh` | _does not exist upstream_ | Orchestration script for local V8 builds |
 
 When conflicts appear, resolve them locally, ensure the CI matrix
 passes on both ubuntu-latest and macos-latest, and push to the sync
@@ -58,7 +65,75 @@ not yet mirrored in the deps modules. In that case, close the
 automated PR with a comment explaining the skip and reopen manually
 once the deps are updated.
 
-## Local V8 rebuild (escape hatch)
+## V8 rebuild via GitHub Actions
+
+The [`build-v8-deps.yml`](../.github/workflows/build-v8-deps.yml)
+workflow rebuilds V8 monolith from source for all 4 platforms. It is
+triggered manually via `workflow_dispatch` and optionally opens a PR
+with the rebuilt archives.
+
+### Matrix
+
+| Platform | Runner | Compiler | Cross-compile? | Special flags |
+|----------|--------|----------|----------------|---------------|
+| linux/amd64 | `ubuntu-latest` | gcc (`is_clang=false`) | No | -- |
+| linux/arm64 | `ubuntu-latest` | V8 clang | Yes (x86\_64 host) | `use_sysroot=true`, `use_custom_libcxx=true` |
+| darwin/arm64 | `macos-latest` | V8 clang | No | -- |
+| darwin/amd64 | `macos-latest` | V8 clang | Yes (arm64 host) | `use_custom_libcxx=true` |
+
+Build time is ~60-90 minutes per platform.
+
+### Key GN args
+
+All platforms share these V8 build flags:
+
+- `v8_enable_sandbox=false` -- enables true zero-copy ArrayBuffer
+- `v8_monolithic=true` -- single static library
+- `use_thin_lto=false` -- avoids LLVM bitcode in archives
+- `v8_embedder_string="-v8go"` -- identifies fork builds
+
+### Why linux/amd64 uses gcc
+
+V8's bundled clang produces ELF objects with features (section types,
+relocation formats) that GNU `ld` on Ubuntu cannot parse, resulting in
+`unknown architecture of input file` errors. Building with the system
+gcc produces standard GNU-compatible ELF objects.
+
+### Why cross-compiles need `use_custom_libcxx`
+
+When cross-compiling, the host system's C++ standard library headers
+may lack C++20/23 features that V8 requires (e.g. `std::bit_cast`,
+`std::make_unique_for_overwrite`). Using V8's bundled libc++ avoids
+these compatibility issues.
+
+### Archive splitting
+
+GitHub limits individual files to ~100 MB. The `split_ar` step in
+`deps/build.py` splits `libv8_monolith.a` (~100-140 MB) into chunks
+under 40 MB each (`libv8-0.a`, `libv8-1.a`, etc.). A `libmanifest`
+file lists the split archives for `update_cgo.py`.
+
+On Linux, the split step forces use of the system `ar` (GNU ar)
+instead of `llvm-ar` because GNU `ld` cannot reliably link archives
+with LLVM's SysV64 symbol table format.
+
+### Assemble job
+
+After all 4 platform builds succeed, the `assemble` job:
+
+1. Downloads all platform artifacts
+2. Runs `deps/update_cgo.py` to regenerate CGo files
+3. Updates `go.mod` with local `replace` directives
+4. Strips `-DV8_ENABLE_SANDBOX` from `cgo.go`
+5. Opens a PR on the `rebuild-v8-deps-no-sandbox` branch
+
+### Workflow inputs
+
+| Input | Type | Default | Description |
+|-------|------|---------|-------------|
+| `create_pr` | boolean | `true` | Open a PR with rebuilt deps |
+
+## V8 rebuild locally (escape hatch)
 
 When CI is unavailable, too slow, or you need to iterate on V8 build
 flags locally, use the local build system. It builds V8 monolith for
@@ -82,14 +157,14 @@ make v8-deps-darwin-arm64
 make v8-deps-linux-amd64
 ```
 
+### How it works
+
 The orchestration script (`deps/build-all-local.sh`) handles:
 1. Fetching `depot_tools` and V8 source (first run only, cached after)
 2. Building darwin targets natively (cross-compile for amd64)
-3. Building linux targets in Docker containers (arm64 native, amd64 via Rosetta)
+3. Building linux targets in Docker containers
 4. Regenerating `cgo_*.go` files via `update_cgo.py`
 
-### How it works
-
 | Target | Method |
 |--------|--------|
 | darwin/arm64 | Native build via V8's bundled clang |
@@ -125,18 +200,46 @@ go test -count=1 -timeout 5m ./...
 |------|---------|
 | `deps/build-all-local.sh` | Orchestration script |
 | `deps/build.py` | Per-platform V8 build (gclient, gn, ninja) |
-| `deps/Dockerfile.builder` | Docker image for linux builds |
+| `deps/Dockerfile.builder` | Docker image for linux builds (Ubuntu 24.04) |
 | `deps/update_cgo.py` | Regenerates cgo Go files from libmanifest |
 | `Makefile` | Convenience targets (`v8-deps-*`) |
 
+## Platform-specific linker notes
+
+### Linux
+
+The fork's V8 archives link with Go's CGo toolchain, which invokes
+the system `gcc`/`g++` and ultimately GNU `ld`. Several compatibility
+constraints apply:
+
+- **gcc for linux/amd64:** V8's clang produces ELF objects with
+  features GNU `ld` cannot parse. The linux/amd64 build uses gcc
+  (`is_clang=false`) to produce standard GNU ELF objects.
+- **`--start-group` / `--end-group`:** gcc-built V8 archives have
+  cross-archive symbol dependencies that require group linking. The
+  `cgo.go` for linux platforms wraps archives with
+  `-Wl,--start-group ... -Wl,--end-group`.
+- **`use_thin_lto=false`:** ThinLTO produces LLVM bitcode objects
+  that GNU `ld` cannot link. Disabled for all platforms.
+- **System `ar` for archive splitting:** On Linux, the `split_ar`
+  step uses GNU `ar` instead of `llvm-ar` to produce archives with
+  standard symbol tables that GNU `ld` can read.
+- **System libraries:** `-ldl -lm -lstdc++`
+
+### Darwin
+
+- No linker group needed (ld64 handles cross-archive references).
+- System libraries: `-lc++ -framework CoreFoundation`
+- V8's bundled clang is used for all darwin builds.
+
 ## V8 binary upgrades
 
-The prebuilt `libv8.a` static libraries live in the deps submodules
-(`tommie/v8go/deps/linux_x86_64`, `tommie/v8go/deps/darwin_arm64`,
-etc.). When upstream bumps the V8 version:
+The fork maintains its own V8 static libraries under `deps/{os}_{arch}/`
+with `v8_enable_sandbox=false`. When upgrading the V8 version:
 
-1. The deps modules are republished with new binaries.
-2. `go.sum` picks up the new hashes on `go mod tidy`.
+1. Update `deps/v8_hash` with the new V8 commit hash.
+2. Run the `build-v8-deps` workflow (or `make v8-deps-all` locally)
+   to rebuild all 4 platforms.
 3. Every CGO call site must be re-validated: the V8 C++ API is not
    ABI-stable across versions, and header renames or signature changes
    can break compilation.
diff --git a/docs/performance.md b/docs/performance.md
index 8d1694e..7b157cd 100644
--- a/docs/performance.md
+++ b/docs/performance.md
@@ -278,13 +278,10 @@ ab, _ := v8.NewArrayBufferExternal(ctx, data)
 The slice is pinned via `runtime.Pinner` and released automatically when
 V8 garbage-collects the ArrayBuffer or the isolate is disposed.
 
-**Sandbox caveat:** When `V8_ENABLE_SANDBOX` is active (the case with
-current prebuilt deps), V8 requires backing stores to live inside its
-sandbox address space. In this mode, `NewArrayBufferExternal` falls back
-to alloc + `memcpy` — the data is copied in and the Go-side pin is
-released immediately. Use `v8.SandboxEnabled()` to check at runtime.
-Once deps are rebuilt with `v8_enable_sandbox=false`, the zero-copy path
-activates automatically.
+The fork's V8 deps are compiled with `v8_enable_sandbox=false`, so the
+zero-copy path is always active. `v8.SandboxEnabled()` returns `false`
+to confirm. Custom V8 builds with the sandbox enabled will fall back to
+alloc + `memcpy` internally.
 
 ## Fast API callbacks
 
diff --git a/docs/release.md b/docs/release.md
index 071cf54..c664e93 100644
--- a/docs/release.md
+++ b/docs/release.md
@@ -65,16 +65,13 @@ Pushing the tag triggers the
 2. **Runs the full CI suite** (build, test, coverage on ubuntu + macOS).
 3. **Creates a GitHub Release** with release notes extracted from the
    matching `CHANGELOG.md` section.
-4. **Triggers downstream bumps** via
-   [auto-bump-downstreams](../.github/workflows/auto-bump-downstreams.yml),
-   opening PRs in blindfox and er (when they import
-   `github.com/ChessCom/v8go`).
 
 ### 4. Verify
 
 - Check the [Releases page](https://github.com/ChessCom/v8go/releases)
   for the new release.
-- Check downstream repos for auto-opened bump PRs.
+- Notify downstream consumers (blindfox, er) to update their
+  `go.mod` to the new tag.
 
 ## Consumer integration
 
@@ -129,23 +126,22 @@ When upstream `tommie/v8go` releases a new version (e.g. `v0.35.0`):
 
 ## Workflow details
 
-### release.yml
+### Workflows
 
-Triggered on tags matching `v*`. Jobs:
+| Workflow | Trigger | What it does |
+|---|---|---|
+| [`release.yml`](../.github/workflows/release.yml) | Tags matching `v*` | Validates tag format, runs CI, creates GitHub Release |
+| [`ci.yml`](../.github/workflows/ci.yml) | Push/PR to `main` | Lint, build, test, coverage, downstream compat |
+| [`upstream-sync.yml`](../.github/workflows/upstream-sync.yml) | Weekly (Mon 06:00 UTC) | Fetches upstream, opens merge PR |
+| [`build-v8-deps.yml`](../.github/workflows/build-v8-deps.yml) | Manual dispatch | Rebuilds V8 monolith for all platforms (not part of release flow) |
+
+### release.yml jobs
 
 | Job | What it does |
 |---|---|
 | `validate` | Checks tag format against `v[0-9]+.[0-9]+.[0-9]+-chess.[0-9]+` |
 | `ci` | Builds and tests on ubuntu-latest + macos-latest, enforces coverage |
 | `release` | Extracts CHANGELOG section, creates GitHub Release |
-| `bump-downstreams` | Calls `auto-bump-downstreams.yml` to open PRs in blindfox/er |
-
-### Required secrets
-
-| Secret | Used by | Scope |
-|---|---|---|
-| `CROSS_REPO_WRITE_TOKEN` | `bump-downstreams` job | `repo:write` on ChessCom/blindfox and ChessCom/er |
 
 The `GITHUB_TOKEN` (automatic) is sufficient for creating the GitHub
-Release. The downstream bump job skips gracefully when
-`CROSS_REPO_WRITE_TOKEN` is not set.
+Release.
diff --git a/docs/zero-cold-start.md b/docs/zero-cold-start.md
index fc01fd6..c1d9002 100644
--- a/docs/zero-cold-start.md
+++ b/docs/zero-cold-start.md
@@ -14,6 +14,11 @@ hardware a ~750 KiB synthetic bundle goes from ~15 ms (source eval) to
 supported — `PackBundleESM` evaluates modules inside the SnapshotCreator,
 bridges the module namespace to a global, and serialises the heap.
 
+The fork's V8 deps are now compiled with `v8_enable_sandbox=false`,
+which removes the sandbox memory cage and enables true zero-copy
+`NewArrayBufferExternal`. This eliminates one barrier from the
+zero-copy data transfer path described below.
+
 The breakdown of that 4 ms is roughly:
 
 | Phase | Cost |